-- Шаблон создан мастером бланков
-- 03.11.2003 10:22:19
--
БланкСШаблоном  "процедуры функции матучета";
CloseMe:l;
ПроверятьОшибки:l;
var Описание[]:s;
Строк_в_описании:i=112;
var logic[]:l;
var logic1[]:l;
var st[]:s;
var st1[]:s;
var st2[]:s;
var st3[]:s;
var st4[]:s;
var nn[]:n;
var nn1[]:n;
var Карт  []:s;
var Фильтр[]:s;
var ПолеПр[]:s;
var МаскаК[]:s;
МаскаСчетаФКР   :String="???.????.???????.???";
МаскаСчетаКД    :String="???.?.??.?????.??.????";
МаскаСчетаКИВФ  :String="???.??.??.??.??.??.????";
МаскаСчетаЗАБНФА:String="ЗАБ.??";
--МаскаСчетаИст   :String="?";
--МаскаСчетаСинт  :String="???";
--МаскаСчетаАн    :String="??";
--МаскаСчетаКОСГУ :String="???";
var МаскаПризнаковНаСчета[]:s;
var МаскаУсловийНаСчета[]:s;

func ДобавитьМаскуПризнаковПоУслСч(УслСч:s):i;
  var p,j,k,z,ii:i;
  var ss:s;
  p=ВставитьВмассивСорт(МаскаУсловийНаСчета,УслСч);
  ClearVariable(Раб.НФА.B01.st);
  ClearVariable(Раб.НФА.B01.st1);
  for счета ss=УслСч do ДобавитьВМассив(st,true,false,МаскаПризнаков(ss,false),МаскаПризнаков(ss,true));od;
  j=ДлинаМассива(st);
  for k=1..j do
    z=КоличествоСлов(st[k],'|');
    for ii=1..z do ДобавитьВМассив(st1,true,false,ВыделитьСлово(ii,st[k],'|'));od;
  od;
  ClearVariable(Раб.НФА.B01.st);
  j=ДлинаМассива(st1);УслСч='';
  for k=1..j do
    ss=trim(st1[k]);
    if ss<>'':УслСч=УслСч+'|'+ss;fi;
  od;
  МаскаПризнаковНаСчета[p]=SubStr(УслСч,2,Длина(УслСч)-1);
  ClearVariable(Раб.НФА.B01.st1);
  ^p;
end;
func ВзятьМаскуПризнаков(УслСч:s):s;
  var p:i;
  УслСч=up(УслСч);
  p=ПоискВмассиве(МаскаУсловийНаСчета,УслСч,true);
  if p<1:p=ДобавитьМаскуПризнаковПоУслСч(УслСч);fi;
  ^МаскаПризнаковНаСчета[p];
end;
func ПризнакиВмаску(СписокПризнаков:s):s;
  var p,j:i;
  var ss:s;
   p=КоличествоСлов(СписокПризнаков,' ');
   for j=1..p do ss=ss+'|'+ВыделитьСлово(1,ВыделитьСлово(j,СписокПризнаков,' '),'.')+'.*';od;
   p=КоличествоСлов(ss,'|');
   ^ВыделитьСлова(1,p,ss,'|');
end;

Menu_Alt_Enter:Объект;
Proc Ini_Menu_Alt_Enter;
  Menu_Alt_Enter.Надпись='&'+chr(13);
  Menu_Alt_Enter.Ширина=0;
  Menu_Alt_Enter.Высота=0;
  Menu_Alt_Enter.КоордX=0;
  Menu_Alt_Enter.КоордY=0;
end;
КнПроводить:Объект;
Proc Ini_КнПроводить;
  КнПроводить.Надпись='П&роводить';
  КнПроводить.Ширина=0;
  КнПроводить.Высота=0;
  КнПроводить.КоордX=0;
  КнПроводить.КоордY=0;
end;
func ab(str1:s;sum:s;str2:s):s;
  if длина(str1)=0:^str2;fi;
  if длина(str2)=0:^str1;fi;
  if длина(str1)+длина(str2)+длина(sum)>255:
     Message('Ошибка![функция РАБ.НФА.B01.ab]^MРезультат превышает максимальную^Mдлину строки в 256 символов^M'+str1+'^M'+sum+'^M'+str2,mterror);
     ^str2;
  fi;
  ^str1+sum+str2;
end;
func ab_error(str1:s;sum:s;str2:s;error:l):s;
  if длина(str1)=0:^str2;fi;
  if длина(str2)=0:^str1;fi;
  if error:
     if длина(str1)+длина(str2)+длина(sum)>255:
        Message('Ошибка![функция РАБ.НФА.B01.ab]^MРезультат превышает максимальную^Mдлину строки в 256 символов^M'+str1+'^M'+sum+'^M'+str2,mterror);
        ^str2;
     fi;
  fi;
  ^str1+sum+str2;
end;

func abl(str1:s;sum:s;str2:s):s;
  str1=trim(str1);
  str2=trim(str2);
  if str1=str2:
     if длина(str1)>0:str1='('+str1+')';fi;
     ^str1;
  fi;
  if длина(str1)>0:str1='('+str1+')';if длина(str2)=0:^str1;fi;fi;
  if длина(str2)>0:str2='('+str2+')';if длина(str1)=0:^str2;fi;fi;
  if длина(str1)+длина(str2)+длина(sum)>255:
     Message('Ошибка![функция РАБ.НФА.B01.abl]^MРезультат превышает максимальную^Mдлину строки в 256 символов^M'+str1+'^M'+sum+'^M'+str2,mterror);
     ^str2;
  fi;
  ^str1+sum+str2;
end;

2Func0 TimeToString(t:i):s;
^Раб.СТР.TimeToStr(t,'');
2End0;
2Func0 ВремяВстроку(t:i):s;
 ^TimeToString(t);
2End0;

var МассивВзятьГруппыСчетов []:s;
var МассивВзятьГруппыСчетов1[]:s;
var arri[]:i;
func ВзятьГруппыСчетов(УслСчДляГрСЧ:s;ИмяМассива:s;ГруппыСчСнач:s):i;
-- ФорматСч=1,2,3 (выбираются номера групп счета с его начала)

  var z,j,ii:i;
  ОчиститьПеременную(МассивВзятьГруппыСчетов1);
     if длина(ГруппыСчСнач)>0:-- работаем по группам с начала
        z=КоличествоСлов(ГруппыСчСнач,',');
        ОчиститьПеременную(arri);
        for j=1..z do arri[j]=int(ВыделитьСлово(j,ГруппыСчСнач,','));od;
        if z=1 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1]);
         | z=2 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2]);
         | z=3 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3]);
         | z=4 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4]);
         | z=5 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4],arri[5]);
         | z=6 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4],arri[5],arri[6]);
         | z=7 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4],arri[5],arri[6],arri[7]);
         | z=8 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4],arri[5],arri[6],arri[7],arri[8]);
         | z=9 :ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4],arri[5],arri[6],arri[7],arri[8],arri[9]);
         | z=10:ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4],arri[5],arri[6],arri[7],arri[8],arri[9],arri[10]);
         | z=11:ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4],arri[5],arri[6],arri[7],arri[8],arri[9],arri[10],arri[11]);
         | z=12:ii=ВзятьГруппуСчетов(УслСчДляГрСЧ,МассивВзятьГруппыСчетов,arri[1],arri[2],arri[3],arri[4],arri[5],arri[6],arri[7],arri[8],arri[9],arri[10],arri[11],arri[12]);
        fi;
     fi;
--     z=КоличествоСлов(ГруппыСч,'#');

--     ii=ВзятьГруппуСчетов(МаскаСчетаФКР+'.?.???.??.???&('+МаскаСч+')',st,6,7);
--     for j=1..ii do ДобавитьВмассив(st1,true,false,st[j]);od;
--     ii=ВзятьГруппуСчетов(МаскаСчетаКД+'.?.???.??.???&('+МаскаСч+')',st,8,9);
--     for j=1..ii do ДобавитьВмассив(st1,true,false,st[j]);od;
--     ii=ВзятьГруппуСчетов(МаскаСчетаКИВФ+'.?.???.??.???&('+МаскаСч+')',st,9,10);
--     for j=1..ii do ДобавитьВмассив(st1,true,false,st[j]);od;
--     ii=ДлинаМассива(st1);




 ^1;
end;
func ГраничныйСимволСлева(st_all:s;pos1:i;StrSymbols:s):i;
--func ГраничныйСимволСлева(ss1,p1-6,'~&|('):i;
var ss:s;
var t,z:i;
    StrSymbols=up(StrSymbols);
    ss=Up(SubStr(st_all,1,pos1));
    t=Length(ss)-1;
    for z=1..t do
      if pos(SubStr(ss,t-z+1,1),StrSymbols)>0:
         ^t-z+1;
      fi;
    od;
^0;
end;
func МаскаСчетов(Спр:s;ФорматСч:s;ДопУслСч:s):i;
-- ФорматСч=1,2,3#1,2,3,4 (до # выбираются номера групп счета с его начала, после # выбираются номера групп с конца счета)

 var МаскаСчетаНФАбал:S;
 var МаскаСчетаНФАзаб:S;
 var ss,ss1:S;
 var ii,j,k:i;

     МаскаСчетаНФАбал='*.?.10?.??.???';
     МаскаСчетаНФАзаб='ЗАБ.??.10?.??';


     ОчиститьПеременную(st1);
     ОчиститьПеременную(st2);
     ОчиститьПеременную(st3);
--     ii=ВзятьГруппуСчетов(МаскаСчетаФКР+'.?.???.??.???&('+МаскаСч+')',st,6,7);
--     for j=1..ii do ДобавитьВмассив(st1,true,false,st[j]);od;
--     ii=ВзятьГруппуСчетов(МаскаСчетаКД+'.?.???.??.???&('+МаскаСч+')',st,8,9);
--     for j=1..ii do ДобавитьВмассив(st1,true,false,st[j]);od;
--     ii=ВзятьГруппуСчетов(МаскаСчетаКИВФ+'.?.???.??.???&('+МаскаСч+')',st,9,10);
--     for j=1..ii do ДобавитьВмассив(st1,true,false,st[j]);od;
--     ii=ДлинаМассива(st1);
--     for k=1..3 do
--       ss=str(k)+'.';
--       for j=1..ii do
--         ss1=ss+st1[j]; -- 1.101.01
--         ss2='*.'+ss1+'.???';
--         for счета счет=ss2; do
--           if МаскаПризнаков(счет,true);
--         od;
--       od;
--     od;
     --Маска("1111", "22222");
--     ii=ВзятьГруппуСчетов(МаскаСчетаЗАБНФА+'.???.??&('+МаскаСчетаНФА+')',st,1,3,4);
--     for j=1..ii do ДобавитьВмассив(st1,true,false,st[j]);od;
^1;
end;
func МаскаСчетовНФА(Спр:s;ФорматСч:s;ДопУслСч:s):i;
^1;

end;

func СчетАн(Сч:s):s;
 var ln:i;
 ln=Length(Сч);
 if ln>12:
   Сч=SubStr(Сч,ln-12,13);
   if match(Сч,'.?.???.??.???'):Сч = SubStr(Сч, 8,2);
    | match(Сч,'ЗАБ.??.???.??'):Сч = SubStr(Сч,12,2);
    | true:^'';
   fi;
  | true:^'';
 fi;
 ^Сч;
end;

func СчетНФА(Сч:s):s;
     if Match(Сч, "*.???.?.10?.??.???")   : Сч=SubStr(Сч, 1, Length(Сч)-3)+"???";
     |  Match(Сч, "ЗАБ.??.10?.??")        : Сч=Сч;
     |  true:Сч='';
     fi;
 ^Сч;
end;

func СчетВИ(Сч:s):s;
 Сч=СчетАн(Сч);
 if length(Сч)=2:Сч=SubStr(Сч, 1,1);fi;
 if Сч='0':Сч='3';fi;
 ^Сч;
end;

func СчетКонстанта(МаскаДляВыбора:s):s;
 var j:i;
 var s,ss:s;
 j=0;
 try
   for счета s=МаскаДляВыбора do
    ss=s;
    j=j+1;if j=2:break;fi;
   od;
 except
 end;
 if j=1:ss=ss;  -- счет=константа
  | j=0:ss=' ';-- счетов нет вообще
  | true:ss='';-- счетов больше одного
 fi;

 ^ss;
end;
func Соотв101_105поНФА(НФА:s;ДляСчета:l):s;  -- РАБ.НФА.B01.Соотв101_105поНФА(
  if ДляСчета:
   | true:
     if pos(' '+SubStr(НФА,1,8),' НФА.101. НФА.102. НФА.103. НФА.105. НФА.106. НФА.108.')>0:^SubStr(НФА,5,6);fi;
  fi;
  if pos('НФА.101.01.',НФА)=1:^'101.?1';
   | pos('НФА.101.02.',НФА)=1:^'101.?2';
   | pos('НФА.101.03.',НФА)=1:^'101.?3';
   | pos('НФА.101.04.',НФА)=1:^'101.?4';
   | pos('НФА.101.05.',НФА)=1:^'101.?5';
   | pos('НФА.101.06.',НФА)=1:^'101.?6';
   | pos('НФА.101.07.',НФА)=1:^'101.?7';
   | pos('НФА.101.08.',НФА)=1:^'101.?8';
   | pos('НФА.102.00.',НФА)=1:^'102.??';
   | pos('НФА.103.01.',НФА)=1:^'103.?1';
   | pos('НФА.103.02.',НФА)=1:^'103.?2';
   | pos('НФА.103.03.',НФА)=1:^'103.?3';
   | pos('НФА.105.01.',НФА)=1:^'105.?1';
   | pos('НФА.105.02.',НФА)=1:^'105.?2';
   | pos('НФА.105.03.',НФА)=1:^'105.?3';
   | pos('НФА.105.04.',НФА)=1:^'105.?4';
   | pos('НФА.105.05.',НФА)=1:^'105.?5';
   | pos('НФА.105.06.',НФА)=1:^'105.?6';
   | pos('НФА.105.07.',НФА)=1:^'105.?7';
   | pos('НФА.105.08.',НФА)=1:^'105.?8';
   | pos('НФА.106.01.',НФА)=1:^'106.?1';
   | pos('НФА.106.02.',НФА)=1:^'106.?2';
   | pos('НФА.106.04.',НФА)=1:^'106.?4';
   | pos('НФА.106.03.',НФА)=1:^'106.?3';
   | pos('НФА.108.06.',НФА)=1:^'108.?6';
   | НФА='':^'10?.??';
   | true:^'';
  fi;
end;
func ан_сч_гр_поСЧНФА(СЧНФА:s):s;
  if  match(СЧНФА,'*.?.10?.??.???') and not(match(СЧНФА,'*.?.104.??.???') or match(СЧНФА,'*.?.109.??.???')):
      ^СчетВИ(СЧНФА);
  fi;
 ^'';
end;

func Соотв101_105поСЧНФА(НФА:s;СЧНФА:s):s;
  var ан_сч_гр:s;
  if pos(' '+SubStr(НФА,1,8),' НФА.101. НФА.102. НФА.103. НФА.105. НФА.106. НФА.108.')<1:^'';fi;
  СЧНФА=trim(up(СЧНФА));
  if СЧНФА=''           :^Соотв101_105поНФА(НФА,true);fi;
  if pos('ЗАБ.',СЧНФА)>0:^Соотв101_105поНФА(НФА,true);fi;
  ан_сч_гр=ан_сч_гр_поСЧНФА(СЧНФА);
  if  ан_сч_гр<>'':^SubStr(НФА,5,4)+ан_сч_гр+SubStr(НФА,10,1); fi;
 ^'';
end;

func Соотв106поНФА(НФА:s;ДляСчета:l):s;
  if pos('НФА.101.',НФА)=1:^if(ДляСчета,'106.?1','106.01');
   | pos('НФА.102.',НФА)=1:^if(ДляСчета,'106.?2','106.02');
   | pos('НФА.103.',НФА)=1:^if(ДляСчета,'106.?3','106.03');
   | pos('НФА.105.',НФА)=1:^if(ДляСчета,'106.?4','106.04');
   | pos('НФА.106.01.',НФА)=1:^if(ДляСчета,'106.?1','106.01');
   | pos('НФА.106.02.',НФА)=1:^if(ДляСчета,'106.?2','106.02');
   | pos('НФА.106.04.',НФА)=1:^if(ДляСчета,'106.?4','106.04');
   | pos('НФА.106.03.',НФА)=1:^if(ДляСчета,'106.?3','106.03');
   | pos('НФА.108.06.',НФА)=1:^if(ДляСчета,'106.?4','106.04');
   | true:^'';
  fi;
end;
func Соотв106поСЧНФА(НФА:s;СЧНФА:s):s;
  var ан_сч_гр:s;
  if pos(' '+SubStr(НФА,1,8),' НФА.101. НФА.102. НФА.103. НФА.105. НФА.106. НФА.108.')<1:^'';fi;
  СЧНФА=trim(up(СЧНФА));
  if СЧНФА=''           :^Соотв106поНФА(НФА,true);fi;
  if pos('ЗАБ.',СЧНФА)>0:^Соотв106поНФА(НФА,true);fi;
  ан_сч_гр=ан_сч_гр_поСЧНФА(СЧНФА);
  if  ан_сч_гр<>'':
     if pos('НФА.101.',НФА)=1 or pos('НФА.106.01.',НФА)=1: ^'106.'+ан_сч_гр+'1';
      | pos('НФА.102.',НФА)=1 or pos('НФА.106.02.',НФА)=1: ^'106.'+ан_сч_гр+'2';
      | pos('НФА.103.',НФА)=1 or pos('НФА.106.03.',НФА)=1: ^'106.'+ан_сч_гр+'3';
      | pos('НФА.105.',НФА)=1 or pos('НФА.106.04.',НФА)=1 or pos('НФА.108.06.',НФА)=1: ^'106.'+ан_сч_гр+'4';
     fi;
  fi;
 ^'';
end;

func Соотв107поНФА(НФА:s;ДляСчета:l):s;
  if pos('НФА.101.',НФА)=1:^if(ДляСчета,'107.?1','107.01');
   | pos('НФА.105.',НФА)=1:^if(ДляСчета,'107.?3','107.03');
   | pos('НФА.108.06.',НФА)=1:^if(ДляСчета,'107.?3','107.03');
   | pos('НФА.102.',НФА)=1:^if(ДляСчета,'107.?2','107.02');
   | true:^'';
  fi;
end;
func Соотв107поСЧНФА(НФА:s;СЧНФА:s):s;
  var ан_сч_гр:s;
  if pos(' '+SubStr(НФА,1,8),' НФА.101. НФА.102. НФА.103. НФА.105. НФА.106. НФА.108.')<1:^'';fi;
  СЧНФА=trim(up(СЧНФА));
  if СЧНФА=''           :^Соотв107поНФА(НФА,true);fi;
  if pos('ЗАБ.',СЧНФА)>0:^Соотв107поНФА(НФА,true);fi;
  ан_сч_гр=ан_сч_гр_поСЧНФА(СЧНФА);
  if  ан_сч_гр<>'':
     if pos('НФА.101.',НФА)=1 or pos('НФА.106.01.',НФА)=1: ^'107.'+ан_сч_гр+'1';
      | pos('НФА.102.',НФА)=1 or pos('НФА.106.02.',НФА)=1: ^'107.'+ан_сч_гр+'2';
--      | pos('НФА.103.',НФА)=1 or pos('НФА.106.03.',НФА)=1: ^'107.'+ан_сч_гр+'3';
      | pos('НФА.105.',НФА)=1 or pos('НФА.106.04.',НФА)=1 or pos('НФА.108.06.',НФА)=1: ^'107.'+ан_сч_гр+'3';
     fi;
  fi;
 ^'';
end;
func Соотв104поНФА(НФА:s):s;
  if pos('НФА.101.01.',НФА)=1:^'*.?.104.?1.410';
   | pos('НФА.101.02.',НФА)=1:^'*.?.104.?2.410';
   | pos('НФА.101.03.',НФА)=1:^'*.?.104.?3.410';
   | pos('НФА.101.04.',НФА)=1:^'*.?.104.?4.410';
   | pos('НФА.101.05.',НФА)=1:^'*.?.104.?5.410';
   | pos('НФА.101.06.',НФА)=1:^'*.?.104.?6.410';
--   | pos('НФА.101.09.',НФА)=1:^'*.?.104.07.410';
--   | pos('НФА.102.',НФА)   =1:^'*.?.104.08.420';

   | pos('НФА.101.07.',НФА)=1:^'*.?.104.?7.410';--библиотечный фонд
   | pos('НФА.101.08.',НФА)=1:^'*.?.104.?8.410';--прочие ОС
   | pos('НФА.102.',НФА)   =1:^'*.?.104.?9.420';

   | true:^'';
  fi;
end;
func Соотв104поСЧНФА(СЧНФА:s):s;
  var ss:s;
  var ln:i;
  if match(СЧНФА,'*.?.101.??.???') or match(СЧНФА,'*.?.102.??.???'):
     ln=Length(СЧНФА);
     ss=SubStr(СЧНФА,Ln-9,3);
     if ss='102':ss=SubStr(СЧНФА,Ln-5,1);^'*.?.104.'+ss+'9.420';
      | ss='101':ss=SubStr(СЧНФА,Ln-5,2);^'*.?.104.'+ss+'.410';
     fi;
  fi;
  ^'';
end;
Func ВзятьКонецСчетАмортПоСчетуНФА(СЧНФА:String) :String;
  var ss:s;
  var ln:i;
  ln=WordsCount(СЧНФА,'.');
  СЧНФА=ExtractWords(ln-3,4,СЧНФА,'.');
  if match(СЧНФА,'?.101.??.???') or match(СЧНФА,'?.102.??.???'):
     ss=SubStr(СЧНФА,3,3);
     if ss='102':ss=SubStr(СЧНФА,7,1);^'104.'+ss+'9.420';
      | ss='101':ss=SubStr(СЧНФА,7,2);^'104.'+ss+'.410';
     fi;
  fi;
  ^'';
end;              
--                    -3   -2   -1
-- 1    2    3     4   5  6  7   8
--188.0000.0000000.000.2.101.11.310
Func ВзятьСчетАмортПоСчетуНФА(СЧНФА:String) :String;
  var ss,ss1:s;
  var ln:i;
  ln=WordsCount(СЧНФА,'.');
  ss=ВзятьКонецСчетАмортПоСчетуНФА(СЧНФА);
  if ss<>'':
    ^ExtractWords(1,ln-3,СЧНФА,'.')+'.'+ss;
  fi;
  ^'';
end;
Func ВзятьКонецСчет101_102ПоСчетуАм(СЧАМ:String) :String;
  var ss:s;
  var ln:i;
  ln=WordsCount(СЧАМ,'.');
  ss=ExtractWords(ln-3,4,СЧАМ,'.');
  if match(ss,'?.104.??.???'):
     if SubStr(ss,8,1)='9':^'102.'+SubStr(ss,7,1)+'0.320';
      | true:^'101.'+SubStr(ss,7,2)+'.310';
     fi;
  fi;
  ^'';
end;
СчетаПодсистемыНФА:s='101|102|103|104|105|106|107|108|208|302|304|401|00';
s101:s='*101.?1.?10|*101.?2.?10|*101.?3.?10|*101.?4.?10|*101.?5.?10|*101.?6.?10|*101.?7.?10|*101.?8.?10';
s102:s='*102.??.?20';
s103:s='*103.?1.?30|*103.?2.?30|*103.?3.?30';
--s104:s='*104.01.410|*104.02.410|*104.03.410|*104.04.410|*104.05.410|*104.06.410|*104.07.410|*104.08.420';
s104:s='*104.?1.410|*104.?2.410|*104.?3.410|*104.?4.410|*104.?5.410|*104.?6.410|*104.?7.410|*104.?8.410|*104.?9.420';
s105:s='*105.?1.?40|*105.?2.?40|*105.?3.?40|*105.?4.?40|*105.?5.?40|*105.?6.?40|*105.?7.?40|*105.?8.?40';
s106:s='*106.?1.?10|*106.?2.?20|*106.?3.?30|*106.?4.?40';
s107:s='*107.?1.?10|*107.?2.?20|*107.?3.?40';
s208:s='*208.31.660|*208.32.660|*208.33.660|*208.34.660';
s302:s='*302.31.730|*302.32.730|*302.33.730|*302.34.730';
s304:s='*304.04.222|*304.04.226|*304.04.290|*304.04.310|*304.04.320|*304.04.340';
s401:s='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.272|*401.20.273|*401.30.000';
s00 :s='00';
sЗАБ:s='ЗАБАЛАНС|00Z|ЗАБ.??.101.?1|ЗАБ.??.101.?2|ЗАБ.??.101.?3|ЗАБ.??.101.?4|ЗАБ.??.101.?5|ЗАБ.??.101.?6|ЗАБ.??.101.?7|ЗАБ.??.101.?8|ЗАБ.??.102.?0|ЗАБ.??.103.?1|ЗАБ.??.103.?2|ЗАБ.??.103.?3|ЗАБ.??.105.?1|ЗАБ.??.105.?2|ЗАБ.??.105.?3|ЗАБ.??.105.?4|ЗАБ.??.105.?5|ЗАБ.??.105.?6|ЗАБ.??.105.?7';



--НФА.101.01 остатки :'*101.01.?10|*106.01.?10|*107.01.?10|ЗАБ.??.101.01';
--101.01 корр '*101.01.?10':'*101.01.310|*104.01.410|*106.01.?10|*106.04.?10|*208.19.660|*302.19.730|*304.04.310|*401.01.151|*401.01.152|*401.01.153|*401.01.172|*401.01.180|*401.01.241|*401.01.242|*401.01.251|*401.01.252|*401.01.271|*401.01.273|*401.03.000|00';
--106.01 корр '*106.01.?10':'*101.01.?10|*107.01.?10|*208.05.660|*208.09.660|*208.18.660|*208.19.660|*302.05.730|*302.09.730|*302.18.730|*302.19.730|*304.04.222|*304.04.226|*304.04.290|*304.04.310|*401.01.180|*401.03.000|00';
--107.01 корр '*107.01.?10':'*106.01.?10|*107.01.?10|*208.05.660|*208.09.660|*208.18.660|*208.19.660|*302.05.730|*302.09.730|*302.18.730|*302.19.730|*304.04.222|*304.04.226|*304.04.290|*304.04.310|*401.03.000|00';
--ЗАБ.101.01 корр 'ЗАБ.??.101.01|ЗАБАЛАНС|00Z';

func СоотвКоррсчПоСчНФАостаткиТекПериодаПрихФКР(СчНФА:s):s;-- возвращает корректное условие на выбор счета по НФА
  var ss:s;
  var ан_сч_гр:s;
  ан_сч_гр=ан_сч_гр_поСЧНФА(СчНФА);
  if соотв(СчНФА,'*101.??.310'):ss='*106.'+ан_сч_гр+'1.310|*304.04.310';
   | соотв(СчНФА,'*102.??.320'):ss='*106.'+ан_сч_гр+'0.320|*304.04.320';
   | соотв(СчНФА,'*103.??.330'):ss='*106.'+ан_сч_гр+'3.330|*304.04.330';
   | соотв(СчНФА,'*105.??.340'):ss='*106.'+ан_сч_гр+'4.340|*304.04.340|*208.34.660|*302.34.730';
  fi;
  ^ss;
end;
func СоотвКоррсчПоСчНФАостаткиТекПериодаПрихКД(СчНФА:s):s;-- возвращает корректное условие на выбор счета по НФА
  var ss:s;
  if соотв(СчНФА,'*101.?1.310'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*101.?2.310'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*101.?3.310'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*101.?4.310'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*101.?5.310'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*101.?6.310'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*101.?7.310'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*101.?8.310'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*102.?0.320'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*103.?1.330'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.180';
   | соотв(СчНФА,'*105.?1.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
   | соотв(СчНФА,'*105.?2.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
   | соотв(СчНФА,'*105.?3.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
   | соотв(СчНФА,'*105.?4.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
   | соотв(СчНФА,'*105.?5.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
   | соотв(СчНФА,'*105.?6.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
   | соотв(СчНФА,'*105.?7.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
   | соотв(СчНФА,'*105.?8.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
   | соотв(СчНФА,'*106.?1.310'):ss='*401.10.180';
   | соотв(СчНФА,'*106.?2.320'):ss='*401.10.180';
   | соотв(СчНФА,'*106.?4.340'):ss='*401.10.180';
   | соотв(СчНФА,'*108.?6.340'):ss='*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180';
  fi;
  ^ss;
end;
func СоотвКоррсчПоСчНФАостаткиТекПериода1(СчНФА:s):s;-- возвращает корректное условие на выбор счета по НФА
  var ss,ss1:s;
  if соотв(СчНФА,'*101.11.?10'):ss='*101.11.310|*104.11.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.12.?10'):ss='*101.12.310|*104.12.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.13.?10'):ss='*101.13.310|*104.13.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.15.?10'):ss='*101.15.310|*104.15.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.18.?10'):ss='*101.18.310|*104.18.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';

   | соотв(СчНФА,'*101.31.?10'):ss='*101.31.310|*104.31.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.32.?10'):ss='*101.32.310|*104.32.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.33.?10'):ss='*101.33.310|*104.33.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.35.?10'):ss='*101.35.310|*104.35.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.38.?10'):ss='*101.38.310|*104.38.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.34.?10'):ss='*101.34.310|*104.34.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.36.?10'):ss='*101.36.310|*104.36.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.37.?10'):ss='*101.37.310|*104.37.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';

   | соотв(СчНФА,'*102.30.?20'):ss='*102.30.320|*104.39.420|*106.32.?20|*106.34.?40|*208.32.660|*302.32.730|*304.04.320|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*103.11.?30'):ss='*103.11.330|*106.?3.?30|*304.04.330|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.31.?40'):ss='*105.?1.340|*106.?4.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.32.?40'):ss='*105.?2.340|*106.?4.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.33.?40'):ss='*105.?3.340|*106.?4.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.34.?40'):ss='*105.?4.340|*106.?4.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.35.?40'):ss='*105.?5.340|*106.?4.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.36.?40'):ss='*105.?6.340|*106.?4.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.37.?40'):ss='*105.?7.340|*106.?4.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.38.?40'):ss='*105.?8.340|*106.?4.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';

   | соотв(СчНФА,'*101.21.?10'):ss='*101.21.310|*104.21.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.22.?10'):ss='*101.22.310|*104.22.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.23.?10'):ss='*101.23.310|*104.23.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.25.?10'):ss='*101.25.310|*104.25.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.28.?10'):ss='*101.28.310|*104.28.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.24.?10'):ss='*101.24.310|*104.24.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.26.?10'):ss='*101.26.310|*104.26.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*101.27.?10'):ss='*101.27.310|*104.27.410|*106.?1.?10|*106.?4.?40|*304.04.310|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';

   | соотв(СчНФА,'*102.20.?20'):ss='*102.20.320|*104.29.420|*106.22.?20|*106.24.?40|*208.32.660|*302.32.730|*304.04.320|*401.10.151|*401.10.152|*401.10.153|*401.10.172|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.271|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.21.?40'):ss='*105.21.340|*106.24.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.22.?40'):ss='*105.22.340|*106.24.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.23.?40'):ss='*105.23.340|*106.24.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.24.?40'):ss='*105.24.340|*106.24.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.25.?40'):ss='*105.25.340|*106.24.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.26.?40'):ss='*105.26.340|*106.24.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.27.?40'):ss='*105.27.340|*106.24.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';
   | соотв(СчНФА,'*105.28.?40'):ss='*105.28.340|*106.24.?40|*208.34.660|*302.34.730|*304.04.340|*401.10.151|*401.10.152|*401.10.153|*401.10.180|*401.20.241|*401.20.242|*401.20.251|*401.20.252|*401.20.272|*401.20.273|*401.30.000|00';


   | соотв(СчНФА,'*106.?1.?10'):ss='*101.??.?10|*107.??.?10|*208.31.660|*208.32.660|*208.34.660|*302.31.730|*302.32.730|*302.34.730|*304.04.222|*304.04.226|*304.04.290|*304.04.310|*401.10.180|*401.30.000|00';
   | соотв(СчНФА,'*106.32.?20'):ss='*102.30.?20|*107.22.?20|*208.32.660|*302.32.730|*304.04.222|*304.04.226|*304.04.290|*304.04.310|*401.10.180|*401.30.000|00';

   | соотв(СчНФА,'*106.?4.?40'):ss='*105.??.?10|*107.33.?10|*208.34.660|*302.34.730|*304.04.222|*304.04.226|*304.04.290|*304.04.310|*401.10.180|*401.30.000|00';
  fi;
  ^ss;
end;

-- +*106.01.310/(*101.0?.410|*107.01.410|*208.05.660|*208.09.660|*208.18.660|*208.19.660|*302.05.730|*302.09.730|*302.18.730|*302.19.730|*304.04.222|*304.04.226|*304.04.290|*304.04.310|*401.01.180|*401.03.000|00)
-- +*106.01.310/(*101.0?.410|*107.01.410|*208.05.660|*208.09.660|*208.18.660|*208.19.660|*302.05.730|*302.09.730|*302.18.730|*302.19.730|*304.04.222|*304.04.226|*304.04.290|*304.04.310|*401.01.180|*401.03.000|00)
-- -*106.01.410/(*101.0?.310|*107.01.310|*304.04.222|*304.04.226|*304.04.290|*304.04.310)

--+*101.01.310/(*101.01.310|*106.01.410|*.106.04.440|*304.04.222|*304.04.290|*304.04.310|*401.01.151|*401.01.152|*401.01.153|*401.01.180|*401.03.000|00)
---*101.01.410/(*106.01.410|*.106.04.440|*304.04.222|*304.04.290|*304.04.310|*401.01.151|*401.01.152|*401.01.153|*401.01.180|*401.03.000|00)

-- *106.04.340/(*101.0?.410|*105.0?.440|*107.01.440|*107.03.440|*208.05.660|*208.09.660|*208.18.660|*208.22.660|*302.05.730|*302.09.730|*302.18.730|*302.22.730|*304.04.222|*304.04.226|*304.04.290|*304.04.340|*401.03.000|00)
-- *105.01.340/(*105.01.340|*106.04.440|*208.22.660|*302.22.730|*304.04.222|*304.04.290|*304.04.310|*401.01.151|*401.01.152|*401.01.153|*401.01.172|*401.01.180|*401.03.000|00)









-- кол и сум
-- +*106.01.310/(*101.0?.410|*107.01.410|*208.19.660|*302.19.730|*304.04.310|*401.01.180|*401.03.000|00)
-- -*106.01.410/(*101.0?.310|*107.01.310|*304.04.310)
-- только сум
-- +*106.01.310/(*101.0?.410|*208.05.660|*208.09.660|*208.18.660|*302.05.730|*302.09.730|*302.18.730|*304.04.222|*304.04.226|*304.04.290)
-- -*106.01.410/(*101.0?.310|*304.04.222|*304.04.226|*304.04.290)

-- кол и сум
--+*101.01.310/(*101.01.310|*106.01.410|*.106.04.440|*304.04.310|*401.01.151|*401.01.152|*401.01.153|*401.01.180|*401.03.000|00)
---*101.01.410/(*106.01.410|*.106.04.440|*304.04.310|*401.01.172|*401.01.241|*401.01.242|*401.01.251|*401.01.252|*401.01.271|*401.01.273|*401.03.000)

-- только сум
--+*101.01.310/(*106.01.410|*.106.04.440|*304.04.222|*304.04.290)
---*101.01.410/(*106.01.410|*.106.04.440|*304.04.222|*304.04.290|*104.01.410)

-- кол и сум
-- *106.04.340/(*101.0?.410|*105.0?.440|*107.03.440|*208.05.660|*208.09.660|*208.18.660|*208.22.660|*302.05.730|*302.09.730|*302.18.730|*302.22.730|*304.04.222|*304.04.226|*304.04.290|*304.04.340|*401.03.000|00)
-- *105.01.340/(*105.01.340|*106.04.440|*208.22.660|*302.22.730|*304.04.222|*304.04.290|*304.04.310|*401.01.151|*401.01.152|*401.01.153|*401.01.172|*401.01.180|*401.03.000|00)
-- только сум
-- *106.04.340/(*101.0?.410|*105.0?.440|*107.01.440|*107.03.440|*208.05.660|*208.09.660|*208.18.660|*208.22.660|*302.05.730|*302.09.730|*302.18.730|*302.22.730|*304.04.222|*304.04.226|*304.04.290|*304.04.340|*401.03.000|00)
-- *105.01.340/(*105.01.340|*106.04.440|*208.22.660|*302.22.730|*304.04.222|*304.04.290|*304.04.310|*401.01.151|*401.01.152|*401.01.153|*401.01.172|*401.01.180|*401.03.000|00)




-- *101.01.310/(*101.01.310|*106.01.410|*.106.04.440|*107.01.410|*209.19.660|*208.19.660|*302.19.730|*304.04.310|*304.04.290|*304.04.222|*401.01.15?

func СверткаУслСч(УслСч:s):s;
 var j,ln:i;
 var s,s0:s;
 s0='';ln=length(УслСч);
 try
   for счета s=УслСч do
    s0=s0+'|'+s;
    if length(s0)-1>ln:s0='|'+УслСч;break;fi;
   od;
 except
 end;
 ^SubStr(s0,2,255);

end;
--var fsin:s='|*222';
var fsin:s='';
var СчетаПодсистемыНФАбал:s='101|102|103|105|106|107|108';
func СоотвСчПоНФА(НФА:s;УслСч:s):s;-- возвращает корректное условие на выбор счета по НФА
  var ss,ss1:s;
--   189.1.16.22000.01.0000.1.401.01.172     3 1 2 5 2 4   1 3 2 3
--     189.0901.4700000.220.1.101.01.310     3 4 7 3       1 3 2 3
--  189.08.02.01.00.01.0000.1.201.03.510     3 2 2 2 2 2 4 1 3 2 3
  if pos('НФА.101.01.',НФА)=1:ss='00|*.101.?1*|ЗАБАЛАНС|*104.?1*|*.106.?1*|*.106.34*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.101.02.',НФА)=1:ss='00|*.101.?2*|ЗАБАЛАНС|*104.?2*|*.106.?1*|*.106.34*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.101.03.',НФА)=1:ss='00|*.101.?3*|ЗАБАЛАНС|*104.?3*|*.106.?1*|*.106.34*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.101.04.',НФА)=1:ss='00|*.101.?4*|ЗАБАЛАНС|*104.?4*|*.106.?1*|*.106.34*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.101.05.',НФА)=1:ss='00|*.101.?5*|ЗАБАЛАНС|*104.?5*|*.106.?1*|*.106.34*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.101.06.',НФА)=1:ss='00|*.101.?6*|ЗАБАЛАНС|*104.?6*|*.106.?1*|*.106.34*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.101.07.',НФА)=1:ss='00|*.101.?7*|ЗАБАЛАНС|*104.?7*|*.106.?1*|*.106.34*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.101.08.',НФА)=1:ss='00|*.101.?8*|ЗАБАЛАНС|*104.?8*|*.106.?1*|*.106.34*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';

   | pos('НФА.105.01.',НФА)=1:ss='00|*.105.?1*|*.106.?4*|*.109.??*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*24?|*25?)';
   | pos('НФА.105.02.',НФА)=1:ss='00|*.105.?2*|*.106.?4*|*.109.??*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*24?|*25?)';
   | pos('НФА.105.03.',НФА)=1:ss='00|*.105.?3*|*.106.?4*|*.109.??*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*24?|*25?)';
   | pos('НФА.105.04.',НФА)=1:ss='00|*.105.?4*|*.106.?4*|*.109.??*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*24?|*25?)';
   | pos('НФА.105.05.',НФА)=1:ss='00|*.105.?5*|*.106.?4*|*.109.??*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*24?|*25?)';
   | pos('НФА.105.06.',НФА)=1:ss='00|*.105.?6*|*.106.?4*|*.109.??*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*24?|*25?)';
   | pos('НФА.105.07.',НФА)=1:ss='00|*.105.?7*|*.106.?4*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*130|*24?|*25?)';
   | pos('НФА.105.08.',НФА)=1:ss='00|*.105.?8*|*.106.?4*|*.109.??*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*24?|*25?)';

   | pos('НФА.101.08.',НФА)=1:ss='00|*.101.?8*|ЗАБАЛАНС|*104.?8*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.102.00.',НФА)=1:ss='00|*.102.?0*|ЗАБАЛАНС|*104.?9*|*.106.?2*|*.208.32*|*.302.32*|*304.04.*&(*320|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
--   | pos('НФА.101.07.',НФА)=1:ss='00|*101.07.?10|ЗАБАЛАНС|ЗАБ.??.101.07|*106.01.???|*2.106.04.340|*107.01.???|*209.19.???|*208.19.???|*302.19.???|*304.04.310|*.??.271';
--   | pos('НФА.101.08.',НФА)=1:ss='00|*101.08.?10|ЗАБАЛАНС|*.101.08*|*106.01.???|*2.106.04.340|*107.01.???|*209.19.???|*208.19.???|*302.19.???|*304.04.310|*.??.271';
   | pos('НФА.103.',НФА)=1:ss='*.??.330|*.??.430|*.106.13.???|*.302.13.???|ЗАБ.??.103.??|ЗАБАЛАНС|(*401.10.1*|*401.20.2*|*?.109.*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.106.01',НФА)=1:ss='00|*.106.?1*|ЗАБАЛАНС|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.10.1*|*401.20.2*)&(*273|*271|*180|*172|*24?|*25?)';
   | pos('НФА.106.04',НФА)=1:ss='00|*.106.?4*|ЗАБАЛАНС|*.208.34*|*.302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*)&(*272|*273|*180|*172|*24?|*25?)';
   | pos('НФА.108.06.',НФА)=1:ss='00|*.108.?6*|*.106.?4*|*.109.??*|*208.34*|*302.34*|ЗАБАЛАНС|*304.04.*&(*340|*290'+fsin+')|(*401.10.1*|*401.20.2*|*?.109.*)&(*272|*273|*180|*172|*24?|*25?)';
   | true:^'';
  fi;
  if длина(УслСч)=0:^ss;
   | true:ss1=СчетКонстанта('('+ss+')&('+УслСч+')');
          if длина(ss1)>0:^trim(ss1);
           | true:^СверткаУслСч(ss);
          fi;
  fi;
end;
func СоотвСчПоНФАФКР(НФА:s;УслСч:s):s;-- возвращает корректное условие на выбор счета по НФА
  var ss,ss1:s;
  if pos('НФА.101.01.',НФА)=1:ss='00|*.101.?1*|*104.?1*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.101.02.',НФА)=1:ss='00|*.101.?2*|*104.?2*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.101.03.',НФА)=1:ss='00|*.101.?3*|*104.?3*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.101.04.',НФА)=1:ss='00|*.101.?4*|*104.?4*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.101.05.',НФА)=1:ss='00|*.101.?5*|*104.?5*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.101.06.',НФА)=1:ss='00|*.101.?6*|*104.?6*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.101.07.',НФА)=1:ss='00|*.101.?7*|*104.?7*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.101.08.',НФА)=1:ss='00|*.101.?8*|*104.?8*|*.106.?1*|*.106.?4*|*.107.?1*|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.105.01.',НФА)=1:ss='00|*.105.?1*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | pos('НФА.105.02.',НФА)=1:ss='00|*.105.?2*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | pos('НФА.105.03.',НФА)=1:ss='00|*.105.?3*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | pos('НФА.105.04.',НФА)=1:ss='00|*.105.?4*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | pos('НФА.105.05.',НФА)=1:ss='00|*.105.?5*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | pos('НФА.105.06.',НФА)=1:ss='00|*.105.?6*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | pos('НФА.105.07.',НФА)=1:ss='00|*.105.?7*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | pos('НФА.105.08.',НФА)=1:ss='00|*.105.?8*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | pos('НФА.102.00.',НФА)=1:ss='00|*.102.?0*|*104.?9*|*.106.?2*|*.106.?4*|*.107.?2*|*.208.32*|*.302.32*|*304.04.*&(*310|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.103.',НФА)=1:ss='*.??.330|*.??.430|*.106.13.???|*.302.13.???|ЗАБ.??.103.??|ЗАБАЛАНС|(*401.20.2*|*?.109.*)&(*273|*271|*24?|*25?)';
   | pos('НФА.106.01',НФА)=1:ss='00|*.106.?1*|ЗАБАЛАНС|*.208.31*|*.302.31*|*304.04.*&(*310|*290'+fsin+')|*401.20.*&(*273|*271|*24?|*25?)';
   | pos('НФА.106.04',НФА)=1:ss='00|*.106.?4*|ЗАБАЛАНС|*.208.34*|*.302.34*|*304.04.*&(*340|*290'+fsin+')|*401.20.*&(*272|*273|*24?|*25?)';
   | pos('НФА.108.06.',НФА)=1:ss='00|*.108.?6*|*.106.?4*|*208.34*|*302.34*|*304.04.*&(*340|*290'+fsin+')|(*401.20.*|*.109.??.*)&(*272|*273|*24?|*25?)';
   | true:^'';
  fi;
  if длина(УслСч)=0:^ss;
   | true:ss1=СчетКонстанта('('+ss+')&('+УслСч+')');
          if длина(ss1)>0:^trim(ss1);
           | true:^СверткаУслСч(ss);
          fi;
  fi;
end;
func СоотвСчПоНФАКД(НФА:s;УслСч:s):s;-- возвращает корректное условие на выбор счета по НФА
  var ss,ss1:s;
  if pos('НФА.101.',НФА)=1:ss='00|*401.10.*&(*180|*172|*15?)';
   | pos('НФА.105.',НФА)=1:ss='00|*401.10.*&(*180|*172|*15?)';
   | pos('НФА.106.01',НФА)=1:ss='00|*401.10.*&(*180|*172|*15?)';
   | pos('НФА.106.04',НФА)=1:ss='00|*401.10.*&(*180|*172|*15?)';
   | pos('НФА.102.',НФА)=1:ss='00|*401.10.*&(*180|*172|*15?)';
   | pos('НФА.103.',НФА)=1:ss='00|*401.10.*&(*180|*172|*15?)';
   | pos('НФА.108.06.',НФА)=1:ss='00|*401.10.*&(*180|*172|*15?)';
   | true:^'';
  fi;
  if длина(УслСч)=0:^ss;
   | true:ss1=СчетКонстанта('('+ss+')&('+УслСч+')');
          if длина(ss1)>0:^trim(ss1);
           | true:^СверткаУслСч(ss);
          fi;
  fi;
end;
func СоотвСчПоНФАЗАБ(НФА:s;УслСч:s):s;-- возвращает корректное условие на выбор счета по НФА
  var ss,ss1:s;
--   189.1.16.22000.01.0000.1.401.01.172     3 1 2 5 2 4   1 3 2 3
--     189.0901.4700000.220.1.101.01.310     3 4 7 3       1 3 2 3
--  189.08.02.01.00.01.0000.1.201.03.510     3 2 2 2 2 2 4 1 3 2 3
  if pos('НФА.101.01.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.101.?1|00Z';
   | pos('НФА.101.02.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.101.?2|00Z';
   | pos('НФА.101.03.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.101.?3|00Z';
   | pos('НФА.101.04.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.101.?4|00Z';
   | pos('НФА.101.05.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.101.?5|00Z';
   | pos('НФА.101.06.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.101.?6|00Z';
   | pos('НФА.101.07.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.101.?7|00Z';
   | pos('НФА.101.08.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.101.?8|00Z';
   | pos('НФА.105.01.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.105.?1|00Z';
   | pos('НФА.105.02.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.105.?2|00Z';
   | pos('НФА.105.03.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.105.?3|00Z';
   | pos('НФА.105.04.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.105.?4|00Z';
   | pos('НФА.105.05.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.105.?5|00Z';
   | pos('НФА.105.06.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.105.?6|00Z';
   | pos('НФА.105.07.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.105.?7|00Z';
   | pos('НФА.106.01.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.106.?1|00Z';
   | pos('НФА.106.02.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.106.?2|00Z';
   | pos('НФА.106.03.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.106.?3|00Z';
   | pos('НФА.106.04.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.106.?4|00Z';

   | pos('НФА.102.',НФА)   =1:ss='ЗАБАЛАНС|ЗАБ.??.102.??|00Z';
   | pos('НФА.103.01.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.103.?1|00Z';
   | pos('НФА.103.02.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.103.?2|00Z';
   | pos('НФА.103.03.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.103.?3|00Z';
   | pos('НФА.108.06.',НФА)=1:ss='ЗАБАЛАНС|ЗАБ.??.108.?6|00Z';
   | true:^'';
  fi;
  if длина(УслСч)=0:^ss;
   | true:ss1=СчетКонстанта('('+ss+')&('+УслСч+')');
          if длина(ss1)>0:^trim(ss1);
           | true:^СверткаУслСч(ss);
          fi;
  fi;
end;

func СоотвКОСГУпоНФА(НФА:s):s;
  if pos('НФА.101.',НФА)=1:^'(КОСГУ.?10*|КОСГУ.271*|КОСГУ.290*)';
   | pos('НФА.105.',НФА)=1:^'КОСГУ.?40*|КОСГУ.290*';
   | pos('НФА.102.',НФА)=1:^'(КОСГУ.?20*|КОСГУ.271*)';
   | pos('НФА.103.',НФА)=1:^'(КОСГУ.?30*)';
   | pos('НФА.106.01',НФА)=1:^'(КОСГУ.?10*|КОСГУ.271*|КОСГУ.226*|КОСГУ.290*)';
   | pos('НФА.106.02',НФА)=1:^'(КОСГУ.?10*|КОСГУ.271*|КОСГУ.226*|КОСГУ.290*)';
   | pos('НФА.106.04',НФА)=1:^'(КОСГУ.?40*|КОСГУ.271*|КОСГУ.226*|КОСГУ.290*)';
   | pos('НФА.108.06.',НФА)=1:^'КОСГУ.?40*|КОСГУ.290*';
   | true:^'';
  fi;
end;
func СоотвКВпоНФА(НФА:s):s;
  var ss:s;
  ss='КВ.'+Соотв106поНФА(НФА,false)+SubStr(НФА,11,255);
  if Name_A(ss)<>' ':^ss;fi;
  ^'';
end;
--((*.208.??.6??|*.302.??.6??)&(*.???.19.???|*.???.20.???|*.???.21.???|*.???.22.???))|*.304.04.3??|*.107.??.4??
func СоотвНФАпоСчету(СЧ:s):s;
  var ss:s;
  var ii:i;
  if не Соотв(СЧ,'*.?.???.??.???'):^'';fi;
  ii=КоличествоСлов(СЧ,'.');
  ss=ВыделитьСлова(ii-2,1,СЧ,'.');

  if СловоВСтроке(ss,'106#209#208#206#302','#'):ss=ВыделитьСлова(ii-1,1,СЧ,'.'); --01 19
   | СловоВСтроке(ss,'210#307#402#304#307#501#502#503#401','#'):ss=ВыделитьСлова(ii,1,СЧ,'.'); --310 410
   | СловоВСтроке(ss,'107','#'):ss=ВыделитьСлова(ii-2,2,СЧ,'.'); --310 410
   | true:^'';
  fi;
  if СловоВСтроке(ss,'11#31#310#410','#'):^'НФА.101.*|НФА.106.01*#pos("101.",ГРНФА)=1 or ГРНФА="106.01"';
   | СловоВСтроке(ss,'32#320#420','#'):^'НФА.102.*#pos("102.",ГРНФА)=1 or ГРНФА="106.02"';
   | СловоВСтроке(ss,'107.33#34#340#440#272','#'):^'НФА.105.*|НФА.106.04*|НФА.108.06*#pos("105.",ГРНФА)=1 or ГРНФА="106.04" or ГРНФА="108.06"';
   | СловоВСтроке(ss,'33#330#430','#'):^'НФА.103.*#pos("103.",ГРНФА)=1 or ГРНФА="106.03"';
   | СловоВСтроке(ss,'271','#'):^'(НФА.101.*&НФА.102.*)#(pos("101.",ГРНФА)=1 or pos("102.",ГРНФА)=1)';
   | true:^'';
  fi;
end;

func ВклВыклИзм(l0:l;l1:l;вкл:s;выкл:s):s;
 var s:s;
  if вкл ='':вкл ='Вкл_';fi;
  if выкл='':выкл='Выкл';fi;
  if l1  :s='['+вкл ;
   | true:s='['+выкл;
  fi;
  if l0<>l1:^s+'*] ';
   | true  :^s+'_] ' ;
  fi;
end;
Proc Menu_Настройки_пересчет(вкл:s;выкл:s);
  var kmnt:s;
  var i,j:i;
  kmnt='--';
  ClearVariable(Раб.НФА.B01.st);
  st[1]='Отказ от изменений'+kmnt+'Отказ от изменений(то же при нажатии [Esc] или [х])';
  st[2]='Применить изменения'+kmnt+'Применить все измененные настройки [*]';
  st[3]='Настройки|'+kmnt+'***** изменение настроек *****';
  j=ДлинаМассива(st1);
  for i=4..j do
    st[i]='Настройки|'+st2[i]+kmnt+ВклВыклИзм(logic[i],logic1[i],вкл,выкл)+if(logic1[i],st3[i],st4[i]);
  od;
end;
func Menu_Настройки(blank_N:s;вкл:s;выкл:s):s;--st [boolean1|имяboolean1|'комментарий на true'|'комментарий на false'],[boolean2|имяboolean1|'комментарий на true'|'комментарий на false'],[...]
 var ll:l;
 var i,j,k:i;
 var s1,s2,s3:s;
   k=ДлинаМассива(st);
   ClearVariable(Раб.НФА.B01.st1);
   ClearVariable(Раб.НФА.B01.st2);
   ClearVariable(Раб.НФА.B01.st3);
   ClearVariable(Раб.НФА.B01.st4);
   ClearVariable(Раб.НФА.B01.logic);
   ClearVariable(Раб.НФА.B01.logic1);
   for i=1..k do
     s1=st[i];
     st1[i+3]=ВыделитьСлово(1,s1,'|');
     st2[i+3]=ВыделитьСлово(2,s1,'|');
     st3[i+3]=ВыделитьСлово(3,s1,'|');
     st4[i+3]=ВыделитьСлово(4,s1,'|');
     if pos('[',st1[i+3])>0:s2=substr(st1[i+3],1,pos('[',st1[i+3])-1);
      | true:s2=st1[i+3];
     fi;
     if ПеременнаяСуществует(blank_N+'.'+s2):
--       logic[i+3]=ВзятьПеременнуюЛ(blank_N+'.'+st1[i+3]);
       logic[i+3]=ВзятьПеременнуюЛ(st1[i+3]);
--       logic[i+3]=ВыполнитьФункциюЛ('ВзятьПеременнуюЛ',st1[i+3]);
       logic1[i+3]=logic[i+3];
     fi;
   od;
   i=4;s1='';
   While i>2 do
     While i>2 do
      Menu_Настройки_пересчет(вкл,выкл);
      i=ДеревоАльтернатив('   ИЗМЕНЕНИЕ НАСТРОЕК',st,95,i,11,'|','Параметр','Комментарий',30,false);
      if i>3:logic1[i]=not logic1[i];fi;
      if i<1:i=1;fi;
     od;
     ll=false;
     for j=1..k do
       if logic1[j+3]<>logic[j+3]:ll=true;s1=s1+'|'+st1[j+3];fi;
     od;
     if i=1 и ll:i=Вопрос('Отказ от изменений!','Обнаружены изменения,'+chr(13)+'Вы уверены в отказе?','Отказ;Применить;Вернуться к выбору', mtWarning);fi;
     if i<1:i=1;fi;
   od;
   if i=2 и ll:s1=SubStr(s1,2,256);
    | true:s1='';
   fi;
^s1;
end;

--ПроверятьОшибки:l=РАБ.НФА.B00.ПроверятьОшибки;
------------ обработчики объектов --------------
--proc ПустоВМаскахСчетов;
--Message('Не заполнена картотека [Маски счетов]!'+chr(13)+
--        'Выберите Навигатор=>Информация=>Маски счетов');
--end;
func ОтказОтИзменений:l;
   ClearVariable(РАБ.НФА.B01.st);
  -- ClearVariable(РАБ.НФА.B01.st1);
   st[1]='Отказ от изменений               ([Esc] или закрыть это окно)';
   st[2]='Данные будут заменены пустым значением';
   if Альтернатива("Вы отказываетесь от изменений?",st,-1,2,12)<2:^true;fi;
   ^false;
end;
Proc РасчетЗавершен(msg:s;tms:i);
 Beep(64);
 if длина(msg)=0:
   if tms>0:msg='Расчет завершен!^MВремя расчета '+ВремяВстроку(tms);
    | true:msg='Расчет завершен!';
   fi;
  | true:msg=msg+' '+ВремяВстроку(tms);
 fi;
 Сообщение(msg);
end;

func ПроверкаНаКОНВ(КОНВ:i;КОНВ_ДНФА:i;Сообщать:l):l;
 if  КОНВ_ДНФА>5 и КОНВ>5:^true;
  |  КОНВ_ДНФА>0 и КОНВ_ДНФА<10 и КОНВ=1:-- операция написана под инструкцию 25н
    ^true;
  | КОНВ_ДНФА>0 и КОНВ_ДНФА<10 и КОНВ>5:-- операция написана под инструкцию 25н а движение под 70н, 
                                        -- но уже сконвертированно и не дается к редактированию и выводу кроме сопр док
    ^false;
  | КОНВ_ДНФА=0:
    if КОНВ>4 и КОНВ<10:-- движение создано как 70н и уже конвертированно как 25н(конвертировать не нужно+редактирование запрещенно)
       if Сообщать:Beep(16);Сообщение('Редактирование запрещенно!^MОперация создана как 70н и уже конвертированно как 25н',mtWarning);fi;
       ^false;
     | КОНВ=0:-- движение создано как 70н и еще не конвертированно (можно работать, если счета позволят :-))
       ^true;
     | КОНВ>0 и КОНВ<5:-- движение создано как 70н и уже конвертированно как 25н(но работать почему-то можно...)
       ^true;
    fi;
 fi;
 ^true;
end;
func ВидПоКОНВ(КОНВ:i;КОНВ_ДНФА:i):l;
 if КОНВ_ДНФА>0 и КОНВ_ДНФА<10 и КОНВ=1:-- операция написана под инструкцию 25н
    ^true;
  | КОНВ_ДНФА>0 и КОНВ_ДНФА<6 и КОНВ>5:-- операция написана под инструкцию 25н а движение под 70н,
                                        -- но уже сконвертированно и не дается к редактированию и выводу кроме сопр док
    ^false;
  | КОНВ_ДНФА>5 и КОНВ>5:-- операция написана под инструкцию 25н а движение под 70н, но потом переделано под 25,

    ^true;
  | КОНВ_ДНФА=0:^true;--осталась старая операция
 fi;
 ^true;
end;

func ПроверкаНаИзменения(ll:l):l;
 if ll:Beep(16);Сообщение('Операция проведена!'+chr(13)+'Для редактирования записи снимите флажок ПРОВОДИТЬ ОПЕРАЦИЮ.',mtWarning);fi;
^not ll;
end;
func ВопросДаНетНеНапоминать(ВопросТекст:s;ii:i):i;
  if ii=3:^3;fi;
  ^Вопрос('',ВопросТекст
            ,'Да;Нет;Нет(не напоминать)'
            ,тсПредупреждение);
end;

func ВопросНеНапоминать(ВопросТекст:s;ii:i):i;
  if ii=3:^3;fi;
  ^Вопрос('',ВопросТекст
            ,'Да;Помощь;Да(не напоминать)'
            ,тсПредупреждение);
end;
func ВопросСообщениеПомощь(ВопросТекст:s;ii:i):i;
  if ii=3:^3;fi;
  ^Вопрос('',ВопросТекст
            ,'Да;Помощь'
            ,тсПодтверждение);
end;


func ПроводитьНеНапоминать(ii:i):i;
  if ii=3:^3;fi;
  ^Вопрос('','Документ не будет обрабатываться!'+chr(13)+
             'Продолжть?'
            ,'Да;Нет(отмена);Да(не напоминать)'
            ,тсПредупреждение);
end;

func НеПравильныйПризнак(s:s):l;
 var ll:l;
 ll=ПравильныйПризнак(s);
 if not ll:Сообщение('Не правильное написание признака!'+chr(13)+
                     'Признак - одно слово, без пробелов,'+chr(13)+
                     'разрешено использовать только буквы,'+chr(13)+
                     'цифры, точку [.], подчеркивание [ _ ]'+chr(13)+
                     '001 МЕШОК.01 МЕШОК_01 ПЕТРОВ_А_П'
                     );fi;
^not ll;
end;

proc GoToFindTextInBlank(text:s);
var file,ss,ss1,NameBln:s;
var ii,jj,k,p,LNameBln,kolst,kolst1:i;
var ll:l;
 ClearTrace;
 ClearVariable(РАБ.НФА.B01.st);
 file='tempfind.txt';
 if ЕстьФайл(file):УдалитьФайл(file);fi;
 ll=ЗаписатьПеремВДБТ(file,false);
 ii=ТекстФайлОткрытьНаЧтение(file);
 try
   while not ТекстФайлКонецФайла(ii) do
     ss=ТекстФайлПрочитатьСтроку(ii);
     ss1=ss;
     p=pos('=',ss);
     if p>0:
       ss=SubStr(ss,1,p-1);
       LNameBln=Length(ss);
       p=pos('.',ss);
       while p>0 do
         ss=SubStr(ss,p+1,255);
         p=pos('.',ss);
       od;
       LNameBln=LNameBln-Length(ss);
       if pos(text,SubStr(ss1,pos('=',ss1)+1,255))>0:
          st[1]=ss;kolst=1;
  --        trace(ss);
       fi;
       break;
--     else break;
     fi;
   od;
   while not ТекстФайлКонецФайла(ii) do
     ss =ТекстФайлПрочитатьСтроку(ii);
     p=pos('=',ss);
     if p>0:
       if pos(text,SubStr(ss,pos('=',ss)+1,255))>0:
          kolst=kolst+1;
          st[kolst]=SubStr(ss,LNameBln+1,p-1-LNameBln);
--          trace(st[kolst]);
       fi;
     fi;
   od;
 Finally
   ТекстФайлЗакрыть(ii);
 End;
--ClearVariable(РАБ.НФА.B01.st1);
--kolst1=0;
ii=0;jj=0;
Template.Row=ii+1;
Template.Column=jj+1;
while ii<AsInteger(Template.Row) do
 ii=ii+1;--текушая строка
 while jj<AsInteger(Template.Column) do
   jj=jj+1;-- текущий столбец в строке
   ss=UP(AsString(Template.Field));
   if ss<>'':
     p=pos('[',ss);
     for k=1..kolst do
      if ss=st[k]: if not(ВопрДаОтказ('Продолжить поиск?')=кмдВерно):exit;fi;
       | (p=0 and pos(ss+'[',st[k])=1):
         if ss+'['+str(AsInteger(Template.Frame))+']'=st[k]: if not(ВопрДаОтказ('Продолжить поиск?')=кмдВерно):exit;fi;fi;
      fi;
     od;
   fi;
   Template.Column=jj+1;
 od;
 jj=0;
 Template.Column=jj+1;
 Template.Row=ii+1;
od;
end;
-- Template.Column=AsInteger(Template.Column)+1;
2Func СоотвСчета
 (
 значсч:s;-- ограничение! значсч должно являтся полным значением а не маской!
 маск:s
 ):Л;
var сч:s;
if маск='':^false;fi;
if not ПравильныйПризнак(значсч):^false;fi;
if Length(значсч)+Length(маск)+4<255:маск=значсч+'&('+маск+')';fi;
-- Проверяет соответствие счета маске, где маска - условие для отбора счетов
 for счета сч=маск do
  if значсч=сч:^true;fi;
 od;
 ^false;
2End;


2Func СоотвПризнака0 -- соответствие признака и маски, если значпр=пусто, то проверяет на существование признаков по маске
 (
 значпр:s;-- ограничение! значпр должно являтся полным значением а не маской!
 маск:s
 ):Л;
var пр:s;
if маск  ='':^false;fi;
if маск  ='*':^true;fi;
if значпр<>'':
   if not ПравильныйПризнак(значпр):^false;fi;
   if Name_A(значпр)=' ':^false;fi;
   if Length(значпр)+Length(маск)+4<255:маск=значпр+'&('+маск+')';fi;
fi;
-- Проверяет соответствие значпр маске, где маска - условие для отбора признаков
 for признака пр=маск do
  if значпр=пр or значпр='':^true;fi;
 od;
 ^false;
2End;

2Func СоотвПризнакаИСчета
 (
 значпр:s;-- ограничение! значпр должно являтся полным значением а не маской!
 маск:s;
 СчетДляДопМаскиПоСтруктуре:s
 ):Л;
var пр,ss1,ss:s;
 if маск='':^false;fi;
 if СчетДляДопМаскиПоСтруктуре<>'':
     ss1=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,true);
     if ss1='':ss1=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,false);
      | true:ss=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,false);
        if ss<>'':ss1=ss1+'|'+ss;ss='';fi;
     fi;
     if ss1<>'' и маск<>'':маск='('+маск+')&('+ss1+')';
      | true:маск=ss1+маск;
     fi;
     if ss1='':^false;fi;--нет привязанных справочников вообще
 fi;
 ^СоотвПризнака(значпр,маск);
2End;

--2Func0 2СоотвМаскиИСчета
-- (
-- маск:s;
-- СчетДляДопМаскиПоСтруктуре:s
-- ):Л;
--var пр,ss1,ss:s;
-- if маск='':^false;fi;
-- if СчетДляДопМаскиПоСтруктуре<>'':
--     ss1=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,true);
--     if ss1='':ss1=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,false);
--      | true:ss=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,false);
--        if ss<>'':ss1=ss1+'|'+ss;ss='';fi;
--     fi;
--     if ss1<>'' и маск<>'':маск='('+маск+')&('+ss1+')';
--      | true:маск=ss1+маск;
--     fi;
-- fi;
-- ^СоотвПризнака(значпр,маск);
--2End;

func ВзятьОснование(фильтр_осн:s):s;
var ss: s;
var r : record;
 try 
  r=OpenCardFile('Основание',фильтр_осн);
  if r<>nil:
   ss=GetCardFieldS('Основание',r,'ОСН');
  |true:ss='';
  fi;
 except
 end;
 ^ss;
end;

func СписокСправочниковПоМаске(МаскаДляВыбора:s;Разд:s):s; -- получаем список справочников работающих в маске  "спр1|спр2|спр3"
 var ll:l;
 var j,i:i;
 var s,ss,кроме,МаскаДляВыбора1:s;
 ClearVariable(РАБ.НФА.B01.st);
 j=0;кроме='';
   ll=true;
   While ll do
     ll=false;
     if кроме='':МаскаДляВыбора1=МаскаДляВыбора;
      | true:if Length(МаскаДляВыбора1)+Length(кроме)+4>255:^' ';fi;
         МаскаДляВыбора1=МаскаДляВыбора+'&~('+кроме+')';
     fi;
     for Признака s=МаскаДляВыбора1 do
      ss=ВзятьСправочникАналит(s);
      if ПоискВмассиве(st,ss,true)<1:
         ВставитьВмассивСорт(st,ss);
         кроме=кроме+if(кроме<>'','|'+ss+'.*',ss+'.*');
         ll=true;break;
      fi;
     od;
   od;

   j=длинамассива(st);
   ss='';
   for i=1..j do
     ss=ss+Разд+st[i];
   od;
   if ss<>'':ss=SubStr(ss,1+Length(Разд),256);fi;
   ^ss;
end;
var СписокДействСчетов_СчетКонстантаОст[]:s;
var ПоследняяМаскаДляВыбора_СчетКонстантаОст:s;

Proc ОбновитьСписокДействСчетов_СчетКонстантаОст(МаскаДляВыбора:s);
 var s,ss,ss1,ss2:s;
  МаскаДляВыбора=up(trim(МаскаДляВыбора));
  if length(МаскаДляВыбора)=0: --обнуляем список если МаскаДляВыбора пустая!
     ClearVariable(РАБ.НФА.B01.СписокДействСчетов_СчетКонстантаОст);
     ПоследняяМаскаДляВыбора_СчетКонстантаОст='';
     exit;
  fi;
  ПоследняяМаскаДляВыбора_СчетКонстантаОст=up(trim(ПоследняяМаскаДляВыбора_СчетКонстантаОст));
  if ПоследняяМаскаДляВыбора_СчетКонстантаОст<>МаскаДляВыбора:-- обновляем список!
     ПоследняяМаскаДляВыбора_СчетКонстантаОст=МаскаДляВыбора;
     ClearVariable(РАБ.НФА.B01.СписокДействСчетов_СчетКонстантаОст);
     for счета s=МаскаДляВыбора do
      ss=s;
      if Length(ss)>30:
         ss=SubStr(ss,1,Length(ss)-3)+'???';
      fi;
      if ПоискВмассиве(СписокДействСчетов_СчетКонстантаОст,ss,true)<1:-- обрабатываем новый счет
        if СчетИспользован(s):-- добавляем новый счет
           ДобавитьВмассив(СписокДействСчетов_СчетКонстантаОст,true,false,ss);
         | true:-- проверка на счета по маске ??? на конце
           if s<>ss: -- значит на конце ???, т.е. проверяем
             ss2=ss+'&~'+s;
             for счета ss1=ss2 do
              if СчетИспользован(ss1):-- добавляем новый счет и выходим из текущего цикла
                 ДобавитьВмассив(СписокДействСчетов_СчетКонстантаОст,true,false,ss);
                 break;
              fi;
             od;
           fi;

--         | true:
--            if s<>ss:
--              if pos('???',ss)>0:-- счет не заболансовый
--                ss2=SubStr(ss,Length(ss)-1,2);
--                ss1=SubStr(ss,1,Length(ss)-3)+'3'+ss2;
--                if ss1=s:-- ищем не проверенный счет
--                 ss1=SubStr(ss,1,Length(ss)-3)+'4'+ss2;
--                fi;
--                if Name_S(ss1)<>' ':-- если счет существует то добавляем его маску
--                   ДобавитьВмассив(СписокДействСчетов_СчетКонстантаОст,true,false,ss);
--                fi;
--              fi;
--            fi;
        fi;
      fi;
     od;
  fi;
end;
var СписокДействСчетов_НФАОст[]:s;
var ПоследняяМаскаДляВыбора_НФАОст:s;

Proc ОбновитьСписокДействСчетов_НФАОст(МаскаДляВыбора:s);
 var s,ss,ss1,ss2:s;
  МаскаДляВыбора=up(trim(МаскаДляВыбора));
  if length(МаскаДляВыбора)=0: --обнуляем список если МаскаДляВыбора пустая!
     ClearVariable(РАБ.НФА.B01.СписокДействСчетов_НФАОст);
     ПоследняяМаскаДляВыбора_НФАОст='';
     exit;
  fi;
  ПоследняяМаскаДляВыбора_НФАОст=up(trim(ПоследняяМаскаДляВыбора_НФАОст));
  if ПоследняяМаскаДляВыбора_НФАОст<>МаскаДляВыбора:-- обновляем список!
     ПоследняяМаскаДляВыбора_НФАОст=МаскаДляВыбора;
     ClearVariable(РАБ.НФА.B01.СписокДействСчетов_НФАОст);
     for счета s=МаскаДляВыбора do
      ss=s;
      if Length(ss)>30:ss=SubStr(ss,1,Length(ss)-3)+'???';fi;
      if ПоискВмассиве(СписокДействСчетов_НФАОст,ss,true)<1:-- обрабатываем новый счет
        if СчетИспользован(s):-- добавляем новый счет
           ДобавитьВмассив(СписокДействСчетов_НФАОст,true,false,ss);
         | true:-- проверка на счета по маске ??? на конце
           if s<>ss: -- значит на конце ???, т.е. проверяем
             ss2=ss+'&~'+s;
             for счета ss1=ss2 do
              if СчетИспользован(ss1):-- добавляем новый счет и выходим из текущего цикла
                 ДобавитьВмассив(СписокДействСчетов_НФАОст,true,false,ss);
                 break;
              fi;
             od;
           fi;
        fi;
      fi;
     od;
  fi;
end;

func СчетКонстантаОст(МаскаДляВыбора:s;УслОст:s;УслДат:d;Дб:l):s;
 var j,p,ii:i;
 var s,ss,s0:s;
 var УслАн:s;
 var ОстСум,ОстКол:n;
 j=pos('{',УслОст);
 p=pos('}',УслОст);
 if j>0 и p>0:УслАн=SubStr(УслОст,j,p-j+1);
  | true:УслАн='';
 fi;
-- УслАн
 j=0;
 ClearVariable(РАБ.НФА.B01.st);
 ClearVariable(РАБ.НФА.B01.st1);
--  ss=ВыборСчета(МаскаДляВыбора);
 ii=ДлинаМассива(СписокДействСчетов_СчетКонстантаОст);

 for p=1..ii do
   ss=СписокДействСчетов_СчетКонстантаОст[p];
   ОстСум=Остаток(ss+УслАн,УслДат+1);
   ОстКол=Остаток(ss+УслАн,УслДат+1,'КОЛ');
   if ОстСум>0 or ОстКол>0:
    j=j+1;
    st [j]=ss+' КОЛ='+str(ОстКол,3)+' Сумма='+str(ОстСум,3);
--    st1[j]=s;
   fi;
 od;

-- for счета s=МаскаДляВыбора do
--  ss=s;
--  if Length(ss)>30:ss=SubStr(ss,1,Length(ss)-3)+'???';fi;

----     ss=SubStr(ss,1,Length(ss)-3);
----     if Дб:ss=ss+'3??';
----      | true:ss=ss+'4??';
----     fi;


--  ОстСум=Остаток(ss+УслАн,УслДат+1);
--  ОстКол=Остаток(ss+УслАн,УслДат+1,'КОЛ');
--  if ОстСум>0 or ОстКол>0:
--   j=j+1;
--   st [j]=ss+' КОЛ='+str(ОстКол,3)+' Сумма='+str(ОстСум,3);
--   st1[j]=s;
--  fi;
-- od;
 if j=1:
  ss=ВыделитьСлово(1,st[j],' ');
 -- trace(str(длина(ss)+длина('&('+МаскаДляВыбора+')')));
  ss=ss+'&('+МаскаДляВыбора+')'; s0='';
  for счета s=ss do
   s0=ab(s0,'|',s);
--   ^s;
  od;
  if pos('|',s0)>0:
     ^ВыборСчета(s0);
  fi;
  ^s0;
-- ^st1[j];
 fi;

 if j=0:
  message('Не найдено счетов на которых числятся остатки данного НФА!',тсПредупреждение);
  ^' ';
 fi;
 j=Альтернатива("Выбор счета...",st,-1,1,12);
 if j=0:^' ';-- счетов нет вообще
  | true:
  ss=ВыделитьСлово(1,st[j],' ');
  ss=ss+'&('+МаскаДляВыбора+')';
  for счета s=ss do
   ^s;
  od;
--  ^st1[j];
 fi;
end;



func ВыборСчетаАльтернатива(МаскаДляВыбора:s):s;
 var j,p:i;
 var s,ss:s;
 j=0;
 ClearVariable(РАБ.НФА.B01.st1);
-- ВзятьГруппуСчетов
 for счета s=МаскаДляВыбора do
  ss=s;
   j=j+1;
   st1[j]=s;
 od;
 if j=1:^st1[j];fi;
 if j=0:
  message('Не найдено счетов на которых числятся остатки данного НФА!',тсПредупреждение);
  ^' ';
 fi;
 j=Альтернатива("Выбор счета...",st1,-1,1,12);
 if j=0:^' ';-- счетов нет вообще
  | true:^st1[j];
 fi;
end;

func ПризнакКонстанта(МаскаДляВыбора:s):s;
 var j,i:i;
 var s,ss:s;
 j=0;
 try
   for признака s=МаскаДляВыбора do
    ss=s;
    j=j+1;if j=2:break;fi;
   od;
 except
 end;


 if j=1:ss=ss;  -- признак=константа
  | j=0:ss=' ';-- признаков нет вообще
  | true:ss='';-- признаков больше одного
 fi;

-- if ss=' ':i=Вопрос('','Не найдено признаков удовлетворяющих условию отбора!','Ок;Создать новый',mtConfirmation);
--    if i=2:ss=ВыборПризнака(МаскаДляВыбора);fi;
-- fi;
 ^ss;
end;
func ВыборПризнакаДляПроводки(Дебет:s;Кредит:s;Параметры:s;Кроме:s):s;
-- Параметры='Д|К|ОБ|НОБ' Д=анализ по дебету К=анализ по кредиту Д|К=анализ по дебету и кредиту 
-- ОБ    =выборка обязательных справочников
-- НОБ   =выборка необязательных справочников
-- ОБ|НОБ=выборка обязательных и необязательных справочников
-- при пустом отборе возвращает пробел, при отказе выбора возвращает пустоту
 var db,kr,ob,nob:l;
 var ss1,ss2,ss:s;
 var i1,i2,j:i;
  db=СловоВСтроке('Д',Параметры,'|');
  kr=СловоВСтроке('К',Параметры,'|');
  if db и kr:ss1=ab(МаскаПризнаков(Дебет,false),'|',МаскаПризнаков(Кредит,false));
             ss2=ab(МаскаПризнаков(Дебет,true ),'|',МаскаПризнаков(Кредит,true ));
   | db     :ss1=МаскаПризнаков(Дебет ,false);
             ss2=МаскаПризнаков(Дебет ,true );
   | kr     :ss1=МаскаПризнаков(Кредит,false);
             ss2=МаскаПризнаков(Кредит,true );
   | true:^' ';
  fi;
  ob =СловоВСтроке('ОБ' ,Параметры,'|');
  nob=СловоВСтроке('НОБ',Параметры,'|');
  if ob и nob: -- раздельный запрос по обязательной и необязательной аналитике
             ss1=ab(МаскаПризнаков(Дебет,true ),'|',МаскаПризнаков(Кредит,true ));
             ss2=ab(МаскаПризнаков(Дебет,false),'|',МаскаПризнаков(Кредит,false));
     ClearVariable(РАБ.НФА.B01.st);
     i1=КоличествоСлов(ss1,'|');
     for j=1..i1 do ss=ВыделитьСлово(j,ss1,'|');if не СловоВСтроке(ss,Кроме,'|'):ДобавитьВмассив(st,true,false,'Обязательные#'+ss+'--'+ПолучитьИмяСправ(ВыделитьСлово(1,ss,'.')));fi;od;
     i2=КоличествоСлов(ss2,'|');
     for j=1..i2 do ss=ВыделитьСлово(j,ss2,'|');if не СловоВСтроке(ss,Кроме,'|'):ДобавитьВмассив(st,true,false,'Необязательные#'+ss+'--'+ПолучитьИмяСправ(ВыделитьСлово(1,ss,'.')));fi;od;
     if длинамассива(st)<1:^' ';fi;
     i1=AlternateTree('Выбор справочника',st,-1,1,10,'#','СПРАВОЧНИКИ','');
     if i1<1:^'';fi;
     ss1=ВыделитьСлово(2,st[i1],'#');
     ss1=trim(ВыделитьСлово(1,ss1,'--'));
   | ob     :ss1=abl(ss1,'&~',Кроме);
   | nob    :ss1=abl(ss2,'&~',Кроме);
   | true:ss1=ab(ss1,'|',ss2);ss1=abl(ss1,'&~',Кроме);
  fi;
  ss=ПризнакКонстанта(ss1);-- проверка на возможность выбора в целом
  if ss='':^ВыборПризнака(ss1);
   | true:^ss;
  fi;
end;
func РазбитьСтроку(Ст:s;Через:i):s;
 var КолСлов,i,j:i;
 var ss:s;
   КолСлов=WordsCount(Ст," ");
   ss=ExtractWord(1,Ст," ");
   for i=2..КолСлов do
     ss=ss+if(((i-1)/Через)=trunc((i-1)/Через),chr(13),' ')+ExtractWord(i,Ст," ");
   od;
   ^ss;
end;

2Func0 УдалитьПризнакИзНабора (СтрокаАн:S; Разделитель1:S;АнКудалению:S):S;
var n,nn,len:i;
 if СтрокаАн="": ^""; fi;
 Разделитель1=up(Разделитель1);
 СтрокаАн=up(Разделитель1+СтрокаАн+Разделитель1);
-- СтрокаАн=up(СтрокаАн+Разделитель1);
 АнКудалению=up(Разделитель1+АнКудалению+Разделитель1);
 len=length(АнКудалению);
 n=pos(АнКудалению,СтрокаАн);
 while n>0 do СтрокаАн=Удалить(СтрокаАн,n+1,len-1);n=pos(АнКудалению,СтрокаАн); od;
 len=length(Разделитель1);
 nn =length(СтрокаАн);
 if SubStr(СтрокаАн,nn-len+1,len)=Разделитель1:
 СтрокаАн=Удалить(СтрокаАн,nn-len+1,len);
 fi;
 if pos(Разделитель1,СтрокаАн)=1:СтрокаАн=Удалить(СтрокаАн,1,len);fi;
-- if Удалить(СтрокаАн,1,length(СтрокаАн)-len)=Разделитель1:СтрокаАн=Удалить(СтрокаАн,length(СтрокаАн)-len,len);fi;

 ^СтрокаАн;
2End0;

2Func0 НаитиПервыйПризнакИзНабораПоСправочникуUP (СтрокаАн:S; Разделитель:S;СПР:S):S;--СтрокаАн,Разделитель1,СПР в верхнем регистре!
2 --СПР=справочник с точкой на конце и содержит Разделитель в начале
2 --СтрокаАн с Разделитель1 в начале и в конце!
var n,nn,len:i;
 n=pos(СПР,СтрокаАн);
 if n>0:СтрокаАн=SubStr(СтрокаАн,n+1,255);^SubStr(СтрокаАн,1,pos(Разделитель,СтрокаАн)-1);
  | true:^"";
 fi;
2End0;

2Func0 УдалитьПризнакИзНабораПоСправочникуUP (СтрокаАн:S; Разделитель1:S;АнКудалению:S):S;--СтрокаАн,Разделитель1,АнКудалению в верхнем регистре!
var n,nn,len:i;
 if СтрокаАн="": ^""; fi;
 СтрокаАн=up(Разделитель1+СтрокаАн+Разделитель1);
-- СтрокаАн=up(СтрокаАн+Разделитель1);
 АнКудалению=up(Разделитель1+АнКудалению+Разделитель1);
 len=length(АнКудалению);
 n=pos(АнКудалению,СтрокаАн);
 while n>0 do СтрокаАн=Удалить(СтрокаАн,n+1,len-1);n=pos(АнКудалению,СтрокаАн); od;
 len=length(Разделитель1);
 nn =length(СтрокаАн);
 if SubStr(СтрокаАн,nn-len+1,len)=Разделитель1:
 СтрокаАн=Удалить(СтрокаАн,nn-len+1,len);
 fi;
 if pos(Разделитель1,СтрокаАн)=1:СтрокаАн=Удалить(СтрокаАн,1,len);fi;
-- if Удалить(СтрокаАн,1,length(СтрокаАн)-len)=Разделитель1:СтрокаАн=Удалить(СтрокаАн,length(СтрокаАн)-len,len);fi;

 ^СтрокаАн;
2End0;

var СписокУслВыборАналитики[]:s;--УсловиеНаАналитику
var СписокЗнчВыборАналитики[]:s;--ПоследнийВыбранныйЭлемент
var СписокУслВыборСчета[]:s;--УсловиеНаСчета
var СписокЗнчВыборСчета[]:s;--ПоследнийВыбранныйСчет
func ПоследнийВыбранныйЭлемент(УсловиеНаАналитику:s):s;
  var ii:i;
  ii=ПоискВМассиве(СписокУслВыборАналитики,УсловиеНаАналитику,True);
  if ii>0:^СписокЗнчВыборАналитики[ii];fi;
  ^'';
end;
Proc ОбновитьВыбранныйЭлемент(УсловиеНаАналитику:s;ВыбранныйЭлемент:s);
  var ii:i;
  ii=ПоискВМассиве(СписокУслВыборАналитики,УсловиеНаАналитику,True);
  if ii>0:СписокЗнчВыборАналитики[ii]=ВыбранныйЭлемент;
   | true:
     ii=ВставитьВмассивСорт(СписокУслВыборАналитики,УсловиеНаАналитику);
     ВставитьВмассив(СписокЗнчВыборАналитики,ii,ВыбранныйЭлемент);
  fi;
end;
func ПоследнийВыбранныйСчет(УсловиеНаСчета:s):s;
  var ii:i;
  ii=ПоискВМассиве(СписокУслВыборСчета,УсловиеНаСчета,True);
  if ii>0:^СписокЗнчВыборСчета[ii];fi;
  ^'';
end;

Proc ОбновитьВыбранныйСчет(УсловиеНаСчета:s;ВыбранныйСчет:s);
  var ii:i;
  ii=ПоискВМассиве(СписокУслВыборСчета,УсловиеНаСчета,True);
  if ii>0:СписокЗнчВыборСчета[ii]=ВыбранныйСчет;
   | true:
     ii=ВставитьВмассивСорт(СписокУслВыборСчета,УсловиеНаСчета);
     ВставитьВмассив(СписокЗнчВыборСчета,ii,ВыбранныйСчет);
  fi;
end;
func ВыборСчета1(МаскаДляВыбора:s):s;
 var ss:s;
   ss=ВыборСчета(МаскаДляВыбора,false,ПоследнийВыбранныйСчет(МаскаДляВыбора));
   if ss<>'':ОбновитьВыбранныйСчет(МаскаДляВыбора,ss);fi;
 ^ss;
end;

func ВыборСчетаПроверка(СтароеЗначение:s;МаскаДляВыбора:s):s;
 var ss:s;
   ss=СчетКонстанта(МаскаДляВыбора);
   if ss='':ss=ВыборСчета1(МаскаДляВыбора);fi;
 if ss='':if ОтказОтИзменений:ss=СтароеЗначение;fi;fi;
 ^ss;
end;
func ВыборСчетаНФАПроверка(СтароеЗначение:s;НФА:s;фильтрсчета:s):s;
 var ss,МаскаДляВыбора:s;
   МаскаДляВыбора='(*.?.'+Соотв101_105поНФА(НФА,true)+'.???|*.?.'+Соотв107поНФА(НФА,true)+'.???|*.?.'+Соотв106поНФА(НФА,true)+'.???|ЗАБ.??.'+Соотв101_105поНФА(НФА,true)+')'+фильтрсчета;
   ss=СчетКонстанта(МаскаДляВыбора);
   if ss='':ss=ВыборСчета1(МаскаДляВыбора);fi;
 if ss='':if ОтказОтИзменений:ss=СтароеЗначение;fi;fi;
 ^ss;
end;
func ВыборПризнака1(МаскаДляВыбора:s;Усл1:l):s;
 var ss,ss1:s;
 var j:i;
 ss='';
 if Усл1:
   ss=ПризнакКонстанта(МаскаДляВыбора);
   if ss='':ss=ВыборПризнака(МаскаДляВыбора,false,false,ПоследнийВыбранныйЭлемент(МаскаДляВыбора));fi;
 fi;
 if ss<>'':ОбновитьВыбранныйЭлемент(МаскаДляВыбора,ss);fi;
 ^ss;
end;

func ВзятьКБКСчета(Счет:s):s;
 var p:i;
 if Счет='00':^'*';fi;
 if не соотв(Счет,'*.?.???.??.???'):^'ЗАБ*';fi;
-- if не соотв(Счет,'*.?.???.??.???'):^'.';fi;
 p=КоличествоСлов(Счет,'.');
 if соотв(Счет,'???.?.*.?.???.??.???') or соотв(Счет,'?.*.?.???.??.???'):^'*.'+ВыделитьСлово(p-3,Счет,'.')+'.';fi;
 ^ВыделитьСлова(1,p-3,Счет,'.')+'.';
-- ^Раб.Бюджет2005.ВзятьКодСчета(Счет,'','ИСТ',true)+'.';
end;
func ВзятьВДСчета(Счет:s):s;
 var p:i;
 if не соотв(Счет,'*.?.???.??.???'):^'';fi;
-- if не соотв(Счет,'*.?.???.??.???'):^'.';fi;
 p=КоличествоСлов(Счет,'.');
 ^ВыделитьСлово(p-3,Счет,'.');
-- ^Раб.Бюджет2005.ВзятьКодСчета(Счет,'','ИСТ',true)+'.';
end;

func СобратьФильтрПоМаске(Поле:s;Маска:s;Справочник:s):s;
 var Спр,f,f1,ss:s;
 var i,j,l:i;
 var ll:l;
   ll=false;
   for признака ss='('+Справочник+'.*)&('+Маска+')' do ll=true;break;od;
   if ll  :^'1=1';
    | true:^'1=0';
   fi;

  Спр='|'+Справочник;
  if pos(Спр+'!',Маска)>0:
     f='1=1';
   | true:
     f='';
     Спр=Спр+'.';
     l=length(Спр);
     i=pos(Спр,Маска);
     ss=Substr(Маска,i,255);
    while i>0 do 
      ss=Substr(ss,l+1,255);
      j=pos('|',ss);
      f1=SubStr(ss,1,j-1);
      f=f+" or Соотв("+Поле+",'"+f1+"')";
      i=pos(Спр,ss);
      ss=Substr(ss,i,255);
    od;
    if pos(' or ',f)=1:
     f=Substr(f,5,255);
    fi;
    if length(f)=0:f='1=0';fi;
  fi;
  ^f;
end;


func СоответствиеСправочникаКартотеке(спр:s):s;
  var rz:s;
  rz='#';
  if спр='Ф.*'       :^РАБ.НФА.B00.СОТРУДНИК    +rz+'1=1'    +rz+спр+rz+'* (Физические лица)';
   | спр='МОЛ.*'     :^РАБ.НФА.B00.СОТРУДНИК    +rz+'МОЛ'    +rz+спр+rz+'* (Материально ответственные)';
   | спр='КОМИССИЯ.*':^РАБ.НФА.B00.СОТРУДНИК    +rz+'КОМ'    +rz+спр+rz+'* (Члены комиссии)';
   | спр='К.*'       :^РАБ.НФА.B00.КОНТРАГЕНТ   +rz+'1=1'    +rz+спр+rz+'* (Организации)';
   | спр='М.*'       :^РАБ.НФА.B00.МЕСТО        +rz+'1=1'    +rz+спр+rz+'* (Места хранения и экспл)';
   | спр='П.*'       :^РАБ.НФА.B00.ПОДРАЗДЕЛЕНИЕ+rz+'1=1'    +rz+спр+rz+'* (Подразделения)';
   | спр='НФА.*'     :^РАБ.НФА.B00.НФА          +rz+'1=1'    +rz+спр+rz+'* (НФА)';
   | спр='РОСТ.*'    :^'РПО_РОСТ'               +rz+'1=1'    +rz+спр+rz+'* (Роста)';
   | спр='РАЗМЕР.*'  :^'РПО_РАЗМЕР'             +rz+'1=1'    +rz+спр+rz+'* (Размеры)';
--   | спр='ПЕРИОД.*'  :^'ПЕРИОД'                 +rz+'1=1'    +rz+спр+rz+'* (Периоды, сроки, даты)';
   | спр='ДОК.*'     :^'РПО_ДОК'                +rz+'1=1'    +rz+спр+rz+'* (Зарегистрированные документы)';
   | спр='ПБС.*'     :^РАБ.НФА.B00.КОНТРАГЕНТ   +rz+'РПО_ПБС'+rz+спр+rz+'* (ПБС)';
  fi;
  ^' ';
end;

func ВыборПризнакаПроверка1(Маска_:s;СчетДляДопМаскиПоСтруктуре:s):s;
var i,j,k,z,wa:i;
var rec:record;
var ll:l;
var ss,ss1,f,f1,Поле,кмнт,крт,имякрт,Маск,Маск0:s;
 Маска_=Up(Маска_);
 if СчетДляДопМаскиПоСтруктуре<>'':
     ss1=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,true);
     if ss1='':ss1=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,false);
      | true:ss=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,false);
        if ss<>'':ss1=ss1+'|'+ss;ss='';fi;
     fi;
     if ss1<>'' и Маска_<>'':Маска_='('+Маска_+')&('+ss1+')';
      | true:Маска_=ss1+Маска_;
     fi;
 fi;
 ss=ПризнакКонстанта(Маска_);-- проверка на возможность выбора в целом
 if ss<>'':^ss;fi;           -- СписокСправочниковПоМаске должен вернуть не пустую строку или ' ' в случае ошибки (больше 255 символов)
end;

func ВыборПризнакаПроверка(КартАн:l;СтароеЗначение:s;Маска_:s;Маска_Карт:s;СчетДляДопМаскиПоСтруктуре:s):s;
var i,j,k,z,wa:i;
var rec:record;
var ll:l;
var ss,ss1,f,f1,Поле,кмнт,крт,имякрт,Маск,Маск0:s;
 Маска_=Up(Маска_);
 if СчетДляДопМаскиПоСтруктуре<>'':
     ss1=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,true);
     if ss1='':ss1=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,false);
      | true:ss=МаскаПризнаков(СчетДляДопМаскиПоСтруктуре,false);
        if ss<>'':ss1=ss1+'|'+ss;ss='';fi;
     fi;
     if ss1<>'' и Маска_<>'':Маска_='('+Маска_+')&('+ss1+')';
      | true:Маска_=ss1+Маска_;
     fi;
 fi;
 ss=ПризнакКонстанта(Маска_);-- проверка на возможность выбора в целом
 if ss<>'':^ss;fi;           -- СписокСправочниковПоМаске должен вернуть не пустую строку или ' ' в случае ошибки (больше 255 символов)

 if NOT КартАн:
  ss=ВыборПризнака1(Маска_,true);
  if ss='':if ss<>СтароеЗначение: if ОтказОтИзменений:ss=СтароеЗначение;fi;fi;fi;
  ^ss;
 fi;
2 --------------------- обработка для КартАн=true -----------------
 i=0;
 Маск0=Маска_;
 ClearVariable(РАБ.НФА.B01.st    );
 ClearVariable(РАБ.НФА.B01.Карт  );
 ClearVariable(РАБ.НФА.B01.Фильтр);
 ClearVariable(РАБ.НФА.B01.ПолеПр);
 ClearVariable(РАБ.НФА.B01.МаскаК);--ВзятьСправочникАналит
 if Length(Маска_Карт)>3:-- есть явный фильтр для картотек
    k=КоличествоСлов(Маска_Карт,'#');
    z=int(k/3);
    for j=1..z do
      i=i+1;
      Карт  [i]=ВыделитьСлово(j*3-2,Маска_Карт,'#');-- имя картотеки
      Фильтр[i]=ВыделитьСлово(j*3-1,Маска_Карт,'#');-- фильтр картотеки
      МаскаК[i]=ВыделитьСлово(j*3  ,Маска_Карт,'#');-- задействованные справочники П.*|М.* или К.*|ПБС.* или *
      st[i]=Карт[i];
    od;
    if z*3<k:-- последнее слово=условие на выбор аналитических признаков при выборе из дерева аналитики
             -- начинаем разбор последнего слова на выбор из картотек по работающим в нем справочникам
             -- Получаем справочники в которых присутствует аналитика которую можно выбрать по Маска_
       Маск0=ВыделитьСлово(k,Маска_Карт,'#');
    fi;
 fi;
2-------------------------------- заполняем оставшиеся картотечные справочники ------------------
 Маск=СписокСправочниковПоМаске(Маск0,'.*|');
 if Length(Маск)>0:
    if SubStr(Маск,Length(Маск)-1,2)<>'.*':Маск=Маск+'.*';fi;-- получили СписокСправочниковПоМаске без ошибок, начинаем искать соответствие с картотеками
    k=КоличествоСлов(Маск,'.*|');
    ss1=Маск;
    for j=1..k do
      ss=ВыделитьСлово(j,Маск,'|');
      f=СоответствиеСправочникаКартотеке(ss);
      if f<>' ':-- есть соответствие=>расшифровка+заполнение рабочих массивов+УдалитьПризнакИзНабора
         if ПоискВмассиве(МаскаК,ss)<1:
           i=i+1;
           Карт  [i]=ВыделитьСлово(1,f,'#');-- имя картотеки
           Фильтр[i]=ВыделитьСлово(2,f,'#');-- фильтр картотеки
           МаскаК[i]=ВыделитьСлово(3,f,'#');-- задействованные справочники П.*|М.* или К.*|ПБС.* или *
           st[i]=МаскаК[i]+ВыделитьСлово(4,f,'#');
--           ss1=УдалитьПризнакИзНабора(ss1,'|',ss);
         fi;
           ss1=УдалитьПризнакИзНабора(ss1,'|',ss);
      fi;
    od;
    Маск=ss1;
  | true:Маск=Маск0;
 fi;
 if Маск<>'':
    i=i+1;
    st[i]=Маск+' признаки для выбора из дерева аналитики';
    МаскаК[i]='('+Маск+')&('+Маска_+')';
 fi;
 if i=1:j=1;else j=Альтернатива("Выбор признака",st,-1,1,12);fi;
 if j>0:
   if Карт[j]<>'':
     wa=OpenWorkArea(Карт[j],'',Фильтр[j]);
      if records(wa)=1:rec=ВзятьКлючЗаписи(wa,1);
       --  ss=МаскаК[j]+GetFieldS(wa,1,ПолеПр[j]);
       | true: rec=ОткрытьКартотеку(Карт[j],Фильтр[j]);
      fi;
      if rec<>nil:
           ОбработатьАналит;
   --        if not Автообработка:ОбработатьАналит;fi;

           k=ЧислоПризнаковЗаписи(Карт[j],rec);
           if k=1:ss=ПризнакЗаписи(Карт[j],rec,1);
              if not 2СоотвПризнака0(ss,'('+МаскаК[j]+')&('+Маск0+')'):
              ss='';
           fi;
         | true:
           ClearVariable(РАБ.НФА.B01.st);
           z=0;
           for i=1..k do
             ss=ПризнакЗаписи(Карт[j],rec,i);
             if 2СоотвПризнака0(ss,'('+МаскаК[j]+')&('+Маск0+')'):z=z+1;st[z]=ss+' - -'+Name_A(ss);fi;
           od;
           if z=0:ss=' ';
            | true:
              if z=1:ss=SubStr(st[1],1,Pos(' ',st[1])-1);
               | true:
                 i=Альтернатива("Выбор признака",st,-1,1,12);
                 ss=if(i>0,SubStr(st[i],1,Pos(' ',st[i])-1),'');
              fi;
           fi;
        fi;
       | true:ss='';
      fi;
     CloseWorkArea(wa);
    | true:ss=ВыборПризнака1(МаскаК[j],true);

   fi;
  | true:ss='';
 fi;



 if ss='':if ОтказОтИзменений:ss=СтароеЗначение;fi;fi;

 ^ss;
end;

func ВыводНФА__:i;
 var j:i;
  ClearVariable(РАБ.НФА.B01.st);
  st[1]='Код и наименование';
  st[2]='Только наименование';
  st[3]='Только код';
  j=Альтернатива('Показать НФА...',st,-1,1);
  ^j-1;
end;

proc test(s:s);
--message(ВыборПризнакаПроверка(true,'МОЛ.1','DSF.АЫП|МОЛ.1|МОЛ.2|МАТ!|МБП.*',''));
 -- message(СобратьФильтрПоМаске('Поле','|DSF.АЫП|A.ЫВА|A.ЫВ|DSF.АЫП|A!|','Ф'));
end;
--ВзятьМаскуМАТ
proc f4;
message('f4');
end;



------------ обработчики объектов --------------
Proc ФлагПриИзменении(s:s);
 var Путь:s;
 var l:l;

 Путь=PlanVar('Матучет')+'\Shared\Операции\';
 РАБ.НФА.B00.ПроверятьОшибки=ПроверятьОшибки;
 if ПроверятьОшибки:Путь=Путь+'операции_ос_проверка.def';
  | true:Путь=Путь+'операции_ос.def';
 fi;
 l=Autorefresh;
 ToggleAutorefresh(false);
if РАБ.НФА.B00.CopyTxtFile(Путь,PlanVar('MyBuh')+'\Операции\операции_ос.def',false):
   ToggleAutorefresh(l);
if ПроверятьОшибки:refresh; fi;
 --  message('Изменения вступили в силу');
fi;
end;
------------------------------------------------
Proc Ini;
ClearVariable(Описание);
Описание[  1]="                                           =============                                                               ";
Описание[  2]="                                        ====/- - - - \2 0====                                                            ";
Описание[  3]="                                      ====/            \====                                                           ";
Описание[  4]="                                    ====/                \====                                                         ";
Описание[  5]="                                  ====/2********0   2*********0\====                                                       ";
Описание[  6]="                                ====/  2*0      2*0   2*0       2*0  \====                                                     ";
Описание[  7]="                              ====/    2*0      2*0   2*0       2*0    \====                                                   ";
Описание[  8]="                            ====/      2*0      2*0   2*0       2*0      \====                                                 ";
Описание[  9]="                          ====/        2********0   2***0     2*0        \====               ";
Описание[ 10]="                          ====\        2*0  2*********0 2*0     2*0        /====               ";
Описание[ 11]="                            ====\      2*0  2*0       2*0 2*0     2*0      /====                                                 ";
Описание[ 12]="                              ====\    2*0  2*0       2*0 2*0     2*0    /====                                                   ";
Описание[ 13]="                                ====\  2*0  2*0       2*0 2*0     2*0  /====                                                     ";
Описание[ 14]="                                  ====\2*0  2*0       2*0 2*******0/====                                                       ";
Описание[ 15]="                                    ====\                /====                                                         ";
Описание[ 16]="                                      ====\ - - - - - -/====                                                           ";
Описание[ 17]="                                        ==================                                                             ";
Описание[ 18]="                                                                                                                       ";
Описание[ 19]="----------------------------------------------------------------------------------------------------------             ";
Описание[ 20]="------------------------------- Блок описания процедур и функций -----------------------------------------             ";
Описание[ 21]="2@--procedure CheckLicense(Номер:i); -- проверка лицензии0                               ";
Описание[ 22]="                                                                                                                       ";
Описание[ 23]="2function ChangeVariableInTable0 2    0-- 2заменяет в таблице одно значение переменной на другое0                            ";
Описание[ 24]="             true  - нормальное выполнение;                                                                            ";
Описание[ 25]="             false - ненормальное выполнение;                                                                          ";
Описание[ 26]="@--(                                                                                                                   ";
Описание[ 27]="@--Имя_Таблицы:s;                                                                                                      ";
Описание[ 28]="@--Фильтр_Таблицы:s;                                                                                                   ";
Описание[ 29]="@--Имя_Поля_Упорядочивания_Таблицы:s;                                                                                  ";
Описание[ 30]="@--Имя_Поля_Для_Замены:s;                                                                                              ";
Описание[ 31]="@--Старое_Значение:s;                                                                                                  ";
Описание[ 32]="@--Новое_Значение:s;                                                                                                   ";
Описание[ 33]="@--Тип:i --   тип: 0-string 1-boolean 2-integer 3-real 4-date 5-record                                                 ";
Описание[ 34]="@--);                                                                                                                  ";
Описание[ 35]="2function ChangeVariableInSubTable0 2 0-- 2заменяет в подтаблице одно значение переменной на другое0                         ";
Описание[ 36]="             true  - нормальное выполнение;                                                                            ";
Описание[ 37]="             false - ненормальное выполнение;                                                                          ";
Описание[ 38]="@--(                                                                                                                   ";
Описание[ 39]="@--Имя_Таблицы:s;                                                                                                      ";
Описание[ 40]="@--Имя_Поля_Упорядочивания_Таблицы:s;                                                                                  ";
Описание[ 41]="@--Фильтр_Таблицы:s;                                                                                                   ";
Описание[ 42]="@--Имя_Подтаблицы:s;                                                                                                   ";
Описание[ 43]="@--Имя_Поля_Упорядочивания_Подтаблицы:s;                                               ";
Описание[ 44]="@--Фильтр_Подтаблицы:s;                                                                                                ";
Описание[ 45]="@--Имя_Поля_для_Замены:s;                                                                                              ";
Описание[ 46]="@--Старое_Значение:s;                                                                                                  ";
Описание[ 47]="@--Новое_Значение:s;                                                                                                   ";
Описание[ 48]="@--Тип:i   -- тип: 0-string 1-boolean 2-integer 3-real 4-date 5-record                                                 ";
Описание[ 49]="@--);                                                                                                                  ";
Описание[ 50]="2function NextStr0 2 -- определяет следущий номер с учетом (или без учета) перехода между годами0                          ";
Описание[ 51]="2                  -- и возвращает его значение в строковом выражении с символами, дополняющими длину строки0            ";
Описание[ 52]="@--(                                                                                                                   ";
Описание[ 53]="@--Имя_Таблицы:String;                                                                                                 ";
Описание[ 54]="@--Фильтр_Таблицы:String;                                                                                              ";
Описание[ 55]="@--Имя_Поля_Даты:String;     -- если пусто - дата не учитывается                                                       ";
Описание[ 56]="@--Имя_Поля_Номера:String;                                                                                             ";
Описание[ 57]="@--Символ:String;                                                                                                      ";
Описание[ 58]="@--Длина_Строки:Integer                                                                                                ";
Описание[ 59]="@--):String;                                                                                                           ";
Описание[ 60]="2function ВыборКартАн  0 2      -- Возвращает значение поля признака картотеки0                                            ";
Описание[ 61]="                             2-- или признак из списка0 2аналитики0                                                        ";
Описание[ 62]="@--(                                                                                                                   ";
Описание[ 63]="@--КартАн:l;                -- из картотеки (КартАн=true); из аналитики (КартАн=false)                                 ";
Описание[ 63]="@--Имя_Картотеки:s;         -- для картотеки                                                                           ";
Описание[ 64]="@--Фильтр_Картотеки:s;      -- для картотеки                                                                           ";
Описание[ 65]="@--Поле_Признака:s;         -- для картотеки                                                                           ";
Описание[ 66]="@--Подстрока_Впереди:s;     -- для картотеки (будет добавлена)                                                         ";
Описание[ 67]="@--Фильтр_Признака:s        -- для аналитики                                                                           ";
Описание[ 68]="@--):String;                                                                                                           ";
Описание[ 69]="                                                                                                                       ";
Описание[ 70]="2function ПолеПоПризнаку      -- Возвращает значение заданного поля картотеки,0                                          ";
Описание[ 71]="                             2-- исходя из признака0                                                                     ";
Описание[ 72]="@--(                                                                                                                   ";
Описание[ 73]="@--Признак:s;                                                                                                          ";
Описание[ 74]="@--Тип_Поля:s;               --   s:string, n:real, i:integer, d:date, r:record                                        ";
Описание[ 75]="@--Поле_Картотеки:s;                                                                                                   ";
Описание[ 76]="@--):String;                                                                                                           ";
Описание[ 77]="                                                                                                                       ";
Описание[ 78]="2function ВыборОРГ            -- Возвращает 'К.' + значение поля признака картотеки Контрагентов0                        ";
Описание[ 79]="2                             -- или К из списка аналитики или '' если ничего не выбрано0                                ";
Описание[ 80]="@--(                                                                                                                   ";
Описание[ 63]="@--КартАн:l;                -- из картотеки (КартАн=true); из аналитики (КартАн=false)                                 ";
Описание[ 81]="@--Фильтр_Картотеки:s;      -- для картотеки                                                                           ";
Описание[ 82]="@--Фильтр_Признака:s        -- для аналитики                                                                           ";
Описание[ 83]="@--):String;                                                                                                           ";
Описание[ 84]="2function ВыборТМЦ            -- Возвращает 'ОС.' или 'МАТ.' или 'МБП.' + значение поля признака картотеки ТМЦ0          ";
Описание[ 85]="2                             -- или ТМЦ из списка аналитики или '' если ничего не выбрано0                              ";
Описание[ 86]="@--(                                                                                                                   ";
Описание[ 63]="@--КартАн:l;                -- из картотеки (КартАн=true); из аналитики (КартАн=false)                                 ";
Описание[ 87]="@--Фильтр_Картотеки:s;      -- для картотеки                                                                           ";
Описание[ 88]="@--Фильтр_Признака:s        -- для аналитики                                                                           ";
Описание[ 89]="@--):String;                                                                                                           ";
Описание[ 90]="                                                                                                                       ";
Описание[ 91]="2function ВыборПОДР           -- Возвращает 'ПОДР.' или 'СКЛАД.' или 'СЛУЖБА.' + значение поля признака картотеки0 2ПОДР0  ";
Описание[ 92]="2                             -- или из списка аналитики или '' если ничего не выбрано0                                  ";
Описание[ 93]="@--(                                                                                                                   ";
Описание[ 63]="@--КартАн:l;                -- из картотеки (КартАн=true); из аналитики (КартАн=false)                                 ";
Описание[ 94]="@--Фильтр_Картотеки:s;      -- для картотеки                                                                           ";
Описание[ 95]="@--Фильтр_Признака:s        -- для аналитики                                                                           ";
Описание[ 96]="@--):String;                                                                                                           ";
Описание[ 97]="                                                                                                                       ";
Описание[ 98]="2function ВыборФиз            -- Возвращает 'Ф.' или 'МОЛ.' или 'КОМИССИЯ.' + значение поля признака картотеки СОТРУДНИК0";
Описание[ 99]="2                             -- или из списка аналитики или '' если ничего не выбрано0                                  ";
Описание[100]="@--(                                                                                                                   ";
Описание[ 63]="@--КартАн:l;                -- из картотеки (КартАн=true); из аналитики (КартАн=false)                                 ";
Описание[101]="@--Фильтр_Картотеки:s;      -- для картотеки                                                                           ";
Описание[102]="@--Фильтр_Признака:s        -- для аналитики                                                                           ";
Описание[103]="@--):String;                                                                                                           ";
Описание[104]="                                                                                                                       ";
Описание[105]="2function СобствРекв:Record;   -- Возвращает указатель на нашу фирму в списке Контрагентов, помеченную Def0              ";
Описание[106]="                                                                                                                       ";
Описание[107]="2function ВыборДаты           -- Возвращает значение функции Календарь с учетом ввода (Календарь/Ручной ввод)0           ";
Описание[108]="@--(                                                                                                                   ";
Описание[ 63]="@--  КартАн:l;              -- из картотеки (КартАн=true); из аналитики (КартАн=false)                                 ";
Описание[109]="@--  Начальная_дата:d;   -- Дата, которая будет установлена на календаре                                               ";
Описание[110]="@--):d;                                                                                                                ";
Описание[111]="------------------------------- Конец блока описания процедур и функций ----------------------------------             ";
Описание[112]="----------------------------------------------------------------------------------------------------------             ";
end;

2func CheckLicense0(2Номер:i0)2:l;0  --16-МатУчет 19-БухУчет
перем Lic:С;
перем a:n;
перем стро:С;
перем стро1:С;
перем Путь:С;
перем т:Ц;
перем LicVar:С;
var Demo:l;

     Demo=false;
     Lic=Версия;
     if pos('6.5',Lic)=1:
       Lic='6.5';
      | pos('6.7',Lic)=1:
       Lic='6.7';
      | pos('6.S',Up(Lic))=1:
       Lic='6.SQL';
      | true:Lic='demo';
     fi;

      стро1="license";

      Путь=ПеремПБ("STD");

      IF ПроверкаЛицензии(Номер)=0:
       If Ввод(стро, "Введите код лицензии:")=10:
        LicVar=if(Номер=16:'0010'|Номер=19:'0013'|true:'');
        СоздатьФайл(Путь+стро1+".reg");
        Записать(Путь+стро1+".reg","REGEDIT4");
        Записать(Путь+стро1+".reg","");
        Записать(Путь+стро1+".reg","[HKEY_LOCAL_MACHINE\Software\Dic\Tbw\"+Lic+"\"+LicVar+"]");
        Записать(Путь+стро1+".reg","");
        Записать(Путь+стро1+".reg","[HKEY_LOCAL_MACHINE\Software\Dic\Tbw\"+Lic+"\"+LicVar+"\License]");
        Записать(Путь+стро1+".reg","");
        Записать(Путь+стро1+".reg","[HKEY_LOCAL_MACHINE\Software\Dic\Tbw\"+Lic+"\"+LicVar+"\License]");
        Записать(Путь+стро1+".reg",'"Number"="'+стро+'"');
        ВыполнитьПрограмму(Путь+стро1+".reg");
        Сообщение('Для проверки правильности ввода нажмите ОК');
        if  ПроверкаЛицензии(Номер)=0:
         Сообщение("Неправильный код лицензии. Программа будет работать в режиме Демо-Версии!!! "+
                 "(оборот по дебету всех счетов не должен превышать 100'000)");
         Demo=true;
        fi;
       |true:
        ^true;--         closeapp;
       Fi;
      FI;

      If Demo:
       a=turn("+(*)", 01.01.1991,today+1);
       if a>100000:
        MESSAGE("Суммарный оборот превысил 100'000. Лимит демо-версии исчерпан.");
        ^true;--closeapp;
       |true:
        ^false;
       fi;
      fi;
2end;
2func БланкКартотеки     -- Возвращает имя бланка редактора для картотеки
(
CrdFile:s
):s;
var возвратС:s;
if CrdFile='РПО_НФА'       :возвратС='ИНФО.НФА.НФА'      ;
 | CrdFile='РПО_ДНФА'      :возвратС='ИНФО.НФА.ДНФА'     ;
 | CrdFile='РПО_РАЗМЕР'    :возвратС='ИНФО.НФА.РАЗМЕР'   ;
 | CrdFile='РПО_РОСТ'      :возвратС='ИНФО.НФА.РОСТ'     ;
 | CrdFile='ПОДРАЗДЕЛЕНИЯ' :возвратС='ИНФО.ПОДРАЗДЕЛЕНИЕ';
 | CrdFile='СОТРУДНИКИ'    :возвратС='ИНФО.СОТРУДНИК'    ;
 | CrdFile='КОНТРАГЕНТ'    :возвратС='ИНФО.КОНТРАГЕНТ'   ;
 | CrdFile='РПО_ИНВКАРТ_ОС':возвратС='НФА.ДОКУМЕНТЫ.КАРТОЧКИ.ОКУД_0504031';
 | CrdFile='ПРОД_БЛЮДА'    :возвратС='НФА.ПРОД.ПРОД_БЛЮДА';
 | CrdFile='ПРОД_ЗАКАЗЫ'   :возвратС='НФА.ПРОД.ПРОД_ЗАКАЗЫ';

fi;
^возвратС;
end;

2proc ОткрытьБланкПоПризнаку  -- Открывает бланк редактор на соответствующий признак
(
Признак:s;
Модально:l
);
var CrdFile:s;
 CrdFile=SignCardFile(Признак);
 if CrdFile<>'':
  OpenBlank(БланкКартотеки(CrdFile),Модально,SignToRecord(Признак,false));
 fi;
end;

2func ChangeVariableInTable     -- заменяет во всех записях таблицы одно значение переменной на другое
--             true  - нормальное выполнение;
--             false - ненормальное выполнение;
(
имя_таблицы:s;
фильтр_таблицы:s;
имя_поля_упорядочивания_таблицы:s;
имя_поля_для_замены:s;
старое_значение:s;
новое_значение:s;
тип:i --   тип: 0-string 1-boolean 2-integer 3-real 4-date 5-record
):l;
var wa,rwa,i,rec:integer;

  wa=openworkarea(имя_таблицы,имя_поля_упорядочивания_таблицы,фильтр_таблицы);
  rwa=records(wa);
  if rwa>0:
   beginchanging(wa);
   for i=1..rwa do
    try
     if  тип=0:
        if getfields(wa,i,имя_поля_для_замены)=старое_значение:
         try
          rec=PutFieldS(wa,i,имя_поля_для_замены,новое_значение);
         except
          cancelchanging(wa);
          ^false;
         end;
        fi;
     fi;
    except
     cancelchanging(wa);
     ^false;
    end;
   end;
   endchanging(wa);
  fi;
   closeworkarea(wa);
  ^true;
2end;


2func ChangeVariableInSubTable  -- заменяет во всех записях0 2подтаблицы одно значение переменной на другое
            -- true  - нормальное выполнение;
            -- false - ненормальное выполнение;
(
имя_таблицы:s;
имя_поля_упорядочивания_таблицы:s;
фильтр_таблицы:s;
имя_подтаблицы:s;
имя_поля_упорядочивания_подтаблицы:s;
фильтр_подтаблицы:s;
имя_поля_для_замены:s;
старое_значение:s;
новое_значение:s;
тип:i   -- тип: 0-string 1-boolean 2-integer 3-real 4-date 5-record
):l;

var wa,rwa,was,rwas,i,j,rec:integer;
var test:integer;
var test1:integer;

  wa=openworkarea(имя_таблицы,имя_поля_упорядочивания_таблицы,фильтр_таблицы);
  rwa=records(wa);
  for i=1..rwa do
   was=openarray(wa,i,имя_подтаблицы,имя_поля_упорядочивания_подтаблицы);
   try
    setfilter(was,фильтр_подтаблицы);
    rwas=records(was);
    if rwas>0:
     try
      beginchanging(was);
      for j=1..rwas do
       if  тип=0:
          if getfields(was,j,имя_поля_для_замены)=старое_значение:
           try
            rec=PutFieldS(was,j,имя_поля_для_замены,новое_значение);
           except
            cancelchanging(was);
            ^false;
           end;
          fi;
       fi;
      end;
      endchanging(was);
     except
      cancelchanging(was);
      ^false;
     end;
    fi;
   finally
   end;
   closeworkarea(was);
  end;
  closeworkarea(wa);
  ^true;
2end;

2func AddChar(ss:s;WidthSt:i;ch:s):s;  -- добавляет ведущие символы к строке
 ^repstr(ch,WidthSt-Length(ss))+ss;
2end;

Func ПривестиКцифрам(НомерБум:String) :String;
^РАБ.СТР.ЗаменаПостороннихСимволов('0123456789',НомерБум,'',false);
end;

2func NextStr  -- определяет следущий номер с учетом (или без учета) перехода между годами
2              -- и возвращает его значение в строковом выражении с нулями, дополняющими длину строки
(2             -- расчет ведется в текущем году!
Имя_Таблицы:String;
Фильтр_Таблицы:String;
Имя_Поля_Даты:String;     -- если пусто - дата не учитывается
Имя_Поля_Номера:String;
Символ:String;
Длина_Строки:Integer
):String;

var number,filter,year_today:s;
var wa,CurN,ii:i;

 number='';
 year_today=Str(year(today));
 if Фильтр_Таблицы<>'':
  Фильтр_Таблицы='('+Фильтр_Таблицы+') and ';
 fi;
 if Имя_Поля_Даты<>'':
  filter=Фильтр_Таблицы+"(Year("+Имя_Поля_Даты+")="+year_today+") and ";
 fi;
 filter=filter+"(length("+Имя_Поля_Номера+")="+str(Длина_Строки)+")";
 wa=openworkarea(Имя_Таблицы,Имя_Поля_Номера,filter);
 ii=records(wa);
 if ii>0:
   number=GetFieldS(wa,ii,Имя_Поля_Номера);
   CurN=int(number);
   while CurN=0 and ii>1 do
    ii=ii-1;
    number=GetFieldS(wa,ii,Имя_Поля_Номера);
    CurN=int(number);
   od;
 fi;
   number=format('%.'+str(Длина_Строки)+'d',CurN+1);
   closeworkarea(wa);
 ^number;
2End;
2func NextStrY -- определяет следущий номер с учетом (или без учета) перехода между годами
2              -- и возвращает его значение в строковом выражении с нулями, дополняющими длину строки
(2             -- расчет ведется для указанного года!
Имя_Таблицы:String;
Фильтр_Таблицы:String;
Имя_Поля_Даты:String;     -- если пусто - дата не учитывается
Имя_Поля_Номера:String;
Символ:String;
Длина_Строки:Integer;
Y:Integer -- если 0 то как в NextStr
):String;

var number,filter,year_today :s;
var wa,CurN,ii:i;

 number='';
 if Y>0:year_today=str(y);
  | true:year_today=Str(year(today));
 fi;
 if Фильтр_Таблицы<>'':
  Фильтр_Таблицы='('+Фильтр_Таблицы+') and ';
 fi;
 if Имя_Поля_Даты<>'':
  filter=Фильтр_Таблицы+"(Year("+Имя_Поля_Даты+")="+year_today+") and ";
 fi;
 filter=filter+"(length("+Имя_Поля_Номера+")="+str(Длина_Строки)+")";
-- trace(filter);
 wa=openworkarea(Имя_Таблицы,Имя_Поля_Номера,filter);
 ii=records(wa);
   if ii>0:
   number=GetFieldS(wa,ii,Имя_Поля_Номера);
   CurN=int(number);
   while CurN=0 and ii>1 do
    ii=ii-1;
    number=GetFieldS(wa,ii,Имя_Поля_Номера);
    CurN=int(number);
   od;
 fi;
 number=format('%.'+str(Длина_Строки)+'d',CurN+1);
 closeworkarea(wa);
 ^number;
2End;
2Func0 ВзятьИндексМассива(ИмяПеременной:s):i;
  var p0,p1:i;
  p0=pos('[',ИмяПеременной);
  p1=pos(']',ИмяПеременной);
  if p1>p0 and p0>0 and p1>0:
     ^int(Substr(ИмяПеременной,p0+1,p1-p0-1));
  fi;
  ^-1;
2End;
2Func СобствРекв:Record;
-- Выдает указатель на нашу фирму в списке ЮрЛиц, помеченную Def
var ro, i:Integer;
var r :RECORD;
  r = nil;
  i = 0;
  ro = OpenWorkArea('КОНТРАГЕНТ', 'Признак', 'Def');
  try
    if Records(ro) = 0:  
      r = NIL; 
    | true:
      r = GetRecordKey(ro,1);
    fi;
  finally
    CloseWorkArea(ro);
  end;
  ^ r;
2End;

2Func ВыборКартАн         -- Возвращает значение поля картотеки
                         2-- или признак из списка0 2аналитики
(
КартАн:l;                -- из картотеки (КартАн=true); из аналитики (КартАн=false)
Имя_Картотеки:s;         -- для картотеки
Фильтр_Картотеки:s;      -- для картотеки
Поле_Признака:s;         -- для картотеки
Подстрока_Впереди:s;     -- для картотеки (будет добавлена)
Фильтр_Признака:s        -- для аналитики
):String;
var s:s;
var r:Record;

if КартАн and Имя_Картотеки<>'':
  r=OpenCardFile(Имя_Картотеки,Фильтр_Картотеки);
   if R<>Nil:
    s=GetCardFieldS(Имя_Картотеки,r,Поле_Признака);
    ^Подстрока_Впереди+s;
   |true:
    ^'';
   fi;
|  (not КартАн) and Фильтр_Признака<>'':
  ^AnaElection(Фильтр_Признака);
|true:
  ^'';
fi;
2End;


func ВыборДатыПроверка
(
  СтароеЗначение:d;
  Начальная_дата:d   -- Дата, которая будет установлена на календаре
):d;
var dd:d;
 dd=КАЛЕНДАРЬ(Начальная_дата);
 if dd=01.01.100:if ОтказОтИзменений:dd=СтароеЗначение;fi;fi;
 ^dd;

2End;
2func ПолеПоРО 0    2     -- Возвращает значение заданного поля рабочей области,
                             2-- исходя из признака
(
РО:i;
НЗ:i;     -- номер записи в РО
Поле_РО:s; -- имяполя
Тип_Поля:s
--SС--строка
--NЧ--число
--IЦ--челое
--DД--дата
--RЗ--ссылка
--LЛ--логическое
--[]--периодическое
--TП--подтаблица
):String;
  if Тип_Поля='SС': ^GetFieldS(РО,НЗ,Поле_РО);
  |  Тип_Поля='NЧ': ^str(GetFieldN(РО,НЗ,Поле_РО),8);
  |  Тип_Поля='IЦ': ^str(GetFieldI(РО,НЗ,Поле_РО));
  |  Тип_Поля='DД': ^DateToString(GetFieldD(РО,НЗ,Поле_РО));
  |  Тип_Поля='RЗ': ^RecordToString(GetFieldR(РО,НЗ,Поле_РО));
  |  Тип_Поля='LЛ': ^if(GetFieldL(РО,НЗ,Поле_РО),'T','F');
  fi;
 ^'';
end;

2func ПолеПоПризнаку 0    2     -- Возвращает значение заданного поля картотеки,
                             2-- исходя из признака
(
Признак:s;
Тип_Поля:s;                  --   s:string, n:real, i:integer, d:date, r:record
Поле_Картотеки:s
):String;
var CrdFile:s;
 CrdFile=SignCardFile(Признак,false);
 if CrdFile<>'':
  if Тип_Поля='s':     ^GetCardFieldS(CrdFile,SignToRecord(Признак,false),Поле_Картотеки);
  |  Тип_Поля='n': ^str(GetCardFieldN(CrdFile,SignToRecord(Признак,false),Поле_Картотеки),8);
  |  Тип_Поля='i': ^str(GetCardFieldI(CrdFile,SignToRecord(Признак,false),Поле_Картотеки));
  |  Тип_Поля='d': ^DateToString(GetCardFieldD(CrdFile,SignToRecord(Признак,false),Поле_Картотеки));
  |  Тип_Поля='r': ^RecordToString(GetCardFieldR(CrdFile,SignToRecord(Признак,false),Поле_Картотеки));
  fi;
 ^'';
 fi;
end;
2func ПолеПоПризнакуС0    2     -- Возвращает значение заданного поля картотеки,
                             2-- исходя из признака
(
Признак:s;
Поле_Картотеки:s
):С;
var CrdFile:s;
 CrdFile=SignCardFile(Признак,false);
 if CrdFile<>'':
   try
     CrdFile=GetCardFieldS(CrdFile,SignToRecord(Признак,false),Поле_Картотеки);
   except
     CrdFile='';
   end;
 ^CrdFile;
 fi;
 ^'';
end;

2func ПолеПоПризнакуЧ0    2     -- Возвращает значение заданного поля картотеки,
                             2-- исходя из признака
(
Признак:s;
Поле_Картотеки:s
):Ч;
var CrdFile:s;
 CrdFile=SignCardFile(Признак,false);
 if CrdFile<>'':^GetCardFieldN(CrdFile,SignToRecord(Признак,false),Поле_Картотеки);fi;
 ^0;
end;
2func ПолеПоПризнакуЦ0    2     -- Возвращает значение заданного поля картотеки,
                             2-- исходя из признака
(
Признак:s;
Поле_Картотеки:s
):Ц;
var CrdFile:s;
 CrdFile=SignCardFile(Признак,false);
 if CrdFile<>'':^GetCardFieldI(CrdFile,SignToRecord(Признак,false),Поле_Картотеки);fi;
 ^0;
end;
2func ПолеПоПризнакуД0    2     -- Возвращает значение заданного поля картотеки,
                             2-- исходя из признака
(
Признак:s;
Поле_Картотеки:s
):Д;
var CrdFile:s;
 CrdFile=SignCardFile(Признак,false);
 if CrdFile<>'':^GetCardFieldD(CrdFile,SignToRecord(Признак,false),Поле_Картотеки);fi;
 ^1.1.100;
end;

2func ПолеПоПризнакуЗ0    2     -- Возвращает значение заданного поля картотеки,
                             2-- исходя из признака
(
Признак:s;
Поле_Картотеки:s
):Запись;
var CrdFile:s;
 CrdFile=SignCardFile(Признак,false);
 if CrdFile<>'':^GetCardFieldR(CrdFile,SignToRecord(Признак,false),Поле_Картотеки);fi;
 ^NIL;
end;
2func ПолеПоПризнакуЛ0    2     -- Возвращает значение заданного поля картотеки,
                             2-- исходя из признака
(
Признак:s;
Поле_Картотеки:s
):Л;
var CrdFile:s;
 CrdFile=SignCardFile(Признак,false);
 if CrdFile<>'':^GetCardFieldL(CrdFile,SignToRecord(Признак,false),Поле_Картотеки);fi;
 ^false;
end;
2Func0 КВД(Счет:s):s; -- код вида деятельности (1-бюджет, 2-предпр, 3-целевка)
 var p:i;
 if не соотв(Счет,'*.?.???.??.???'):^'.';fi;
 p=КоличествоСлов(Счет,'.');
 ^ВыделитьСлова(p-3,1,Счет,'.');
-- ^Раб.Бюджет2005.ВзятьКодСчета(сч,'','ИСТ',false);
2End;

--ТМЦН[]:s=if(ShCodeNameI=0:if(Позиции[$].ТМЦ<>'','('+Позиции[$].ТМЦ+')/'+Name_A(Позиции[$].ТМЦ),'')|
--            ShCodeNameI=1:Name_A(Позиции[$].ТМЦ)|
--            ShCodeNameI=2:Позиции[$].ТМЦ);
2Func0 GetShCodeName(ShCodeNameI:i;Code:s):s;
 ^if(ShCodeNameI=0:if(Code<>'','('+Code+')/'+Name_A(Code),'')
    |ShCodeNameI=1:Name_A(Code)
    |ShCodeNameI=2:Code
    |true:'<ошибка, значение ShCodeNameI перешло все границы...>');
2End;
2Func0 GetVarShCodeName(ShCodeNameI:i):s;
 ^if(ShCodeNameI=0:'Код и наименование'
    |ShCodeNameI=1:'Наименование'
    |ShCodeNameI=2:'Код'
    |true:'<ошибка, значение ShCodeNameI перешло все границы...>');
2End;

2Func0 NameColor(i:i):s;
 if i=coBlack      :^'coBlack       Черный          ';
  | i=coWhite      :^'coWhite       Белый           ';
  | i=coMaroon     :^'coMaroon      ТемноКрасный    ';
  | i=coRed        :^'coRed         Красный         ';
  | i=coTeal       :^'coTeal        ТемноАква       ';
  | i=coAqua       :^'coAqua        Аква            ';
  | i=coNavy       :^'coNavy        ТемноСиний      ';
  | i=coBlue       :^'coBlue        Синий           ';
  | i=coLime       :^'coLime        Салатовый       ';
  | i=coGreen      :^'coGreen       Зелёный         ';
  | i=coOlive      :^'coOlive       Оливковый       ';
  | i=coYellow     :^'coYellow      Желтый          ';
  | i=coGray       :^'coGray        Серый           ';
  | i=coLtGray     :^'coLtGray      СветлоСерый     ';
  | i=coPurple     :^'coPurple      Фиолетовый      ';
  | i=coFuchsia    :^'coFuchsia     Розовый         ';
--  | i=coDkGray     :^'coDkGray      ТемноСерый      ';
--  | i=coSilver     :^'coSilver      Серебреный      ';
  | i=coTransparent:^'coTransparent Прозрачный      ';
--  | i=coBackground :^'coBackground  Задний план     ';
  | true:^str(i);
 fi;
2End0;
-- CellFontStyle|КлеткаСтильШрифта    fsBold|сфЖирность, fsItalic|сфНаклон  fsUnderline|сфПодчерк fsStrikeout|сфЗачерк;
-- CellFontSize |КлеткаРазмерШрифта
-- CellFontColor|КлеткаЦветШрифта
-- CellAlignment|КлеткаВыравнивание 0 - лево 1 - право 2 - центр
-- CellBgColor  |КлеткаЦвет
2Func0 NameCellMethod(i:i):s;
 if i=CellFontStyle:^'CellFontStyle|КлеткаСтильШрифта ';
  | i=CellFontSize :^'CellFontSize |КлеткаРазмерШрифта';
  | i=CellFontColor:^'CellFontColor|КлеткаЦветШрифта  ';
  | i=CellAlignment:^'CellAlignment|КлеткаВыравнивание';
  | i=CellBgColor  :^'CellBgColor  |КлеткаЦвет        ';
  | true:^str(i);
 fi;
2End0;
2Func0 NameCellFontStyle(i:i):s;
var i1:i;
var ss:s;
 if i=0:^'Обычн';fi;
 if i>7:ss='Зачерк '     ;i=i-8;fi;
 if i>3:ss=ss+'Подчерк ' ;i=i-4;fi;
 if i>1:ss=ss+'Наклон '  ;i=i-2;fi;
 if i>0:ss=ss+'Жирность ';i=i-1;fi;
 if i<>0:^str(i);
  | true:^ss;
 fi;
2End0;
2Func0 ВзятьПериодПоДате(dd:d;ТочностьПериода:s):s; 
--ТочностьПериода: гг - год, кв - квартал, мм - месяц
--ТочностьПериода пусто => с максимальной точностью!
var ii:i;
var ss:s;
 ss='ПЕРИОД.'+str(год(dd));
 if ТочностьПериода='гг':^ss;fi;
 ii=мес(dd);
 if ii<4 :ss=ss+'.1';
  | ii<7 :ss=ss+'.2';
  | ii<10:ss=ss+'.3';
  | ii<13:ss=ss+'.4';
 fi;
 if ТочностьПериода='кв':^ss;fi;
 if ii<10:ss=ss+'.0'+str(ii);
  | true :ss=ss+'.' +str(ii);
 fi;
 if ТочностьПериода='мм':^ss;fi;
  ^ss;
2End0;
2Func0 ВзятьИмяАмортГруппы(НомерГруппы:i):s;
  if НомерГруппы= 1:^'все недолговечное имущество от 1 до 2 лет';
   | НомерГруппы= 2:^'имущество от 2 до 3 лет';
   | НомерГруппы= 3:^'имущество от 3 до 5 лет';
   | НомерГруппы= 4:^'имущество от 5 до 7 лет';
   | НомерГруппы= 5:^'имущество от 7 до 10 лет';
   | НомерГруппы= 6:^'имущество от 10 до 15 лет';
   | НомерГруппы= 7:^'имущество от 15 до 20 лет';
   | НомерГруппы= 8:^'имущество от 20 до 25 лет';
   | НомерГруппы= 9:^'имущество от 25 до 30 лет';
   | НомерГруппы=10:^'имущество свыше 30 лет';
   | true:^'';
  fi;
2End0;
2Func0 ВзятьСрокАмортГруппы(НомерГруппы:i):i;
  if НомерГруппы= 1:^2;
   | НомерГруппы= 2:^3;
   | НомерГруппы= 3:^5;
   | НомерГруппы= 4:^7;
   | НомерГруппы= 5:^10;
   | НомерГруппы= 6:^15;
   | НомерГруппы= 7:^20;
   | НомерГруппы= 8:^25;
   | НомерГруппы= 9:^30;
   | НомерГруппы=10:^100;
   | true:^0;
  fi;
2End0;

2Func0 ВыборНомераАмортГруппы:i;
var i:i;
   ClearVariable(РАБ.НФА.B01.st);
   for i=1..10 do st[i]=str(i)+' - '+ВзятьИмяАмортГруппы(i);od;
   ^Альтернатива("Выбор амортизационной группы",st,-1,1);
2End0;
2Func0 НормаАмортизацииНовая(БалСтоим:n;НачисленоАморт:n;НормаДо:n;НормаПосле:n):n;
var результат,срокуженачаморт:n;
 срокуженачаморт=ОКР((100*НачисленоАморт)/(БалСтоим*НормаДо));
 if ОКР((100/НормаПосле)-срокуженачаморт)>0:
    результат=((БалСтоим-НачисленоАморт)*НормаДо*НормаПосле)/(БалСтоим*НормаДо-НачисленоАморт*НормаПосле);
  | true:результат=1200;
 fi;
 ^результат;
2End0;

Func 2ВыводП_ИНВ0(NFA:String; INV:String; Type:Integer; Zero:String; Raz:String) :String;
-- NFA - код аналитического признака;
-- INV - код аналитического признака;
-- Type - тип форматирования - 0:Учетный + Инвентарный; 1:Учетный ; 2:Инвентарный; 3: Инвентарный + Учетный
-- Zero - строка для вывода если пусто
var tmp :String;
var tmp1:String;
var nn :Integer;
 if Type=-1:^'** нет ввода **';fi;
 if Type=-2:^'!! заполнить !!';fi;
 if NFA="": ^""; fi;
 tmp ="ИНВВЕД."+NFA+'.'+INV;
 tmp1=Name_A(tmp);-- ведомственный инв номер
 if tmp1=' ':tmp1=Zero;fi;
 if INV="": tmp=Zero; 
  | true:tmp=SubStr(INV,5,255);
 fi;
 if Type=0:^tmp+Raz+tmp1;--Учетный + Инвентарный
  | Type=1:^tmp;         --Учетный
  | Type=2:^tmp1;        --Инвентарный
  | Type=3:^tmp1+Raz+tmp;--Инвентарный + Учетный
 fi;
 ^'';
end;
Func ВыборВидаТаблицыИНВ(State:Integer) :Integer;
var nn :Integer;
 ClearVariable(РАБ.НФА.B01.st);
 st[1]="Учетный + Инвентарный";
 st[2]="Учетный";
 st[3]="Инвентарный";
 st[4]="Инвентарный + Учетный";
 nn=Alternate("Выберите способ отображения инвентарного номера", st, -1, State+1, 12);
 if nn=0: ^State; fi;
 ^(nn-1);
end;

2func0 2ВыводП0(s:s;i:i):s;-- s=признак;i=2-код,1-наименование,0-код/наименование

 if i=-1:s='** нет ввода **';
  | i=-2:s='!! заполнить !!';
  | i=2 :s=s;
  | i=1 :s=Name_A(s);
  | i=0 :if s='':^s;fi;s='['+s+']/'+Name_A(s);
 fi;
 ^s;
2end0;

2func0 2ВыводС0(s:s;i:i):s;-- s=счет;i=2-код,1-наименование,0-код/наименование

 if i=-1:s='** нет ввода **';
  | i=-2:s='!! заполнить !!';
  | i=2 :s=s;
  | i=1 :s=Name_S(s);
  | i=0 :if s='':^s;fi;s='['+s+']/'+chr(13)+Name_S(s);
 fi;
 ^s;
2end0;
func ВыборВывода:i;
 var j:i;
  ClearVariable(РАБ.НФА.B01.st);
  st[1]='1 Код и наименование';
  st[2]='2 Только наименование';
  st[3]='3 Только код';
  j=Альтернатива('Выбор способа вывода...',st,-1,1);
  ^j-1;
end;
func ВыборВыводаИНВ:i;
 var j:i;
  ClearVariable(РАБ.НФА.B01.st);
  st[1]='1 Учетный и инвентарный';
  st[2]='2 Только учетный';
  st[3]='3 Только инвентарный';
  j=Альтернатива('Выбор способа вывода...',st,-1,1);
  ^j-1;
end;

2Func0 ФорматСтрокиАн(СтрокаАн:s;Разделитель1:s;Разделитель2:s;форматст:i):s;
-- формат=0;1;2 0- (код)/наименование; 1- наименование; 2 код;
-- СтрокаАн - список кодов ан признаков через разделитель1
-- Разделитель2 - с помощью разделителя2 формируется результат
var i,j,k:i;
var ss,ss0:s;
   if форматст=-1:^'** нет ввода **';
    | форматст=-2:^'!! заполнить !!';
   fi;
   ss='';
   j=КоличествоСлов(СтрокаАн,Разделитель1);
   for i=1..j do
     ss0=ВыделитьСлово(i,СтрокаАн,Разделитель1);
     if pos('ЗН.',ss0)=1:ss=ss+Разделитель2+ss0;
      | true:ss=ss+Разделитель2+2ВыводП0(ss0,форматст);
     fi;

   od;
   k=pos(Разделитель2,ss);
   if k=1:ss=SubStr(ss,Length(Разделитель2)+1,Length(ss));fi;
   ^ss;
2End0;
2Func0 ФорматСтрокиСч(СрокаСч:s;Разделитель1:s;Разделитель2:s;форматст:i):s;
-- формат=0;1;2 0- (код)/наименование; 1- наименование; 2 код;
-- СрокаСч - список кодов ан признаков через разделитель1
-- Разделитель2 - с помощью разделителя2 формируется результат
var i,j,k:i;
var ss:s;
   if форматст=-1:^'** нет ввода **';
    | форматст=-2:^'!! заполнить !!';
   fi;
   ss='';
   j=КоличествоСлов(СрокаСч,Разделитель1);
   for i=1..j do
     ss=ss+Разделитель2+2ВыводС0(ВыделитьСлово(i,СрокаСч,Разделитель1),форматст);
   od;
   k=pos(Разделитель2,ss);
   if k=1:ss=SubStr(ss,Length(Разделитель2)+1,Length(ss));fi;
   ^ss;
2End0;

2Func0 УдалитьПризнакИзНабора_Диалог (СтрокаАн:S; Разделитель1:S):S;
var n,nn:i;
var ss1,ss2:s;
 if СтрокаАн="": ^""; fi;
 ClearVariable(РАБ.НФА.B01.st);
 nn=КоличествоСлов(СтрокаАн,Разделитель1)+1;
 if nn=2: ^""; fi;
 st[1]="Удалить все";
 for n=2..nn do
  st[n]=2ВыводП0(ВыделитьСлово(n-1,СтрокаАн,Разделитель1),0);
 od;
 n=Alternate("Удаление признака",st,-1);
 if n=0: ^СтрокаАн; fi;
 if n=1: ^""; fi;
 ss1=ВыделитьСлова(1,n-2,СтрокаАн,Разделитель1);
 ss2=ВыделитьСлова(n,nn+1-n,СтрокаАн,Разделитель1);
 if ss1<>'' и ss2<>'':СтрокаАн=ss1+Разделитель1+ss2;
  | true:СтрокаАн=ss1+ss2;
 fi;
 ^СтрокаАн;
2End0;

2Func0 ДобавитьПризнак(СтрокаАн:s;Разделитель1:s;Признак:s):s;
-- СтрокаАн - список кодов ан признаков через разделитель1
-- МаскаАн - маска на признаки для их добавления в СтрокаАн
var i,j,k,p:i;
var ss,ss1,ss2:s;
   СтрокаАн=up(СтрокаАн);
   j=КоличествоСлов(СтрокаАн,Разделитель1);
   if j=0:^Признак;fi;--если набор признаков пустой то добавить туды новый признак сразу
   ss=ВзятьСправочникАналит(Признак);--Определяем название справочника
   p=pos(Разделитель1+ss+'.',Разделитель1+СтрокаАн);
   if p=0:^СтрокаАн+Разделитель1+Признак;fi;--если данного справочника нет в наборе то добавляем его
   ss1='';
   for i=1..j do
    ss2=ВыделитьСлово(i,СтрокаАн,Разделитель1);
    if pos(ss,ss2)<>1:ss1=ss1+Разделитель1+ss2;
     | true:ss1=ss1+Разделитель1+Признак+Разделитель1+ВыделитьСлова(i+1,j-i,СтрокаАн,Разделитель1);^ss1;
    fi;
   od;
2End0;

2Proc0 Создатель1(CreatedUser:s;ModifiedUser:s);
 var ll:l;
 ll=(CreatedUser=ModifiedUser);
-- if ll:EditorCancel;
2End0;
2Func0 Создатель(CreatedUser:s;ModifiedUser:s):l;
 var ll:l;
 ll=(CreatedUser=ModifiedUser);
 if not ll: Message('Вы необладаете правом на изменение данной записи'+chr(13)+
                    'так как не являетесь ее создателем.'
                    ,тсПредупреждение);
    EditorCancel;
 fi;
 ^ll;
2End0;

--Proc КнРасчет_ПриНажатии(s:s);
-- var d1,d2:d;
-- var t,nsig1,nsig2,nsig3:i;
-- var ll:l;
-- var signs,УслМол1,УслМол2,УслМ:s;

-- var Приход,ВнПер,Расход,услсч,АН_ДНФА:s;
-- Приход='+(*.?.101.??.???|*.?.105.??.???|ЗАБ.??.*)/*&~(*.?.101.??.???|*.?.105.??.???|ЗАБ.??.*)';
-- ВнПер ='(*.?.101.??.???|*.?.105.??.???|ЗАБ.??.*)/(*.?.101.??.???|*.?.105.??.???|ЗАБ.??.*)';
---- Расход='-(*.?.101.??.???|*.?.105.??.???|ЗАБ.??.*)/*&~(*.?.101.??.???|*.?.105.??.???|ЗАБ.??.*)';
-- Расход='-(*.?.105.??.???|ЗАБ.??.105.*)/*&~(*.?.101.??.???|*.?.105.??.???|ЗАБ.??.*)';
-- d1=ВзятьКартПолеД('РПО_ОПЕРАЦИИДНФА',ЧислоВзапись(ДНФАID),'ДатОпер');
-- d2=d1+1;
-- ДатаАкта=d1;
-- --ЗАКДАТА=d1;
-- АН_ДНФА=ВзятьКартПолеС('РПО_ОПЕРАЦИИДНФА',ЧислоВзапись(ДНФАID),'АН_ДНФА');
-- if pos('ПРИХ.',АН_ДНФА)=1:услсч=Приход;УслМол1='+МОЛ.';УслМ='+М.';УслМол2='';
--  | pos('ВНПР.',АН_ДНФА)=1:услсч=ВнПер; УслМол1='+МОЛ.';УслМ='+М.';УслМол2='-МОЛ.';
--  | pos('РАСХ.',АН_ДНФА)=1:услсч=Расход;УслМол1=''     ;УслМ='-М.';УслМол2='-МОЛ.';
--  | true:message(АН_ДНФА);услсч='*';
-- fi;
-- ClearVariable(СписМатер);
---- if ФИОК<>'':ФИОК='';fi;
---- if Мол<>'' :Мол ='';fi;
---- if ПОСТ<>'':ПОСТ='';fi;
-- ll=false;
-- nsig1=0;
-- nsig2=0;
-- nsig3=0;
-- for transaction t=услсч+'{НФА.*&ДНФАID.'+стр16(ДНФАID)+'&ДНФА.'+АН_ДНФА+'}',d1,d2 do
---- for transaction t=услсч+'{ДНФАID.00000001 }',1.1.100,сегодня do
--  InsertFrame(СписМатер,СписМатер+1);
--  СписМатер[СписМатер].КодМат     =ПроводКоличПризнак(t);
--  СписМатер[СписМатер].НаименМат  =Name_A(СписМатер[СписМатер].КодМат);
--  СписМатер[СписМатер].ЕдИзм      =Unit(СписМатер[СписМатер].КодМат);
--  СписМатер[СписМатер].СчДебета   =ПроводДеб(t);
--  СписМатер[СписМатер].СчКредита  =ПроводКре(t);
--  СписМатер[СписМатер].ФИзр_Колво =ПроводСумма(t,'КОЛ');
--  СписМатер[СписМатер].ФИзр_Цена  =ПроводСумма(t)/СписМатер[СписМатер].ФИзр_Колво;
--  if not ll:
--    --signs=ПроводАналитика(t);
----    if УслМол1<>'':nsig1=ПроводНомерПризнака(t,УслМол1);
----    if nsig1=0:signs='';
----     | true:   signs=ПроводИмяПризн(t,nsig1);
----    fi;
----    Мол =if(pos('-',signs)+pos('+',signs)>0,SubStr(signs,2,length(signs)-1),signs);fi;
--    if УслМол2<>'':nsig2=ПроводНомерПризнака(t,УслМол2);
--    if nsig2=0:signs='';
--      | true  :signs=ПроводИмяПризн(t,nsig2);
--    fi;
--    Мол=Name_A(if(pos('-',signs)+pos('+',signs)>0,SubStr(signs,2,length(signs)-1),signs));fi;

--    if УслМ<>''   :nsig3=ПроводНомерПризнака(t,УслМ);
--    if nsig3=0:signs='';
--      | true  :signs=ПроводИмяПризн(t,nsig3);
--    fi;
--    ПОучреж=Name_A(if(pos('-',signs)+pos('+',signs)>0,SubStr(signs,2,length(signs)-1),signs));fi;
--    ll=(ПОучреж<>'' or Мол<>'');
--  fi;
-- od;
--end;

2Func0 ДНФА_ФИКС(Rec:record;Пересчет:l):l;
-- var wa:i;
-- wa=
-- d1=ВзятьКартПолеД('РПО_ОПЕРАЦИИДНФА',ЧислоВзапись(ДНФАID),'ДатОпер');
-- d2=d1+1;
-- АН_ДНФА=ВзятьКартПолеС('РПО_ОПЕРАЦИИДНФА',ЧислоВзапись(ДНФАID),'АН_ДНФА');
-- ClearVariable(СписМатер);
-- ll=false;
-- nsig1=0;
-- nsig2=0;
-- nsig3=0;
-- for transaction t='*{НФА.*&ДНФАID.'+стр16(ДНФАID)+'&ДНФА.'+АН_ДНФА+'}',d1,d2 do


-- od;
 ^true;
2End0;
2Func0 СвернутьПризнакиДляПроводки(Ан1:s;Ан2:s;Разделитель:s):s;
var i,t,j:i;
var l:l;
var s1,s2,ss:s;
Ан1=Разделитель+Ан1+Разделитель;
Ан2=Разделитель+Ан2+Разделитель;
ClearVariable(Раб.НФА.B01.st);
ss='';
s2='';
t=КоличествоСлов(Ан1,Разделитель);
for i=1..t do
  s1=ВыделитьСлово(i,Ан1,Разделитель);
  ВставитьВмассивСорт(st,s1);
od;
t=КоличествоСлов(Ан2,Разделитель);
for i=1..t do
  s1=ВыделитьСлово(i,Ан1,Разделитель);
  j=ПоискВмассиве(st,s1,true);
  if j>0:УдалитьИзМассива(st,j);
     ss=ss+Разделитель+s1;
   | true: s2=s2+Разделитель+'-'+s1;
  fi;
od;
t=ДлинаМассива(st);
s1='';
for i=1..t do
  s1=s1+Разделитель+'+'+st[i];
od;
^s1+Разделитель+s2+Разделитель+ss;

2End0;

2Func0 РавныеСтрокиПоСловам(Ан1:s;Ан2:s;Разделитель:s):l;
var i,t:i;
var l:l;
var s1,s2:s;
Ан1=Разделитель+Ан1+Разделитель;
Ан2=Разделитель+Ан2+Разделитель;
ClearVariable(st);
t=КоличествоСлов(Ан1,Разделитель);
for i=1..t do
  s1=ВыделитьСлово(i,Ан1,Разделитель);
  ВставитьВмассивСорт(st,s1);
od;
s2='';
for i=1..t do
  s2=s2+Разделитель+st[i];
od;

ClearVariable(st);
t=КоличествоСлов(Ан2,Разделитель);
for i=1..t do
  s1=ВыделитьСлово(i,Ан1,Разделитель);
  ВставитьВмассивСорт(st,s1);
od;
s1='';
for i=1..t do
  s1=s1+Разделитель+st[i];
od;

^(s1=s2);
2End0;

2Func0 РавныеПроводки(Сч1:s;Сч2:s;Ан1:s;Ан2:s;Сум1:n;Сум2:n;Кол1:n;Кол2:n):l;
var l:l;
l=(Сч1=Сч2);
l=l и (Сум1=Сум2);
l=l и (Кол1=Кол2);
if l:l=l и РавныеСтрокиПоСловам(Ан1,Ан2,' ');
 | true:^false;
fi;
 ^l;
2End0;
2Func0 ФиксДНФА(
  NNDAY        :I;
  НОМЕР        :S;
  ДАТОПЕР      :D;
  АН_ДНФА      :S;
  ПРОВОДИТЬ    :L;
  ПРОВЕРИТЬ    :L;
  ФИКС         :L;
  ТНФА         :S;
  ТКОЛНФА      :S;
  ТСУМНФА      :S;
  ТЦЕНАНФА     :S;
  ТСЧНФА       :S;
  ТКОРСЧНФА    :S;
  ТАМСЧНФА     :S;
  ТАМСУМНФА    :S;
  ТАН01        :S;
  ТАН02        :S;
  ТАН03        :S;
  ТАН04        :S;
  ТАН05        :S;
  ТАН06        :S;
  ТАН07        :S;
  ТАН08        :S;
  ТАН09        :S;
  ТАН10        :S;
  ТАН11        :S;
  ТАН12        :S;
  ТАН13        :S;
  ТАН14        :S;
  ТАН15        :S;
  ТАН16        :S;
  ТАН17        :S;
  ТАН18        :S;
  ТАН19        :S;
  ТАН20        :S;
  ТАН21        :S;
  ТАН22        :S;
  ТАН23        :S;
  ТАН24        :S;
  ТАН25        :S;
  ТЧ01         :S;
  ТЧ02         :S;
  ТЧ03         :S;
  ТЧ04         :S;
  ТЧ05         :S;
  ТСЧ01        :S;
  ТСЧ02        :S;
  ТСЧ03        :S;
  ТСЧ04        :S;
  ТСЧ05        :S;
  ТСЧ06        :S;
  ТСЧ07        :S;
  ТСЧ08        :S;
  ТСЧ09        :S;
  ТСЧ10        :S;
  ТСЧ11        :S;
  ТД01         :S;
  ТД02         :S;
  ТД03         :S;
  ТД04         :S;
  ТД05         :S;
  ОСНОВАНИЕ    :S;
  МАКСКОЛПРОВ  :I;

    НФА      :S;
    ИМЯНФА   :S;
    КОЛНФА   :n;
    СУМНФА   :n;
    АМСУМНФА :n;
    СЧНФА    :S;
    КОРСЧНФА :S;
    АМСЧНФА  :S;
    ОСТНФА   :S;
    АН01     :S;
    АН02     :S;
    АН03     :S;
    АН04     :S;
    АН05     :S;
    АН06     :S;
    АН07     :S;
    АН08     :S;
    АН09     :S;
    АН10     :S;
    АН11     :S;
    АН12     :S;
    АН13     :S;
    АН14     :S;
    АН15     :S;
    АН16     :S;
    АН17     :S;
    АН18     :S;
    АН19     :S;
    АН20     :S;
    АН21     :S;
    АН22     :S;
    АН23     :S;
    АН24     :S;
    АН25     :S;
    Ч01      :n;
    Ч02      :n;
    Ч03      :n;
    Ч04      :n;
    Ч05      :n;
    СЧ01     :S;
    СЧ02     :S;
    СЧ03     :S;
    СЧ04     :S;
    СЧ05     :S;
    СЧ06     :S;
    СЧ07     :S;
    СЧ08     :S;
    СЧ09     :S;
    СЧ10     :S;
    СЧ11     :S;
    Д01      :D;
    Д02      :D;
    Д03      :D;
    Д04      :D;
    Д05      :D;
    кмнт     :s
):i;
    VAR   колпров :Ц;
    VAR   НФАПР   :С;
    VAR   КолНФАПР:Ч;
    VAR   Сум  :Ч;
    VAR   ДСчет:С;
    VAR   КСчет:С;
    VAR   ДАН01:С;
    VAR   ДАН02:С;
    VAR   ДАН03:С;
    VAR   ДАН04:С;
    VAR   ДАН05:С;
    VAR   ДАН06:С;
    VAR   ДАН07:С;
    VAR   ДАН08:С;
    VAR   ДАН09:С;
    VAR   ДАН10:С;
    VAR   ДАН11:С;
    VAR   ДАН12:С;
    VAR   ДАН13:С;
    VAR   ДАН14:С;
    VAR   ДАН15:С;
    VAR   ДАН16:С;
    VAR   ДАН17:С;
    VAR   ДАН18:С;
    VAR   ДАН19:С;
    VAR   ДАН20:С;
    VAR   ДАН21:С;
    VAR   ДАН22:С;
    VAR   ДАН23:С;
    VAR   ДАН24:С;
    VAR   ДАН25:С;
    VAR   КАН01:С;
    VAR   КАН02:С;
    VAR   КАН03:С;
    VAR   КАН04:С;
    VAR   КАН05:С;
    VAR   КАН06:С;
    VAR   КАН07:С;
    VAR   КАН08:С;
    VAR   КАН09:С;
    VAR   КАН10:С;
    VAR   КАН11:С;
    VAR   КАН12:С;
    VAR   КАН13:С;
    VAR   КАН14:С;
    VAR   КАН15:С;
    VAR   КАН16:С;
    VAR   КАН17:С;
    VAR   КАН18:С;
    VAR   КАН19:С;
    VAR   КАН20:С;
    VAR   КАН21:С;
    VAR   КАН22:С;
    VAR   КАН23:С;
    VAR   КАН24:С;
    VAR   КАН25:С;

    VAR   КАН00:С;
    VAR   ДАН00:С;

    VAR   t:i;
    VAR   Проверять:l;
    VAR   ll1:l;
    VAR   ll2:l;
    VAR   stt:s;
    VAR   ss:s;
    VAR   s0:s;
    VAR   di:s;
    VAR   ОстКол:n;
    VAR   ОстСум:n;
    VAR   Кмнт_:s;
    колпров=0;
    di='ДНФА.'+АН_ДНФА;
ClearVariable(Раб.НФА.B01.st);  --ДАН00+КАН00
ClearVariable(Раб.НФА.B01.st1); --ДСчет
ClearVariable(Раб.НФА.B01.st2); --КСчет
ClearVariable(Раб.НФА.B01.st3); --кмнт
ClearVariable(Раб.НФА.B01.st4); --НФАПР
ClearVariable(Раб.НФА.B01.nn ); --Сум
ClearVariable(Раб.НФА.B01.nn1); --КолНФАПР

      for t=1..МаксКолПров do
         stt=str(t);
         s0=stt+'о';

        Сум=if(pos(s0,ТСумНФА)>0:СумНФА
              |pos(s0,ТАмСумНФА)>0:АмСумНФА
              |pos(s0,ТЧ01)>0:Ч01
              |pos(s0,ТЧ02)>0:Ч02
              |pos(s0,ТЧ03)>0:Ч03
              |pos(s0,ТЧ04)>0:Ч04
              |pos(s0,ТЧ05)>0:Ч05

              |pos(s0,ТД01)>0:Д01-1.1.100
              |pos(s0,ТД02)>0:Д02-1.1.100
              |pos(s0,ТД03)>0:Д03-1.1.100
              |pos(s0,ТД04)>0:Д04-1.1.100
              |pos(s0,ТД05)>0:Д05-1.1.100

              ,0
              );

        НФАПР   =if(pos(s0,ТНФА   )>0:НФА   ,'');
        КолНФАПР=if(pos(s0,ТКолНФА)>0:КолНФА,0 );

        ss=stt+'д';
        ДСчет=if(pos(ss,ТСчНФА)>0 or pos(s0,ТСчНФА)>0:СчНФА
                |pos(ss,ТКорСчНФА)>0 or pos(s0,ТКорСчНФА)>0:КорСчНФА
                |pos(ss,ТАмСчНФА)>0 or pos(s0,ТАмСчНФА)>0:АмСчНФА
                |pos(ss,ТСЧ01)>0 or pos(s0,ТСЧ01)>0:СЧ01
                |pos(ss,ТСЧ02)>0 or pos(s0,ТСЧ02)>0:СЧ02
                |pos(ss,ТСЧ03)>0 or pos(s0,ТСЧ03)>0:СЧ03
                |pos(ss,ТСЧ04)>0 or pos(s0,ТСЧ04)>0:СЧ04
                |pos(ss,ТСЧ05)>0 or pos(s0,ТСЧ05)>0:СЧ05
                |pos(ss,ТСЧ06)>0 or pos(s0,ТСЧ06)>0:СЧ06
                |pos(ss,ТСЧ07)>0 or pos(s0,ТСЧ07)>0:СЧ07
                |pos(ss,ТСЧ08)>0 or pos(s0,ТСЧ08)>0:СЧ08
                |pos(ss,ТСЧ09)>0 or pos(s0,ТСЧ09)>0:СЧ09
                |pos(ss,ТСЧ10)>0 or pos(s0,ТСЧ10)>0:СЧ10
                |pos(ss,ТСЧ11)>0 or pos(s0,ТСЧ11)>0:СЧ11,''
                );

        ДАН01=if(pos(ss,ТАН01)>0 or pos(s0,ТАН01)>0:АН01,'');ДАН00=if(ДАН01<>'','|+'+ДАН01,'');
        ДАН02=if(pos(ss,ТАН02)>0 or pos(s0,ТАН02)>0:АН02,'');ДАН00=ДАН00+if(ДАН02<>'','|+'+ДАН02,'');
        ДАН03=if(pos(ss,ТАН03)>0 or pos(s0,ТАН03)>0:АН03,'');ДАН00=ДАН00+if(ДАН03<>'','|+'+ДАН03,'');
        ДАН04=if(pos(ss,ТАН04)>0 or pos(s0,ТАН04)>0:АН04,'');ДАН00=ДАН00+if(ДАН04<>'','|+'+ДАН04,'');
        ДАН05=if(pos(ss,ТАН05)>0 or pos(s0,ТАН05)>0:АН05,'');ДАН00=ДАН00+if(ДАН05<>'','|+'+ДАН05,'');
        ДАН06=if(pos(ss,ТАН06)>0 or pos(s0,ТАН06)>0:АН06,'');ДАН00=ДАН00+if(ДАН06<>'','|+'+ДАН06,'');
        ДАН07=if(pos(ss,ТАН07)>0 or pos(s0,ТАН07)>0:АН07,'');ДАН00=ДАН00+if(ДАН07<>'','|+'+ДАН07,'');
        ДАН08=if(pos(ss,ТАН08)>0 or pos(s0,ТАН08)>0:АН08,'');ДАН00=ДАН00+if(ДАН08<>'','|+'+ДАН08,'');
        ДАН09=if(pos(ss,ТАН09)>0 or pos(s0,ТАН09)>0:АН09,'');ДАН00=ДАН00+if(ДАН09<>'','|+'+ДАН09,'');
        ДАН10=if(pos(ss,ТАН10)>0 or pos(s0,ТАН10)>0:АН10,'');ДАН00=ДАН00+if(ДАН10<>'','|+'+ДАН10,'');
        ДАН11=if(pos(ss,ТАН11)>0 or pos(s0,ТАН11)>0:АН11,'');ДАН00=ДАН00+if(ДАН11<>'','|+'+ДАН11,'');
        ДАН12=if(pos(ss,ТАН12)>0 or pos(s0,ТАН12)>0:АН12,'');ДАН00=ДАН00+if(ДАН12<>'','|+'+ДАН12,'');
        ДАН13=if(pos(ss,ТАН13)>0 or pos(s0,ТАН13)>0:АН13,'');ДАН00=ДАН00+if(ДАН13<>'','|+'+ДАН13,'');
        ДАН14=if(pos(ss,ТАН14)>0 or pos(s0,ТАН14)>0:АН14,'');ДАН00=ДАН00+if(ДАН14<>'','|+'+ДАН14,'');
        ДАН15=if(pos(ss,ТАН15)>0 or pos(s0,ТАН15)>0:АН15,'');ДАН00=ДАН00+if(ДАН15<>'','|+'+ДАН15,'');
        ДАН16=if(pos(ss,ТАН16)>0 or pos(s0,ТАН16)>0:АН16,'');ДАН00=ДАН00+if(ДАН16<>'','|+'+ДАН16,'');
        ДАН17=if(pos(ss,ТАН17)>0 or pos(s0,ТАН17)>0:АН17,'');ДАН00=ДАН00+if(ДАН17<>'','|+'+ДАН17,'');
        ДАН18=if(pos(ss,ТАН18)>0 or pos(s0,ТАН18)>0:АН18,'');ДАН00=ДАН00+if(ДАН18<>'','|+'+ДАН18,'');
        ДАН19=if(pos(ss,ТАН19)>0 or pos(s0,ТАН19)>0:АН19,'');ДАН00=ДАН00+if(ДАН19<>'','|+'+ДАН19,'');
        ДАН20=if(pos(ss,ТАН20)>0 or pos(s0,ТАН20)>0:АН20,'');ДАН00=ДАН00+if(ДАН20<>'','|+'+ДАН20,'');
        ДАН21=if(pos(ss,ТАН21)>0 or pos(s0,ТАН21)>0:АН21,'');ДАН00=ДАН00+if(ДАН21<>'','|+'+ДАН21,'');
        ДАН22=if(pos(ss,ТАН22)>0 or pos(s0,ТАН22)>0:АН22,'');ДАН00=ДАН00+if(ДАН22<>'','|+'+ДАН22,'');
        ДАН23=if(pos(ss,ТАН23)>0 or pos(s0,ТАН23)>0:АН23,'');ДАН00=ДАН00+if(ДАН23<>'','|+'+ДАН23,'');
        ДАН24=if(pos(ss,ТАН24)>0 or pos(s0,ТАН24)>0:АН24,'');ДАН00=ДАН00+if(ДАН24<>'','|+'+ДАН24,'');
        ДАН25=if(pos(ss,ТАН25)>0 or pos(s0,ТАН25)>0:АН25,'');ДАН00=ДАН00+if(ДАН25<>'','|+'+ДАН25,'');
        ss=stt+'к';
        КСчет=if(pos(ss,ТСчНФА)>0 or pos(s0,ТСчНФА)>0:СчНФА
                |pos(ss,ТКорСчНФА)>0 or pos(s0,ТКорСчНФА)>0:КорСчНФА
                |pos(ss,ТАмСчНФА)>0 or pos(s0,ТАмСчНФА)>0:АмСчНФА
                |pos(ss,ТСЧ01)>0 or pos(s0,ТСЧ01)>0:СЧ01
                |pos(ss,ТСЧ02)>0 or pos(s0,ТСЧ02)>0:СЧ02
                |pos(ss,ТСЧ03)>0 or pos(s0,ТСЧ03)>0:СЧ03
                |pos(ss,ТСЧ04)>0 or pos(s0,ТСЧ04)>0:СЧ04
                |pos(ss,ТСЧ05)>0 or pos(s0,ТСЧ05)>0:СЧ05
                |pos(ss,ТСЧ06)>0 or pos(s0,ТСЧ06)>0:СЧ06
                |pos(ss,ТСЧ07)>0 or pos(s0,ТСЧ07)>0:СЧ07
                |pos(ss,ТСЧ08)>0 or pos(s0,ТСЧ08)>0:СЧ08
                |pos(ss,ТСЧ09)>0 or pos(s0,ТСЧ09)>0:СЧ09
                |pos(ss,ТСЧ10)>0 or pos(s0,ТСЧ10)>0:СЧ10
                |pos(ss,ТСЧ11)>0 or pos(s0,ТСЧ11)>0:СЧ11,''
                );

        КАН01=if(pos(ss,ТАН01)>0 or pos(s0,ТАН01)>0:АН01,'');КАН00=if(КАН01<>'','|-'+КАН01,'');
        КАН02=if(pos(ss,ТАН02)>0 or pos(s0,ТАН02)>0:АН02,'');КАН00=КАН00+if(КАН02<>'','|-'+КАН02,'');
        КАН03=if(pos(ss,ТАН03)>0 or pos(s0,ТАН03)>0:АН03,'');КАН00=КАН00+if(КАН03<>'','|-'+КАН03,'');
        КАН04=if(pos(ss,ТАН04)>0 or pos(s0,ТАН04)>0:АН04,'');КАН00=КАН00+if(КАН04<>'','|-'+КАН04,'');
        КАН05=if(pos(ss,ТАН05)>0 or pos(s0,ТАН05)>0:АН05,'');КАН00=КАН00+if(КАН05<>'','|-'+КАН05,'');
        КАН06=if(pos(ss,ТАН06)>0 or pos(s0,ТАН06)>0:АН06,'');КАН00=КАН00+if(КАН06<>'','|-'+КАН06,'');
        КАН07=if(pos(ss,ТАН07)>0 or pos(s0,ТАН07)>0:АН07,'');КАН00=КАН00+if(КАН07<>'','|-'+КАН07,'');
        КАН08=if(pos(ss,ТАН08)>0 or pos(s0,ТАН08)>0:АН08,'');КАН00=КАН00+if(КАН08<>'','|-'+КАН08,'');
        КАН09=if(pos(ss,ТАН09)>0 or pos(s0,ТАН09)>0:АН09,'');КАН00=КАН00+if(КАН09<>'','|-'+КАН09,'');
        КАН10=if(pos(ss,ТАН10)>0 or pos(s0,ТАН10)>0:АН10,'');КАН00=КАН00+if(КАН10<>'','|-'+КАН10,'');
        КАН11=if(pos(ss,ТАН11)>0 or pos(s0,ТАН11)>0:АН11,'');КАН00=КАН00+if(КАН11<>'','|-'+КАН11,'');
        КАН12=if(pos(ss,ТАН12)>0 or pos(s0,ТАН12)>0:АН12,'');КАН00=КАН00+if(КАН12<>'','|-'+КАН12,'');
        КАН13=if(pos(ss,ТАН13)>0 or pos(s0,ТАН13)>0:АН13,'');КАН00=КАН00+if(КАН13<>'','|-'+КАН13,'');
        КАН14=if(pos(ss,ТАН14)>0 or pos(s0,ТАН14)>0:АН14,'');КАН00=КАН00+if(КАН14<>'','|-'+КАН14,'');
        КАН15=if(pos(ss,ТАН15)>0 or pos(s0,ТАН15)>0:АН15,'');КАН00=КАН00+if(КАН15<>'','|-'+КАН15,'');
        КАН16=if(pos(ss,ТАН16)>0 or pos(s0,ТАН16)>0:АН16,'');КАН00=КАН00+if(КАН16<>'','|-'+КАН16,'');
        КАН17=if(pos(ss,ТАН17)>0 or pos(s0,ТАН17)>0:АН17,'');КАН00=КАН00+if(КАН17<>'','|-'+КАН17,'');
        КАН18=if(pos(ss,ТАН18)>0 or pos(s0,ТАН18)>0:АН18,'');КАН00=КАН00+if(КАН18<>'','|-'+КАН18,'');
        КАН19=if(pos(ss,ТАН19)>0 or pos(s0,ТАН19)>0:АН19,'');КАН00=КАН00+if(КАН19<>'','|-'+КАН19,'');
        КАН20=if(pos(ss,ТАН20)>0 or pos(s0,ТАН20)>0:АН20,'');КАН00=КАН00+if(КАН20<>'','|-'+КАН20,'');
        КАН21=if(pos(ss,ТАН21)>0 or pos(s0,ТАН21)>0:АН21,'');КАН00=КАН00+if(КАН21<>'','|-'+КАН21,'');
        КАН22=if(pos(ss,ТАН22)>0 or pos(s0,ТАН22)>0:АН22,'');КАН00=КАН00+if(КАН22<>'','|-'+КАН22,'');
        КАН23=if(pos(ss,ТАН23)>0 or pos(s0,ТАН23)>0:АН23,'');КАН00=КАН00+if(КАН23<>'','|-'+КАН23,'');
        КАН24=if(pos(ss,ТАН24)>0 or pos(s0,ТАН24)>0:АН24,'');КАН00=КАН00+if(КАН24<>'','|-'+КАН24,'');
        КАН25=if(pos(ss,ТАН25)>0 or pos(s0,ТАН25)>0:АН25,'');КАН00=КАН00+if(КАН25<>'','|-'+КАН25,'');
        ll1=false;
        ll2=false;
        if ДАН01=КАН01 and pos("НФА.",КАН01)=1: НФАПР=КАН01; КАН01=""; ДАН01="";
        |  ДАН02=КАН02 and pos("НФА.",КАН02)=1: НФАПР=КАН02; КАН02=""; ДАН02="";
        |  ДАН03=КАН03 and pos("НФА.",КАН03)=1: НФАПР=КАН03; КАН03=""; ДАН03="";
        |  ДАН04=КАН04 and pos("НФА.",КАН04)=1: НФАПР=КАН04; КАН04=""; ДАН04="";
        fi;
        if Сум=0 or КолНФАПР=0:
           s0=stt+'0';
          if Сум=0:ll1=true;
                if pos(s0,ТСумНФА)>0:Сум=СумНФА;
                   |pos(s0,ТАмСумНФА)>0:Сум=АмСумНФА;
                   |pos(s0,ТЧ01)>0:Сум=Ч01;
                   |pos(s0,ТЧ02)>0:Сум=Ч02;
                   |pos(s0,ТЧ03)>0:Сум=Ч03;
                   |pos(s0,ТЧ04)>0:Сум=Ч04;
                   |pos(s0,ТЧ05)>0:Сум=Ч05;

                   |pos(s0,ТД01)>0:Сум=Д01-1.1.100;
                   |pos(s0,ТД02)>0:Сум=Д02-1.1.100;
                   |pos(s0,ТД03)>0:Сум=Д03-1.1.100;
                   |pos(s0,ТД04)>0:Сум=Д04-1.1.100;
                   |pos(s0,ТД05)>0:Сум=Д05-1.1.100;

                   |true:ll1=false;
                fi;
          fi;
          if КолНФАПР=0:
            КолНФАПР=if(pos(s0,ТКолНФА)>0:КолНФА,0 );
            ll2=pos(s0,ТКолНФА)>0;
          fi;--  if ll:message(s0);fi;
        fi;
        if 2(Сум0=20 or КолНФАПР0=20)0 and (ll1 or ll2):
           2Сум0=200;
           2КолНФАПР0=200;
        fi;

        if ДСчет<>'' and КСчет<>'' and (Сум<>0 or КолНФАПР<>0):
--        if ДСчет<>'' and КСчет<>'' and Сум<>0:
          if НФАПР<>'':
             if Сум<>0 или КолНФАПР<>0:
                колпров=колпров+1;
                nn [колпров]=Сум;
                nn1[колпров]=КолНФАПР;
                st1[колпров]=ДСчет;
                st2[колпров]=КСчет;
                st [колпров]=ДАН00+КАН00;
  --              st [колпров]=' '+di+'|'+ДАН00+КАН00;
                st3[колпров]=кмнт;
                st4[колпров]=НФАПР;
   --          : Сум $ДСчет [$ДАН01 $ДАН02 $ДАН03 $ДАН04 $ДАН05 $ДАН06 $ДАН07 $ДАН08 $ДАН09 $ДАН10 $ДАН11 $ДАН12 $ДАН13 $ДАН14 $ДАН15 $ДАН16 $ДАН17 $ДАН18 $ДАН19 $ДАН20] $КСчет [$КАН01 $КАН02 $КАН03 $КАН04 $КАН05 $КАН06 $КАН07 $КАН08 $КАН09 $КАН10 $КАН11 $КАН12 $КАН13 $КАН14 $КАН15 $КАН16 $КАН17 $КАН18 $КАН19 $КАН20] {$НФАПР:КолНФАПР $di} -- $ОСНОВАНИЕ
             fi;
           | true:
             колпров=колпров+1;
                nn [колпров]=Сум;
                nn1[колпров]=0;
                st1[колпров]=ДСчет;
                st2[колпров]=КСчет;
                st [колпров]=ДАН00+КАН00;
--                st [колпров]=' '+di+'|'+ДАН00+КАН00;
                st3[колпров]=кмнт;
                st4[колпров]='';
 --          : Сум $ДСчет [$ДАН01 $ДАН02 $ДАН03 $ДАН04 $ДАН05 $ДАН06 $ДАН07 $ДАН08 $ДАН09 $ДАН10 $ДАН11 $ДАН12 $ДАН13 $ДАН14 $ДАН15 $ДАН16 $ДАН17 $ДАН18 $ДАН19 $ДАН20] $КСчет [$КАН01 $КАН02 $КАН03 $КАН04 $КАН05 $КАН06 $КАН07 $КАН08 $КАН09 $КАН10 $КАН11 $КАН12 $КАН13 $КАН14 $КАН15 $КАН16 $КАН17 $КАН18 $КАН19 $КАН20]  {$di}-- $ОСНОВАНИЕ
          fi;
        fi;
      od;
^колпров;
2End0;

2func0 БланкИмя:s;
 var ss:s;
 ss=БланкИмяФайла('');
 ss=ВыделитьСлова(КоличествоСлов(ss,'\'),1,ss,'\');
 ss=ВыделитьСлова(1,КоличествоСлов(ss,'.')-1,ss,'.');
 ^ss;
2End0;
2func0 BlnName:s;
^БланкИмя;
2End0;
2func0 ПутьSTD_RPO:s;
 ^РАБ.ПЛАН.ВзятьПолныйПутьSTD_RPO;
2End0;
2func0 ВзятьBRO(Место1:s;Место2:s;Место3:s;BRO:s):s;-- Место1,Место2 - пути поиска по приоритету с '\' на конце, если путь не пустой
     -- возвращает существующий броузер по приоритету поиска Место1,Место2, если такого нет, но есть одноименная картотека
     -- возвращает ее имя, в противном случае пустая строка.
 var ss:s;
 var ii:i;
 ss=BRO+'.bro';
 if ЕстьФайл(Место1+ss):^Место1+BRO;fi;
 if ЕстьФайл(Место2+ss):^Место2+BRO;fi;
 if ЕстьФайл(Место3+ss):^Место3+BRO;fi;
 if ЕстьКартотека(BRO):^BRO;fi;
 ^'';
2End0;
2func0 ВзятьBROизКартотеки(BRO:s):s;
 var ПутьLocalDataКартотеки,ПутьSTD_RPO_ОбщиеКартотеки,ПутьSTD_RPO_НФА_Картотеки:s;
 var ii:i;
   ПутьLocalDataКартотеки=PlanVar("LocalData")+'\Картотеки';
--   if не ЕстьПапка(ПутьLocalDataКартотеки): -- пытаемся найти в ПутьSTD_RPO
      ПутьSTD_RPO_ОбщиеКартотеки=ПутьSTD_RPO+'\Общие\Картотеки';
      if не ЕстьПапка(ПутьSTD_RPO_ОбщиеКартотеки):ПутьSTD_RPO_ОбщиеКартотеки='';fi;
      ПутьSTD_RPO_НФА_Картотеки=ПутьSTD_RPO+'\НФА\Картотеки';
      if не ЕстьПапка(ПутьSTD_RPO_НФА_Картотеки):ПутьSTD_RPO_НФА_Картотеки='';fi;
--   fi;
   if ПутьLocalDataКартотеки<>'':ПутьLocalDataКартотеки=ПутьLocalDataКартотеки+'\';fi;
   if ПутьSTD_RPO_ОбщиеКартотеки<>'':ПутьSTD_RPO_ОбщиеКартотеки=ПутьSTD_RPO_ОбщиеКартотеки+'\';fi;
   if ПутьSTD_RPO_НФА_Картотеки<>'':ПутьSTD_RPO_НФА_Картотеки=ПутьSTD_RPO_НФА_Картотеки+'\';fi;
   ^ВзятьBRO(ПутьLocalDataКартотеки,ПутьSTD_RPO_ОбщиеКартотеки,ПутьSTD_RPO_НФА_Картотеки,BRO);
2End0;
2proc0  TransOpenJurNFA(t:i);
 var ИмяКарт,ИмяБро,ВИДДОК,БланкРед:s;
 var rec:record;
   ИмяКарт=ПроводКартотека(t);
   БланкРед='';
   if ИмяКарт='РПО_ОПЕРАЦИИДНФА':ВИДДОК='ВИДДОК.НФА.ЖУР.ОПЕРАЦИИДНФА';БланкРед='НФА.ЖУР.ОПЕРАЦИИДНФА';
    | ИмяКарт='РПО_ОСТ_НФА'     :ВИДДОК='ВИДДОК.НФА.ЖУР.РПО_ОСТ_НФА'; БланкРед='НФА.ЖУР.РПО_ОСТ_НФА';
    | ИмяКарт='РПО_ВНУТР_ПЕРЕМ_МОЛ'     :ВИДДОК='ВИДДОК.НФА.ЖУР.ВНУТР_ПЕРЕМЕЩЕН'; БланкРед='НФА.ЖУР.ВНУТР_ПЕРЕМЕЩЕН';
    | true:TransOpenJur(t);exit;
   fi;
   ИмяБро=2ПолеПоПризнакуС0(ВИДДОК,'КАРТБРО');
   ИмяБро=ВзятьBROизКартотеки(ИмяБро);
--   if БланкРед<>'':
--     if БланкОткрыт(БланкРед):
--        Закрыть(БланкРед);
--     fi;
--   fi;
   rec=ПроводЗапись(t);
   ОткрытьКартотеку(ИмяБро,'',rec);
2End0;
Func ЗаполнитьСписокПолейКартотеки(картимя:s):s;-- возвращает полный путь к массиву с подготовленными данными
  var ii,j,k,z,jj:i;
  var ss,ss1:s;
  ClearVariable(Раб.НФА.B01.st);
  ClearVariable(Раб.НФА.B01.st1);
  ClearVariable(Раб.НФА.B01.st2);

  st1[1]=картимя;
  ii=ВзятьПоляКартотеки(картимя,Раб.НФА.B01.st2,mtlSUBTAB);
--  ii=ВыполнитьФункциюЦ('ВзятьПоляКартотеки',картимя,st2,mtlSUBTAB);
  for j=1..ii do st1[j+1]=картимя+'@'+st2[j];od;
  k=ДлинаМассива(st1);
  for j=1..k do -- цикл по таблице и подтаблицам
    ii=ВзятьПоляКартотеки(st1[j],Раб.НФА.B01.st2,mtlREAL   );jj=ДлинаМассива(st);for z=1..ii do st[jj+z]=st1[j]+'|'+st2[z]+'|NЧ';od;
    ii=ВзятьПоляКартотеки(st1[j],Раб.НФА.B01.st2,mtlINTEGER);jj=ДлинаМассива(st);for z=1..ii do st[jj+z]=st1[j]+'|'+st2[z]+'|IЦ';od;
    ii=ВзятьПоляКартотеки(st1[j],Раб.НФА.B01.st2,mtlBOOLEAN);jj=ДлинаМассива(st);for z=1..ii do st[jj+z]=st1[j]+'|'+st2[z]+'|LЛ';od;
    ii=ВзятьПоляКартотеки(st1[j],Раб.НФА.B01.st2,mtlSTRING );jj=ДлинаМассива(st);for z=1..ii do st[jj+z]=st1[j]+'|'+st2[z]+'|SС';od;
    ii=ВзятьПоляКартотеки(st1[j],Раб.НФА.B01.st2,mtlDATE   );jj=ДлинаМассива(st);for z=1..ii do st[jj+z]=st1[j]+'|'+st2[z]+'|DД';od;
    ii=ВзятьПоляКартотеки(st1[j],Раб.НФА.B01.st2,mtlREF    );jj=ДлинаМассива(st);for z=1..ii do st[jj+z]=st1[j]+'|'+st2[z]+'|RЗ|'+ВзятьКартотекуПоСсылочномуПолю(st1[j],st2[z]);od;
  od;
--  ii=ДлинаМассива(st);
--  for j=1..ii do
--    trace(st[j]);
--  od;

-- st
--mtlTimed-- периодические поля
--mtlAll-- все поля картотеки.
 ^'st';
end;

2proc0 КопироватьЗаписьПодтаблицыБланкаРедактора(МассивСписокПолейКартотеки:s;ДлинаСписка:i;Таблица:s;ПодТаблица:s;i0:i;i1:i);
  var ii:i;
  var ss,ss1,ss2,ss3,тип:s;
  Таблица=Up(Таблица);
  ПодТаблица=Up(ПодТаблица);
  for ii=1..ДлинаСписка do
    ss=Up(ВзятьПеременнуюС(МассивСписокПолейКартотеки+'['+str(ii)+']'));
    if pos(Таблица+'@'+ПодТаблица+'|',ss)=1:
       ss3=ВыделитьСлово(2,ss,'|');
       if pos(ss3,'UKEY CARDUKEY')<1:
          тип=ВыделитьСлово(3,ss,'|');
          ss1='['+str(i1)+'].'+ss3;
          ss2='['+str(i0)+'].'+ss3;
          if pos('С',тип)>0:ЗаписатьПеременнуюС(ПодТаблица+ss1,ВзятьПеременнуюС(ПодТаблица+ss2));
           | pos('Ч',тип)>0:ЗаписатьПеременнуюЧ(ПодТаблица+ss1,ВзятьПеременнуюЧ(ПодТаблица+ss2));
           | pos('Ц',тип)>0:ЗаписатьПеременнуюЦ(ПодТаблица+ss1,ВзятьПеременнуюЦ(ПодТаблица+ss2));
           | pos('Л',тип)>0:ЗаписатьПеременнуюЛ(ПодТаблица+ss1,ВзятьПеременнуюЛ(ПодТаблица+ss2));
           | pos('Д',тип)>0:ЗаписатьПеременнуюД(ПодТаблица+ss1,ВзятьПеременнуюД(ПодТаблица+ss2));
           | pos('З',тип)>0:ЗаписатьПеременнуюЗ(ПодТаблица+ss1,ВзятьПеременнуюЗ(ПодТаблица+ss2));
          fi;
       fi;
    fi;
  od;
2end0;
Func СтрокуВЧисл (Value:S):N;
var p:i;
 p=Pos("'",Value);
 While p>0 do
  Value=Delete(Value,p,1);
  p=Pos("'",Value);
 od;
 ^Round(Value,2);
end;




func ОбработатьТекТекстПроводку(НФ:i):s;
  var Дб,Кр,Ан,КолАн,Вал,ss,ss0,ss1:s;
  var Сум,СумВал,Кол:s;
  var ii,p:i;
  var ПозСум1,ПозСум2,ПозКол,ПозАн1,ПозАн2,ПозКмнт:i;
--  ss0=":   1'000.0000 187.0000.0000000.000.2.101.01.310 187.0000.0000000.000.2.101.01.310";
--  ss0=":   1'000.0000 187.0000.0000000.000.2.101.01.310 187.0000.0000000.000.2.101.01.310 {ФКР.187.0000.0000000.000 РБС.001 НФА.101.04.77771.ПРИНТЕР:10}";
--  ss0=":   1'000.0000^usd : 500 187.0000.0000000.000.2.101.01.310 187.0000.0000000.000.2.101.01.310 {ФКР.187.0000.0000000.000 РБС.001 НФА.101.04.77771.ПРИНТЕР:10}";
--  ss0=ТекстФайлПрочитать(НФ,255);
  ss0=ТекстФайлПрочитатьСтроку(НФ);
  ПозСум1=Pos(':',ss0);
  ПозКмнт=Pos('--',ss1);
  if (ПозКмнт<ПозСум1 и ПозКмнт>0)или ПозСум1<1:^'';fi;-- строка закомментирована или дата, или пустая...
  ПозАн1=Pos('{',ss0);
  ПозАн2=Pos('}',ss0);
  if ПозАн1>0:
     Ан=SubStr(ss0,ПозАн1+1,ПозАн2-ПозАн1-1);
     ss0=trim(SubStr(ss0,ПозСум1+1,ПозАн1-ПозСум1-1));-- в ss0 теперь только суммы и счета без первого двоеточия
     ПозКол=Pos(':',Ан);
     if ПозКол>0:-- есть количественный признак
       ss   =SubStr(Ан,1,ПозКол-1);
       КолАн=trim(ВыделитьСлово(КоличествоСлов(ss,' '),ss,' '));-- выбрали признак
       ss   =trim(ВыделитьСлова(1,КоличествоСлов(ss,' ')-1,ss,' '));
       ss1  =SubStr(Ан,ПозКол+1,255)+' ';
       p=pos(' ',ss1);
       Кол  =SubStr(ss1,1,p-1); -- выбрали количество
       Ан=ss+' '+SubStr(ss1,p+1,255);-- теперь Ан не содержит кол признака и количества
     fi;
   | true:ss0=trim(Удалить(ss0,1,ПозСум1+1));--в ss0 теперь только суммы и счета без первого двоеточия
  fi;
  ii=КоличествоСлов(ss0,' ');
  Дб =trim(ВыделитьСлово(ii-1,ss0,' '));
  Кр =trim(ВыделитьСлово(ii  ,ss0,' '));
  ss =trim(ВыделитьСлово(1   ,ss0,' '));
  p=pos('^',ss);
  if p>0:-- это валюта
     СумВал=SubStr(ss,1,p-1);
     Вал   =SubStr(ss,p+1,255);
   | true:Сум=ss;
  fi;
  if ii>3: -- в проводке есть две суммы
     if ii=5:ss=trim(ВыделитьСлово(3  ,ss0,' '));
      | ii=4:ss=trim(ВыделитьСлово(2  ,ss0,' '));
             ss=trim(SubStr(ss,2,255));
     fi;
     p=pos('^',ss);
     if p>0:-- это валюта
        СумВал=SubStr(ss,1,p-1);
        Вал   =SubStr(ss,p+1,255);
      | true:Сум=ss;
     fi;
  fi;

  ^Сум+' #'+СумВал+' #'+Вал+' #'+КолАн+' #'+Кол+' #'+Дб+' #'+Кр+' #'+Ан;
-- СтрокуВЧисло
-- if ExistFile(FName)=False: Exit; fi;

-- НФ=ТекстФайлОткрытьНаЧтение(FName);
-- ShowProgress(n,"Подготовка данных...");
-- n=0;
-- Try
--  While not ЗавершитьОбработку do

--  ТекстФайлКонецФайла(НФ)
--   n=n+1;
--   ProgressPos(n);
--   tmp=TextFileReadLn(F);
--   ReadTrans(ИсклАн,tmp);
--  od;
-- Finally
--  CloseProgress;
--  TextFileClose(F);
-- end;


end;
func ОбработатьТекТекстПроводкуДляАн(НФ:i):s;
  var Ан,ss,ss1:s;
  var ii,p:i;
  Ан=ТекстФайлПрочитатьСтроку(НФ);
  p=Pos(':',Ан);
  ii=Pos('--',Ан);
  if (ii<p и ii>0)или p<1:^'';fi;-- строка закомментирована или дата, или пустая...

  p=Pos('{',Ан);
  if p>0: -- нашли аналитику
     ii=Pos('}',Ан);
     Ан=SubStr(Ан,p+1,ii-p-1); -- вырезали аналитику
     p=Pos(':',Ан);
     if p>0:-- есть количественный признак
       ss   =SubStr(Ан,1,p-1);
       ss1  =SubStr(Ан,p+1,255)+' ';
       p=pos(' ',ss1);
       ^ss+' '+SubStr(ss1,p+1,255);-- теперь Ан не содержит количества у колпризнака
      | true:^Ан;
     fi;
   | true:^'';
  fi;
end;
func ОбработатьТекТекстПроводкуДляСчАн(НФ:i):s;
  var Ан,ss,ss1,ss0:s;
  var ii,p:i;
  Ан=ТекстФайлПрочитатьСтроку(НФ);
  p=Pos(':',Ан);
  ii=Pos('--',Ан);
  if (ii<p и ii>0)или p<1:^'';fi;-- строка закомментирована или дата, или пустая...

  p=Pos('{',Ан);
  if p>0: -- нашли аналитику
     ss0=SubStr(Ан,1,p-1);-- записали в ss0 суммы и счета
     ii=Pos('}',Ан);
     Ан=SubStr(Ан,p+1,ii-p-1); -- вырезали аналитику
     p=Pos(':',Ан);
     if p>0:-- есть количественный признак
       ss   =SubStr(Ан,1,p-1);
       ss1  =SubStr(Ан,p+1,255)+' ';
       p=pos(' ',ss1);
       Ан=ss+' '+SubStr(ss1,p+1,255);-- теперь Ан не содержит количества у колпризнака
     fi;
   | true:ss0=Ан;-- записали в ss0 суммы и счета
  fi;
  p=КоличествоСлов(ss0,' ');
  ss=Отрезать(ВыделитьСлово(p-1,ss0,' '));
  if ss='00':ss=Отрезать(ВыделитьСлово(p,ss0,' '));fi;
  ^ss+' '+Ан;
end;
func ОбработатьТекТекстПроводкуДляСч(НФ:i):s;
  var Ан,ss,ss1,ss0:s;
  var ii,p:i;
  Ан=ТекстФайлПрочитатьСтроку(НФ);
  p=Pos(':',Ан);
  ii=Pos('--',Ан);
  if (ii<p и ii>0)или p<1:^'';fi;-- строка закомментирована или дата, или пустая...

  p=Pos('{',Ан);
  if p>0: -- нашли аналитику
     ss0=SubStr(Ан,1,p-1);-- записали в ss0 суммы и счета
   | true:ss0=Ан;-- записали в ss0 суммы и счета
  fi;
  p=КоличествоСлов(ss0,' ');
  ss=Отрезать(ВыделитьСлово(p-1,ss0,' '));-- дебет
  ss0=Отрезать(ВыделитьСлово(p,ss0,' '));   -- кредит
  ^ss+' '+ss0;
end;

proc set_all_auto(auto:l;rep:l;v:l);
     if auto<>v:ЗадатьАвтообработку(v);fi;
     if rep <>v:ЗадатьОбработкуРеп (v);fi;
end;
proc Reset_all_auto(auto:l;rep:l;v:l);
     if auto<>v:ЗадатьАвтообработку(auto);fi;
     if rep <>v:ЗадатьОбработкуРеп (rep );fi;
end;
func СовместныеПризнакиДляСправочника(Услсч:s;УслПризнаков:s;Спр:s;АльтернативныйПункт:s;d1:d;d2:d;обработка:l):s;
  var r:report;
  var Путь,Имяотчета:s;
  var j,k,z,k1,k2:i;
  var auto,rep:l;
  if не обработка:
     auto=автообработка;
     rep =ОбработкаРеп ;
     set_all_auto(auto,rep,false);
  fi;
  ClearVariable(Раб.НФА.B01.st);
  Путь     =PlanVar("НФА")+"\Отчеты\НФАОТЧ.lst";
  Имяотчета="Отчет (бланки, не менять!!!)";k1=0;k2=0;
  r=RepOpen(Путь+"|"+ИмяОтчета,услсч,спр+'.*&('+УслПризнаков+')', d1, d2,'',спр);
  RepReset(r);j=0;while RepNext(r) do j=j+1;st[j]=trim(RepIdent(r));k1=max(k1,length(st[j]));od;r=RepClose(r);
  j=ДлинаМассива(st);
--  if АльтернативныйПункт='' and j=1:^st[1];fi;
  z=1;
  if АльтернативныйПункт<>'':
    if j=0:Reset_all_auto(auto,rep,false);^'#';fi;
    ВставитьВмассив(st,1,АльтернативныйПункт);j=j+1;z=2;k1=max(k1,length(АльтернативныйПункт));
   | true:if j=0:Reset_all_auto(auto,rep,false);^'';fi;
  fi;
  for k=z..j do 
  k2=max(k2,length(Name_A(st[k])));
  st[k]=st[k]+' --'+Name_A(st[k]);
  od;
  k1=max(k1,length('Признак'));
  k2=max(k2,length('Наименование'));

  j=AlternateTree('',st,k1+k2,1,10,'#','Признак','Наименование',k1,false);
  if j<1:Reset_all_auto(auto,rep,false);^'';fi;
  if j=1 and АльтернативныйПункт<>'':Reset_all_auto(auto,rep,false);^'#';fi;
  Reset_all_auto(auto,rep,false);
  ^SubStr(st[j],1,pos(' ',st[j])-1);

end;

func SuperReplace(StrIn:s;StrMatch:s;StrMatchR:s;StrReplace:s):s; --control userpasswords2
  var ss:s;
  var j:i;
  if not Match(StrIn,StrMatch):^StrIn;fi;-- если не слово не прошло проверку, то нечего менять, его и возвращаем без изменений
  -- проверка StrMatchR на коректность (замена @ на .*. ! на ?) @=слово на замену из любого количества символов !=символ на замену
  ss=Раб.СТР.ЗаменаПодстроки(StrMatchR,'@','.*.');
  ss=Раб.СТР.ЗаменаПодстроки(ss,'!','?');
  while pos('..',ss)>1 do ss=Раб.СТР.ЗаменаПодстроки(ss,'..','.'); od;
  while pos('**',ss)>1 do ss=Раб.СТР.ЗаменаПодстроки(ss,'**','*'); od;
  if not Match(StrIn,ss):^StrIn;fi;--некорректное условие на замену - возврат слова без изменений
  ClearVariable(st1);
  j=КоличествоСлов(StrMatchR,'*');


--  ss0='';
--  p1=deb(pos('@',ss));
--  p2=deb(pos('!',ss));        Раб.Нфа.B01.ЗаменаПодстроки(StrMatchR,'@','.*.');
--  if p1<p2 b and
--  ii=min(deb(p1),deb(p2));
--  if deb


end; --format('%.2d',мес(dd1)) Format('%d %d %0:d %1:d', 10, 20); -- возвращаемая строка '10 20 10 20'.
Func ВзятьДЭКСПЛ_КМНТ(КМНТ:s):d;
  var ДЭКСПЛ:d;
  var p:i;
      КМНТ=' '+КМНТ;
      p=pos(' ДЭКСПЛ=',КМНТ);
      if p>0:
       КМНТ=substr(КМНТ,p+8,10);
       ДЭКСПЛ=строкувдату(КМНТ);
      fi;
      ^ДЭКСПЛ;
end;

Func ВзятьДЭКСПЛ(НФА:s;УЧН:s):d; --
  var ДЭКСПЛ:d;
  if УЧН='' or НФА='':^1.1.100;fi;
  ДЭКСПЛ=1.1.100+int(ОСТАТОК('ЗАБ.НФА.ДЭКСПЛ{'+НФА+'&'+УЧН+'}',01.01.2050));
  if год(ДЭКСПЛ)>1850 and год(ДЭКСПЛ)<2099:^ДЭКСПЛ;fi;
 ^1.1.100;
end;

Func ВзятьДУЧЕТ(НФА:s;УЧН:s):d; --
  var ДУЧЕТ:d;
  if УЧН='' or НФА='':^1.1.100;fi;
  ДУЧЕТ=1.1.100+int(ОСТАТОК('ЗАБ.НФА.ДУЧЕТ{'+НФА+'&'+УЧН+'}',01.01.2050));
  if год(ДУЧЕТ)>1850 and год(ДУЧЕТ)<2099:^ДУЧЕТ;fi;
 ^1.1.100;
end;
Func ВзятьНЕТМЕСАМОРТ(НФА:s;УЧН:s):i; --
  if УЧН='' or НФА='':^0;fi;
  ^int(ОСТАТОК('ЗАБ.НФА.НЕТМЕСАМОРТ{'+НФА+'&'+УЧН+'}',01.01.2050));
end;

Func ВзятьМИН_ДУЧЕТ_ДЭКСПЛ(НФА:s;УЧН:s):d; --
 ^Раб.СТР.MinDebDat2(ВзятьДЭКСПЛ(НФА,УЧН),ВзятьДУЧЕТ(НФА,УЧН));
end;
func ПолныхМесяцев(dd1:d;dd2:d):i;-- результат= сколько раз между датами поменялся месяц
  var yy,mm1,mm2:i;
  var d1,d2:d;
  if dd1<dd2:d1=dd1;d2=dd2;
   | true:d2=dd1;d1=dd2;
  fi;
  mm1=год(d1)*12+мес(d1);
  mm2=год(d2)*12+мес(d2);
  ^mm2-mm1;
end;
var addacc[]:s;
var addacc_z[]:l;-- флаг забаланса иначе баланс
Proc addacc_from_array_ini;
  ClearVariable(РАБ.НФА.B01.addacc);
  ClearVariable(РАБ.НФА.B01.addacc_z);
end;
Proc addacc_from_array_add(acc:s;zab:l);
var z:i;
  if length(acc)=0:exit;fi;
  if Name_S(acc)<>' ':exit;fi;
  z=SearchInArray(РАБ.НФА.B01.addacc,acc,true);
  if z<1:
     z=InsertInArraySort(РАБ.НФА.B01.addacc,acc);
     InsertInArray(РАБ.НФА.B01.addacc_z,z,zab);
  fi;
--  z=lengthofarray(РАБ.НФА.B01.addacc)+1;
--  РАБ.НФА.B01.addacc  [z]=acc;
--  РАБ.НФА.B01.addacc_z[z]=zab;
end;
Proc addacc_from_array;
var t,z:i;
  t=ДлинаМассива(addacc);
  if t>0:
    РАБ.КСА.НАЧАТЬ;
    for z=1..t do
      РАБ.КСА.ДобавитьСч(addacc[z],if(addacc_z[z],'ЗАБ','БАЛ'),false);
    od;
    if Раб.КСА.Закончить(True):Message('Счета успешно добавлены');fi;
  fi;
end;
Proc addacc_ALL(foracc:s);
  var t,z,ln:i;
  var fkr0,vd0,acc0,acc_,ss:s;
   acc_='';
   ln=WordsCount(foracc,'.');
--                  123456789012345678901234567890

   if match(ExtractWords(ln-3,3,foracc,'.'),'?.10?.??'):
      fkr0=ExtractWords(1,ln-4,foracc,'.');
      vd0 =ExtractWord(ln-3,foracc,'.');
      acc0=ExtractWords(ln-2,2,foracc,'.');
   fi;
   if acc0<>'':
      if acc0='101.31':acc_='101.31.310|101.31.410|104.31.410|106.31.310|106.31.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.32':acc_='101.32.310|101.32.410|104.32.410|106.31.310|106.31.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.33':acc_='101.33.310|101.33.410|104.33.410|106.31.310|106.31.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.34':acc_='101.34.310|101.34.410|104.34.410|106.31.310|106.31.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.35':acc_='101.35.310|101.35.410|104.35.410|106.31.310|106.31.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.36':acc_='101.36.310|101.36.410|104.36.410|106.31.310|106.31.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.37':acc_='101.37.310|101.37.410|104.37.410|106.31.310|106.31.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.38':acc_='101.38.310|101.38.410|104.38.410|106.31.310|106.31.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='102.30':acc_='102.30.320|101.30.420|104.39.420|106.32.320|106.32.420|106.34.340|106.34.440|208.32.560|208.32.660|302.32.730|302.32.830|304.04.320|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';

       | acc0='105.31':acc_='105.31.340|105.31.440|106.31.310|106.31.410|106.34.340|106.34.440|208.34.560|208.34.660|302.34.730|302.34.830|304.04.340|401.20.272|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='105.32':acc_='105.32.340|105.32.440|106.31.310|106.31.410|106.34.340|106.34.440|208.34.560|208.34.660|302.34.730|302.34.830|304.04.340|401.20.272|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='105.33':acc_='105.33.340|105.33.440|106.31.310|106.31.410|106.34.340|106.34.440|208.34.560|208.34.660|302.34.730|302.34.830|304.04.340|401.20.272|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='105.34':acc_='105.34.340|105.34.440|106.31.310|106.31.410|106.34.340|106.34.440|208.34.560|208.34.660|302.34.730|302.34.830|304.04.340|401.20.272|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='105.35':acc_='105.35.340|105.35.440|106.31.310|106.31.410|106.34.340|106.34.440|208.34.560|208.34.660|302.34.730|302.34.830|304.04.340|401.20.272|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='105.36':acc_='105.36.340|105.36.440|106.31.310|106.31.410|106.34.340|106.34.440|208.34.560|208.34.660|302.34.730|302.34.830|304.04.340|401.20.272|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='105.37':acc_='105.37.340|105.37.440|106.31.310|106.31.410|106.34.340|106.34.440|208.34.560|208.34.660|302.34.730|302.34.830|304.04.340|401.20.272|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='105.38':acc_='105.38.340|105.38.440|106.31.310|106.31.410|106.34.340|106.34.440|208.34.560|208.34.660|302.34.730|302.34.830|304.04.340|401.20.272|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';

       | acc0='106.31':acc_='106.31.310|106.31.410|304.04.340|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='106.32':acc_='106.32.320|106.32.420|304.04.340|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='106.34':acc_='106.34.340|106.34.440|304.04.340|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';

       | acc0='101.11':acc_='101.11.310|101.11.410|104.11.410|106.11.310|106.11.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.12':acc_='101.12.310|101.12.410|104.12.410|106.11.310|106.11.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.13':acc_='101.13.310|101.13.410|104.13.410|106.11.310|106.11.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.15':acc_='101.15.310|101.15.410|104.15.410|106.11.310|106.11.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='101.18':acc_='101.18.310|101.18.410|104.18.410|106.11.310|106.11.410|106.34.340|106.34.440|208.31.560|208.31.660|302.31.730|302.31.830|304.04.310|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
       | acc0='103.11':acc_='103.11.330|103.11.430|106.13.330|106.13.430|304.04.330|401.20.271|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';

       | acc0='106.11':acc_='106.11.310|106.11.410|304.04.340|401.20.273|401.20.241|401.20.242|401.20.251|401.30.000';
      fi;
   fi;
   if acc_<>'': --добавляем счета по фкр

          z=КоличествоСлов(acc_,'|');
          for t=1..z do
            ss=fkr0+'.'+vd0+'.'+ВыделитьСлово(t,acc_,'|');
            if Name_S(ss)=' ':
              addacc_from_array_add(ss,false);
--              addinarray(addacc,true,false,ss);
            fi;
          od;

      if vd0='2' or vd0='4':  -- добавляем счета ?.109.61.271 фкр
            ss=fkr0+'.'+vd0+'.109.60.271';
            if Name_S(ss)=' ':
              addacc_from_array_add(ss,false);
--              addinarray(addacc,true,false,ss);
            fi;
      fi;
   -- добавляем счета КД
      ss=SubStr(fkr0,1,3)+'.1.17.05010.01.0000.'+vd0+'.401.10.180';
      if Name_S(ss)=' ':
         addacc_from_array_add(ss,false);
--        addinarray(addacc,true,false,ss);
      fi;
      ss=SubStr(fkr0,1,3)+'.1.17.05010.01.0000.'+vd0+'.401.10.172';
      if Name_S(ss)=' ':
        addacc_from_array_add(ss,false);
--        addinarray(addacc,true,false,ss);
      fi;
   fi;
end;
Proc AddAccAll_Mask(Mask:s;OnlyWorks:l); -- Добавление недостающих счетов НФА по проверочной маске
 var ac:s;
     addacc_from_array_ini;
     for Account ac=Mask, sort do
       if OnlyWorks: if AccountUsed(ac):addacc_ALL(ac);fi;
        | true: addacc_ALL(ac);
       fi;
     od;
     addacc_from_array;
end;


Func ПризнакИзСтрокиАналитикиПроводки_приоритет(x:Integer; VOC:String; приоритет:s) :String;
-- x - номер проводки
var p,z,t,j,k :Integer;
var sep, ANA ,VOC_cur:String;
 z=length(приоритет);
 j=КоличествоСлов(VOC,'|');
 for k=1..j do
   VOC_cur=ВыделитьСлово(k,VOC,'|');
   for t=1..z do
     sep=trim(SubStr(приоритет,t,1));ANA="";
     p=TransNumSign(x, sep+VOC_cur+".");
     if p>0: ^ExtractWord(1,TransSignName(x, p),приоритет); fi;
--     if p>0: ANA=TransSignName(x, p); ^(SubStr(ANA, length(sep)+1, 255)); fi;
   od;
 od;
 ^'';
end;

Proc ШаблонПриОткрытии(l:l);
ini;
ПроверятьОшибки=РАБ.НФА.B00.ПроверятьОшибки;
--if CloseMe:Close;fi;
end;


Proc ШаблонПриЗакрытии(l:l);
 CloseMe=true;
end;
2--a []:s;
2--ai[]:i=if(a[$]='800000',1,0);
2--c []:i=SumOfArray(ai,$+1);
2--b[]:s=a [$+c[$]];
2----b[]:s=a[$+SumOfArray(ai,$+1)];

Конец
