PIPOATP
/// <summary>
/// PIPO item service class
/// </summary>
[DataContract(classStr(GopSOPIPOItemContract))]
public class GopSOPIPOItemService
{
Set toBeDeleted;
Set created;
Set updated;
Set ordersProcessed;
Set salesOrderTobeConfirmed;
Map salesLineLineNum;
boolean pipoError;
/// <summary>
/// process standalone
/// </summary>
/// <param name = "_itemId">itemid</param>
/// <param name = "atpCalculation">atpCal</param>
/// <param name = "_reserve">reservation</param>
/// <param name = "_soConfirmation">confirmations</param>
public static void processStandalone(SalesTable _salesTable,
boolean atpCalculation = true,
boolean _reserve = false,
boolean _pipo = false)
{
Query query = new Query(queryStr(GopSalesOrderAutoReservation));
QueryBuildDataSource qbds = query.dataSourceTable(tableNum(SalesLine));
qbds.addRange(fieldNum(SalesLine, SalesId)).value(queryValue(_salesTable.SalesId));
qbds.addRange(fieldNum(SalesLine, SalesStatus)).value(queryValue(SalesStatus::Backorder));
GopSOPIPOItemContract contract = new GopSOPIPOItemContract();
contract.parmAllowReservation(_reserve);
contract.parmATPCalculation(atpCalculation);
contract.parmConfirmation(NoYes::No);
contract.parmPIPO(_pipo);
contract.parmQuery(SysOperationHelper::base64Encode(query.pack()));
GopSOPIPOItemService pipoService = new GopSOPIPOItemService();
pipoService.process(contract);
}
/// <summary>
/// Entry point method
/// </summary>
/// <param name = "_contract">contract</param>
public void process(GopSOPIPOItemContract _contract)
{
Query query = new Query(_contract.getQuery());
query = this.buildQuery(query);
QueryRun queryRun = new QueryRun(query);
toBeDeleted = new Set(Types::Int64);
created = new Set(Types::Int64);
updated = new Set(Types::Int64);
ordersProcessed = new Set(Types::String);
salesOrderTobeConfirmed = new Set(Types::String);
salesLineLineNum = new Map(Types::Int64, Types::Real);
SalesLine salesLine;
GopPIPOLog PIPOLog;
while (queryRun.next())
{
try
{
ttsbegin;
salesLine = queryRun.get(salesLine.TableId);
salesLine.selectForUpdate(true);
this.processSalesLine(salesLine, _contract);
if (!ordersProcessed.in(salesLine.SalesId))
{
ordersProcessed.add(salesLine.SalesId);
}
salesLine.reread();
ttscommit;
}
catch
{
str log = GopMulesoftIntegrationLogTable::captureInfoLog();
PIPOLog.clear();
PIPOLog.SalesId = salesLine.SalesId;
PIPOLog.LineNum = salesLine.LineNum;
PIPOLog.POItemId = salesLine.ItemId;
PIPOLog.Notes = log;
PIPOLog.Status = GopMulesoftIntegrationResponseStatus::Failure;
PIPOLog.insert();
pipoError = false;
continue;
}
}
this.postOperation(_contract.parmConfirmation());
}
/// <summary>
/// post processing operations
/// </summary>
private void postOperation(boolean _postConfirmation = false)
{
this.processSalesLinesList();
SetEnumerator orderEnum = salesOrderTobeConfirmed.getEnumerator();
while (orderEnum.moveNext())
{
if (_postConfirmation)
{
this.salesOrderConfirmation(orderEnum.current());
}
}
}
/// <summary>
/// post processing method
/// </summary>
private void processSalesLinesList()
{
SetEnumerator toBeDeletedEnumerator = toBeDeleted.getEnumerator();
while (toBeDeletedEnumerator.moveNext())
{
SalesLine salesLine = SalesLine::findRecId(toBeDeletedEnumerator.current());
ttsbegin;
salesLine.selectForUpdate(true);
if (salesLine.validateDelete())
{
salesLine.delete();
}
ttscommit;
}
MapEnumerator salesLineUpdateEnum = salesLineLineNum.getEnumerator();
while (salesLineUpdateEnum.moveNext())
{
SalesLine salesLine = SalesLine::findRecId(salesLineUpdateEnum.currentKey(), true);
ttsbegin;
salesLine.LineNum = salesLineUpdateEnum.currentValue();
salesLine.doUpdate();
ttscommit;
}
}
/// <summary>
/// process SalesLine
/// </summary>
/// <param name = "salesline">salesline</param>
/// <param name = "_contract">Contract</param>
private void processSalesLine(SalesLine salesline, GopSOPIPOItemContract _contract)
{
SalesLine newSalesLine;
boolean isReplaced = false;
GopPIPOLog PIPOLog;
if (_contract.parmATPCalculation())
{
/* Functionality No Longer needed
SalesATPQty atpQty = this.calcATPQty(salesLine);
if (atpQty > 0 && atpQty < salesLine.RemainInventPhysical)
{
newSalesLine = this.splitSalesline(salesline, atpQty);
salesline.reread();
}
*/
if (!toBeDeleted.in(salesline.RecId))
{
this.recalculateATPDate(salesline);
}
}
if (_contract.parmAllowReservation() && !toBeDeleted.in(salesline.RecId))
{
GopAutoReservationService::reserveSalesLineStandalone(salesline);
}
// PIPO calc
if (_contract.parmPIPO() && !toBeDeleted.in(salesline.RecId))
{
if (!salesLine.mcrSalesQtyReserved() && !salesline.mcrSalesQtyDelivered())
{
using (RetailSalesOrderCreationContext context = RetailSalesOrderCreationContext::construct())
{
newSalesLine = this.updateReplacementItem(salesLine);
}
if(newSalesLine.ItemId != salesLine.ItemId)
{
PIPOLog.clear();
PIPOLog.SalesId = salesLine.SalesId;
PIPOLog.LineNum = salesLine.LineNum;
PIPOLog.POItemId = salesLine.ItemId;
PIPOLog.PIItemId = newSalesLine.ItemId;
PIPOLog.Notes = "";
PIPOLog.Status = GopMulesoftIntegrationResponseStatus::Success;
PIPOLog.insert();
}
}
}
}
/// <summary>
/// PIPO
/// </summary>
/// <param name = "_salesLine">salesline</param>
public SalesLine updateReplacementItem(SalesLine _salesLine)
{
SalesLine newSalesline;
ItemId altItemId;
buf2Buf(_salesLine, newSalesline);
newSalesline.InventTransId = "";
altItemId = GopSOPIPOItemService::findAlternativeItem(_salesLine.ItemId, _salesLine.inventDim(), _salesLine.QtyOrdered);
boolean ret = this.validateAltItem(_salesLine, altItemId);
if (ret && altItemId != _salesLine.ItemId)
{
SalesQty salesQty = _salesLine.SalesQty;
ReturnExpectedRetQty returnExpectedRetQty = _salesLine.ExpectedRetQty;
AmountCur origAmount = _salesLine.SalesPrice;
ItemId origItem = _salesLine.ItemId;
InventDimId origInventDimId = _salesLine.InventDimId;
newSalesline.setInventDimIdFromInventDim(_salesLine.inventDim());
newSalesline.ItemId = altItemId;
newSalesline.itemIdChanged();
newSalesline.initBarcode();
newSalesline.SalesQty = salesQty;
newSalesline.ExpectedRetQty = returnExpectedRetQty;
newSalesline.GopPIPOReplacement = NoYes::Yes;
newSalesline.GopCustReqReceiptDate = _salesLine.GopCustReqReceiptDate;
SalesLine::modifySalesQty(newSalesline,newSalesline.inventDim());
newSalesline.GopCustReqReceiptDate = _salesLine.GopCustReqReceiptDate;
newSalesline.modifiedField(fieldNum(SalesLine, GopCustReqReceiptDate));
// Insert alternate item event
MCROrderEventTable mcrOrderEventTable;
mcrOrderEventTable.insertAlternateItemUsed(newSalesline, MCROrderEventType::AlternateItemUsed,
origItem, origInventDimId, origAmount);
SalesUpdateRemain::updateDeliveryRemainder(_salesLine, 0, 0);
newSalesline.createLine(true, true, true, true, true);
if (!salesOrderTobeConfirmed.in(newSalesline.SalesId))
{
salesOrderTobeConfirmed.add(newSalesline.SalesId);
}
// Insert log
toBeDeleted.add(_salesLine.RecId);
created.add(newSalesline.RecId);
salesLineLineNum.insert(newSalesline.RecId, _salesLine.LineNum);
}
if (!ret)
{
pipoError = true;
throw Exception::Error;
}
return newSalesline;
}
public boolean validateAltItem(SalesLine _salesline, ItemId _altItemId)
{
boolean ret = true;
InventItemSalesSetup salesSetupOrig = InventItemSalesSetup::find(_salesline.ItemId, _salesline.InventDimId);
InventItemSalesSetup salesSetupAltItem = InventItemSalesSetup::find(_altItemId, _salesline.InventDimId);
SalesUnit salesUnitAltItem = InventTableModule::find(_altItemId, ModuleInventPurchSales::Sales).UnitId;
if (salesUnitAltItem != _salesline.SalesUnit)
{
ret = checkFailed("UOM is Different for Alt Item");
}
if (salesSetupOrig.LowestQty != salesSetupAltItem.LowestQty)
{
ret = checkFailed("Minimum Order Quantity is different for Alt Item") && ret;
}
if (salesSetupOrig.MultipleQty != salesSetupAltItem.MultipleQty)
{
ret = checkFailed("Multiple Order Quantity is different for Alt Item") && ret;
}
return ret;
}
/// <summary>
/// calculate ATP qty
/// </summary>
/// <param name = "_salesLine">salesline</param>
/// <returns>SalesATPQty</returns>
public SalesATPQty calcATPQty(SalesLine _salesLine)
{
SalesATPCalculation salesATPCalculation = SalesATPCalculation::newSalesCalculation(_salesLine.ItemId, _salesLine.InventDimId, _salesLine.CustAccount);
SalesTmpATP tempData;
tempData.setTmpData(salesATPCalculation.calcSalesTmpATP(_salesLine.InventTransId, _salesLine.RemainInventPhysical));
select firstonly tempData
order by atpDate
where tempData.atpQty;
return tempData.ATPQty;
}
/// <summary>
/// Recalculate ATP Dates on salesline
/// </summary>
/// <param name = "_salesline">salesline</param>
public void recalculateATPDate(SalesLine _salesline)
{
TransDate shippingDateRequested = _salesline.ShippingDateRequested;
SalesLine oldSalesline;
oldSalesline.GopCustRequestedDate = _salesline.GopCustRequestedDate;
oldSalesline.ShippingDateRequested = _salesline.ShippingDateRequested;
oldSalesline.ReceiptDateRequested = _salesline.ReceiptDateRequested;
_salesline.ReceiptDateRequested = _salesline.GopCustReqReceiptDate;
//SalesCalcAvailableDlvDates salesCalcAvailableDlvDates = SalesCalcAvailableDlvDates::newCommonSalesDlvDateType(_salesline, fieldNum(SalesLine, ReceiptDateRequested));
//salesCalcAvailableDlvDates.validateWritePrompt(_salesline,false,true,true, false);
using (var context = new GopCustReqReceiptDateContext())
{
_salesline.modifiedFieldDDC(fieldNum(SalesLine, ReceiptDateRequested), false);
}
_salesline.update();
if (!salesOrderTobeConfirmed.in(_salesline.SalesId))
{
salesOrderTobeConfirmed.add(_salesline.SalesId);
}
GopATPLog::createLog(oldSalesline, _salesline);
}
/// <summary>
/// Total number of opensalesLines in salesOrder
/// </summary>
/// <param name = "_salesId">salesid</param>
/// <returns>noOfLines</returns>
private Integer noOfSalesLines(SalesId _salesId)
{
Integer noOfSalesLines;
SalesLine salesLine;
select count(RecId) from salesLine
where salesLine.SalesId == _salesId &&
salesLine.SalesStatus == SalesStatus::Backorder;
return salesLine.RecId;
}
/// <summary>
/// Sales order confirmation
/// </summary>
/// <param name = "_salesId">sales id</param>
private void salesOrderConfirmation(SalesId _salesId)
{
SalesTable salesTable = SalesTable::find(_salesId);
SalesFormLetter salesFormLetter = SalesFormLetter::construct(DocumentStatus::Confirmation);
salesFormLetter.update(salesTable, DateTimeUtil::getSystemDate(DateTimeUtil::getUserPreferredTimeZone()), SalesUpdate::All);
}
private SalesLine splitSalesline(SalesLine _salesline, SalesATPQty _atpQty)
{
RefRecId fromUnit = UnitOfMeasure::findBySymbol(_salesline.inventTable().inventUnitId()).RecId;
RefRecId toUnit = UnitOfMeasure::findBySymbol(_salesline.SalesUnit).RecId;
SalesQty convertATPtoSalesQty = UnitOfMeasureConverter::convert(_atpQty,fromUnit, toUnit, NoYes::Yes, _salesline.inventTable().Product);
SalesLine newSalesLine, replacedLine;
SalesUpdateRemain::updateDeliveryRemainder(_salesLine, 0, 0);
newSalesLine = this.createNewLine(_salesline, convertATPtoSalesQty);
if (!salesOrderTobeConfirmed.in(newSalesline.SalesId))
{
salesOrderTobeConfirmed.add(newSalesline.SalesId);
}
GopATPLog::createLog(_salesline, newSalesLine);
replacedLine = this.createNewLine(_salesline, _salesline.SalesQty - convertATPtoSalesQty);
if (!salesOrderTobeConfirmed.in(replacedLine.SalesId))
{
salesOrderTobeConfirmed.add(replacedLine.SalesId);
}
GopATPLog::createLog(_salesline, newSalesLine);
created.add(newSalesLine.RecId);
created.add(replacedLine.RecId);
toBeDeleted.add(_salesline.RecId);
return newSalesLine;
}
/// <summary>
/// create duplicate salesline with spilited qty
/// </summary>
/// <param name = "_salesline">origsalesline</param>
/// <param name = "_salesQty">atpQty</param>
/// <returns>newsalesline</returns>
private SalesLine createNewLine(SalesLine _salesline, SalesQty _salesQty)
{
SalesLine salesLine;
salesLine.clear();
salesLine.initFromSalesTable(_salesline.salesTable());
salesLine.DeliveryPostalAddress = _salesline.DeliveryPostalAddress;
salesLine.SalesId = _salesline.SalesId;
salesLine.ItemId = _salesline.ItemId;
salesLine.initFromInventTable(_salesline.inventTable());
salesLine.SalesQty = _salesQty;
salesLine.InventDimId = _salesline.InventDimId;
SalesLine::modifySalesQty(salesLine,_salesLine.inventDim());
salesLine.ShippingDateRequested = salesLine.ShippingDateRequested;
salesLine.GopCustomerOrderContract = _salesLine.GopCustomerOrderContract;
salesLine.GopCustomerPartNumber = _salesline.GopCustomerPartNumber;
salesLine.GopGTINNumber = _salesline.GopGTINNumber;
salesLine.GopCatalogueNumber = _salesline.GopCatalogueNumber;
salesLine.GopCustomerOrderQty = _salesline.GopCustomerOrderQty;
salesLine.GopCustRequestedDate = _salesline.GopCustRequestedDate;
salesLine.GopCustReqReceiptDate = _salesline.GopCustReqReceiptDate;
salesLine.modifiedField(fieldNum(SalesLine, GopCustReqReceiptDate));
if (_salesline.GopCustomerPartNumber)
{
salesLine.GopCustomerOrderUOM = _salesline.GopCustomerPartNumber;
}
salesLine.GopEDISalesPrice = _salesline.GopEDISalesPrice;
salesLine.CustomerRef = _salesline.CustomerRef;
salesLine.GopEDILineNum = _salesline.GopEDILineNum;
salesLine.GopASNCustConversionFactor = _salesline.GopASNCustConversionFactor;
salesLine.GopASNCUOM = _salesline.GopASNCUOM;
salesLine.GopASNCustomerPartNum = _salesline.GopASNCustomerPartNum;
salesLine.GopASNGTINNum = _salesline.GopASNGTINNum;
salesLine.GopParentLineNum = _salesline.LineNum;
salesLine.GopSplittedLineATP = NoYes::Yes;
//end
salesLine.createLine(true, true, true, true, true, true);
salesLine.selectForUpdate(true);
salesLine.Name = _salesline.Name;
salesLine.SalesQty = _salesQty;
if (_salesline.MatchingAgreementLine)
{
salesLine.initFromAgreementLine(AgreementLine::find(_salesline.MatchingAgreementLine));
}
else
{
salesLine.SalesPrice = _salesline.SalesPrice;
salesLine.modifyField(fieldNum(SalesLine, SalesPrice));
}
salesLine.doUpdate();
return salesLine;
}
private Query buildQuery(Query _query)
{
QueryBuildRange qbr = _query.dataSourceTable(tableNum(SalesLine)).findRange(fieldNum(SalesLine, SalesQty));
qbr.value(queryValue('>0'));
return _query;
}
public static ItemId findAlternativeItem(
ItemId _itemId,
InventDim _inventDim,
InventQty _qty)
{
InventDim newInventDim = _inventDim;
ItemId newItemId = _itemId;
InventTable inventTable = InventTable::find(_itemId);
if (inventTable.hasActiveAltItemId())
{
boolean tryNextItem = true;
Set visitedItems = new Set(Types::String);
do
{
visitedItems.add(newItemId);
InventOnHandQty onhandQuantity = InventOnHandQty::newParameters(newItemId, _inventDim);
if (onhandQuantity.availPhysical() < _qty)
{
newItemId = inventTable.AltItemId;
if (newItemId)
{
inventTable = InventTable::find(newItemId);
tryNextItem = inventTable.hasActiveAltItemId();
}
if (visitedItems.in(newItemId))
{
newItemId = inventTable.ItemId;
tryNextItem = false;
}
}
else
{
tryNextItem = false;
}
}
while (tryNextItem);
}
return newItemId;
}
}
------------------------------
/// <summary>
/// Data contract for auto allocation
/// </summary>
[DataContractAttribute]
[SysOperationAlwaysInitializeAttribute]
public class GopSOPIPOItemContract
{
str packedQuery;
boolean atpCalculation;
boolean reservation;
boolean soConfirmation;
boolean pipo;
/// <summary>
/// PIPO
/// </summary>
/// <param name = "_pipo">PIPO</param>
/// <returns>boolean</returns>
[
DataMemberAttribute('pipo'),
SysOperationLabelAttribute(literalStr("PIPO"))
]
public boolean parmPIPO(boolean _pipo = pipo)
{
pipo = _pipo;
return pipo;
}
/// <summary>
/// ATP Calculation
/// </summary>
/// <param name = "_atpCalc">_atpCalc</param>
/// <returns>boolean</returns>
[
DataMemberAttribute('atpCalculation'),
SysOperationLabelAttribute(literalStr("ATP Calculation"))
]
public boolean parmATPCalculation(boolean _atpCalc = atpCalculation)
{
atpCalculation = _atpCalc;
return atpCalculation;
}
/// <summary>
/// Reservation allowed
/// </summary>
/// <param name = "_reserve">_reserve</param>
/// <returns>boolean</returns>
[
DataMemberAttribute('reservation'),
SysOperationLabelAttribute(literalStr("Reservation"))
]
public boolean parmAllowReservation(boolean _reserve = reservation)
{
reservation = _reserve;
return reservation;
}
/// <summary>
/// SO confirmation
/// </summary>
/// <param name = "_confirm">confirm</param>
/// <returns>boolean</returns>
[
DataMemberAttribute('soConfirmation'),
SysOperationLabelAttribute(literalStr("Post Confirmation"))
]
public boolean parmConfirmation(boolean _confirm = soConfirmation)
{
soConfirmation = _confirm;
return soConfirmation;
}
/// <summary>
/// Packed Query
/// </summary>
/// <param name = "_packedQuery">str</param>
/// <returns>str</returns>
[DataMemberAttribute,
AifQueryTypeAttribute('_packedQuery', querystr(GopSalesOrderAutoReservation))
]
public str parmQuery(str _packedQuery = packedQuery)
{
packedQuery = _packedQuery;
return packedQuery;
}
/// <summary>
/// Get Query
/// </summary>
/// <returns>Query</returns>
public Query getQuery()
{
return new Query(SysOperationHelper::base64Decode(packedQuery));
}
/// <summary>
/// Set Query
/// </summary>
/// <param name = "_query">Query</param>
public void setQuery(Query _query)
{
packedQuery = SysOperationHelper::base64Encode(_query.pack());
}
}
------------
public class GopSOPIPOItemController extends SysOperationServiceController
{
/// <summary>
/// Caption
/// </summary>
/// <returns>description</returns>
public ClassDescription defaultCaption()
{
return "Sales Order Optimization Service";
}
/// <summary>
/// Main
/// </summary>
/// <param name = "_args"_args></param>
public static void main(Args _args)
{
GopSOPIPOItemController controller;
controller = new GopSOPIPOItemController(classStr(GopSOPIPOItemService),
methodStr(GopSOPIPOItemService, process),SysOperationExecutionMode::Synchronous);
controller.startOperation();
}
}
public void solvCalcCustomerReqShipDate()
{
SalesCalcAvailableDlvDates salesCalcAvailableDlvDates = SalesCalcAvailableDlvDates::newCommonSalesDlvDateType(this, fieldNum(SalesLine, ReceiptDateRequested));
CalendarId shippingCalendarId;
CustVendTransportCalendarId transportCalendarId;
shippingCalendarId = InventLocation::find(this.inventDim().InventLocationId).ReqCalendarId;
if (!shippingCalendarId)
{
shippingCalendarId = CompanyInfo::find().ShippingCalendarId;
}
if (CustVendTransportCalendarSetup::exist(this.DlvMode, this.inventDim().InventLocationId))
{
transportCalendarId = CustVendTransportCalendarSetup::find(this.DlvMode, this.inventDim().InventLocationId).Calendar;
}
else if (CustVendTransportCalendarSetup::exist(this.DlvMode, ''))
{
transportCalendarId = CustVendTransportCalendarSetup::find(this.DlvMode, '').Calendar;
}
SalesShippingDateAvailable availableShippingDate;
SalesReceiptDateAvailable availableReceiptDate;
WorkCalendarSched workCalendarSched = new WorkCalendarSched();
CustVendTransportDays transportDays = salesCalcAvailableDlvDates.transportDays();
availableReceiptDate = workCalendarSched.schedDate(SchedDirection::Backward, this.SolvCustReqReceiptDate, 0, true, this.receiptCalendarForSalesLine(this, this.salesTable()));
availableShippingDate = workCalendarSched.schedDate(SchedDirection::Backward,
availableReceiptDate,
transportDays,
true,
transportCalendarId,
shippingCalendarId,
SalesCheckForPickup::PrimaryCalendar);
if (availableShippingDate < DateTimeUtil::getSystemDate(DateTimeUtil::getUserPreferredTimeZone()))
{
availableShippingDate = min(DateTimeUtil::getSystemDate(DateTimeUtil::getUserPreferredTimeZone()), this.SolvCustReqReceiptDate);
}
this.SolvCustRequestedDate = availableShippingDate;
}
private CalendarId receiptCalendarForSalesLine(SalesLine _receiptCalendarSalesLine, SalesTable _receiptCalendarSalesTable)
{
CalendarId salesLineReceiptCalendarId = LogisticsLocationExt::find(_receiptCalendarSalesLine.deliveryLocation()).SalesCalendarId;
if (!salesLineReceiptCalendarId && _receiptCalendarSalesLine.AddressRefTableId && _receiptCalendarSalesLine.AddressRefRecId)
{
switch (_receiptCalendarSalesLine.AddressRefTableId)
{
case tableNum(LogisticsLocation) :
salesLineReceiptCalendarId = LogisticsLocationExt::find(_receiptCalendarSalesLine.AddressRefRecId).SalesCalendarId;
break;
case tableNum(CustTable) :
salesLineReceiptCalendarId = (select custTable where custTable.TableId == _receiptCalendarSalesLine.AddressRefTableId && custTable.RecId == _receiptCalendarSalesLine.AddressRefRecId).SalesCalendarId;
break;
default :
break;
}
}
if (!salesLineReceiptCalendarId)
{
salesLineReceiptCalendarId = LogisticsLocationExt::find(_receiptCalendarSalesTable.deliveryLocation()).SalesCalendarId;
}
if (!salesLineReceiptCalendarId && _receiptCalendarSalesTable.AddressRefTableId && _receiptCalendarSalesTable.AddressRefRecId)
{
switch (_receiptCalendarSalesTable.AddressRefTableId)
{
case tableNum(LogisticsLocation) :
salesLineReceiptCalendarId = LogisticsLocationExt::find(_receiptCalendarSalesTable.AddressRefRecId).SalesCalendarId;
break;
case tableNum(CustTable) :
salesLineReceiptCalendarId = (select custTable where custTable.TableId == _receiptCalendarSalesTable.AddressRefTableId && custTable.RecId == _receiptCalendarSalesTable.AddressRefRecId).SalesCalendarId;
break;
default :
break;
}
}
if (!salesLineReceiptCalendarId)
{
salesLineReceiptCalendarId = CustTable::find(_receiptCalendarSalesLine.CustAccount).SalesCalendarId;
}
return salesLineReceiptCalendarId;
}
public void modifiedField(FieldId _fieldId)
{
next modifiedField(_fieldId);
switch (_fieldId)
{
case fieldnum(SalesLine, SolvCustReqReceiptDate):
case fieldNum(SalesLine, DlvMode):
this.solvCalcCustomerReqShipDate();
}
}
Comments
Post a Comment