json-object-editor 0.10.210 → 0.10.222

package/js/joe.js

@@ -9382,7 +9382,7 @@ logit(intent)
                             logit(response);
                             var bucket = response.bucket || (_joe.Data.setting.where({name:'AWS_BUCKETNAME'})[0] || {value:''}).value;
                             var region = (_joe.Utils.Settings('AWS_S3CONFIG') ||{}).region;
-                            var prefix = 'https://s3.'+((region && region +'.')||'')+'amazonaws.com/'+bucket+'/';
+                            var prefix = (_joe.Data.setting.where({name:'AWS_S3PREFIX'})[0] || {value:''}).value || 'https://s3.'+((region && region +'.')||'')+'amazonaws.com/'+bucket+'/';
                             var url = prefix+response.Key;
                             var filename = response.Key.replace(self.current.object._id+'/','');
                             //TODO: change file status in list.
@@ -9421,7 +9421,9 @@ logit(intent)
                             logit(data);
                             var bucket = data.bucket || (_joe.Data.setting.where({name:'AWS_BUCKETNAME'})[0] || {value:''}).value;
                             
-                            var prefix = 'https://s3.amazonaws.com/'+bucket+'/';
+                            //var prefix = 'https://s3.amazonaws.com/'+bucket+'/';
+                            var prefix = (_joe.Data.setting.where({name:'AWS_S3PREFIX'})[0] || {value:''}).value || 'https://s3.'+((region && region +'.')||'')+'amazonaws.com/'+bucket+'/';
+
                             var url = prefix+data.Key;
                             if(field.url_field){
                                 var nprop = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-object-editor",
-  "version": "0.10.210",
+  "version": "0.10.222",
   "description": "JOE the Json Object Editor | Platform Edition",
   "main": "app.js",
   "scripts": {
@@ -35,6 +35,7 @@
     "cookie-parser": "^1.4.1",
     "craydent": "^0.8.9",
     "express": "^4.16.4",
+    "got": "^12.6.0",
     "jwt-decode": "^2.2.0",
     "mailgun": "^0.5.0",
     "mongojs": "^2.3.0",
@@ -43,7 +44,7 @@
     "nodemailer-ses-transport": "^1.4.0",
     "opener": "^1.4.3",
     "pem": "^1.13.2",
-    "plaid": "^3.1.1",
+    "plaid": "^13.1.0",
     "renderizer": "^1.1.0",
     "socket.io": "^2.2.0"
   },

package/pages/joe.html

@@ -8,7 +8,7 @@
 	<link rel="icon" href="/JsonObjectEditor/favicon.ico" type="image/x-icon">
 	<link rel="icon" sizes="192x192" href="/JsonObjectEditor/img/ico/android-icon-192x192.png">
 	<link rel="apple-touch-icon" sizes="144x144" href="/JsonObjectEditor/img/ico/android-icon-144x144.png" />
-
+	<meta name="joe-notes" content="joe.html template" >
 	<meta name="apple-mobile-web-app-capable" content="yes">
 	<meta name="mobile-web-app-capable" content="yes">
 

package/pages/template.html

@@ -6,18 +6,19 @@
 	<meta name='viewport' content='initial-scale=1.0, user-scalable=no' >
 	<title> ${this.webconfig.name} > ${APPNAME} </title>
 	<script src="/JsonObjectEditor/js/libs/adapter-latest.js"></script>
-	<link rel="shortcut icon" href="/JsonObjectEditor/favicon.ico" type="image/x-icon">
+	<!-- <link rel="shortcut icon" href="/JsonObjectEditor/favicon.ico" type="image/x-icon">
 	<link rel="icon" href="/JsonObjectEditor/favicon.ico" type="image/x-icon">
 	<link rel="icon" sizes="192x192" href="/JsonObjectEditor/img/ico/android-icon-192x192.png">
-	<link rel="apple-touch-icon" sizes="144x144" href="/JsonObjectEditor/img/ico/android-icon-144x144.png" />
+	<link rel="apple-touch-icon" sizes="144x144" href="/JsonObjectEditor/img/ico/android-icon-144x144.png" /> -->
 
+	<meta name="joe-notes" content="template.html template" >
 	<meta name="apple-mobile-web-app-capable" content="yes">
 	<meta name="mobile-web-app-capable" content="yes">
 
 	<link rel="stylesheet" href="${JOEPATH}js/plugins/c3/c3.min.css"/>
 	<link rel="stylesheet" href="${JOEPATH}capp/capp.css"/>
 	<link href="/JsonObjectEditor/css/joe.css" rel="stylesheet" type="text/css"/>
-	
+	${this.settings.joe_icons}
 	<!--<script src="${JOEPATH}_joeinclude.js"></script>-->
 	
 	<script type="text/javascript" src="/JsonObjectEditor/js/libs/jquery-1.11.3.min.js"></script>

package/plaidTest.js

@@ -0,0 +1,87 @@
+const plaid = require('plaid');
+
+  var self = this;
+  var plaidClient;
+
+  var PUBLIC_TOKEN = null;
+
+  var ACCESS_TOKENS
+
+  function getAT(data){
+    var AT = ACCESS_TOKENS[data.bank];
+    if(!AT){return false;}
+    return AT.access_token;
+  }
+
+  function initPlaidClient() {
+    var client_id = "57ec34dbf5c9c9795f46a523";
+    var secret = "dc2dd377d986f833101da67dfbac34";
+    var public_key = "5b7b648e71bc056b974036d32026db";
+    ACCESS_TOKENS = {
+      "chase":{
+          "access_token":"access-development-655b2910-0e0d-4fde-80da-8c77aa92be87"
+      },
+      "wf":{
+          "access_token":"access-development-5a3be1ca-0150-4e96-8a5d-38964d0f0ebf"
+      },
+      "corey_discover":{
+          "access_token":"access-development-95426771-6f02-4c25-ab5c-7d2488f49c86"
+      },
+      "liz_discover":{
+          "access_token":"access-development-bdd33633-ebc6-4944-a487-3552c4648fa5"
+      }
+      }
+    //console.log('plaidinit',plaidClient);
+    if(!client_id || !secret || !ACCESS_TOKENS){
+      return 'plaidClient not initialized';
+    }
+    if(plaidClient){ return;}
+    console.log('initializing plaid client')
+  try {
+
+    const configuration = new plaid.Configuration({
+      basePath: plaid.PlaidEnvironments.development,
+      baseOptions: {
+        headers: {
+          'PLAID-CLIENT-ID': client_id,
+          'PLAID-SECRET': secret,
+          'Plaid-Version': '2020-09-14',
+        },
+      },
+    });
+
+    plaidClient = new plaid.PlaidApi(configuration);
+    return true;
+  } catch (e) {
+    console.log("plaid client init error",e);
+    return e;
+  }
+}
+async function createLink(data, request, response){
+  initPlaidClient();
+  const options = {
+    user: {
+      client_user_id: 'user-123',
+    },
+    client_name: 'Plaid Test',
+    products: ['auth'],
+    country_codes: ['US'],
+    language: 'en',
+  };
+
+  try {
+    const linkTokenResponse = await plaidClient.linkTokenCreate(options);
+    const linkToken = linkTokenResponse.data.link_token;
+    console.log(linkToken);
+    const response = await plaidClient.itemPublicTokenExchange({ linkToken });
+    
+    const access_token = response.data.access_token;
+    const accounts_response = await plaidClient.accountsGet({ access_token });
+    const accounts = accounts_response.data.accounts;
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+initPlaidClient();
+createLink();

package/server/modules/Apps.js

@@ -2,6 +2,22 @@ var fs = require('fs');
 function Apps(){
     var moduleName = JOE.Utils.color('[apps] ','module');
     var self = this;
+
+    function formatBytes(bytes,pretty) {
+        let mbs = bytes / (1024 * 1024);
+        let gbs = null;
+        let pref="mbs";
+        
+        if(mbs > 1000){
+            gbs = (mbs/1000);
+            pretty && (gbs = gbs.toFixed(2));
+            pref="gbs"
+        }
+        pretty && (mbs = mbs.toFixed(2));
+
+        return {mbs,gbs,pref};
+      }
+      
     this.Cards = {
         _generate : function(cardtype,specs,cardtype_specs){
             //console.log('generating card '+cardtype);

package/server/modules/Server.js

@@ -443,7 +443,7 @@ server.get(['/API/schema/:names','/API/schemas/:names'],auth,function(req,res,ne
 
 
 //PLUGINS
-function pluginHandling(req,res,next){
+async function pluginHandling(req,res,next){
     var pBM = new Benchmarker();
     var plugin = req.params.plugin;
     
@@ -483,7 +483,11 @@ function pluginHandling(req,res,next){
         if(typeof pluginClass[method] == "string"){
             var response = pluginClass[method];
         }else{
-            var response = pluginClass[method](data,req,res);
+            if(pluginClass.async && pluginClass.async[method]){
+                var response = await pluginClass[method](data,req,res);
+            }else{
+                var response = pluginClass[method](data,req,res);
+            }
         }
         if(response && response.use_callback){
             return;

package/server/plugins/auth copy.js

@@ -0,0 +1,103 @@
+var jwtDecode = require('jwt-decode');
+var request = require("request");
+function Auth(){
+    var self = this;
+    this.default = function(data,req,res){
+        try{ 
+            var payload = {
+                params:req.params,
+                data:data
+            }
+
+        }catch(e){
+            return {errors:'plugin error: '+e,failedat:'plugin'};
+        }
+        
+       
+        
+        return payload;
+    };
+
+    this.login = function(data,req,res){
+    
+        //make post request
+        var originalUrl = data.state||'';
+        console.log(originalUrl);
+
+        var options = { method: 'POST',
+        url: 'https://www.googleapis.com/oauth2/v4/token',
+        qs: 
+        {
+            grant_type: 'authorization_code',
+            code: data.code,
+            redirect_uri: `${JOE.webconfig.authorization.host}/API/plugin/auth/login`,
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'client_id':JOE.webconfig.authorization.client_id,
+            'client_secret':JOE.webconfig.authorization.client_secret
+        },
+        headers: 
+        {
+            'cache-control': 'no-cache',
+            Authorization: JOE.webconfig.authorization.header,
+            Accept: 'application/json',
+
+        },
+            rejectUnauthorized:false,
+            json: true 
+        };
+
+        request(options, function (error, response, body) {
+            if (error){
+                res.send(error);
+                return;
+            }
+            if (body.error){
+                res.send(body.error);
+                return;
+            }
+            //res.send(body);
+            
+            //get creds
+            var id_token = body.id_token;
+            var access_token = body.access_token;
+            var user = {};
+            var idTokenInfo = jwtDecode(id_token);
+            //var accessTokenInfo = jwtDecode(access_token);
+            
+            //user.username = accessTokenInfo.username.toLowerCase();
+            user.email = idTokenInfo.email.toLowerCase();
+            var users = (JOE.Data && JOE.Data.user) || [];
+            var User = users.where({email:user.email})[0]||false;
+            if(User){
+                //req.cookies._j_user && req.cookies._j_token
+                res.cookie('_j_user',User.name);
+                res.cookie('_j_token',User.token);
+                
+            }else{
+                var finalUrl = originalUrl+(originalUrl.indexOf('?') == -1?'?':'&')+'noSSO=true'
+                res.redirect(finalUrl);
+                return;
+            }
+        //redirect to home or gotoUrl
+            res.redirect(originalUrl || `/JOE/${User.apps[0]}`);
+            //res.send(body);
+            
+
+            
+        });
+
+     
+        //return(data);
+        return({use_callback:true})
+    }
+    this.html = function(data,req,res){
+        
+ 
+       
+        
+        return JSON.stringify(self.default(data,req),'','\t\r\n <br/>');
+    }
+    this.protected = [];
+    return self; 
+}
+module.exports = new Auth();

package/server/plugins/auth.js

@@ -1,6 +1,9 @@
 var jwtDecode = require('jwt-decode');
-var request = require("request");
+// var request = require("request");
+
+//var got = require('got');
 function Auth(){
+    
     var self = this;
     this.default = function(data,req,res){
         try{ 
@@ -18,39 +21,49 @@ function Auth(){
         return payload;
     };
 
-    this.login = function(data,req,res){
-    
+    this.login = async function(data,req,res){
+        const got = await import('got');
         //make post request
         var originalUrl = data.state||'';
         console.log(originalUrl);
 
-        var options = { method: 'POST',
-        url: 'https://www.googleapis.com/oauth2/v4/token',
-        qs: 
-        {
-            grant_type: 'authorization_code',
-            code: data.code,
-            redirect_uri: `${JOE.webconfig.authorization.host}/API/plugin/auth/login`,
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'client_id':JOE.webconfig.authorization.client_id,
-            'client_secret':JOE.webconfig.authorization.client_secret
-        },
-        headers: 
-        {
-            'cache-control': 'no-cache',
-            Authorization: JOE.webconfig.authorization.header,
-            Accept: 'application/json',
+        var options = { 
+            method: 'POST',
+            url: 'https://www.googleapis.com/oauth2/v4/token',
+            searchParams: {
+                grant_type: 'authorization_code',
+                code: data.code,
+                redirect_uri: `${JOE.webconfig.authorization.host}/API/plugin/auth/login`,
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'client_id':JOE.webconfig.authorization.client_id,
+                'client_secret':JOE.webconfig.authorization.client_secret
+            },
+            headers: 
+            {
+                'cache-control': 'no-cache',
+                Authorization: JOE.webconfig.authorization.header,
+                Accept: 'application/json',
 
-        },
-            rejectUnauthorized:false,
-            json: true 
+            },
+            responseType: 'json',
+            https: {
+              rejectUnauthorized: false
+            }
+            // rejectUnauthorized:false,
+            // json: true 
         };
 
-        request(options, function (error, response, body) {
-            if (error){
-                res.send(error);
-                return;
-            }
+       // request(options, function (error, response, body) {
+        got.default(options)
+        .catch(error => {
+            res.send(error);
+        })
+        .then(response => {  
+            const body = response.body;
+            // if (error){
+            //     res.send(error);
+            //     return;
+            // }
             if (body.error){
                 res.send(body.error);
                 return;
@@ -98,6 +111,7 @@ function Auth(){
         return JSON.stringify(self.default(data,req),'','\t\r\n <br/>');
     }
     this.protected = [];
+    this.async = {login:true}
     return self; 
 }
 module.exports = new Auth();

package/server/plugins/money-legacy.js

@@ -0,0 +1,268 @@
+function Money() {
+  var self = this;
+  const plaid = require("plaid");
+  var environment = plaid.environments.development;
+  var plaidClient;
+  var ACCESS_TOKEN = "";
+  var PUBLIC_TOKEN = null;
+
+  var ACCESS_TOKENS
+  //initPlaidClient();
+
+  function initPlaidClient() {
+      //console.log('plaidinit',plaidClient);
+      if(plaidClient){ return;}
+      logit('initializing plaid client')
+    try {
+      var client_id = JOE.Cache.settings.PLAID_CLIENTID;
+      var secret = JOE.Cache.settings.PLAID_SECRET_development;
+      var public_key = JOE.Cache.settings.PLAID_PUBLIC_KEY;
+      ACCESS_TOKENS = JOE.Cache.settings.PLAID_ACCESS_TOKENS && JSON.parse(JOE.Cache.settings.PLAID_ACCESS_TOKENS);
+      //console.log(ACCESS_TOKENS);
+      plaidClient = new plaid.Client(
+        client_id,
+        secret,
+        public_key,
+        environment,
+        { version: "2018-05-22" }
+      );
+      return true;
+    } catch (e) {
+      logit("plaid client init error",e);
+      return e;
+    }
+  }
+  function checkPlaidClient(res){
+    var p = initPlaidClient();
+    if(!plaidClient){
+        res.jsonp(p);
+        return false;
+    }
+    return true;
+  }
+
+  function getAT(data){
+    var AT = ACCESS_TOKENS[data.bank];
+    if(!AT){return false;}
+    return AT.access_token;
+  }
+
+  this.getPublicToken = function(data, request, response){
+    var p = initPlaidClient();
+    if(!plaidClient){
+        return p;
+    }
+    var AT = ACCESS_TOKENS[data.bank];
+    if(!AT)return {error:'bank not found'}
+    logit(AT);
+    plaidClient.createPublicToken(AT.access_token, (err,data)=>{
+        response.jsonp({err,data})
+    });
+    return { use_callback: true };
+  }
+  this.getItem = function(data, request, response){
+    var p = initPlaidClient();
+    if(!plaidClient){
+        return p;
+    }
+    var AT = getAT(data);
+    
+    if(!AT){return {error:'access token not found',ACCESS_TOKENS};}
+    //plaidClient.getItem(ACCESS_TOKEN, cb);
+    plaidClient.getItem(AT, (err,pdata)=>{
+        response.jsonp({err,pdata,data})
+    });
+    return { use_callback: true };
+  }
+  
+  this.get_access_token = function(data, request, response) {
+    var p = initPlaidClient();
+    if(!plaidClient){
+        return p;
+    }
+    console.log(data);
+    PUBLIC_TOKEN = (request.query && request.query.public_token) 
+    ||(request.body && request.body.public_token);
+    plaidClient.exchangePublicToken(PUBLIC_TOKEN, function(
+      error,
+      tokenResponse
+    ) {
+      if (error != null) {
+        console.log("Could not exchange public_token!" + "\n" + error);
+        return response.jsonp({ error });
+      }
+      ACCESS_TOKEN = tokenResponse.access_token;
+      ITEM_ID = tokenResponse.item_id;
+      console.log("Access Token: " + ACCESS_TOKEN);
+      console.log("Item ID: " + ITEM_ID);
+      response.jsonp({ error: false });
+    });
+    return { use_callback: true };
+  };
+  this.accounts = function(data, request, response){
+    var p = initPlaidClient();
+    if(!plaidClient){
+        return p;
+    }
+    var AT = getAT(data);
+    if(!AT)return {error:'bank not found'}
+    plaidClient.getAccounts(AT, (err, result) => {
+        // Handle err
+        if(err){
+            response.json({error:err});
+        }else{
+        const accounts = result.accounts;
+        response.jsonp(result);
+        }
+      });
+    return { use_callback: true };
+  }
+  this.accountNumbers = function(data, request, response){
+    var p = initPlaidClient();
+    if(!plaidClient){
+        return p;
+    }
+    var AT = getAT(data);
+    if(!AT)return {error:'bank not found'}
+    plaidClient.getAuth(AT,{}, (err, result) => {
+        // Handle err
+        if(err){
+            response.json({error:err});
+        }else{
+          var accounts = result.accounts;
+          response.jsonp(result);
+        }
+      });
+    return { use_callback: true };
+  }
+  this.transactions = function(data, request, response,specs={}){
+    var p = initPlaidClient();
+    if(!plaidClient){
+        return p;
+    }
+    var request = request || (data && data.request);
+    console.log('params',data);
+    var AT = request.query.at || (data.account && data.account.access_token)|| getAT(data);
+    var account_ids = request.query.account_ids && (request.query.account_ids.split(',')) || null;
+    console.log('accounts',account_ids);
+    console.log('AT',AT)
+    var curDate = new Date();
+    var start_date  = data.start_date || curDate.getFullYear()+'-01-01';
+    var end_date  = data.end_date || new Date().format('Y-m-d');
+    var count = data.count || 500;
+    if(!AT){return {error:'access token not found',ACCESS_TOKENS};}
+    plaidClient.getTransactions(AT, start_date, end_date, {count,account_ids}, (error,pdata)=>{
+
+      if(!specs.callback){
+        if(error){
+          return response.jsonp({error})
+        }
+        if(!request.query.full){
+          return response.jsonp({error,transactions:pdata.transactions})
+        }
+        response.jsonp({error,pdata,data})
+      }else{
+        logit('[money] using callback')
+        specs.callback(error,pdata,data)
+        return;
+      }
+    });
+
+    if(!specs.async){
+      return { use_callback: true };
+    }
+  }
+  this.institutions = function(data, req, res) {
+    var p = initPlaidClient();
+    if(!plaidClient){
+        return p;
+    }
+    var callback = function(err, mfaResponse, response) {
+      res.jsonp({
+        err: err,
+        mfaResponse: mfaResponse,
+        response: response,
+        environments: plaid.environments
+      });
+    };
+    if (data["id"]) {
+      plaid.getInstitution(data["id"], environment, callback);
+    } else {
+      plaid.getInstitutions(environment, callback);
+    }
+    return { use_callback: true };
+  };
+
+  this.authTest = function(data, req, res) {
+    if (!plaidClient) {
+      initPlaidClient();
+    }
+    try {
+      var user = data["username"] || "plaid_test";
+      var pass = data["password"] || "plaid_good";
+
+      var credentials = { username: user, password: pass };
+      var institution_type = "wells"; //wf
+      plaidClient.addAuthUser(institution_type, credentials, function(
+        err,
+        mfaResponse,
+        response
+      ) {
+        res.jsonp({ err: err, mfaResponse: mfaResponse, response: response });
+      });
+
+      return { use_callback: true };
+    } catch (e) {
+      return { error: e };
+    }
+  };
+
+  this.connect = function(data, req, res) {
+    if (!plaidClient) {
+      initPlaidClient();
+    }
+    try {
+      var user = data["username"] || "plaid_test";
+      var pass = data["password"] || "plaid_good";
+
+      var credentials = { username: user, password: pass };
+      var institution_type = "wells"; //wf
+      plaidClient.addConnectUser(institution_type, credentials, function(
+        err,
+        mfaResponse,
+        response
+      ) {
+        res.jsonp({ err: err, mfaResponse: mfaResponse, response: response });
+      });
+
+      return { use_callback: true };
+    } catch (e) {
+      return { error: e };
+    }
+  };
+
+  this.token = function(data, req, res) {
+    var public_token = data["token"];
+    var callback = function(err, mfaResponse, response) {
+      res.jsonp({ err: err, mfaResponse: mfaResponse, response: response });
+    };
+    try {
+      plaidClient.exchangeToken(public_token, callback);
+    } catch (e) {
+      return { error: e };
+    }
+  };
+
+  this.default = function(data, req, res) {
+    res.jsonp({ data: data });
+    return { use_callback: true };
+  };
+
+  this.html = function(data, req) {
+    logit('html route')
+    return JSON.stringify(self.default(data, req), "", "\t\r\n <br/>");
+  };
+  this.protected = [];
+  return self;
+}
+module.exports = new Money();