@qikdev/sdk 0.1.14 → 0.1.18

package/src/api/qik.core.js

@@ -3,8 +3,12 @@
 import QikAPI from './qik.api.js';
 import QikAuth from './qik.auth.js';
 import QikUtils from './qik.utils.js';
+import QikFilter from './qik.filter.js';
+import QikFiles from './qik.files.js';
 import QikCache from './qik.cache.js';
 import QikAccess from './qik.access.js';
+import QikContent from './qik.content.js';
+import QikSystem from './qik.system.js';
 import { EventDispatcher } from './qik.utils.js';
 
 ///////////////////////////////////////
@@ -38,8 +42,6 @@ import { EventDispatcher } from './qik.utils.js';
 
 import { version } from '../version.js';
 
-console.log('BEFORE class')
-
 export default function(options) {
     if (!options) {
         options = {
@@ -65,7 +67,7 @@ export default function(options) {
             options.apiURL = 'https://api.staging.qik.dev';
             break;
         case 'local':
-            options.apiURL = 'http://localhost:4001';
+            options.apiURL = 'http://api.qik.localhost:4001';
             break;
     }
 
@@ -75,6 +77,7 @@ export default function(options) {
         //Other options
         // domain:'',
         version,
+        global:{},
     })
 
     console.log('Instantiate class', core)
@@ -88,11 +91,12 @@ export default function(options) {
      * and storing API requests and other information in memory
      * @type {QikCache}
      */
-    var cache = QikCache;
+    const cache = QikCache;
     Object.defineProperty(core, 'cache', {
         value: cache,
         writable: false,
     });
+    
     ///////////////////////////////////////
 
     /**
@@ -100,7 +104,7 @@ export default function(options) {
      * with Qik data
      * @type {QikUtils}
      */
-    var utils = QikUtils;
+    const utils = QikUtils;
     Object.defineProperty(core, 'utils', {
         value: utils,
         writable: false,
@@ -108,8 +112,36 @@ export default function(options) {
 
     ///////////////////////////////////////
 
+    /**
+     * Provides helper functions for working
+     * with Qik filters
+     * @type {QikFilter}
+     */
+    const filter = QikFilter;
+    Object.defineProperty(core, 'filter', {
+        value: filter,
+        writable: false,
+    });
+
+
+
+    ///////////////////////////////////////
+
+    /**
+     * Provides helper functions for working
+     * with Qik files
+     * @type {QikFiles}
+     */
+    const files = new QikFiles(core);
+    Object.defineProperty(core, 'files', {
+        value: files,
+        writable: false,
+    });
+
+    ///////////////////////////////////////
+
     //Create a new global dispatcher so we can trigger events
-    var dispatcher = new EventDispatcher();
+    const dispatcher = new EventDispatcher();
     dispatcher.bootstrap(core);
 
     //Set the function
@@ -131,7 +163,7 @@ export default function(options) {
      * that works in conjunction with the other Qik modules
      * @type {QikAPI}
      */
-    var api = new QikAPI(core);
+    const api = new QikAPI(core);
     Object.defineProperty(core, 'api', {
         value: api,
         writable: false,
@@ -143,7 +175,7 @@ export default function(options) {
      * and other user/application specific functionality
      * @type {QikAuth}
      */
-    var auth = new QikAuth(core);
+    const auth = new QikAuth(core);
     Object.defineProperty(core, 'auth', {
         value: auth,
         writable: false,
@@ -155,7 +187,7 @@ export default function(options) {
      * A helper service for understanding a user's access permissions
      * @type {QikAccess}
      */
-    var access = new QikAccess(core);
+    const access = new QikAccess(core);
     Object.defineProperty(core, 'access', {
         value: access,
         writable: false,
@@ -163,6 +195,33 @@ export default function(options) {
 
     ///////////////////////////////////////
 
+    /**
+     * A helper service for content create, update, read and delete operations.
+     * @type {QikContent}
+     */
+    const system = new QikSystem(core);
+    Object.defineProperty(core, 'system', {
+        value: system,
+        writable: false,
+    });
+
+
+    ///////////////////////////////////////
+
+    /**
+     * A helper service for content create, update, read and delete operations.
+     * @type {QikContent}
+     */
+    const content = new QikContent(core);
+    Object.defineProperty(core, 'content', {
+        value: content,
+        writable: false,
+    });
+
+    ///////////////////////////////////////
+
+    ///////////////////////////////////////
+
     return core;
 
 }

package/src/api/qik.files.js

@@ -0,0 +1,88 @@
+export default function(qik) {
+
+
+    ///////////////////////
+
+    var service = {};
+
+    ///////////////////////
+
+    service.downloadUrl = function(type, id, params) {
+        params = params || {}
+        params.download = true;
+        id = qik.utils.id(id);
+        return qik.api.generateEndpointURL(`/${type}/${id}`, params);
+    }
+
+    service.mediaUrl = function(type, id, params) {
+        params = params || {}
+        id = qik.utils.id(id);
+        return qik.api.generateEndpointURL(`/${type}/${id}`, params);
+    }
+
+    ///////////////////////
+
+    service.filesize = function(bytes) {
+        var sizes = ['b', 'kb', 'mb', 'gb', 'tb'];
+        if (bytes == 0) return '0 Byte';
+        var i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
+        return Math.round(bytes / Math.pow(1024, i), 2) + '' + sizes[i];
+    }
+
+    ///////////////////////
+
+    service.getBinaryTypeFromMime = function(fileMime) {
+
+        if (!fileMime) {
+            return 'file';
+        }
+
+        ////////////////////////////////
+
+        switch (fileMime) {
+            case 'image/jpeg':
+            case 'image/png':
+            case 'image/gif':
+            case 'image/bmp':
+            case 'image/tiff':
+            case 'image/svg+xml':
+                return 'image';
+                break;
+            case 'video/mp4':
+            case 'video/quicktime':
+            case 'video/ogg':
+            case 'video/webm':
+                return 'video'
+                break;
+            case 'audio/aac':
+            case 'audio/aiff':
+            case 'audio/mp3':
+            case 'audio/x-m4a':
+            case 'audio/mpeg':
+            case 'audio/ogg':
+            case 'audio/wav':
+            case 'audio/webm':
+                return 'audio'
+                break;
+            default:
+                //See if we can guess it from the first part of the mimetype
+                var prefix = fileMime.split('/')[0];
+                switch (prefix) {
+                    case 'image':
+                    case 'video':
+                    case 'audio':
+                        return prefix;
+                        break;
+                    default:
+                        return 'file';
+                        break;
+                }
+                break;
+        }
+    }
+
+    ////////////////////////////////
+
+    return service;
+
+}

package/src/api/qik.filter.js

@@ -0,0 +1,255 @@
+///////////////////////
+
+var service = {};
+
+
+///////////////////////
+
+
+function isEmpty(value) {
+    if(value === 0) {
+        return false;
+    }
+
+    var empty = typeof value === 'undefined' || value === null || String(value).trim() === '';
+
+    if (empty) {
+        return true;
+    }
+
+    //If it's a string of undefined or null then treat it as empty also
+    if (value === 'undefined' || value === 'null') {
+        return true;
+    }
+
+    return false;
+}
+
+function compactFunction(val) {
+    return !isEmpty(val)
+}
+
+
+///////////////////////
+
+service.cleanKey = function(key) {
+    key = String(key).split('|')[0];
+
+    if (key[0] == '.') {
+        key = key.slice(1);
+    }
+
+    return key;
+}
+
+///////////////////////
+
+service.isValidFilter = function(filter) {
+    if (!filter) {
+        return false;
+    }
+
+    ///////////////////////////
+
+    //If the filter has nested filters consider it valid
+    //if it has valid child filters
+    if (filter.operator) {
+        if (!filter.filters || !filter.filters.length) {
+            return false;
+        }
+
+        return filter.filters.some(service.isValidFilter);
+    }
+
+    // ///////////////////////////
+
+    // //Get the comparator for the filter
+    // var comparator = hash[filter.comparator];
+    // if (!comparator) {
+    //     //No comparator was specified for the filter
+    //     return false;
+    // }
+
+    ///////////////////////////
+
+    var key = service.cleanKey(filter.key);
+    if (!key) {
+        //No key has been specified for the filter
+        return false;
+    }
+
+    if(filter.comparator == 'empty' || filter.comparator == 'notempty') {
+        return true;
+    }
+
+
+    var multiValues = (filter.values || []).filter(compactFunction);
+
+
+
+    return !isEmpty(filter.value) || !isEmpty(filter.value2) || multiValues.length;
+    // ///////////////////////////
+
+    // switch (filter.inputType) {
+    //     case 'none':
+    //         //If we are checking empty/notempty
+    //         //the filter is always valid without any extra parameters
+    //         return true;
+    //         break;
+    //     case 'range':
+    //         //If we are filtering a number range
+    //         //we need the start and end of the range
+    //         if (!filter.value || isNaN(filter.value)) {
+    //             return false;
+    //         }
+
+    //         if (!filter.value2 || isNaN(filter.value2)) {
+    //             return false;
+    //         }
+    //         break;
+    //     case 'daterange':
+    //         if (!filter.value || !parseDate(filter.value)) {
+    //             return false;
+    //         }
+
+    //         if (!filter.value2 || !parseDate(filter.value2)) {
+    //             return false;
+    //         }
+    //         break;
+    //     case 'array':
+    //         if (!filter.values || !filter.values.length) {
+    //             return false;
+    //         }
+    //         break;
+    //     default:
+    //         // if (filter.dataType == 'boolean') {
+    //         //     //Check if they provided a valid boolean value to the filter
+    //         //     return validBooleans[String(filter.value).toLowerCase()];
+    //         // } else {
+    //         //     //The filter has not been provided with a value
+    //         if (isEmpty(filter.value)) {
+    //             return false;
+    //         }
+    //         // }
+    //         break;
+    // }
+
+    ///////////////////////////
+
+    //If we got this far then the information
+    //provided to the filter is enough to run it
+    return true;
+
+}
+
+////////////////////////////////////////////////
+
+service.activeFilters = function(filterConfiguration) {
+    var memo = [];
+
+    retrieveActiveFilter(filterConfiguration, memo);
+
+    return memo;
+
+    ////////////////////////////
+
+    function retrieveActiveFilter(filterBlock, memo) {
+        if (!filterBlock) {
+            return;
+        }
+
+        var isValid = service.isValidFilter(filterBlock);
+
+        if (isValid) {
+            memo.push(filterBlock);
+        }
+
+        if (filterBlock.filters && filterBlock.filters.length) {
+            filterBlock.filters.forEach(function(b) {
+                retrieveActiveFilter(b, memo);
+            })
+        }
+    }
+}
+
+////////////////////////////////////////////////
+
+service.activeFilterKeys = function(filterConfiguration) {
+    var value = service.activeFilters(filterConfiguration)
+        .filter(function(entry) {
+            //Ignore all the wrapping entries
+            return !entry.operator;
+        })
+        .reduce(function(set, filter) {
+            var rootKey = service.cleanKey(filter.key);
+            set[rootKey] = true;
+            return set;
+        }, {})
+
+    return Object.keys(value);
+}
+
+service.activeFilterComparators = function(filterConfiguration) {
+    var comparators = service.activeFilters(filterConfiguration)
+        .filter(function(entry) {
+            //Ignore all the wrapping entries
+            return !entry.operator;
+        })
+        .reduce(function(set, filter) {
+            set[filter.comparator] = true;
+            return set;
+        }, {})
+
+    return Object.keys(comparators);
+}
+
+
+service.activeFilterOperators = function(filterConfiguration) {
+    var operators = service.activeFilters(filterConfiguration)
+        .filter(function(entry) {
+            return entry.operator;
+        })
+        .reduce(function(set, filter) {
+            set[filter.operator] = true;
+            return set;
+        }, {})
+
+    return Object.keys(operators);
+}
+
+
+
+service.activeFilterValues = function(filterConfiguration, options) {
+
+    options = options || {};
+
+    var activeFilters = service.activeFilters(filterConfiguration);
+
+    var values = activeFilters
+        .filter(function(entry) {
+            //Ignore all the wrapping entries
+            return !entry.operator;
+        })
+        .reduce(function(set, filter) {
+            set = [...set, ...(filter.values || []), filter.value, filter.value2];
+            return set;
+        }, [])
+        .filter(compactFunction);
+
+
+
+    return values;
+}
+service.filterChangeString = function(config) {
+    var string = [
+        service.activeFilterKeys(config).join(', '),
+        service.activeFilterValues(config).join(', '),
+        service.activeFilterComparators(config).join(', '),
+        service.activeFilterOperators(config).join(', '),
+    ]
+    return string.filter(compactFunction).join(', ');
+};
+
+///////////////////////
+
+export default service;

package/src/api/qik.system.js

@@ -0,0 +1,42 @@
+///////////////////////////////////////////////////
+
+/**
+ * Creates a new QikSystem instance.
+ * This module provides a number of helper functions for the system
+ * @alias content
+ * @constructor
+ * @hideconstructor
+ * @param {QikCore} qik A reference to the parent instance of the QikCore module. This module is usually created by a QikCore instance that passes itself in as the first argument.
+ */
+export default function(qik) {
+
+    ///////////////////////////////////////////////////
+
+    var service = {}
+
+
+    ///////////////////////////////////////////////////////////////////////////////
+
+    var inflightCountries;
+
+    service.countries = async function() {
+
+        if (!inflightCountries) {
+
+            inflightCountries = new Promise(async function(resolve, reject) {
+                qik.api.get(`/system/countries`)
+                    .then(function(res) {
+                        return resolve(res.data);
+                    })
+                    .catch(reject);
+            })
+        }
+
+        return inflightCountries;
+    }
+
+    ///////////////////////////////////////////////////
+
+    return service;
+
+}