index.js

var models = require('./models');
var endpoints = require('./endpoints');
var request = require('request');
var AzureMedia = require('./media');

var resourceMap = {
    accesspolicy: 'AccessPolicies',
    assetfile: 'Files',
    asset: 'Assets',
    contentkey: 'ContentKeys',
    ingestmanifest: 'IngestManifests',
    ingestmanifestasset: 'IngestManifestAssets',
    ingestmanifestfile: 'IngestManifestFiles',
    job: 'Jobs',
    jobtemplate: 'JobTemplates',
    locator: 'Locators',
    mediaprocessor: 'MediaProcessors',
    notificationendpoint: 'NotificationEndpoints',
    task: 'Tasks',
    tasktemplate: 'TaskTemplates',
};


function AzureAPI(config) {
    this.config = config || {};
    if (!this.config.hasOwnProperty('base_url')) {
        this.config.base_url = "https://media.windows.net/API/";
    }
    if (!this.config.hasOwnProperty('oauth_url')) {
        this.config.oauth_url = "https://wamsprodglobal001acs.accesscontrol.windows.net/v2/OAuth2-13";
    }
    this.auth_token = config.auth_token || '';
    this.rest = {};

    this.media = new AzureMedia(this);
}

(function () {

    this.init = function (cb) {
        Object.keys(endpoints).forEach(function (endpoint) {
            this.rest[endpoint] = {};
            Object.keys(endpoints[endpoint]).forEach(function (call) {
                this.rest[endpoint][call] = function () {
                    endpoints[endpoint][call].apply(this, arguments);
                }.bind(this);
            }.bind(this));
        }.bind(this));

        Object.keys(models).forEach(function (model) {
            if (model !== 'common') {
                models[model].addModelVar('api', this);
            }
        }.bind(this));

        this.getAuthToken(function (err, result) {
          if (err) return cb(err);
            //get the first redirect
          request.get({
              uri: this.modelURI('asset'),
              headers: this.defaultHeaders(),
              followRedirect: false,
              strictSSL: true
          }, function (err, res) {
            if (err) return cb(err);
            if (!err && res.statusCode === 301) {
                this.config.base_url = res.headers.location;
                console.log("changing base url to",  this.config.base_url);
            }
            cb(err, result);
          }.bind(this));
        }.bind(this));
    };

    this.defaultHeaders = function (opts) {
        var headers = {
            Accept: 'application/json;odata=verbose',
            DataServiceVersion: '3.0',
            MaxDataServiceVersion: '3.0',
            'x-ms-version': '2.11',
            'Content-Type': 'application/json;odata=verbose',
            Authorization: 'Bearer ' + this.oauth.access_token
        };
        return headers;
    };

    this.modelURI = function (modelName, id, filters) {
        var filter;
        var fidx;
        var url = this.config.base_url + resourceMap[modelName];
        var filterurl = [];
        if (id) {
            url = url + "('" + id + "')";
        }
        if (typeof filters !== 'undefined') {
            for (fidx in filters) {
                filter = filters[fidx];
                filterurl.push("$filter=" + filter.op + "('" + filter.source + ", " + filter.compare + "')");
            }
        }
        return url;
    };

    this.getAuthToken = function (cb) {
        cb = cb || function () {};

        request.post({
            uri: this.config.oauth_url,
            form: {
                grant_type: 'client_credentials',
                client_id: this.config.client_id,
                client_secret: this.config.client_secret,
                scope: 'urn:WindowsAzureMediaServices'
            },
            strictSSL: true
        }, function (err, res) {
            if (err) {
                return cb(err);
            }

            var result = JSON.parse(res.body);

            if (result.error) {
                return cb(result);
            }

            this.oauth = result;
            this.oauth.time_started = Date.now();
            cb(err, result.access_token);
        }.bind(this));
    };

    this.getRequest = function (model, id, cb) {
        cb = cb || function () {};

        request.get({
            uri: this.modelURI(model, id),
            headers: this.defaultHeaders(),
            followRedirect: false,
            strictSSL: true
        }, function (err, res) {
            if (res.statusCode == 200) {
                var data = JSON.parse(res.body).d;
                var dobj = models[model].create(data);
                cb(err, dobj);
            } else {
                cb(err || 'Expected 200 status, received: ' + res.statusCode + ' ' + res.body);
            }
        });
    };

    this.listRequest = function (model, cb, query) {
        cb = cb || function () {};

        request.get({
            uri: this.modelURI(model),
            headers: this.defaultHeaders(),
            followRedirect: false,
            strictSSL: true,
            qs: query
        }, function (err, res) {			
          if (err) return cb(err);
          var objs = [];
          if (res.statusCode == 200) {
              var data = JSON.parse(res.body).d.results;
			  if(data.length>0) {
				data.forEach(function (rawd) {
                  var dobj = models[model].create(rawd);
                  objs.push(dobj);
				});
			  }
              cb(err, objs);
          } else {
              cb(err || 'Expected 200 status, received: ' + res.statusCode + '\n' + res.body);
          }
      });
    };

    this.createRequest = function (model, data, cb) {
        cb = cb || function () {};

        var pl = models[model].create(data);
        var validationErrors = pl.doValidate();
        if (validationErrors.length) {
            return cb(validationErrors);
        }
        var r = request.post({
            uri: this.modelURI(model),
            headers: this.defaultHeaders(),
            body: JSON.stringify(data),
            followRedirect: false,
            strictSSL: true
        }, function (err, res) {
          if (err) return cb(err);
          if (res.statusCode == 201) {
              var data = JSON.parse(res.body).d;
              var dobj = models[model].create(data);
              cb(err, dobj);
          } else {
              cb(err || 'Create ' + model + ': Expected 201 status, received: ' + res.statusCode + '\n' + res.body);
          }
        });
    };

    this.deleteRequest = function (model, id, cb) {
        cb = cb || function () {};
        request({
            method: 'DELETE',
            uri: this.modelURI(model, id),
            headers: this.defaultHeaders(),
            followRedirect: false,
            strictSSL: true
        }, function (err, res) {
            if (res.statusCode == 204) {
                cb(err);
            } else {
                cb(err || 'Delete ' + model + ': Expected 204 status, received: ' + res.statusCode + '\n' + res.body);
            }
        });
    };

    this.updateRequest = function (model, id, data, cb) {
        cb = cb || function () {};

        var pl = models[model].create(data);
        var validationErrors = pl.doValidate();
        if (validationErrors.length) {
            return cb(validationErrors);
        }

        request({
            method: 'MERGE',
            uri: this.modelURI(model, id),
            headers: this.defaultHeaders(),
            followRedirect: false,
            strictSSL: true,
            body: JSON.stringify(data)
        }, function (err, res) {
          if (err) return cb(err);
          if (res.statusCode == 204 || res.statusCode == 200) {
			  if(res.statusCode == 204){
				  console.log(res.body);
				  cb(err, 'No content');
			  } else {
				var data = JSON.parse(res.body).d;
				var dobj = models[model].create(data);  
				cb(err, dobj);
			  }              
          } else {
              cb(err || 'Update ' + model + ': Expected 204 or 200 status, received: ' + res.statusCode + '\n' + res.body);
          }
        });
    };

}).call(AzureAPI.prototype);


module.exports = AzureAPI;