ServerConnector.js

"use strict";

/* exported logger */

var Promise = require("bluebird");

var logger = require('./logger');

var request = require('request');

var Alias = require('./map/data/Alias');
var Chemical = require('./map/data/Chemical');
var Comment = require('./map/data/Comment');
var Configuration = require('./Configuration');
var Drug = require('./map/data/Drug');
var ConfigurationType = require('./ConfigurationType');
var IdentifiedElement = require('./map/data/IdentifiedElement');
var LayoutAlias = require('./map/data/LayoutAlias');
var LayoutData = require('./map/data/LayoutData');
var LayoutReaction = require('./map/data/LayoutReaction');
var MiRna = require('./map/data/MiRna');
var Project = require('./map/data/Project');
var Reaction = require('./map/data/Reaction');
var ReferenceGenome = require('./map/data/ReferenceGenome');
var SessionData = require('./SessionData');
var User = require('./map/data/User');

var GuiConnector = require('./GuiConnector');

var ObjectWithListeners = require('./ObjectWithListeners');

/**
 * This object contains methods that will communicate with server.
 */
var ServerConnector = new ObjectWithListeners();
ServerConnector.registerListenerType("onDataLoadStart");
ServerConnector.registerListenerType("onDataLoadStop");

ServerConnector._configurationParam = [];

ServerConnector.getMinOverlayColorInt = function() {
  var self = this;
  var userColor;
  return self.getLoggedUser().then(function(user) {
    userColor = user.getMinColor();
    return self.getConfigurationParam(ConfigurationType.MIN_COLOR_VAL);
  }).then(function(systemMinColor) {
    var color = userColor;
    if (userColor === null || userColor === undefined || userColor === "") {
      color = systemMinColor;
    }
    color = parseInt(color, 16);
    /* jslint bitwise: true */
    color = (color & 0xFFFFFF);
    return color;
  });
};

ServerConnector.getMaxOverlayColorInt = function() {
  var self = this;
  var userColor;
  return self.getLoggedUser().then(function(user) {
    userColor = user.getMaxColor();
    return self.getConfigurationParam(ConfigurationType.MAX_COLOR_VAL);
  }).then(function(systemMaxColor) {
    var color = userColor;
    if (userColor === null || userColor === undefined || userColor === "") {
      color = systemMaxColor;
    }
    color = parseInt(color, 16);
    /* jslint bitwise: true */
    color = (color & 0xFFFFFF);
    return color;
  });
};

ServerConnector.readFile = function(url, description) {
  var self = this;
  if (description === undefined) {
    description = url;
  }
  var content;
  return self.callListeners("onDataLoadStart", description).then(function() {
    return self._readFile(url);
  }).then(function(result) {
    content = result;
    return self.callListeners("onDataLoadStop", description);
  }, function(error) {
    return self.callListeners("onDataLoadStop", description).then(function() {
      return Promise.reject(error);
    });
  }).then(function() {
    return content;
  });
};

ServerConnector._readFile = function(url) {
  return new Promise(function(resolve, reject) {
    request.get(url, function(error, response, body) {
      if (error) {
        reject(error);

      } else if (response.statusCode !== 200) {
        var error = new Error(url + " rejected with status code: " + response.statusCode);
        reject(error);
      } else {
        resolve(body);
      }
    });
  });
};

ServerConnector.sendPostRequest = function(url, params) {
  return new Promise(function(resolve, reject) {
    request.post({
      url : url,
      form : params
    }, function(error, response, body) {
      if (error) {
        reject(error);

      } else if (response.statusCode !== 200) {
        var error = new Error(url + " rejected with status code: " + response.statusCode);
        reject(error);
      } else {
        resolve(body);
      }
    });
  });
};

ServerConnector.sendPutRequest = function(url, params) {
  return new Promise(function(resolve, reject) {
    request.put({
      url : url,
      form : params
    }, function(error, response, body) {
      if (error) {
        reject(error);
      } else if (response.statusCode !== 200) {
        var error = new Error(url + " rejected with status code: " + response.statusCode);
        reject(error);
      } else {
        resolve(body);
      }
    });
  });
};

ServerConnector.sendDeleteRequest = function(url, params) {
  return new Promise(function(resolve, reject) {
    request({
      method : "DELETE",
      url : url,
      json : params,
    }, function(error, response, body) {
      if (error) {
        reject(error);
      } else if (response.statusCode !== 200) {
        var error = new Error(url + " rejected with status code: " + response.statusCode);
        reject(error);
      } else {
        resolve(body);
      }
    });
  });
};

ServerConnector.sendPatchRequest = function(url, params) {
  return new Promise(function(resolve, reject) {
    request({
      method : "PATCH",
      url : url,
      json : params,
    }, function(error, response, body) {
      if (error) {
        reject(error);
      } else if (response.statusCode !== 200) {
        var error = new Error(url + " rejected with status code: " + response.statusCode);
        reject(error);
      } else {
        resolve(body);
      }
    });
  });
};

ServerConnector.getToken = function(token) {
  if (token !== undefined) {
    return Promise.resolve(token);
  }

  var self = this;
  token = self.getSessionData(null).getToken();
  if (token === undefined) {
    return self.login();
  } else {
    // if the project is not initialized then check if we can download data
    // using current token
    if (self.getSessionData().getProject() === null) {
      return self.getConfiguration({
        token : token
      }).then(function() {
        return token;
      }, function() {
        return self.login();
      });
    } else {
      return Promise.resolve(token);
    }
  }
};

ServerConnector.getApiBaseUrl = function() {
  return this.getServerBaseUrl() + "/api/";
};

ServerConnector.getServerBaseUrl = function() {
  if (this._serverBaseUrl === undefined) {
    var url = "" + window.location.href;
    if (!url.endsWith("/")) {
      url = url.substr(0, url.lastIndexOf("/") + 1);
    }
    this._serverBaseUrl = url;
  }
  return this._serverBaseUrl;
};

ServerConnector.createGetParams = function(params, prefix) {
  var sorted = [], key;

  for (key in params) {
    if (params.hasOwnProperty(key)) {
      sorted.push(key);
    }
  }
  sorted.sort();

  var result = "";
  for (var i = 0; i < sorted.length; i++) {
    key = sorted[i];
    var value = params[key];
    if (prefix !== undefined) {
      key = prefix + "." + key;
    }

    if (value instanceof google.maps.Point) {
      value = this.pointToString(value);
    } else if (Object.prototype.toString.call(value) === '[object Array]') {
      value = this.idsToString(value);
    } else if (typeof value === 'string' || value instanceof String || !isNaN(value)) {

    } else {
      result += this.createGetParams(value, key);
      value = undefined;
    }

    if (value !== undefined && value !== "") {
      result += key + "=" + value + "&";
    }
  }
  return result;
};

ServerConnector.getApiUrl = function(paramObj) {
  var type = paramObj.type;
  var method = paramObj.method;
  var params = this.createGetParams(paramObj.params);

  var result = paramObj.url;
  if (result === undefined) {
    result = this.getApiBaseUrl() + "/" + type;
  }
  if (method !== undefined) {
    result += "/" + method;
  }
  if (params !== "") {
    result += "?" + params;
  }
  return result;
};

ServerConnector.getProjectsUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    type : "projects/" + queryParams.projectId + "/",
    params : filterParams,
  });
};

ServerConnector.getPublicationsUrl = function(queryParams, filterParams) {
  filterParams.start = filterParams.start || 0;
  filterParams.length = filterParams.length || 10;

  return this.getApiUrl({
    url : this.getModelsUrl(queryParams) + "publications/",
    params : filterParams,
  });
};

ServerConnector.getReferenceGenomeUrl = function(queryParams, filterParams) {
  var version = this.getIdOrAsterisk(queryParams.version);

  return this.getApiUrl({
    type : "genomics/taxonomies/" + queryParams.organism + "/types/" + queryParams.type + "/versions/" + version,
    params : filterParams
  });
};

ServerConnector.loginUrl = function() {
  return this.getApiUrl({
    type : "/doLogin",
  });
};

ServerConnector.getSuggestedQueryListUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getBioEntitiesUrl(queryParams) + "suggestedQueryList/",
    params : filterParams,
  });
};

ServerConnector.addCommentUrl = function(queryParams) {
  return this.getApiUrl({
    url : this.getCommentsUrl(queryParams)
  });
};

ServerConnector.addOverlayUrl = function(queryParams) {
  return this.getApiUrl({
    url : this.getOverlaysUrl(queryParams)
  });
};

ServerConnector.updateOverlayUrl = function(queryParams) {
  return this.getApiUrl({
    url : this.getOverlayByIdUrl(queryParams)
  });
};

ServerConnector.deleteOverlayUrl = function(queryParams) {
  return this.getApiUrl({
    url : this.getOverlayByIdUrl(queryParams),
  });
};

ServerConnector.getOverlaysUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getProjectsUrl(queryParams) + "overlays/",
    params : filterParams,
  });
};

ServerConnector.getCommentsUrl = function(queryParams, filterParams) {
  var modelId = this.getIdOrAsterisk(queryParams.modelId);
  var url = this.getProjectsUrl(queryParams) + "comments/models/" + modelId + "/";
  if (queryParams.elementType !== undefined) {
    if (queryParams.elementType === "ALIAS") {
      url += "bioEntities/elements/" + queryParams.elementId;
    } else if (queryParams.elementType === "REACTION") {
      url += "bioEntities/reactions/" + queryParams.elementId;
    } else if (queryParams.elementType === "POINT") {
      url += "points/" + queryParams.coordinates;
    } else {
      throw new Error("Unknown element type: " + queryParams.elementType);
    }
  }
  return this.getApiUrl({
    url : url,
    params : filterParams,
  });
};

ServerConnector.getOverlayByIdUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getOverlaysUrl(queryParams) + queryParams.overlayId + "/",
    params : filterParams,
  });

};

ServerConnector.getOverlayElementsUrl = function(queryParams, filterParams) {

  return this.getApiUrl({
    url : this.getModelsUrl(queryParams) + "bioEntities/",
    params : filterParams,
  });

};

ServerConnector.getFullOverlayElementUrl = function(queryParams, filterParams) {

  return this.getApiUrl({
    url : this.getAliasesUrl(queryParams) + queryParams.id + "/",
    params : filterParams,
  });

};

ServerConnector.idsToString = function(ids) {
  var result = "";
  if (ids !== undefined) {
    ids.sort(function(a, b) {
      return a - b;
    });
    for (var i = 0; i < ids.length; i++) {
      if (result !== "") {
        if (ids[i - 1] !== ids[i]) {
          result = result + "," + ids[i];
        } // we ignore duplicates
      } else {
        result = ids[i];
      }
    }
  }
  return result;
};

ServerConnector.pointToString = function(point) {
  return point.x.toFixed(2) + "," + point.y.toFixed(2);
};

ServerConnector.columnsToString = function(columns) {
  if (columns === undefined) {
    return "";
  }
  return columns;
};

ServerConnector.getModelsUrl = function(queryParams) {
  var modelId = this.getIdOrAsterisk(queryParams.modelId);
  var overlayId = queryParams.overlayId;
  var url = this.getProjectsUrl(queryParams);
  if (overlayId !== undefined) {
    url = this.getOverlayByIdUrl(queryParams);
  }

  return this.getApiUrl({
    url : url + "models/" + modelId + "/",
  });
};

ServerConnector.getBioEntitiesUrl = function(queryParams) {
  return this.getApiUrl({
    url : this.getModelsUrl(queryParams) + "bioEntities/",
  });
};

ServerConnector.getIdOrAsterisk = function(id) {
  if (id === undefined || id === "" || id === null) {
    return "*";
  } else {
    return id;
  }
};

ServerConnector.getReactionsUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getBioEntitiesUrl(queryParams) + "reactions/",
    params : filterParams,
  });
};

ServerConnector.getAliasesUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getBioEntitiesUrl(queryParams) + "elements/",
    params : filterParams,
  });
};

ServerConnector.getConfigurationUrl = function(queryParams, filterParams) {
  var result = this.getApiUrl({
    type : "configuration/",
    params : filterParams
  });
  return result;
};

ServerConnector.getSearchUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getModelsUrl(queryParams) + "bioEntities:search",
    params : filterParams,
  });
};

ServerConnector.getSearchDrugsUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getProjectsUrl(queryParams) + "drugs:search",
    params : filterParams,
  });
};

ServerConnector.getSearchMiRnasUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getProjectsUrl(queryParams) + "miRnas:search",
    params : filterParams,
  });
};

ServerConnector.getSearchChemicalsUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getProjectsUrl(queryParams) + "chemicals:search",
    params : filterParams,
  });
};

ServerConnector.getOverlaySourceUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getOverlaysUrl(queryParams) + queryParams.overlayId + ":downloadSource",
    params : filterParams
  });
};

ServerConnector.getImageUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getProjectsUrl(queryParams) + "models/" + queryParams.modelId + ":downloadImage",
    params : filterParams,
  });
};

ServerConnector.getModelPartUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    url : this.getProjectsUrl(queryParams) + "models/" + queryParams.modelId + ":downloadModel",
    params : filterParams,
  });
};

ServerConnector.getProjectSourceUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    type : "projects/" + queryParams.projectId + ":downloadSource",
    params : filterParams
  });
};

ServerConnector.getUserUrl = function(queryParams, filterParams) {
  return this.getApiUrl({
    type : "users/",
    method : queryParams.login,
    params : filterParams,
  });
};

ServerConnector.getConfiguration = function(params) {
  if (params === undefined) {
    params = {};
  }
  var self = this;
  if (this._configuration === undefined) {
    return self.getToken(params.token).then(function(token) {
      return self.readFile(self.getConfigurationUrl(null, {
        token : token
      }));
    }).then(function(content) {
      self._configuration = new Configuration(JSON.parse(content));
      return Promise.resolve(self._configuration);
    });
  } else {
    return Promise.resolve(self._configuration);
  }
};

ServerConnector.getConfigurationParam = function(paramId) {
  var self = this;
  return self.getConfiguration().then(function(configuration) {
    return configuration.getOption(paramId);
  });
};

ServerConnector.getProject = function(projectId) {
  var queryParams = {};
  var filterParams = {};
  var project;
  var self = this;
  return self.getProjectId(projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getProjectsUrl(queryParams, filterParams));
  }).then(function(content) {
    project = new Project(content);
    return self.getOverlays(projectId);
  }).then(function(overlays) {
    project.getModel().addLayouts(overlays);
    return project;
  });
};

ServerConnector.getLoggedUser = function() {
  var self = this;
  if (self._loggedUser !== undefined) {
    return Promise.resolve(self._loggedUser);
  } else {
    return self.getUser(self.getSessionData().getLogin()).then(function(user) {
      self._loggedUser = user;
      return self._loggedUser;
    });
  }
};

ServerConnector.getUser = function(login) {
  var self = this;
  var queryParams = {
    login : login,
  };
  var filterParams = {};

  return self.getToken().then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getUserUrl(queryParams, filterParams));
  }).then(function(content) {
    var obj = JSON.parse(content);
    return new User(obj);
  });
};

ServerConnector.getOverlays = function(projectId) {
  var self = this;
  var queryParams = {};
  var filterParams = {};
  return new Promise(function(resolve, reject) {
    self.getProjectId(projectId).then(function(result) {
      queryParams.projectId = result;
      return self.getToken();
    }).then(function(token) {
      filterParams.token = token;
      return self.readFile(self.getOverlaysUrl(queryParams, filterParams));
    }).then(function(content) {
      var arr = JSON.parse(content);
      var result = [];
      for (var i = 0; i < arr.length; i++) {
        var overlay = new LayoutData(arr[i]);
        result.push(overlay);
      }
      resolve(result);
    }, reject);
  });
};

ServerConnector.getOverlayElements = function(overlayId, projectId) {
  var self = this;
  if (overlayId === undefined) {
    throw new Error("Layout id must be defined");
  }
  var queryParams = {
    overlayId : overlayId,
    modelId : "*",
  };
  var filterParams = {};

  return self.getToken().then(function(result) {
    filterParams.token = result;
    return self.getProjectId(projectId);
  }).then(function(result) {
    queryParams.projectId = result;
    return self.readFile(self.getOverlayElementsUrl(queryParams, filterParams));
  }).then(function(content) {
    var arr = JSON.parse(content);
    var result = [];
    for (var i = 0; i < arr.length; i++) {
      var element = arr[i];
      if (element.type === "REACTION") {
        result.push(new LayoutReaction(element.overlayContent));
      } else if (element.type === "ALIAS") {
        result.push(new LayoutAlias(element.overlayContent));
      } else {
        throw new Error("Unknown element type: " + element.type);
      }
    }
    return result;
  });
};

ServerConnector.getFullOverlayElement = function(params) {
  var self = this;

  var queryParams = {
    overlayId : params.overlay.getId(),
    modelId : params.element.getModelId(),
    id : params.element.getId(),
  };
  var filterParams = {};

  return self.getToken().then(function(result) {
    filterParams.token = result;
    return self.getProjectId(params.projectId);
  }).then(function(result) {
    queryParams.projectId = result;
    return self.readFile(self.getFullOverlayElementUrl(queryParams, filterParams));
  }).then(function(content) {
    var element = JSON.parse(content);
    var result = null;
    if (element.type === "REACTION") {
      result = new LayoutReaction(element.overlayContent);
    } else if (element.type === "ALIAS") {
      result = new LayoutAlias(element.overlayContent);
    } else {
      throw new Error("Unknown element type: " + element.type);
    }
    return result;
  });
};

ServerConnector.getProjectId = function(projectId) {
  var self = this;
  if (projectId !== undefined && projectId !== null && projectId !== "") {
    return Promise.resolve(projectId);
  } else if (GuiConnector.getParams['id'] !== undefined) {
    return Promise.resolve(GuiConnector.getParams['id']);
  } else {
    return self.getConfigurationParam(ConfigurationType.DEFAULT_MAP);
  }
};

ServerConnector.getLogoImg = function() {
  return this.getConfigurationParam(ConfigurationType.LOGO_IMG);
};

ServerConnector.getLogoLink = function() {
  return this.getConfigurationParam(ConfigurationType.LOGO_LINK);
};

ServerConnector.getMaxSearchDistance = function() {
  return this.getConfigurationParam(ConfigurationType.SEARCH_DISTANCE);
};

ServerConnector.getOverlayById = function(overlayId, projectId) {
  var self = this;
  var queryParams = {
    overlayId : overlayId
  };
  var filterParams = {};
  return self.getProjectId(projectId).then(function(data) {
    queryParams.projectId = data;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getOverlayByIdUrl(queryParams, filterParams));
  }).then(function(content) {
    return new LayoutData(JSON.parse(content));
  });
};

ServerConnector.getReactions = function(params) {
  var self = this;
  var queryParams = {};
  var filterParams = {
    id : params.ids,
    columns : params.columns,
    participantId : params.participantId,
  };
  return self.getProjectId(params.projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getReactionsUrl(queryParams, filterParams));
  }).then(function(content) {
    var array = JSON.parse(content);
    var result = [];
    for (var i = 0; i < array.length; i++) {
      result.push(new Reaction(array[i]));
    }
    return result;
  });
};

ServerConnector.getAliases = function(aliasIds, projectId, columns) {
  var self = this;
  var queryParams = {};
  var filterParams = {
    id : aliasIds,
    columns : columns
  };
  return self.getProjectId(projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getAliasesUrl(queryParams, filterParams));
  }).then(function(content) {
    var array = JSON.parse(content);
    var result = [];
    for (var i = 0; i < array.length; i++) {
      result.push(new Alias(array[i]));
    }
    return result;
  });
};

ServerConnector.getLightComments = function(params) {
  params.columns = [ "id", "elementId", "modelId", "type", "icon", "removed" ];
  return this.getComments(params);
};

ServerConnector.getComments = function(params) {
  var self = this;
  var queryParams = {
    elementId : params.elementId,
    elementType : params.elementType,
  };
  var filterParams = {
    columns : params.columns
  };
  return self.getProjectId(params.projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getCommentsUrl(queryParams, filterParams));
  }).then(function(content) {
    var array = JSON.parse(content);
    var result = [];
    for (var i = 0; i < array.length; i++) {
      result.push(new Comment(array[i]));
    }
    return result;
  });
};

ServerConnector.getLightAliases = function(aliasIds, projectId) {
  return this.getAliases(aliasIds, projectId, "id,bounds,modelId");
};

ServerConnector.getSessionData = function(project) {
  if (this._sessionData === undefined) {
    this._sessionData = new SessionData(project);
  }
  if (project !== undefined && this._sessionData.getProject() === null) {
    this._sessionData.setProject(project);
  }
  return this._sessionData;
};

ServerConnector.getClosestElementsByCoordinates = function(params) {
  var self = this;
  var queryParams = {
    modelId : params.modelId
  };
  var filterParams = {
    coordinates : params.coordinates,
    count : params.count,
  };
  return self.getProjectId(params.projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getSearchUrl(queryParams, filterParams));
  }).then(function(content) {
    var array = JSON.parse(content);
    var result = [];
    for (var i = 0; i < array.length; i++) {
      result.push(new IdentifiedElement(array[i]));
    }
    return result;
  });
};

ServerConnector.login = function(login, password) {
  var self = this;
  var params = {};
  if (login !== undefined) {
    params.login = login;
    params.password = password;
  } else {
    params.login = "anonymous";
  }
  return self.sendPostRequest(self.loginUrl(), params).then(function() {
    self.getSessionData().setLogin(params.login);
    return Promise.resolve(self.getSessionData().getToken());
  });
};

ServerConnector.logout = function() {
  var self = this;
  self.getSessionData().setToken(undefined);
  self.getSessionData().setLogin(undefined);
  return Promise.resolve();
};

ServerConnector.getElementsByQuery = function(params) {
  var self = this;
  var queryParams = {
    modelId : params.modelId
  };
  var filterParams = {
    query : params.query,
    perfectMatch : params.perfectMatch,
  };

  return self.getProjectId(params.projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getSearchUrl(queryParams, filterParams));
  }).then(function(content) {
    var array = JSON.parse(content);
    var result = [];
    for (var i = 0; i < array.length; i++) {
      result.push(new IdentifiedElement(array[i]));
    }
    return result;
  });
};

ServerConnector.getDrugsByQuery = function(params) {
  var self = this;
  var queryParams = {};
  var filterParams = {
    query : params.query
  };
  return self.getProjectId(params.projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getSearchDrugsUrl(queryParams, filterParams));
  }).then(function(content) {
    var array = JSON.parse(content);
    var result = [];
    for (var i = 0; i < array.length; i++) {
      result.push(new Drug(array[i]));
    }
    return result;
  });
};

ServerConnector.getMiRnasByQuery = function(params) {
  var self = this;
  var queryParams = {};
  var filterParams = {
    query : params.query
  };
  return self.getProjectId(params.projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getSearchMiRnasUrl(queryParams, filterParams));
  }).then(function(content) {
    var array = JSON.parse(content);
    var result = [];
    for (var i = 0; i < array.length; i++) {
      result.push(new MiRna(array[i]));
    }
    return result;
  });
};

ServerConnector.getChemicalsByQuery = function(params) {
  var self = this;
  var queryParams = {};
  var filterParams = {
    query : params.query
  };
  return self.getProjectId(params.projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.readFile(self.getSearchChemicalsUrl(queryParams, filterParams));
  }).then(function(content) {
    var array = JSON.parse(content);
    var result = [];
    for (var i = 0; i < array.length; i++) {
      result.push(new Chemical(array[i]));
    }
    return result;
  });
};

ServerConnector.getOverlaySourceDownloadUrl = function(params) {
  var self = this;
  var queryParams = {
    overlayId : params.overlayId
  };
  var filterParams = {};
  return self.getProjectId(params.projectId).then(function(result) {
    queryParams.projectId = result;
    return self.getToken();
  }).then(function(token) {
    filterParams.token = token;
    return self.getOverlaySourceUrl(queryParams, filterParams);
  });
};

ServerConnector.getImageDownloadUrl = function(params) {
  var self = this;
  var queryParams = {
    projectId : params.projectId,
    modelId : params.modelId,
  };
  var filterParams = {
    token : params.token,
    polygonString : params.polygonString,
    handlerClass : params.handlerClass,
    backgroundOverlayId : params.backgroundOverlayId,
    zoomLevel : params.zoomLevel,
    overlayIds : this.idsToString(params.overlayIds),