godprotocol 1.2.12 → 1.2.14

package/Objects/Manager.js

@@ -339,6 +339,11 @@ class Manager {
           this.served = true
           this.oracle = this.options.oracle;
           this.oracle.set_manager(this)
+            .then(async()=>{
+              if (this.options.init_account){
+                await this.add_account(this.options.init_account.name, {password: this.options.init_account.password, init: true})
+              }
+            })
         }
       }
     }

package/Objects/Oracle.js

@@ -147,25 +147,36 @@ class Oracle extends Handlers{
     return res;
   }
 
-  set_to_repos = async(address, content)=>{
+  set_to_repos = async(address, content, options)=>{
+    let {count, args} = options, counted = count != null, res;
     for (let r=0; r< this.repos.length; r++){
       let repo = this.repos[r]
 
       if (!repo.filter || address.match(repo.filter)){
-        await repo.repo.write_file(address, content)
+        await repo.repo.write_file(address, content, args)
+        res = await repo.repo.objectify()
+        if (counted && !count) break;
+        count --
       }
     }
+
+    return res;
   }
 
-  get_from_repos = async(address)=>{
+  get_from_repos = async(address, repo_)=>{
+    let content
     for (let r=0; r< this.repos.length; r++){
       let repo = this.repos[r]
       
-      if (!repo.filter || address.match(repo.filter)){
-        let content = await repo.repo.read_file(address)
-        if (content) return content;
+      if(repo_ && repo.repo.match(repo_)){
+        content = await repo.repo.read_file(address)
+        break
+      } else if (!repo.filter || address.match(repo.filter)){
+        content = await repo.repo.read_file(address)
+        if (content) break
       }
     }
+    return content
   }
 
   read = async(path, options={})=>{

package/Objects/Repository.js

@@ -8,6 +8,10 @@ class Repository{
       obj.name = this.name;
       obj.remote = this.remote
       obj.__dirname = this.__dirname
+    }else if (this.type === 'github'){
+      obj.key = this.auth_token
+      obj.username = this.owner
+      obj.repo = this.repo;
     }
 
     return obj

package/Objects/Utils.js

@@ -10,6 +10,27 @@ class Utils{
     
     await this.load({address: address.slice(this.physical_address.length+1), sequence: res, compiler: true, from_reload: true})
   }
+
+  get_from_repo = async(address) =>{
+    address = `${this.physical_address}/${address}/__literal__`
+    let content = await this.manager.oracle.get_from_repo(address, {count: 1})
+
+    return content && JSON.parse(content)
+  }
+
+  read_file = async(address) =>{
+    let content = await this.manager.oracle.read(address, {account: this.physical_address})
+
+    return content;
+  }
+
+  write_file = async(address, content)=>{
+    let res = await this.manager.oracle.write(address, JSON.stringify(content), {account: this.physical_address})
+  }
+
+  read = async(address, query)=>{
+
+  }
 }
 
 

package/html/index.js

@@ -22,18 +22,23 @@ const header_script = (manager)=>{
     let domain = manager.options.server_domain
     if (domain.startsWith('127')) domain = `http://${domain}`
     else domain = `https://${domain}`
-    
+
     return ` let ftch = async(path, body)=>{
-      let fch = await fetch("${domain}".concat(path), {
-        method: 'POST',
-        header: {
-          'Content-Type': 'application/json',
-          Accept: 'application/json'
-        },
-        body: JSON.stringify(body)
-      })
-      let response = await fch.json()
-      return response;
+      try{
+        let fch = await fetch("${domain}".concat(path), {
+          method: 'POST',
+          header: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json'
+          },
+          body: JSON.stringify(body)
+        })
+        let response = await fch.json()
+        return response;
+      }catch(e){
+        console.log(e)
+        return {message: e.message}
+      }
     }`
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.2.12",
+  "version": "1.2.14",
   "description": "A distributed computing environment",
   "main": "Index.js",
   "scripts": {

package/repos/github.js

@@ -22,14 +22,20 @@ class Github extends Repository{
     let sha = null;
 
     // Check if file exists, get its SHA
-    const exists = await this.file_exists(file_path);
-    if (exists) {
-      const res = await fetch(url, { headers: this.get_headers() });
-      if (res.ok) {
-        const data = await res.json();
-        sha = data.sha;
+    try{
+      const exists = await this.file_exists(file_path);
+      if (exists) {
+        const res = await fetch(url, { headers: this.get_headers() });
+        if (res.ok) {
+          const data = await res.json();
+          sha = data.sha;
+        }
       }
+    }catch(e){
+      console.log(e.message)
+      return 
     }
+    
 
     // Build payload
     const body = {
@@ -51,7 +57,14 @@ class Github extends Repository{
   read_file = async (file_path) => {
     const url = `${this.base_url}/repos/${this.owner}/${this.repo}/contents/${file_path}`;
 
-    const response = await fetch(url, { headers: this.get_headers() });
+    let response;
+    try{
+      response = await fetch(url, { headers: this.get_headers() })
+    }catch(e){
+      console.log(e)
+      return;
+    }
+    ;
     if (!response.ok) return null;
 
     const fileData = await response.json();

package/utils/create_server.js

@@ -72,17 +72,19 @@ export const handle_routes =  async (req, res, manager, app) => {
         result = await manager.oracle.call(data);
         break;
       default:
-        let accountName = account_uids[data.account];
-        if (!accountName) return res.end(JSON.stringify({ message: `Account ${data.account} not found` }));
-
-        let accountObj = await manager.get_account(accountName);
+        let account_name = account_uids[data.account], account_obj;
+        if (!account_name){
+          if (['load', 'run', 'parse'].includes(req.url.slice(1))){
+            return res.end(JSON.stringify({ message: `Account ${data.account} not found` }));
+          }
+        }else account_obj = await manager.get_account(account_name);
 
         if (req.url === '/load'){
-          result = await accountObj.load(data);
+          result = await account_obj.load(data);
         }else if (req.url === '/run'){
-          result = await accountObj.run(data);
+          result = await account_obj.run(data);
         }else if (req.url === '/parse'){
-          result = await accountObj.parse(data);
+          result = await account_obj.parse(data);
         }else {
           return app? app(req,res): res.writeHead(404).end('Not Found');
         }