//@include lib_Class.js

/**
 * Utility functions for action handling.
 *
 * @author JHR, ELO Digital Office GmbH
 * @version 1.0
 *
 * @eloix
 * @requires sol.common.Config
 * @requires sol.common.Map
 * @requires sol.common.RepoUtils
 */
sol.define("sol.dev.ix.ActionUtils", {
  singleton: true,

  /**
   * Starts the workflow defined in the configuration: `dev.requestWorkflows.createAction.workflowTemplateName`
   * @param {String} objId The objId on which the workflow should be started
   * @param {String} wfName The Name of the new workflow
   * @return {String} The flowId of the new workflow
   */
  startCreateActionWorkflow: function (objId, wfName) {
    var me = this;
    me.loadConfig();
    return ixConnect.ix().startWorkFlow(me.config.dev.requestWorkflows.createAction.workflowTemplateName, wfName, objId);
  },

  /**
   * Loads the configuration from the JSON dev: `/Administration/Business Solutions/development_internal/Configuration/dev.config`
   * @return {Object}
   */
  loadConfigDev: function () {
    var me = this;
    me.config = sol.create("sol.common.Config", { compose: "/development/Configuration/dev.config" }).config;
    return me.config;
  },

  /**
   * Loads the configuration from the JSON dev: `/Administration/Business Solutions/development_internal/Configuration/dev.config`
   * @return {Object}
   */
  loadConfigDevInternal: function () {
    var me = this;
    me.config = sol.create("sol.common.Config", { compose: "/development_internal/Configuration/dev_internal.config" }).config;
    return me.config;
  },

  /**
   * Sets the logger object from using class
   * @param {Object} classLogger
   */
  setLogger: function (classLogger) {
    var me = this;

    me.logger = classLogger;
  },

  /**
   * Sets the logger object from using class
   * @param {String} classObjId
   */
  setObjId: function (classObjId) {
    var me = this;

    me.objId = classObjId;
  },

  /**
   * Checks, if an de.elo.ix.client.Sord is from type JSON-Configuration
   * @param {de.elo.ix.client.Sord} sord
   * @return {Boolean}
   */
  isJsonConfig: function (sord) {
    var myconfig;

    try {
      myconfig = sol.create("sol.common.Config", { load: sord.id }).config;
    } catch (ex) {
    }
    if (myconfig) {
      return true;
    }
    return false;
  },

  /**
   * Recursively merge properties of two objects
   * @param {Object} obj1 JSON-Configuration
   * @param {Object} obj2 JSON-Configuration
   * @return {Object} Merged JSON-Configuration
   */
  mergeRecursive: function (obj1, obj2) {
    var me = this,
        p;

    for (p in obj2) {
      try {
        // Property in destination object set; update its value.
        if (obj2[p].constructor == Object) {
          obj1[p] = me.mergeRecursive(obj1[p], obj2[p]);
        } else {
          obj1[p] = obj2[p];
        }
      } catch (e) {
        // Property in destination object not set; create it and set its value.
        obj1[p] = obj2[p];
      }
    }
    return obj1;
  },

  /**
   * @private
   * @param {String} objId
   * @return {Object}
   */
  getcomponentSord: function (objId) {
    var folderSord, packSord;

    folderSord = ixConnect.ix().checkoutSord(objId, EditInfoC.mbAll, LockC.NO).sord;
    packSord = ixConnect.ix().checkoutSord(folderSord.parentId, EditInfoC.mbAll, LockC.NO).sord;
    return packSord;
  },

  /**
   * @private
   * @param {Object} objSord
   * @return {Object}
   */
  getSolutionSord: function (objSord) {
    var me = this,
        solId, solSord;

    if (me.config.solPath) {
      solId = sol.common.RepoUtils.preparePath(me.config.solPath, { data: objSord });
      solSord = ixConnect.ix().checkoutSord(solId, EditInfoC.mbAll, LockC.NO).sord;
    }
    return solSord;
  },

  /**
   * @private
   * @param {Object} objSord
   */
  processComponent: function () {
    var me = this,
        objSord, tempSord, tempconf, map, i, j,
        folder, mode, type, wftemplate, references,
        sordfs, sordf, sordps, sordp, solId, targetId;

    objSord = ixConnect.ix().checkoutSord(me.objId, EditInfoC.mbAll, LockC.NO).sord;
    tempSord = sol.common.SordUtils.getTemplateSord(objSord);

    targetId = sol.common.RepoUtils.preparePath(me.config.newComponentPath, { data: objSord });
    me.moveSord(me.objId, targetId);

    tempconf = me.loadTemplateConfig(me.objId);

    if (tempconf.mapfields) {
      map = sol.create("sol.common.Map", {
        objId: me.objId
      });
      map.read();
      for (i = 0; i < tempconf.mapfields.length; i++) {
        map.setValue(tempconf.mapfields[i].key, tempconf.mapfields[i].value);
      }
      map.write();
    }
    objSord = ixConnect.ix().checkoutSord(me.objId, EditInfoC.mbAll, LockC.NO).sord;
    tempSord = sol.common.SordUtils.getTemplateSord(objSord);

    if (tempconf.jobs) {
      for (i = 0; i < tempconf.jobs.length; i++) {
        folder = tempconf.jobs[i].folder;
        mode = tempconf.jobs[i].mode;
        type = tempconf.jobs[i].type;
        wftemplate = tempconf.jobs[i].wftemplate;
        references = tempconf.jobs[i].references;
        if (folder) {
          me.generateEntry(me.objId, tempSord, folder, mode, type, references);
          me.logger.info(["generate component folder {0} sord (objId={1}): ", folder, me.objId]);
        }
        if (wftemplate) {
          me.generateWfTemplate(tempSord, wftemplate, type);
          me.logger.info(["generate wftemplate {0}): ", wftemplate]);
        }
      }
    }

    sordfs = sol.common.RepoUtils.findChildren(me.objId, { recursive: false, level: 1, includeDocuments: false, includeFolders: true, includeReferences: false });
    for (i = 0; i < sordfs.length; i++) {
      sordf = sordfs[i];

      // Move Business Solutions
      if (sordf.name == "Business Solutions") {
        sordps = sol.common.RepoUtils.findChildren(sordf.id, { recursive: false, level: 1, includeDocuments: false, includeFolders: true, includeReferences: false });
        for (j = 0; j < sordps.length; j++) {
          sordp = sordps[j];
          solId = sol.common.RepoUtils.preparePath(me.config.solutionFolderPath);
          me.moveSord(sordp.id, solId);
        }
      }
      // Move Business Solutions Custom
      if (sordf.name == "Business Solutions Custom") {
        sordps = sol.common.RepoUtils.findChildren(sordf.id, { recursive: false, level: 1, includeDocuments: false, includeFolders: true, includeReferences: false });
        for (j = 0; j < sordps.length; j++) {
          sordp = sordps[j];
          solId = sol.common.RepoUtils.preparePath(me.config.customSolutionFolderPath);
          me.moveSord(sordp.id, solId);
        }
      }
    }
  },

  /**
   * @private
   * @return {Object}
   */
  loadTemplateConfig: function () {
    var me = this,
        sord, sords, i, tempconf;

    sords = sol.common.RepoUtils.findChildren(me.objId, { recursive: true, level: 2, includeDocuments: true, includeFolders: false, includeReferences: false });
    for (i = 0; i < sords.length; i++) {
      sord = sords[i];
      if (sord.name == "template.config") {
        tempconf = sol.create("sol.common.Config", { load: sord.id }).config;
      }
    }
    return tempconf;
  },

  /**
   * @private
   * @param {Object} objSord
   * @param {Object[]} references
   */
  generateReferences: function (objSord, references) {
    var me = this,
        searchConfig = {},
        packSord, i, j, reference,
        folderFromId, folderToId,
        sordfs, sordf;

    packSord = me.getSolutionSord(objSord);

    for (i = 0; i < references.length; i++) {
      reference = references[i];
      if (reference.from) {
        folderFromId = me.getSubFolderId(packSord.id, reference.from);
        if (reference.to) {
          folderToId = sol.common.RepoUtils.preparePath(reference.to);
          searchConfig = {};
          if (reference.document) {
            searchConfig.includeDocuments = true;
          }
          if (reference.folder) {
            searchConfig.includeFolders = true;
          }
          searchConfig.recursive = true;
          searchConfig.level = -1;
          searchConfig.includeReferences = false;

          sordfs = sol.common.RepoUtils.findChildren(folderFromId, searchConfig);
          for (j = 0; j < sordfs.length; j++) {
            sordf = sordfs[j];
            ixConnect.ix().refSord("", folderToId, sordf.id, -1);
          }
        }
      }
    }
  },

  /**
   * @private
   * @param {Object} tempSord
   * @param {Object} wftemplate
   * @param {String} type
   */
  generateWfTemplate: function (tempSord, wftemplate, type) {
    var me = this,
        tpl, wfName;

    if (type == "CREATEWFTEMPLATE") {
      tpl = sol.create("sol.common.Template", { source: wftemplate });
      wfName = tpl.apply(tempSord);
      me.createWorkflowTemplate(wfName);
    }
  },

  /**
   * @private
   * @param {String} objId
   * @param {Object} tempSord
   * @param {Object} folder
   * @param {String} mode
   * @param {String} type
   * @param {Object[]} references
   */
  generateEntry: function (objId, tempSord, folder, mode, type, references) {
    var me = this,
        folderId, sordf, sordfs, i,
        packSord, targetId, objSord,
        oldDocuments, oldFolderId;

    oldDocuments = me.getOldDocuments(objId, folder, type);
    folderId = me.getSubFolderId(objId, folder);
    sordfs = sol.common.RepoUtils.findChildren(folderId, { recursive: true, level: -1, includeDocuments: true, includeFolders: true, includeReferences: false });
    if (mode == "SINGLE") {
      // delete all Subfolder
      for (i = 0; i < sordfs.length; i++) {
        sordf = sordfs[i];
        if (sol.common.SordUtils.isFolder(sordf)) {
          sol.common.RepoUtils.deleteSord(sordf.id);
        }
      }
      sordfs = sol.common.RepoUtils.findChildren(folderId, { recursive: true, level: -1, includeDocuments: true, includeFolders: true, includeReferences: false });
    }
    for (i = 0; i < sordfs.length; i++) {
      sordf = sordfs[i];
      sordf = me.generateSordNameDesc(tempSord, sordf);
      oldDocuments = me.generateDocumentContent(tempSord, sordf, type, oldDocuments);
    }
    me.processOldDocuments(oldDocuments, folderId);
    objSord = ixConnect.ix().checkoutSord(me.objId, EditInfoC.mbAll, LockC.NO).sord;
    packSord = me.getSolutionSord(objSord);
    if (packSord) {
      targetId = packSord.id;
      if (type != "IMPORTWORKFLOW") {
        oldFolderId = me.getSubFolderId(targetId, folder);
        me.moveSord(folderId, targetId);
        if (oldFolderId) {
          sol.common.RepoUtils.deleteSord(oldFolderId);
        }
        if (references) {
          me.generateReferences(objSord, references);
          me.logger.info(["generate references {0}): ", references]);
        }
      }
    }
  },

  /**
   * @private
   * @param {Object} sordf
   * @param {String} wfName
   */
  importWorkflow: function (sordf, wfName) {
    var me = this,
        wfData, workflowImportOptions;

    wfName = me.createWorkflowName(wfName);
    workflowImportOptions = new WorkflowImportOptions();
    wfData = sol.common.RepoUtils.downloadToByteArray(sordf.id, null);
    ixConnect.ix().importWorkFlow2(wfName, wfData, workflowImportOptions);

  },

  /**
   * @private
   * @param {String} wfName
   * @return {Boolean}
   */
  existWorkflowTemplate: function (wfName) {
    var info, wfs;

    info = new FindWorkflowInfo();
    info.type = WFTypeC.TEMPLATE;
    info.name = wfName;

    wfs = sol.common.WfUtils.findWorkflows(info);
    if (wfs) {
      if (wfs.length > 0) {
        return true;
      }
    }
    return false;
  },

  /**
   * @private
   * @param {String} wfName
   * @return {String}
   */
  createWorkflowName: function (wfName) {
    var me = this,
        wfVersion, wfNameNew;

    // Check, if template already exists
    wfVersion = 1;
    if (me.existWorkflowTemplate(wfName)) {
      wfNameNew = wfName + "(" + wfVersion + ")";
      while (me.existWorkflowTemplate(wfNameNew)) {
        wfVersion++;
        wfNameNew = wfName + "(" + wfVersion + ")";
      }
      wfName = wfNameNew;
    }
    return wfName;
  },

  /**
   * @private
   * @param {String} wfName
   */
  createWorkflowTemplate: function (wfName) {
    var me = this,
        wf, wfNode, wfNodeAssoc, wfNodes, wfMatrixAssocs;

    wfName = me.createWorkflowName(wfName);

    // Initialize workflow object.
    wf = ixConnect.ix().createWorkFlow(wfName, WFTypeC.TEMPLATE);

    // ---- Create the workflow nodes -------

    // Create an array to store the workflow nodes
    wfNodes = [];

    // Create the start node
    wfNode = ixConnect.ix().createWFNode(0, WFNodeC.TYPE_BEGINNODE);
    wfNode.name = "Start node";
    wfNodes.push(wfNode);

    // Create the end node
    wfNode = ixConnect.ix().createWFNode(1, WFNodeC.TYPE_ENDNODE);
    wfNode.name = "Finish";
    wfNodes.push(wfNode);

    wf.nodes = wfNodes;

    // ---- Create the workflow node associations -------

    // Create matrix and array to hold the associations
    wf.matrix = new WFNodeMatrix();
    wfMatrixAssocs = [];

    // Connect start node to end node
    wfNodeAssoc = new WFNodeAssoc();
    wfNodeAssoc.nodeFrom = 0; // == wf.nodes[0].id;
    wfNodeAssoc.nodeTo = 1; // == wf.nodes[1].id;
    wfMatrixAssocs.push(wfNodeAssoc);

    wf.matrix.assocs = wfMatrixAssocs;


    // ---- Store the new workflow ---------------------
    wf.id = ixConnect.ix().checkinWorkFlow(wf, WFDiagramC.mbAll, LockC.NO);

  },

  /**
   * @private
   * @param {Object[]} oldDocuments
   * @param {String} folderId
   */
  processOldDocuments: function (oldDocuments, folderId) {
    var me = this,
        i, arcPath, actdefId, sordad,
        bytes, baos;

    if (oldDocuments) {
      for (i = 0; i < oldDocuments.length; i++) {
        if (!oldDocuments[i].processed) {
          if (oldDocuments[i].extension == "Action definitions") {
            arcPath = sol.common.RepoUtils.getPathFromObjId(folderId) + oldDocuments[i].relpath;
            actdefId = sol.common.RepoUtils.createPath(arcPath, { mask: "Action definition" });
            if (actdefId) {
              sordad = ixConnect.ix().checkoutSord(actdefId, EditInfoC.mbAll, LockC.NO).sord;
              sol.common.SordUtils.updateSord(sordad, [{ key: "name", type: "SORD", value: oldDocuments[i].name }]);
              sol.common.SordUtils.updateSord(sordad, [{ key: "desc", type: "SORD", value: oldDocuments[i].content }]);
              ixConnect.ix().checkinSord(sordad, SordC.mbAll, LockC.NO);
            }
          } else if (oldDocuments[i].extension == "Folder") {
            arcPath = sol.common.RepoUtils.getPathFromObjId(folderId) + oldDocuments[i].relpath;
            actdefId = sol.common.RepoUtils.createPath(arcPath, { mask: "Folder" });
            if (actdefId) {
              sordad = ixConnect.ix().checkoutSord(actdefId, EditInfoC.mbAll, LockC.NO).sord;
              sol.common.SordUtils.updateSord(sordad, [{ key: "name", type: "SORD", value: oldDocuments[i].name }]);
              sol.common.SordUtils.updateSord(sordad, [{ key: "desc", type: "SORD", value: oldDocuments[i].content }]);
              ixConnect.ix().checkinSord(sordad, SordC.mbAll, LockC.NO);
            }
          } else {
            arcPath = sol.common.RepoUtils.getPathFromObjId(folderId) + oldDocuments[i].relpath;
            if (me.isOfficeDocument(oldDocuments[i].extension)) {
              bytes = oldDocuments[i].content;
              baos = new java.io.ByteArrayOutputStream(bytes.length);
              baos.write(bytes, 0, bytes.length);
              sol.common.RepoUtils.saveToRepo({ repoPath: arcPath, outputStream: baos, extension: oldDocuments[i].extension, maskId: oldDocuments[i].mask, tryUpdate: true });
            } else {
              sol.common.RepoUtils.saveToRepo({ repoPath: arcPath, contentString: oldDocuments[i].content, extension: oldDocuments[i].extension, maskId: oldDocuments[i].mask, tryUpdate: true });
            }
          }
        }
      }
    }
  },

  /**
   * @private
   * @param {String} ext
   * @return {Boolean}
   */
  isOfficeDocument: function (ext) {
    var me = this,
        offDocs = me.config.officeDocuments, i;

    if (offDocs) {
      for (i = 0; i < offDocs.length; i++) {
        if (offDocs[i] == ext) {
          return true;
        }
      }
    }
    return false;
  },

  /**
   * @private
   * @param {String} objId
   * @param {Object} folder
   * @param {String} type
   * @return {Object}
   */
  getOldDocuments: function (objId, folder, type) {
    var me = this,
        oldDocuments = [],
        objSord, packSord, oldFolderId,
        sordfs, sordf, i, jsText, relPath;

    objSord = ixConnect.ix().checkoutSord(me.objId, EditInfoC.mbAll, LockC.NO).sord;
    packSord = me.getSolutionSord(objSord);
    if (packSord) {
      oldFolderId = me.getSubFolderId(packSord.id, folder);
    }
    if (oldFolderId) {
      sordfs = sol.common.RepoUtils.findChildren(oldFolderId, { recursive: true, level: -1, includeDocuments: true, includeFolders: true, includeReferences: false });
      for (i = 0; i < sordfs.length; i++) {
        sordf = sordfs[i];
        if (((type == "APPEND") && (sol.common.SordUtils.isDocument(sordf))) ||
             ((type == "INTEGRATE") && ((me.isJsonConfig(sordf)) || (sol.common.SordUtils.isDocument(sordf)))) ||
             ((type == "COPY") && (sol.common.SordUtils.isDocument(sordf)))) {
          if (me.isOfficeDocument(sordf.docVersion.ext)) {
            jsText = sol.common.RepoUtils.downloadToByteArray(sordf.id, null);
          } else {
            jsText = sol.common.RepoUtils.downloadToString(sordf.id, null);
          }
          relPath = me.getRelPath(oldFolderId, sordf.id);
          oldDocuments.push({ name: sordf.name, content: jsText, extension: sordf.docVersion.ext, relpath: relPath, mask: sordf.mask });
        } else if (folder == "Action definitions") {
          relPath = me.getRelPath(oldFolderId, sordf.id);
          oldDocuments.push({ name: sordf.name, content: sordf.desc, extension: "Action definitions", relpath: relPath, mask: sordf.mask });
        } else if (sol.common.SordUtils.isFolder(sordf)) {
          relPath = me.getRelPath(oldFolderId, sordf.id);
          oldDocuments.push({ name: sordf.name, content: sordf.desc, extension: "Folder", relpath: relPath, mask: sordf.mask });
        }
      }
    }
    return oldDocuments;
  },

  /**
   * @private
   * @param {String} parentId
   * @param {String} folderId
   * @return {String}
   */
  getRelPath: function (parentId, folderId) {
    var parentPath, folderPath, plen, relPath;

    parentPath = sol.common.RepoUtils.getPathFromObjId(parentId);
    folderPath = sol.common.RepoUtils.getPathFromObjId(folderId);

    plen = parentPath.length;
    relPath = folderPath.slice(plen);

    return relPath;
  },

  /**
   * @private
   * @param {Object} tempSord
   * @param {Object} sordf
   * @return {Object}
   */
  generateSordNameDesc: function (tempSord, sordf) {
    var tpl, jsText;

    sordf = ixConnect.ix().checkoutSord(sordf.id, EditInfoC.mbAll, LockC.NO).sord;
    tpl = sol.create("sol.common.Template", { source: sordf.name });
    jsText = tpl.apply(tempSord);
    if (jsText != "") {
      sol.common.SordUtils.updateSord(sordf, [{ key: "name", type: "SORD", value: jsText }]);
    }
    if (sordf.desc) {
      if (sordf.desc != "") {
        tpl = sol.create("sol.common.Template", { source: sordf.desc });
        jsText = tpl.apply(tempSord);
        if (jsText != "") {
          sol.common.SordUtils.updateSord(sordf, [{ key: "desc", type: "SORD", value: jsText }]);
        }
        ixConnect.ix().checkinSord(sordf, SordC.mbAll, LockC.YES);
      }
    }
    ixConnect.ix().checkinSord(sordf, SordC.mbAll, LockC.NO);
    return sordf;
  },

  /**
   * @private
   * @param {Object} tempSord
   * @param {Object} sordf
   * @param {String} type
   * @param {Object[]} oldDocuments
   * @return {Object[]}
   */
  generateDocumentContent: function (tempSord, sordf, type, oldDocuments) {
    var me = this,
        oldContent, i, tpl, jsText,
        bytes, baos, wfName;

    if (sol.common.SordUtils.isDocument(sordf)) {
      if ((type == "APPEND") || (type == "INTEGRATE")) {
        oldContent = "";
        if (oldDocuments) {
          for (i = 0; i < oldDocuments.length; i++) {
            if (oldDocuments[i].name == sordf.name) {
              oldContent = oldDocuments[i].content;
              oldDocuments[i].processed = true;
            }
          }
        }
      }

      if (me.isOfficeDocument(sordf.docVersion.ext) || (type == "IMPORTWORKFLOW")) {
        jsText = sol.common.RepoUtils.downloadToByteArray(sordf.id, null);
      } else {
        jsText = sol.common.RepoUtils.downloadToString(sordf.id, null);
        tpl = sol.create("sol.common.Template", { source: jsText });
        jsText = tpl.apply(tempSord);
      }

      if (type == "APPEND") {
        jsText = oldContent + jsText;
      }
      if ((type == "INTEGRATE") && (me.isJsonConfig(sordf))) {
        try {
          oldContent = JSON.parse(oldContent);
        } catch (ex1) {
          oldContent = {};
        }
        try {
          jsText = JSON.parse(jsText);
        } catch (ex2) {
          jsText = {};
        }
        jsText = me.mergeRecursive(oldContent, jsText);
        jsText = new java.lang.String(JSON.stringify(jsText, null, 2));
      }
      wfName = sordf.name;
      if (me.isOfficeDocument(sordf.docVersion.ext) || (type == "IMPORTWORKFLOW")) {
        bytes = jsText;
      } else {
        bytes = new java.lang.String(jsText).getBytes("UTF-8");  // Workaround to save without BOM
      }
      baos = new java.io.ByteArrayOutputStream(bytes.length);
      baos.write(bytes, 0, bytes.length);
      sol.common.RepoUtils.saveToRepo({ objId: sordf.id, outputStream: baos, extension: sordf.docVersion.ext, tryUpdate: true });
      if (type == "IMPORTWORKFLOW") {
        me.importWorkflow(sordf, wfName);
      }
    }
    return oldDocuments;
  },

  /**
   * @private
   * @param {String} parentId
   * @param {String} folder
   * @return {String}
   */
  getSubFolderId: function (parentId, folder) {
    var folderPath, folderId, sordfs, sordf, i;

    folderPath = sol.common.RepoUtils.getPathFromObjId(parentId) + "/" + folder;
    if (folderPath) {
      folderId = sol.common.RepoUtils.getObjId(folderPath);
      if (!folderId) {
        sordfs = sol.common.RepoUtils.findChildren(parentId, { recursive: false, level: 1, includeDocuments: false, includeFolders: true, includeReferences: false });
        for (i = 0; i < sordfs.length; i++) {
          sordf = sordfs[i];
          // Get folderId
          if (sordf.name == folder) {
            folderId = sordf.id;
          }
        }
      }
    }
    return folderId;
  },

  /**
   * @private
   * @param {String} objId
   * @param {String} targetId
   */
  moveSord: function (objId, targetId) {
    var me = this,
        sord = ixConnect.ix().checkoutSord(objId, EditInfoC.mbSord, LockC.NO).sord,
        oldParentId = sord.parentId,
        newParentId;

    if (targetId == "0") {
      newParentId = "0";
    } else {
      newParentId = ixConnect.ix().checkoutSord(targetId, EditInfoC.mbOnlyId, LockC.NO).sord.id; // make sure, newParentId is a number (targetId might be an arcpath)
    }

    me.logger.info(["move sord (objId={0}, name={1}): {2} -> {3}", objId, sord.name, oldParentId, newParentId]);
    ixConnect.ix().refSord(oldParentId, newParentId, objId, -1);
  },
  /**
   * @private
   * @param {String} templateId
   * @return {Object}
   */
  existPathFullNameSpace: function (templateId) {
    var me = this,
        map, fullNameSpace, path1, path2, obj1Id, obj2Id;

    map = sol.create("sol.common.SordMap", {
      objId: templateId
    });
    map.read();
    fullNameSpace = map.getValue("FULLNAMESPACE");
    if ((!fullNameSpace) || (fullNameSpace == "")) {
      fullNameSpace = map.getValue("NAMESPACE") + "." + map.getValue("PACKAGE");
    }

    path1 = me.config.solutionFolderPath + "/" + fullNameSpace;
    path2 = me.config.customSolutionFolderPath + "/" + fullNameSpace;

    obj1Id = sol.common.RepoUtils.getObjId(path1);
    obj2Id = sol.common.RepoUtils.getObjId(path2);

    return (obj1Id && obj2Id);

  }

});