impossiblefxv1 1.13.2

package/lib/services/project.js

@@ -0,0 +1,102 @@
+
+var FX = require('../core');
+
+FX.util.update(FX.Project.prototype, {
+
+    TransformProjectList: function(request) {
+        var data = request.response.data
+        var result = {Projects: []}
+
+        for(var p=0; p < data.Projects.length; p++) {
+            var prjuid = data.Projects[p][0]
+            result.Projects.push({
+                ProjectId: prjuid,
+                Region: request.service.config.region,
+                Name: data.Metadata[prjuid].name,
+                Created: data.Metadata[prjuid].date_created
+            })
+        }
+
+        request.response.data = result
+    },
+
+
+    TransformProjectCreate: function(request) {
+        var data = request.response.data
+        request.response.data = {
+            Project: {
+                ProjectId: data['project-UID'],
+                Region: request.service.config.region,
+                Name: request.params['Name'],
+                Created: new Date()
+            }
+        }
+    },
+
+    TransformAssetList: function(request) {
+        var data = request.response.data
+        var result = { All: {}, Videos: [], Images: [], Sounds: [], Fonts: [], Datasources: [], Aux: [], Trackdata: [] }
+
+        var collectAssets = function(source, destination) {
+            for(var a=0; a < source.length; a++) {
+                var name = source[a]
+                var asset = {}
+                FX.util.each(data.Metadata[name], function(key, value){
+                    asset[FX.util.string.upperFirst(key)] = value
+                })
+                asset.Region = request.service.config.region,
+                asset.ProjectId = request.params['ProjectId']
+                result.All[name]  = asset
+                destination.push(asset)
+            }
+        }
+
+        collectAssets(data.Videos, result.Videos)
+        collectAssets(data.Images, result.Images)
+        collectAssets(data.Audios, result.Sounds)
+        collectAssets(data.Fonts, result.Fonts)
+        collectAssets(data.Generic, result.Aux)
+        collectAssets(data.Trackdata, result.Trackdata)
+        collectAssets(data.Datasources, result.Datasources)
+        request.response.data = result
+    },
+
+    TransformAssetGet: function(request) {
+        request.response.data = {
+            Data: request.response.httpResponse
+        }
+    },
+
+    TransformMovieGet: function(request) {
+        var data = request.response.data
+        request.response.data = {
+             Movie: new FX.SDL().Movie.decode(data)
+        }
+    },
+
+    TransformMovieList: function(request) {
+        var data = request.response.data
+        var result = {Movies: []}
+
+        for(var p=0; p < data.SDLS.length; p++) {
+            var name = data.SDLS[p];
+            var meta = data.Metadata[name];
+
+            result.Movies.push({
+                ProjectId: request.params['ProjectId'],
+                Region: request.service.config.region,
+                Name: name,
+                Created: meta.date_created,
+                Modified: meta.date_modified,
+                Width: meta['width'],
+                Height: meta['height'],
+                Codecs: meta['codec'],
+                Length: meta['seconds'],
+                VariableLength: meta['variablelength']
+            })
+        }
+
+        request.response.data = result
+    },
+
+})

package/lib/services/render.js

@@ -0,0 +1,63 @@
+
+var FX = require('../core');
+
+FX.util.update(FX.Render.prototype, {
+
+    TransformTokenGet: function(request) {
+        var data = request.response.data
+        request.response.data = {
+            Token: data.token 
+        }
+
+        if(data.upload) {
+            request.response.data.Upload = {
+                Result: data.upload.result,
+                Status: data.upload.status
+            }    
+        }
+    },
+
+
+    TransformRenderURL: function(request) {
+        var data = request.response.data
+        request.response.data = {
+            Token: data.token,
+            URL: FX.Render.computeRenderURL({
+                Token: data.token,
+                Endpoint: request.params.Endpoint || (request.httpRequest.protocol + "://" + request.httpRequest.hostname),
+                Mode: request.params.Mode || request.operation.input.members.Mode.default,
+                Format: request.params.Format || request.operation.input.members.Format.default
+
+            }) 
+        }
+    }
+})
+
+FX.util.update(FX.Render, {
+
+    /**
+     * Get a render URL for a given token.
+     *
+     * @note Synchronous operation
+     * @param Token [String] A token
+     * @param Extension [String] A video container format, e.g. "mp4"
+     * @option Endpoint [string] Override geo detection and route request to given region
+     * @option Mode [string] Delivery mode, defaults to "render"
+     */
+    computeRenderURL: function(params) {
+        var endpoint = params.Endpoint 
+        var mode = params.Mode
+        var format = params.Format
+        return endpoint+ "/v2/" + mode + "/" + params.Token + "." + format
+    },
+    
+
+    /**
+     * render preview image 
+     */
+    renderPreview: function(service, method, operation, params) {
+        var req = new FX.Request(service, method, operation, params)
+        //FX.HttpClient.getInstance().exec(self.httpRequest, function(err, stream) {
+
+    }
+})

package/lib/services/story.js

@@ -0,0 +1,5 @@
+
+var FX = require('../core');
+
+FX.util.update(FX.Story.prototype, {
+})

package/lib/services.js

@@ -0,0 +1,30 @@
+var FX = require('./core')
+var fs = require('fs');
+var path = require('path');
+
+// the Browser version has this already loaded
+//throw new Error("Browser should not load this");
+if(!FX.serviceMap) {
+    // Default (node) ApiLoader
+    FX.apiLoader = function(svcName, version) {
+        return require(FX.Service.serviceFile(svcName, version));
+    }
+
+    // Default (node) ServiceMap
+    var apiRoot = path.join(__dirname, '..', 'apis');
+    FX.serviceMap = require(path.join(apiRoot, 'metadata.json'));
+
+    FX.util.each(FX.serviceMap, function(key, value){
+        if(value.enabled) {
+
+            FX[value.domain] = FX.Service.defineService(key, value.versions);
+
+            // load any customizations from lib/services/<svcidentifier>.js
+            var svcFile = path.join(__dirname, 'services', key + '.js');
+            if (fs.existsSync(svcFile)) 
+                require('./services/' + key);
+        }
+    })
+}
+
+

package/lib/util.js

@@ -0,0 +1,126 @@
+
+var util = {
+    copy: function(obj) {
+        if(obj === null || obj === undefined) 
+            return obj;
+        var dupe = {};
+        // jshint forin:false
+        for (var key in obj) {
+            dupe[key] = obj[key];
+        }
+        return dupe;
+    },
+
+    each: function each(object, iterFunction) {
+        for (var key in object) {
+            if (Object.prototype.hasOwnProperty.call(object, key)) {
+                var ret = iterFunction.call(this, key, object[key]);
+                // if (ret === util.abort) 
+                //     break;
+            }
+        }
+    },
+
+    arrayEach: function arrayEach(array, iterFunction) {
+        for (var idx in array) {
+            if (Object.prototype.hasOwnProperty.call(array, idx)) {
+                var ret = iterFunction.call(this, array[idx], parseInt(idx, 10));
+            //    if (ret === util.abort) break;
+            }
+        }
+    },
+
+    update: function update(obj1, obj2) {
+        util.each(obj2, function iterator(key, item) {
+            obj1[key] = item;
+        });
+        return obj1;
+    },
+
+    isEmpty: function isEmpty(obj) {
+        for (var prop in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+                return false;
+            }
+        }
+        return true;
+    },
+
+    inherit: function inherit(klass, features) {
+        var newObject = null;
+        if (features === undefined) {
+            features = klass;
+            klass = Object;
+            newObject = {};
+        } else {
+            var ctor = function ConstructorWrapper() {};
+            ctor.prototype = klass.prototype;
+            newObject = new ctor();
+        }
+
+        // constructor not supplied, create pass-through ctor
+        if(features.constructor === Object) {
+            features.constructor = function() {
+                if (klass !== Object) {
+                    return klass.apply(this, arguments);
+                }
+            };
+        }
+        
+        features.constructor.prototype = newObject;
+        util.update(features.constructor.prototype, features);
+        features.constructor.__super__ = klass;
+        return features.constructor;
+    },
+
+    string: {
+        lowerFirst: function lowerFirst(string) {
+            return string[0].toLowerCase() + string.substr(1);
+        },
+        upperFirst: function lowerFirst(string) {
+            return string[0].toUpperCase() + string.substr(1);
+        }
+    },
+
+    date: {
+        getDate: function() {
+            return new Date()
+        }
+    },
+
+    ini: {
+        parse: function string(ini) {
+            var currentSection, map = {};
+            util.arrayEach(ini.split(/\r?\n/), function(line) {
+                line = line.split(/(^|\s);/)[0]; // remove comments
+                var section = line.match(/^\s*\[([^\[\]]+)\]\s*$/);
+                if (section) {
+                    currentSection = section[1];
+                } else if (currentSection) {
+                    var item = line.match(/^\s*(.+?)\s*=\s*(.+?)\s*$/);
+                    if (item) {
+                        map[currentSection] = map[currentSection] || {};
+                        map[currentSection][item[1]] = item[2];
+                    }
+                }
+            });
+
+            return map;
+        }
+    },
+
+    readFileSync: function readFileSync(path) {
+        if (util.isBrowser()) return null;
+        return util.nodeRequire('fs').readFileSync(path, 'utf-8');
+    },
+
+    //injected by browserify
+    isBrowser: function isBrowser() { return process && process.browser; },
+    isNode: function isNode() { return !util.isBrowser(); },
+    nodeRequire: function nodeRequire(module) {
+        if(util.isNode()) return require(module);
+    },
+    
+}
+
+module.exports = util;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "impossiblefxv1",
+  "version": "1.13.2",
+  "description": "ImpossibleFX Scripting and API (Legacy)",
+  "main": "lib/fx.js",
+  "scripts": {
+    "test": "node_modules/.bin/mocha test/*.js",
+    "make-browser-sdk": "node dist-tools/build-browser.js > dist/fx-sdk-latest.js",
+    "build": "dist-tools/build-sdk.sh",
+    "foo": "sh dist-tools/foo.sh",
+    "version": "npm run build",
+    "postversion": "npm publish && sh dist-tools/publish.sh"
+  },
+  "repository": {
+    "type": "git",
+    "url": "."
+  },
+  "author": "Impossible Software GmbH",
+  "license": "Proprietary",
+  "dependencies": {
+    "bytebuffer": "^5.0.1",
+    "follow-redirects": "^1.15.2",
+    "long": "^3.2.0",
+    "protobufjs": "^5.0.1",
+    "stream": "0.0.2"
+  },
+  "devDependencies": {
+    "bluebird": "^3.4.1",
+    "browserify": "^13.0.1",
+    "buffertools": "^2.1.4",
+    "chai": "^3.5.0",
+    "debug": "^4.3.4",
+    "mocha": "*",
+    "nock": "^8.0.0",
+    "should": ">= 0.0.1"
+  }
+}

package/package.json.save

@@ -0,0 +1,36 @@
+"name": "impossiblefx",
+  "version": "3.13.1",
+  "description": "ImpossibleFX Scripting and API",
+  "main": "lib/fx.js",
+  "scripts": {
+    "test": "node_modules/.bin/mocha test/*.js",
+    "make-browser-sdk": "node dist-tools/build-browser.js > dist/fx-sdk-latest.js",
+    "build": "dist-tools/build-sdk.sh",
+    "foo": "sh dist-tools/foo.sh",
+    "version": "npm run build",
+    "postversion": "npm publish && sh dist-tools/publish.sh"
+  },
+  "repository": {
+    "type": "git",
+    "url": "."
+  },
+  "author": "Impossible Software GmbH",
+  "license": "Proprietary",
+  "dependencies": {
+    "bytebuffer": "^5.0.1",
+    "follow-redirects": "^1.15.2",
+    "long": "^3.2.0",
+    "protobufjs": "^5.0.1",
+    "stream": "0.0.2"
+  },
+  "devDependencies": {
+    "bluebird": "^3.4.1",
+    "browserify": "^13.0.1",
+    "buffertools": "^2.1.4",
+    "chai": "^3.5.0",
+    "debug": "^4.3.4",
+    "mocha": "*",
+    "nock": "^8.0.0",
+    "should": ">= 0.0.1"
+  }
+}