review call

Author: Francesca-Bit

lib/woql.js

@@ -1396,64 +1396,7 @@ WOQL.link = function(subject, predicate, object, graphRef) {
     return new WOQLQuery().link(subject, predicate, object, graphRef)
 }
 
-/**
- * @param {WOQLClient} woqlClient - an WoqlClient instance
- * @param {string} propId - property id
- * @param {string} classId - the enum class id
- * @param {string} classLabel - the enum class label
- * @param {string} [classDesc]  - the enum class description
- * @param {string} [schemaGraph] - the resource identifier of a schema graph. The Default value id schema/main
- * @returns {WOQLQuery} - A WOQLQuery which contains the Create Enum Class Statement
- */
-WOQL.makeEnum = function(woqlClient, propId, classId, classLabel, classDesc, schemaGraph) {
-    return new WOQLQuery().makeEnum(woqlClient, prop, classId, classLabel, classDesc, schemaGraph)
-}
-
-/**
- * Generates a class representing a choice list - an enumerated list of specific options
- * @param {string} classId - the enum class id
- * @param {string} classLabel - the enum class label
- * @param {string} classDesc  - the enum class description
- * @param {array}  choices - an list of permitted values [[id,label,comment],[id,label,comment]]
- * @param {string} [schemaGraph] - the resource identifier of a schema graph. The Default value id schema/main
- * @param {string} [parent] - the id of a class that this class inherits from (e.g. scm:Enumerated)
- * @returns {WOQLQuery} - A WOQLQuery which contains the Generate Enum/Choice Class Statement
- */
-
-WOQL.generateChoiceList = function(classId, classLabel, classDesc, choices, schemaGraph, parent) {
-    return new WOQLQuery().generateChoiceList(
-        classId,
-        classLabel,
-        classDesc,
-        choices,
-        schemaGraph,
-        parent,
-    )
-}
 
-/**
- * update or create an enumeration class. You have to add at least one permitted values in the list
- * @param {string} classId - the enum class id
- * @param {string} classLabel - the enum class label
- * @param {string} classDesc  - the enum class description
- * @param {array}  choices - an list of permitted values [[id,label,comment],[id,label,comment]]
- * @param {string} [schemaGraph] - the resource identifier of a schema graph. The Default value id schema/main
- * @returns {WOQLQuery} - A WOQLQuery which contains the Update Enum/Choice Class Statement
- */
-WOQL.updateChoiceList = function(classId, classLabel, classDesc, choices, schemaGraph) {
-    return new WOQLQuery().updateChoiceList(classId, classLabel, classDesc, choices, schemaGraph)
-}
-
-/**
- * delete the enum list for a specific enumeration class, but not the class
- * @param {string} classId - the enum class name
- * @param {string} [schemaGraph] - the resource identifier of a schema graph. The Default value id schema/main
- * @returns {WOQLQuery} - A WOQLQuery which contains the Delete Choice List Statement
- */
-
-WOQL.deleteChoiceList = function(classId, schemaGraph) {
-    return new WOQLQuery().deleteChoiceList(classId, schemaGraph)
-}
 
 /**
  * Called to load Terminus Predefined libraries:

lib/woqlClient.js

@@ -372,67 +372,14 @@ WOQLClient.prototype.deleteDatabase = function(dbId, orgId, force) {
     this.organization(orgIdValue)
     let payload = force ? {force: true} : null
     if (dbId && this.db(dbId)) {
-        return this.dispatch(CONST.DATABASE, this.connectionConfig.dbURL(), payload)
+        return this.dispatch(CONST.DELETE, this.connectionConfig.dbURL(), payload)
     }
     let errmsg = `Delete database parameter error - you must specify a valid database id  - ${dbId} is invalid`
     return Promise.reject(
-        new Error(ErrorMessage.getInvalidParameterMessage(CONST.DATABASE, errmsg)),
+        new Error(ErrorMessage.getInvalidParameterMessage(CONST.DELETE, errmsg)),
     )
 }
 
-/**
- * Creates a new named graph within a TerminusDB database
- * @param {typedef.GraphType} graphType - type of graph
- * @param {string} graphId  - id of the graph to be created
- * @param {string} commitMsg  - a message describing the reason for the change that will be written into the commit log
- * @returns {Promise} A promise that returns the call response object, or an Error if rejected.
- * @example
- * client.createGraph("schema", "alt", "Adding new schema graph")
- */
-//TO BE REMOVED
-WOQLClient.prototype.createGraph = function(graphType, graphId, commitMsg) {
-    if (
-        graphType &&
-        ['inference', 'schema', 'instance'].indexOf(graphType) !== -1 &&
-        graphId &&
-        commitMsg
-    ) {
-        let commit = this.generateCommitInfo(commitMsg)
-        return this.dispatch(
-            CONST.CREATE_GRAPH,
-            this.connectionConfig.graphURL(graphType, graphId),
-            commit,
-        )
-    }
-    let errmsg = `Create graph parameter error - you must specify a valid type (inference, instance, schema), graph id and commit message`
-    return Promise.reject(
-        new Error(ErrorMessage.getInvalidParameterMessage(CONST.CREATE_GRAPH, errmsg)),
-    )
-}
-
-/**
- * Deletes a graph from a TerminusDB database
- * @param {typedef.GraphType} graphType - type of graph
- * @param {string} graphId - local id of graph
- * @param {string} commitMsg - a message describing the reason for the change that will be written into the commit log
- * @returns {Promise} A promise that returns the call response object, or an Error if rejected.
- * @example
- * client.deleteGraph("schema", "alt", "Deleting alt schema graph")
- */
-WOQLClient.prototype.deleteGraph = function(graphType, graphId, commitMsg) {
-    if (graphType && ['inference', 'schema', 'instance'].indexOf(graphType) != -1 && graphId) {
-        let commit = this.generateCommitInfo(commitMsg)
-        return this.dispatch(
-            CONST.GRAPH,
-            this.connectionConfig.graphURL(graphType, graphType),
-            commit,
-        )
-    }
-    let errmsg = `Delete graph parameter error - you must specify a valid type (inference, instance, schema), graph id and commit message`
-    return Promise.reject(
-        new Error(ErrorMessage.getInvalidParameterMessage(CONST.GRAPH, errmsg)),
-    )
-}
 
 /**
  * Retrieve the contents of a graph within a TerminusDB as triples, encoded in the turtle (ttl) format
@@ -871,24 +818,34 @@ WOQLClient.prototype.dispatch =  function(action, apiUrl, payload) {
                 ),
             ),
         )
-    }//I have to do a call to get the jwt token
-    /*if(this.connectionConfig.tokenParameter){
+    }
+    //I have to review this I don't want a call everytime
+    if(this.connectionConfig.tokenParameter){
         const param = this.connectionConfig.tokenParameter
-        await axios.post(param.url,param.options).then(result=>result.data).then(data=>{
+        axios.post(param.url,param.options).then(result=>result.data).then(data=>{
             if(data.access_token){
                 console.log("ACCESS_TOKEN",data.access_token)
                 this.localAuth({"key":data.access_token,"type":"jwt"})
             }
+            return DispatchRequest(
+                apiUrl,
+                action,
+                payload,
+                this.localAuth(),
+                this.remoteAuth(),
+                this.customHeaders(),
+            )
         })          
-    }*/
-    return DispatchRequest(
-            apiUrl,
-            action,
-            payload,
-            this.localAuth(),
-            this.remoteAuth(),
-            this.customHeaders(),
-        )
+    }else{
+        return DispatchRequest(
+                apiUrl,
+                action,
+                payload,
+                this.localAuth(),
+                this.remoteAuth(),
+                this.customHeaders(),
+            )
+    }
 
 }
 
@@ -1318,34 +1275,37 @@ WOQLClient.prototype.getEnums = function(dbId){
  * @param {string} [dbId] 
  * @returns 
  */
-/*WOQLClient.prototype.getClassDocuments = async function(dbId){
+WOQLClient.prototype.getClassDocuments = function(dbId){
     const params = {'graph_type':"schema","as_list":true,"type":"sys:Class"}
-    const result = await this.getDocument(params,dbId)
-    let documents=[]
-    if(result){
+    return this.getDocument(params,dbId).then(result=>{
+        let documents=[]
+        if(result){
          documents = result.filter(item => !item['@subdocument'] && !item['@abstract'])
-    }
-    return documents
-}*/
+        }
+        return documents
+    })
+}
 
 /**
  * 
  * @param {*} dbId 
  * @returns 
  */
-/*WOQLClient.prototype.getBranches = async function(dbId){
+WOQLClient.prototype.getBranches = function(dbId){
     const params={type:'Branch','as_list':true}
     const branch = this.checkout()
-    const result = await this.getDocument(params,dbId,"_commits")
+    return this.getDocument(params,dbId,"_commits").then(result=>{
+        const branchesObj = {}
+        if(result){
+            result.forEach(item=>{
+                branchesObj[item.name]=item
+            })
+        }
+        this.checkout(branch)
+        return branchesObj
+    })
     //reset branch
-    const branchesObj = {}
-    if(result){
-        result.forEach(item=>{
-            branchesObj[item.name]=item
-        })
-    }
-    this.checkout(branch)
-    return branchesObj
-}*/
+   
+}
 
 module.exports = WOQLClient