src/backend/common.js - dev - weylin/WtDev

src/backend/common.js
1 420 строк30 KB
Weylin
Исправлено скачивание xml удаленных действий
01 июл 2025, 15:16
01 июл 2025, 15:16476bacd
/*#wtdevsync{
	"type": "elem",
	"elem": "custom_web_template",
	"code": "wtdev_common",
	"encloseInAspTags": true
}#*/

/* eslint-disable no-throw-literal */
/* eslint-disable eqeqeq */

function alertExecTime(label, tempObj) {
  if (tempObj.HasProperty("disabled") && tempObj.disabled) {
    return true;
  }

  var curTicks = GetCurTicks();

  if (
    !tempObj.HasProperty("startExecTime") ||
    tempObj.startExecTime == undefined
  ) {
    tempObj.startExecTime = curTicks;
  }

  var execTime = Real(curTicks - tempObj.startExecTime) / 1000;
  alert(label + ": " + execTime + " sec.");

  tempObj.startExecTime = curTicks;
}

function getExecTime(tempObj) {
  if (tempObj.HasProperty("disabled") && tempObj.disabled) {
    return false;
  }

  var curTicks = GetCurTicks();

  if (
    !tempObj.HasProperty("startExecTime") ||
    tempObj.startExecTime == undefined
  ) {
    tempObj.startExecTime = curTicks;
  }

  var execTime = Real(curTicks - tempObj.startExecTime) / 1000;

  tempObj.startExecTime = curTicks;

  return execTime;
}

function decodeJsonOpt(jsonStr, defaultVal) {
  try {
    return DecodeJson(jsonStr);
  } catch (e) {
    return defaultVal;
  }
}

function getQueryValText(name, defaultVal) {
  if (defaultVal == undefined) {
    defaultVal = "";
  }

  var _value = Request.Query.GetOptProperty(name, defaultVal);
  return _value;
}

function getQueryValInt(name, defaultVal) {
  if (defaultVal == undefined) {
    defaultVal = 0;
  }

  try {
    var _value = Request.Query.GetOptProperty(name, defaultVal);
    return Int(_value);
  } catch (e) {
    return defaultVal;
  }
}

function getQueryValBool(name, defaultVal) {
  return tools_web.is_true(getQueryValText(name, defaultVal));
}

function getFormValText(name, defaultVal) {
  if (defaultVal == undefined) {
    defaultVal = "";
  }

  var _value = Request.Form.GetOptProperty(name, defaultVal);
  return _value;
}

function getFormValTextArray(name, delimiter, defaultVal) {
  if (delimiter == undefined) {
    throw "Delimiter not defined";
  }

  var _value = Trim(getFormValText(name, defaultVal));

  var resultArray = [];

  if (_value != "") {
    resultArray = _value.split(delimiter);
  }

  return resultArray;
}

function getFormValIntArray(name, delimiter, defaultVal) {
  var textArray = getFormValTextArray(name, delimiter, defaultVal);

  return ArrayExtract(textArray, "OptInt(This)");
}

function getFormValDate(name, defaultVal) {
  var _value = getFormValText(name, "");

  if (_value == "") {
    return defaultVal;
  }

  try {
    _value = ParseDate(_value);
  } catch (e) {
    return defaultVal;
  }

  return _value;
}

function getFormValInt(name, defaultVal) {
  if (defaultVal == undefined) {
    defaultVal = 0;
  }

  try {
    var _value = Request.Form.GetOptProperty(name, defaultVal);
    return Int(_value);
  } catch (e) {
    return defaultVal;
  }
}

function getFormValJson(name, defaultVal) {
  var _value = decodeJsonOpt(getFormValText(name), defaultVal);
  return _value;
}

function getFormValFile(name, defaultVal) {
  var formFile = Request.Form.GetOptProperty(name);

  if (formFile == undefined || formFile == "undefined") {
    return defaultVal;
  } else {
    return formFile;
  }
}

function setCustomElemVal(teObj, customElemName, newValue) {
  if (DataType(customElemName) != "string") {
    throw "customElemName must be string";
  }

  teObj.custom_elems.ObtainChildByKey(customElemName).value = newValue;
}

function setCustomElemVals(teObj, oData) {
  if (DataType(oData) != "object" || IsArray(oData)) {
    throw "data must be object";
  }

  for (key in oData) {
    teObj.custom_elems.ObtainChildByKey(key).value = oData[key];
  }
}

function copyCustomFields(teSource, teTarget, customElemCodes) {
  for (customElemCode in customElemCodes) {
    setCustomElemVal(
      teTarget,
      customElemCode,
      getCustomElemVal(teSource, customElemCode)
    );
  }
}

function getCustomElemVal(teObj, customElemName, defaultVal) {
  if (defaultVal == undefined) {
    defaultVal = "";
  }

  var customElem;
  customElem = teObj.custom_elems.GetOptChildByKey(customElemName);

  if (customElem != undefined) {
    return customElem.value;
  } else {
    return defaultVal;
  }
}

function getCustomElemInt(teObj, customElemName, defaultVal) {
  return OptInt(
    getCustomElemVal(teObj, customElemName, defaultVal),
    defaultVal
  );
}

function getCustomElemBool(teObj, customElemName, defaultVal) {
  return tools_web.is_true(getCustomElemVal(teObj, customElemName, defaultVal));
}

function getCustomElemDate(teObj, customElemName, defaultVal) {
  try {
    return Date(getCustomElemVal(teObj, customElemName, ""));
  } catch (e) {
    return defaultVal;
  }
}

function getCustomElemJson(teObj, customElemName, defaultVal) {
  return decodeJsonOpt(getCustomElemVal(teObj, customElemName, ""), defaultVal);
}

function getCustomFieldVal(teObj, customFieldName, defaultVal) {
  if (defaultVal == undefined) {
    defaultVal = "";
  }

  var customField;
  customField = teObj.custom_fields.GetOptChildByKey(customFieldName);

  if (customField != undefined) {
    return customField.value;
  } else {
    return defaultVal;
  }
}

function getCustomFieldInt(teObj, customFieldName, defaultVal) {
  return OptInt(
    getCustomFieldVal(teObj, customFieldName, defaultVal),
    defaultVal
  );
}

function getCustomFieldBool(teObj, customFieldName, defaultVal) {
  return tools_web.is_true(
    getCustomFieldVal(teObj, customFieldName, defaultVal)
  );
}

function getCustomFieldDate(teObj, customFieldName, defaultVal) {
  try {
    return Date(getCustomFieldVal(teObj, customFieldName, ""));
  } catch (e) {
    return defaultVal;
  }
}

function getCustomFieldJSON(teObj, customFieldName, defaultVal) {
  return decodeJsonOpt(
    getCustomFieldVal(teObj, customFieldName, ""),
    defaultVal
  );
}

function out(text) {
  Response.Write(text);
}

function outAsJson(obj) {
  Response.Write(EncodeJson(obj));
}

function outbr(text) {
  Response.Write(text + "<br>\n");
}

function bool(val, defaultVal) {
  if (val == undefined && defaultVal != undefined) {
    return defaultVal;
  }

  return tools_web.is_true(val);
}

function translate(str, dict, defaultVal) {
  if (dict.HasProperty(str)) {
    return dict.GetProperty(str);
  } else {
    return defaultVal;
  }
}

function translateBack(str, dict, defaultVal) {
  for (key in dict) {
    if (dict[key] == str) {
      return key;
    }
  }

  return defaultVal;
}

function safeXQuery(XQString) {
  XQString = StrReplace(XQString, "return $elem", " return $elem");

  return tools.xquery(XQString);
}

// deprecated
function dropApplicationCache(appName) {
  var teApp = tools_app.get_application(appName);
  tools_app.get_cur_application(teApp.id);
  tools_app.clear_application_cache();
}

function regExpTest(pattern, str) {
  var regExp = tools_web.reg_exp_init();
  regExp.Global = true;
  regExp.Pattern = pattern;
  regExp.MultiLine = true;

  var matches = regExp.Execute(str);

  //alert('matches'+EncodeJson(matches));
  //alert('matches.Count: '+matches.Count);
  //alert('pattern: '+pattern);
  //alert('str: '+str);

  return matches.Count > 0;
}

function regExpReplace(pattern, str, replaceStr, options) {
  options = setDefaultOptions(options, {
    ignoreCase: false,
  });

  var regExp = tools_web.reg_exp_init();
  regExp.Global = true;
  regExp.Pattern = pattern;
  regExp.MultiLine = true;
  regExp.IgnoreCase = options.ignoreCase;

  return regExp.Replace(str, replaceStr);
}

function dateOpt(str, defaultVal) {
  try {
    return Date(str);
  } catch (e) {
    return defaultVal;
  }
}

function parseDateOpt(str, defaultVal) {
  try {
    return ParseDate(str);
  } catch (e) {
    return defaultVal;
  }
}

function strDateOpt(date, showTime, showSeconds, defaultVal) {
  try {
    return StrDate(date, showTime, showSeconds);
  } catch (e) {
    return defaultVal;
  }
}

function getDaysInMonth(month, year) {
  return month === 2
    ? (year & 3) > 0 || (year % 25 == 0 && (year & 15) > 0)
      ? 28
      : 29
    : 30 + ((month + (month >> 3)) & 1);
}

function shiftDateMonths(date, months) {
  months = Int(months);

  var dateYear = Year(date);
  var dateMonth = Month(date);
  var dateDay = Day(date);

  var years = Int(months / 12);

  var restMonths = months - years * 12;

  dateYear += years;
  dateMonth += restMonths;

  if (dateMonth > 12) {
    dateMonth -= 12;
    dateYear++;
  }

  var daysInMonth = getDaysInMonth(dateMonth, dateYear);

  if (dateDay > daysInMonth) {
    dateMonth++;
    dateDay -= daysInMonth;
  }

  if (dateMonth > 12) {
    dateMonth -= 12;
    dateYear++;
  }

  return Date(dateYear, dateMonth, dateDay);
}

function deleteOptDoc(docID, checkExisting) {
  try {
    if (checkExisting == undefined) {
      checkExisting = false;
    }

    if (checkExisting) {
      var doc = tools.open_doc(docID);

      if (doc == undefined) {
        return false;
      }
    }

    DeleteDoc(UrlFromDocID(Int(docID)));
    return true;
  } catch (e) {
    alert("deleteOptDoc error: " + e);
    return false;
  }
}

function openDocElemID(docElemOrID, dbgStr) {
  //if (IsEmptyValue(docElemOrID)) # FIXME
  //	return undefined;

  var docElem;

  if (OptInt(docElemOrID, 0) > 0) {
    if (dbgStr) {
      alert("openDocElemID " + dbgStr + ": id");
    }
    docElem = tools.open_doc(OptInt(docElemOrID));
  } else if (ObjectType(docElemOrID) == "XmElem") {
    if (dbgStr) {
      alert("openDocElemID " + dbgStr + ": doc");
    }
    docElem = docElemOrID;
  } else {
    return undefined;
  }

  return docElem;
}

function cloneObject(source) {
  return DecodeJson(EncodeJson(source));
}

function setDefaultOptions(options, defaultOptions) {
  if (options == undefined) {
    options = {};
  }

  for (key in defaultOptions) {
    if (!options.HasProperty(key) || options.GetOptProperty(key) == undefined) {
      options.SetProperty(key, defaultOptions[key]);
    }
  }

  return options;
}

function defineObjectFields(obj, fields) {
  if (obj == undefined) {
    throw "object not defined";
  }

  var field;
  var missingRequiredFields = [];
  var unknownFields = [];

  for (fieldKey in fields) {
    field = setDefaultOptions(fields[fieldKey], {
      required: false,
      defaultVal: undefined,
    });

    if (!obj.HasProperty(fieldKey)) {
      if (field.required) {
        missingRequiredFields.push(fieldKey);
      } else {
        obj.SetProperty(fieldKey, field.defaultVal);
      }
    }
  }

  if (missingRequiredFields.length > 0) {
    throw "Required fields not defined: " + missingRequiredFields.join(", ");
  }

  for (objKey in obj) {
    if (!fields.HasProperty(objKey)) {
      unknownFields.push(objKey);
    }
  }

  if (unknownFields.length > 0) {
    throw "Unknown fields: " + unknownFields.join(", ");
  }

  return obj;
}

function inArray(haystack, needles) {
  if (!IsArray(needles)) {
    needles = [needles];
  }

  var needle;

  for (needle in needles) {
    if (ArrayOptFind(haystack, "This == needle") != undefined) {
      return true;
    }
  }

  return false;
}

function arrayUnionFast(array1, array2) {
  for (elem in array2) {
    array1.push(elem);
  }

  return array1;
}

function arrayMap(elems, evalStr) {
  var This, result;
  for (i = 0; i < ArrayCount(elems); i++) {
    This = elems[i];
    result = tools.safe_execution(evalStr);

    if (DataType(This) != "object") {
      elems[i] = result;
    }
  }
  return elems;
}

function arraySubtract(
  arrayMinuend,
  arraySubtrahend,
  fieldMinuend,
  fieldSubtrahend
) {
  if (fieldMinuend == undefined) {
    fieldMinuend = "This";
  }

  if (fieldSubtrahend == undefined) {
    fieldSubtrahend = fieldMinuend;
  }

  var arrayCond =
    'ArrayOptFind(arraySubtrahend, "' +
    fieldSubtrahend +
    ' == "+CodeLiteral(' +
    fieldMinuend +
    ")) == undefined";

  var arrayResult = ArraySelect(arrayMinuend, arrayCond);

  return arrayResult;
}

function arrayOptLastElem(array) {
  if (IsArray(array)) {
    return ArrayCount(array) > 0 ? array[ArrayCount(array) - 1] : undefined;
  } else {
    return undefined;
  }
}

function popRandomArrayElem(array) {
  var elemCount = ArrayCount(array);
  if (elemCount == 0) {
    return false;
  }

  var randomElemIndex = Random(0, elemCount - 1);
  var randomArrayElem = array[randomElemIndex];
  array.splice(randomElemIndex, 1);

  return randomArrayElem;
}

function getRandomArrayElem(array, selectCond) {
  var elemCount = ArrayCount(array);
  if (elemCount == 0) {
    return undefined;
  }

  if (selectCond != undefined) {
    array = ArraySelect(array, selectCond);
  }

  var randomElemIndex = Random(0, elemCount - 1);
  return array[randomElemIndex];
}

function getCellValue(oWorkSheet, rowNum, columnNum, defaultVal) {
  var oCell = oWorkSheet.Cells.GetCell(getCellName(rowNum, columnNum));

  if (oCell.Value != undefined) {
    return oCell.Value;
  } else {
    return defaultVal;
  }
}

function getCellName(rowNum, columnNum) {
  if (columnNum < 0 || rowNum < 0) {
    return "";
  }

  var columnLetterCodes = [];

  var lettersInAlphabet = Real(26);
  var columnNumRem = columnNum;

  while (columnNumRem >= lettersInAlphabet) {
    columnLetterCodes.push(columnNumRem % lettersInAlphabet);
    columnNumRem = Int(columnNumRem / lettersInAlphabet) - 1;
  }
  columnLetterCodes.push(columnNumRem);

  var columnLetter = "";

  for (letterCode in columnLetterCodes) {
    columnLetter = String.fromCharCode(65 + letterCode) + columnLetter;
  }

  return columnLetter + (rowNum + 1);
}

function obtainDocByKey(catalog, keyValPairs, options) {
  options = setDefaultOptions(options, {
    saveNewDoc: true,
    debug: false,
  });

  var xElem = getElemByKey(catalog, keyValPairs);

  var docElem;

  if (xElem == undefined) {
    docElem = tools.new_doc_by_name(catalog);
    docElem.BindToDb(DefaultDb);

    for (key in keyValPairs) {
      if (key == "app_instance_id") {
        docElem.TopElem.doc_info.creation.app_instance_id = keyValPairs[key];
      } else {
        docElem.TopElem.Child(key).Value = keyValPairs[key];
      }
    }

    if (options.saveNewDoc) {
      docElem.Save();
    }
  } else {
    docElem = tools.open_doc(xElem.id);
  }

  return docElem;
}

function existsElemByKey(catalog, keyValPairs, options) {
  return getElemIDByKey(catalog, keyValPairs, options) != undefined;
}

function getElemByKey(catalog, keyValPairs, options) {
  var xElems = getElemsByKey(catalog, keyValPairs, options);

  return ArrayOptFirstElem(xElems);
}

function getElemIDByKey(catalog, keyValPairs, options) {
  return ArrayOptFirstElem(getElemIDsByKey(catalog, keyValPairs, options));
}

function getElemIDsByKey(catalog, keyValPairs, options) {
  options = setDefaultOptions(options, {
    fields: ["id"],
  });

  var xElems = getElemsByKey(catalog, keyValPairs, options);

  return ArrayExtract(xElems, "id");
}

function getElemsByKey(catalog, keyValPairs, options) {
  options = setDefaultOptions(options, {
    debug: false,
    fields: undefined,
  });

  var XQString;

  try {
    var XQFilters = [];
    var val, valVarians;

    for (key in keyValPairs) {
      val = keyValPairs[key];

      if (IsArray(val)) {
        if (ArrayCount(val) == 0) {
          return [];
        }

        valVarians = [];

        for (valVariant in val) {
          valVarians.push("$elem/" + key + " = " + XQueryLiteral(valVariant));
        }

        XQFilters.push("(" + valVarians.join(" or ") + ")");
      } else {
        XQFilters.push("$elem/" + key + " = " + XQueryLiteral(val));
      }
    }

    var XQFiltersStr = XQFilters.join(" and ");

    var XQReturnStr;

    if (options.fields != undefined && IsArray(options.fields)) {
      XQReturnStr = ArrayMerge(options.fields, "'$elem/'+This", ", ");
    } else {
      XQReturnStr = "$elem";
    }

    XQString =
      "for $elem in " +
      catalog +
      "s where " +
      XQFiltersStr +
      " return " +
      XQReturnStr;

    if (options.debug) {
      alert(XQString);
    }

    //if (options.fields != undefined && IsArray(options.fields))
    //	alert(XQString);

    var result = ArraySelectAll(tools.xquery(XQString));
    return result;
  } catch (e) {
    //alert("getElemsByKey ERROR: "+e);
    alert("XQString: " + XQString);

    throw e;
    //return [];
  }
}

var CACHED_ELEMs_BY_CODE = [];

function getCachedElemIDByCode(catalog, code, options) {
  options = setDefaultOptions(options, {
    errorMessageWhenNotFound: undefined,
  });

  var elemID;

  var cachedElem = ArrayOptFind(
    CACHED_ELEMs_BY_CODE,
    "This.catalog == catalog && This.code == code"
  );

  if (cachedElem != undefined) {
    elemID = cachedElem.id;
  } else {
    elemID = getElemIDByKey(catalog, { code: code });

    if (elemID == undefined && options.errorMessageWhenNotFound != undefined) {
      throw options.errorMessageWhenNotFound;
    }

    CACHED_ELEMs_BY_CODE.push({
      catalog: catalog,
      code: code,
      id: elemID,
    });
  }

  return elemID;
}

function getArrayXElemField(elemID, xElems, field, defaultVal) {
  elemID = OptInt(elemID);
  var xElem = ArrayOptFind(xElems, "This.id == elemID");

  if (xElem == undefined) {
    return defaultVal;
  }

  return xElem.Child(field).Value;
}

function updateSdFields(teElem_Target, fields) {
  var docElem, xmlElem;

  for (field in fields) {
    //tools.common_filling('collaborator', teElem.Child(field.name).sd, field.elemID, field.GetOptProperty('teElem') );

    xmlElem = undefined;

    if (field.HasProperty("teElem")) {
      xmlElem = field.teElem;
    } else {
      if (tools_web.is_true(field.GetOptProperty("useForeignElem"))) {
        xmlElem = field.elemID.OptForeignElem;
      } else {
        docElem = tools.open_doc(field.elemID);
        xmlElem = docElem.TopElem;
      }
    }

    if (xmlElem == undefined) {
      continue;
    }

    fldSD = teElem_Target.Child(field.name).sd;

    fldSD.fullname = xmlElem.fullname;
    fldSD.position_name = xmlElem.position_name;
    fldSD.position_id = xmlElem.position_id;
    fldSD.org_name = xmlElem.org_name;
    fldSD.is_dismiss = xmlElem.is_dismiss;
  }
}

function copySdFields(teSource, teTarget, fieldNames) {
  for (fieldName in fieldNames) {
    teTarget.Child(fieldName).sd.AssignElem(teSource.Child(fieldName).sd);
  }
}

function strReduceEllipsis(text, notLongerThanCharsNum) {
  var shortText = StrReduce(text, notLongerThanCharsNum);

  if (StrCharCount(text) > StrCharCount(shortText)) {
    shortText += "...";
  }

  return shortText;
}

function strReduce(text, notLongerThanCharsNum) {
  var words = String(text).split(" ");

  var shortTextWords = [];

  for (word in words) {
    shortTextWords.push(word);

    if (StrCharCount(shortTextWords.join(" ")) > notLongerThanCharsNum) {
      lastButOneWordIndex = ArrayCount(shortTextWords) - 2;

      if (lastButOneWordIndex > 0) {
        shortTextWords = ArrayRange(shortTextWords, 0, lastButOneWordIndex);
      }

      break;
    }
  }

  return shortTextWords.join(" ");
}

function int2hex(intVal) {
  return "0x" + StrHexInt(intVal, 16);
}

function setWVar(docElem, wvarName, wvarValue, wvarType) {
  var wvar = docElem.TopElem.wvars.GetOptChildByKey(wvarName);

  var wvarIsNew = wvar == undefined;

  if (wvarIsNew) {
    wvar = docElem.TopElem.wvars.ObtainChildByKey(wvarName);
  }

  if (wvarType != undefined) {
    wvar.type = wvarType;
  } else if (wvarIsNew) {
    wvar.type = "string";
  }

  wvar.value = wvarValue;

  return true;
}

CACHED_BOSS_TYPES_BY_OPERATIONS = {};

function getBossTypesByOperationCode(operationCode) {
  var isOperationCached =
    CACHED_BOSS_TYPES_BY_OPERATIONS.HasProperty(operationCode);

  if (!isOperationCached) {
    CACHED_BOSS_TYPES_BY_OPERATIONS[operationCode] = [];

    var operationID = getElemIDByKey("operation", { code: operationCode });

    if (operationID != undefined) {
      var xBossTypes = getBossTypesByOperationID(operationID);

      CACHED_BOSS_TYPES_BY_OPERATIONS[operationCode] = xBossTypes;
    }
  }

  return CACHED_BOSS_TYPES_BY_OPERATIONS[operationCode];
}

function getBossTypesByOperationID(operationID) {
  var xBossTypes = ArraySelectAll(
    XQuery(
      " \
		for $elem in boss_types \
		where \
			contains($elem/operations, " +
        XQueryLiteral(operationID + "") +
        ") \
		return $elem \
	"
    )
  );

  return xBossTypes;
}

function getSubdivIDsWithChildren(_subdivIDs) {
  var result = [];
  var subdivIDs, subdivID;

  if (!IsArray(_subdivIDs)) {
    subdivIDs = [_subdivIDs];
  } else {
    subdivIDs = _subdivIDs;
  }

  for (subdivID in subdivIDs) {
    result = ArrayUnion(
      result,
      ArrayExtract(getSubdivHierarchyXQ(OptInt(subdivID)), "This.id")
    );
  }

  return result;
}

function getSubdivIDsWithParents(subdivIDs, cached) {
  var result = [];

  if (!IsArray(subdivIDs)) {
    subdivIDs = [subdivIDs];
  }

  for (subdivID in subdivIDs) {
    result = ArrayUnion(
      result,
      ArrayExtract(getSubdivWithParents(OptInt(subdivID), cached), "This.id")
    );
  }

  return result;
}

var getSubdivWithParents_CACHED_xSUBDIVS;

function getSubdivWithParents(subdivID, auxResultFields) {
  var xSubdiv;

  var cached = true;

  if (cached) {
    if (getSubdivWithParents_CACHED_xSUBDIVS == undefined) {
      var resultFields = ["id", "parent_object_id"];

      if (auxResultFields != undefined) {
        resultFields = ArrayUnion(resultFields, auxResultFields);
      }

      var xqResultFieldsStr = ArrayMerge(resultFields, '"$elem/"+This', ", ");

      getSubdivWithParents_CACHED_xSUBDIVS = ArraySelectAll(
        safeXQuery(
          " \
				for $elem in subdivisions \
				order by \
					$elem/id \
				return " +
            xqResultFieldsStr +
            " \
			"
        )
      );
    }

    xSubdiv = ArrayOptFindBySortedKey(
      getSubdivWithParents_CACHED_xSUBDIVS,
      subdivID,
      "id"
    );
  } else {
    xSubdiv = getElemByID("subdivision", subdivID);
  }

  var upperSubdivs = [];

  if (xSubdiv == undefined || xSubdiv.id == 0) {
    return [];
  }

  if (xSubdiv.parent_object_id > 0) {
    upperSubdivs = getSubdivWithParents(xSubdiv.parent_object_id, cached);
  }

  return ArrayUnion(upperSubdivs, [xSubdiv]);
}

function getSubdivHierarchyXQ(subdivID) {
  var xSubdivs = XQuery(
    "for $elem in subdivisions where $elem/id = " + subdivID + " return $elem"
  );
  xSubdivs = ArrayUnion(
    xSubdivs,
    XQuery("CatalogHierSubset('subdivisions', " + subdivID + ")")
  );
  return xSubdivs;
}

function isCollInGroup(collID, groupCode) {
  var docGroup = tools.get_doc_by_key("group", "code", groupCode);

  if (docGroup == null) {
    return false;
  }

  var groupID = docGroup.DocID;

  var xGroupColl = ArrayOptFirstElem(
    XQuery(
      " \
		for $elem in group_collaborators \
		where \
			$elem/group_id = " +
        groupID +
        " \
			and $elem/collaborator_id = " +
        collID +
        " \
		return $elem \
	"
    )
  );

  return xGroupColl != undefined;
}

function addCustomExpert(tePlan, expertID, expertPersonType, responsible) {
  if (expertID == undefined) {
    return undefined;
  }

  var fldCustomExpert = ArrayOptFind(
    tePlan.custom_experts,
    " \
		This.person_id == OptInt(expertID) \
		&& (expertPersonType == undefined || This.person_type == OptInt(expertPersonType)) \
		&& (responsible == undefined || This.responsible == responsible) \
	"
  );

  if (fldCustomExpert == undefined) {
    fldCustomExpert = tePlan.custom_experts.AddChild();

    fldCustomExpert.person_id = expertID;
    fldCustomExpert.person_type = expertPersonType;

    if (responsible != undefined) {
      fldCustomExpert.responsible = responsible;
    }
  }

  return fldCustomExpert;
}

function removeCustomExpert(tePlan, expertID, expertPersonType, responsible) {
  var customExpertMatchs;

  for (fldCustomExpert in tePlan.custom_experts) {
    customExpertMatchs =
      fldCustomExpert.person_id == OptInt(expertID) &&
      (expertPersonType == undefined ||
        fldCustomExpert.person_type == OptInt(expertPersonType)) &&
      (responsible == undefined || fldCustomExpert.responsible == responsible);

    if (customExpertMatchs) {
      fldCustomExpert.Delete();
    }
  }

  return true;
}

function getFuncManagerID(docColl, xBossTypesOrOpCode, params) {
  params = setDefaultOptions(params, {
    searchInColl: false,
  });

  var funcManagerIDs = getFuncManagerIDs(docColl, xBossTypesOrOpCode, params);

  return ArrayOptFirstElem(funcManagerIDs);
}

function getFuncManagerIDs(docColl, xBossTypesOrOpCode, params) {
  params = setDefaultOptions(params, {
    searchInColl: false,
    searchInSubdivs: true,
    searchInOrg: true,
  });

  var xBossTypes = IsArray(xBossTypesOrOpCode)
    ? xBossTypesOrOpCode
    : getBossTypesByOperationCode(xBossTypesOrOpCode);
  var bossTypeIDs = ArrayMerge(xBossTypes, "This.id", ",");

  var subdivIDs = getSubdivIDsWithParents(
    OptInt(docColl.TopElem.position_parent_id)
  );

  //alert("subdivIDs: "+subdivIDs.join(', '));

  var xFuncManagers = [];
  var XQString;

  if (params.searchInColl) {
    xFuncManagers = ArrayUnion(
      xFuncManagers,
      ArraySelectAll(
        XQuery(
          " \
			for $elem in func_managers \
			where \
				$elem/catalog = 'collaborator' \
				and $elem/object_id = " +
            docColl.DocID +
            " \
				and MatchSome($elem/boss_type_id, (" +
            bossTypeIDs +
            ")) \
			return $elem \
		"
        )
      )
    );
  }

  if (params.searchInSubdivs) {
    for (
      i = ArrayCount(subdivIDs) - 1;
      i >= 0;
      i-- //for (i = 0; i < ArrayCount(subdivIDs); i++)
    ) {
      XQString =
        " \
				for $elem in func_managers \
				where \
					$elem/catalog = 'subdivision' \
					and $elem/object_id = " +
        subdivIDs[i] +
        " \
					and MatchSome($elem/boss_type_id, (" +
        bossTypeIDs +
        ")) \
				return $elem \
			";

      xFuncManagers = ArrayUnion(
        xFuncManagers,
        ArraySelectAll(XQuery(XQString))
      );

      //alert(UnifySpaces(XQString));
      //alert("ArrayCount(xFuncManagers): "+ArrayCount(xFuncManagers))
    }
  }

  if (params.searchInOrg) {
    xFuncManagers = ArrayUnion(
      xFuncManagers,
      ArraySelectAll(
        XQuery(
          " \
			for $elem in func_managers \
			where \
				$elem/catalog = 'org' \
				and $elem/object_id = " +
            docColl.TopElem.org_id +
            " \
				and MatchSome($elem/boss_type_id, (" +
            bossTypeIDs +
            ")) \
			return $elem \
		"
        )
      )
    );
  }

  var funcManagerIDs = ArrayExtract(xFuncManagers, "This.person_id");
  funcManagerIDs = ArraySelectDistinct(funcManagerIDs, "This");

  return funcManagerIDs;
}

function getNativeBossID(docCollID) {
  var collID;

  if (docCollID > 0) {
    collID = docCollID;
  } else {
    collID = docCollID.DocID;
  }

  //var xFuncManagers = tools.get_uni_user_bosses(docColl.DocID, {return_object_type: 'func_managers'} );
  var xFuncManagers = getCollMainFuncManagers(collID);

  var xFuncManager_firstSuitable;

  for (xFuncManager in xFuncManagers) {
    if (xFuncManager.person_id != collID) {
      xFuncManager_firstSuitable = xFuncManager;
      break;
    }
  }

  if (xFuncManager_firstSuitable != undefined) {
    return xFuncManager_firstSuitable.person_id;
  } else {
    return undefined;
  }
}

function getCollMainFuncManagers(collID, catalogNames) {
  var docColl = tools.open_doc(collID);
  if (docColl == undefined) {
    return [];
  }

  var mainBossTypeID = getElemIDByKey("boss_type", { code: "main" });

  var xFuncManagers_Result = [];

  var xFuncManagers = tools.get_uni_user_bosses(collID, {
    return_object_type: "func_managers",
  });

  xFuncManagers_Suitable = ArraySelect(
    xFuncManagers,
    "This.boss_type_id == mainBossTypeID"
  );

  if (catalogNames == undefined) {
    catalogNames = ["collaborator", "subdivision", "org"];
  }

  var xFuncManagers_inCatalog;

  for (catalogName in catalogNames) {
    xFuncManagers_inCatalog = ArraySelect(
      xFuncManagers_Suitable,
      "This.catalog == catalogName"
    );

    for (xFuncManager_inCatalog in xFuncManagers_inCatalog) {
      //if (ArrayOptFind(xFuncManagers_Result, "This.person_id == xFuncManager_inCatalog.person_id") != undefined)
      //	continue;

      xFuncManagers_Result.push(xFuncManager_inCatalog);
    }
  }

  return ArraySelectDistinct(xFuncManagers_Result, "This.person_id");
}

function isEmptyStr(str) {
  return (
    str == undefined ||
    str == null ||
    str == "" ||
    str == "null" ||
    str == "undefined"
  );
}

function addLeadingZeros(number, resultStrMinLength) {
  var zerosStr = "";

  for (var i = StrLen(number); i < resultStrMinLength; i++) {
    zerosStr += "0";
  }

  return zerosStr + number;
}

function deleteFileOpt(fileUrlOrPath) {
  try {
    DeleteFile(fileUrlOrPath);
    return { ok: true };
  } catch (e) {
    return { ok: false, error: e };
  }
}

function saveFileAsResource(fileName, fileContent, resourceID) {
  var docResource;

  if (resourceID > 0) {
    docResource = tools.open_doc(resourceID);
  } else {
    docResource = tools.new_doc_by_name("resource");
    docResource.BindToDb(DefaultDb);
  }

  docResource.TopElem.name = fileName;
  docResource.TopElem.file_name = fileName;
  docResource.TopElem.put_str(fileContent, fileName);
  docResource.Save();

  return docResource;
}

function getRandomFolderUrl(rootUrl, prefix) {
  if (prefix == undefined) {
    prefix = "";
  }

  var randomFolderName =
    prefix + DateToRawSeconds(Date()) + "a" + tools.random_string(10);

  return UrlAppendPath(rootUrl, randomFolderName);
}

function getRandomFolderPath(rootUrl, prefix) {
  return UrlToFilePath(getRandomFolderUrl(rootUrl, prefix));
}

function parseFilename(filename) {
  var dotPositionIndex = StrOptSubStrRightPos(filename, ".");

  if (dotPositionIndex != undefined) {
    return {
      name: StrLeftRange(filename, dotPositionIndex),
      ext: StrRightRangePos(filename, dotPositionIndex + 1),
    };
  } else {
    return {
      name: filename,
      ext: "",
    };
  }
}

function makeUniqFilename(filename, existingFilenames) {
  var existingFilename, uniqFilename;
  var cnt = 0;

  var parsedFilename = parseFilename(filename);

  while (true) {
    uniqFilename =
      parsedFilename.name +
      (cnt > 0 ? "_" + cnt : "") +
      "." +
      parsedFilename.ext;

    existingFilename = ArrayOptFind(existingFilenames, "This == uniqFilename");

    if (existingFilename == undefined) {
      break;
    }

    cnt++;
  }

  return uniqFilename;
}

function lf2crlf(str) {
  return regExpReplace("(^|[^\\r])(\\n)", str, "$1\r\n");
}

function crlf2lf(str) {
  return StrReplace(str, "\r\n", "\n");
}