import "XStdlib.dll"

int MAX_PATH = 300;
int MSXMLVersion = 0;

var OrderDocumentNumber; // номер документа(приказа) в WIN кодировке! в Т60 при печати расчета отпуска из приказа


SHIFT(fkey) { return ((fkey)!=F11 && (fkey)!=F12)?(25+(fkey)):(2+(fkey)); }
CTRL(fkey)  { return ((fkey)!=F11 && (fkey)!=F12)?(35+(fkey)):(4+(fkey)); }
ALT(fkey)   { return ((fkey)!=F11 && (fkey)!=F12)?(45+(fkey)):(6+(fkey)); }

MIN(a,b)
{
   return (a < b) ? a : b;
}

MAX(a,b)
{
   return (a < b) ? b : a;
}


min(a,b)
{
   return (a < b) ? a : b;
}

max(a,b)
{
   return (a < b) ? b : a;
}

nabs( val )
// назначение: возвращает модуль числа
// параметры: Number - число
{
   if ( val>=0 ) return val;
   return -val;
} 

Sgn( val )
{
  double Eps = 0.000000001;
  if ( val>Eps ) return 1;
  if ( val<-Eps) return -1;
  return 0;
}

RTrimS(str) //функция создает новую строку, не меняя переданную
{
  char s[strlen(str)+1];
  s=str;
  RTrim(s);
  return static_cast_to_string(s);
}

SayError(err)
{
   SayUndefinedScriptError();
/*
   char Mes[2048];
   Mes = err.Message();
   for ( int i=strlen(Mes)-1; i>=0; i-- )
      if ( Mes[i]=='\r' || Mes[i]=='\n' )
         Mes[i]=' ';
   CharToOem(Mes,Mes);
   AmbaMessageBox(Mes,"Ошибка!",0,0);
*/
}

SaveTmpFile(&TmpFileName)
//==================================================================
// переписываем временный файл в файл заданный в панели запросов
//==================================================================
{
   // определяем имя файла, которое было задано в панели 
   char NameFile[256];
   var OptionsTR = CreateObject("TransferOptions");
   stccpy(NameFile,OptionsTR.GetNameFileWin(),256);
   FreeSpaceString(NameFile,3," ");

   return SaveTmp2File(TmpFileName,NameFile,true);
}

SaveTmp2File(&TmpFileName,&NameFile,bMsg)
//==================================================================
// переписываем временный файл в другой файл с контролем свободного 
// места
//==================================================================
{
   int rc=0;

   // определяем первые три символа пути, куда будем писать файл
   char RootPathName[25];
   sprintf(RootPathName,"%-3.3s",NameFile); 

   unsigned long FileSize=0;
   int hf; 
   if ((hf = CreateFile(TmpFileName,1073741824,1 ,0 ,1 ,128 ,0 )) != -1)
   {   
      FileSize=SetFilePointer(hf,0,0,1);
      CloseHandle(hf);
   }

   int iDisk=1;
   unsigned long FreeSpace=5000000;

   // если в пути указан диск, то определяем свободное место на диске
   if (RootPathName[1]==':')
   {
      unsigned long SectorsPerCluster=0,
                    BytesPerSector=0,
                    NumberOfFreeClusters=0,
                    TotalNumberOfClusters=0;
      iDisk=GetDiskFreeSpace(RootPathName,SectorsPerCluster,BytesPerSector,
                                NumberOfFreeClusters,TotalNumberOfClusters);
     
      FreeSpace=static_cast_to_double(NumberOfFreeClusters) *
                      static_cast_to_double(SectorsPerCluster) *
                      static_cast_to_double(BytesPerSector);
   }

   if (iDisk==0)
   {
       if ( bMsg )
          AmbaMessageBox("Устройство не готово. Файл не будет создан. ","ошибка",MB_OK|MB_ICONERROR, 0);
       rc=1;
   }
   else
   {
      if (FreeSpace<FileSize)
      {
         if ( bMsg )
            AmbaMessageBox("На диске недостаточно места. Файл не будет создан.","ошибка",MB_OK|MB_ICONERROR, 0);
         rc=2;
      }
      else
      {
         if ( bMsg && !access(NameFile,0) )
         {
            string Title = "";
            string s = "Файл "+AnsiToOem(NameFile)+" существует! Перезаписать?";
            int res=AmbaMessageBox(s,Title,MB_YESNO|MB_ICONWARNING,0);
            if ( res!=IDYES ) 
               rc=4;
         }

         if ( !rc )
         {
            DeleteFile(NameFile);
            char TmpNameF[strlen(NameFile)+1];
            TmpNameF=NameFile;
            bool bSuccessRename = false;
            try
            {
               if ( rename(TmpFileName,TmpNameF)==0 )
                  bSuccessRename = true;
            }
            catch(...)
            {
               ;
            }
            if ( !bSuccessRename )
            {
               iDisk=CopyFile(TmpFileName,TmpNameF,0);
               DeleteFile(TmpFileName);
            }
            if (iDisk)
            {
               if ( bMsg )
                  AmbaMessageBox("Сохранение файла прошло успешно. ", "", MB_OK, 0);
            }
            else
            {
               if ( bMsg )
               {
                  char str[512];
                  sprintf(str, "Ошибка при записи файла \"%s\"",AnsiToOem(NameFile)  );
                  AmbaMessageBox(str, "Ошибка", MB_OK|MB_ICONERROR, 0);
               }
               rc=3;
            }
         }
      }
   }
   return rc;
}    

   BreakFIO(FIO,&F,&I,&O)
// ~~~~~~~~
// Получение из ФИО отдельных частей
{
   var Par = CreateObject("ParamFuncRW");
   Par.IInitial(static_cast_to_string(FIO)," .",3);
   F = Par.Get(0);
   I = Par.Get(1);
   O = Par.Get(2);
}

GetStrGUID()
{
   string GUID="";
   try 
   {
      GUID = GetGUID();
   }
   catch(...)
   {
      GUID = GetHandMadeGUID();
   }
   return GUID;
}

MakeRandomFileNameForPath(path)
{
   string Name;
   int cnt = 100;
   do
   {
      Name = path+GetGUID()+".tmp";
   } while ( cnt-- >0 && access(Name,0)==0 );
   return Name;
}

MakeRandomFileName()
// замена сишной Rand_Name
{
   return MakeRandomFileNameForPath("");
}

GetTimeWithTimeZone()
{
   // struct SYSTEMTIME lcl;
   // GetLocalTime(lcl);
   struct SYSTEMTIME st;
   GetLocalTime(st);

   char Buf[1024];
   // sprintf(Buf,"System: %04d-%02d-%02d %02d:%02d:%02d  Local: %04d-%02d-%02d %02d:%02d:%02d", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond,lcl.wYear, lcl.wMonth, lcl.wDay, lcl.wHour, lcl.wMinute, lcl.wSecond);
   struct TIME_ZONE_INFORMATION tzi;

   int rc=GetTimeZoneInformation(tzi);
/*
   string TZname="";
   if (rc == TIME_ZONE_ID_STANDARD || rc == TIME_ZONE_ID_UNKNOWN)    
      TZname=tzi.StandardName;
   else if( rc == TIME_ZONE_ID_DAYLIGHT )
      TZname=tzi.DaylightName;
*/
   int AdjustForDST=0; // необходимо учитывать переход на лентее время или нет
   long TBias = -tzi.Bias;
   if ( rc==TIME_ZONE_ID_DAYLIGHT && AdjustForDST )
      TBias = -(tzi.Bias + tzi.DaylightBias);

   char cSgn = Sgn(TBias)<0?'-':'+';
   int Hours=nabs(TBias)/60;
   int Minutes=nabs(TBias)%60;
   sprintf(Buf,"%04d-%02d-%02dT%02d:%02d:%02d%c%02d:%02d", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond,cSgn,Hours,Minutes);
   return to_string(Buf);
}

GetHandMadeGUID()
// ~~~~~~~~~~~~~~~
// код возвращающий что-то типа случайной последовательности символов длины 36
{
   char Buf[512];
   struct SYSTEMTIME st;
   GetLocalTime(st);
   long rand1 = (st.wMilliseconds*0xBCF7Fa+st.wSecond*0xFD3+st.wHour*0x252+st.wMinute*0x335)<<3 & 0xFFFFFFFF;
   GetLocalTime(st);
   long rand2 = (st.wMilliseconds*0xDF7+rand1)>>7 & 0xFFFF,
        rand3 = (rand1*0x34+rand2*0xF2)>>3 & 0xFFFF,
        rand4 = (rand1+rand3 * st.wMilliseconds<<9|st.wSecond<<3)>>5 & 0xFFFF,
        rand5 = (st.wMilliseconds*0xDE921+st.wSecond*0xFD3+st.wHour*0x252+st.wMinute*0x135)<<5 & 0xFFFFFFFF,
        rand6 = (rand1*0x17+rand2-rand3+rand4-rand5+st.wMinute*0x23D1) & 0xFFFF;
   sprintf(Buf,"%08LX-%04X-%04X-%04X-%08LX%04X", rand1,rand2,rand3,rand4,rand5,rand6);
   return Buf;
}

CheckExistKELite()
{
  return Send2KELite("", 4, 0);
}

RunKELite()
{
 Send2KELite("",2,0);
}

   Send2KELite(NameFile,Type,bMsg)
// ~~~~~~~~~~~
// Связь с Контур-Экстерн Лайт
// Type & 1 - только загрузка
// Type & 2 - запуск GUI
// Type & 4 - только проверка наличия
// bMsg - выдавать сообщения (true) или нет (false)

{
   return false; //связь отключена т.к. портит базу КЭ-лайт

   var KELiteInfo=0;
   bool bKELite = false;
   bool bTransfer = false;
   try
   {
      KELiteInfo = CreateObject("SKBKontur.LIT.KELite.SimpleCore.KELiteSimpleCoreInfo");
      bKELite = true;
   }
   // Любые исключения трактуются как отсутствие KELite 
   catch(...)
   {
      bKELite = false;
   }

   if ( bKELite )
   {
      // MessageBox(0,KELiteInfo.Version,"",0);
      // Проверяем, что версия KELite не ниже той, с которой происходила интеграция: 1.2.1
      var Par = CreateObject("ParamFuncRW");
      try
      {
         Par.IInitial(KELiteInfo.Version,".",5);
      }
      catch(...)
      {
         bKELite=false;
      }
      if ( bKELite && Par.Count()>2 )
      {
         int VerMaj = atoi(Par.Get(0));
         int VerMin = atoi(Par.Get(1));
         int VerBuild = atoi(Par.Get(2));
         if ( VerMaj>1 || VerMaj==1 && VerMin>2 || VerMaj==1 && VerMin==2 && VerBuild>=1 )
         {
            bKELite = true;
         }
         else
         {
            if ( bMsg ) 
               AmbaMessageBox("Несовместимая версия \"Контур-Экстерн Лайт\"","Ошибка!",0,0);
            bKELite = false;
         }
      }
      if (Type & 4)
        return bKELite;
      // Если все таки решили передавать, создаем объект, которым и передадим
      if ( bKELite )
      {
         var KELite = 0;
         var Report = 0;
         if ( (Type & 1) && 
              (!bMsg || AmbaMessageBox("Передать файл отчетности в \"Контур-Экстерн Лайт\"?",
                             "",MB_YESNO,0) == IDYES) )
         {
            try 
            {
               KELite = CreateObject("SKBKontur.LIT.KELite.SimpleCore.KELiteSimpleCore");
               KELite.Initialize("└╠┴р","3.7.0.0");
               /*Report =*/ KELite.CreateReportDCFromFile(static_cast_to_string(NameFile));
               bTransfer = true;

            }
            catch(...)
            {
               if ( bMsg )
                 AmbaMessageBox("Ошибка при попытке передать отчет в \"Контур-Экстерн Лайт\"","Ошибка!",0,0);
               bKELite = false;
               bTransfer = false;
            }
            KELite=0;
         }
         if ( (Type & 2) && bKELite && (bTransfer || !(Type&1)) &&
              (!bMsg || AmbaMessageBox("Запустить программу \"Контур-Экстерн Лайт\"?",
                                       "",MB_YESNO,0) == IDYES) )
         {
            try
            {
               KELite = CreateObject("SKBKontur.LIT.KELite.SimpleCore.ReportsSenderManager");
               KELite.Run();
               // KELite.RunAndCheck(Report);
            }
            catch(...)
            {
               if ( bMsg )
                  AmbaMessageBox("Ошибка при запуске \"Контур-Экстерн Лайт\"","Ошибка!",0,0);
               bKELite = false;
            }
            KELite = 0;
         }
      }
   }
   return bTransfer;
}


SendToKELite(rep,Type,bMsg,Vid)
// Связь с Контур-Экстерн Лайт
// Type = 1 - только загрузка
// bMsg - выдавать сообщения (true) или нет (false)
// Vid = 1 - передача 2-НДФЛ
{
// return false; //связь отключена т.к. портит базу КЭ-лайт

   if ( Vid == 1 ) if ( GetCommonCnfInt("Tr2ndflKEL","2ndfl") == 0 ) return false;

   char str[1024];

   GetCurrentDirectory(511,str); // рабочий каталог амбы
   
   if ( !IsLocalZPL() )
   {
     if ( IsCommonResource(NameCommonDir()) == RES_GLOBAL )
     {
       GetCommonZPL(str,511);
     }
   }

   rep = str + "\\" + rep;

   //Создаем и инициализируем приложение
   var app = 0;
   var jobQueueService = 0; // Сервис работы с заданиями
   var dcProviderService = 0; // Сервис для получения ДО
   var xDCService = 0; // Сервис работы с конкретными документами
   var xDC = 0; // Отчет


   bool bKELite = false;
   bool bTransfer = false;

   try
   {
      app = CreateObject("SKBKontur.LIT.KELite.Integration.COM.KELiteApp");
      app.Initialize("ClientID", "1.01");

      bKELite = true;
   }
   // Любые исключения трактуются как отсутствие KELite 
   catch(...)
   {
      bKELite = false;
   }

   if ( bKELite )
   {
      if ( (Type == 1) && 
           (!bMsg || AmbaMessageBox("Передать файл отчетности в \"Контур-Экстерн Лайт\"?",
                          "",MB_YESNO,0) == IDYES) )
      {
         try 
         {
            jobQueueService = app.GetService("JobQueueService");
            dcProviderService = app.GetService("DCProviderService");

            if ( Vid == 1 )
            { // 2-НДФЛ
               xDCService = app.GetService("FnsDCService");
               xDC = xDCService.CreateDCFromFile(rep);
               xDC = dcProviderService.FindDCById(xDC.Id); // Обновление ДО
            }

            AmbaMessageBox("Передача в Контур-Экстерн Лайт выполнена","",0,0);

            bTransfer = true;

         }
         catch(...)
         {
            if ( bMsg ) AmbaMessageBox("Ошибка при попытке передать отчет в \"Контур-Экстерн Лайт\"","Ошибка!",0,0);
              
            bKELite = false;
            bTransfer = false;
         }

         xDC = 0;
         xDCService = 0;
         dcProviderService = 0;
         jobQueueService = 0;
         app = 0;
      } 
   }

   return bTransfer;
}


GetNameScriptNastrXML(&NameFile,bMsg)
{
   char CurrentDir[512];
   // ищем относительно RSCALT
   stccpy(CurrentDir,"..\\SCRIPT\\USER\\",255);
   char Dir[128], Path[256], nam[81], ext[21];
   string NameExe = namexe();
   splitpath(NameExe,Dir,Path,nam,ext);
   CurrentDir = Dir+Path+CurrentDir;
   fullpath(CurrentDir,CurrentDir,255);
   FreeSpaceString(CurrentDir,3,"");
   NameFile = CurrentDir+NameFile;
   if ( access(NameFile,0) )
   {
       if ( bMsg )
          AmbaMessageBox("Файл настроек не найден!","Ошибка",MB_OK|MB_ICONERROR,0);
       return false;
   }
   return true;
}

UpdateOneNastrXMLInt(&XMLDoc,&Tag,&NewNastr,&OldNastr)
// Функция "обновления" одной настройки
// Возвращает 1 - если требуется сохранение изменений, 0 - в противном случае
// NewNastr & OldNastr приводятся в актуальное состояние
{
   bool NeedSave = NewNastr!=OldNastr;
   try
   {
      var List = XMLDoc.getElementsByTagName(Tag);
      if ( List.length() )
      {
         if ( NeedSave ) List.item(0).text = NewNastr;
         else            NewNastr=atoi(List.item(0).text);
      }
      else if ( NeedSave )
      {
         var Elem = CreateChildElemXML(XMLDoc,XMLDoc.documentElement,Tag);
         char Buf[256];
         sprintf(Buf,"%-ld",static_cast_to_long(NewNastr));
         Elem.text = static_cast_to_string(Buf);
      }
   }
   catch(...)
   {
      ;
   }
   OldNastr = NewNastr;
   return (NeedSave)?1:0;
}

GetListDatBeg(ps,DatB,DatE)
// *************************************************************
// *** Функция получает список дат изменения значений в КЧ в 
// **  заданный период времени
// *************************************************************
{
   // Дата конца действия очередного значения 
   // В самом начале она равна последнему дню месяца.
   var DateEnd = CreateObject("KDate");
   DateEnd.SetDateD(GetDateFromFuncRWScript(DatE));
   DateEnd.SetDateII(DateEnd.CountDay(),DateEnd.GetAbs());
   var DatBeg = CreateObject("KDate");
   DatBeg.SetDateD(GetDateFromFuncRWScript(DatB));
   int absDB = DatBeg.GetAbs();

   // Найдем дату начала действия очередного значения
   char StrD[21];
   GetKchDate(ps,StrD,10,DateEnd);
   var Date=CreateObject("KDate");
   Date.SetDate(static_cast_to_string(StrD));

   var Map = CreateObject("MapLong");
   
   // Если вдруг дата начала пустая,
   // установим ее равной первому числу расчетного месяца
   if ( Date.IsEqI(INVALID_DATE_VALUE) )
      Date.SetDateII(1,absDB);

   while ( 1 )
   {
      Map.Add(Date.GetDouble()*100+0.001,1);
      // Устанавливаем дату конца очередного значения
      // равной дате начала уже рассмотренного значения минус один день.
      DateEnd.SetDateD(Date.GetDouble());
      DateEnd.Dec();

      // Если дата конца вышла за пределы расчетного месяца - выходим
      if ( DateEnd.IsEqI(INVALID_DATE_VALUE) || DateEnd.GetAbs()<absDB )
         break;

      // Находим дату начала для очередного значения
      GetKchDateP(ps,StrD,10,Date);
      Date.SetDate(static_cast_to_string(StrD));
      if ( Date.IsEqI(INVALID_DATE_VALUE) )
         Date.SetDateII(1,absDB);
   }
   string ListDat="";
   for ( bool Cur=Map.InitIterator(); Cur; Cur=Map.Next() )
   {
       if ( ListDat!="" ) ListDat+=",";
       long LongD = Map.GetCurKey();
       Date.SetDateD(LongD/100.);
       ListDat += Date.GetStr();
   }
   return ListDat;
}

GetCountDatBeg(str)
// *************************************************************
// *** Функция возвращает кол-во параметров разделенных запятыми
// ************************************************************* 
{
   var Par = CreateObject("ParamFuncRW");
   Par.IInitial(static_cast_to_string(str),",",1000);
   return Par.Count();
}

GetKchDatBeg(ps,str,idx)
// *************************************************************
// *** Функция дает значение из КЧ, взяв из строки str c датами
// **  начала действия значений idx-ую по счету дату начала
// *************************************************************
{
   var Par = CreateObject("ParamFuncRW");
   Par.IInitial(static_cast_to_string(str),",",1000);
   var Dat = CreateObject("KDate");
   Dat.SetDate(static_cast_to_string(Par.Get(idx)));
   char Buf[512];
   GetKchValue(ps,Buf,511,Dat);
   return Buf;
}

GetOtdName(Otd)
{
   try
   {
      return OtdNameByCod(static_cast_to_long(Otd));
   }
   catch(...)
   {
      int pos = OtdPos(Otd);
      return (pos!=EOF)?OtdName(pos):"";
   }
}

LSRead(Tn, flag)
//===========================================================
// Чтение ЛС по ТН
//===========================================================
{
    int rc=LSReadTN(Tn,flag); 
    if (rc==0) 
    {
      char str[256];str = "Ошибка чтения ЛС (ТН:"+static_cast_to_string(Tn)+")";
      RaiseError(OemToAnsi(str));
    }
    return rc;
}

WinScriptRef(&buffer,bufsize,handle,&C_Params)
{
   char Buf[bufsize]; // bufsize задан с учетом 0 символа
   CharToOem(buffer,Buf);
   int rc= SimpleRef(C_Params.NF,C_Params.PX,C_Params.PY,
                                C_Params.DX,C_Params.DY,
                                Buf,bufsize-1,Buf,C_Params.KF);
   if ( rc!=ESC )
   {
      OemToChar(Buf,buffer);
      return 1;
   }
   return 0;
}

GetOutFormTmpFileName(newReporting)
{
   if (newReporting) mkdirAll("Reporting.tmp\\");
   
   char currDir[256];
   GetCurrentDirectory(255,currDir);
   string path = currDir + (newReporting ? "\\Reporting.tmp\\" : "\\");
   
   return MakeRandomFileNameForPath(path);
}

IsExistParametrTable(&Tbl,NameParam)
{
   return Tbl.GetKeyValueCollections(true).IsKeyExist("__TableParametrs/"+NameParam);
}

IsExistParametrCurrentTable(NameParam)
{
   var Tbl = CreateObject("CurPrnTbl");
   return IsExistParametrTable(Tbl,NameParam);
}

SetParametrTable(&Tbl,NameParam,Value)
{
   return Tbl.GetKeyValueCollections(true).SetValue("__TableParametrs/"+NameParam,to_string(Value));
}

SetParametrCurrentTable(NameParam,Value)
{
   var Tbl = CreateObject("CurPrnTbl");
   return SetParametrTable(Tbl,NameParam,Value);
}

GetParametrTable(&Tbl,NameParam)
{
   return Tbl.GetKeyValueCollections(true).GetValue("__TableParametrs/"+NameParam);
}

GetParametrTableEndPeriod(Tbl,fldEndP)
{
   string strDateEndP = "";
   if ( IsExistParametrTable(Tbl,"DateEnd") )
   {
      strDateEndP =  GetParametrTable(Tbl,"DateEnd");
      var DateEndP = CreateObject("KDate");
      DateEndP.SetDate(strDateEndP); DateEndP.ImproveDay();
      DateEndP.SetDateII(DateEndP.CountDay(),DateEndP.GetAbs());
      strDateEndP=DateEndP.GetStr();
   }
   if ( strDateEndP=="" && fldEndP!=-1 )
   {
      var DateEndP = KDateFromStr(Tbl.Text(fldEndP,0)); 
      DateEndP.SetDate(strDateEndP); DateEndP.ImproveDay();
      for (int rcr=1; rcr<Tbl.Count_Rcr(); ++rcr)
      {
         var curDate = KDateFromStr(Tbl.Text(fldEndP,rcr));
         curDate.ImproveDay();
         if ( !DateEndP.IsValid() || (curDate.IsValid() && curDate.GT(DateEndP)) )
            DateEndP = curDate;
      }
      DateEndP.SetDateII(DateEndP.CountDay(),DateEndP.GetAbs());
      strDateEndP=DateEndP.GetStr();
   }
   return strDateEndP;
}

GetParametrTableBegPeriod(Tbl)
{
}

GetParametrCurrentTable(NameParam)
{
   var Tbl = CreateObject("CurPrnTbl");
   return GetParametrTable(Tbl,NameParam);
}

GetPathXLTForTable( &Tbl, &KeyOrNameXLT )
{
   var KeyValueRef = Tbl.GetKeyValueCollections(true);
   string PathToXlt=NameCommonDir();
   if ( KeyValueRef.IsKeyExist("__System/PathToXLT") )
      PathToXlt=KeyValueRef.GetValue("__System/PathToXLT");
   string NameXlt = KeyOrNameXLT;
   if ( KeyValueRef.IsKeyExist(NameXlt) )
      NameXlt=KeyValueRef.GetValue(NameXlt);
   return GetPathXLT(PathToXlt,NameXlt);
}

GetPathXLT( Resource, NameXLT )
//=============================================================================
// Определяет путь к шаблону NameXLT
//=============================================================================
{
    // Определяем каталог, куда будем складывать файлы
    char strt[256], nm[256]; 

    if( Resource=="" )  
      nm = "\\"+NameXLT;
    else
      nm = "\\"+Resource+"\\"+NameXLT;

    FreeSpaceString(nm,3,"");

    // получим полный путь к шаблону
    GetCurrentDirectory(255,strt);
    char NewNameXlt[256];
    NewNameXlt = strt + nm;
    if ( IsSubStrPresent(NewNameXlt,"..\\") )
    {
      fullpath(NewNameXlt,NewNameXlt,255);
      FreeSpaceString(NewNameXlt,3,"");
    }

    // если шаблона нет, на лок.машине, и версия сетевая...то берем шаблон с
    // серверной машины
    if ( !IsLocalZPL() && ( Resource=="" || IsCommonResource(Resource) ) )
    {
      //берем путь к сетевому ZPL 
      GetCommonZPL(NewNameXlt,255);
      int len = strlen(NewNameXlt);
      if (NewNameXlt[len-1]=='\\')
         NewNameXlt[len-1]='\0'; 
      NewNameXlt = NewNameXlt+nm;
    }

    FreeSpaceString(NewNameXlt,3,"");
    // Если задан путь относительно текущего каталога (относительно ZPL)
    // то делаем из него абсолютный путь 
    if ( NewNameXlt[0]=='.' && NewNameXlt[1]=='.' )
    {
      fullpath(NewNameXlt,NewNameXlt,255);
      FreeSpaceString(NewNameXlt,3,"");
    }

    if ( access(NewNameXlt,0) )
       AmbaMessageBox("Шаблон "+NewNameXlt+" не найден!","ошибка",MB_OK|MB_ICONERROR, 0);
    
    return NewNameXlt;
}

IsObjectExists(progid)
//=============================================================================
// -IDR- проверка регистрации объекта с заданным ProgId
//       возвращает: 1 - удалось создать (объект есть), 
//        <=0 - создать не удалось (скорее всего объекта нет)
//=============================================================================
{
//  Пытаемся создать объект и если все прошло без исключений
//  возвращаем положительный результат
    var t = CreateObject("TmpDisableDebugMode"); // отключили "режим отладки" скриптов
    try
    {
       if (!strlen(progid)) return -1;
       var obj=CreateObject(progid);       
    }
    catch(object err)
    {
       string str=err.Message();
       if (reinterpret_cast_to_long(strstr(progid,str))==0) return 0;
       return -1;
    }
    catch(...)
    {
       return -1;
    }
    return 1;
}

strstr_result(str,str_search)
//=============================================================================
// -IDR- возвращает часть строки str, с позиции, в которой впервые встретилась строка 
// str_search, и до конца. Если str_search не найдена, возвращает пустую строку
//=============================================================================
{
  long p=reinterpret_cast_to_long(strstr(str,str_search));
  string res="";
  if (p)
  {
    long offset=p-reinterpret_cast_to_long(str);
    res=substr(str,offset);
  }
  return res;
}

fgetstr(cnt,&str,file)
//=============================================================================
// -IDR- чтение строки с текущей позиции файла file (открытого с помощью fopen), 
// но не более cnt символов. Возвращает количество прочитанных символов
//=============================================================================
{
   str="";
   char buf[2];
   buf[1]=0;
   int cntread=0;
   int isEndStr = 0;
   do
   {
      read(file,buf,1);
      str+=buf;
      cntread++;           
      if ( buf[0]==0x0d ) isEndStr=1;
      if ( isEndStr==1 )
      {
         if ( buf[0]==0x0a ) isEndStr = 2; 
         else                isEndStr = 0;
      }
   }
   while (isEndStr!=2 && cntread < cnt);
   return strlen(str);
}


//===========================================================
// Функции транслитерации:
// TranslitInit() - Инициализация 
// TranslitStr(inputstr) - Возвращает англ.вариант строки
//===========================================================

var mapTran = CreateObject("MapString");

TranslitStr(inputstr)
{
   char str[256];
   string s = "";
   string rus_str = static_cast_to_string(inputstr);

   for ( int i=0; i<strlen(rus_str) ;i++ )
   {
      s = SubStr(rus_str,i,1);
      if ( mapTran.IsExist(s) )
      {
         str += mapTran.GetValue(s);
      }
      else
      {
         str += s;
      }
   }
   return str;
}

TranslitInit()
{
   mapTran.Add("А","A");    mapTran.Add("Б","B");    mapTran.Add("В","V");
   mapTran.Add("Г","G");    mapTran.Add("Д","D");    mapTran.Add("Е","E");
   mapTran.Add("Ё","YO");   mapTran.Add("Ж","G");    mapTran.Add("З","Z");
   mapTran.Add("И","I");    mapTran.Add("Й","J");    mapTran.Add("К","K");
   mapTran.Add("Л","L");    mapTran.Add("М","M");    mapTran.Add("Н","N");
   mapTran.Add("О","O");    mapTran.Add("П","P");    mapTran.Add("Р","R");
   mapTran.Add("С","S");    mapTran.Add("Т","T");    mapTran.Add("У","U"); 
   mapTran.Add("Ф","F");    mapTran.Add("Х","H");    mapTran.Add("Ц","TZ");
   mapTran.Add("Ч","CH");   mapTran.Add("Ш","SH");   mapTran.Add("Щ","SCH");
   mapTran.Add("Ъ","");     mapTran.Add("Ы","Y");    mapTran.Add("Ь","");
   mapTran.Add("Э","E");    mapTran.Add("Ю","YU");   mapTran.Add("Я","YA");

   mapTran.Add("а","a");    mapTran.Add("б","b");    mapTran.Add("в","v");
   mapTran.Add("г","g");    mapTran.Add("д","d");    mapTran.Add("е","e");
   mapTran.Add("ё","yo");   mapTran.Add("ж","g");    mapTran.Add("з","z");
   mapTran.Add("и","i");    mapTran.Add("й","j");    mapTran.Add("к","k");
   mapTran.Add("л","l");    mapTran.Add("м","m");    mapTran.Add("н","n");
   mapTran.Add("о","o");    mapTran.Add("п","p");    mapTran.Add("р","r");
   mapTran.Add("с","s");    mapTran.Add("т","t");    mapTran.Add("у","u"); 
   mapTran.Add("ф","f");    mapTran.Add("х","h");    mapTran.Add("ц","tz");
   mapTran.Add("ч","ch");   mapTran.Add("ш","sh");   mapTran.Add("щ","sch");
   mapTran.Add("ъ","");     mapTran.Add("ы","y");    mapTran.Add("ь","");
   mapTran.Add("э","e");    mapTran.Add("ю","yu");   mapTran.Add("я","ya");

   return 0;
}

ShowHtmlFile(&NameFile)
{
   if ( !Str_Cmp(NameFile," "," ") || access(NameFile,0) )
      return false;
   var IE = 0;
   bool bView = false;   
   for ( int i=0; i<3 && !bView; ++i )   
   {
      IE = CreateObject("InternetExplorer.Application");
      try
      {
         IE.ToolBar = false;
         IE.AddressBar= false;
         IE.Offline=true;
         IE.Navigate(static_cast_to_string(NameFile));
         IE.Visible = true;
         bView = true;
      }
      catch(...)
      {
         IE=0;
      }
   }
   return true;
}

CreateNameFileWithTime( Path, Ext )
//=============================================================================
// Создаем имя файла для новой выходной формы
//=============================================================================
{
   char strt[81];
   GetDateTime(strt,80);

   // имя файла Path_ГГГГММДД.tmp
   // ГГГГММДД - дата передачи
   // sprintf(Str,"t60_%s",strt);

   var NameFile = Path+strt+Ext;
   var tmp=-1;
   while( !access(NameFile,0) && tmp<200 )
   {
      tmp++;
      NameFile = Path+strt+static_cast_to_string(tmp)+Ext;
   }
   return NameFile;
}


string SysStrDateOneScript="",SysStrDateTwoScript="";
AskPeriod(Flag,_Comment)
{
   bool bControlOnce = Flag & 0x01; // панель выдавать только для "пустой" таблицы
   bool bFull        = Flag & 0x02; // полные даты
   bool bPeriod      = Flag & 0x04; // период
   bool bOtchetn     = Flag & 0x08; // кварталы "накопительным" порядком (т.е. квартал, полугодие, 9 месяцев)
   bool bKvartal     = Flag & 0x10; // простые кварталы
   bool bHalfYear    = Flag & 0x20; // полугодие
   bool bYear        = Flag & 0x40; // год
   bool returnRC     = Flag & 0x100; // возвращать вместо даты код возврата, 0 - ОК, ESC - Отмена
   bool bExactDates  = Flag & 0x200; // только вместе с флагом bFull: при запросе, если Str_Date_0 & Str_Date_1 не пусты - 
                                     // оставлять их такими, какие есть
   bool bDontCheckSystemPeriod = Flag & 0x400; // НЕ проверять -P2MES + B2MES

   if ( bControlOnce )
   {
      // Обеспечиваем однократный вызов панели (может плохо срабатывать если есть фильтр в таблице, в этом случае
      // надо здесь сами добавить строчку в таблицу)
      var Tbl = CreateObject("CurPrnTbl");
      if ( Tbl.Count_Rcr()>1 )
      {
         Str_Date_1 = SysStrDateTwoScript;
         Str_Date_0 = SysStrDateOneScript;
         if (returnRC) return 0;
         return SysStrDateOneScript;
      }
   }

   if ( Str_Cmp(SysStrDateOneScript," "," ./\\") )
      Str_Date_0=SysStrDateOneScript;
   if ( Str_Cmp(SysStrDateTwoScript," "," ./\\") )
      Str_Date_1 = SysStrDateTwoScript;


   string SelectArray[10]; // 4 + 4 квартала, 2 полугодия
   int CountSelect = 0;
   int LBoundOtch=-1,HBoundOtch=-1,LBoundKv=-1,HBoundKv=-1,LBoundHalf=-1,HBoundHalf=-1;
   if ( bOtchetn )
   {
      LBoundOtch = CountSelect;
      SelectArray[CountSelect++]="1-ый квартал";
      SelectArray[CountSelect++]="1-ое полугодие";
      SelectArray[CountSelect++]="9 месяцев";
      SelectArray[CountSelect++]="12 месяцев";
      HBoundOtch = CountSelect;
   }
   if ( bKvartal )
   {
      LBoundKv = CountSelect;
      SelectArray[CountSelect++]="1-ый квартал";
      SelectArray[CountSelect++]="2-ой квартал";
      SelectArray[CountSelect++]="3-ий квартал";
      SelectArray[CountSelect++]="4-ый квартал";
      HBoundKv = CountSelect;
   }
   if ( bHalfYear )
   {
      LBoundHalf = CountSelect;
      SelectArray[CountSelect++]="1-ое полугодие";
      SelectArray[CountSelect++]="2-ое полугодие";
      HBoundHalf = CountSelect;
   }

   if ( CountSelect ) bYear = 0; // выбор лет с выбором кварталов не монтируется

   int RowSelect = CountSelect;
   if ( RowSelect<1 ) RowSelect=1;
   string Comment=_Comment;
   FreeSpaceString(Comment,2,"");
   if ( strlen(Comment)<1 )
   {
       if ( bPeriod )
            Comment = "Период";
       else Comment = bFull?"Дата":"Месяц";
       Comment+=":";
   }

   int LenComment = strlen(Comment);

   string ControlF = "Control_Date";
   int W=7;
   string Shb = "  .    ";

   while ( 1 )
   {
      if ( bFull )
      {
         var Dat = CreateObject("KDate");
         Dat.SetDate(static_cast_to_string(Str_Date_0));
         if (!bExactDates) Dat.SetDateIII(1,Dat.GetMonth(),Dat.GetYear());
         // Dat.SetDateD(data+0.01);
         sprintf(Str_Date_0,"%.10s",Dat.GetStr());
         Dat.SetDate(static_cast_to_string(Str_Date_1));
         if (!bExactDates) Dat.SetDateIII(Dat.CountDay(),Dat.GetMonth(),Dat.GetYear());
         sprintf(Str_Date_1,"%.10s",Dat.GetStr());
         W=10;
         Shb = "  .  .    ";
      }
      else
      {
         var Dat = CreateObject("KMonth");
         Dat.SetDate(static_cast_to_string(Str_Date_0));
         sprintf(Str_Date_0,"%.8s",Dat.GetStr());
         Dat.SetDate(static_cast_to_string(Str_Date_1));
         sprintf(Str_Date_1,"%.8s",Dat.GetStr());
      }

      if ( bYear || CountSelect )
      {
         W=4;
         Shb="    ";
         ControlF = "Control_Year";
         var Dat = CreateObject("KMonth");
         Dat.SetDate(static_cast_to_string(Str_Date_0));
         if ( !Dat.GetYear() ) Dat.SetMonth(mtek);
         sprintf(Str_Date_0,"%04d",Dat.GetYear());
         if ( bYear )
         {
            Dat.SetDate(static_cast_to_string(Str_Date_1));
            if ( !Dat.GetYear() ) Dat.SetMonth(mtek);
            sprintf(Str_Date_1,"%04d",Dat.GetYear());
         } 
      }

      char InsertSelect[CountSelect+1];
      char AccessSelect[CountSelect+1];
      for ( int i=0; i<=CountSelect; ++i )
         InsertSelect[i]=AccessSelect[i]=' ';
      InsertSelect[0]=0;

      char Insert00[1];
      char Access00[1];
      var Text00[1];
      MakeReferenceVar(Text00[0],Str_Date_0);
      Insert00[0]=Access00[0]=' ';

      char Insert01[1];
      char Access01[1];
      var Text01[1];
      MakeReferenceVar(Text01[0],Str_Date_1);
      Insert01[0]=Access01[0]=' ';

      var Elem[3];
      for ( int i=0; i<3; ++i)
         Elem[i]=CreateObject("KControlElement");

      int LeftDatBeg = 2+LenComment+2;
      if ( CountSelect ) LeftDatBeg += 20;
      Elem[0].Initial(2+LenComment+2,2,14,1,18,RowSelect,0,0,0,E_AUTO_SELECT,RowSelect,CountSelect?1:0,"Before_S",
                      "Control_S",Shb,SelectArray,InsertSelect,AccessSelect);
         // Дата начала или год
      Elem[1].Initial(LeftDatBeg,2,W,1,W,1,0,0,0,E_EDIT_AREA,1,1,"Before_S",
                      ControlF,Shb,Text00,Insert00,Access00);
         // Дата конца
      Elem[2].Initial(LeftDatBeg+W+5,2,W,1,W,1,0,0,0,E_EDIT_AREA,1,bPeriod && !CountSelect?1:0,"Before_S",
                      ControlF,Shb,Text01,Insert01,Access01);
      var Head[3];
      for ( int i=0; i<3; ++i )
         Head[i]=CreateObject("KControlHeading");
      Head[0].Initial(Comment,2,2,2+LenComment,2,1);
      Head[1].Initial(" - ",LeftDatBeg+W+1,2,LeftDatBeg+W+4,2,bPeriod && !CountSelect?1:0);
      Head[2].Initial("года",LeftDatBeg+W+1,2,LeftDatBeg+W+4,2,CountSelect?1:0);
      int SizePanel = LeftDatBeg+W+10;
      if ( bPeriod ) SizePanel  += W+5;
      if ( SizePanel>78 ) SizePanel = 78;
      if ( SizePanel<30 ) SizePanel = 34;
      SizePanel /= 2;

      if ( Panel(Elem,3,Head,3,40-SizePanel,10,40+SizePanel,14+CountSelect,' ',5,"ControlPanel",0,"") == ESC )
         if (returnRC) return ESC;
         else return Shb;

      // Если запрашивали года, то преобразуем это в период месяцев
      if ( bYear )
      {
         int YearBeg = atoi(Str_Date_0), YearEnd = atoi(Str_Date_1);
         if ( !bPeriod ) YearEnd=YearBeg;
         sprintf(Str_Date_0,"01.%04d",YearBeg);
         sprintf(Str_Date_1,"12.%04d",YearEnd);
      }
      
      // Если задавали предопределенными периодами
      if ( CountSelect )
      {
         int Len = strlen(InsertSelect);
         int MonthBeg=1,MonthEnd=1;
         if ( LBoundOtch<=Len && Len<HBoundOtch )
         {
            int Ost = Len-LBoundOtch;
            if      ( Ost==1 ) MonthEnd = 6;
            else if ( Ost==2 ) MonthEnd = 9;
            else if ( Ost==3 ) MonthEnd = 12;
            else MonthEnd = 3;
         }
         else if ( LBoundKv<=Len && Len<HBoundKv )
         {
            int Ost = Len-LBoundKv;
            if      ( Ost==1 ) MonthBeg = 4, MonthEnd = 6;
            else if ( Ost==2 ) MonthBeg = 7, MonthEnd = 9;
            else if ( Ost==3 ) MonthBeg = 10, MonthEnd = 12;
            else MonthBeg = 1, MonthEnd = 3;
         }
         else if ( LBoundHalf<=Len && Len<HBoundHalf )
         {
            int Ost = Len-LBoundHalf;
            if      ( Ost==1 ) MonthBeg = 7, MonthEnd = 12;
            else MonthBeg = 1, MonthEnd = 6;
         }
         int Year = atoi(Str_Date_0);
         sprintf(Str_Date_0,"%02d.%04d",MonthBeg,Year);
         sprintf(Str_Date_1,"%02d.%04d",MonthEnd,Year);
      }

      if ( !bDontCheckSystemPeriod ) // -P2MES +B2MES
      {
          var Dat;
          if ( bFull ) Dat=CreateObject("KDate");
          else         Dat=CreateObject("KMonth");
          Dat.SetDate(static_cast_to_string(Str_Date_0));
          if ( Dat.GetAbs()>mtek+B2MES )
          {
              Dat.SetDateII(1,mtek+B2MES);
              Dat.SetDateII(Dat.CountDay(),mtek+B2MES);
              AmbaMessageBox("Нельзя выбирать период вперед дальше чем "+Dat.GetStr()+"! Повторите ввод.","Ошибка!",MB_OK|MB_ICONERROR,0);
              Str_Date_0=Dat.GetStr();
              continue;
          }
          if ( Dat.GetAbs()<mtek-P2MES )
          {
             Dat.SetDateII(bFull?Dat.GetDay():1,mtek-P2MES);
             if ( bFull) Dat.ImproveDay();
             Str_Date_0=Dat.GetStr();
          }

          Dat.SetDate(static_cast_to_string(Str_Date_1));
          if ( Dat.GetAbs()<mtek-P2MES )
          {
              Dat.SetDateII(1,mtek-P2MES);
              AmbaMessageBox("Нельзя выбирать период назад дальше чем "+Dat.GetStr()+"! Повторите ввод.","Ошибка!",MB_OK|MB_ICONERROR,0);
              Str_Date_1=Dat.GetStr();
              continue;
          }
          if ( Dat.GetAbs()>mtek+B2MES )
          {
             Dat.SetDateII(bFull?Dat.GetDay():1,mtek+B2MES);
             if ( bFull ) Dat.ImproveDay();
             Str_Date_1=Dat.GetStr();
          }
      }
      break;
   }
   
   SysStrDateTwoScript=Str_Date_1;
   SysStrDateOneScript=Str_Date_0;
   if (returnRC) return 0;
   else return SysStrDateOneScript;
   
}

Control_Year(&Text0,Text_Old, h)
{
   int Year = atoi(Text0);
   if ( Year && Year<100 ) Year+=2000;
   if ( !Year )
   {
      AmbaMessageBox("Год не может быть равен нулю! Повторите пожалуйста ввод.","Ошибка",MB_OK|MB_ICONERROR, 0);
      return ESC;
   }
   /*
      char Buf[256];
      var Month = CreateObject("KMonth");
      Month.SetMonth(mtek-P2MES-B2MES);
      if ( Year<Month.GetYear() )
      {
         sprintf(Buf,"Год не может быть меньше %04d! Повторите пожалуйста ввод.",Month.GetYear());
         AmbaMessageBox(Buf,"Ошибка",MB_OK|MB_ICONERROR, 0);
         return ESC;
      }
      Month.SetMonth(mtek+B2MES);
      if ( Year>Month.GetYear() )
      {
         sprintf(Buf,"Год не может быть больше %04d! Повторите пожалуйста ввод.",Month.GetYear());
         AmbaMessageBox(Buf,"Ошибка",MB_OK|MB_ICONERROR, 0);
         return ESC;
      }
   */
   return 0;
}

MonthBySumCol(Col) // месяц по номеру столбца в с1
{
   int C2MES=P2MES_MAX+1+B2MES;
   int ColMTek = s119(mtek);
   int Offs = Col-ColMTek;
   if ( Offs>B2MES  ) Offs -= C2MES;
   if ( Offs<-P2MES_MAX ) Offs += C2MES;
   return mtek+Offs;
}
MonthByWorkTimeCol(Col) // месяц по номеру столбца в с2
{
   int C2MES=P2MES_MAX+1+B2MES;
   int ColMTek = s120(mtek);
   int Offs = Col-ColMTek;
   if ( Offs>B2MES  ) Offs -= C2MES;
   if ( Offs<-P2MES_MAX ) Offs += C2MES;
   return mtek+Offs;
}

GetXmlValue(node, path)
{
   var childNode = node.selectSingleNode(path);
   if (!VarHasValue(childNode)) return "";
   return childNode.text;
}

KDateFromStr(str)
{
   var kd=CreateObject("KDate");
   kd.SetDate(static_cast_to_string(str));
   return kd;
}
KDateFromInt(m)
{
   var kd=CreateObject("KDate");
   kd.SetMonth(atoi(m));
   return kd;
}
//return KDateFromInt_WithDay(1,mrasch).GetStr();
KDateFromInt_WithDay(day,m)
{
   var kd=CreateObject("KDate");
   kd.SetDateII(day,m);
   return kd;
}
//return KDateFromInt_LastDay(mrasch).GetStr();
KDateFromInt_LastDay(m)
{
   var month=CreateObject("KMonth");
   month.SetMonth(atoi(m));
   var kd=CreateObject("KDate");
   kd.SetDateII(month.CountDay(),m);
   return kd;
}

KDateFromD(double_d)
{
   var kd=CreateObject("KDate");
   kd.SetDateD(double_d);
   return kd;
}
KDateFromIntDate(date)
{
   var kd=CreateObject("KDate");
   kd.SetInt(atoi(date));
   return kd;
}

BreakColumnCalc() 
{
   var v = CreateObject("TmpDisableDebugMode");
   long err=static_cast_to_long(breakLineColumn);
   throw err;
}

BreakTableCalc() 
{
   var v = CreateObject("TmpDisableDebugMode");
   long err=static_cast_to_long(breakTable);
   throw err;
}

BreakLineReceive() 
{
   var v = CreateObject("TmpDisableDebugMode");
   long err=static_cast_to_long(breakLineColumn);
   throw err;
}

BreakTableReceive()
{
   var v = CreateObject("TmpDisableDebugMode");
   long err=static_cast_to_long(breakTable);
   throw err;
}

BreakLineDelivery() 
{
   var v = CreateObject("TmpDisableDebugMode");
   long err=static_cast_to_long(breakLineColumn);
   throw err;
}

BreakTableDelivery()
{
   var v = CreateObject("TmpDisableDebugMode");
   long err=static_cast_to_long(breakTable);
   throw err;
}

BreakTableTransfer()
{
   var v = CreateObject("TmpDisableDebugMode");
   long err=static_cast_to_long(breakTable);
   throw err;
}

IsKchDateExist(pseudo, kchDate)
{
   char buf[256];
   if (!Str_Cmp(kchDate,"  .  .    "," "))
   {
     GetKchValueExact(pseudo,buf,255,KDateFromStr(kchDate));
     if (RTrimS(buf)=="") return 0;
     return 1;
   }
   GetKchDate(pseudo,buf,11,KDateFromStr(kchDate));
   if (!Str_Cmp(buf,kchDate," "))
      return 1;
   return 0;
}

RefinePeriodToMonth(month, &kdBeg, &kdEnd, refineByWorkStartDate)
{
   var dMonth=KDateFromStr(month);
   if (kdBeg.GetDouble()<1) kdBeg.SetDateII(1,dMonth.GetAbs());
   if (kdEnd.GetDouble()<1) kdEnd.SetDateII(dMonth.CountDay(),dMonth.GetAbs()); 

   if (kdBeg.GT(kdEnd)) return 0;
   
   int d1,d2;
   s6400(kdBeg.GetDouble(),kdEnd.GetDouble(),d1,d2,dMonth.GetDouble());
   if (d1==d2 && d1==0) return 0; // чэрўшЄ яхЁхёхўхэш  яхЁшюфют эхЄ (яхЁхэхё т√°х SetDateII, эх сєфхь яюЁЄшЄ№ kdBeg т ¤Єюь ёыєўрх)      
   kdBeg.SetDateII(d1,dMonth.GetAbs());
   kdEnd.SetDateII(d2,dMonth.GetAbs());
   
   //kdBeg ш kdEnd єцх т ьхё Ўх month, фрыхх ьюцэю юяхЁшЁютрЄ№ фэ ьш      
   if (refineByWorkStartDate)
   {
      char buf[32];
      R_Face("data_rb",buf,31,0);
      var dateRb=KDateFromStr(buf);
      if (dateRb.GetDouble()<1) dateRb.SetDateII(1,dMonth.GetAbs());
      R_Face("data_uv",buf,31,0);
      var dateUv=KDateFromStr(buf);
      if (dateUv.GetDouble()<1) dateUv.SetDateII(dMonth.CountDay(),dMonth.GetAbs());

      s6400(dateRb.GetDouble(),dateUv.GetDouble(),d1,d2,dMonth.GetDouble());
      if (d1==d2 && d1==0) return 0; // чэрўшЄ т ¤Єюь ьхё Ўх ўхыютхъ эх ЁрсюЄрхЄ
      
      if (kdBeg.GetDay()<d1) kdBeg.SetDateII(d1,dMonth.GetAbs());
      if (kdEnd.GetDay()>d2) kdEnd.SetDateII(d2,dMonth.GetAbs());
   }
   return 1;
}

RefineDateToMonth(month, date, isStartDate, &kd, refineByWorkStartDate)
{
   var kdEmpty=CreateObject("KDate");
   kd=KDateFromStr(date);
   if (isStartDate) 
      return RefinePeriodToMonth(month, kd, kdEmpty, refineByWorkStartDate);
   else             
      return RefinePeriodToMonth(month, kdEmpty, kd, refineByWorkStartDate);
}

// схч єўхЄр фрЄ яЁшхьр/єтюы№эхэш 
IsValueValidInMonth(month, dateBeg, dateEnd)
{
   var kdBeg=KDateFromStr(dateBeg);
   var kdEnd=KDateFromStr(dateEnd);
   return RefinePeriodToMonth(month, kdBeg, kdEnd, false);
}

NounAfterNumeral(_Numeral, &Noun1, &Noun2, &Noun5)
{
   long Numeral = static_cast_to_long(_Numeral);
   long Rest10 = Numeral%10;
   long Rest100 = Numeral%100;
   if (Rest10 == 1 && Rest100 != 11) return static_cast_to_string(Noun1);
   if (Rest10 >= 2 && Rest10 <= 4 && (Rest100 < 10 || Rest100 >= 20)) return static_cast_to_string(Noun2);
   return static_cast_to_string(Noun5);
}

EditTableKeyCollections(adr)
{
   var table = CreateObject("CurPrnTbl");
   table.Initial(adr);
   return NetDialogs().ShowTableKeyCollections(table);
}

Panel_Choice(title, array, &selected)
{
  var MapPanel = CreateObject("MapString");

  int count = GetUBound(array)+1;
  if (count <2) 
    return 0;
  for(int i = 0; i<count; i++)
    MapPanel.Add(to_string(i),to_string(array[i]));
  var MapRez = CreateObject("MapString");

  int c=PanelValueFromMap(MapPanel,MapRez,1, title);
  if (c==ESC)
  {
     return(ESC);
  }
  selected= atoi(MapRez.GetCurKey());
  return 0;
}

ConcatApropArrays(arrayTo, arrayFrom)
{
  for(int i = 0; i<arrayFrom.Size(); i++)
    arrayTo.Insert(arrayFrom.Get(i));
}

GetDateBegPilotFSS()
{
   char DatPilotS[81]; 
   GetEnterpriseVar(AnsiToOem("╧╚╦╬╥╘╤╤"),DatPilotS,80);
   var DatPilot = KDateFromStr(DatPilotS);
   if ( !DatPilot.IsValid() )
      DatPilot = KDateFromStr("01.01.2021");
   return DatPilot;
}