Галактика в вопросах и ответах

Код: Выделить всё

//------------------------------------------------------------------------------
//                                                      (c) корпорация Галактика
// Галактика 5.80 - модуль "Платежный календарь"
// Объект для работы с Финобязательствами
//------------------------------------------------------------------------------


#ifndef __AAKTOFP_VIH__
#define __AAKTOFP_VIH__
// *****************************************************************************
#ifdef ComponentVersion
#component "F_OFP"
#end
// *****************************************************************************
#include ofptypes.vpp // TAktOfp

#include aErrorMng.obj // менеджер работы с ошибками
#include aBudByDoc.vih // TDocForBudget

#doc
Объект для работы с Финобязательствами.<br>
#end
Private ObjInterface objAktOfp;

  #doc
  Освобождение ссылок на объекты, провоцирующие циклические зависимости объектов.<br>
  #end
  Function FreeCrossVipRef : boolean;

  /////////////////////// РАЗЛИЧНЫЕ НАЗВАНИЯ ///////////////////////////////////
  Function AktOfp_GetSortName(bufAktOfp: TAktOfp): string;
  #doc
  Наименование ФО.<br>
  #end
  Function AktOfp_GetName(_NoDoc: string; _dDoc: date): string;
  Function AktOfp_GetNameByBuf(bufAktOfp: TAktOfp): string;
  Function AktOfp_GetNameRec(_cAktOFP: comp): string; // см.FO_GetFullName
  Function AktOfp_GetNameInDativeRec(_cAktOFP: comp): string;
  #doc
  Название ФО взаимозачета.<br>
  #end
  Function AktOfp_GetVzaimName(_cAktOFP: comp): string;
  #doc
  Название типа основания ФО (для вывода в Browser).<br>
  #end
  Function AktOfp_GetReasonTypeName(_Type: word): string;
  #doc
  Название основания.<br>
  #end
  Function AktOfp_GetReasonName(_Type: word; _NRec: comp): string;
  #doc
  Организация по умолчанию.<br>
  #end
  Function AktOfp_GetZeroOrgName: string;
  #doc
  Название периода погашения Фоп.<br>
  #end
  Function AktOfp_GetPeriodFopName(bufAktOfp: TAktOfp): string;
  #doc
  Вид платежа по ФО.<br>
  #end
  Function AktOfp_GetTypePlatName(_TypePlat: word): string;
  #doc
  Тип ФО по валюте.<br>
  #end
  Function AktOfp_GetTipMoneyName(_TipMoney: word): string;
  #doc
  Название статуса.<br>
  #end
  Function AktOfp_GetStatusName(_Status: word): string;

  /////////////////////// РАЗЛИЧНЫЕ ПРОВЕРКИ ///////////////////////////////////
  #doc
  Соответствие валюты Фоп типу по валюте ФО.<br>
  #end
  Function AktOfp_ValAccording(_TipMoney: word; _cValAkt, _cValDoc: comp): boolean;

  #doc
  проверяет участвует ли ФОБ в зачете авансов.<br>
  #end
  Function AktOfp_CheckAvans(_cAktOfp: comp; _wTypePlat: word): boolean;

  #doc
  Проверяет соответствие валюты SoprHoz полю TipMoney ФО и контрагентов.<br>
  #end
  Function AktOfp_CheckSoprHoz(_cAktOFP: comp; _cSoprHoz: comp): boolean;

  #doc
  Проверяет валюту документа на соответствие его типу по валюте - общая функция.<br>
  #end
  Function AktOfp_CheckValByTipMoney(_cVal: comp; _tipMoney: word): boolean;

  #doc
  При выборе валюты.<br>
  #end
  Function AktOfp_CheckValForTipMoney(_tipMoney: word; _direct: word): boolean;

  #doc
  Исполнено ли ФО.<br>
  #end
  Function AktOfp_IsRealized(bufAktOfp: TAktOfp): boolean;

  #doc
  Исполнено ли ФО и все его Фоп - то же, но по SumFact.<br>
  #end

  Function AktOfp_RealizedFoAndFop(_cAktOFP: comp): boolean;

  #doc
  ФО и все его Фоп на закрытые дни.<br>
  #end
  Function AktOfp_IsInCldPeriod(_cAktOFP: comp): boolean;

  #doc
  Есть ли у ФОБ ФОП с заданным типом ПС.<br>
  #end
  Function AktOfp_CheckClearingMeanType(_cAktOfp: comp; _MeanType: word): boolean;

  #doc
  Есть ли у ФОБ ФОП с заданной валютой.<br>
  #end
  Function AktOfp_CheckClearingVal(_cAktOfp: comp; _cVal: comp): boolean;

  #doc
  При рассогласовании сумм ФОБ и связанных ФОП.<br>
  #end
  Function AktOfp_OnDisBalansFob(_BufAktOfp: TAktOfp; _SumMode: word): boolean;

  #doc
  При рассогласовании сумм ФОБ и связанных ФОП (по ссылке).<br>
  #end
  Function AktOfp_OnDisBalansFobRec(_cAktOfp: comp; _SumMode: word): boolean;

  /////////////////////// РАЗЛИЧНЫЕ АТРИБУТЫ ///////////////////////////////////
  #doc
  Определяет включена ли настройка для типа документа, Descr.<br>
  #end
  Function User_Nastr(_OfpDocType: word; _Descr: tDescr): boolean;

  #doc
  Доступ к документу в статусе для Descr.<br>
  #end
  Function User_D(_OfpDocType: word; _Descr: tDescr; _cNote: comp): boolean;

  #doc
  Возвращает ФО по основанию (ДО, заявке).<br>
  #end
  Function AktOfp_FindByReason(_vidDO: word; _cDO: comp): comp;

  #doc
  Тип основания: ДО, заявки или ГВПК.<br>
  #end
  Function AktOfp_GetTypeOfReason(_ReasonType: word): word;

  #doc
  Его название.<br>
  #end
  Function AktOfp_GetTypeOfReasonName(_ReasonType: word): string;

  #doc
  Направление по типу ДО.<br>
  #end
  Function AktOfp_GetDirectByReasonType(_ReasonType: word): word;

  #doc
  Маска, куда статус ФО не может быть переведен.<br>
  #end
  Function AktOfp_StatusMaska(bufAktOfp: TAktOfp): word;

  #doc
  Направление - по направлению основания.<br>
  #end
  Function AktOfp_DocType(_direct: word): word;

  #doc
  Ссылка на BaseDoc.<br>
  #end
  Function AktOfp_GetBaseDocRec(bufAktOfp: TAktOfp): comp;

  #doc
  Ссылка на Доп.соглашение, если нет - на договор.<br>
  #end
  Function AktOfp_GetDogovorOrAppRec(bufAktOfp: TAktOfp): comp;

  #doc
  Есть ли у ФО Фоп.<br>
  #end
  Function AktOfp_HasClearing(_cAktOFP: comp): boolean;

  ///////////////////// СВЯЗЬ С ФИНПЛАНИРОВАНИЕМ ///////////////////////////////
  #doc
  Заполнить разноску по статьям из ФинПроводок.<br>
  #end
  Function AggrFpOb(_cSoprHoz: comp; var _pAktOfp: #TAktOfpX): boolean;

  #doc
  Заполнить разноску по статьям ФинПроводок из ХозОперации.<br>
  #end
  Function AggrFpOb_Eval_01(_cSoprHoz: comp; var _pAktOfp: #TAktOfpX; _wMode: word; _isMessage: word): boolean;

  #doc
  Заполнить разноску по статьям ФинПроводок из ХозОперации договора.<br>
  #end
  Function AggrFpObByDocSource(_cDocSource: comp; var _pAktOfp: #TAktOfpX): boolean;

  #doc
  Привязка статьи к ФО на все 100 процентов, появились документы несущие ContAn.<br>
  #end
  Function AktOfp_StBudAttach_Eval_01(bufAktOfp: TAktOfp; _cStBud: comp; _ContAn: LongInt ): boolean;

  #doc
  Привязка статьи к ФО на все 100 процентов.<br>
  #end
  Function AktOfp_StBudAttach(bufAktOfp: TAktOfp; _cStBud: comp): boolean;

  #doc
  Просмотр бюджета по ФО.<br>
  #end
  Function AktOfp_SeeBudget(bufAktOfp: TAktOfp): boolean;

  #doc
  Просмотр/редактирование (_regim) привязки к статьям.<br>
  #end
  Procedure AktOfp_EditStBud(_regim: word; bufAktOfp: TAktOfp);

  #doc
  Заполнение по аналитике соответствующего поля в буфере ФОб с IsNeedUpDate & IsNeedPosit.<br>
  #end
  Function AktOfp_SetAnalitikToBuf(var _bufAktOfp: TAktOfp; _wKau: word; _cKau: comp; _wMode: word = cgBitNo): boolean;

  #doc
  Установить значение поля.<br>
  #end
  Function AktOfp_SetDefValueToBuf(var bufAktOfp: TAktOfp; _wFld: word; _wFldValue: word; _dFldValue: date): boolean;

  #doc
  Аналитика только данного документа из буфера ФОб.<br>
  #end
  Function AktOFP_ExtractKAU(bufAktOfp: TAktOfp; _wKau: word): TnRec;

  #doc
  Аналитика только данного документа.<br>
  #end
  Function AktOfp_GetDocAnaliticByBuf(bufAktOfp: TAktOfp; var _contId: longint): boolean;

  #doc
  Заполнение контейнера аналитик по буферу ФО (связана с предыдущей).<br>
  #end
  Function AktOfp_GetAnaliticByBuf(bufAktOfp: TAktOfp; var _contId: longint): boolean;

  //////////////////// ПРОВЕРКА ДОСТУПНОСТИ ФО /////////////////////////////////
  #doc
  Макс дата, не доступная для редактирования.<br>
  #end
  Function AktOfp_GetMaxNotADate: date;

  #doc
  Поиск среди запрещенных к редактированию доков ПК у тек.группы на ук.дату.<br>
  #end
  Function AktOfp_CheckADate(_dDoc: date; _isMessage: word): boolean;

  #doc
  Если дата запрещена для ред. - вернет первую не запрещенную.<br>
  #end
  Function AktOfp_GetFirstADate(_dDoc: date): date;

  #doc
  Первая дата ФО, на кот.его можно редактировать.<br>
  #end
  Function AktOfp_GetFirstADateForEdit: date;

  #doc
  Первая дата ФО, доступная для редактирования, не меньше _dDoc.<br>
  #end
  Function AktOfp_GetFirstOpenADateNotLess(_dDoc: date): date;

  #doc
  То же с сообщением.<br>
  #end
  Function AktOfp_CheckFirstADateForEdit(_date: date; _DateName: string): boolean;

  #doc
  Проверяет дату на доступность и открытость.<br>
  #end
  Function AktOfp_CanEditOnDate(_date: date; _NeedMessage: boolean): boolean;

  #doc
  Можно ли редактировать документ.<br>
  #end
  Function AktOfp_AvailableForUser(bufAktOfp: TAktOfp): boolean;

  #doc
  То же - по заранее вычисленной максимально доступной дате.<br>
  #end
  Function AktOfp_AvailableForUserWithMaxDate(_bufAktOfp: TAktOfp; _maxDate: date): boolean;

  #doc
  Можно ли создавать ФО на дату заявки (без сообщения).<br>
  #end
  Function AktOfp_CanForReqDate(_retDate: date; _NeedMessage: boolean): boolean;

  #doc
  Можно ли создавать ФО на дату ДО (без сообщения).<br>
  #end
  Function AktOfp_CanForDODate(_cDO: comp; _UchNaSrok: boolean; var _retDate: date; _NeedMessage: boolean): boolean;

  #doc
  То же для поля "Оплатить до".<br>
  #end
  Function AktOfp_CanForDOPayTill(_cDO: comp; var _retDate: date; _NeedMessage: boolean): boolean;

  #doc
  Можно ли обновлять поля ФО.<br>
  #end
  Function AktOfp_CanUpdate(bufAktOfp: TAktOfp): boolean;

  #doc
  Можно ли создавать платежные документы.<br>
  #end
  Function AktOfp_CanMakePlatDoc(_Status: word): boolean;

  #doc
  Можно ли переносить ФО на ук.дату.<br>
  #end
  Function AktOfp_CanMoveToDay(_cAktOfp: comp; _date: date; _isMessage: word): boolean;

  #doc
  Можно только изменять дату документа.<br>
  #end
  Function AktOfp_CanBeReason(_ReasonType: word): boolean;

  #doc
  Всегда можно в архив с этим статусом.<br>
  #end
  Function AktOfp_CanToArchiveAlways(bufAktOfp: TAktOfp): boolean;

  #doc
  можно ли создавать ФОБ (с сообщением или без).<br>
  #end
  Function AktOfp_CanSetDefault(_OfpDocType: word; _NeedMessage: boolean): boolean;

  #doc
  можно ли редактировать ФОБ (с сообщением или без).<br>
  #end
  Function AktOfp_CanEdit(bufAktOfp: TAktOfp; _CheckStatus, _NeedMessage: boolean): boolean;

  #doc
  можно ли удалять ФОБ (с сообщением или без).<br>
  #end
  Function AktOfp_CanDelete(bufAktOfp: TAktOfp; _NeedMessage: boolean): boolean;

  #doc
  Проверка на возможность удаления перед формированием.<br>
  #end
  Function AktOfp_CheckDeleteBeforeCreate(bufAktOfp: TAktOfp): boolean;

  #doc
  Можно ли удалить все (для tDOLG_BYE2) ФО по указанному ДО.<br>
  #end
  Function AktOfp_CanDeleteAllByDo(_cOfpModel: comp; _DocReasonType: word; _cDocReason: comp): boolean;

  ///////////////////////// У Д А Л Е Н И Е ////////////////////////////////////

  #doc
  Удаляет все Фоп у ФО (с проверкой удалять ли исполняемые ФОП).<br>
  #end
  Function AktOfp_DeleteClearingsWithAktPerfCheck( _cAktOFP               : comp;
                                                   _needUpdateAkt         : boolean;
                                                   _needDeleteWithAktPerf : boolean;
                                                   _isMessage             : word
                                                                         ): boolean;

  #doc
  Удаляет все Фоп у ФО.<br>
  #end
  Function AktOfp_DeleteClearings(_cAktOFP: comp; _NeedUpdateAkt: boolean): boolean;
  #doc
  Удаляет ФОБ и все его ФОП.<br>
  #end
  Function AktOfp_DeleteP(_cAktOfp: comp; _pAktOfp: #TAktOFPX): boolean;

  #doc
  Удаляет ФОБ и все соответствующие ему ФОБ в моделях.<br>
  #end
  Function AktOfp_Delete(_cAktOFP: comp): boolean;

  #doc
  Удаление всех ФО у ДО.<br>
  #end
  Function AktOfp_DeleteInModelByDO( _cOfpModel     : comp;
                                     _DocReasonType : word;
                                     _cDocReason    : comp;
                                     _byReason      : boolean
                                                   ): boolean;

  ///////////////////// ДОБАВЛЕНИЕ/ОБНОВЛЕНИЕ //////////////////////////////////
  #doc
  Обновление SoprHoz по ФО (для ТФО - разноски по статьям бюджета).<br>
  #end
  Function AktOfp_MakeSoprHoz(bufAktOFP: TAktOFP): boolean;

  #doc
  Сразу после добавления любой записи.<br>
  #end
  Function AktOfp_AfterInsert(bufAktOfp: TAktOfp): boolean;
  #doc
  Вставить
  #end
  Function AktOfp_Insert(var _pAktOFP: #TAktOFPX): comp;
  #doc
  Вставить AktOfp по буферу
  #end
  Function AktOfp_InsertBuff(_BuffAktOFP: TAktOFP): comp;
  #doc
  Модифицировать буфер в позиции в таблице
  #end
  Function AktOfp_Update(var _pAktOFP: #TAktOFPX): comp;
  ////////////////////// ЗАПОЛНЕНИЕ БУФЕРА ФО //////////////////////////////////
  #doc
  По основанию заполняет буфер ФО.<br>
  #end
  Function AktOfp_Fill(  var bufAktOFP : TAktOFP;
                        _DocReasonType : word;
                        _cDocReason    : comp;
                        _cSoprHoz      : comp;
                        _datePeriod    : date;
                        _direct        : word;  // для rsFIN_OBLIGATION
                        _HandMade      : boolean
                                      ): boolean;
  #doc
  Заполнение буфера ФО по ХО и ФОп.<br>
  #end
  Function FillFOBySH(_cSoprHoz: comp; _wOnlyBySH: word; var _pAktOfp: #TAktOfpX): boolean;

  #doc
  По основанию создает AktOFP (автоматически) _datePeriod - для период-ких.<br>
  #end
  Function AktOfp_CreateByBase( _DocReasonType : word;
                                _cDocReason    : comp;
                                _cSoprHoz      : comp;
                                _datePeriod    : date;
                                _FOCourse      : word; // для вал-руб ФО
                                _NeedClearing  : boolean;
                                _HandMade      : boolean
                                               ): comp;

  #doc
  По основанию создает AktOFP (вручную) _datePeriod - для период-ких
  #end
  Function AktOfp_CreateByBase_AltF( _DocReasonType : word;
                                     _cDocReason    : comp;
                                     _datePeriod    : date;
                                     _rMaket        : TMaketAktOfp
                                                   ): comp;

  #doc
  По основанию обновляет AktOFP (вручную или автоматически).<br>
  #end
  Function AktOfp_UpdateByBase(_pAktOfp: #TAktOFPX; _datePeriod: date): comp;

  //////////////////////// РАЗЛИЧНЫЕ РАСЧЕТЫ ///////////////////////////////////
  #doc
  Сумма Фоп по вал-руб ФО (с запросом или без).<br>
  #end
  Function AktOfp_GetSummaForFop(bufAktOFP: TAktOFP; bufClearing: TClearing; _Ask: boolean; var _Summa: double): boolean;

  #doc
  Нужно ли пересчитывать сумму Фоп.<br>
  #end
  Function AktOfp_SetSummaFopNeed(_TipMoney: word): boolean;

  #doc
  То же, но по ссылке и без запроса курса (дольше).<br>
  #end
  Function AktOfp_SetSummaFop(_cAktOfp: comp; _cClearing: comp; _Ask: boolean): boolean;

  #doc
  Возвращает сумму ФО и валюту в соответствии с TipMoney (для Фоп).<br>
  #end
  Function AktOfp_GetSummaForFopByCourse( _cAktOFP    : comp;
                                          _FOCourse   : word;
                                          var _cVal   : comp;
                                          var _Summa  : double;
                                          var _SumVal : double
                                                     ): boolean;

  #doc
  Пересчитывает указанную в НДЕ сумму в валюту ФО.<br>
  #end
  Function AktOfp_SummaToFromValFO( bufAktOfp     : TAktOfp;
                                    _cVal         : comp;
                                    _Summa        : double;
                                    _isToValFO    : boolean;
                                    var _wasError : boolean
                                                 ): double;

  #doc
  Пересчет сумм Фоп ук-го ФО по курсу (последнему известному).<br>
  #end
  Function AktOfp_RecountFopByCourse(_cAktOFP: comp): boolean;

  #doc
  Сумма Фоп по ФО в валюте ФО (валюта - на дату ФО), сумма Фоп конвертации уч-тся только для ФО конвертации.<br>
  #end
  Function AktOfp_GetSummaFopOther(bufAktOFP: TAktOfp; _cClearing: comp): double;

  #doc
  Сумма Фоп по ФО в валюте ФО (валюта - на дату ФО), с КАУ ( сумма Фоп конвертации уч-тся только для ФО конвертации).<br>
  #end
  Function AktOfp_GetSummaFop_by_Kau(bufAktOFP: TAktOfp; _wKau: word): double;

  #doc
  Суммы ФОБ по заявке (все либо по основанию) в указанной валюте.<br>
  #end
  Function AktOfp_GetSumByReq(_cDocReq: comp; _ByReason: boolean; _cVal: comp; var _Summa, _HozSumma, _SumFact: double): boolean;

  #doc
  Сумма ФО, которую можно включить во взаимозачет.<br>
  #end
  Function AktOfp_RestSummaToVzaim(bufAktOfp: TAktOfp): double;

  #doc
  Сумма аванса.<br>
  #end
  Function AktOfp_GetAvans(_bufAktOFP: TAktOfp): double;

  #doc
  Факт по ФО - оплаченные хоз.документы (долго - переделать потом).<br>
  #end
  Function AktOfp_GetFact(_bufAktOFP: TAktOfp; _Period: word; var _sumFact: double; var _hozSumma: double): boolean;

  #doc
  Часть факта ФО, которая оплачена в закрытом периоде (в регистре "факт").<br>
  #end
  Function AktOfp_GetClosedFact(_bufAktOFP: TAktOfp): double;

  #doc
  Контроль сумм.<br>
  #end
  Function AktOfp_SummControl(_bufAktOFP: TAktOfp; _cClearing: comp; _isValSumm: boolean; var _Summa: double): boolean;

  ///////////////////// ИЗМЕНЕНИЕ АТРИБУТОВ ////////////////////////////////////
  #doc
  Спрашивает новую дату.<br>
  #end
  Function AktOfp_DateGet(_cAktOFP: comp; var NewDate: date): boolean;

  #doc
  Изменим если надо дату Фоп у ФО.<br>
  #end
  Procedure AktOfp_DateSetAfter(_cAktOFP: comp; _OldDate: date; _NewDate: date; _CheckFop: boolean);

  #doc
  Изменение даты финобязательства с проверкой бюджетов.<br>
  #end
  Function AktOfp_SetDateWithBudgetCheck(_cAktOFP: comp): boolean;

  #doc
  изменение даты финобязательства.<br>
  #end
  Function AktOfp_DateSet_Eval_02(var _pAktOFP: #TAktOfpX; _NewDate: date; _wMode: word): boolean;

  #doc
  Изменение даты финобязательства.<br>
  #end
  Function AktOfp_DateSet(_cAktOFP: comp; _NewDate: date; _CheckFop: boolean): boolean;

  #doc
  Автокореектировка даты финобязательства.<br>
  #end
  Function AktOfp_DateReSet(_cAktOFP: comp): boolean;

  #doc
  Обновление суммы, пересчет исполнения, факта.<br>
  #end
  Function AktOfp_SummReSet(_cAktOFP: comp; _AddSumm: double): boolean;

  #doc
  Изменение статуса привязанных ФОП.<br>
  #end
  Function AktOfp_SetStatusAfter(bufAktOfp: TAktOfp; _OldStatus: word): boolean;

  #doc
  Пересчет первоначальной даты обязательства.<br>
  #end
  Function AktOfp_DFirstRecount(_cAktOfp: comp; _NewDate: date; _isDate: boolean): boolean;

  #doc
  изменение статуса у ФО (без подтверждения).<br>
  #end
  Function AktOfp_SetStatusP(var _pAktOFP: #TAktOFPX; _NewStatus: word; _NewcNote: comp; _comment: string[80] = ''): boolean;

  #doc
  То же, но по ссылке.<br>
  #end
  Function AktOfp_SetStatus(_cAktOFP: comp; _NewStatus: word; _NewcNote: comp; _comment: string[80] = ''): boolean;

  #doc
  Изменение приоритета ФО.<br>
  #end
  Function AktOfp_SetPrior(var _bufAktOFP: TAktOfp; _prior: word; _wMode: word): word;

  #doc
  Изменение (увеличение или уменьшение) исполнения и факта ФО ( выз. только из Clearing_ChangeFact).<br>
  #end
  Function AktOfp_ChangeFact(bufClearing: TClearing; _SumPerf: double; _dSoprHoz : date; _direct: word): boolean;

  #doc
  Увеличение или изменение фактической суммы (при изм.даты ХозОп), (то же, но только факт) выз.только из Clearing_HozToFact.<br>
  #end
  Function AktOfp_HozToFact(bufClearing: TClearing; _summa: double; _direct: word): boolean;

  #doc
  Изменение периодического прихода.<br>
  #end
  Function ChangeStatSumma(_pSoprHoz: TPSoprHoz): boolean;

  #doc
  Обновляет распределение по ДО, ПКП, Договорам на основании авансового и фактического обязательства
  #end
  Function AktOfp_UpdateBaseFinByAvans(_cBaseFin, _cAktOfpAvans, _cAktOfpFact: comp; _UpdPlPor: boolean = true): boolean;

  #doc
  Перенос ФО и его Фоп в архив.<br>
  #end
  Function AktOfp_ToArchive(_cAktOFP: comp): boolean;

  #doc
  Перенос ФО и его Фоп из архива на указанную дату.<br>
  #end
  Function AktOfp_FromArchive(_cAktOFP: comp; _NewDate: date): boolean;

End;

VipInterface iAktOfp implements objAktOfp, objErrorMng
#Licensed_PK // На случай если будем возвращаться к прежней концепции лицензирования
;
//******************************************************************************
#end //__AAKTOFP_VIH__

Код: Выделить всё

!#component "F_OFP"
!#define __SumBalansFob__
!#include aAktOfp.vih
!#include aAktOfp.vip
#include ValFunc.vih
alter interface iAktOfp
  ('')
;

overload
  // по основанию создает AktOFP (вручную или автоматически) _datePeriod - для период-ких
  Function ObjAktOfp.AktOfp_CreateByBase(
      _DocReasonType: word;
      _cDocReason: comp;
      _cSoprHoz: comp;
      _datePeriod: date;
      _FOCourse: word; // для вал-руб ФО
      _NeedClearing: boolean;
      _HandMade: boolean
    ): comp;

  // то же, но по ссылке и без запроса курса (дольше)
  //!!D переименовать - добавить "ValRub"
  Function ObjAktOfp.AktOfp_SetSummaFop(
      _cAktOfp: comp;
      _cClearing: comp;
      _Ask: boolean
    ): boolean;

  // пересчет сумм Фоп ук-го ФО по курсу (последнему известному)
  Function ObjAktOfp.AktOfp_RecountFopByCourse(
      _cAktOFP: comp
    ): boolean;

  Procedure AktOfp_FillByDocReq(bufDocReq: TDocReq;
                          var bufAktOFP: TAktOFP; _HandMade: boolean; _datePeriod: date);


//------------------------------------------------------------------------------
//!!!!!!!!!!!!!!!!!D сумма в бюджете - надо между регистрами перекинуть
// piBudByOfp.Budget_DocLimitOnPaid
// в конце выполнения каждой следующей функции
// Пока это происходит только на закрытие дня/откат - может так и правильно
// изменение (увеличение или уменьшение) исполнения и факта ФО
// выз. только из Clearing_ChangeFact
 Function ObjAktOfp.AktOfp_ChangeFact(
      bufClearing: TClearing;
      _SumPerf: double;
      _dSoprHoz : date;
      _direct: word
    ): boolean;
end;


#include ValFunc.var

#include ofpvalfunc.vpp // movalfunc - функции для работы с валютой

create view
var
 vw_cDocReq_2 : comp;
from
 DocReq   EPA_DocReq
,Clearing EPA_Clearing
where
((
       vw_cDocReq_2  == EPA_DocReq.Nrec
   and AktOFP.nRec == EPA_Clearing.cAktOFP
));

Procedure AktOfp_FillByDocReq(bufDocReq: TDocReq;
                          var bufAktOFP: TAktOFP; _HandMade: boolean; _datePeriod: date);
{
  inherited::AktOfp_FillByDocReq(bufDocReq, bufAktOFP, _HandMade, _datePeriod);
  if ( bufDocReq.cPodr != 0h )
    bufAktOFP.cPodr := bufDocReq.cPodr;
}


// Создание заявок на расходование средств
Function ObjAktOfp.AktOfp_CreateByBase(
    _DocReasonType: word;
    _cDocReason: comp;
    _cSoprHoz: comp;
    _datePeriod: date;
    _FOCourse: word; // для вал-руб ФО
    _NeedClearing: boolean;
    _HandMade: boolean
  ): comp;
{
   result := Inherited::AktOfp_CreateByBase( _DocReasonType
                                            ,_cDocReason
                                            ,_cSoprHoz
                                            ,_datePeriod
                                            ,_FOCourse
                                            ,_NeedClearing
                                            ,_HandMade);

  // для заявок на расходование средств нужно проставить дату курса, если она есть в заявке
  if (result != 0 and _DocReasonType = tREQ_RASHOD)
   {
      vw_cDocReq_2 := _cDocReason;

      if (getFirst FastFirstRow EPA_DocReq = tsOk)
       {
          if (EPA_DocReq.dValCurse != 0)
            {
               update AktOfp
               where
                ((
                    result == AktOfp.Nrec
                ))
               set AktOfp.dValCurse = EPA_DocReq.dValCurse;
            }
       }
   }
}
 // Перенос даты погашения
Function ObjAktOfp.AktOfp_SetSummaFop(
    _cAktOfp: comp;
    _cClearing: comp;
    _Ask: boolean
  ): boolean;
{
  AktOfp_SetSummaFop := False; // не обновили пока

  if getfirst AktOFP where ((_cAktOFP == AktOFP.nRec)) = tsOk
    // вал-руб - пересчитаем по курсу
    if AktOfp_SetSummaFopNeed(AktOFP.TipMoney)
    {
      if getfirst Clearing where ((_cClearing == Clearing.nRec)) = tsOk
      {
        // буфер до изменений
        var bufFopOld: TClearing;
        bufFopOld := TClearing(Clearing.buffer);

        // если установлена фиксированная дата курса, пересчитывать надо по ней
        var bufClearing  : TClearing;
        bufClearing      := TClearing(Clearing.buffer);
        bufClearing.dDoc := if (AktOFP.dValCurse != 0, AktOFP.dValCurse, bufClearing.dDoc);

        // сумма Фоп по вал-руб ФО (с запросом или без)
        if AktOfp_GetSummaForFop( TAktOFP(AktOFP.buffer)
                                , bufClearing
                                , _Ask
                                , Clearing.Summa)
          AktOfp_SetSummaFop :=
             piClearing.Clearing_UpdateR(#TClearingX(Clearing.bufferP), bufFopOld) <> 0;
      }
   }
}

//------------------------------------------------------------------------------
// пересчет сумм Фоп ук-го ФО по курсу (последнему известному)
Function ObjAktOfp.AktOfp_RecountFopByCourse(_cAktOFP: comp): boolean;
{
  AktOfp_RecountFopByCourse := True; // без ошибки
  // не вал-руб - не надо
  If getfirst AktOFP where ((_cAktOFP == AktOFP.nRec)) <> tsOk
    exit;

  If (AktOFP.TipMoney <> tipVALRUB)
    exit;

  // !!!если в ДО зафиксирован курс - не пересчитывать
  // !!!операции конвертации пересчитывать? а взаимозачета?
  _loop Clearing where ((_cAktOFP == Clearing.cAktOFP))
  {
    if (Clearing.cVal = 0)
    {
      var bufOld: TClearing;
      bufOld    := TClearing(Clearing.buffer);

      Clearing.Summa := #(movalfunc)CalcRubValMoney( True, AktOFP.cVal, if (AktOFP.dValCurse != 0, AktOFP.dValCurse, Clearing.dDoc), Clearing.cVal, AktOFP.DopProc, Clearing.SumVal);

      AktOfp_RecountFopByCourse :=
        piClearing.Clearing_UpdateR(#TClearingX(Clearing.bufferP), bufOld) <> 0;
    }
  }
}

// Обнуление отрицательных "хвостов" после удаления распределения
Function ObjAktOfp.AktOfp_ChangeFact(
     bufClearing: TClearing;
     _SumPerf: double;
     _dSoprHoz : date;
     _direct: word
   ): boolean;
{
   result := Inherited::AktOfp_ChangeFact(bufClearing,_SumPerf,_dSoprHoz,_direct) ;

   if (GetFirst AktOFP where ((bufClearing.cAktOFP == AktOFP.nRec)) = tsOk)
    {
      var tmpSum : double;
      tmpSum := 0;
      _Loop EPA_Clearing
      {
        if (EPA_Clearing.HozSumma > 0)
          tmpSum += EPA_Clearing.SumVal;
      }
      if (tmpSum < 0)
        set AktOFP.HozSumma := 0;
      else
        set AktOFP.HozSumma := tmpSum;
      update current AktOFP;
    }
}

End.