// Copyright (c) 1993-2005 "Компания БЭСТ". Все права сохраняются.

#include "inkey.ch"
#include "sc_all.ch"
#include "task.ch"
#Include "my.ch"
#IFNDEF __HARBOUR__
#define         KS_F4                     CHR(0)   + CHR(62)
#define  KS_F10        CHR(0)   + CHR(68)
#define         KS_ENTER                  CHR(13)  + CHR(28)
#ELSE
#INCLUDE "ctscan_h.ch"

#ENDIF

#DEFINE R_KEY  UPPER(Sclad+Vid+Type+CodeDoc+NumDoc)
#DEFINE C_KEY  "UPPER(Sclad+Vid+Type+CodeDoc+NumDoc)"
#DEFINE L_SCLAD 6
#DEFINE IS_CLS_RESERV (MSCHET->XRAN = "1" .AND. MemVar->PricePart = 1)
#DEFINE IS_REZERV (lOpen != NIL.OR.(IsRezerv .AND.YesReal.AND.GlobalTask$'03SR'))
#define    S_LIB_ADD    2   // дополнение
#DEFINE TYPE_CLOSE "D"

STATIC lSumMaker := .F.
STATIC l50,l51,l52,l76,l60,lI
STATIC aSaveBase := {}
//--------------------------------------------------------------------------//
                            FUNCTION IsLocateDoc(nModel)
//--------------------------------------------------------------------------//
// Ищет ссылки на модель калькуляции в накладных и заказах
LOCAL aBase := {{"MDOC","MDOC"}}
LOCAL lSeek := .F., aMess
IF GlobalTask $ "0503"
  AADD(aBase,{"RBOOK","RBOOK"})
ENDIF
dbOpenBases(aBase)
SELECT MDOC
ORDSETFOCUS("MDOC")
dbGoTop()
prDBEVAL({|| NIL },,{|| !(lSeek := MDOC->MODEL = nModel) })
IF !lSeek
  IF GlobalTask $ "0503"
    SELECT RBOOK
    ORDSETFOCUS("RBOOK0")
    dbGoTop()
    prDBEVAL({|| NIL },,{|| !(lSeek := RBOOK->MODEL = nModel) })
    IF lSeek
       aMess := {;
              "Модель задействована в заказах ",;
              "и в частности в заказе :",;
              " N "+RBOOK->DOPCODE+" от "+DTOC(RBOOK->DATE);
                 }
    ENDIF
  ENDIF
ElSE
  aMess := {;
    " Модель задействована в документах  склада ",;
    " и в частности в документе :",;
    " склад "+MDOC->SCLAD+" N "+MDOC->NUMDOC+" от "+DTOC(MDOC->DATE);
            }
ENDIF
dbCloseBases(aBase)
RETURN !lSeek .OR. SayError(aMess)
//--------------------------------------------------------------------------//
    PROCEDURE ChangeAddCenaPart(cKey,nOperFact,cType,nCena,cSelShOp,cSelDocM)
//--------------------------------------------------------------------------//
// Накапливает массив несоответствий цен для возможной последующей обработки
// используется текущая запись карточки партии
LOCAL cGrup,cNNum,cPartia
IF iMSCHET->XRAN = "1" .AND. nCena != iSPR_PART->CENA_P
  cGrup := iSPR_PART->GRUP
  cNNum := iSPR_PART->NNUM
  cPartia  := iSPR_PART->CODE
  dbPush(cSelDocM,"MDOCM_S","",{"UPPER(GRUP+NNUM+PARTIA)",UPPER(cGrup+cNNum+cPartia),,.F.,{"MDOCM_S"}},"")
  dbGoTop()
  IF EOF() .OR. UPPER(cKey) == (cSelDocM)->(R_KEY)
    dbPush(cSelShOp,"TAG_TYPEN","",{"TYPE+UPPER(GRUP+NNUM+PARTIA)",cType+UPPER(cGrup+cNNum+cPartia),,.F.,{"TAG_TYPEN"}},"")
    dbGoTop()
    IF EOF() .OR. (cSelShOp)->NNOPER = nOperFact
      AADD(ChangeCenaPart(.T.),{iSPR_PART->(RECNO()),nCena})
    ENDIF
    dbPop()
  ENDIF
  dbPop()
ENDIF
RETURN
//--------------------------------------------------------------------------//
                 FUNCTION ChangeCenaPart(lGet)
//--------------------------------------------------------------------------//
// Возвращает массив несоответствий цен для обработки (lGet - .T.)
// или запускает обработку по массиву несоответствий (lGet - .F. или NIL)
STATIC aChange := {}
LOCAL aMess := {}, nPoz, lChange := .F.
IF EMPTY(lGet) .AND. !EMPTY(aChange)
  AADD(aMess," ПО КАРТОЧКАМ ПАРТИИ, СФОРМИРОВАННЫМ НА ")
  AADD(aMess," ОСНОВАНИИ СЧЕТА-ФАКТУРЫ ОБНАРУЖЕНА ")
  AADD(aMess," РАЗНИЦА МЕЖДУ ЦЕНОЙ ПОСТАВКИ В КАРТОЧКАХ ПАРТИИ ")
  AADD(aMess," И ЦЕНОЙ ПОСТАВКИ В НАКЛАДНОЙ : ")
  AADD(aMess,"")
  AADD(aMess," Группа Ном/номер    Партия   Цена в карточке  Цена в накладной ")
  AEVAL(aChange,{|x| iSPR_PART->(dbGoTo(x[1])),AADD(aMess,iSPR_PART->GRUP+" "+iSPR_PART->NNUM+" "+SPR_PART->CODE+"   "+TRANSFORM(iSPR_PART->CENA_P,SummaPic(3,15))+"  "+TRANSFORM(x[2],SummaPic(3,15))+" ") },1,MIN(8,LEN(aChange)))
  IF LEN(aChange) > 8
    AADD(aMess," И ДРУГИЕ ... ")
  ENDIF
  AADD(aMess,"")
  IF _ROZNICA
     AADD(aMess," ИЗМЕНИТЬ ЦЕНЫ В КАРТОЧКАХ НА ЦЕНЫ ПОСТАВКИ НАКЛАДНОЙ ? ")
     nPoz := NoOrYes(aMess,1,{" Изменить "," Нет "})
     IF nPoz # 0
        nPoz += 2
     ENDIF
  ELSE
     AADD(aMess," ИЗМЕНИТЬ ЦЕНЫ В КАРТОЧКАХ НА ЦЕНЫ ИЗ НАКЛАДНОЙ ? ")
     nPoz := NoOrYes(aMess,1,{" Поставщика и учетную "," Учетную "," Поставщика "," Нет "})
  ENDIF
  IF nPoz > 0 .AND. nPoz != 4
    lChange := .T.
*    AEVAL(aChange,{|x| iSPR_PART->(dbGoTo(x[1])),IF(iSPR_PART->(RecLock()),iSPR_PART->(IF(nPoz = 1 .OR. nPoz = 3,iSPR_PART->CENA_P := x[2],NIL),IF((nPoz = 1 .OR. nPoz = 2) .AND. !EMPTY(iSPR_PART->CENA_F),iSPR_PART->CENA_F := x[2],NIL),dbUnLock()),NIL) })
    AEVAL(aChange,{|x| iSPR_PART->(dbGoTo(x[1])),IF(iSPR_PART->(RecLock()),iSPR_PART->(IF(nPoz = 1 .OR. nPoz = 3,iSPR_PART->CENA_P := x[2],NIL),IF((nPoz = 1 .OR. nPoz = 2) ,iSPR_PART->CENA_F := x[2],NIL),dbUnLock()),NIL) })
  ENDIF
  aChange := {}
ENDIF
RETURN IF(EMPTY(lGet),lChange,aChange)
//--------------------------------------------------------------------------//
                     FUNCTION SetAppPart(nApp)
//--------------------------------------------------------------------------//
// Сохраняет кол-во введенных карточек партий
// Поддерживаются свои счетчики для каждого префикса
STATIC aAppend := {}
LOCAL nAppend := ASCAN(aAppend,{|x| x[1] = GetPrefix() })
 IF nAppend = 0
   AADD(aAppend,{GetPrefix(),0})
   nAppend := LEN(aAppend)
 ENDIF
 IF AddPart()
   IF nApp = NIL
     aAppend[nAppend,2] := 0
   ELSE
     aAppend[nAppend,2] += nApp
   ENDIF
 ELSE
   aAppend[nAppend,2] := 0
 ENDIF
RETURN aAppend[nAppend,2]
//--------------------------------------------------------------------------//
                     FUNCTION GetSetPart(nIdVar)
//--------------------------------------------------------------------------//
// Сохраняет значения для каждого префикса по nIdVar
STATIC aData := {}
LOCAL nAppend := ASCAN(aData,{|x| x[1] = GetPrefix() .AND. x[2] = nIdVar })
IF nAppend = 0
  AADD(aData,{GetPrefix(),nIdVar,NIL})
  nAppend := LEN(aData)
ENDIF
RETURN aData[nAppend]
//--------------------------------------------------------------------------//
                     FUNCTION AddPart(lAdd)
//--------------------------------------------------------------------------//
// Сохраняет флаг работы с сеансом ввода для карточек партий
// Поддерживаются свои флаги для каждого префикса
STATIC aStAdd := {}
LOCAL lOldStatus, nAppend := ASCAN(aStAdd,{|x| x[1] = GetPrefix() })
LOCAL bakPrefix := GetPrefix()
IF nAppend = 0
  AADD(aStAdd,{GetPrefix(),.F.})
  nAppend := LEN(aStAdd)
ENDIF
lOldStatus := aStAdd[nAppend,2]
IF lAdd != NIL
  IF ValType(lAdd) != "A"
    aStAdd[nAppend,2] := lAdd
    SetAppPart()
  ELSE
    aStAdd := lAdd
    AEVAL(aStAdd,{|x| SetPrefix(x[1]),SetAppPart() })
  ENDIF
ENDIF
SetPrefix(bakPrefix)
RETURN lOldStatus
//--------------------------------------------------------------------------//
                           FUNCTION SumMaker(cAlias,cKey,cVar)
//--------------------------------------------------------------------------//
// Функция накапливающая результат выражения cVar
LOCAL cSelAlias := ALIAS()
PRIVATE nSum := 0
IF(cAlias = NIL,cAlias := ALIAS(),NIL)
SELECT (cAlias)
lSumMaker := .T.
dbPush(,,,{ORDKEY(),&cKey,,.F.,{ORDNAME()}})
DBEVAL(&("{|| nSum := nSum + "+cVar+" }"))
dbPop()
lSumMaker := .F.
SELECT (cSelAlias)
RETURN nSum
//--------------------------------------------------------------------------//
                           FUNCTION HeadMaker(cAlias,cKey,cName)
//--------------------------------------------------------------------------//
// Вычисляет заголовок
LOCAL nRec, cSelAlias := ALIAS(), cHead := "", xKey
IF(cAlias = NIL,cAlias := ALIAS(),NIL)
SELECT (cAlias)
xKey := &cKey
nRec := RECNO()
dbSkip(-1)
IF BOF() .OR. xKey != &cKey
  cHead := cName
ENDIF
dbGoTo(nRec)
SELECT (cSelAlias)
RETURN cHead
//--------------------------------------------------------------------------//
                           FUNCTION OnlyMaker(cKey)
//--------------------------------------------------------------------------//
// Возвращает .T. если запись первая по текущему ключу cKey
LOCAL nRec := RECNO()
                /// !! так нельзя &(SH_OP->(IF(cKey =NIL,ORDKEY(),cKey)))
LOCAL lOnly, xKey := &(IF(cKey =NIL,ORDKEY(),cKey))
LOCAL cFilter := dbFilter()
dbClearFilter()
dbSeek(xKey)
lOnly := nRec = RECNO()
IF !EMPTY(cFilter)
  dbSetFilter(&("{||"+cFilter+"}"),cFilter)
ENDIF
dbGoTo(nRec)
RETURN lOnly .OR. lSumMaker
//--------------------------------------------------------------------------//
                           FUNCTION SortMaker(cAlias,cKey,cFilter)
//--------------------------------------------------------------------------//
// Кстановка фильтра и сортировки при печати списка
STATIC xNameCdx, nKolRec
LOCAL nRec, cSelAlias := ALIAS()
IF(cAlias = NIL,cAlias := ALIAS(),NIL)
IF cKey != NIL .AND. MemVar->N = 1
  SELECT (cAlias)
  xNameCdx := NIL
  nKolRec := 0
  IF cKey != NIL
    CreateFilter(".T.",,cKey,"TAG_MAKER",@xNameCdx)
  ENDIF
    (cAlias)->(ORDSETFOCUS())
  dbSetFilter(&("{||"+cFilter+"}"),cFilter)
  DBEVAL({|| nKolRec++ })
  dbGoTop()
ELSEIF MemVar->N = nKolRec    //  cKey = NIL .AND.
  SELECT (cAlias)
  IF xNameCdx != NIL
    DeleteFilter()
    xNameCdx := NIL
  ENDIF
ENDIF
  //  DeleteFilter()

SELECT (cSelAlias)
RETURN ""
//--------------------------------------------------------------------------//
           PROCEDURE InputToRBook(cAliasKey,cAliasRes)
//--------------------------------------------------------------------------//
// Сбрасывает флаги изменений по строкам заказа и шапке
// не требует актуальной текущей записи в RBOOKM

  dbPush(cAliasRes,"RBOOKM","",{"UPPER(DopCode)",UPPER((cAliasKey)->DopCode),,.F.,{"RBOOKM"}},"")
  dbGoTop()
  xDBEVAL({|| FIELD->INPUT := '1' },,,.T.)
  dbPop()
  IF (cAliasKey)->(RecLock())
    (cAliasKey)->INPUT := '1'
    (cAliasKey)->(dbUnLock())
  ENDIF

RETURN
//--------------------------------------------------------------------------//
                       FUNCTION GetTypeFact(cType)
//--------------------------------------------------------------------------//
// Возвращает односимвольный тип счета-фактуры (cType)
LOCAL aTypeZap :={{"1"," "},{"2","А"},{"3","С"},{"4","Б"},{"5","П"},{"6","П"}},n
RETURN IF((n := ASCAN(aTypeZap,{|x| x[1] = cType })) != 0,aTypeZap[n,2]," ")

//--------------------------------------------------------------------------//
        FUNCTION PereshetOst(IsKolTek,IsRezerv,lOpen,cKey,lNoDisp,nError,aSelect,aError)
//--------------------------------------------------------------------------//
// Пересчет остатков в картотеке
// IsKolTek - пересчет остатков (Boolean)
// IsRezerv - пересчет резерва  (Boolean)
// lOpen    - признак открытия баз
// cKey     - ключ для выборочного пересчета UPPER(SCLAD+GRUP+NNUM)
// lNoDisp  - без прорисовки сообщений
// nError   - кол-во ошибок по ссылке (если не NIL)
// aSelect  - Набор алиасов (Def:= {"MDOCM","RBOOK","RBOOKM"})
// aError   - массив ошибочных позиций структуры (если не NIL)
//            {;
//              склад,группа,номенклатурный номер,партия,;
//              {старое кол-во резерва,новое кол-во резерва},;
//              {старое кол-во ТМЦ на складе, новое кол-во ТМЦ на складе};
//            }
LOCAL aBase :={"MKART","MDOCM","MLABEL","MSCHET","MSTRU","MEMDAT"}, aSet := SaveSet()
LOCAL nProces, nKol1, nKol2, cGrup := "",xKey, nKolRes, oldKolR, nPoz, nKol1WD, nKol2WD
LOCAL lError := aError != NIL .OR. nError != NIL
LOCAL bError := {|lKolTek,nKol| IF(lError,(nPoz := NIL,IF(IF(lKolTek,MKART->KOLTEK,MKART->KOLRES) != nKol,(nError++, IF(aError!=NIL.AND.LEN(aError) < 4000 .AND. (nPoz := ASCAN(aError,{|x| UPPER(x[1]+x[2]+x[3]+x[4]) = UPPER(MKART->SCLAD+MKART->GRUP+MKART->NNUM+MKART->PARTIA) })) = 0,(nPoz := LEN(aError)+1,AADD(aError,{MKART->SCLAD,MKART->GRUP,MKART->NNUM,MKART->PARTIA,{MKART->KOLRES,MKART->KOLRES},{MKART->KOLTEK,MKART->KOLTEK}})),NIL),IF(nPoz != NIL,(IF(lKolTek,aError[nPoz,6] := {MKART->KOLTEK,nKol},aError[nPoz,5] := {MKART->KOLRES,nKol})),NIL)),NIL)),NIL) }
LOCAL aKartSum := {}, nRecStru
LOCAL cOrdSh, cOrdSt, cAlias, nRecNo
LOCAL cMDocM, cRBook, cRBookM
LOCAL bReserv := {||;
     nKolRes:=0,;
     IF(IS_REZERV,;
        (;
         (cRBookM)->(DBSEEK(UPPER(MKart->(Grup+NNum+IF(MemVar->PricePart = 1,"",Partia))))),;
         (cRBookM)->(DBEVAL({|| IF(cKey != NIL,SetKolRes(cMDocM,cRBook),NIL),nKolRes += (cRBookM)->KOL_RES },{|| UPPER((cRBookM)->SCLAD) == UPPER(MKart->Sclad).AND.(cRBook)->(DBSEEK(UPPER((cRBookM)->DopCode))).AND.(cRBook)->Status='1' },{|| UPPER((cRBookM)->(Grup+NNum+Partia))=UPPER(MKart->(Grup+NNum+IF(MemVar->PricePart = 1,"",Partia)))  }));
        ),;
        NIL;
        ),;
     nKolRes;
                 }

// Запись итоговых карточек по складам
LOCAL bKartSum := {|nRec| ;
                      nRec := RECNO(),;
                      IF(IS_CLS_RESERV,NIL,oldKolR:= nKolRes),;  //Так надо
                      AEVAL(aKartSum,{|aKol|;
                            IF(dbSeek(xKey+SPACE(L_PARTIA)+aKol[1]),NIL,(AddRec(),MKART->SCLAD := aKol[1],MKART->GRUP := LEFT(xKey,L_GRUP),MKART->NNUM := SUBSTR(xKey,L_GRUP+1,L_NNUM),dbUnLock())),;
                            MLabel->(DBSEEK(MKart->(UPPER(Grup+NNum)))),;
                            MStru->(DBSEEK(MKart->(UPPER(Sclad+Grup)))),;
                            IF(RecLock(),;
                               (;
                                IF(IsKolTek,;
                                   (;
                                    MKART->Kol0 := aKol[5],;
                                    EVAL(bError,.T.,aKol[5]+aKol[2]-aKol[3]),;
                                    MKART->KolTek := aKol[5]+aKol[2]-aKol[3],;
                                    IF(_ROZNICA,MKART->Kol_WD := aKol[5]+aKol[6]-aKol[7],NIL),;
                                    MKART->Schet := MStru->Schet,;
                                    MKART->Name := MLabel->Name;
                                    ),;
                                   NIL;
                                   ),;
                                IF(IS_REZERV,;
                                    (;
                                     nKolRes := IF(IS_CLS_RESERV,EVAL(bReserv),aKol[4]),;
                                     EVAL(bError,.F.,nKolRes),;
                                     MKART->KolRes := nKolRes;
                                     ),;
                                    NIL;
                                    ),;
                                dbUnLock();
                                ),;
                               NIL;
                               );
                                      }),;
                      aKartSum := {},;
                      dbGoTo(nRec),;
                      IF(IS_CLS_RESERV,NIL,nKolRes:= OldKolR),; //Так надо
                      xKey := UPPER(MKART->GRUP+MKART->NNUM),;
                      MStru->(DBSEEK(UPPER(MKART->SCLAD+MKART->GRUP))),;
                      MLABEL->(DBSEEK(UPPER(MKART->GRUP+MKART->NNUM)));
                    }
// Накопление итогов по складам
LOCAL bAddKart := {|nPoz|;
                 IF(!EMPTY(MKART->PARTIA),;
                    (;
                     IF((nPoz := ASCAN(aKartSum,{|x| x[1] = UPPER(MKART->SCLAD) })) = 0,(AADD(aKartSum,{UPPER(MKART->SCLAD),0,0,0,0,0,0}),nPoz := LEN(aKartSum)),NIL),;
                     aKartSum[nPoz,2] += nKol1,;
                     aKartSum[nPoz,3] += nKol2,;
                     aKartSum[nPoz,4] += nKolRes,;
                     aKartSum[nPoz,5] += MKART->KOL0,;
                     aKartSum[nPoz,6] += nKol1WD,;
                     aKartSum[nPoz,7] += nKol2WD;
                    ),;
                    NIL;
                   );
                   }
LOCAL nRec1,nRec2,nRec3,nRec4, lSeek
LOCAL cStatus
LOCAL bAddGrup := {||;
         IF(cKey = NIL .AND. UPPER(cGrup)!=UPPER(Grup),;
            (;
              cGrup:= MKART->Grup,;
              IF(!EMPTY(MKART->NNum).AND.AddRec(),(MKART->Grup := cGrup,dbUnLock()),NIL),;
              dbSkip(),;
              IF(((UPPER(cGrup)!=UPPER(MKART->Grup) .AND. (dbSkip(-1),.T.)) .OR. EMPTY(MKART->NNUM)).AND.!EOF(),;
                 (;
                  xDBEVAL({|| dbDelete() },,{|| EMPTY(MKART->NNUM).AND.UPPER(MKART->STATUS) = cStatus.AND.UPPER(MKART->GRUP) = UPPER(cGrup) },.T.),;
                  cGrup := MKART->GRUP;
                  ),;
                 NIL;
                );
             ),;
             NIL;
           );
                   }

LOCAL bRunKart :=;
  {||;
  DBEVAL({||;
     IF(!lNoDisp,;
        (;
         Proces_Update(nProces),;
         SetPos(11,41),;
         DispOut(MKART->Grup+' '+MKART->NNum+' '+MKART->Partia,COL_BROWSE);
         ),;
         NIL;
        ),;
     nKolRes:=nKol1:=nKol2:=nKol1WD:=nKol2WD:=0,;
     IF(IsKolTek,;
        (;
         MLabel->(DBSEEK(MKart->(UPPER(Grup+NNum)))),;
         IF((cMDocM)->(DBSEEK(UPPER(MKart->(Sclad+Grup+NNum+Partia)))),NIL,IF(MSCHET->UCHET = "2".AND.(cMDocM)->(ORDSETFOCUS("MDOCM_S"),lSeek := !dbSeek(MKart->(UPPER(Grup+NNum))),ORDSETFOCUS("MDOCM_K"),lSeek).AND. !(GlobalTask$'SRZR').AND.MLABEL->(RecLock()),MLABEL->(MLABEL->CENA := MLABEL->CENA0,dbUnLock()),NIL)),;
         (cMDocM)->(DBEVAL({|| IF(RecLock(),((cMDocM)->SCHET := MSTRU->SCHET,dbUnLock()),NIL),(IF((cMDocM)->Vid='1',nKol1+=(cMDocM)->Kol,nKol2+=(cMDocM)->Kol),IF(_ROZNICA.AND.(cMDocM)->Date<_CURR_WDAY ,IF((cMDocM)->Vid='1',nKol1WD+=(cMDocM)->Kol,nKol2WD+=(cMDocM)->Kol),NIL)) },;
                        NIL,;
                        {|| UPPER(Sclad+Grup+NNum+Partia)==UPPER(MKart->(Sclad+Grup+NNum+Partia)) };
                        );
                 );
        ),;
        NIL;
       ),;
     IF(IS_CLS_RESERV,,EVAL(bReserv)),;
     IF(MSCHET->XRAN = '1',(IF(xKey != UPPER(MKART->Grup+MKART->NNum),EVAL(bKartSum),NIL),EVAL(bAddKart)),NIL),;
     IF(RecLock(),(IF(IsKolTek,(EVAL(bError,.T.,MKART->Kol0+nKol1-nKol2),MKART->KolTek := MKART->Kol0+nKol1-nKol2,MKART->Schet := MStru->Schet,IF(_ROZNICA,(MKART->Kol_WD :=MKART->Kol0+nKol1WD-nKol2WD),NIL),MKART->Name := MLabel->Name),NIL),IF(IS_REZERV,(nKolRes := IF(IS_CLS_RESERV,0,nKolRes),EVAL(bError,.F.,nKolRes),MKART->KolRes := nKolRes),NIL),dbUnLock()),NIL);
         },;
       {|| EVAL(bAddGrup),MStru->(DBSEEK(MKart->(UPPER(Sclad+Grup)))),!EMPTY(MKART->PARTIA) .OR. (EMPTY(MKART->PARTIA) .AND. MSCHET->XRAN != '1') };
        ),;
  EVAL(bKartSum);
              }

PRIVATE dContrData := DATE()
IF(aSelect==NIL, (cMDocM:="MDOCM",cRBook:="RBOOK",cRBookM:="RBOOKM"),;
                 (cMDocM:=aSelect[1],cRBook:=aSelect[2],cRBookM:=aSelect[3]))
lNoDisp := !EMPTY(lNoDisp)
IF(ValType(nError) != "N",nError := 0,NIL)
IF !EMPTY(lOpen)
   cAlias:= ALIAS()
   nRecNo:= RecNo()
ELSE
   dbPush()
ENDIF
BEGIN SEQUENCE
  IF IS_REZERV
    AADD(aBase,{cRbookM,"RBOOKM"})
    AADD(aBase,{cRBook,"RBOOK"})
  ENDIF
  IF lOpen = NIL .OR. !lOpen
    dbOpenBases(aBase)
  ENDIF
  IF IS_REZERV
    (cRBookM)->(DbPush(,'RBookM_G',"",{}))
    SELECT (cRBookM)
    SET RELATION TO
    (cRBook)->(DbPush(,'RBook0',"",{}))
  ENDIF
  cOrdSh:= MSCHET->(ORDSETFOCUS('MSCHET'))
  SELECT MSTRU
  cOrdSt:= ORDSETFOCUS('MStru_G')
  SET RELATION TO UPPER(SCHET) INTO MSCHET
  (cMDocM)->(DbPush(,"MDOCM_K","",IF(cKey==NIL, {}, {"UPPER(SCLAD+GRUP+NNUM)",cKey,,.F.,{"MDOCM_K"}})))
  MKART->(DbPush(,"MKART",IF(cKey==NIL,"","UPPER(SCLAD)='"+UPPER(LEFT(cKey,6))+"'"), IF(cKey==NIL, {}, {"UPPER(GRUP+NNUM)",SUBSTR(cKey,7),,.F.,{"MDOCM_K"}}) ))
  SELECT MKART
  IF !lNoDisp
    nProces := Proces_Ini(LASTREC(),15,,IF(IsKolTek.AND.IS_REZERV,"Перерасчет количества ТМЦ и резерва",IF(IsKolTek,"Перерасчет количества ТМЦ","Перерасчет резерва ТМЦ")))
    FRAME("[ Пересчет остатков ]",10,20,12,67,COL_BROWSE,2,.T.,.T.)
    SetPos(11,22)
    DispOut("По номенклатуре :",COL_BROWSE)
  ENDIF
  EVAL(bRunKart)
  IF !lNoDisp
    Proces_End(nProces)
  ENDIF
  IF EMPTY(cKey)
    SaveVar("dContrData","","ПРИЗНАК ВЫПОЛНЕНИЯ ВОССТАНОВЛЕНИЯ",,,.T.)
  ENDIF
  MKART->(DbPop())
  (cMDocM)->(DbPop())
  MSTRU->(ORDSETFOCUS(cOrdSt))
  MSCHET->(ORDSETFOCUS(cOrdSh))
  IF IS_REZERV
    (cRBook)->(DbPop())
    (cRBookM)->(DbPop())
  ENDIF
  IF lOpen = NIL //.OR. !lOpen
    dbCloseBases(aBase)
  ENDIF
END SEQUENCE
IF !EMPTY(lOpen)
 SELECT (cAlias)
 DbGoTo(nRecNo)
ELSE
dbPop()
ENDIF
RestSet(aSet)
RETURN NIL

//--------------------------------------------------------------------------//
                    FUNCTION IsUhetSclad(cSclad)
//--------------------------------------------------------------------------//
// Возвращет признак наличия на складе только учетных цен
LOCAL lSeek := .T.
dbPush(cSelSchet,"MSCHET","","","")
dbPush(cSelStru,"MSTRU_G","",{"UPPER(SCLAD)",UPPER(cSclad),,.F.,{"MSTRU_G"}},"")
DBEVAL({|| lSeek := .F. },{|| iMSCHET->(dbSeek(UPPER(iMSTRU->SCHET))) .AND. iMSCHET->UCHET != '1' },{|| lSeek })
dbPop()
dbPop()
RETURN lSeek
//--------------------------------------------------------------------------//
                  FUNCTION isSxema(cGrup,cSclad,lNoFact)
//--------------------------------------------------------------------------//
// Возвращает .T., если группа (cGrup) участвут в схеме хранения склада (cSclad)
// если склад указан
// lNoFact -  .T. ,то дополнительно исключается группы с фактическими ценами
LOCAL lSeek := .T.
IF SELECT(cSelStru) != 0
  iMSTRU->(;
   dbPush(,IF(EMPTY(cSclad),"TAG_GRUP","MSTRU_G"),"",IF(EMPTY(cSclad),{"UPPER(GRUP)",UPPER(cGrup),,.F.,{"TAG_GRUP"}},{"UPPER(SCLAD+GRUP)",UPPER(cSclad+cGrup),,.F.,{"MSTRU_G"}})),;
   IF((lSeek:= !EOF()) .AND. !EMPTY(lNoFact),;
     (;
      dbPush(cSelSchet,"MSCHET","",{"UPPER(SCHET)",UPPER(iMSTRU->SCHET),,.F.,{"MSCHET"}}),;
      lSeek := !EOF() .AND. iMSCHET->UCHET = "1",;
      dbPop();
      ),;
     NIL;
     ),;
    dbPop();
   )
ENDIF
RETURN lSeek
//--------------------------------------------------------------------------//
FUNCTION GetAgentCode(cSchet,cCode,lCode,cAnalit,cNAnalit,cPlanSch,lName)
//--------------------------------------------------------------------------//
// Возвращает код(lName-то наименование) контрагента
// по счету (cSchet) и аналитике (cCode) (lCode - .F.)
// или код(lName-то наименование) аналитического счета по счету (cSchet)
// и коду контрагента (сCode - .T.)
// Или пустую строку, если связка не найдена
LOCAL cXCode := ""
IF(cAnalit = NIL,cAnalit := "ANALIT",NIL)
IF(cNAnalit = NIL,cNAnalit := "NANALIT",NIL)
IF(cPlanSch = NIL,cPlanSch := "PLAN",NIL)
(cPlanSch)->(dbSeek(UPPER(cSchet)))
IF "03" $ (cPlanSch)->NEW_SPRAW
  IF !lCode
    (cAnalit)->(;
                dbPush(,"CODE","",{"UPPER(SCHET+CODE)",UPPER(cSchet+cCode),,.F.,{"CODE"}}),;
                IF(!EOF() .AND. (cAnalit)->NNOPER > 0,;
                  (cNAnalit)->(;
                              dbPush(,"KEY","SPRAW_CODE='03'",{"STR(OPER_ANALIT,17,0)",STR((cAnalit)->NNOPER,17,0),,.F.,{"KEY"}}),;
                              IF(!EOF(),;
                                 cXCode := IF(EMPTY(lName), FIELD->CODE, FIELD->NAME),;
                                 NIL),;
                              dbPop();
                              ),;
                  NIL;
                 ),;
                dbPop();
               )
  ELSE
    (cNAnalit)->(;
                dbPush(,"CODE","",{"OPER_SPRAW+UPPER(CODE)","03"+UPPER(cCode),,.F.,{"CODE"}}),;
                DBEVAL({||;
                   (cAnalit)->(;
                               dbPush(,"OPER_ANAL","",{"STR(NNOPER,17,0)+UPPER(SCHET)",STR((cNAnalit)->OPER_ANAL,17,0)+UPPER(cSchet),,.F.,{"OPER_ANAL"}}),;
                               IF(!EOF(),;
                                  cXCode := IF(EMPTY(lName),FIELD->CODE,FIELD->NAME),;
                                  NIL),;
                               dbPop();
                               );
                        },{|| (cNAnalit)->OPER_ANAL > 0 },{|| EMPTY(cXCode) }),;
                dbPop();
                )
  ENDIF
ENDIF
RETURN IF(EMPTY(cXCode),"",cXCode)
******************
FUNCTION GetSRAgentCode(cPartCode,lName)
******************
LOCAL cRes
dbPush('MPartner','MPart')
dbSeek(UPPER(LBL_CODE+cPartCode))
cRes = IF(EMPTY(lName),MPartner->Agent_Code, MPartner->Name)
dbPop()
Return cRes

//--------------------------------------------------------------------------//
              FUNCTION IsDopAnalit(cSchet,cSpraw,cSelPlan)
//--------------------------------------------------------------------------//
// Возвращает признак наличия привязки справочника (cSpraw)
// в качестве дополнительной аналитике на счете (cSchet)
LOCAL lSeek
IF(cSelPlan = NIL,cSelPlan := "PLAN",NIL)
(cSelPlan)->(;
            dbPush(,"CODE","",{"UPPER(SCHET)",UPPER(cSchet),,.F.,{"CODE"}}),;
            lSeek := IF(cSpraw != NIL,cSpraw,"03") $ FIELD->NEW_SPRAW,;
            dbPop();
             )
RETURN lSeek
//--------------------------------------------------------------------------//
                       FUNCTION RetPrCena(cName)
//--------------------------------------------------------------------------//
// Возвращает цены прайса
__PSEEK_CENA
RETURN  __PALIAS->(FieldGet(FieldPos(cName)))

//--------------------------------------------------------------------------//
                    FUNCTION CloseKartP(lMode)
//--------------------------------------------------------------------------//
LOCAL sRet:=SETKEY(K_RETURN,NIL)
LOCAL lYes,cGrup:=Grup,nProces, lYes1, lYes2, cBakCode
LOCAL nOrd:=ORDNUMBER()
LOCAL aScope,nRec,nRecNo:=RECNO()
LOCAL aBase := ;
 {;
   {GetPrefix()+"MSCHET",GetPrefixPath()+"MSCHET"},;
   {GetPrefix()+"MSTRU",GetPrefixPath()+"MSTRU"},;
   {GetPrefix()+"MDOCM",GetPrefixPath()+"MDOCM"},;
   {"MCODOP",GetPrefixPath()+"MCODOP"},;
   {"SSH_OP",LoadPath()+"REAL\SH_OP.DBF"},;
   {"SSH_FACT",LoadPath()+"REAL\SH_FACT.DBF"},;
   {"SH_OP",LoadPath()+"TOVAR\SH_OP.DBF"},;
   {"SH_FACT",LoadPath()+"TOVAR\SH_FACT.DBF"},;
   {"MBPSCHET",LoadPath()+"ZAPAS\MBPSCHET"};
 }, aS45 := {}
LOCAL bSave := {|lError|;
          IF(iSPR_PART->CODE # "HEADS",;
            (lYes := .F.,;
            lYes2 := .F.,;
            lYes1 := IsSeekNom(GetPrefix(),iSPR_PART->GRUP,iSPR_PART->NNUM,iSPR_PART->Code,,'базы не окрывать'),;
            lYes1 .AND. (AEVAL(aS45,{|cSchet| lYes2 := lYes2 .OR. iMDOCM->(dbSeek(UPPER(cSchet+iSPR_PART->GRUP+iSPR_PART->NNUM+iSPR_PART->Code))) }),.T.),;
            !lYes1 .AND. iMKART->(DBSEEK(UPPER(iSPR_PART->(Grup+NNum+Code)))),;
            !lYes1 .AND. iMKART->(DBEVAL({|| lYes := .T. },{|| EMPTY(iMKART->Status) .AND. (!EMPTY(iMKART->PARTIA) .OR. !IsUhetPartia(iMLABEL->GRUP,.T.)) },{|| !lYes .AND. UPPER(iMKART->Grup+iMKART->NNUM+iMKART->Partia) == UPPER(iSPR_PART->Grup+iSPR_PART->NNum+iSPR_PART->Code) }),.T.),;
            IF(!lYes1 .AND. !lYes .AND. !lYes2 .AND. RecLock(),;
               (cBakCode:=iSPR_PART->Grup,iSPR_PART->Status := '1',DBUNLOCK(),iSPR_PART->(dbPush(),ORDSETFOCUS("TAG_SNUM"),IF((dbSeek(' '+UPPER(iSPR_PART->GRUP)+SPACE(13)+"HEADS"),dbSkip(),cBakCode != iSPR_PART->GRUP) .AND. (dbSkip(-1),iSPR_PART->CODE = "HEADS".AND. RecLock()),(dbDelete(),dbUnLock()),NIL),dbPop())),;
               IF(!EMPTY(lError),SayError(IF(lYes,'Карточка партии задействована в картотеке!',IF(lYes2,IF(GlobalTask = "09" .OR. GetPrefix() == "Z",'Карточка партии задействована в журнале учета "МБП в эксплуатации"!',{'Карточка партии задействована в журнале учета','"Товаров отгруженных"!'})," Карточка партии задействована в счетах-фактурах !"))),NIL);
              );
            ),;
          NIL);
                }
IF lMode
   lYes:=YesOrNo('Закрыть и поместить в архив (Esc-отмена):',,;
   '       - карточку партии          ',;
   ' - все незадействованные карточки ')
   IF LASTKEY()!=K_ESC
      dbOpenBases(aBase)
      iMDOCM->(ORDSETFOCUS("MDOCM_AM"))
      MCODOP->(ORDSETFOCUS("MCODOP_C"))
      IF GlobalTask = "03" .OR. GetPrefix() == "S"
        MCODOP->(dbSeek("23"))
        MCODOP->(DBEVAL({|| AADD(aS45,MCODOP->SCHET_A) },,{|| MCODOP->VID+MCODOP->TYPE = "23" }))
      ELSEIF GlobalTask = "09" .OR. GetPrefix() == "Z"
        MBPSCHET->(DBEVAL({|| AADD(aS45,MBPSCHET->SCHET) }))
      ENDIF
      SELECT iSPR_PART
      IF lYes
         SKIP
         IF EOF()
            GO TOP
         ENDIF
         nRec:=RECNO()
         GO nRecNo
         EVAL(bSave,.T.)
      ELSE
         aScope:=SetScope()
         ORDSETFOCUS('Tag_Num') //Переходим в независимый индекс Grup+NNum
         GO TOP
         nProces := Proces_Ini(LASTREC(),,,"Закрытие карточек партий ")
         WHILE !EOF()
            Proces_Update(nProces)
            EVAL(bSave)
            SKIP
         ENDDO
         ORDSETFOCUS(nOrd)
         SetScope(aScope)
         GO TOP
         nRec := RECNO()
         Proces_End()
      ENDIF
      dbCloseBases(aBase)
      iSPR_PART->(dbGoTo(nRec))
   ENDIF
ELSEIF YesOrNo('Открыть карточку партии?')
   SKIP
   IF EOF()
      GO TOP
   ENDIF
   nRec:=RECNO()
   GO nRecNo
   RecLock()
   cBakCode:=iSPR_PART->Grup
   REPLACE Status WITH ' '
   UNLOCK
   SELECT iMLABEL
   RecLock()
   REPLACE Status WITH ' '
   UNLOCK
   SELECT iSPR_PART
   // Добавим заголовочную запись
   dbPush(,"TAG_NUM","","","")
   IF !dbSeek(UPPER(cBakCode)+SPACE(13)+"HEADS") .AND. AddRec()
      FIELD->CODE := "HEADS"
      FIELD->GRUP := cBakCode
      dbUnLock()
   ENDIF
   dbPop()
   GO nRec
ENDIF
SETKEY(K_RETURN,sRet)
RETURN(2)
// Изменение 4.D
//--------------------------------------------------------------------------//
        PROCEDURE AddRez(cInfo,nKol,lPlus)
//--------------------------------------------------------------------------//
// Документирование коррекции резерва
STATIC nKolTek := 0, nIdStation
LOCAL cFile := LoadPath()+"DOC_REZ.DBF"
IF TYPE("lYesDocReserv") = "L" .AND. MemVar->lYesDocReserv
  PushData(ALIAS())
  IF nIdStation = NIL
    nIdStation := RANDOM()
  ENDIF
  IF SELECT("DOC_REZ") = 0
    IF !FILE(cFile)
      dbCreate(cFile,{{"ID_STATION","C",25,0},{"ID_PROCESS","C",5,0},{"SCLAD","C",6,0},{"GRUP","C",5,0},{"NNUM","C",13,0},{"PARTIA","C",5,0},{"KOL","C",19,3},{"INFO","M",10,0},{"K_RECNO","C",17,0},{"RECNO","C",17,0},{"LPLUS","C",5,0},{"KOL_R","C",19,3},{"DATE","C",8,0},{"TIME","C",8,0},{"SECONDS","C",17,0},{"KOLRES","C",19,3}})
    ENDIF
    NetUse("DOC_REZ",cFile)
  ENDIF
  SELECT DOC_REZ
  IF cInfo = NIL
    nKolTek := iMKART->KOLRES
  ELSE
    AddRec()
    DOC_REZ->ID_STATION := IDENT_USER
    DOC_REZ->ID_PROCESS := STR(nIdStation,5,0)
    DOC_REZ->SCLAD      := iMKART->SCLAD
    DOC_REZ->GRUP       := iMKART->GRUP
    DOC_REZ->NNUM       := iMKART->NNUM
    DOC_REZ->PARTIA     := iMKART->PARTIA
    DOC_REZ->KOL        := STR(iMKART->KOLRES-nKolTek,19,3)
    DOC_REZ->KOL_R      := STR(nKol,19,3)
    DOC_REZ->KOLRES     := STR(iMKART->KOLRES,19,3)
    DOC_REZ->TIME       := TIME()
    DOC_REZ->DATE       := DTOC(DATE())
    DOC_REZ->SECONDS    := STR(SECONDS(),7,0)
    DOC_REZ->LPLUS      := IF(lPlus,"плюс","минус")
    DOC_REZ->RECNO      := STR(RECNO(),17,0)
    DOC_REZ->K_RECNO    := STR(iMKART->(RECNO()),17,0)
    DOC_REZ->INFO       := cInfo
    dbUnLock()
  ENDIF
  SELECT (PopData())
ENDIF
RETURN
// Изменение 4.D
//--------------------------------------------------------------------------//
             PROCEDURE KorrReserv(nKol,lPlus,cInfo)
//--------------------------------------------------------------------------//
// Коррекция резерва итоговой карточки
IF !EMPTY(iMKART->PARTIA)
  dbPush(cSelKart,"MKART","",{"UPPER(GRUP+NNUM+PARTIA+SCLAD)",UPPER(iMKART->GRUP+iMKART->NNUM+SPACE(L_PARTIA)+iMKART->SCLAD),NIL,.F.,{"MKART"}},"")
  IF !EOF().AND.RecLock()
   AddRez()
   FIELD->KolRes += IF(lPlus,nKol,-nKol)
   dbUnLock()
   AddRez("Коррекция резерва итоговой карточки | "+IF(EMPTY(cInfo),"",cInfo),nKol,lPlus)
  ENDIF
  dbPop()
ENDIF
RETURN
//--------------------------------------------------------------------------//
          FUNCTION TnPrePart(cAliasP)
//--------------------------------------------------------------------------//
LOCAL nPreRec,cGrNN,nCena
RETURN IF(EMPTY((cAliasP)->CENA_F),;
           (;
             nPreRec:= (cAliasP)->(RecNo()),;
             cGrNN:= UPPER((cAliasP)->Grup+(cAliasP)->NNum),;
             (cAliasP)->(DbSkip(-1)),;
             nCena:= IF(UPPER((cAliasP)->Grup+(cAliasP)->NNum)==cGrNN, (cAliasP)->CENA_F, NIL),;
             (cAliasP)->(DbGoTo(nPreRec)),;
             IF(nCena==NIL, (cAliasP)->CENA_F, nCena);
            ),;
           (cAliasP)->CENA_F;
          )

//--------------------------------------------------------------------------//
          FUNCTION TnPrePartN(cAliasP)
//--------------------------------------------------------------------------//
LOCAL nPreRec,cGrNN,nCena
RETURN IF(EMPTY((cAliasP)->CENA_FN),;
           (;
             nPreRec:= (cAliasP)->(RecNo()),;
             cGrNN:= UPPER((cAliasP)->Grup+(cAliasP)->NNum),;
             (cAliasP)->(DbSkip(-1)),;
             nCena:= IF(UPPER((cAliasP)->Grup+(cAliasP)->NNum)==cGrNN, (cAliasP)->CENA_FN, NIL),;
             (cAliasP)->(DbGoTo(nPreRec)),;
             IF(nCena==NIL, (cAliasP)->CENA_FN, nCena);
            ),;
           (cAliasP)->CENA_FN;
          )

//---------------------------------------------------------------------------
Function DefPict(cVar,nSize,nDec)
//---------------------------------------------------------------------------
// Для задания Picture
LOCAL cCh:= IF(cVar=="N","9","X")
IF(nDec==NIL,nDec:=0,)
RETURN PADR("",nSize-IF(nDec<=0,0,nDec)-1,cCh)+IF(nDec<=0,cCh,"."+PADR("",nDec,cCh))

//---------------------------------------------------------------------------
Function SetCurrWDay(lSet,lReset,lSay)
//---------------------------------------------------------------------------
LOCAL aBase:= {{"ArcMag",LoadPath()+"TZ\ARC\Mag"}}
LOCAL dDate
IF TYPE("dCurrWDay")!="D"
   PUBLIC dCurrWDay
ENDIF
IF EMPTY(lReset)
   IF EMPTY(m->dCurrWDay).OR.!EMPTY(lSet)
      DbOpenBases(aBase)
      ArcMag->(DbGoBottom())
      dDate:= IF(EMPTY(ArcMag->DatEnd), IF(EMPTY(ArcMag->Date), NIL, ArcMag->Date),;
                                        ArcMag->DatEnd+1)
      m->dCurrWDay:= IF(EMPTY(dDate).OR.dDate<iSCL_BEG, iSCL_BEG, dDate)
      DbCloseBases(aBase)
   ENDIF
ELSE
   dCurrWDay:= BLANK(dCurrWDay,.T.)
ENDIF
IF !EMPTY(lSay).AND.iSCL_BEG>dCurrWDay
   SayError({"Начало периода на складе не должно превышать",;
             "даты начала рабочего дня.",;
             "Необходимо предварительно закрыть рабочий день.";
            })
ENDIF
RETURN dCurrWDay
//--------------------------------------------------------------------------//
                     FUNCTION GetSumOpl(xKey)
//--------------------------------------------------------------------------//
// Возвращает сумму по документу подлежащую оплате
LOCAL nSumma
dbPush("MDOC","MDOC","",{C_KEY,xKey,,.F.,{"MDOC"}},"")
dbPush("MDOCM","MDOCM_W","",{C_KEY,xKey,,.F.,{"MDOCM_W"}},"")
IF SUBSTR(xKey,7) = "23"
  nSumma := MDOC->SUMR + IF(MDOC->L_NDS,0,MDOC->SUM_NDS) + IF(MDOC->L_ACZ,0,MDOC->SUM_ACZ) + IF(MDOC->L_CSH,0,MDOC->SUM_CSH)

  DBEVAL({|| nSumma -= MDOCM->KOL2*Div((MDOCM->SUMFACT + IF(MDOC->L_NDS,0,MDOCM->SUM_NDS) + IF(MDOC->L_ACZ,0,MDOCM->SUM_ACZ) + IF(MDOC->L_CSH,0,MDOCM->SUM_CSH)),MDOCM->KOL) })
ELSEIF SUBSTR(xKey,7) = "1"
  nSumma := MDOC->SUMR
ELSE
  nSumma := MDOC->SUMR + IF(MDOC->L_NDS,0,MDOC->SUM_NDS) + IF(MDOC->L_ACZ,0,MDOC->SUM_ACZ) + IF(MDOC->L_CSH,0,MDOC->SUM_CSH)
ENDIF
dbPop()
dbPop()
RETURN ROUND(nSumma,CURR_MAIN)
//--------------------------------------------------------------------------//
                     PROCEDURE SaveSumFact(lModel,lReal)
//--------------------------------------------------------------------------//
// Записывает накопительные сумм
IF GlobalTask = "05" .OR. (lReal != NIL .AND. lReal)
  FIELD->SumOut := m->pSumOutR
  IF lModel = NIL .OR. lModel
   // azat Q_SAVE_FLAG    НЕ ИСПОЛЬЗОВАТЬ БОЛЕЕ
   (MDOC->L_NDS := RetFlagNalog(1,MemVar->pModel),MDOC->L_ACZ := RetFlagNalog(2,MemVar->pModel),MDOC->L_CSH := RetFlagNalog(3,MemVar->pModel))
    AEVAL(MemVar->aSumModel,{|x| EVAL(x[2],.T.) })
  ENDIF
ELSE
  MDOC->Summa   := pSumma
  MDOC->SumOutR := pSumOutR+SUM_TSUM
  MDOC->SumOut  := pSumOut
  MDOC->SumR    := pSumR
  MDOC->SumRN    := pSumRN
  IF (IS_MODEL .AND. (lModel = NIL .OR. lModel)) .OR. pVid+pType = '17'
   IF IS_MODEL .OR. IS_SHFACT .OR. IS_PSHFACT  .OR. pVid+pType = '17'
     SAV_FLAG
   ENDIF
   AEVAL(MemVar->aSumModel,{|x| EVAL(x[2],.T.) })
  ENDIF
ENDIF
RETURN
//--------------------------------------------------------------------------//
                     PROCEDURE DocSumFact()
//--------------------------------------------------------------------------//
// Инициализация накопительных сумм по шапке
IF GlobalTask = "05"
ELSE
  DOC_TSUM
  DOC_FLAG
  pSumFact:=pSumma:=Summa
  pSumR := SumR
  pSumRN := SumRN
  pSumOut:=SumOut
  pSumOutR:=SumOutR-SUM_TSUM
ENDIF
RETURN
//--------------------------------------------------------------------------//
                     PROCEDURE InitSumFact(lModel)
//--------------------------------------------------------------------------//
// Инициализирует накопительные суммы
pSumR := pSumRN := pKol := pSumOutR := pSumma := pSumOut := pSumFact := 0
IF (GlobalTask = "05" .OR. IS_MODEL.OR. pVid+pType = '17') .AND. (lModel = NIL .OR. lModel)
  // Очистка накопленных значений
  AEVAL(MemVar->aSumModel,{|x| x[1] := 0 })
ENDIF
//Обнуление массива НДС {ставка,сумма} для печати == titov DT10080
m->aSummaNDS:={}
RETURN
//--------------------------------------------------------------------------//
                     PROCEDURE InsSumFact(x,lModel,lReal)
//--------------------------------------------------------------------------//
// Накапливает накопительные суммы
LOCAL nSum0,nSumR,nSumRN,nKol,i,nStavkaNDS,nSummaNDS
  IF GlobalTask = "05" .OR. (TYPE('lUdalReal')='L'.AND.m->lUdalReal) .OR. (lReal != NIL .AND. lReal)
    nKol := VAL(SUBSTR(x,Q_KOL,13))
    MemVar->pKol += nKol
    m->pSumOut   += ROUND(nKol*ROUND(VAL(SUBSTR(x,Q_VCENA,15)),VALUTA->ACCURACY),VALUTA->ACCURACY)
    m->pSumOutR  += ROUND(VAL(SUBSTR(x,Q_SUMOUT,15)),CURR_MAIN)
  ELSE
    Spr_Part->(dbSEEK(UPPER(SUBSTR(x,P_GRUP,L_GRUP)+SUBSTR(x,P_NNUM,L_NNUM)+SUBSTR(x,P_PARTIA,L_PARTIA))))
    nKol  := VAL(SUBSTR(x,P_KOL,L_KOL))
    nSum0 := ROUND(GetMatSum0(@x),CURR_MAIN)
    nSumR := ROUND(VAL(SUBSTR(x,P_SUMOUTR,L_SUM)),CURR_MAIN)
    nSumRN := ROUND(VAL(SUBSTR(x,P_SUMN,19)),CURR_MAIN)
    MemVar->pSumma   += ROUND(VAL(SUBSTR(x,P_SUMFACT,L_SUM)),CURR_MAIN)
    MemVar->pSumOut  += ROUND(VAL(SUBSTR(x,P_SUMOUT,L_SUM)),VALUTA->ACCURACY)
    MemVar->pSumOutR += IF(pVid='2'.OR.!Moves->YesSeb,nSum0,nSumR)
    MemVar->pSumFact += nSum0
    MemVar->pSumR    += nSumR
    MemVar->pSumRN   += nSumRN
    MemVar->pKol     += nKol
    IF TYPE("aSummaNDS")=="A"
       //формирование массива НДС {ставка,сумма} для печати == titov DT10080
       nStavkaNDS:=VAL(SUBSTR(x,P_NDS,8))
       IF(i:=ASCAN(m->aSummaNDS,{|a|a[1]==nStavkaNDS}))==0
          AADD(m->aSummaNDS,{nStavkaNDS,0})
          ASORT(m->aSummaNDS,,,{|a,b|a[1]<b[1]})
          i:=ASCAN(m->aSummaNDS,{|a|a[1]==nStavkaNDS})
       ENDIF
       m->aSummaNDS[i,2]+=VAL(SUBSTR(x,P_SUM_NDS,19))
    ENDIF
  ENDIF
  IF (GlobalTask = "05" .OR. IS_MODEL.OR. pVid+pType = '17') .AND. (lModel = NIL .OR. lModel)
    // Накопление
    AEVAL(MemVar->aSumModel,{|a| EVAL(a[4],@x) })
  ENDIF


RETURN
//---------------------------------------------------------------------------
Function GetLProv()
//---------------------------------------------------------------------------
RETURN IF(!_ROZNICA.OR.TYPE("pDate")!="D".OR.m->pDate<_CURR_WDAY.OR.(TYPE('FORM_PROV')='L'.AND.m->Form_Prov ),;
                    Moves->LProv,;
                    .F.)
//--------------------------------------------------------------------------//
Function IsView(dDate)
//--------------------------------------------------------------------------//
local lResult := (_ROZNICA.AND.IF(ValType(dDate)!="D",m->pDate,dDate)<_CURR_WDAY).OR.(TYPE("lSaveSR") = "L".AND.lSaveSR = .T.)
RETURN lResult //Вася
//--------------------------------------------------------------------------//
                      PROCEDURE ShetOstError(nSeconds)
//--------------------------------------------------------------------------//
LOCAL aBase := {{"SEMAFOR",LoadPath()+"INI\SEMAFOR.DBF"},"MDOCM","MDOC","RBOOK","RBOOKM","MKART","MSTRU","MSCHET","MEMDAT","MLABEL"}
LOCAL aSemafor := {}, aFileName := {}, cFileName, nPoz, bakSeconds, bakData
LOCAL nRow := 10, nCol := 20, nStSeconds := SECONDS(), nIncSeconds := 0, cAlias, aNumDoc
LOCAL bAddNumDoc := {|cSclad,cGrup,cNNum,cPartia| IF(ASCAN(aNumDoc,UPPER(cSclad+cGrup+cNNum+cPartia)) = 0,AADD(aNumDoc,UPPER(cSclad+cGrup+cNNum+cPartia)),NIL) }
LOCAL nKolDoc := 0, nKolDocS := 0, nKolDocR := 0, nNumDoc := 0
PushData(SaveSet())
PushData(SaveSetKey())
ScrTitul(1,"ПЕРЕСЧЕТ ТЕКУЩЕГО И ЗАРЕЗЕРВИРОВАННОГО КОЛ-ВА ТМЦ")
BEGIN SEQUENCE
  dbOpenBases(aBase)
  AADD(aFileName,{"MDOC",MDOC->(ALLTRIM(UPPER(Bs_TableName())))})
  AADD(aFileName,{"RBOOK",RBOOK->(ALLTRIM(UPPER(Bs_TableName())))})
  FRAME("[ Коррекция сбоев ]",nRow,nCol,nRow+5,nCol+30,COL_BROWSE,1,.T.,.T.)
  WHILE Inkey() != K_ESC .AND. LastKey() != K_ESC
    aSemafor := {}
    SEMAFOR->(DBEVAL({||;
     AADD(;
      aSemafor,;
      {;
       nPoz,;
       SEMAFOR->RECNO,;
       SEMAFOR->ID_STATION+SEMAFOR->ID_PROCESS;
       });
                      },;
                      {||;
       cFileName := ALLTRIM(UPPER(SEMAFOR->FILE_PATH)),;
       (nPoz := ASCAN(aFileName,{|x| cFileName == x[2] })) != 0;
                       }))
    bakSeconds := SECONDS()
    bakData    := DATE()
    SetPos(nRow+2,nCol+2)
    DispOut("Проверено накладных.: ",COL_BROWS0)
    DispOut(ALLTRIM(STR(nKolDocS,7,0)),COL_BROWSE)
    SetPos(nRow+3,nCol+2)
    DispOut("Проверено заказов...: ",COL_BROWS0)
    DispOut(ALLTRIM(STR(nKolDocR,7,0)),COL_BROWSE)
    SetPos(nRow+4,nCol+2)
    DispOut("Восстановлено ошибок: ",COL_BROWS0)
    DispOut(ALLTRIM(STR(nNumDoc,7,0)),COL_BROWSE)
    WHILE SECONDS()-bakSeconds < nSeconds .AND. bakData = DATE()
      SetPos(nRow+1,nCol+2)
      DispOut("Прошло времени......: ",COL_BROWS0)
      DispOut(ALLTRIM(STR(SECONDS()-nStSeconds,7,0)),COL_BROWSE)
      IF Inkey() = K_ESC .OR. Lastkey() = K_ESC
        BREAK
      ENDIF
    ENDDO
    Busy(.T.,"Проверка наличия сбойных документов")
    IF bakData != DATE()
      bakData := DATE()
      nStSeconds := 0
      nIncSeconds +=  nStSeconds
    ENDIF
    aNumDoc := {}
    SEMAFOR->(DBEVAL({|cAlias|;
        IF(RecLock(),;
           (;
            SEMAFOR->FILE_PATH := "",;
            SEMAFOR->RECNO := 0,;
            SEMAFOR->ID_STATION := "",;
            SEMAFOR->ID_PROCESS := "",;
            dbUnLock();
            ),;
           NIL;
           ),;
        cAlias := aFileName[aSemafor[nPoz,1],1],;
        IF(;
           cAlias = "RBOOK",;
           (;
            RBOOK->(dbGoTo(aSemafor[nPoz,2])),;
            dbPush("RBOOKM","RBOOKM","",{"UPPER(DOPCODE)",UPPER(RBOOK->DOPCODE),,.F.,{"RBOOKM"}}),;
            EVAL(bAddNumDoc,RBOOKM->SCLAD,RBOOKM->GRUP,RBOOKM->NNUM,RBOOKM->PARTIA),;
            nKolDocR++,;
            dbPop();
            ),;
           (;
            MDOC->(dbGoTo(aSemafor[nPoz,2])),;
            dbPush("MDOCM","MDOCM_W","",{C_KEY,MDOC->(R_KEY),,.F.,{"MDOCM_W"}}),;
            EVAL(bAddNumDoc,MDOCM->SCLAD,MDOCM->GRUP,MDOCM->NNUM,MDOCM->PARTIA),;
            nKolDocS++,;
            dbPop();
            );
           );
                      },;
                      {||;
       cFileName := ALLTRIM(UPPER(SEMAFOR->FILE_PATH)),;
       (nPoz := ASCAN(aFileName,{|x| cFileName == x[2] })) != 0 .AND.;
       (nPoz := ASCAN(aSemafor,{|x| nPoz = x[1] .AND. x[2] = SEMAFOR->RECNO .AND. x[3] = SEMAFOR->ID_STATION+SEMAFOR->ID_PROCESS })) != 0;
                       }))
     AEVAL(aNumDoc,{|cKey| PereshetOst(.T.,.T.,.T.,LEFT(cKey,24),.T.,@nNumDoc) })
     Busy(.F.)
  ENDDO
  dbCloseBases(aBase)
END SEQUENCE
RestSetKey(PopData())
RestSet(PopData())
RETURN
//--------------------------------------------------------------------------//
                  STATIC PROCEDURE SetKolRes(cMDocM,cRBook)
//--------------------------------------------------------------------------//
// Восстановление позиций отгрузки
LOCAL nKol1 := 0, nSum1 := 0
SetZakKolSum(.F.,@nKol1,@nSum1,cMDocM,cRBook)
IF RecLock()
  FIELD->KOL1 := nKol1 //Пишем в RBookM
  FIELD->SUM1 := nSum1
  dbUnLock()
ENDIF
RETURN

#IFNDEF TV_TASK
//----------------------------------------------------------------------------//
                         FUNCTION Prosm(lArxiv,lPreGet,cFlag,lEditDate,GetList)
//----------------------------------------------------------------------------//
// Просмотр документа
// Навешивается на WHen первого поля
LOCAL cMess, aSetKey
IF( ValType(lPreGet) = "L",, lPreGet := .F.)
IF lArxiv
 SetLastKey(K_ENTER)
 cMess := CHARODD(SCREENSTR(24,0))
 IF "F10:Сохр." $ cMess .AND. !("ESC:Выход" $ cMess)
   cMess := STRTRAN(cMess,"F10:Сохр.","ESC:Выход")
 ELSEIF "F10:Сохранение" $ cMess  .AND. !("ESC:Выход" $ cMess)
   cMess := STRTRAN(cMess,"F10:Сохранение","ESC:Выход")
 ENDIF
 WHILE LastKey() != K_ESC .AND. LastKey() != K_PGUP .AND. LastKey() != K_PGDN
    IF  lEditDate<>NIL .AND. lEditDate.AND.TYPE("aHeads")=="A"
        @ m->aHeads[SeekPos("TEK_DATA")][1][1],m->aHeads[SeekPos("TEK_DATA")][1][2] GET m->aIn[SeekPos("TEK_DATA")]
        READ
    ENDIF
   IF LastKey() = K_TAB .AND. SetKey(K_TAB) != NIL
     EVAL(SetKey(K_TAB))
   ENDIF
   IF LastKey() = K_F9 .AND. SetKey(K_F9) != NIL
     EVAL(SetKey(K_F9))
   ENDIF
   IF LastKey() = K_ALT_F5 .AND. SetKey(K_ALT_F5) != NIL
     EVAL(SetKey(K_ALT_F5))
   ENDIF
   IF !lPreGet
     IF ReadKill()
       EXIT
     ELSEIF ValType(GetActive()) = "O" .AND. GetActive():hasFocus
       GetActive():KillFocus()
     ENDIF
   ENDIF
   SetCursor(0)
   SAYSCREEN(cMess,24,0)
   aSetKey := SaveSetKey()
   InkeyTrap(0)
   RestSetKey(aSetKey)
   SetCursor(1)
 ENDDO
 IF !lPreGet
   IF ReadKill()
     SetLastKey(K_ESC)
   ENDIF
   ReadKill(.T.)
 ELSE
   KEYBOARD CHR(LastKey())
 ENDIF
ENDIF
RETURN !lArxiv
#ENDIF
//--------------------------------------------------------------------------//
                    PROCEDURE GetAddNewPart(nStatus,lSave)
//--------------------------------------------------------------------------//
// Автоматическое добавление карточек партий
// nStatus
//     1 - вызов для инициации входа в карточку партии из реестра
//     2 - вызов для инициации мгновенного выхода из карточки партии
//         при ее редактировании
//     3 - вызов для инициации выбора добавленной карточки партии
//     4 - вызов при выходе из справочника
// lSave - признак успешного сохранения
STATIC nBegKey, lStSave := .T.
IF IS_AUTO_PART .OR. (TYPE('lFromImpExp')='L'.AND.m->lFromImpExp.AND. TYPE('nPartImpP')='N'.AND.m->nPartImpP=3  )
  IF nStatus = 1 .AND. nBegKey != K_F2
    nBegKey := LastKey()
    lStSave := .T.
    IF nBegKey != K_F2
      _DispBegin()
      KEYSEND(KS_F4)
    ENDIF
  ELSEIF nStatus = 2 .AND. nBegKey != K_F2 .AND. lStSave
    // Только данные не по первой карточке в сеансе ввода
    IF !(SetAppPart(0) = 0 .AND. (inGenPCode = 2 .OR. inGenPName = 2 .OR. inGenPAgent= 4))
    //  KEYBOARD K_PGDN
      KEYSEND(KS_F10)
    ELSE
      _DispEnd()
    ENDIF
  ELSEIF nStatus = 3 .AND. (lStSave := lSave) .AND. nBegKey != K_F2
    IF nBegKey = K_F2
      KEYSEND(KS_ENTER)
    ENDIF
  ELSEIF nStatus = 4
    IF nBegKey != K_F2
      _DispEnd()
    ENDIF
    nBegKey := NIL
  ENDIF
ENDIF
RETURN

//---------------------------------------------------------------------------
FUNCTION IsSetCena(cGrup, cNNum)
//---------------------------------------------------------------------------
//Вернем можно ли менять цену для розницы
LOCAL lRet:= .T., lDoublePart:=.F.
IF _ROZNICA
   IF IsUhetPartia(cGrup)
      iSPR_PART->(DbPush(,"TAG_NUM",,{"UPPER(GRUP+NNUM)",UPPER(cGrup+cNNum)}))
      IF iSPR_PART->(!EOF())
         iSPR_PART->(DbSkip())
         IF iSPR_PART->(EOF())
            iMLABEL->(DbPush(,"MLABEL"))
            iMLABEL->(DbSeek(UPPER(cGrup+cNNum)))
            lRet:= EMPTY(iMLABEL->CENA)
            iMLABEL->(DbPop())
         ELSE
            lDoublePart:=.T.
            lRet:= .F.
         ENDIF
      ENDIF
      iSPR_PART->(DbPop())
   ELSE
      iMLABEL->(DbPush(,"MLABEL"))
      iMLABEL->(DbSeek(UPPER(cGrup+cNNum)))
      lRet:= EMPTY(iMLABEL->CENA)
      iMLABEL->(DbPop())
   ENDIF
ENDIF
RETURN lRet.OR.(!lDoublePart.AND.!(AddInPrice(cGrup,cNNum,NIL,NIL,"Только поиск или цена=0")))

//---------------------------------------------------------------------------
FUNCTION RetNasenka(nCenaP,nCena0,nMax,nAccur)
//---------------------------------------------------------------------------
//Возвращает процент наценки (для партий).
// [nMax]- Максимальная наценка (9999.999)
// [nAccur]- Точность после запятой (3)
LOCAL nNasenka
IF(nAccur==NIL, nAccur:= 3, )
IF(nMax==NIL, nMax:= 9999.999, )
nNasenka:= ROUND(IF(!EMPTY(nCenaP), (100*nCena0/nCenaP)-100, 0),3)
RETURN IF(nNasenka>nMax, nMax, nNasenka)

//---------------------------------------------------------------------------
FUNCTION SetCenaAllPart(cGrup,cNNum,nCena0)
//---------------------------------------------------------------------------
//Определяем новые учетные цены для всех партий номенклатуры
LOCAL lRet, lAll:= .T.
iSPR_PART->(DbPush(,"TAG_NUM",,{"UPPER(GRUP+NNUM)",UPPER(cGrup+cNNum)}))
     iSPR_PART->(DbEval({|| IF(RecLock(),(;
                           FIELD->CENA_F:= nCena0,;
                           FIELD->NASENKA:= RetNasenka(FIELD->Cena_P,nCena0),;
                           DbUnLock()   ),;
                           lAll:= .F.);
                       }))
lRet:= iSPR_PART->(EOF()).AND.lAll
iSPR_PART->(DbPop())
RETURN lRet
//--------------------------------------------------------------------------//
                     FUNCTION ListBlockPrint(a)
//--------------------------------------------------------------------------//
// Возвращает блок кода для печати массива (a)
LOCAL cFile,nTmpFile
LOCAL nMaxLen := 0
RETURN {||;
        lHardKart:=.T.,;
        IF( (cFile:=TEMPFILE(_TMP_DIR),nTmpFile:=FCREATE(cFile))==-1,;
            SayError('Ошибка создания вpеменного файла'),;
            (;
              AEVAL(a,{|x| nMaxLen := MAX(LEN(x),nMaxLen) }),;
              AEVAL(a,{|x| Str2File(PADR(TRIM(x),nMaxLen,CHR(255)),nTmpFile) }),;
              FCLOSE(nTmpFile),;
              View(cFile,LEN(a));
            );
           );
         }
//--------------------------------------------------------------------------//
                      FUNCTION InTextArray(cString,cParam)
//--------------------------------------------------------------------------//
// Возвращает массив описанный в cString
LOCAL cNext, aArray
IF !EMPTY(cString)
  aArray := {}
  cString := BEFORATNUM("}",AFTERATNUM("{",cString,1))
  TokenInit( @cString,",")
  WHILE !TokenEnd()
    cNext := TokenNext(@cString)
    IF TYPE(cNext) != "U"
      AADD(aArray,&cNext)
    ENDIF
  END
ELSE
  aArray := &cParam
ENDIF
RETURN aArray
//--------------------------------------------------------------------------//
                  PROCEDURE SetRealTimeDoc(nSet,lSclad,nOper,aMatWork)
//--------------------------------------------------------------------------//
// Поддержание реальной базы на основе динамических массивов
// для возможности получения реальных данных о товарных остатках
// в Real Time режиме
// nSet - режим
//    1 - начальная инициализция
//    2 - обновление
//    3 - завершение работы (очистка)
//    4 - завершение работы (очистка) по текущим данным записи MKART
//    5 - завершение работы обновление по текущим данным записи RBOOKM и MDOC1
// lSclad - признак работы с накладной иначе с заказом
// nOper  - уникальный номер документа  (Если == NIL то ничего не делаем)
// aMatWork - массив строк документа в стандарте aWork или aMat
STATIC aKol
LOCAL bKey, cOpBase, nPoz, xMat, bKol, cBakFocus, nKol, bAdd, bKol1
IF nOper != NIL .AND. nOper > 0 .AND. SELECT("SD_OP") != 0 .AND. SELECT("RD_OP") != 0

  cOpBase := IF(lSclad,"SD_OP","RD_OP")
  IF nSet = 4
    // очистка по позиции на основании MKART
    (cOpBase)->(;
      cBakFocus := ORDSETFOCUS("TAG_NNOPER"),;
       SetScope(),;    // Вася
       SetScope("IIF(!DELETE,'T','F')","T"),;  // Вася
     IF(;
        dbSeek("T"+STR(nOper,17,0)+UPPER(iMKART->GRUP+iMKART->NNUM+iMKART->PARTIA+iMKART->SCLAD)),;
        xDELETE(),;
        NIL;
         ),;
      ORDSETFOCUS(cBakFocus),;
      SetScope();
                )
  ELSEIF nSet = 5
    // обновление по позиции на основании RBOOKM,MDOC1
    RD_OP->(;
      cBakFocus := ORDSETFOCUS("TAG_NNOPER"),;
       SetScope(),;    // Вася
       SetScope("IIF(!DELETE,'T','F')","T"),;  // Вася
      IF(;
        dbSeek("T"+STR(MDOC1->NNOPER,17,0)+UPPER(RBOOKM->GRUP+RBOOKM->NNUM+RBOOKM->PARTIA+RBOOKM->SCLAD)) .AND. RecLock(),;
        (FIELD->KOL1 := RBOOKM->KOL1+RBOOKM->KOL10,dbUnlock()),;
        NIL;
         ),;
      ORDSETFOCUS(cBakFocus),;
      SetScope();
                )
  ELSE
    bAdd := {|x,lNew|;
       cBakFocus := ORDSETFOCUS("TAG_DELETE"),;
        SetScope(),; // Вася
        SetScope("IIF(DELETE,'T','F')","T"),; // Вася
       dbGoTop(),;
       IF(EOF() .OR. !Bs_RLock(),AddRec(),RecLock()),;
       FIELD->NNOPER_ := nOper,;
       FIELD->KEY := x[1]+IF(lSclad,UPPER(PADR(pDopCode,6)),""),;
       IF(lSclad,FIELD->VID := pVid,NIL),;
       IF(lNew,(FIELD->KOL1 := x[4],FIELD->KOL := x[2],FIELD->KOL_OLD := x[2]),(FIELD->KOL := x[3],FIELD->KOL_OLD := 0,FIELD->KOL1 := x[4])),;
       xRECALL(),;
       dbUnLock(),;
       ORDSETFOCUS(cBakFocus),;
       SetScope();
               }
    IF !EMPTY(aMatWork)
      IF ValType(aMatWork[1]) = "C"
        bKey := IF(lSclad,{|x| UPPER(SUBSTR(x,P_GRUP,L_GRUP+L_NNUM)+SUBSTR(x,P_PARTIA,L_PARTIA)+pSclad+PADR(pDopCode,6)) },{|x| UPPER(SUBSTR(x,Q_GRUP,L_GRUP+L_NNUM)+SUBSTR(x,Q_PARTIA,L_PARTIA)+SUBSTR(x,Q_SCLAD,L_SCLAD)) })
        bKol := IF(lSclad,{|x| VAL(SUBSTR(x,P_KOL,L_KOL)) },{|x| VAL(SUBSTR(x,Q_KOL,L_KOLR)) })
        bKol1 := IF(lSclad,{|| 0 },{|x| VAL(SUBSTR(x,Q_KOL1,L_KOLR))+VAL(SUBSTR(x,Q_KOL10,L_KOLR)) })
      ELSE
        bKey := IF(lSclad,{|x| UPPER(x[1]+PADR(pDopCode,6)) },{|x| UPPER(x[1]) })
        bKol := {|x| x[3] }
        bKol1 := IF(lSclad,{|| 0 },{|x| x[5] })
      ENDIF
    ELSE
      bKey := {|| SPACE(L_GRUP+L_NNUM+L_PARTIA+L_SCLAD+IF(lSclad,6,0)) }
      bKol := {|| 0 }
      bKol1 := {|| 0 }
    ENDIF

    IF nSet = 1
      // начальная инициализация
      aKol := {}
      AEVAL(aMatWork,{|x| nKol := EVAL(bKol,x),xMat := x,IF((nPoz := ASCAN(aKol,{|x| x[1] = EVAL(bKey,@xMat) })) = 0,(AADD(aKol,{EVAL(bKey,@xMat),0,0,EVAL(bKol1,@xMat)}),nPoz := LEN(aKol)),NIL),aKol[nPoz,2] += nKol })
      (cOpBase)->(AEVAL(aKol,{|x| EVAL(bAdd,x,.T.) } ))
    ELSEIF nSet = 2
      // обновление
      // Структура aKol
      // 1 - ключ  GRUP+NNUM+PARTIA+SCLAD+DOPCODE
      // 2 - старое кол-во по ТМЦ после коррекции базы
      // 3 - новое кол-во по ТМЦ до коррекции базы
      AEVAL(aMatWork,{|x| nKol := EVAL(bKol,x),xMat := x,IF((nPoz := ASCAN(aKol,{|x| x[1] = EVAL(bKey,@xMat) })) = 0,(AADD(aKol,{EVAL(bKey,@xMat),0,0,EVAL(bKol1,@xMat)}),nPoz := LEN(aKol)),NIL),aKol[nPoz,3] += nKol })
      (cOpBase)->(;
        OrdSetFocus("TAG_NNOPER"),; // Вася
        SetScope("IIF(!DELETE,'T','F')","T"),; // Вася
        dbGoTop(),; // Вася
     AEVAL(aKol,{|x,n|;
           IF(x[2] != x[3],;
             IF(dbSeek("T"+STR(nOper,17,0)+x[1]),(RecLock(),FIELD->KOL := x[3],dbUnLock()),EVAL(bAdd,x,.F.)),;
             NIL;
             ),;
           x[2] := x[3],;
           x[3] := 0;
                    }),;
          SetScope();
                   )
    ELSEIF nSet = 3
      // очистка
      aKol := NIL
      (cOpBase)->(;
        cBakFocus := ORDSETFOCUS("TAG_NNOPER"),; // Вася
         SetScope(),;
         SetScope("IIF(!DELETE,'T','F')","T"),;
        dbSeek("T"+STR(nOper,17,0)),;
        xDBEVAL({|| xDELETE() },,{|| FIELD->NNOPER_ = nOper },.T.),;
        ORDSETFOCUS(cBakFocus),;
        SetScope();
                  )
    ENDIF
  ENDIF
ENDIF
RETURN
//----------------------------------------------------------------------------//
                  FUNCTION SprTovKol(lKolRes,nOperBook,nOperDoc,cEd,nR,nKolForView )
//----------------------------------------------------------------------------//
// Справка по текущим данным MKART о наличии
// реальных остатков по складу и зарезервированный товар
// nKolForView - показывать форму только если свободное количество < его
LOCAL aSet := {SaveSet(),SaveSetKey()}
LOCAL aDisp := {}, nIndik
LOCAL cFile,nTmpFile, nPoz
LOCAL nRec := iMKART->(RECNO()), lPartia, cKey, aSclad:= {}, aReal := {}
LOCAL aBase := {;
   {"RD_OP",LoadPath()+"REAL\RD_OP"},;
   {"SD_OP",GetPrefixPath()+"SD_OP"},;
   ;//{cSelKart,GetPrefixPath()+"MKART"},;
   {cSelGrup,GetPrefixPath()+"MGRUP"},;
   {cSelLabel,GetPrefixPath()+"MLABEL"},;
   {"_MDOC",GetPrefixPath()+"MDOC"},;
   {"_RBOOK",LoadPath()+"REAL\RBOOK"},;
   {"_RBOOKM",LoadPath()+"REAL\RBOOKM"};
                }
LOCAL aStruct :=;
     {;
   {"VID","C",1,0},;
   {"TYPE","C",1,0},;
   {"CODEDOC","C",3,0},;
   {"NUMDOC","C",6,0},;
   {"SCLAD","C",6,0},;
   {"DOPCODE","C",6,0},;
   {"KOL","N",19,4},;
   {"TERMINAL","C",20,0},;
   {"USER_CODE","C",6,0};
       }
LOCAL aStation := {}
LOCAL nKolRes, nKolTek , nOldKol, nNewKol, nKol, xNameCdx

IF SELECT(cSelKart) = 0
   AADD(aBase,{cSelKart,GetPrefixPath()+"MKART"})
ENDIF
BEGIN SEQUENCE
  dbOpenBases(aBase,,,,.T.)

  IF FILE(_PRO_PATH+'STATION.PRO')
    USE ( _PRO_PATH+'STATION.PRO' ) ALIAS STATION NEW SHARED
    IF !USED()
      BREAK
    ENDIF
    DBEVAL({|| AADD(aStation,{STATION->NNOPER,STATION->NUM_DISK+STATION->NUM_NET}) },,{|| LEN(aStation) <= 4000 })
    dbCloseArea()
  ELSE
    BREAK
  ENDIF

  CreateMetka(,"TKOL",aStruct,"")

  SELECT TKOL

  CreateFilter(,"TKOL","VID+TYPE+UPPER(CODEDOC+NUMDOC+DOPCODE)","DOC",@xNameCdx)
  iMKART->(dbGoTo(nRec))
  lPartia := !EMPTY(iMKART->PARTIA) .AND. !(lKolRes .AND. MemVar->PricePart = 1)
  cKey := UPPER(iMKART->GRUP+iMKART->NNUM+IF(lPartia,iMKART->PARTIA,SPACE(L_PARTIA))+iMKART->SCLAD)
  iMKART->(dbPush(,'MKart','',''))
  iMGRUP->(ORDSETFOCUS("MGRUP"))
  iMLABEL->(ORDSETFOCUS("MLABEL"))
  iMKART->(dbSeek(cKey),RecLock())
  iMGRUP->(dbSeek(UPPER(iMKART->GRUP)))
  iMLABEL->(dbSeek(UPPER(iMKART->GRUP+iMKART->NNUM)))


  nKolRes := iMKART->KolRes
  nKolTek := iMKART->KolTek

  cKey := UPPER(iMKART->GRUP+iMKART->NNUM+IF(lPartia,iMKART->PARTIA+iMKART->SCLAD,""))
  RD_OP->(ORDSETFOCUS("TAG_KEY"))
  RD_OP->(SetScope())
  RD_OP->(SetScope('IIF(!lDelete,"T","F")',"T"))
  _MDOC->(ORDSETFOCUS("TAG_REAL"))
  _RBOOK->(ORDSETFOCUS("TAG_OPER"))
  _RBOOKM->(ORDSETFOCUS("RBOOKM"))
  // Накопление по накладным
  SD_OP->(;
    ORDSETFOCUS("TAG_KEY"),;
    SetScope(),;
    SetScope('IIF(!DELETE,"T","F")',"T"),;
    dbSeek("T"+cKey),;
    DBEVAL({||;
        _MDOC->(dbSeek(SD_OP->NNOPER_)),;
        nKol    := IF(SD_OP->VID = "1",SD_OP->KOL-SD_OP->KOL_OLD,SD_OP->KOL_OLD-SD_OP->KOL),;
        nKolTek += nKol,;
        IF(SD_OP->VID = "2" .AND. lKolRes .AND.;
          _RBOOKM->(dbSeek(UPPER(SUBSTR(SD_OP->KEY,L_GRUP+L_NNUM+L_PARTIA+L_SCLAD+1,6)+iMKART->GRUP+iMKART->NNUM+IF(MemVar->PricePart = 1,SPACE(L_PARTIA),iMKART->PARTIA)+iMKART->SCLAD))),;
          (;
           nOldKol := _RBOOKM->KOL-MIN(_RBOOKM->KOL1+_RBOOKM->KOL10,_RBOOKM->KOL),;
           nNewKol := _RBOOKM->KOL-MIN(_RBOOKM->KOL1-nKol+_RBOOKM->KOL10,_RBOOKM->KOL),;
           nKolRes += nNewKol-nOldKol;
           ),;
          NIL;
          ),;
        TKOL->(;
          AddRec(),;
          TKOL->KOL := SD_OP->KOL,;
          TKOL->VID := SD_OP->VID,;
          TKOL->DOPCODE := SUBSTR(SD_OP->KEY,L_GRUP+L_NNUM+L_PARTIA+L_SCLAD+1,6),;
          TKOL->TYPE := _MDOC->TYPE,;
          TKOL->CODEDOC := _MDOC->CODEDOC,;
          TKOL->NUMDOC := _MDOC->NUMDOC,;
          TKOL->SCLAD := _MDOC->SCLAD,;
          TKOL->TERMINAL := IF((nPoz := ASCAN(aStation,{|x| x[1] = SD_OP->ID_ST })) != 0,aStation[nPoz,2],""),;
          TKOL->USER_CODE := SD_OP->USER_CODE,;
          dbUnLock();
                );
            },;
           {||;
        SUBSTR(SD_OP->KEY,L_GRUP+L_NNUM+L_PARTIA+1,L_SCLAD) = UPPER(iMKART->SCLAD) .AND.;
        SD_OP->NNOPER_ != nOperDoc;
            },;
           {||;
        SD_OP->KEY = cKey;
            };
           );
          )
  IF lKolRes
    // Накопление по заказам
    RD_OP->(;
    ORDSETFOCUS("TAG_KEY"),;
    SetScope(),;
    SetScope('IIF(!DELETE,"T","F")',"T"),;
      cKey := UPPER(iMKART->GRUP+iMKART->NNUM+IF(MemVar->PricePart = 1,"",iMKART->PARTIA+iMKART->SCLAD)),;
      dbSeek("T"+cKey),;
      DBEVAL({||;
          _RBOOK->(dbSeek(RD_OP->NNOPER_)),;
          nOldKol := RD_OP->KOL_OLD-MIN(RD_OP->KOL1,RD_OP->KOL_OLD),;
          nNewKol := RD_OP->KOL-MIN(RD_OP->KOL1,RD_OP->KOL),;
          nKolRes += nNewKol-nOldKol,;
          TKOL->(;
            AddRec(),;
            TKOL->KOL := RD_OP->KOL,;
            TKOL->VID := "3",;
            TKOL->NUMDOC := _RBOOK->DopCode,;
            TKOL->SCLAD := iMKART->SCLAD,;
            TKOL->TERMINAL := IF((nPoz := ASCAN(aStation,{|x| x[1] = RD_OP->ID_ST })) != 0,aStation[nPoz,2],""),;
            TKOL->USER_CODE := RD_OP->USER_CODE,;
            dbUnLock();
                  );
              },;
             {||;
          SUBSTR(RD_OP->KEY,L_GRUP+L_NNUM+L_PARTIA+1,L_SCLAD) = UPPER(iMKART->SCLAD) .AND.;
          RD_OP->NNOPER_ != nOperBook;
              },;
             {||;
          RD_OP->KEY = cKey;
              };
             );
            )
  ENDIF
  iMKART->(dbUnLock())

  IF nKolForView = NIL .OR. nKolForView > nKolTek-(nKolRes-IF(MemVar->RLimit_,iMKART->KolLim,0))
     PrintOthet(lKolRes,nKolTek,nKolRes,cEd,nR)
  ENDIF

  DeleteMetka()
  iMKART->(dbPop())

END SEQUENCE

dbCloseBases(aBase)
RestSet(aSet[1])
RestSetKey(aSet[2])

RETURN NIL
//----------------------------------------------------------------------------//
    STATIC FUNCTION PrintOthet(lKolRes,nKolTek,nKolRes,cEd,nR)
//----------------------------------------------------------------------------//
// Печать справки о реальном кол-ве товара на складе и зарезервировано
LOCAL aGrup := {}, nError := 0, bSort
LOCAL bPreBlock := {|| nError++ }
LOCAL aCols,cFormat,aHeader,aFieldsHead, nLin, nHeads
LOCAL cReport, nDifit, nSvob
LOCAL lNoOnlyEd := UPPER(iMLABEL->ED) != UPPER(cEd)

 Busy(.T.,"Формирование отчета")

 dbPush("TKOL","DOC","KOL != 0")
 GO TOP

 AADD(aGrup,{;
 "VID",;
 {||;
  nError := 0,;
  IF(TKOL->VID = "1",;
    " Накладные (приход) ",;
    IF(TKOL->VID = "2"," Накладные (расход) "," Заказы ");
    );
   },;
 {|aSum,lNoPrint|;
  lNoPrint := .T.,;
  Str2File("│"+REPLICATE("─",LEN(cFormat)-2)+"│"),;
  Str2File("│"+PADR("В работе документов : "+ALLTRIM(STR(nError,10,0)),LEN(cFormat)-2)+"│"),"" },1})


 nDifit := -((nKolTek-IF(m->Norma_[2],MLABEL->NORMA,0))-(nKolRes-IF(MemVar->RLimit_,iMKART->KolLim,0)))
 nSvob  := nKolTek-(nKolRes-IF(MemVar->RLimit_,iMKART->KolLim,0))

 aHeader := {;
   "",;
   "  РАСЧЕТ С УЧЕТОМ РЕДАКТИРУЕМОГО КОЛ-ВА НАХОДЯЩЕГОСЯ В РАБОТЕ",;
   "",;
   " CКЛАД...........: "+iMKART->SCLAD,;
   " ТМЦ.............: "+iMKART->GRUP+" "+iMKART->NNUM+IF(!EMPTY(iMKART->PARTIA)," "+iMKART->PARTIA,""),;
   "                   "+iMLABEL->NAME,;
   "";
             }

 IF(lKolRes,AADD(aHeader," СВОБОДНО........: "+STR(IF(nSvob   > 0,nSvob  ,0),13,iMGRUP->KOL_)+" ("+ALLTRIM(iMLABEL->ED)+")"+IF(lNoOnlyEd,"    "+STR(oREdKol(IF(nSvob   > 0,nSvob  ,0),cEd,nR),13,iMGRUP->KOL1_)+" ("+cEd+")","")),NIL)
            AADD(aHeader," ТЕКУЩИЙ ОСТАТОК.: "+STR(IF(nKolTek > 0,nKolTek,0),13,iMGRUP->KOL_)+" ("+ALLTRIM(iMLABEL->ED)+")"+IF(lNoOnlyEd,"    "+STR(oREdKol(IF(nKolTek > 0,nKolTek,0),cEd,nR),13,iMGRUP->KOL1_)+" ("+cEd+")",""))
 IF(lKolRes,AADD(aHeader," ДЕФИЦИТ.........: "+STR(IF(nDifit  > 0,nDifit ,0),13,iMGRUP->KOL_)+" ("+ALLTRIM(iMLABEL->ED)+")"+IF(lNoOnlyEd,"    "+STR(oREdKol(IF(nDifit  > 0,nDifit ,0),cEd,nR),13,iMGRUP->KOL1_)+" ("+cEd+")","")),NIL)
 IF(lKolRes,AADD(aHeader," РЕЗЕРВ..........: "+STR(IF(nKolRes > 0,nKolRes,0),13,iMGRUP->KOL_)+" ("+ALLTRIM(iMLABEL->ED)+")"+IF(lNoOnlyEd,"    "+STR(oREdKol(IF(nKolRes > 0,nKolRes,0),cEd,nR),13,iMGRUP->KOL1_)+" ("+cEd+")","")),NIL)
 AADD(aHeader,"")
 AADD(aHeader,"                 Документы находящиеся в работе")


 nHeads := 0
 aFieldsHead := {;
            "┌───┬──────┬──────┬",;
            "│Вид│N док.│N зак.│",;
            "├───┼──────┼──────┼";
                }
 cFormat := "│XXX│XXXXXX│XXXXXX│"
 aCols := {;
          'CODEDOC',;
          'IF(VID != "3",IF(EMPTY(NUMDOC),"НОВЫЙ ",NUMDOC),SPACE(6))',;
          'IF(VID != "3",DOPCODE,IF(EMPTY(NUMDOC),"НОВЫЙ ",NUMDOC))';
           }

 aFieldsHead[nHeads+1] += "─────────────┬"
 aFieldsHead[nHeads+2] += PADC("Кол-во("+TRIM(iMLABEL->ED)+")",13)+"│"
 aFieldsHead[nHeads+3] += "─────────────┼"
 cFormat +=  SummaPic(iMGRUP->KOL_,13)+"│"
 AADD(aCols,'KOL')

 IF lNoOnlyEd
   aFieldsHead[nHeads+1] += "─────────────┬"
   aFieldsHead[nHeads+2] += PADC("Кол-во("+TRIM(cEd)+")",13)+"│"
   aFieldsHead[nHeads+3] += "─────────────┼"
   cFormat += SummaPic(iMGRUP->KOL1_,13)+"│"
   AADD(aCols,'oREdKol(KOL,['+cEd+'],'+STR(nR,19,7)+')')
 ENDIF

 aFieldsHead[nHeads+1] += "────────────────────┬────────────┐"
 aFieldsHead[nHeads+2] += "      Станция       │Пользователь│"
 aFieldsHead[nHeads+3] += "────────────────────┼────────────┤"
 cFormat               += "XXXXXXXXXXXXXXXXXXXX│XXXXXXXXXXXX│"
 AADD(aCols,"TERMINAL")
 AADD(aCols,"PADC(USER_CODE,12)")

 cReport := TEMPFILE( _TMP_DIR, "TXT")
 nLin := TotRep(aHeader, aCols, aFieldsHead, cFormat,,aGrup,, ;
             cReport, , .T.,.F.,,,,,,bPreBlock,,,bSort  )
 Busy(.F.)
 View(cReport,nLin)
 dbPop()

RETURN NIL

//---------------------------------------------------------------------------
FUNCTION GetLastPartC(cGRUP,cNNUM)
//-Последняя непустая цена партии--------------------------------------------
LOCAL nRetCen
Spr_Part->(DbPush(,"TAG_NUM",,{"UPPER(Grup+NNum)",UPPER(cGRUP+cNNUM)}))
Spr_Part->(DbGoBottom())
PushData(Spr_Part->(RecNo()))
IF Spr_Part->(!EOF())
   DO WHILE Spr_Part->(!BOF()).AND.EMPTY(Spr_Part->Cena_f)
      Spr_Part->(DbSkip(-1))
   ENDDO
ENDIF
IF(Spr_Part->(BOF()), Spr_Part->(DbGoTo(PopData("View"))), NIL)
PopData()
Spr_Part->(DbPop("NoGoRec"))
nRetCen:= Spr_Part->Cena_f
IF EMPTY(nRetCen)
   PushData(MLABEL->(RECNO()))
   IF UPPER(MLABEL->GRUP+MLABEL->NNUM)!=UPPER(cGRUP+cNNUM)
     PushData(MLABEL->(ORDNAME()))
     PushData(MLABEL->(SetScope({})))
     MLABEL->(ORDSETFOCUS("MLABEL"))
     MLABEL->(DBSEEK(UPPER(cGRUP+cNNUM)))
     nRetCen:= MLABEL->CENA
     MLABEL->(SetScope(PopData()))
     MLABEL->(ORDSETFOCUS(PopData()))
   ELSE
     nRetCen:= MLABEL->CENA
   ENDIF
   MLABEL->(DbGoTo(PopData()))
ENDIF
RETURN nRetCen

//--------------------------------------------------------------------------//
               FUNCTION FinGet(cAlias,cName,lShOp)
//--------------------------------------------------------------------------//
// Возвращает значение поля
//Переменная lNoShOp должна быть определена как PRIVATE = .T., если не нужно брать из SH_OP
LOCAL cRet
IF lShOp = NIL .AND. SELECT("SH_OP") != 0 .AND. SH_OP->TYPE $ "45" .AND. SH_OP->(FieldPos(cName)) != 0 .AND. !(TYPE('lNoShOp')='L'.AND.m->lNoShOp)
 RETURN SH_OP->(FieldGet(FieldPos(cName)))
ENDIF
RETURN IF((cAlias)->(FieldPos(cName)) != 0,(cAlias)->(FieldGet(FieldPos(cName))),IF((cAlias)->(TYPE(cName))= "U","",(cAlias)->(&cName)))

//---------------------------------------------------------------------------
FUNCTION FullSclSekc(aSclSekc,aShops,lSclad)
//---------------------------------------------------------------------------
// Заполняем массив складами секциями привязанными к магазину
// aSclSekc передается по ссылке (в случые ошибки вернет aSclSekc=={})
// [aShops] - тоже по ссылке если необходимо
// [lSclad] - Чтобы не ругаться на склады
LOCAL aDBases:= {{"Mag_Sek" , LoadPath()+"TZ\Mag_Sek.dbf"},;
                 {"Mag" ,     LoadPath()+"TZ\Mag.dbf"}}
IF(aShops==NIL, aShops:={}, ASIZE(aShops,0))
IF(aSclSekc==NIL, aSclSekc:={}, ASIZE(aSclSekc,0))
PushData(ALIAS())
DbOpenBases(aDBases)
BEGIN SEQUENCE
  DbSelectArea("Mag")
  DbGoTop()
  DBEVAL({|| AADD(aShops,{Code,Name,NNoper}) })
  IF LEN(aShops)!=1
     SayError(IF(LEN(aShops)==0,"Справочник магазинов пуст !","Необходимо настроить только один магазин !"))
     BREAK
  ENDIF
  SELECT Mag_Sek
  OrdSetFocus("Oper_Mag")
  SetScope("STR(OPER_MAG,17,0)",STR(aShops[1,3],17,0))
  DbGoTop() // Все склады/секции должны быть привязаны к этому магазину (и должны быть)
  DbEval({|| AADD(aSclSekc, UPPER(FIELD->Oper_Sek))})
  ASORT(aSclSekc,,, {|a1,a2| a1<a2})
  IF LEN(aSclSekc)==0.AND.lSclad==NIL
     SayError("Нет ни одного склада/секции привязанного к магазину.")
  ENDIF
END SEQUENCE
DbCloseBases(aDBases)
DbSelectArea(PopData())
RETURN NIL

//---------------------------------------------------------------------------
FUNCTION GetActOfDate(dDat1,dDat2,aDoc)
//-Вернем акты по складам----------------------------------------------------
LOCAL aSclSekc:= {}, aBase:= {{"MPere", LoadPath()+"SCLAD\MPere.dbf"}}
PushData(ALIAS())
FullSclSekc(aSclSekc)
IF LEN(aSclSekc)>0
   DbOpenBases(aBase)
   SELECT MPere
   ORDSETFOCUS("MPERE")
   SetScope("DTOS(Date)",DTOS(dDat1),DTOS(dDat2))
   DbGoTop()
   DbEval({|| AEVAL(aSclSekc,;
                    {|x| AADD(aDoc, UPPER(x+MPere->Status+"$"+SPACE(3)+MPere->Num))});
          })
   DbCloseBases(aBase)
ENDIF
DbSelectArea(PopData())
RETURN NIL

//--------------------------------------------------------------------------
FUNCTION AlqQSave(aFields,aVars,cAlias,lNoLock)
//--------------------------------------------------------------------------
// Типа QSave() по списку полей aFields в [cAlias]
// [aVars] - значения для записи, (==NIL то берем из aIn[SeekPos(aFields[i])])
// [lNoLock] - не блокировать (уже заблокирована)
LOCAL aaFields:= IF(ValType(aFields)=="A",aFields,{aFields})
LOCAL aaVars:= {}
IF(EMPTY(cAlias), cAlias:= ALIAS(), NIL)
IF(EMPTY(lNoLock), (cAlias)->(RecLock()), NIL)
IF aVars==NIL
   AEVAL(aaFields, {|x| AADD(aaVars,m->aIn[SeekPos(UPPER(x))])})
ELSE
   aaVars:= IF(ValType(aVars)=="A", aVars, {aVars})
ENDIF
AEVAL(aaFields, {|x,i| (cAlias)->(FieldPut(FieldPos(x),aaVars[i]))})
IF(EMPTY(lNoLock), (cAlias)->(DbUnLock()), NIL)
RETURN (.T.)

//---------------------------------------------------------------------------
FUNCTION FullScladsHelp()
//---------------------------------------------------------------------------
IF TYPE("N_HELP_1")!="C"
   PUBLIC N_HELP_1:="3.9"/*справочник партий*/,;
          N_HELP_2:="3.10"/*редактирование карточки партии*/,;
          N_HELP_3:="7.6"/*работа с удаленными складами*/,;
          N_HELP_4:="7.7"/*модели калькуляции отпускной цены*/,;
          N_HELP_5:="7.8"/*технич.настройка термопринтера*/,;
          N_HELP_6:="7.9"/* настройка шаблонов термопринтера*/,;
          N_HELP_7:="7.10"/*справочник атрибутов*/,;
          N_HELP_8:="7.11"/*иерархические справочники*/,;
          N_HELP_9:="7.12"/* справочник партнеров*/,;
          N_HELP_10:="7.13"/*настройка шаблонов счетов фактур*/,;
          N_HELP_11:="7.14"/*справочник групп услуг*/,;
          N_HELP_12:="7.15"/*номенклатура услуг*/,;
          N_HELP_13:="9.1"/*ресстр счетов-фактур*/,;
          N_HELP_14:="9.2"/*редактирование счета-фактуры*/,;
          N_HELP_15:=  "9.5"     /* работа со списком счета-фактуры*/,;
          N_HELP_16:=  "9.4"     /* работа со списком перепривязки */,;
          N_HELP_17:=  "8.1"     /* книга покупок/продаж           */,;
          N_HELP_18:=  "8.2"     /* редактирование записи книги покупок/продаж*/,;
          N_HELP_19:=  "8.4"     /* контроль книги покупок/продаж             */,;
          N_HELP_20:=  "9.8"     /* восстановление данных АРМ "Управление продажами/закупками"*/,;
          N_HELP_21:=  "8.6"     /* настройка печати реестра карточек партий*/,;
          N_HELP_22:=  "8.7"     /* настройка печати карточки партии        */,;
          N_HELP_23:=  "9.3"     /* редактирование счета-фактуры            */,;
          N_HELP_24:=  "1.2.1"   /* редактирование акта оприходования услуг */,;
          N_HELP_25:=  "7.16"    /* закрытая номенклатура услуг             */,;
          N_HELP_26:=  "7.17"    /* Настройка шаблонов счетов фактур для печати из накладной*/,;
          N_HELP_27:=  "9.6"     /* Контроль книги продаж*/,;
          N_HELP_28:=  "9.7"     /* редактирования строки счета фактуры*/,;
          N_HELP_29:=  "16.1"    /* строки акта оприходования          */,;
          N_HELP_30:=  "16.2"    /* редактирование строки акта оприходования*/,;
          N_HELP_31:=  "16.3"    /* редактирование проводок*/,;
          N_HELP_32:=  "5.1"     /* архивные счета кредиторов*/,;
          N_HELP_33:=  "21.1"    /* справочник реквизитов    */,;
          N_HELP_34:=  "5.8"     /* архив ведомостей переоценки*/,;
          N_HELP_35:=  "12.1"     /* реестр дополнительных прай-листов*/,;
          N_HELP_36:=  "12.2"     /* просмотр дополнительных прайс-листов*/,;
          N_HELP_37:=  "12.3"     /* редактирование заголовочной части прайс-листа*/,;
          N_HELP_38:=  "16.4"     /* добавление строк акта оприходования          */,;
          N_HELP_39:=  "7.5.3"    /* архив ведомостей списания                    */,;
          N_HELP_40:=  "7.5.4"    /* архив ведомостей переоценки                  */,;
          N_HELP_41:=  "18.1"     /* оприходование с наценкой                     */,;
          N_HELP_42:=  "5.1.1"    /* закрытые счета кредиторов                    */;
/* Описание кодов разделов HELP для работы с архивом                             */,;
          N_HELP_13A:=  "9.1.1"     /*ресстр счетов-фактур  (Архив) */,;
          N_HELP_15A:=  "9.5.1"     /* работа со списком счета-фактуры (Архив) */,;
          N_HELP_14A:=  "9.2.1"     /*редактирование счета-фактуры (Архив) */,;
          N_HELP_23A:=  "9.3.1"     /* редактирование счета-фактуры (Архив)   */,;
          N_HELP_28A:=  "9.7.1"     /* редактирования строки счета фактуры (Архив) */,;
          N_HELP_17A:=  "8.1.1"     /* книга покупок/продаж  (Архив)         */,;
          N_HELP_18A:=  "8.2.1"     /* редактирование записи книги покупок/продаж  (Архив) */,;
          N_HELP_19A:=  "8.4.1"     /* контроль книги покупок/продаж   (Архив)          */,;
          N_HELP_24A:=  "1.2.5"   /* редактирование акта оприходования услуг (Архив) */,;
          N_HELP_60A:=  "60.1.1"    /* Очистка архива      (Архив)    */,;
          N_HELP_29A:=  "16.1.1"    /* строки акта оприходования      (Архив)    */,;
          N_HELP_30A:=  "16.2.1"    /* редактирование строки акта оприходования  (Архив) */;
/* Описание кодов разделов HELP в АРМе "Торговый Зал"                             */,;
          TZ_H_0:=    "0"      /* Общие сведения (на главном меню модуля)*/,;
          TZ_H_1:=    "1"      /* Учет pозничных пpодаж (в pеестpах тов.отчетов)*/,;
          TZ_H_11:=   "1.1"    /* Ввод/pедактиpование док-тов (заголовок тов.отчета)*/,;
          TZ_H_12:=   "1.2"    /* Ввод стpок ТМЦ (2-ое окно док-та)                 */,;
          TZ_H_13:=   "1.3"    /* Ввод ТМЦ по пpайс-листу (внутpи пpайса)           */,;
          TZ_H_14:=   "1.4"    /* Pабота с пpоводками (в окне пpоводок)             */,;
          TZ_H_2 :=   "2"      /* Снятие остатков (pеестp док-тов)                  */,;
          TZ_H_21:=   "2.1"    /* Ввод/pедактиpование док-тов (заголовок док-та)    */,;
          TZ_H_22:=   "2.2"    /* Ввод стpок ТМЦ (2-ое окно док-та)                 */,;
          TZ_H_23:=   "2.3"    /* Ввод ТМЦ по пpайс-листу (внутpи пpайса)           */,;
          TZ_H_3 :=   "3"      /* Пpосмотp док-тов склада (без мемо-поля)           */,;
          TZ_H_31:=   "3.1"    /* Пpосмотp док-тов (pеестp док-тов,содежимое док-та)*/,;
          TZ_H_32:=   "3.2"    /* Пpосмотp каpтотеки (внутpи каpтотеки)             */,;
          TZ_H_4 :=   IF(!_ROZNICA,"4","4.3")  /* Ведение пpайс-листов (пpи откpытии подменю)*/,;
          TZ_H_41:=   IF(!_ROZNICA,"4.1","4.3")/* Ведение текущего пpайса (в пpайс-листе)    */,;
          TZ_H_42:=   IF(!_ROZNICA,"4.2","4.5")/* Аpхив пpайс-листов (в аpхиве)              */,;
          TZ_H_43:=   "4.3"    /* Ведение текущего пpейскуранта (в нем (розница))            */,;
          TZ_H_44:=   "4.4"    /* Протокол требований переоценки (розница)                   */,;
          TZ_H_45:=   "4.5"    /* Аpхив пpейскурантов (в аpхиве (розница))                   */,;
          TZ_H_5 :=   "5"      /* Экспоpт-импоpт (пpи откpытии подменю)                      */,;
          TZ_H_51:=   "5.1"    /* Обработка дневных пpодаж (Внутpи pеестpа)                  */,;
          TZ_H_52:=   "5.2"    /* Фоpмиpование спpавочника товаpов (cпpавочник)              */,;
          TZ_H_521:=  "5.3"    /* Электронные весы (cпpавочник)                              */,;
          TZ_H_6  :=  "6"      /* Фоpмиpование отчетов (в подменю и пpи выводе каpточки запpоса)*/,;
          TZ_H_7  :=  "7"      /* Настpойка, спpавочники (в подменю)                            */,;
          TZ_H_71 :=  "7.1"    /* Спpавочник типовых опеpаций (внутpи спpавочника)              */,;
          TZ_H_72 :=  "7.2"    /* Спpавочник секций                                             */,;
          TZ_H_73 :=  "7.3"    /* Спpавочник магазинов                                          */,;
          TZ_H_74 :=  "7.4"    /* Настpойка теpмопpинтеpа (в подменю)                           */,;
          TZ_H_741:=  "7.4.1"  /* Техн.настpойка                                                */,;
          TZ_H_742:=  "7.4.2"  /* Настpойка шаблонов                                            */,;
          TZ_H_75 :=  "7.5"    /* Настpойка pаботы с кассами (в подменю)                        */,;
          TZ_H_751:=  "7.5.1"  /* Настpойка на касс.аппаpаты (внутpи настpойки)                 */,;
          TZ_H_752:=  "7.5.2"  /* Типы касс.аппаpатов                                           */,;
          TZ_H_753:=  "7.5.3"  /* Виды касс.опеpаций                                            */,;
          TZ_H_754:=  "7.5.4"  /* Спpавочник типов кодов товаpов                                */,;
          TZ_H_76 :=  "7.6"    /* Настpойка видов движения (настpойка видов,настpойка фоpмы ввода)*/,;
          TZ_H_77 :=  "7.7"    /* Спpавочник комплектов                                           */,;
          TZ_H_78 :=  "7.8"    /* Настpойка паpаметpов подсистемы                                 */,;
          TZ_H_79 :=  "7.9"    /* Настpойка паpолей доступа                                       */,;
          TZ_H_7101:= "7.10.1" /* Настpойка на электронные весы                                   */,;
          TZ_H_7102:= "7.10.2" /* Типы электронных весов                                          */,;
          TZ_H_8   := "8"      /* Работа с аpхивом (пpосмотp аpхива тов.отчетов,содеpжимое док-та)*/
ENDIF
RETURN (NIL)


                  PROCEDURE AddOperPrint(aFi)
//--------------------------------------------------------------------------//
// Добавляет типовые значения в привязку печатной формы
IF ValType(aFi) = "A"
  AADD(aFi,NIL)
  AINS(aFi,1)
  aFi[1] := {'Название фирмы из карточки предпр.&C  ','P'    ,'{|| MemVar->LBL_NAME }',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,2)
  aFi[2] := {'Код партнера из карт/предпр &C  ','PrCode'    ,'{|| MemVar->LBL_OPER }',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,3)
  aFi[3]:={'Полное наименование предприятия &C  ','P0'    ,'{|| MemVar->LBL_ORGNAME }',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,4)
  aFi[4]:={'Код ИНН/КПП предприятия из карт/предпр &C ', 'InnKpp' ,'{|| MEMVAR->LBL_INNKPP}',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,5)
  aFi[5]:={'ОКПО предприятия из карт/предпр  &C ','OKPO' ,'{|| MemVar->LBL_OKPO }',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,6)
  aFi[6]:={'Банк предприятия из карт/предпр     &C ', 'Bank' , '{|| MEMVAR->LBL_BANK}',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,7)
  aFi[7]:={'Филиал банка из карт/предпр &C ', 'Recv' , '{|| MEMVAR->LBL_RECV}',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,8)
  aFi[8]:={'БИК банка из карт/предпр  &C ', 'Bkod' , '{|| MEMVAR->LBL_BNKKOD}',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,9)
  aFi[9]:={'Расч/счет из карт/предпр    &C ', 'Rsch' , '{|| MEMVAR->LBL_RSCHET}',,'F'}
  AADD(aFi,NIL)
  AINS(aFi,10)
  aFi[10]:={'Корр/счет предприятия из карт/предпр &C ', 'Ksch' , '{|| MEMVAR->LBL_CORR}',,'F'}
  AADD(aFi,{'Фамилия И.О. директора  &C ','Boss','{||M->LBL_BOSS}',,'F'})
  AADD(aFi,{'Фамилия И.О. бухгалтера &C ','Shef','{||M->LBL_SHEF}',,'F'})
  AADD(aFi,{'Название должности директора  &C ','Boss1','{||M->LBL_BOSS1}',,'F'})
  AADD(aFi,{'Название должности бухгалтера &C ','Shef1','{||M->LBL_SHEF1}',,'F'})
  AADD(aFi,{'Телефон                &C ','Tele' ,'{|| MemVar->LBL_TEL }',,'F'})
  AADD(aFi,{'Телефон (факт адрес)   &C ','Tele2' ,'{|| MemVar->LBL_TEL2 }',,'F'})
  AADD(aFi,{'Факс                   &C ','Fax'  ,'{|| MemVar->LBL_FAX }',,'F'})
  AADD(aFi,{'Адрес предприятия      &C ','Andr' ,'{|| MemVar->LBL_ADRES }',,'F'})
  AADD(aFi,{'Адрес предприятия фактический &C ','AndrF' ,'{|| MemVar->LBL_ADRESF }',,'F'})
  
  IF !EMPTY( Global_Set[2]) //GetUser("КОД ОПЕРАТОРА"))
    AADD(aFi,{'Код оператора        &C   ','OperCode','{|| GetUser("КОД ОПЕРАТОРА") }',,'F'})
    AADD(aFi,{'Фамилия оператора    &C   ','OperName','{|| GetUser("ФАМИЛИЯ ОПЕРАТОРА") }',,'F'})
  ENDIF
  AADD(aFi,{'Ввести перед печатью   &C ','Dest','{||SPACE(40)}','I'})
  AADD(aFi,{'Вычислить по формуле   &N ','For','{||0}','F'})
  AADD(aFi,{'Вычислить и накопить   &N ','ForS','{||0}','Q'})
  AADD(aFi,{'Вставить текст в форму  &C ','Text','{||""}','T'})
  AADD(aFi,{'Прогон листа            &C ','End_l',CHR(12)})
ENDIF
RETURN




//--------------------------------------------------------------------------//
                    PROCEDURE UpgradePere()
//--------------------------------------------------------------------------//
IF MPERE1->(FieldPos("NNOPER_")) = 0 .OR. MPERE1->(ORDNUMBER("TAG_NNOPER")) = 0
  SayError(" Выполните UPGRADE !")
  BREAK
ENDIF
dbPush("MPERE",0,"","","")
dbPush("MPERE1","MPERE1","","","")
IF MPERE->(!EOF()) .AND. EMPTY(MPERE->NNOPER)
  ORDSETFOCUS("MPERE1")
  // Upgrade
  MPERE->(;
         prDBEVAL({||;
              MPERE->NNOPER := IncStep("OperMPere"),;
              MPERE1->(;
                  dbSeek(UPPER(MPERE->NUM)),;
                  xDBEVAL({|| MPERE1->NNOPER_ := MPERE->NNOPER },,{|| UPPER(MPERE->NUM) = UPPER(MPERE1->NUM) },.T.);
                       );
                  },,,,,.T.,.T.);
           )
ENDIF
dbPop()
dbPop()
RETURN
//--------------------------------------------------------------------------//
                       FUNCTION RetDataPartia(cGrup,cNNum,cPartia,cName)
//--------------------------------------------------------------------------//
// Возвращает значение из спр.партии
LOCAL cRet
SPR_PART->(dbSeek(UPPER(cGrup+cNNum+cPartia)))
IF SPR_PART->OPER_FACT != 0 .AND.(UPPER(cName) == "AG_CODE" .OR. UPPER(cName ) == "AG_SCHET" .OR. UPPER(cName) == "AGENT_CODE" .OR. UPPER(cName) == "AG_NAME" ) .AND. SH_FACT->(dbSeek(SPR_PART->OPER_FACT)) .AND. S_KREDIT->(dbSeek(SH_FACT->OPER_KRED))
 IF cName = "AG_CODE"
   cRet := S_KREDIT->CODE
 ELSEIF cName = "AG_SCHET"
   cRet := S_KREDIT->SCHET
 ELSEIF cName = "AGENT_CODE"
   cRet := S_KREDIT->AG_CODE
 ELSEIF cName = "AG_NAME"
   cRet := S_KREDIT->AG_NAME
 ENDIF
 RETURN cRet
ENDIF
RETURN  SPR_PART->(FieldGet(FieldPos(cName)))

//--------------------------------------------------------------------------//
                       FUNCTION GetFiPartn(cCode,cName)
//--------------------------------------------------------------------------//
// Возвращает значение из спр.партнеров
LOCAL cRet:=''
PARTNER->(dbPush(,'FULLCODE'))
PARTNER->(dbSeek(UPPER(cCode)))
IF PARTNER->(FIELDPOS(cName)) >0
   cRet := PARTNER->(FIELDGET(FIELDPOS(cName)))
ENDIF
PARTNER->(dbPop())
RETURN cRet


//--------------------------------------------------------------------------//
                     FUNCTION DelSemafor()
//--------------------------------------------------------------------------//
// Удаляет файл семафоров
RETURN FERASE(LoadPath()+"INI\SEMAFOR.DBF")
//--------------------------------------------------------------------------//
                 FUNCTION GetStavka(nSt,lNds,lAcz,lAdd,lCsh)
//--------------------------------------------------------------------------//
// Установка и возврат флагов ставок НДС и акциза
// nSt        1 - НДС
//            2 - акциз
//            3 - налог с продаж
// nSetStavka 1 - НДС не вкл.,акциз вкл. в цену пост.
//            2 - НДС и акциз вкл. в цену поставки
//            3 - НДС и акциз не вкл. в цену поставки
// Возвращает признак успешности выбора
STATIC nSetStavka := 1, lSet := .F.
LOCAL nWin := WSELECT()
LOCAL aNameNds := NAME_NDS, aPoz
LOCAL aCaseSet := ARRAY(CS_LEN), aSet
IF ValType(lNds) = "L" .AND. ValType(lAcz) = "L" .AND. ValType(lCsh) = "L"
  IF !EMPTY(lAdd)
    IF !lNds .AND. lAcz .AND. !lCsh
      nSetStavka := 1
    ELSEIF lNds .AND. lAcz .AND. !lCsh
      nSetStavka := 2
    ELSEIF !lNds .AND. !lAcz .AND. !lCsh
      nSetStavka := 3
    ELSEIF lNds .AND. lAcz .AND. lCsh
      nSetStavka := 4
    ELSE
      nSetStavka := 1
    ENDIF
  ELSEIF !lSet
    AEVAL(iaSetNds,{|lVar,nPoz| aNameNds[nPoz] := IF(lVar,{nPoz,aNameNds[nPoz]},NIL) })
    PackDelEl(aNameNds)
    IF LEN(aNameNds) = 1
      nSetStavka := aNameNds[1,1]
    ELSE
      nSetStavka := 1
    ENDIF
  ENDIF
  RETURN NIL
ENDIF
IF TYPE(itaSetNds) != "A"
  nSetStavka := 1
  IF nSt = NIL
    RETURN NIL
  ENDIF
ENDIF
IF nSt = NIL
 AEVAL(iaSetNds,{|lVar,nPoz| aNameNds[nPoz] := IF(lVar,{nPoz,aNameNds[nPoz]},NIL) })
 PackDelEl(aNameNds)
 IF LEN(aNameNds) = 1
   nSetStavka := aNameNds[1,1]
 ELSEIF LEN(aNameNds) < 1
   nSetStavka := 1
 ELSE
   CS_L_ONLY  := .T.
   CS_N_ROW   := 10
   CS_N_COL   := 20
   CS_A_LIST  := aNameNds
   CS_X_ONLY  := nSetStavka
   CS_C_COLOR := COL_NCC4
   CS_L_FRAME := .T.
   CS_C_HEAD  := "[ Формирование цены поставки ]"
   WSELECT(0)
   aSet := SaveSet()
   nSetStavka := GetCase(aCaseSet)
   lSet := .T.
   RestSet(aSet)
   WSELECT(nWin)
 ENDIF
ELSE
 IF nSetStavka = 1
   RETURN nSt = 2
 ELSEIF nSetStavka = 2
   RETURN nSt # 3
 ELSEIF nSetStavka = 3
   RETURN .F.
 ELSEIF nSetStavka = 4
   RETURN .T.
 ENDIF
ENDIF
RETURN LastKey() != K_ESC
//--------------------------------------------------------------------------//
                   FUNCTION ChangeKredit(nAdd,lSetKredit,aSetKredit)
//--------------------------------------------------------------------------//
// Установка флага использования счета кредитора
// Используется текущая запись SH_FACT и S_KREDIT
LOCAL aNameKredit := NAME_KREDIT
LOCAL aCaseSet := ARRAY(CS_LEN), aSet
IF nAdd = S_LIB_ADD
  AEVAL(aSetKredit,{|lVar,nPoz| aNameKredit[nPoz] := IF(lVar,{nPoz,aNameKredit[nPoz]},NIL) })
  PackDelEl(aNameKredit)
  IF LEN(aNameKredit) = 1
    lSetKredit := aNameKredit[1,1] = 1
  ELSEIF LEN(aNameKredit) < 1
    lSetKredit := .T.
  ELSE
    CS_L_ONLY  := .T.
    CS_N_ROW   := 10
    CS_N_COL   := 20
    CS_A_LIST  := aNameKredit
    CS_X_ONLY  := 1
    CS_C_COLOR := COL_NCC4
    CS_L_FRAME := .T.
    CS_C_HEAD  := "[ Использование счета-кредитора ]"
    aSet := SaveSet()
    lSetKredit := GetCase(aCaseSet) = 1
    RestSet(aSet)
  ENDIF
ELSE
  lSetKredit := S_KREDIT->TYPE != TYPE_CLOSE
ENDIF
RETURN LastKey() != K_ESC
//--------------------------------------------------------------------------//
FUNCTION Algo(cAlgoritm,cRetType)
//--------------------------------------------------------------------------//
LOCAL nSum:= IF(cRetType = NIL,0,""), cType
IF !EMPTY(cAlgoritm).AND.((cType := TYPE(cAlgoritm))=IF(cRetType = NIL,"N",cRetType).OR.cType = "UI")
  nSum:=&cAlgoritm
  IF ValType(nSum) != IF(cRetType = NIL,"N",cRetType)
    nSum := IF(cRetType = NIL,0,"")
    SayError({" Ошибка в формуле ",cAlgoritm})
  ENDIF
ENDIF
RETURN (nSum)

//--------- Стековые DispBegin/DispEnd---------------------------------------
FUNCTION _DispBegin()
//---------------------------------------------------------------------------
  PushData("DispBegin",3)
  DispBegin()
RETURN .T.

FUNCTION _DispEnd()
RETURN IF(VarCompare(PopData("V",3),"DispBegin"), (PopData(,3),DispEnd(),.T.), .F.)

FUNCTION _IsDispBegin()
RETURN VarCompare(PopData("V",3),"DispBegin")

FUNCTION _DispEndAll()
    DO WHILE VarCompare(PopData("V",3),"DispBegin")
       PopData(,3)
       DispEnd()
    ENDDO
RETURN .T.

//---------------------------------------------------------------------------
FUNCTION VarCompare(xVar1,xVar2)
//--Сравнение двух переменнх неопределенных типов----------------------------
RETURN ValType(xVar1)==ValType(xVar2).AND.xVar1==xVar2

//--------------------------------------------------------------------------//
                FUNCTION RetValShOp(aMess)
//--------------------------------------------------------------------------//
// Запрос на формирование в валютных ценах ориентация на текущий алиас
// Возвращает .T. если все нормально
// aMess - сообщение об ошибке по ссылке
LOCAL lValSeek := .F., cValSeek := GlobalValuta, lSeek := .F., lExit := .T.
LOCAL nRec := RECNO(), lOnlyVal := .T.
IF TYPE("pCodeVal") = "C" .AND. TYPE("pCenaVal") = "N" .AND. TYPE("pDate") = "D" .AND. Moves->YesValuta
  DBEVAL({|| lOnlyVal := !lSeek .OR. UPPER(cValSeek) = UPPER(SH_OP->VAL_CODE),cValSeek := SH_OP->VAL_CODE,lSeek := lValSeek := .T. },{|| !EMPTY(SH_OP->VAL_CODE) .AND. UPPER(SH_OP->VAL_CODE) != UPPER(GlobalValuta) .AND. ROUND(SH_OP->SUMMA_V,3) != 0 },{|| lOnlyVal })
  dbGoTo(nRec)
  IF lOnlyVal
    lValSeek := lValSeek .AND. ( UPPER(MemVar->pCodeVal) = UPPER(cValSeek) .OR. YesOrNo(' Формировать накладную в валютных ценах ('+cValSeek+') ?'))
    IF UPPER(MemVar->pCodeVal) != UPPER(GlobalValuta).AND.UPPER(MemVar->pCodeVal) != UPPER(cValSeek) .AND. lSeek .AND. !lValSeek
      aMess := {"Формирование накладной в валюте ("+MemVar->pCodeVal+")","отличной от валюты счета-фактуры ("+cValSeek+")","невозможно !"}
      lExit := .F.
    ELSE
      MemVar->pCodeVal := IF(lValSeek,cValSeek,GlobalValuta)
      MemVar->CURS := MemVar->pCenaVal := InputVCurs(MemVar->pCodeVal,MemVar->pDate,.F.)[1]
    ENDIF
  ELSEIF (UPPER(MemVar->pCodeVal) = UPPER(GlobalValuta) .OR. YesOrNo(' Формировать накладную в основной валюте ('+GlobalValuta+') ?'))
    MemVar->pCodeVal := GlobalValuta
    MemVar->CURS := MemVar->pCenaVal := 1
  ELSE
    aMess := {"Счет-фактура сформирован в нескольких валютах","формирование накладной в валюте ("+MemVar->pCodeVal+")","невозможно !"}
    lExit := .F.
  ENDIF
ENDIF
RETURN lExit

//---------------------------------------------------------------------------
FUNCTION AddInPrice(cGrup,cNNum,cName,nCena,OnlySeek)
//---------------------------------------------------------------------------
// OnlySeek - ничего не меняет - только возвращает проставлена ли цена в прайсе(.T.-проставлена)
LOCAL aBase:= {{"Mag",LoadPath()+"TZ\Mag"},{"M_Price",LoadPath()+"TZ\M_Price"}}
LOCAL nRecLabel:= iMLABEL->(RECNO()), aShop:= {}, nShop:=1, xRet:= NIL
 DbPush()
 dbOpenBases(aBase)
 BEGIN SEQUENCE
       DbSelectArea("Mag")
       DbGoTop()
       DBEVAL({|| AADD(aShop,{Code,Name,NNoper}) })
       IF LEN(aShop)!=1
          SayError(IF(LEN(aShop)==0,"Справочник магазинов пуст !","Необходимо настроить только один магазин !"))
          BREAK
       ENDIF
       DbSelectArea("M_Price")
       OrdSetFocus("TAG_CODE")
       DbGoTop()
       IF EMPTY(OnlySeek)
          IF (!DbSeek(UPPER(aShop[nShop,1]+cGrup+cNNum)).AND.AddRec()).OR.;
             (EMPTY(SumOut).AND.EMPTY(SumOutR).AND.RecLock())
             REPLACE Code WITH aShop[nShop,1], Grup WITH cGrup, NNum WITH cNNum,;
                     Name WITH cName
             iMLABEL->(DbGoTo(nRecLabel))
             IF(nCena==NIL, nCena:= __CENA, NIL)
             REPLACE SumOut WITH nCena, SumOutR WITH nCena
             DbUnLock()
             AddGrup(1,UPPER(aShop[nShop,1]+cGrup+SPACE(13)),{"Code","Grup"},{aShop[nShop,1],cGrup})
          ENDIF
       ELSE
          xRet:= (DbSeek(UPPER(aShop[nShop,1]+cGrup+cNNum)).AND.(!EMPTY(SumOut).OR.!EMPTY(SumOutR)))
       ENDIF
 END SEQUENCE
 dbCloseBases(aBase)
 DbPop()
RETURN xRet

//--------------------------------------------------------------------------
FUNCTION RunPereOst(aErrStr)
//--------------------------------------------------------------------------
LOCAL nProces, aSet := SaveSet()
LOCAL aBase :={"MKART","MDOCM","MLABEL","MSCHET","MSTRU",;
               "MEMDAT","RBOOKM","RBOOK"}
dbOpenBases(aBase)
nProces := Proces_Ini(LEN(aErrStr),15,,"Перерасчет количества ТМЦ и резерва")
FRAME("[ Пересчет остатков ]",10,20,12,67,COL_BROWSE,2,.T.,.T.)
SetPos(11,22)
DispOut("По номенклатуре :",COL_BROWSE)
AEVAL(aErrStr, {|x|;
                    Proces_Update(nProces),;
                    SetPos(11,41),;
                    DispOut(x[2]+' '+x[3],COL_BROWSE),;
                    PereshetOst(.T.,.T.,.T.,UPPER(x[1]+x[2]+x[3]),.T.);
               })
Proces_End(nProces)
dbCloseBases(aBase)
RestSet(aSet)
RETURN NIL

//----------------------------------------------------------------------------
FUNCTION IsMayLock()
//----------------------------------------------------------------------------
LOCAL OldSem:= SetSemafor(.T.), lRet, aLock:= {.F., .F.}
  aLock[1]:= !(GetSetSemafor(.T.))
  IF(!aLock[1], GetSetSemafor(.F.), NIL)
  IF (!GlobalTask$"05").AND.!aLock[1].AND.SELECT('MDOC1')>0.AND.;
                                 ( GlobalTask$'03SR' ).AND.;
                                 SELECT('MDOC')>0.AND.;
                                 YesReal.AND.YesDop.AND.MDoc->Vid=="2".AND.;
                                 MDoc1->(DBSEEK(UPPER(LEFT(MDoc->DopCode,6))))
     aLock[2]:= !(MDoc1->(GetSetSemafor(.T.)))
     IF(!aLock[2], MDoc1->(GetSetSemafor(.F.)), NIL)
  ENDIF
lRet:= !(aLock[1].OR.aLock[2])
IF !lRet
   SayError({IF(aLock[2].OR.GlobalTask$"05","Заказ заблокирован другим пользователем.","Документ заблокирован другим пользователем."),;
             "Удаление "+IF(GlobalTask$"05","заказа","документа")+" запрещено."})
ENDIF
SetSemafor(OldSem)
RETURN lRet

//--------------------------------------------------------------------------
FUNCTION AADD2D(aArray,xVar,nElem,nMaxLen)
//--------------------------------------------------------------------------
//Добавление в двумерный массив
//Усе по ссылке кроме xVar,nMaxLen
//[nElem,nMaxLen] - не обязателены
//массив по ссылке !!!
IF(EMPTY(nMaxLen), nMaxLen:=2000, )
IF(EMPTY(nElem),   nElem:= LEN(aArray), )
IF LEN(aArray[nElem])>=nMaxLen
   AADD(aArray,{})
   nElem++
ENDIF
AADD(aArray[nElem], xVar)
RETURN NIL

//---------------------------------------------------------------------------
FUNCTION ASCAN2D(aArray,bEqval,nMaxLen)
//---------------------------------------------------------------------------
//Поиск по двумерному массиву
//[nMaxLen] = максимальное чило елементов в одной пачке
//Лучше массив по ссылке
LOCAL nSeek:= 0, nElem:=1, nTmpSeek
IF(EMPTY(nMaxLen).AND.LEN(aArray)>0, nMaxLen:= LEN(aArray[1]), NIL)
      DO WHILE nSeek==0.AND.nElem<=LEN(aArray)
         nTmpSeek:= ASCAN(aArray[nElem], bEqval)
         IF !EMPTY(nTmpSeek)
            nSeek:= (nElem-1)*nMaxLen+nTmpSeek
         ELSE
            nElem++
         ENDIF
      ENDDO
RETURN nSeek

//---------------------------------------------------------------------------
FUNCTION AEVAL2D(aArray,bRun)
//---------------------------------------------------------------------------
//Лучше массив по ссылке
  AEVAL(aArray, {|aPodArray| AEVAL(aPodArray, bRun)})
RETURN NIL

//---------------------------------------------------------------------------
FUNCTION GetVar2D(aArray,nPoz,nMaxLen)
//---------------------------------------------------------------------------
//Взять значение двумерного массива по длинному номеру от ASCAN2D
//Лучше массив по ссылке
LOCAL nElem
IF(EMPTY(nMaxLen).AND.LEN(aArray)>0, nMaxLen:= LEN(aArray[1]), NIL)
nElem:= INT((nPoz-1)/nMaxLen)+1
RETURN aArray[nElem][nPoz-(nMaxLen*(nElem-1))]

/*******************************
*   My_RetSumOprix () --> NIL
*
*/
FUNCTION My_RetSumOprix(lReal,aNoRelat)
    LOCAL aRet:={}
    IF  !lReal
        IF  SH_OP->TYPE=="4" .OR. ((aNoRelat[1].AND.SH_OP->TYPE=="1") .OR. (aNoRelat[2].AND.SH_OP->TYPE=="2"))
            IF  !EMPTY(SH_OP->DATA_OPR)
                aRet:=SH_OP->DATA_OPR
                IF(LEN(SH_OP->DATA_OPR)>=1.AND. LEN(SH_OP->DATA_OPR[1])=22,AADD(aRet[1],0.0),NIL)
            ENDIF
        ENDIF
    ENDIF
RETURN aRet  // from  func My_RetSumOprix

/*******************************
*   MyYesTV () --> NIL
*
*/
FUNCTION  MyYesTV()
    LOCAL lRet:=.T.,cSel:="",cType_St:=SH_OP->TYPE
    LOCAL aBaseMov:={},lZClose:=.F.,lSClose:=.F.

    DBPUSH()
    IF  SELECT("MOVES")==0
        aBaseMov:={{"MOVES",LoadPath()+"ZAPAS\MOVES"}}
        dbOpenBases(aBaseMov)
        lZClose:=.T.
    ENDIF
    IF  SELECT("SMOVES")==0
        aBaseMov:={{"SMOVES",LoadPath()+"SCLAD\MOVES"}}
        dbOpenBases(aBaseMov)
        lSClose:=.T.
    ENDIF

    IF  cType_St=="1".AND.SELECT("SMOVES")<>0
        cSel:="SMOVES"
    ELSEIF cType_St=="2".AND.SELECT("MOVES")<>0
        cSel:="MOVES"
    ELSE
        cSel:=""
    ENDIF
    IF  !EMPTY(cSel)
        (cSel)->(DBPUSH())
        (cSel)->(ORDSETFOCUS("MOVES_V"))
        (cSel)->(DBSEEK("1"))
        (cSel)->(DBEVAL({|| IIF(lRet,IIF((cSel)->YESTV,lRet:=.F.,lRet:=.T.),.T.) },,{||(cSel)->VID=="1"}))
        (cSel)->(DBPOP())
    ELSE
        lRet:=NIL
    ENDIF

    //dbCloseBases(aBaseMov[1])
    IF  lZClose
        MOVES->(DBCLOSEAREA())
    ENDIF
    IF lSClose
        SMOVES->(DBCLOSEAREA())
    ENDIF
    DBPOP()
RETURN lRet  // from  func MyYesTV

#define __DATA         7    // Дата документа

#define __SUM_G_OPR   15    // Сумма оприходования без НДС в GlobalValuta
#define __SUM_G_BR    17    // Сумма брака в GlobalValuta
#define __SUM_G_NED   18    // Сумма недостачи в GlobalValuta

#define __SUM_G_SND   16    // Сумма оприходования c НДС в GlobalValuta
#define __SUM_G_SBR   21    // Сумма брака в GlobalValuta с НДС
#define __SUM_G_SNED  20    // Сумма недостачи в GlobalValuta с НДС
#define __SUM_CSH  23    // Сумма налога с продаж

/*******************************
*   My_SSB () --> NIL
*
* Почти тоже самое, что ShetSumBook, только запихивает оприходованные
* по ALT_O суммы по СФ
* P.S. Уже далеко не тоже самое
*
*     Описание параметров:
* cSelShOp    - алиас строк СФ
* nOperFact   - уникальный номер СФ
* aNds        - из функции ShetSumBook()
* nSumma      - из функции ShetSumBook()
* nSummaNds   - из функции ShetSumBook()
* dMyDateBook - Вывод оприходованных сумм для даты меньшей или равной этой
* lNoOperFact - из функции ShetSumBook()
* lOnlyOprx   - Выводить только реально оприходованные суммы
* lFineCompDat- Точное сравнение с датой
*
*/
FUNCTION  My_SSB(cSelShOp,nOperFact,aNds,nSumma,nSummaNds,dMyDateBook,lNoOperFact,lOnlyOprx,lFineCompDat,nSummaCsh)
    LOCAL nPoz,nS:=0,nSNds:=0,nSCsh:=0,nSnoNDS:=0
    LOCAL lYesOprx:=MyPredScanOprx(cSelShOp,nOperFact)
    LOCAL aRetOpx:={},aArr:={}
    LOCAL lYesTV,lFEnter:=.T.
    LOCAL aNoRelat:=IsNoTVRel()

    //IF  lYesTV==NIL.OR.lYesTV    // (lYesTV<>NIL.AND.lYesTV) .OR. (!lYesOprx.AND.MyYesTV(.T.))
        aNds:={}
        nSumma    :=0
        nSummaNds :=0
        nSummaCsh :=0
        (cSelShOp)->( DBPUSH(,"TAG_NNOPER","","","") )
        (cSelShOp)->( DBSEEK(STR(nOperFact,17,0)) )
        DO WHILE  !(cSelShOp)->(EOF()).AND.nOperFact = (cSelShOp)->NNOPER_
            //lYesTV:=MyYesTV()
            IF  (cSelShOp)->TYPE=="3".OR.(cSelShOp)->TYPE=="4".OR.((aNoRelat[1].AND.(cSelShOp)->TYPE=="1").OR.(aNoRelat[2].AND.(cSelShOp)->TYPE=="2"))
                //IIF(lFEnter,(aNds:={},nSumma:=0,nSummaNds:=0,lFEnter:=.F.),)
                aRetOpx:=My_RetSumOprix(.F.,aNoRelat)
                IF  (nPoz := ASCAN(aNds,{|x| x[1] = (cSelShOp)->OPER_NDS })) = 0
                    AADD(aNds,{(cSelShOp)->OPER_NDS,0,0,IF(lNoOperFact != NIL,{0.0,0.0},NIL),IIF(!EMPTY(aRetOpx),aRetOpx[1][__DATA],CTOD(""))})
                    nPoz := LEN(aNds)
                ENDIF
                IF  (cSelShOp)->TYPE=="3"  //.OR.(cSelShOp)->TYPE=="4"
                    IF  EMPTY(aRetOpx)
                        AADD(aRetOpx,ARRAY(22))
                    ENDIF
                    aArr:=aRetOpx[1]
                    IsStrDelShFact(@aArr)
                    aRetOpx:={aArr}
                ENDIF
            ***** Если есть связь с закупками на складе и в запасах
            ELSEIF (!aNoRelat[1].AND.(cSelShOp)->TYPE=="1").OR.(!aNoRelat[2].AND.(cSelShOp)->TYPE=="2")
                aRetOpx:={ARRAY(22)}
                IF  (nPoz := ASCAN(aNds,{|x| x[1] = (cSelShOp)->OPER_NDS })) = 0
                    AADD(aNds,{(cSelShOp)->OPER_NDS,0,0,IF(lNoOperFact != NIL,{0.0,0.0},NIL),IIF(!EMPTY(aRetOpx),aRetOpx[1][__DATA],CTOD(""))})
                    nPoz := LEN(aNds)
                ENDIF
                aArr:=aRetOpx[1]
                IsStrDelShFact(@aArr)
                aRetOpx:={aArr}
            ENDIF
            IF  !EMPTY(aRetOpx) .AND. !EMPTY(aRetOpx[1][__DATA]) .AND. IIF(!EMPTY(dMyDateBook), IIF(lFineCompDat<>NIL,aRetOpx[1][__DATA]==dMyDateBook,aRetOpx[1][__DATA]<=dMyDateBook) ,.T.)
                nS:=aRetOpx[1][__SUM_G_SND]-aRetOpx[1][__SUM_G_SBR]-aRetOpx[1][__SUM_G_SNED]
                nSnoNDS:=aRetOpx[1][__SUM_G_OPR]-aRetOpx[1][__SUM_G_BR]-aRetOpx[1][__SUM_G_NED]
                nSCsh:=aRetOpx[1][__SUM_CSH]
                nSNds:=nS-nSnoNDS
            ELSE
                nS:=0; nSNds:=0; nSCsh:=0
            ENDIF
            IF  !EMPTY(aRetOpx).AND.!EMPTY(aRetOpx[1][__DATA]).AND.TYPE("aDateBook")=="A"
                AADD(m->aDateBook,aRetOpx[1][__DATA])
            ENDIF
            // Если вообще нет оприходования
            // Если lOnlyOprx<>NIL, то выводить суммы по реальному оприходованию,
            //   т.е. в этом случае возвращается только сумма оприходования, а не
            //   полная сумма по строке СФ
            IF  !lYesOprx .AND. lOnlyOprx==NIL
                nS    := ROUND((cSelShOp)->SUMMA_FACT,CURR_MAIN)
                nSNds := ROUND((cSelShOp)->SUMMA_NDS,CURR_MAIN)
                nSCsh := ROUND((cSelShOp)->SUMMA_CSH,CURR_MAIN)
            ENDIF
            nSumma       += nS
            nSummaNds    += nSNds
            nSummaCsh    += nSCsh
            aNds[nPoz,2] += nSNds
            aNds[nPoz,3] += nS
            IF  lNoOperFact != NIL
                aNds[nPoz,4,1] += ROUND((cSelShOp)->SUMMA_NDS,CURR_MAIN)
                aNds[nPoz,4,2] += ROUND((cSelShOp)->SUMMA_FACT,CURR_MAIN)
            ENDIF

            (cSelShOp)->(DBSKIP())
        ENDDO
        (cSelShOp)->( DBPOP() )
    //ENDIF
RETURN NIL  // from  func My_SSB

/*******************************
*   MyPredScanOprx () --> NIL
*
* Предварительное сканирование по СФ на предмет ручного оприходования по ALT_O
* Если вообще нет никакого оприходования, то возвращает .F., иначе .T.
*
*/
FUNCTION  MyPredScanOprx(cSelShOp,nOperFact)
    LOCAL lYesOprx:=.F.

    (cSelShOp)->( DBPUSH(,"TAG_NNOPER","","","") )
    (cSelShOp)->( DBSEEK(STR(nOperFact,17,0)) )
    (cSelShOp)->(;
                DBEVAL( {||;
                            IIF (!EMPTY(SH_OP->DATA_OPR).AND.!EMPTY(SH_OP->DATA_OPR[1][__DATA]),;
                                    lYesOprx:=.T.,;
                                    NIL;
                                );
                        },,;
                        {||!lYesOprx .AND. nOperFact = (cSelShOp)->NNOPER_};
                      );
                )

    (cSelShOp)->( DBPOP() )

RETURN lYesOprx  // from  func MyPredScanOprx

/*******************************
*   MyChekOpxBook () --> NIL
*  Контроль книги
*  Выдает .T. если текущая строка СФ оприходована
*
*/
FUNCTION  MyChekOpxBook(lReal,aRetOpx,lYesOprx,aNoRelat)
    //LOCAL lYesOprx:=MyPredScanOprx("SH_OP",SH_FACT->NNOPER)
    LOCAL lYesTV,aTemp

    IF  !lReal
        //lYesTV:=MyYesTV()
        IF  SH_OP->TYPE=="3".OR.SH_OP->TYPE=="4".OR.((aNoRelat[1].AND.SH_OP->TYPE=="1").OR.(aNoRelat[2].AND.SH_OP->TYPE=="2"))
            m->aRet_Opx:=My_RetSumOprix(lReal,aNoRelat)
            IIF(!EMPTY(m->aRet_Opx),m->aRet_Opx:=m->aRet_Opx[1],)
            IF  SH_OP->TYPE=="3"         // Услуги
                IF  VALTYPE(SH_OP->DATA_OPR)=="A".AND.!EMPTY(SH_OP->DATA_OPR[1][__DATA])
                    m->aRet_Opx:=SH_OP->DATA_OPR[1]
                    IF(LEN(SH_OP->DATA_OPR)>=1.AND. LEN(SH_OP->DATA_OPR[1])=22,AADD(m->aRet_Opx,0.0),NIL)
                ELSE
                    aTemp:=ARRAY(23)
                    IsStrDelShFact(@aTemp)    //Ищем в актах, если по ALT_O пусто
                    m->aRet_Opx:=aTemp
                ENDIF
            ENDIF
        ***** Если есть связь с закупками на складе или в запасах
        ELSEIF (!aNoRelat[1].AND.SH_OP->TYPE=="1").OR.(!aNoRelat[2].AND.SH_OP->TYPE=="2")
            aTemp:=ARRAY(23)
            IsStrDelShFact(@aTemp)
            m->aRet_Opx:=aTemp
        ENDIF
    ENDIF
RETURN IIF(!EMPTY(m->aRet_Opx).AND.!EMPTY(m->aRet_Opx[__DATA]),.T.,.F.)  // from  func MyChekOpxBook

/*******************************
*   IsNoTVRel () --> NIL
*
* Модификация MyYesTV для многократного вызова для строк СФ
* Возвращает массив: {<связь с закупками>,<связь с запасами>}
*
*/
FUNCTION  IsNoTVRel()
    LOCAL lRet:=.F.
    LOCAL aBaseMov:={},lZClose:=.F.,lSClose:=.F.
    LOCAL aSel:={},i,aRet:={.F.,.F.}

    DBPUSH()
    IF  SELECT("SMOVES")==0
        aBaseMov:={{"SMOVES",LoadPath()+"SCLAD\MOVES"}}
        dbOpenBases(aBaseMov)
        lSClose:=.T.
    ENDIF
    IF  SELECT("MOVES")==0
        aBaseMov:={{"MOVES",LoadPath()+"ZAPAS\MOVES"}}
        dbOpenBases(aBaseMov)
        lZClose:=.T.
    ENDIF
    AADD(aSel,"SMOVES")
    AADD(aSel,"MOVES")

    FOR i:=1 TO LEN(aSel)
        (aSel[i])->(DBPUSH())
        (aSel[i])->(ORDSETFOCUS("MOVES_V"))
        (aSel[i])->(DBSEEK("1"))
        (aSel[i])->(DBEVAL({|| NIL },,{||!(aSel[i])->YESTV.AND.(aSel[i])->VID=="1"}))
        aRet[i]:=!(aSel[i])->YESTV
        (aSel[i])->(DBPOP())
    NEXT
    IF  lZClose
        MOVES->(DBCLOSEAREA())
    ENDIF
    IF lSClose
        SMOVES->(DBCLOSEAREA())
    ENDIF
    DBPOP()
RETURN aRet  // from  func IsNoTVRel

/*******************************
*   RetSummBook () --> NIL
*
*/
FUNCTION  RetSummBook()
    LOCAL nSumma:=0.0

    BOOK->(DBPUSH())
    BOOK->(ORDSETFOCUS("TAG_FACT"))
    IF  BOOK->(DBSEEK(STR(SH_Fact->NNOPER,17,0)))
        BOOK->(DBEVAL({||nSumma+=BOOK->SUMMA_FACT},,{||BOOK->OPER_FACT==SH_Fact->NNOPER}))
    ENDIF
    BOOK->(DBPOP())
    IIF(SH_FACT->SUMMA_OPL-nSumma<0,nSumma:=0,nSumma:=SH_FACT->SUMMA_OPL-nSumma)
RETURN nSumma  // from  func RetSummBook

/*******************************
*   MyEraseSeek () --> NIL
*
*/
FUNCTION  MyEraseSeek(/*aIn*/)
    //IIF(!lRealSeek.AND.aIn[1]=='4',(aIn[2]:="",aIn[3]:=""),)
    m->aIn[2]:=REPLICATE(" ",LEN(m->aIn[2]))
    m->Getlist[2]:Display()
    IF LEN(aIn)>2
       m->aIn[3]:=REPLICATE(" ",LEN(m->aIn[3]))
       m->GetList[3]:Display()
    ENDIF
RETURN .T.  // from  func MyEraseSeek

/*******************************
*   SetPLG () --> NIL
*
*/
FUNCTION  SetPLG()
    m->pLastGrup:=aIn[2]
RETURN .T.  // from  func SetPLG


FUNCTION RepOpl(cSch,cAgentC, nRej, cMess)
#DEFINE P_HEADER  1
#DEFINE P_FIELDS  2
#DEFINE P_HEADS   3
#DEFINE P_FORMAT  4
#DEFINE P_TOT     5
#DEFINE P_GROUP   6
#DEFINE P_ISNUM   7
#DEFINE P_FOOT    8
#DEFINE SHOW_LINES   .T.
#DEFINE SHOW_PAGES   .T.
#DEFINE SHOW_PROCESS .T.
LOCAL aSet := SaveSet(), aSetKeys := SaveSetKey()
LOCAL aInit  //->aHeader,aFields,aHeads,cFormat
LOCAL cTemp :=TEMPFILE(PATH_TMP,'DBF')
LOCAL cTemp2 :=TEMPFILE(PATH_TMP,'DBF')
LOCAL cTempi :=TEMPFILE(PATH_TMP,'IDX')
LOCAL cTempi2 :=TEMPFILE(PATH_TMP,'IDX')
LOCAL cTempi3 :=TEMPFILE(PATH_TMP,'IDX')
LOCAL cFile:=TEMPFILE(PATH_TMP)
LOCAL lc:=0, lMain := .F.
LOCAL cHelp_Code:=HELP_CODE

BEGIN SEQUENCE

ScrTitul(24,' ')
/*RestPar('Scet')
RestPar('RDoc')
RestPar('MLab')
RestPar('Ana')
RestPar('Pric') */

PRIVATE aStatus:={'Закpыт','Откpыт'}
PRIVATE lNaim := .F.
   dbOpenBases({{'Analit1','Analit'}},,,,.T.)
   IF  SELECT('Main') = 0
      NetUse('Main','Main','Main',,,,,.T.)
      lMain := .T.
   ENDIF
   aInit:=FRepRas(cTemp,cTempi,cTempi2,cTempi3,cTemp2,cSch,cAgentC,nRej,cMess)

GO TOP
IF (LEN(aInit[P_FIELDS])>0 .AND.;
   (lc:=TotRep(aInit[P_HEADER],aInit[P_FIELDS],aInit[P_HEADS],aInit[P_FORMAT],;
   aInit[P_TOT],aInit[P_GROUP],aInit[P_FOOT], ;
   cFile,aInit[P_ISNUM],SHOW_PAGES,SHOW_PROCESS,LASTREC())) > 0)
   View(cFile,lc,LEN(aInit[P_FORMAT]))
ENDIF


END SEQUENCE
dbCloseBases({'Analit1'})
IF SELECT('TEMP') # 0
   CLOSE TEMP
ENDIF
IF SELECT('TEMP2') # 0
   CLOSE TEMP2
ENDIF
IF lMain
   CLOSE Main
ENDIF

FERASE(cTemp)
FERASE(cTemp2)
FERASE(cTempi)
FERASE(cTempi2)
FERASE(cTempi3)
FERASE(cFile)
aIn0 = {}

RestSet(aSet)
RestSetKey(aSetKeys)
HELP_CODE:=cHelp_Code
SETBLINK(.F.)


RETURN (NIL)


FUNCTION FRepRas(cTemp,cTempi,cTempi2,cTempi3, cTemp2,cSch,cAgentC,nRej,cMess)
   // nRej - 1|NIL/2/3 - заказчик/покупаталь/поставщик
   LOCAL bFoot,bFor,bFor0,i,l1,l2
   LOCAL aHeader:={},aFields:={},aHeads:={},cFormat,aTot:={},aGroup:={},lIsNum:=.F.
   LOCAL aStru,aCode:={}
   LOCAL nLen:=16, nOper

   LOCAL aTmpFile, cCodeAnal, cSchAnal
   LOCAL cHead:='' , oGet, cDt
*   MEMVAR aAgents
   PRIVATE aAgents:={}

   IF nRej = NIL
      nRej = 1
   ENDIF
   IF nRej = 3
      cDt = 'Кт'
   ELSE
      cDt = 'Дт'
   ENDIF


   AADD(aHeader,' '+m->LBL_NAME);AADD(aHeader,SPACE(1))


   BEGIN SEQUENCE

      IF EMPTY(cSch) .AND. EMPTY(cAgentC)
         IF ((nOper:=BoxMenu(' Выбор счета расчетов ',17,30,{'      -по коду               ','      -по наименованию       '},,,,COL_SHEADR,COL_SHEADR))#0)
            IF nOper = 1
               PRIVATE GetList:={}, pSch := SPACE(10), pAgentC:=SPACE(6),cNDoc
               cNDoc:= &('InDocFact(SH_FACT->NNOPER,SH_FACT->TYPE_SV,SH_FACT->OPER_KRED,,@pSch,@pAgentC)')
               Plan->(MakeSchetRefer('Plan1','pSch',1))
               Analit->(SAnalit('Analit','pAgentC',1,,'NoInput'))
                FRAME("",9,20,13,67,COL_INPUT,2,.T.,.T.)
                @11,22 SAY 'Укажите счет расчетов ' COLOR COL_INPUT
               oGet:=GETNEW(11,44,{|x| IF(x != NIL,pSch := x,pSch)},"pSch","@K "+_PIC_SCHET,COL_GET)
               oGet:preBlock:= {||.T.}
               oGet:reader :={|x| ReferGetReader(x,"Plan1")}
               oGet:postBlock:={|| SaveLoadType(pSch),.T.}
               AADD(GetList,oGet)
               GetList[1]:display()
               oGet:=GETNEW(11,45+_LEN_SCHET,{|x| IF(x != NIL,pAgentC := x,pAgentC)},"pAgentC","@K",COL_GET)
               oGet:preBlock:= {||.T.}
               oGet:reader :={|x| ReferGetReader(x,"Analit")}
               oGet:postBlock:={|| .T.}
               AADD(GetList,oGet)
               GetList[2]:display()
               SET CURSOR ON
               READ
               SET CURSOR OFF
               IF LASTKEY() = K_ESC
                  BREAK
               ENDIF
               cAgentC = pAgentC
               cSch = pSch
            ELSEIF nOper = 0
               BREAK
            ELSE
               m->lNaim = .T.
               dbPush('Analit',,'ALLTRIM(UPPER(SH_FACT->Ag_Name))$UPPER(Name)')
               dbEval({||AADD(aAgents,{UPPER(Analit->Schet),UPPER(Analit->Code)})})
               dbPop()
            ENDIF
         ENDIF
         IF nOper = 0
            BREAK
         ENDIF

      ENDIF
      IF EMPTY(cMess)
         cHead:='РАСЧЕТЫ С '+IF(nRej=1,'ЗАКАЗЧИКОМ ',IF(nRej = 2,'ПОКУПАТЕЛЕМ ','ПОСТАВЩИКОМ '))
      ELSE
         cHead:= cMess

      ENDIF
      aIn0 = ARRAY(40)
      aIn0[30] := cSch
      aIn0[31] := cAgentC
      aIn0[32] := ''
      aIn0[8] := ctod('')
      aIn0[9] := DATE()
      l50:=.F.;l51:=.F.;l52:=.F.;l76:=.F.;l60:=.F.;lI:=.F.
      Busy(.T.,'Расчет оплат и отгрузки')
         aStru:={;
         {'Schet','C',10,0},;
         {'Name','C',25,0},;
         {'Code','C',6,0},;
         {'Date1','D',8,0},;
         {'Num1','C',6,0},;
         {'Sum1','N',19,3},;
         {'Date2','D',8,0},;
         {'Num2','C',6,0},;
         {'Sum50','N',19,CURR_MAIN+1},;
         {'Sum51','N',19,CURR_MAIN+1},;
         {'Sum52','N',19,CURR_MAIN+1},;
         {'Sum76','N',19,CURR_MAIN+1},;
         {'Sum60','N',19,CURR_MAIN+1},;
         {'SumI' ,'N',19,CURR_MAIN+1};
         }
      DBCREATE(cTemp,aStru)
      NetUseExcA('Temp',cTemp)
         INDEX ON UPPER(Name+Code+Schet) TO (cTempi)
         INDEX ON UPPER(Name+Code+DTOS(Date1)+FIELD->Num1+Schet) TO (cTempi2)
         INDEX ON UPPER(Name+Code+DTOS(Date2)+FIELD->Num2+Schet) TO (cTempi3)
         SET INDEX TO (cTempi),(cTempi2),(cTempi3)
      RE_OPEN_DBF
      SELECT Main
      IF m->lNaim
         bFor:={||(DataOper>=aIn0[8]).AND.DataOper<=aIn0[9].AND.;
         (ASCAN(aAgents,{|x|UPPER(Dt_Schet+Dt_Code)==UPPER(x[1]+x[2])})>0.OR.;
          ASCAN(aAgents,{|x|UPPER(Kt_Schet+Kt_Code)==UPPER(x[1]+x[2])})>0)}
      ELSEIF EMPTY(aIn0[31]+aIn0[32])
         bFor:={||(DataOper>=aIn0[8]).AND.DataOper<=aIn0[9].AND.;
         (UPPER(Dt_Schet)==UPPER(aIn0[30]).OR.UPPER(Kt_Schet)==UPPER(aIn0[30]))}
      ELSEIF !EMPTY(aIn0[31])
         bFor:={||(DataOper>=aIn0[8]).AND.DataOper<=aIn0[9].AND.;
         (UPPER(Dt_Schet+Analit->Code)==UPPER(aIn0[30]+aIn0[31]).OR.;
          UPPER(Kt_Schet+Analit1->Code)==UPPER(aIn0[30]+aIn0[31]))}
      ELSE
         IF ('*'$aIn0[32])
            aIn0[32]:=LEFT(aIn0[32],AT('*',aIn0[32])-1)
         ENDIF
         bFor:={||(DataOper>=aIn0[8]).AND.DataOper<=aIn0[9].AND.;
         (UPPER(Dt_Schet+TRIM(Analit->Name))==UPPER(aIn0[30]+TRIM(aIn0[32])).OR.;
          UPPER(Kt_Schet+TRIM(Analit1->Name))==UPPER(aIn0[30]+TRIM(aIn0[32])))}
      ENDIF
      SELECT Main
      ORDSETFOCUS("TAG_NNOPER")
      GO TOP
      WHILE !EOF()
         l1:=l2:=.F.
         IF m->lNaim
            IF ASCAN(aAgents,{|x|UPPER(Dt_Schet+Dt_Code)==UPPER(x[1]+x[2])})>0
               aIn0[30] := Dt_Schet
               aIn0[31] := Dt_Code
            ELSEIF ASCAN(aAgents,{|x|UPPER(Kt_Schet+Kt_Code)==UPPER(x[1]+x[2])})>0
                aIn0[30] := Kt_Schet
                aIn0[31] := Kt_Code
            ELSE
                aIn0[30] := CHR(255)
                aIn0[31] := CHR(255)
            ENDIF
         ENDIF
         IF UPPER(Dt_Schet)==UPPER(aIn0[30])
            l1:=Analit->(DBSEEK(Main->(UPPER(Dt_Schet+Dt_Code))))
         ENDIF
         IF UPPER(Kt_Schet)==UPPER(aIn0[30])
            l2:=Analit1->(DBSEEK(Main->(UPPER(Kt_Schet+Kt_Code))))
         ENDIF
         IF (l1.OR.l2).AND.EVAL(bFor)
            RascetFF(2,nRej)
         ENDIF
         DbSkip()
      ENDDO
         Temp->( DbClearIndex() )
         Temp->( DbSetIndex( cTempi ) )
         IF !M_OPEN_Base( { { 'PLAN',    0 }, ;
                            { 'PLAN0',   0 }, ;
                            { 'ANALIT0', 0 }, ;
                            { 'ANALIT',  0 }, ;
                            { 'VALUTA',  0 }, ;
                            { 'MAIN',    0 }, ;
                            'TMP', 'TmpAnal', 'TmpSchet';
                          },;
                          @aTmpFile )
            BREAK
         ENDIF
         /*
             Повесим фильтр не очень красиво
         */
         SELECT MAIN
         OrdSetFocus("TAG_DATE")
         if m->lNaim
            Set Filter To ASCAN(aAgents,{|x|UPPER(MAIN->KT_SCHET)==UPPER(x[1]) .AND. UPPER(MAIN->KT_CODE) ==UPPER(x[2])} )>0 .OR.;
                          ASCAN(aAgents,{|x|UPPER(MAIN->DT_SCHET)==UPPER(x[1]) .AND. UPPER(MAIN->DT_CODE) ==UPPER(x[2])} )>0
         else
            Set Filter To ( MAIN->KT_SCHET==aIn0[30] .AND. MAIN->KT_CODE ==aIn0[31] ) .OR.;
                          ( MAIN->DT_SCHET==aIn0[30] .AND. MAIN->DT_CODE ==aIn0[31] )
         endif
         DbGoTop()
         MainOborot(;
                     {|| MAIN->DataOper <= aIn0[9] },;
                     {||IF(MAIN->DataOper >= aIn0[8], 1, 0) };
                   )
         MAIN->( DbClearFilter() )
         Select TmpAnal
         Copy TO ( cTemp2 )
         NetUseExcA('Temp2',cTemp2)
         IF m->lNaim
            INDEX ON UPPER( FIELD->SCHET + FIELD->CODE )+" " TO (cTempi3)
         ELSE
            INDEX ON UPPER( FIELD->SCHET + FIELD->CODE )+" " TO (cTempi3) ;
                  FOR Field->SCHET==aIn0[30]
         ENDIF
         M_Close_Base( { 'TMP', 'TmpAnal', 'TmpSchet' })
         IF ValType( aTmpFile ) == "A"
            AEVAL( aTmpFile, {|x| FERASE(x)})
         ENDIF

      SELECT Temp
      ORDSETFOCUS(1)
      Busy(.F.)

         AADD(aHeads,"┌────────────────────────────────┬────────────────")
         AADD(aHeads,"│             Отгружено          │                ")
         AADD(aHeads,"├────────┬──────┬────────────────┼────────┬──────┬")
         AADD(aHeads,"│  Дата  │ Док. │      Сумма     │  Дата  │ Док. │")
         AADD(aHeads,"├────────┼──────┼────────────────┼────────┼──────┼")
         AADD(aHeads,"│   01   │  02  │       03       │   04   │  05  │")
         AADD(aHeads,"├────────┼──────┼────────────────┼────────┼──────┼")
         cFormat:=   "│99999999│XXXXXX│RRRRRRRRRRRRRRRR│99999999│XXXXXX│"


         AADD(aFields,'StrS(Date1)')
         AADD(aFields,'Num1')
         AADD(aFields,'Sum1')
         AADD(aFields,'StrS(Date2)')
         AADD(aFields,'Num2')
         i:=6
         AADD( aGroup,;
               { "UPPER(Name+Code+IF(m->lNaim,Schet,''))",;
                 {||cCodeAnal := Temp->Code,;
                    cSchAnal := Temp->Schet,;
                    IF(m->lNaim,;
                        Str2File( "│"+PadC(TRIM(Temp->Schet)+' '+Temp->Code+' '+ALLTRIM(Temp->Name),Len(cFormat)-2,'.') + "│"),;
                        NIL),;
                    Str2File( PadR( "│Начальное сальдо" + if( Temp2->( DbSeek( UPPER(Temp->Schet+Temp->Code ) ) ),;
                                                              (;
                                                               if( Temp2->DtOb_N != 0,;
                                                                   IF(nRej=3,Replicate(" ", Len(cFormat) - 34 ),'')+StrS(Temp2->DtOb_N,16,CURR_MAIN),;
                                                                   IF(nRej#3,Replicate(" ", Len(cFormat) - 34 ),'')+StrS(Abs(Temp2->KtOb_N),16,CURR_MAIN);
                                                                 );
                                                              ),;
                                                              "";
                                                            ),;
                                    Len(cFormat)-1;
                                  ) + "│";
                            ),;
                    NIL;
                 },;
                 {|a,f,g|F := .T.,;
                               Str2File( PadR(;
                                              "│Сальдо на конец " + if( Temp2->( DbSeek( UPPER(cSchAnal+cCodeAnal) ) ),;
                                                                        (;
                                                                         if( Temp2->DtOst != 0,;
                                                                             IF(nRej=3,Replicate(" ", Len(cFormat) - 34 ),'')+StrS(Temp2->DtOst,16,CURR_MAIN),;
                                                                             IF(nRej#3,Replicate(" ", Len(cFormat) - 34 ),'')+StrS(Abs(Temp2->KtOst),16,CURR_MAIN);
                                                                           );
                                                                        ),;
                                                                        "";
                                                                      ),;
                                              Len(cFormat)-1;
                                             );
                                             +"│";
                                       ),"" },;
                 3/*,12*/;
               };
             )
         AADD(aGroup,{"UPPER(Name+Code+IF(m->lNaim,Schet,''))",;
            ,;
            ,3/*,6,7,8,9,10,11,12*/})
         IF l50
            aHeads[1]+="─────────────────"
            aHeads[2]+="                 "
            aHeads[3]+="────────────────┬"
            aHeads[4]+="      "+cDt+"50      │"
            aHeads[5]+="────────────────┼"
            aHeads[6]+=PADC(STRTRAN(STR(i++,2,0),' ','0'),16)+"│"
            aHeads[7]+="────────────────┼"
            cFormat+=  "RRRRRRRRRRRRRRRR│"
            AADD(aFields,'Sum50')
            AADD(aGroup[2],LEN(aFields))
            nLen+=17
         ENDIF
         IF l51
            aHeads[1]+="─────────────────"
            aHeads[2]+="                 "
            aHeads[3]+="────────────────┬"
            aHeads[4]+="      "+cDt+"51      │"
            aHeads[5]+="────────────────┼"
            aHeads[6]+=PADC(STRTRAN(STR(i++,2,0),' ','0'),16)+"│"
            aHeads[7]+="────────────────┼"
            cFormat+=  "RRRRRRRRRRRRRRRR│"
            AADD(aFields,'Sum51')
            AADD(aGroup[2],LEN(aFields))
            nLen+=17
         ENDIF
         IF l52
            aHeads[1]+="─────────────────"
            aHeads[2]+="                 "
            aHeads[3]+="────────────────┬"
            aHeads[4]+="      "+cDt+"52      │"
            aHeads[5]+="────────────────┼"
            aHeads[6]+=PADC(STRTRAN(STR(i++,2,0),' ','0'),16)+"│"
            aHeads[7]+="────────────────┼"
            cFormat+=  "RRRRRRRRRRRRRRRR│"
            AADD(aFields,'Sum52')
            AADD(aGroup[2],LEN(aFields))
            nLen+=17
         ENDIF
         IF l76
            aHeads[1]+="─────────────────"
            aHeads[2]+="                 "
            aHeads[3]+="────────────────┬"
            aHeads[4]+="      "+cDt+"76      │"
            aHeads[5]+="────────────────┼"
            aHeads[6]+=PADC(STRTRAN(STR(i++,2,0),' ','0'),16)+"│"
            aHeads[7]+="────────────────┼"
            cFormat+=  "RRRRRRRRRRRRRRRR│"
            AADD(aFields,'Sum76')
            AADD(aGroup[2],LEN(aFields))
            nLen+=17
         ENDIF
         IF l60
            aHeads[1]+="─────────────────"
            aHeads[2]+="                 "
            aHeads[3]+="────────────────┬"
            aHeads[4]+=" "+cDt+"60 (бартер)  │"
            aHeads[5]+="────────────────┼"
            aHeads[6]+=PADC(STRTRAN(STR(i++,2,0),' ','0'),16)+"│"
            aHeads[7]+="────────────────┼"
            cFormat+=  "RRRRRRRRRRRRRRRR│"
            AADD(aFields,'Sum60')
            AADD(aGroup[2],LEN(aFields))
            nLen+=17
         ENDIF
         IF lI
            aHeads[1]+="─────────────────"
            aHeads[2]+="                 "
            aHeads[3]+="────────────────┬"
            aHeads[4]+="     Прочие     │"
            aHeads[5]+="────────────────┼"
            aHeads[6]+=PADC(STRTRAN(STR(i++,2,0),' ','0'),16)+"│"
            aHeads[7]+="────────────────┼"
            cFormat+=  "RRRRRRRRRRRRRRRR│"
            AADD(aFields,'SumI')
            AADD(aGroup[2],LEN(aFields))
            nLen+=17
         ENDIF
         aHeads[1]+="────────────────┐"
         aHeads[2]+="                │"
         aHeads[3]+="────────────────┤"
         aHeads[4]+="     Итого      │"
         aHeads[5]+="────────────────┤"
         aHeads[6]+=PADC(STRTRAN(STR(i++,2,0),' ','0'),16)+"│"
         aHeads[7]+="────────────────┤"
         cFormat+=  "RRRRRRRRRRRRRRRR│"
         nLen+=16
         aHeads[2]:=STUFF(aHeads[2],35,nLen,PADC('Оплачено',nLen))
         AADD(aFields,'Sum50+Sum51+Sum52+Sum76+Sum60+SumI')
         AADD(aHeader,CENTER(ALLTRIM(cHead),LEN(cFormat)))
         IF !m->lNaim
            AADD(aHeader,CENTER(ALLTRIM(cSch+' '+cAgentC+' '+(ANALIT->(dbSEEK(UPPER(cSch+cAgentC)),Name))),LEN(cFormat)))
         ELSE
            AADD(aHeader,CENTER(ALLTRIM(SH_FACT->Ag_Name),LEN(cFormat)))
         ENDIF
         AADD(aGroup[1],LEN(aFields))
         AADD(aGroup[2],LEN(aFields))
         AADD(aHeader,'')
      DbGoTop()
   END SEQUENCE

RETURN {aHeader,aFields,aHeads,cFormat,aTot,aGroup,lIsNum,bFoot}

STATIC FUNCTION RascetFF(n1,nRej)
LOCAL x1:=UPPER(Analit->(Name+Code)+DTOS(Main->DataOper)+Main->NNDoc+IF(m->lNaim,Analit->Schet,'')),;
      x2:=UPPER(Analit1->(Name+Code)+DTOS(Main->DataOper)+Main->NNDoc+IF(m->lNaim,Analit1->Schet,''))
LOCAL cDt_Schet, cKt_Schet, cDt_Code, cKt_Code, cAnalit, cAnalit1
SELECT Temp
IF nRej = 3
   cDt_Schet = Main->Kt_Schet
   cKt_Schet = Main->Dt_Schet
   cDt_Code = Main->Kt_Code
   cKt_Code = Main->Dt_Code
   cAnalit = 'Analit1'
   cAnalit1 = 'Analit'
ELSE
   cDt_Schet = Main->Dt_Schet
   cKt_Schet = Main->Kt_Schet
   cDt_Code = Main->Dt_Code
   cKt_Code = Main->Kt_Code
   cAnalit = 'Analit'
   cAnalit1 = 'Analit1'
ENDIF
IF (cDt_Schet=aIn0[30] .AND. (EMPTY(aIn0[31]).OR.UPPER(cDt_Code)=UPPER(aIn0[31]) )).OR. ;
   (m->lNaim.AND.;
    ASCAN(m->aAgents,{|x|UPPER(cDt_Schet+cDt_Code)==UPPER(x[1]+x[2])})>0.AND.;
    (aIn0[30] := cDt_Schet,;
     aIn0[31] := cDt_Code,;
     Analit->(DBSEEK(Main->(UPPER(cDt_Schet+cDt_Code)))),;
     .T.))
   ORDSETFOCUS(2)
   IF !DBSEEK(x1)
      IF (!m->lNaim.OR.EMPTY(dbSETFILTER({||Temp->Schet=(cAnalit)->Schet},'Temp->Schet=(cAnalit)->Schet')) ).AND.;
         !DBSEEK(UPPER((cAnalit)->(Name+Code)+DTOS(CTOD('  /  /  '))))
         AddRec()
         REPLACE Temp->Name WITH (cAnalit)->Name,Temp->Code WITH (cAnalit)->Code, Temp->Schet WITH (cAnalit)->Schet
      ELSE
         ORDSETFOCUS(1)
         IF !DBSEEK(UPPER((cAnalit)->(Name+Code+IF(m->lNaim,Analit->Schet,''))))
            AddRec()
            REPLACE Temp->Name WITH (cAnalit)->Name,Temp->Code WITH (cAnalit)->Code, Temp->Schet WITH (cAnalit)->Schet
         ENDIF
         WHILE !EMPTY(Date1)
            SKIP
         ENDDO
      ENDIF
      IF m->lNaim
         DBCLEARFILTER()
      ENDIF
   ENDIF
   REPLACE Temp->Date1 WITH Main->DataOper,;
   Temp->Num1 WITH Main->NNDoc,;
   Temp->Sum1 WITH Temp->Sum1+Main->Summa
ENDIF
IF (cKt_Schet=aIn0[30] .AND. (EMPTY(aIn0[31]).OR.UPPER(cKt_Code)=UPPER(aIn0[31]) )).OR.;
   (m->lNaim.AND.;
    ASCAN(m->aAgents,{|x|UPPER(cKt_Schet+cKt_Code)==UPPER(x[1]+x[2])})>0.AND.;
    (aIn0[30] := cKt_Schet,;
     aIn0[31] := cKt_Code,;
     Analit1->(DBSEEK(Main->(UPPER(cKt_Schet+cKt_Code)))),;
     .T.))
   Temp->(ORDSETFOCUS(3))
   IF !DBSEEK(x2)
      IF (!m->lNaim.OR.EMPTY(dbSETFILTER({||Temp->Schet=(cAnalit1)->Schet},'Temp->Schet=(cAnalit1)->Schet')) ).AND.;
         !DBSEEK(UPPER((cAnalit1)->(Name+Code))+DTOS(CTOD('  /  /  ')))
         AddRec()
         REPLACE Temp->Name WITH (cAnalit1)->Name,Temp->Code WITH (cAnalit1)->Code, Temp->Schet WITH (cAnalit1)->Schet
      ELSE
         ORDSETFOCUS(1)
         IF !DBSEEK(UPPER((cAnalit1)->(Name+Code+IF(m->lNaim,Analit1->Schet,''))))
            AddRec()
            REPLACE Temp->Name WITH (cAnalit1)->Name,Temp->Code WITH (cAnalit1)->Code, Temp->Schet WITH (cAnalit1)->Schet
         ENDIF
         WHILE !EMPTY(Date2)
            SKIP
         ENDDO
      ENDIF
      IF m->lNaim
         DBCLEARFILTER()
      ENDIF
   ENDIF
   REPLACE Temp->Date2 WITH Main->DataOper,;
   Temp->Num2 WITH Main->NNDoc
   DO CASE
      CASE LEFT(cDt_Schet,2)='50'
      REPLACE Temp->Sum50 WITH Temp->Sum50+Main->Summa
      l50:=.T.
      CASE LEFT(cDt_Schet,2)='51'
      REPLACE Temp->Sum51 WITH Temp->Sum51+Main->Summa
      l51:=.T.
      CASE LEFT(cDt_Schet,2)='52'
      REPLACE Temp->Sum52 WITH Temp->Sum52+Main->Summa
      l52:=.T.
      CASE LEFT(cDt_Schet,2)='76'
      REPLACE Temp->Sum76 WITH Temp->Sum76+Main->Summa
      l76:=.T.
      CASE LEFT(cDt_Schet,2)='60'
      REPLACE Temp->Sum60 WITH Temp->Sum60+Main->Summa
      l60:=.T.
      OTHERWISE
      REPLACE Temp->SumI WITH Temp->SumI+Main->Summa
      lI:=.T.
   ENDCASE
ENDIF
SELECT Main
RETURN(NIL)

******************
FUNCTION QuickBC(nRej,nRow,nCol,nOrd,NewColor,lNoSavePar,cPref,bPreSeek)
******************
//Функция для быстрого поиска по штрих-коду
// nRej - режим: 1 - выставить существующий режим
//               2 - изменить режим
//               3,NIL - осуществить поиск
//lNoSavePar - не сохранять параметры экрана и setkey (только для nRej=1)
// m->CurrModeBC 1,NIL- обычный режим
//               2 - режим быстрого поиска
// bPreSeek -блок для расчета значения поиска по базе. Параметр - ш-код
LOCAL cBCode := SPACE(13), oldOrd, oldRec
LOCAL aSetKey,cScreen, lFound :=.F., cPoisk
LOCAL aScope := GetScope(), bScope:=ScopeBlock(ORDNAME()),;
      bForIndex := &('{||'+IIF(!EMPTY(OrdFor()),OrdFor(),".T.")+'}')
//LOCAL bPreSeek_ := bPreSeek
STATIC cScr, aKey0_9[10]
IF TYPE('CurrModeBC') # 'N'
   PUBLIC CurrModeBC
ENDIF
DO CASE
   CASE nRej = 1
      IF EMPTY(lNoSavePar)
         m->CurrModeBC = 1
         m->CurrModeBC:= SaveVar("CurrModeBC","РЕЖИМ ПОИСКА ПО ШТРИХ-КОДУ",IDENT_USER)
         aEVAL(aKey0_9,{|x,i|aKey0_9[i]:=SETKEY(ASC(STR(i-1,1)))})
         cScr = SAVESCREEN(nRow,nCol,nRow,nCol+26)
         SETKEY(K_F11,{||QuickBC(2,nRow,nCol,nOrd,NewColor,,cPref,bPreSeek)})
      ENDIF
      IF m->CurrModeBC = 2
         aEVAL(aKey0_9,{|x,i|SETKEY(ASC(STR(i-1,1)),{||QuickBC(,nRow,nCol,nOrd,NewColor,,cPref,bPreSeek)})})
         @nRow,nCol SAY 'Поиск по ш/к:' COLOR NewColor
      ELSE
         aEVAL(aKey0_9,{|x,i|SETKEY(ASC(STR(i-1,1)),x)})
         RESTSCREEN(nRow,nCol,nRow,nCol+26,cScr)
      ENDIF
   CASE nRej = 2
      IF m->CurrModeBC = 2
         m->CurrModeBC = 1
      ELSE
         m->CurrModeBC = 2
      ENDIF
      SaveVar("CurrModeBC","РЕЖИМ ПОИСКА ПО ШТРИХ-КОДУ",IDENT_USER,,,.T.)
      QuickBC(1,nRow,nCol,nOrd,NewColor,'не сохраняя',cPref,bPreSeek)
   OTHERWISE
      aSetKey:=SaveSetKey()
      cScreen:=SAVESCREEN()
      PRIVATE GETLIST := {}
      KEYBOARD CHR(LASTKEY())
      @nRow,nCol + 13 GET cBCode PICTURE '9999999999999' COLOR "W+/N"
      SET CURSOR ON
      READ
      SET CURSOR OFF
      IF LASTKEY() # K_ESC
         oldOrd := ORDSETFOCUS(nOrd)
         oldRec := RECNO()
         SetScope()
         IF VALTYPE(bPreSeek) ='B'
            cPoisk:=EVAL(bPreSeek,cBCode)
         ELSE
            cPoisk := UPPER(IF(cPref=NIL,'',&(cPref))+cBCode)
         ENDIF
         IF !dbSEEK(cPoisk) .OR. (dbEval({||lFound:=.T.},;
                                                {||(VALTYPE(bForIndex)#'B'.OR. EVAL(bForIndex)).AND.(VALTYPE(bScope)#'B'.OR.EVAL(bScope))},;
                                                {||cPoisk=UPPER(LEFT(&(IndexKey()),LEN(cPoisk))).AND.!lFound}),;
                                  dbSKIP(-1),!lFound)
            SAYERROR('Штрих-код не найден')
            dbGOTO(oldRec)
         ENDIF
         SetScope(aScope)
         ORDSETFOCUS(oldOrd)
      ENDIF
      RestSetKey(aSetKey)
      RESTSCREEN(,,,,cScreen)
ENDCASE

RETURN NIL

/*******************************
*   _BRaznos () --> NIL
*
*/
/*
FUNCTION  _BRaznos(x,aBookNds,cSelBook)
    //LOCAL
    IF  x[3]=aBookNds[1,1].AND.x[5] = (cSelBook)->TEK_DATA
    ENDIF

RETURN NIL  // from  func _BRaznos
*/

/*******************************
*   _RROUND () --> NIL
*
* Замена обычного ROUND'а, т.к. он не всегда правильно округлял :(((
*
*/
FUNCTION  _RROUND(n,d)
    LOCAL nOkr,c,c1,c2
    c:=ALLTRIM(STR(n))
    c:=IF(AT(".",c)=0,RTRIM(c)+'.',c)
    c1:=SUBSTR(c,1,AT(".",c)+d)
    IF  VAL(SUBSTR(c,AT(".",c)+d+1,1)) >= 5
        /*
        c2:=ALLTRIM(STR( VAL( SUBSTR(c1,AT(".",c1)+d,1) )+1 ))
        c1:=STUFF(c1,AT(".",c1)+d,1,c2)
        */
        c2:=VAL(c1)+IF(n>0,1,-1)*10^-d
    ELSE
        c2:=VAL(c1)
    ENDIF
    //nOkr:=VAL(c1)
RETURN c2/*nOkr*/  // from  func _RROUND


//----------------------------------------------------------------------------//
     FUNCTION InfoUser()
//----------------------------------------------------------------------------//


#ifndef __HARBOUR__

LOCAL ;
aString := {;
 "Свободное количество дескрипт : "+NTOC(FilesFree()),;
 "Кол-во открытых файлов        : "+NTOC(FilesMax()-FilesFree()),;
 'SYSTEM BUFFERS                : '+STR(NUMBUFFERS(),6,0),;
 'Основная память,Кб            : '+STR(MEMSIZE(.F.),6,0),;
 'Расширенная память,Кб         : '+STR(MEMSIZE(.T.),6,0),;
 'Всего памяти свободно,Кб      : '+STR(MEMORY( 0 ), 6,0),;
 'Непрерывно память,Кб          : '+STR(MEMORY( 1 ), 6,0),;
 'Свободная память для  RUN,Кб  : '+STR(MEMORY( 2 ), 6,0),;
 'Кол-во свободных байт стека   : '+STR(STACKFREE(), 6,0);  //,;
 ;  //'Всего свободно памяти,Кб      : '+STR(BLIMEMAVL()/1024, 6,0),;
 ;  //'Свободно непрерывной памяти,Кб: '+STR(BLIMEMMAX()/1024, 6,0),;
 ;  //'Размер оверлейной области,Кб  : '+STR(BLIOVLOPS()/1024, 6,0),;
 ;  //'Текущая ошибка BLINKER        : '+STR(BLIERRNUM(), 6,0),;
 ;  //'DOS extender host is          : '+{"DPMI","VCPI","XMS"}[BLIMGRSTS(4)];
            }
//LOCAL cVar := ENVPARAM()

//TOKENINIT(@cVar,CHR(13)+CHR(10),2)
//DO WHILE ! TOKENEND()
 //AADD(aString,TOKENNEXT(@cVar))
//ENDDO
//AEVAL(aString,{|x,y| aString[y] := PADR(x,60) })
NoOrYes(aString, 1, {" Продолжение - любая клавиша "},,,COL_BROWSE,,.T.)

#endif


RETURN NIL

//#include "sclad\mkr_mdl.prg"
// azat 29.10.2005
//--------------------------------------------------------------------------//
//    PROCEDURE MakeModel(cNameRef,nTypeRef,cNameCode,cSourceCode,cSeekModel,cTag)
//--------------------------------------------------------------------------//
// Рефер моделей калькуляции

//----------------------------------------------------------------------------//
                     PROCEDURE dbSaveBases()
//----------------------------------------------------------------------------//
// Закрытие всех баз с сохранением информации для открытия dbRestBases()
LOCAL aBase := {}, aPush := {}, aTPush := DBPush(,,,,,,,.T.)
LOCAL i := 1, cNameDbf
Busy(.T.,"Сохранение окружения")
FOR i := 1 TO 255
 IF !EMPTY(ALIAS(i))
   SELECT (i)
   #ifdef SIX
     cNameDbf := ALLTRIM(UPPER(Sx_TableName()))
   #else
     #IFDEF CDX
       cNameDbf := ALLTRIM(UPPER(dbInfo(10)))
     #ELSE
       cNameDbf := ALLTRIM(UPPER(Ax_TableName()))
     #ENDIF
   #endif
   AADD(aBase,{ALIAS(),cNameDbf})
   AADD(aPush,DBPush(,,,,,,,.T.))
 ENDIF
NEXT
Busy(.F.)
AADD(aSaveBase,{aBase,aPush,aTPush})
COMMIT
CLOSE ALL
RETURN
//----------------------------------------------------------------------------//
                     PROCEDURE dbRestBases(lSave)
//----------------------------------------------------------------------------//
LOCAL aBase := ATAIL(aSaveBase)[1]
LOCAL cScr := BrSaveScreen()
CLOSE ALL
ScrTitul(MaxRow()-1,"")
Busy(.T.,"Восстановление окружения")
dbOpenBases(aBase,,,,.T.)
AEVAL(ATAIL(aSaveBase)[2],{|x,n| (aBase[n,1])->(dbPop(,x)) })
dbPop(,ATAIL(aSaveBase)[3])
If EMPTY(lSave)
  ASIZE(aSaveBase,LEN(aSaveBase)-1)
endif
Busy(.F.)
BrRestScreen(cScr)
RETURN

*
/*******************************
*   IsDateOut () --> NIL
*
*/
FUNCTION IsDateOut(dDate,lSay,nAdd)
    LOCAL dMaxDate,cOldAlias

   // IF !EMPTY(dDate).AND.LASTKEY()#K_F4.AND.!A3MaxDate(dDate)
 //       RETURN .T.
 //   ENDIF

    PRIVATE dDateGlob:=CTOD("")
    IF  _ROZNICA.OR./*EMPTY(Global_Set[2]).OR.*/!(GlobalTask$'0309TZ05').OR.(nAdd<>NIL.AND.nAdd=2)
        RETURN .F.
    ENDIF
    cOldAlias:=ALIAS()
    IF  SELECT("MEMDAT")=0
        NetUse("MEMDAT","MEMDAT")
    ENDIF
    dDateGlob:=MEMDAT->(SaveVar("dDateGlob",,GlobalTask+"УПРАВЛЕНИЕ ОП.ПЕРИОДОМ"))
    IF  GlobalTask=="TZ"
        NetUse("_MEMDAT",LoadPath()+"SCLAD\MEMDAT.DBF")
        dDateGlob:=SaveVar("dDateGlob",,"03УПРАВЛЕНИЕ ОП.ПЕРИОДОМ",,"_MEMDAT")
        _MEMDAT->(DBCLOSEAREA())
        _DATE_CNTRL:=CTOD("")
        IF  FILE(_PRO_PATH+'LOGIN.PRO').AND.NetUse("_LOGIN",_PRO_PATH+"LOGIN.PRO")
            LOCATE FOR FIELD->TYPE_ARM=="03".AND._FIRM_CODE==LBL_CODE.AND.Global_Set[2]==CODE
            IF  FOUND()
                _DATE_CNTRL:=FIELD->DATE_CNTRL
            ENDIF
        ENDIF
    ENDIF
    DBSELECTAREA(cOldAlias)
    IF  EMPTY(Global_Set[2])         //Авторизация выключена
        IF  EMPTY(dDateGlob)
            RETURN .F.
        ELSE
            dMaxDate:=MAX(iSCL_BEG,dDateGlob)
            IF  dDate >= dMaxDate
                RETURN .F.
            ELSE
                IF  lSay<>NIL
                    SayError({"По АРМу разрешена модификация данных с",DTOC(dMaxDate)})
                ENDIF
                RETURN .T.
            ENDIF
        ENDIF
    ELSE
        IF  EMPTY(_DATE_CNTRL).AND.EMPTY(dDateGlob)
            RETURN .F.
        ELSE
            dMaxDate:=MAX(iSCL_BEG,MAX(_DATE_CNTRL,dDateGlob))
            IF  dDate >= dMaxDate
                RETURN .F.
            ELSE
                IF  lSay<>NIL
                    SayError({"Оператору "+Global_Set[2]+" разрешена модификация данных с",DTOC(dMaxDate)})
                ENDIF
                RETURN .T.
            ENDIF
        ENDIF
    ENDIF
RETURN .F.  // from  func IsDateOut

******************
FUNCTION SetOplKass()
******************
//Проставляет оплату по чеку
LOCAL cFile := GetNameOplChek()
IF !EMPTY(cFile).AND. FILE(cFile)
   IF RecLock()
      REPLACE FIELD->Summa0 WITH ROUND(FIELD->SumOut+IF(FIELD->L_NDS,0,FIELD->SUM_NDS)+IF(FIELD->L_ACZ,0,FIELD->SUM_ACZ)+IF(FIELD->L_CSH,0,FIELD->SUM_CSH),3)
      REPLACE Date0 WITH MAX(FIELD->Date,Date()), PayType WITH 'Касса'
      FERASE (cFile)
   ENDIF
   UNLOCK
ENDIF

RETURN .T.

******************
FUNCTION GetNameOplChek(Rej,cNum)
******************
//rej =0!NIL - оплачено CSH
//     1 - передано dbf!txt
//     2 - в работе wrk
//     3 - только dbf
LOCAL cFile,n,aExtChek,nExt_,cPath
IF rej = NIL
   rej = 0
ENDIF
IF EMPTY(cNum)
   cNum:=STRTRAN(FIELD->NumDoc,' ','_')
ENDIF
IF (TKassa->CodeKassa = m->TypeKassCh .OR. TKassa->(dbSEEK(UPPER(m->TypeKassCh)))) .AND. ;
   !EMPTY(m->PathChek) .AND. !EMPTY(TKassa->FChek)
   IF TKassa->(FieldPos('ExtChek')>0).AND. !EMPTY(TKassa->ExtChek)
      aExtChek:=TKassa->ExtChek
   ELSE
      aExtChek:={;
                  {'DBF','WRK','CSH'},;
                  {'TXT','WRK','CSH'}}
   ENDIF
   IF m->TypeFChek = 1
      nExt_:=aSCAN(aExtChek,{|x|UPPER(x[1])='DBF'})
   ELSE
      nExt_:=aSCAN(aExtChek,{|x|UPPER(x[1])#'DBF'})
   ENDIF
   IF EMPTY(nExt_)
      nExt_:=1
   ENDIF
   IF (n:=AT('.',TKassa->FChek))>0
      cFile:=LEFT(TKassa->FChek,n)+IF(Rej=0,aExtChek[nExt_,3],IF(Rej=1,aExtChek[nExt_,1],IF(Rej=3,'DBF',aExtChek[nExt_,2])))
   ELSE
      cFile:=TKassa->FChek+'.'+IF(Rej=0,aExtChek[nExt_,3],IF(Rej=1,aExtChek[nExt_,1],IF(Rej=3,'DBF',aExtChek[nExt_,2])))
   ENDIF
   cPath:=ALLTRIM(m->PathChek)
   RETURN cPath+If(Right(cPath,1)=='\','','\')+alltrim(STRTRAN(cFile,'~',cNum))
ENDIF
RETURN ''

*
FUNCTION UprOperPer()
    LOCAL cOldDate:=SET(_SET_DATEFORMAT)
    LOCAL bEnter:=SETKEY(K_ENTER,NIL)
    LOCAL bAltO:=SETKEY(K_ALT_O,NIL)
    LOCAL GetList:={},cScr:=SAVESCREEN(),nLen:=35,nLeft
    LOCAL cOldAlias
    LOCAL bakHelp := m->HELP_CODE
    PRIVATE dDate:=CTOD("")

    SETKEY(K_ALT_O,{||OperPerOper()})

    nLeft:=INT( MaxCol()/2 - nLen/2 - 1 )
    DBPUSH()
    //cOldAlias:=ALIAS()
    IF  SELECT("MEMDAT")=0.AND.!NetUse("MEMDAT","MEMDAT")
        RETURN NIL
    ENDIF
    SET DATE FORMAT TO "dd/mm/yyyy"
    dDate:=SaveVar("dDate",,GlobalTask+"УПРАВЛЕНИЕ ОП.ПЕРИОДОМ")
    ScrMain()
    ScrTitul( 24, 'ALT_O:По операторам' )
    ShadowBox(" Управление оперативным периодом ",9,nLeft,13,nLeft+nLen+1,COL_HEADR)
    @ 11,nLeft+7 SAY "Дата начала" COLOR COL_HEADR GET dDate COLOR "W+/N"
    m->HELP_CODE := '7.2.5'
    SETCURSOR(1)
    READ
    m->HELP_CODE := bakHelp
    IF  LASTKEY()<>K_ESC
        SaveVar("dDate",,GlobalTask+"УПРАВЛЕНИЕ ОП.ПЕРИОДОМ",,,.T.)
    ENDIF
    SETCURSOR(0)
    SET DATE FORMAT TO cOldDate
    SETKEY(K_ENTER,bEnter)
    SETKEY(K_ALT_O,bAltO)
    RESTSCREEN(,,,,cScr)
    MEMDAT->(DBCLOSEAREA())
    //DBSELECTAREA(cOldAlias)
    DBPOP()
RETURN NIL

FUNCTION OperPerOper()
    LOCAL aSet := {SaveSetKey()}
    LOCAL nTop:= 6,nLeft,nBottom := 18,nRight
    LOCAL sEnter, sTab, cSel:=SELECT()
    LOCAL bField  := {||" "+FIELD->CODE+" "}
    LOCAL cFile,cOldColor,cScr:=SAVESCREEN(),aBlockCols

    //DBPUSH()
    cFile :=TEMPFILE(_TMP_DIR,"CDX")

    IF  !NetUse ( "USER_PRO",_PRO_PATH+'USER.PRO')
        SayAndWait( {'Справочник операторов заблокирован в сети!'} )
        RETURN NIL
    ENDIF
    IF  EOF()
        SayError("Справочник операторов пуст!")
        RETURN NIL
    ENDIF
    INDEX ON CODE TO &(cFile) FOR !DELETED()
    IF  !NetUse ( "LOGIN",_PRO_PATH+"LOGIN.PRO" )
        SayAndWait( {'Справочник прав доступа заблокирован в сети!'} )
        RETURN NIL
    ENDIF
    SET RELATION TO CODE INTO USER_PRO
    SET FILTER TO LOGIN->TYPE_ARM==GlobalTask.AND.;
                  _FIRM_CODE==LOGIN->LBL_CODE.AND.!DELETED()
    DBGOTOP()

    ScrMain()
    //ScrTitul(  1, 'ИМПОРТ ДАННЫХ' )
    ScrTitul( 24, 'ENTER:Корректировка даты' )
    SETBLINK(.F.)
    //cOldColor:=SetColor('GR+/B*,W+/N,,,W+/B*')
    cOldColor:=SetColor(COL_HEADR)
    nLeft  := INT( MaxCol()/2 - 45/2 - 1 )
    nRight := nLeft+45+1
    aBlockCols := {;
                    {{||LOGIN->CODE},nLeft+2},;
                    {{||USER_PRO->NAME},nLeft+9},;
                    {{||RIGHT(DTOS(LOGIN->DATE_CNTRL),2)+"/"+SUBSTR(DTOS(LOGIN->DATE_CNTRL),5,2)+"/"+LEFT(DTOS(LOGIN->DATE_CNTRL),4)},nLeft+35};
                  }
    ShadowBox(" Начало оперативного периода по операторам ",nTop, nLeft, nBottom, nRight)
    sEnter := SetKey(K_ENTER,{||EditPerDate(nLeft+35)})

    QBrowse(nTop+2,nLeft+1,nBottom-2,nRight-1,aBlockCols,'GR+/B*,W+/N,,,W+/B*',{||CurProc(nBottom,nLeft,nRight)} )
    SetKey( K_ENTER, sEnter )

    SETCOLOR(cOldColor)
    RESTSCREEN(,,,,cScr)
    USER_PRO->(DBCLOSEAREA())
    LOGIN->(DBCLOSEAREA())
    FERASE(cFile)
    RestSetKey(aSet[1])
    SELECT (cSel)
    //DBPOP()
RETURN NIL

STATIC FUNCTION CurProc(nBottom,nLeft,nRight)
   //@ nBottom - 2, nLeft + 27 SAY PadR(LST->PATH_OUT, nRight-nLeft-28) COLOR 'W+/B*'
   //@ nBottom - 1, nLeft + 27 SAY PadR(LST->PATH_IN, nRight-nLeft-28) COLOR 'W+/B*'
Return NIL

STATIC FUNCTION EditPerDate(nLeft)
    LOCAL aSet := {SaveSetKey()}
    LOCAL dDate:=LOGIN->DATE_CNTRL
    LOCAL cOldDate:=SET(_SET_DATEFORMAT)
    LOCAL bEnter:=SETKEY(K_ENTER,NIL)
    LOCAL GetList:={}

    SET DATE FORMAT TO "dd/mm/yyyy"
    @ ROW(),nLeft GET dDate /*PICTURE "D"*/ COLOR "W+/N"
    SETCURSOR(1)
    READ
    IF  LASTKEY()<>K_ESC.AND.LOGIN->(RecLock())
        LOGIN->DATE_CNTRL:=dDate
        IF  LOGIN->CODE==_USER_CODE
            _DATE_CNTRL:=dDate
        ENDIF
        LOGIN->(DBUNLOCK())
    ENDIF
    SETCURSOR(0)
    SET DATE FORMAT TO cOldDate
    SETKEY(K_ENTER,bEnter)
    RestSetKey(aSet[1])
RETURN NIL

******************
FUNCTION GetCenSpCon(lFromMas,cMat)
******************
LOCAL xKey1, cDate1,nRec:=MDocm->(RECNO()), lDate1 := .T., cRet:=0
LOCAL nRecL:=MLabel->(RecNo()), nRecS:=SPR_Part->(Recno())
IF pVid+pType=='17'
   IF lFromMas = NIL
      MDOCM->(xKey1  := UPPER(Sclad1+'23'+CodeDoc1+NumDoc1+Grup+NNum+Partia+Schet_A+AgentCode))
      cDate1 := MDOCM->Date1
   ELSE
      MDOCM->(xKey1  := UPPER(SUBSTR(cMat,P_SCLAD1,6)+'23'+SUBSTR(cMat,P_CODEDOC1,3)+SUBSTR(cMat,P_NUMDOC1,6)+SUBSTR(cMat,P_GRUP,L_GRUP)+SUBSTR(cMat,P_NNUM,L_NNUM)+SUBSTR(cMat,P_PARTIA,L_PARTIA)+MCodOp->Schet_A+pAgentCode))
      cDate1 := CTOD(SUBSTR(cMat,P_DATE1,L_DATE1))
   ENDIF
   dbPush('MDocM','MDocM_W','','')
   lDate1 := .T.
   IF DBSEEK(xKey1)
      Do While UPPER(Sclad+Vid+Type+CodeDoc+NumDoc+Grup+NNum+Partia+Schet_A+AgentCode)=xKey1
         if cDate1=Date
            lDate1:=.F.
            EXIT
         endif
         DbSkip()
      EndDo
      if !lDate1
         cRet := MDocM->Cena0
      endif
   ENDIF
   dbPop();MDocM->(dbGOTO (nRec))
   MLabel->(dbGoto(nRecL))
   SPR_PART->(dbGoto(nRecS))
ENDIF
RETURN cRet
//--------------------------------------------------------------------------//
                  FUNCTION GetUser(cIdent)
//--------------------------------------------------------------------------//
// Возаращает значения из Global_Set
DO CASE
   CASE cIdent = "КОД ОПЕРАТОРА"
     RETURN _USER_CODE
   CASE cIdent = "ФАМИЛИЯ ОПЕРАТОРА"
     RETURN _USER_NAME
ENDCASE
RETURN ""

//----------------------------------------------------------------------------//
                     FUNCTION MSeek(cAlias,cTag,cKey,bPreKey)
//----------------------------------------------------------------------------//
// Поиск при неизвестной старшей части ключа [EVAL(bPreKey)]+cKey
// по базе cAlias с тэгом cTag
// Ключ только символьного типа !!
LOCAL bakSelect := SELECT(), lRet := .F., bakTag, nRec

SELECT (cAlias)
bakTag := ORDSETFOCUS(cTag)
dbGoTop()
IF bPreKey = NIL
 lRet := dbSeek(UPPER(cKey))
ELSE
  WHILE !EOF()
    nRec := RECNO()
    IF (lRet := dbSeek(UPPER(EVAL(bPreKey)+cKey)))
      EXIT
    ENDIF
    dbGoTo(nRec)
    dbSeek(UPPER(LEFT(EVAL(bPreKey),LEN(EVAL(bPreKey))-1)+CHR(ASC(IF(RIGHT(EVAL(bPreKey),1)#'Я',RIGHT(EVAL(bPreKey),1),CHR(239)))+1)),.T.)
  END
ENDIF
ORDSETFOCUS(bakTag)
SELECT (bakSelect)

RETURN lRet

******************
FUNCTION ProvToOc(nAdd,cSclad,cVid,cType,cCodeDoc,cNumDoc,cNumOC,lNoUst)
******************
LOCAL lRes := .T.
IF nAdd = S_LIB_ADD
   lRes:=.T.
ELSE
   COC_BUF->(dbPush(,'Tag_Doc',,{'UPPER(TASK+Sclad+Vid+Type+CodeDoc+NumDoc)',UPPER(m->GlobalTask+cSclad+cVid+cType+cCodeDoc+cNumDoc)}))
   DO WHILE  COC_BUF->( !EOF())
      IF COC_BUF->State = '1' .OR. COC_BUF->State = '2'.OR. COC_BUF->State = '3'
         cNumOC := COC_BUF->OCNNDoc
         lRes := .F.
         EXIT
      ENDIF
      COC_BUF->(dbSKIP())
   ENDDO
   IF lRes .AND. lNoUst=NIL
      COC_BUF->(dbGOTOP())
      DO WHILE  COC_BUF->( !EOF())
         IF COC_BUF->(RECLOCK())
            COC_BUF->State := '9'
            COC_BUF->(dbUnLock())
         ENDIF
         COC_BUF->(dbSKIP())
      ENDDO
   ENDIF
   COC_BUF->(dbPop())
ENDIF

RETURN lRes

******************
FUNCTION GetSumNal(nCena,nKol,lVvod,lAGrup)     // victor спецодежда
******************
//  Корректировка налоговой суммы и цены
//nCena = NIL - вызов из документа
//nKol = NIL - не выводить строку суммы
//lvvod - разрешать ввод или нет
LOCAL lIzm:=.F.    // victor спецодежда
PRIVATE aSet := {SaveSetKey(),SaveSet()}, lSumN:=(nCena=NIL .OR. nKol # NIL), lDoc:=.F.
PRIVATE nSum
IF !EMPTY(lAGrup).AND. TYPE('pA_Grup')='C'  // victor спецодежда if
   lAGrup:=.T.
ELSE
   lAGrup:=.F.
ENDIF
IF nCena = NIL
   nKol:=aIn[5]
   nSum := m->nSumN
   lDoc:=.T.
   nCena := DIV(nSum,nKol)
ELSEIF nKol # NIL
   nSum := nCena*nKol
ELSE
   nSum:=0
ENDIF

PRIVATE GetList :={},aInN :={m->nSum,nCena,IF(lAGrup,m->pA_Grup,NIL),IF(TYPE('m->cSchetZMN')='C',m->cSchetZMN,NIL),IF(TYPE('m->cZCodeMN')='C',m->cZCodeMN,NIL)} // victor спецодежда
IF lVvod = NIL
   lVvod:=(pVid=='1')
ENDIF
FRAME("Налоговый учет",7,46,IF(lAGrup,15,13-IF(pVid+pType = '26' .AND. GlobalTask='09',0,2)),IF(lAGrup,78,73),COL_SHEADR,2,.T.,.T.)  // victor спецодежда
IF lSumN
   @ 9,48 SAY 'Стоимость';       // victor спецодежда
       COLOR COL_SHEADR;
       GET aInN[1];
       PICTURE SummaPic(CURR_MAIN,L_SUM);
       COLOR IF(lVvod,COL_GET,COL_SHEADR);
       WHEN lVvod;
       VALID {||aInN[2]:=DIV(aInN[1],nKol),GetList[2]:display(),.T.}
ENDIF
@10,48 SAY 'Цена     ';   // victor спецодежда
          COLOR COL_SHEADR;
          GET aInN[2];
          PICTURE SummaPic(5,L_SUM);
          COLOR IF(lVvod,COL_GET,COL_SHEADR);
          WHEN lVvod;
          VALID {||IF(!lSumN.OR.aInN[2]=0 ,NIL,(aInN[1]:=ROUND(aInN[2]*nKol,CURR_MAIN),GetList[1]:display())),.T.}
IF pVid+pType = '26' .AND. GlobalTask='09' .AND. TYPE('m->cSchetZMN')='C'
   Plan->(MakeSchetRefer('PlanZMN','aInN[4]',2))
   @ 11,48 SAY 'Счет затрат' COLOR COL_SHEADR GET aInN[4]  PICT _PIC_SCHET COLOR COL_GET
   GetList[LEN(GetList)]:reader := {|get|ReferGetReader(get,'PlanZMN')}
   GetList[LEN(GetList)]:preblock := {|| /*LinMetod(aIn[13],'налог',aInN[2],pDate).AND.*/ (IF(EMPTY(aInN[4]).AND. !EMPTY(m->pSchetZN),(aInN[4]:=m->pSchetZN,aInN[5]:=m->pZCodeN),NIL),.T.)}

   ANALIT->(SAnalit( "AnalZN", "aInN[5]", 2,"F2:Спpавочник "))
   @12,48 SAY 'Шифр затрат' COLOR COL_SHEADR ;
            GET aInN[5]  COLOR COL_GET
   GetList[LEN(GetList)]:reader := {|get|ReferGetReader(get,'AnalZN')}
   GetList[LEN(GetList)]:preblock := {||/*LinMetod(aIn[13],'налог',aInN[2],pDate) .AND.*/ (SaveLoadType(aInN[4]),PLAN->(dbSeek(UPPER(aInN[4]))),PLAN->ANALIT_Y_N)}
ENDIF
IF lAGrup   // victor спецодежда if

   OC_AG->(MakeRefer('A_Grup',"Справочник амортизационных групп",3,;
   {"Код","Наименование"},{4,40,10},COL_REFER,{"Code"},{"aInN[3]"},;
   "UPPER(aInN[3])",{{||Code},{||Name}},;
   {;
         {'- кодам            ','Код?:','Code','UPPER(TRIM(aIn[1]))',,,,'Code'},;
         {'- наименованиям    ','Наименование?:', 'LEFT(Name,10)','UPPER(TRIM(aIn[1]))',,,,'Name'}},;
   ,,,,,,,,,,,,,,,;
   'cFind$UPPER(TRIM(Name))','Code'))
   @13,48 SAY 'Амортиз. группа  ';
             COLOR COL_SHEADR;
             GET aInN[3];
             PICTURE 'XXXXXX';
             COLOR COL_GET;
             VALID  {||  OC_AG->(dbSEEK(UPPER(aInN[3]))),;
                         SETPOS(14,48),DISPOUT(OC_AG->Name,COL_NCC4),;
                         SETPOS(13,66),;
                         .T. }
   GetList[IF(lSumN,5,4)]:reader:={|oGet| ReferGetReader(oGet,"A_GRUP") }
   GetList[LEN(GetList)]:preblock := {|| LinMetod(aIn[13],'налог',aInN[2],pDate)}
   OC_AG->(dbSEEK(UPPER(aInN[3])))
   SETPOS(14,48)
   DISPOUT(OC_AG->Name,COL_NCC4)
ENDIF
READ
IF LASTKEY()=K_CTRL_N   //!lVvod .AND. !lAGrup  // victor спецодежда
   SET CURSOR OFF
   INKEY(0)
   SET CURSOR ON
ELSE
   IF LASTKEY()#K_ESC
      IF lDoc
         IF m->nSumN#aInN[1]
            m->nSumN:=aInN[1]
            IF TYPE('SNal')='N'
               m->SNal:=aInN[1]
            ENDIF
            IF TYPE('pUpdated')='L'
               m->pUpdated:=.T.
            ENDIF
            lIzm:=.T.
         ENDIF
      ELSE
         nCena := aInN[2]
      ENDIF
      IF TYPE('lHandSumNal')='L'
         m->lHandSumNal:=.T.
      ENDIF
      IF pVid+pType = '26' .AND. GlobalTask='09' .AND. TYPE('m->cSchetZMN')='C'
         IF m->cSchetZMN#aInN[4]
            m->cSchetZMN := aInN[4]
            IF TYPE('pUpdated')='L'
               m->pUpdated:=.T.
            ENDIF
            lIzm:=.T.
         ENDIF
         IF m->cZCodeMN#aInN[5]
            m->cZCodeMN := aInN[5]
            IF TYPE('pUpdated')='L'
               m->pUpdated:=.T.
            ENDIF
            lIzm:=.T.
         ENDIF
      ENDIF
      IF lAGrup                // victor спецодежда  if
         IF m->pA_Grup#aInN[3]
            m->pA_Grup := aInN[3]
            IF TYPE('pUpdated')='L'
               m->pUpdated:=.T.
            ENDIF
         ENDIF
      ENDIF
      IF lIzm
         m->pUpdateSON:=.T.
         //PutDateAm(.F.,.T., MDocM->Date )
      ENDIF
   ENDIF
ENDIF
RestSetKey(aSet[1])
RestSet(aSet[2])
RETURN .T.

******************
FUNCTION IsklNalog()
******************
// Файл появляется при апгрeйде с версии, не имеющей налогового учета и
// остается до первого расчета налоговой с/c
RETURN FILE(LoadPath()+'UPGRN.TXT')
//-----------------------------------------------------------------------------//
FUNCTION MakeMOperRefer(cRefer,aDest,nTypeRefer,cHelp,cKeyVal,cSoAlias,bTypeOper)
//-----------------------------------------------------------------------------//
//  Справочник операций
LOCAL bCoProc, bPreDisp, bPostDisp, cAlias, nTop := 17, nBottom := 22, nLeft := 3, nBTop, cScr
LOCAL aIns := {'CODE'}
LOCAL aHeadsCol := {" Код ","Наименование                                    "}
LOCAL aBlockCol := {{||FIELD->CODE},{|| LEFT(FIELD->NAME,47) }}, bOrdKey
nTypeRefer:=IF(nTypeRefer==NIL,1,nTypeRefer)
bOrdKey := &("{||"+ORDKEY()+"}")
bPreDisp := {|| dbPush(,,,{ORDKEY(),EVAL(bTypeOper),,.F.,{ORDNAME()}}),cScr := SaveScreen() }
bCoProc := {|| FRAME("[ Проводки ]",nTop,nLeft,nBottom,MaxCol()-nLeft,COL_REFER,1,.T.),;
               SetPos(nTop+1,nLeft+1),;
               DispOut(PADC("Дт",_LEN_SCHET)+"   Шифр "+PADC("Кт",_LEN_SCHET)+"   Шифр  Содержание проводки  Формула",COL_REFER),;
               nBTop := nTop+1,;
               cAlias := ALIAS(),;
               (cSoAlias)->(dbSeek(EVAL(bTypeOper)+UPPER((cAlias)->CODE)),;
                            DBEVAL({|| nBTop++,SetPos(nBTop,nLeft+1),;
                                       DispOut(" "+LEFT(FIELD->DT_SCHET,_LEN_SCHET)+" "+FIELD->DT_CODE+" "+LEFT(FIELD->KT_SCHET,_LEN_SCHET)+" "+FIELD->KT_CODE+" "+LEFT(FIELD->NAME,20)+" "+LEFT(FIELD->ALGORITM,33-_LEN_SCHET*2),COL_REFER) },,{|| EVAL(bOrdKey) = EVAL(bTypeOper)+UPPER((cAlias)->CODE)  .AND. nBTop < nBottom - 1 })) }
bPostDisp := {|| dbPop(.T.),RestScreen(,,,,cScr) }
MakeRefer(cRefer, "[ Справочник операций ]", nTypeRefer, aHeadsCol, {3,8,7},COL_REFER,aIns,aDest,cKeyVal,aBlockCol,{{"- по коду ", "Код :","CODE",STRTRAN(ORDKEY(),"CODE","aIn[1]"),"@K"}},,,,,,bPreDisp,bPostDisp,,,,cHelp,bCoProc,,,,"AllStringBases(cFind)")
RETURN (NIL)

******************
FUNCTION GetFIFOLIFO(lNaim)
******************
LOCAL res := ''
IF TYPE('nPorSpis')='N' .AND. m->nPorSpis = 1
   IF EMPTY(lNaim)
      res = 'F'
   ELSE
      res = 'ФИФО'
   ENDIF
ELSEIF TYPE('nPorSpis')='N' .AND. m->nPorSpis = 2
   IF EMPTY(lNaim)
      res = 'L'
   ELSE
      res = 'ЛИФО'
   ENDIF
ENDIF

RETURN res

******************
FUNCTION TochKol(cEd,cGrup,cNnum)
******************
IF !EMPTY(cGrup)
   iMGRUP->(DBSEEK(UPPER(cGrup)))
ENDIF
IF !EMPTY(cNnum)
   iMLABEL->(DBSEEK(UPPER(cGrup)+UPPER(cNnum)))
ENDIF
RETURN IF(cEd=NIL.OR. iMLABEL->Ed=cEd,iMGRUP->KOL_,iMGRUP->Kol1_)
******************
FUNCTION YesInMassiv(n)
******************

RETURN n<=LEN(IF(TYPE('aWindow')='A',aWindow[2,7]:cargo[1],m->aMat))


******************
FUNCTION myASORT(Mas,Block,aErr)
******************
LOCAL Buf,i,j,ni,nj
FOR i=1 to LEN(Mas)-1
   FOR j=i+1 TO LEN(Mas)
      IF !EVAL(Block,Mas[i],Mas[j])
         ni:=nj:=0
         IF !EMPTY(aErr)
            ni:=ASCAN(aErr,i)
            nj:=ASCAN(aErr,j)
         ENDIF
         buf:=Mas[i]
         Mas[i] := Mas[j]
         Mas[j] := buf
         IF ni#0
            aErr[ni]:=j
         ENDIF
         IF nj#0
            aErr[nj]:=i
         ENDIF
      ENDIF
   NEXT
NEXT
RETURN .T.

******************
FUNCTION PutDateAm(lIzm,lIzmN, dDat,cMDocM,lAbs)  // victor спецодежда fun
******************
// установить дату для зеленения ведомостей аморт. спецодежды
//lAbs- Изменять, не проверяя на линейность
LOCAL lSO
LOCAL lSON
LOCAL l:= .F., dNewDate := STOD(GetNewPer(LEFT(DTOS(dDat),6))+'01')

lAbs:=!EMPTY(lAbs)
cMDocM:=IF(EMPTY(cMDocM),'MDocM',cMDocM)
lSO := MLabel->Wrk_Cl = '1' .AND. LinMetod((cMDocM)->Period).AND. ;
      (VAL(LEFT(Str((cMDocM)->PP1,8,0),4)) *12+Val(SUBSTR(Str((cMDocM)->PP1,8,0),5,2)))+(cMDocM)->Period > ;
      YEAR(dDat)*12 + MONTH(dDat)
lSON := MLabel->Wrk_Cl = '1' .AND. LinMetod((cMDocM)->Period,'Nalog',(cMDocM)->Cena0N).AND. ;
      (VAL(LEFT(Str((cMDocM)->PP1,8,0),4)) *12+Val(SUBSTR(Str((cMDocM)->PP1,8,0),5,2)))+(cMDocM)->Period > ;
      YEAR(dDat)*12 + MONTH(dDat)
IF lAbs
   lSo:=lSON:=.T.
ENDIF
IF lIzm .AND. lSO .AND. dNewDate<m->SCL_DAmSO
   m->SCL_DAmSO :=dNewDate
   l:=.T.
ENDIF
IF lIzmN .AND. lSON .AND. dNewDate<m->SCL_DAmSON
   m->SCL_DAmSON := dNewDate
   l:=.T.
ENDIF
IF l
   SavePar('MAIN')
ENDIF


RETURN .T.

******************
FUNCTION LinMetod(Srok,lNal,nCena,dDoc,cSchet)   // victor спецодежда fun
******************
// nCena-налоговая цена задается толька для налоговой
LOCAL lRes:=.F.,nRecS
IF GlobalTask = '09'.AND. SELECT('MBPSchet')#0
   nRecS:=MBPSchet->(RECNO())
   IF nCena = NIL
      nCena=0
   ENDIF
   IF dDoc = NIL
      dDoc = STOD(STR(MDocM->PP1,8,0))
   ENDIF
   IF !EMPTY(cSChet)
      MBPSchet->(dbSEEK(UPPER(cSchet)))
   ENDIF
/************* titov-spi
   lNal:=!EMPTY(lNal)
   IF MLabel->Wrk_Cl=='1'.AND.;
      dDoc >= CTOD('01.01.03').AND. ;
      (Srok>12 .OR.  (!lNal.AND. MBPSchet->Dep_Met='1')) .AND. ;
      !(lNal.AND.Srok>12 .AND. TYPE('Lim_Sum')='N' .AND. nCena < m->Lim_Sum )
         lRes:=.T.
   ENDIF
*****************/
  lNal:=!EMPTY(lNal)
altd()
  IF MLabel->Wrk_Cl=='1' //titov-spi
     IF !lNal //бухгалтерская
        lRes:=IF(Srok<=12,MBPSchet->Dep_Met=='1',MBPSchet->Dep_Met1=='1')
     ELSE 
        IF Srok<=12
           lRes:=MBPSchet->Dep_MetN=='1'
        ELSE
           lRes:=(MBPSchet->Dep_MetN1=='1').AND. ;
           (TYPE('Lim_Sum')='N' .AND. nCena > m->Lim_Sum )
        ENDIF
     ENDIF
  ENDIF



   //xaltd(!(lNal.AND.Srok>12 .AND. TYPE('Lim_Sum')='N' .AND. nCena < m->Lim_Sum ),lNal,Srok>12,TYPE('Lim_Sum')='N',nCena < m->Lim_Sum)
   IF !EMPTY(cSChet)
      MBPSchet->(dbGOTO(nRecS))
   ENDIF

ENDIF
RETURN lRes

******************
FUNCTION GetNewPer(cPer)        // victor спецодежда  fun
******************
LOCAL nGod:=YEAR(SCL_BEG), nMes:=MONTH(SCL_BEG)-1, cRes
IF cPer=NIL
   dbPush('Dep_Ved','TAG_PER')
   dbGoBottom()
   IF !EOF()
      cPer:=Dep_Ved->Ved_Per
   ENDIF
   dbPop()
ENDIF
IF cPer # NIL
   nGod := VAL(LEFT(cPer,4))
   nMes := VAL(RIGHT(cPer,2))
ENDIF
nMes++
IF nMes>12
   nMes:=1
   nGod++
ENDIF
cRes:= STR(nGod,4,0)+STR(nMes,2,0)
IF SUBSTR(cRes,5,1)=' '
   cRes:=STUFF(cRes,5,1,'0')
ENDIF

RETURN cRes

******************
FUNCTION ArrRavno(a1,a2)
******************
LOCAL lRes:=.T.,i
FOR i=1 TO MIN(LEN(a1),LEN(a2))
   IF a1[i]#a2[i]
      lRes:=.F.
   ENDIF
NEXT

RETURN lRes
//#include "sclad\gettax.prg"
/* azat будем откусывать маленькими кусками - - вынесено 27.10.2005 в sclad\gettax.prg
******************   // victor история НДС
FUNCTION GetTax(dDat,lOper)
******************
LOCAL cGr
  lOper:=!EMPTY(lOper)
  cGr:=IF(lOper,iMGRUP->Oper_NDS,iMGRUP->NDS)

  IF iMGRUP->Is_History
     iMTAXGRP->(dbPush(,'Tag_Code',,{'UPPER(Code)',UPPER(iMGRUP->Code)}))
     DO WHILE iMTAXGRP->(!EOF())
        IF dDat >= iMTAXGRP->Date_Beg .AND. (EMPTY(iMTAXGRP->Date_End).OR.dDat <= iMTAXGRP->Date_End )
           IF lOper
              cGr :=  iMTAXGRP->TAX_ID
           ELSE
              cGr :=  iMTAXGRP->TAX
           ENDIF
        ENDIF
        iMTAXGRP->(dbSKIP())
     ENDDO
     iMTAXGRP->(dbPop())
  ELSE
  ENDIF
  If lOper .AND. (SELECT("SPR_NDS")!=0)
    SPR_NDS->(dbPush(,"TAG_OPER",''),;
              dbSeek(cGr),;
              dbPop("стой");
             )
  endif

RETURN cGr
*/
 ****************
 FUNCTION altdb(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)
 ****************
 altd()
 RETURN .T.

 ****************
 FUNCTION DateProv(nnOp)
 ****************
 LOCAL dRes:=CTOD('31/12/2020'), lOpen:=.F.

 dbPush()
 IF SELECT('MAIN') = 0
   NETUSE('MAIN','MAIN.DBF')
   lOpen:=.T.
 ENDIF
 MAIN->(dbPush(,'Tag_NNOper',,{'NNOper',nnOp}))
 DO WHILE  !MAIN->(EOF())
   IF Main->DataOper < dRes
      dRes:= Main->DataOper
   ENDIF
   MAIN->(dbSKIP())
 ENDDO
 MAIN->(dbPop())
 IF lOpen
   MAIN->(dbCloseArea())
 ENDIF
 dbPop()
 RETURN dRes


// Перенесено сюда из s_kit.prg 19 января 2005 - вынесено 27.10.2005 в sclad\selepart.prg
//#include "sclad\selepart.prg"
/*
//--------------------------------------------------------------------------//
//   FUNCTION SelectPartia(cSclad,cGrup,cNNum,nKol,aWork,nSum,nSum1,lAll,lNoRaspr,nSumNDS,nSumAcz,nSumCsh)
//--------------------------------------------------------------------------//
// Возвращает наиболее приемлемый массив по кол-ву, cтруктуры :
// {{номер партии,номер в aWork,распределенное кол-во,распред.сумма,распред.сумма 1}...}
// [aWork] - может не указываться
// [lAll] - .T. то распределение происходит до конца (по умолчанию .F. )
// [lNoRaspr] - .T. , то без распределения один пустой элемент
//              с полным кол-ом (для прихода) (по умолчанию .F. )
*/