protected virtual void InsertARTran(ARInvoiceEntry arGraph, EPExpenseClaimDetails row, bool copyNotes, bool copyFiles)
{
ARTran tran = (ARTran)arGraph.Transactions.Cache.CreateInstance();
tran.InventoryID = row.InventoryID;
tran.TranDesc = row.TranDesc;
tran.TranCost = row.ExtCost;
tran.Qty = row.Qty;
tran.UOM = row.UOM;
tran.CuryTranAmt = row.CuryTranAmt;
tran.AccountID = row.SalesAccountID;
tran.SubID = row.SalesSubID;
tran.Date = row.ExpenseDate;
tran = arGraph.Transactions.Insert(tran);
if (copyNotes)
{
string note = PXNoteAttribute.GetNote(Caches[typeof(EPExpenseClaimDetails)], row);
if (note != null)
{
PXNoteAttribute.SetNote(arGraph.Transactions.Cache, tran, note);
}
}
if (copyFiles)
{
Guid[] files = PXNoteAttribute.GetFileNotes(Caches[typeof(EPExpenseClaimDetails)], row);
if (files != null && files.Length > 0)
{
PXNoteAttribute.SetFileNotes(arGraph.Transactions.Cache, tran, files);
}
}
}
protected virtual void InsertPMTran(RegisterEntry pmGraph, EPExpenseClaimDetails row, EPExpenseClaim doc, bool copyNotes, bool copyFiles)
{
PMProject project = PXSelect <PMProject, Where <PMProject.contractID, Equal <Required <PMProject.contractID> > > > .Select(pmGraph, row.ContractID);
Account account = PXSelect <Account, Where <Account.accountID, Equal <Required <Account.accountID> > > > .Select(this, row.ExpenseAccountID);
if (account.AccountGroupID == null && project.BaseType == PMProject.ProjectBaseType.Project)
{
throw new PXException(Messages.AccountGroupIsNotAssignedForAccount, account.AccountCD);
}
PMTran tran = (PMTran)pmGraph.Transactions.Cache.Insert();
tran.AccountGroupID = account.AccountGroupID;
tran.BAccountID = row.CustomerID;
tran.LocationID = row.CustomerLocationID;
tran.ProjectID = row.ContractID;
tran.TaskID = row.TaskID;
tran.InventoryID = row.InventoryID;
tran.Qty = row.Qty;
tran.Billable = true;
tran.BillableQty = row.Qty;
tran.UOM = row.UOM;
tran.UnitRate = row.UnitCost;
tran.Amount = row.TranAmt;
tran.AccountID = row.ExpenseAccountID;
tran.SubID = row.ExpenseSubID;
tran.StartDate = row.ExpenseDate;
tran.EndDate = row.ExpenseDate;
tran.Date = row.ExpenseDate;
tran.ResourceID = doc.EmployeeID;
tran.Released = project.BaseType == PMProject.ContractBaseType.Contract; //contract trans are created as released
pmGraph.Transactions.Update(tran);
pmGraph.Document.Current.Released = project.BaseType == PMProject.ContractBaseType.Contract;
if (copyNotes)
{
string note = PXNoteAttribute.GetNote(Caches[typeof(EPExpenseClaimDetails)], row);
if (note != null)
{
PXNoteAttribute.SetNote(pmGraph.Transactions.Cache, tran, note);
}
}
if (copyFiles)
{
Guid[] files = PXNoteAttribute.GetFileNotes(Caches[typeof(EPExpenseClaimDetails)], row);
if (files != null && files.Length > 0)
{
PXNoteAttribute.SetFileNotes(pmGraph.Transactions.Cache, tran, files);
}
}
}
protected virtual List <BillingData> BillTask(PMTask task, PMBillingRule rule, DateTime billingDate)
{
PMProject project = PXSelect <PMProject, Where <PMProject.contractID, Equal <Required <PMProject.contractID> > > > .Select(this, task.ProjectID);
Customer customer = PXSelect <Customer, Where <Customer.bAccountID, Equal <Required <Customer.bAccountID> > > > .Select(this, project.CustomerID);
List <BillingData> list = new List <BillingData>();
Dictionary <int, decimal> availableQty = new Dictionary <int, decimal>();
Dictionary <int, ContractDetail> billingItems = new Dictionary <int, ContractDetail>();
//recurent Billing:
PXSelectBase <ContractDetail> selectBilling = new PXSelect <ContractDetail,
Where <ContractDetail.contractID, Equal <Required <ContractDetail.contractID> >,
And <ContractDetail.taskID, Equal <Required <ContractDetail.taskID> > > > >(this);
foreach (ContractDetail billing in selectBilling.Select(task.ProjectID, task.TaskID))
{
billingItems.Add(billing.InventoryID.Value, billing);
if (billing.Included > 0)
{
if (billing.ResetUsage == ResetUsageOption.OnBilling)
{
availableQty.Add(billing.InventoryID.Value, billing.Included.Value);
}
else
{
decimal qtyLeft = billing.Included.Value - billing.LastBilledQty ?? 0;
if (qtyLeft > 0)
{
availableQty.Add(billing.InventoryID.Value, qtyLeft);
}
}
}
bool bill = false;
if (billing.ResetUsage == ResetUsageOption.OnBilling)
{
bill = true;
}
else
{
if (billing.LastBilledDate == null)
{
bill = true;
}
}
if (bill)
{
ARTran arTran = new ARTran();
arTran.InventoryID = billing.InventoryID;
arTran.TranDesc = billing.Description;
arTran.Qty = billing.Included;
arTran.UOM = billing.UOM;
arTran.ExtPrice = billing.ItemFee;
arTran.TranAmt = arTran.ExtPrice;
arTran.ProjectID = task.ProjectID;
arTran.TaskID = task.TaskID;
arTran.Commissionable = false; //todo
string subCD = null;
#region Set Account and Subaccount
if (billing.AccountSource != PMAccountSource.None)
{
if (rule.AccountSource == PMAccountSource.RecurringBillingItem)
{
if (billing.AccountID != null)
{
arTran.AccountID = billing.AccountID;
}
else
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(this, billing.InventoryID);
throw new PXException(Messages.BillingRuleAccountIsNotConfiguredForBillingRecurent, item.InventoryCD);
}
}
else if (billing.AccountSource == PMAccountSource.Project)
{
if (project.DefaultAccountID != null)
{
arTran.AccountID = project.DefaultAccountID;
}
else
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(this, billing.InventoryID);
throw new PXException(Messages.ProjectAccountIsNotConfiguredForBillingRecurent, item.InventoryCD, project.ContractCD);
}
}
else if (billing.AccountSource == PMAccountSource.Task)
{
if (task.DefaultAccountID != null)
{
arTran.AccountID = task.DefaultAccountID;
}
else
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(this, billing.InventoryID);
throw new PXException(Messages.TaskAccountIsNotConfiguredForBillingRecurent, item.InventoryCD, project.ContractCD, task.TaskCD);
}
}
else if (billing.AccountSource == PMAccountSource.InventoryItem)
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(this, billing.InventoryID);
if (item != null)
{
if (item.SalesAcctID != null)
{
arTran.AccountID = item.SalesAcctID;
}
else
{
throw new PXException(Messages.InventoryAccountIsNotConfiguredForBillingRecurent, item.InventoryCD);
}
}
}
else if (billing.AccountSource == PMAccountSource.Customer && customer != null)
{
CR.Location customerLoc = PXSelect <CR.Location, Where <CR.Location.bAccountID, Equal <Required <CR.Location.bAccountID> >, And <CR.Location.locationID, Equal <Required <CR.Location.locationID> > > > > .Select(this, customer.BAccountID, customer.DefLocationID);
if (customerLoc != null)
{
if (customerLoc.CSalesAcctID != null)
{
arTran.AccountID = customerLoc.CSalesAcctID;
}
else
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(this, billing.InventoryID);
throw new PXException(Messages.CustomerAccountIsNotConfiguredForBillingRecurent, item.InventoryCD, customer.AcctCD);
}
}
}
if (arTran.AccountID == null && !string.IsNullOrEmpty(billing.SubMask))
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(this, billing.InventoryID);
throw new PXException(Messages.SubAccountCannotBeComposed, item.InventoryCD);
}
else if (arTran.AccountID != null && !string.IsNullOrEmpty(billing.SubMask))
{
subCD = PMRecurentBillSubAccountMaskAttribute.MakeSub <PMBillingRule.subMask>(this, billing.SubMask,
new object[] { billing.SubID, project.DefaultSubID, task.DefaultSubID },
new Type[] { typeof(PMBillingRule.subID), typeof(PMProject.defaultSubID), typeof(PMTask.defaultSubID) });
}
}
#endregion
list.Add(new BillingData(arTran, rule, null, subCD, null, null));
billing.LastBilledDate = billingDate;
ContractDetail.Update(billing);
}
}
int mult = 1;
PMAccountGroup ag = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(this, rule.AccountGroupID);
if (ag == null)
{
throw new PXException(Messages.AccountGroupInBillingRuleNotFound, rule.BillingID, rule.AccountGroupID);
}
if (ag.Type == GL.AccountType.Liability || ag.Type == GL.AccountType.Income)
{
mult = -1;
}
DateTime cuttofDate = billingDate; //all transactions excluding the current day.
ContractBillingSchedule schedule = PXSelect <ContractBillingSchedule> .Search <ContractBillingSchedule.contractID>(this, task.ProjectID);
if (schedule != null && schedule.Type == BillingType.OnDemand)
{
cuttofDate = billingDate.AddDays(1); //all transactions including the current day.
}
else
{
if (IncludeTodaysTransactions)
{
cuttofDate = billingDate.AddDays(1);
}
}
List <PMTran> billingBase = SelectBillingBase(task.ProjectID, task.TaskID, rule.AccountGroupID, cuttofDate,
rule.IncludeNonBillable == true);
foreach (PMTran tran in billingBase)
{
ARTran arTran = new ARTran();
arTran.BranchID = tran.BranchID;
if (tran.InventoryID != PMInventorySelectorAttribute.EmptyInventoryID)
{
arTran.InventoryID = tran.InventoryID;
}
arTran.TranDesc = tran.Description;
arTran.UOM = tran.UOM;
arTran.Qty = tran.BillableQty * mult;
arTran.ExtPrice = tran.Amount * mult;
if (arTran.Qty != 0)
{
arTran.UnitPrice = arTran.ExtPrice / arTran.Qty;
}
else
{
arTran.UnitPrice = 0;
}
arTran.TranAmt = arTran.ExtPrice;
arTran.ProjectID = task.ProjectID;
arTran.TaskID = task.TaskID;
arTran.PMTranID = tran.TranID;
arTran.Commissionable = false; //todo
arTran.Date = tran.Date;
string subCD = null;
#region Set Account and Subaccount
int?employeeSubID = null;
if (tran.ResourceID != null)
{
EP.EPEmployee emp = PXSelect <EP.EPEmployee, Where <EP.EPEmployee.bAccountID, Equal <Required <EP.EPEmployee.bAccountID> > > > .Select(this, tran.ResourceID);
if (emp != null)
{
employeeSubID = emp.SalesSubID;
}
}
if (rule.AccountSource != PMAccountSource.None)
{
if (rule.AccountSource == PMAccountSource.BillingRule)
{
if (rule.AccountID != null)
{
arTran.AccountID = rule.AccountID;
}
else
{
throw new PXException(Messages.BillingRuleAccountIsNotConfiguredForBilling, rule.BillingID);
}
}
else if (rule.AccountSource == PMAccountSource.Project)
{
if (project.DefaultAccountID != null)
{
arTran.AccountID = project.DefaultAccountID;
}
else
{
throw new PXException(Messages.ProjectAccountIsNotConfiguredForBilling, rule.BillingID, project.ContractCD);
}
}
else if (rule.AccountSource == PMAccountSource.Task)
{
if (task.DefaultAccountID != null)
{
arTran.AccountID = task.DefaultAccountID;
}
else
{
throw new PXException(Messages.TaskAccountIsNotConfiguredForBilling, rule.BillingID, project.ContractCD, task.TaskCD);
}
}
else if (rule.AccountSource == PMAccountSource.InventoryItem)
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(this, tran.InventoryID);
if (item != null)
{
if (item.SalesAcctID != null)
{
arTran.AccountID = item.SalesAcctID;
}
else
{
throw new PXException(Messages.InventoryAccountIsNotConfiguredForBilling, rule.BillingID, item.InventoryCD);
}
}
}
else if (rule.AccountSource == PMAccountSource.Customer && customer != null)
{
CR.Location customerLoc = PXSelect <CR.Location, Where <CR.Location.bAccountID, Equal <Required <CR.Location.bAccountID> >, And <CR.Location.locationID, Equal <Required <CR.Location.locationID> > > > > .Select(this, customer.BAccountID, customer.DefLocationID);
if (customerLoc != null)
{
if (customerLoc.CSalesAcctID != null)
{
arTran.AccountID = customerLoc.CSalesAcctID;
}
else
{
throw new PXException(Messages.CustomerAccountIsNotConfiguredForBilling, rule.BillingID, customer.AcctCD);
}
}
}
else if (rule.AccountSource == PMAccountSource.Resource)
{
EP.EPEmployee emp = PXSelect <EP.EPEmployee, Where <EP.EPEmployee.bAccountID, Equal <Required <EP.EPEmployee.bAccountID> > > > .Select(this, tran.ResourceID);
if (emp != null)
{
if (emp.SalesAcctID != null)
{
arTran.AccountID = emp.SalesAcctID;
}
else
{
throw new PXException(Messages.EmployeeAccountIsNotConfiguredForBilling, rule.BillingID, emp.AcctCD);
}
}
}
if (arTran.AccountID == null && !string.IsNullOrEmpty(rule.SubMask))
{
throw new PXException(Messages.SubAccountCannotBeComposed, rule.BillingID);
}
else if (arTran.AccountID != null && !string.IsNullOrEmpty(rule.SubMask))
{
subCD = PMBillSubAccountMaskAttribute.MakeSub <PMBillingRule.subMask>(this, rule.SubMask,
new object[] { tran.SubID, rule.SubID, project.DefaultSubID, task.DefaultSubID, employeeSubID },
new Type[] { typeof(PMTran.subID), typeof(PMBillingRule.subID), typeof(PMProject.defaultSubID), typeof(PMTask.defaultSubID), typeof(EP.EPEmployee.salesSubID) });
}
}
#endregion
string note = PXNoteAttribute.GetNote(Transactions.Cache, tran);
Guid[] files = PXNoteAttribute.GetFileNotes(Transactions.Cache, tran);
list.Add(new BillingData(arTran, rule, tran, subCD, note, files));
if (billingItems.ContainsKey(tran.InventoryID.Value))
{
if (availableQty.ContainsKey(tran.InventoryID.Value))
{
decimal available = availableQty[tran.InventoryID.Value];
if (tran.BillableQty <= available)
{
//Transaction is already payed for as a post payment included. Thus it should be free.
arTran.TranDesc = PXMessages.LocalizeNoPrefix(CT.Messages.PrefixIncludedUsage) + " " + tran.Description;
availableQty[tran.InventoryID.Value] -= arTran.Qty.Value; //decrease available qty
arTran.UnitPrice = 0;
arTran.ExtPrice = 0;
arTran.TranAmt = 0;
}
else
{
arTran.TranDesc = PXMessages.LocalizeNoPrefix(CT.Messages.PrefixOverused) + " " + tran.Description;
arTran.Qty = arTran.Qty - available;
availableQty[tran.InventoryID.Value] = 0; //all available qty was used.
}
}
}
tran.Billed = true;
tran.BilledDate = billingDate;
Transactions.Update(tran);
}
return(list);
}
public virtual void GenerateProc(Schedule s, short Times, DateTime runDate)
{
string LastBatchNbr = "0000000000";
Int64 LastInfoID = -1;
List <ScheduleDet> sd = MakeSchedule(s, Times, runDate);
using (PXTransactionScope ts = new PXTransactionScope())
{
foreach (ScheduleDet d in sd)
{
foreach (BatchNew b in PXSelect <BatchNew, Where <BatchNew.scheduleID, Equal <Optional <Schedule.scheduleID> >, And <BatchNew.scheduled, Equal <boolTrue> > > > .Select(this, s.ScheduleID))
{
BatchNew copy = PXCache <BatchNew> .CreateCopy(b);
copy.OrigBatchNbr = copy.BatchNbr;
copy.OrigModule = copy.Module;
copy.CuryInfoID = null;
copy.NumberCode = "GLREC";
copy.NoteID = null;
CurrencyInfo info = (CurrencyInfo)PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CurrencyInfo.curyInfoID> > > > .Select(this, b.CuryInfoID);
if (info != null)
{
CurrencyInfo infocopy = PXCache <CurrencyInfo> .CreateCopy(info);
infocopy.CuryInfoID = LastInfoID;
copy.CuryInfoID = LastInfoID;
CuryInfo_Created.Cache.Insert(infocopy);
}
copy.Posted = false;
copy.Released = false;
copy.Status = "B";
copy.Scheduled = false;
copy.DateEntered = d.ScheduledDate;
copy.FinPeriodID = d.ScheduledPeriod;
copy.TranPeriodID = null;
copy.BatchNbr = LastBatchNbr;
copy.RefBatchNbr = LastBatchNbr;
LastBatchNbr = AutoNumberAttribute.NextNumber(LastBatchNbr);
LastInfoID--;
copy = (BatchNew)Batch_Created.Cache.Insert(copy);
CurrencyInfoAttribute.SetEffectiveDate <Batch.dateEntered>(Batch_Created.Cache, new PXFieldUpdatedEventArgs(copy, null, false));
PXNoteAttribute.SetNote(Batch_Created.Cache, copy, PXNoteAttribute.GetNote(Caches[typeof(BatchNew)], b));
PXNoteAttribute.SetFileNotes(Batch_Created.Cache, copy, PXNoteAttribute.GetFileNotes(Caches[typeof(BatchNew)], b));
foreach (GLTranNew tran in PXSelect <GLTranNew, Where <GLTranNew.module, Equal <Required <GLTranNew.module> >, And <GLTranNew.batchNbr, Equal <Required <GLTranNew.batchNbr> > > > > .Select(this, b.Module, b.BatchNbr))
{
GLTranNew trancopy = PXCache <GLTranNew> .CreateCopy(tran);
trancopy.OrigBatchNbr = trancopy.BatchNbr;
trancopy.OrigModule = trancopy.Module;
trancopy.BatchNbr = copy.BatchNbr;
trancopy.RefBatchNbr = copy.RefBatchNbr;
trancopy.CuryInfoID = copy.CuryInfoID;
trancopy.CATranID = null;
trancopy.TranDate = d.ScheduledDate;
trancopy.FinPeriodID = d.ScheduledPeriod;
trancopy.TranPeriodID = d.ScheduledPeriod;
Tran_Created.Cache.Insert(trancopy);
}
}
s.LastRunDate = d.ScheduledDate;
Running_Schedule.Cache.Update(s);
}
Running_Schedule.Cache.Persist(PXDBOperation.Update);
Batch_Created.Cache.Persist(PXDBOperation.Insert);
Batch_Created.Cache.Persist(PXDBOperation.Update);
foreach (GLTranNew tran in Tran_Created.Cache.Inserted)
{
foreach (BatchNew batch in Batch_Created.Cache.Cached)
{
if (object.Equals(batch.RefBatchNbr, tran.RefBatchNbr))
{
tran.BatchNbr = batch.BatchNbr;
tran.CuryInfoID = batch.CuryInfoID;
if (!string.IsNullOrEmpty(batch.RefNbr))
{
tran.RefNbr = batch.RefNbr;
}
break;
}
}
}
Tran_Created.Cache.Normalize();
Tran_Created.Cache.Persist(PXDBOperation.Insert);
Tran_Created.Cache.Persist(PXDBOperation.Update);
Caches[typeof(CA.CADailySummary)].Persist(PXDBOperation.Insert);
ts.Complete(this);
}
Running_Schedule.Cache.Persisted(false);
Batch_Created.Cache.Persisted(false);
Tran_Created.Cache.Persisted(false);
Caches[typeof(CA.CADailySummary)].Persisted(false);
}
public static void ReleaseDoc(EPExpenseClaim claim)
{
APInvoiceEntry docgraph = PXGraph.CreateInstance <APInvoiceEntry>();
ExpenseClaimEntry expenseclaim = PXGraph.CreateInstance <ExpenseClaimEntry>();
if (claim.FinPeriodID == null)
{
throw new PXException(Messages.ReleaseClaimWithoutFinPeriod);
}
//docgraph.FieldVerifying.AddHandler<APInvoice.vendorLocationID>(APInterceptor);
EPEmployee employee = PXSelect <EPEmployee, Where <EPEmployee.bAccountID, Equal <Required <EPExpenseClaim.employeeID> > > > .Select(docgraph, claim.EmployeeID);
Location emplocation = PXSelect <Location, Where <Location.bAccountID, Equal <Required <EPExpenseClaim.employeeID> >, And <Location.locationID, Equal <Required <EPExpenseClaim.locationID> > > > > .Select(docgraph, claim.EmployeeID, claim.LocationID);
EPSetup epsetup = PXSelectReadonly <EPSetup> .Select(docgraph);
APSetup apsetup = PXSelectReadonly <APSetup> .Select(docgraph);
docgraph.vendor.Current = employee;
docgraph.location.Current = emplocation;
CurrencyInfo infoOriginal = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <EPExpenseClaim.curyInfoID> > > > .Select(docgraph, claim.CuryInfoID);
CurrencyInfo info = PXCache <CurrencyInfo> .CreateCopy(infoOriginal);
info.CuryInfoID = null;
info = docgraph.currencyinfo.Insert(info);
APInvoice invoice = new APInvoice();
invoice.CuryInfoID = info.CuryInfoID;
invoice.Hold = true;
invoice.Released = false;
invoice.Printed = false;
invoice.OpenDoc = true;
invoice.DocDate = claim.DocDate;
invoice.InvoiceNbr = claim.RefNbr;
invoice.DocDesc = claim.DocDesc;
invoice.VendorID = claim.EmployeeID;
invoice.CuryID = info.CuryID;
invoice.VendorLocationID = claim.LocationID;
invoice.APAccountID = emplocation != null ? emplocation.APAccountID : null;
invoice.APSubID = emplocation != null ? emplocation.APSubID : null;
invoice.TaxZoneID = claim.TaxZoneID;
invoice = docgraph.Document.Insert(invoice);
PXCache claimcache = docgraph.Caches[typeof(EPExpenseClaim)];
PXCache claimdetailcache = docgraph.Caches[typeof(EPExpenseClaimDetails)];
if (epsetup.CopyNotesAP == true)
{
string note = PXNoteAttribute.GetNote(claimcache, claim);
if (note != null)
{
PXNoteAttribute.SetNote(docgraph.Document.Cache, invoice, note);
}
}
if (epsetup.CopyFilesAP == true)
{
Guid[] files = PXNoteAttribute.GetFileNotes(claimcache, claim);
if (files != null && files.Length > 0)
{
PXNoteAttribute.SetFileNotes(docgraph.Document.Cache, invoice, files);
}
}
using (PXConnectionScope cs = new PXConnectionScope())
{
using (PXTransactionScope ts = new PXTransactionScope())
{
TaxAttribute.SetTaxCalc <APTran.taxCategoryID, APTaxAttribute>(docgraph.Transactions.Cache, null, TaxCalc.ManualCalc);
foreach (PXResult <EPExpenseClaimDetails, Contract> res in PXSelectJoin <EPExpenseClaimDetails,
LeftJoin <Contract, On <EPExpenseClaimDetails.contractID, Equal <Contract.contractID> > >,
Where <EPExpenseClaimDetails.refNbr, Equal <Required <EPExpenseClaim.refNbr> > > > .Select(docgraph, claim.RefNbr))
{
EPExpenseClaimDetails claimdetail = (EPExpenseClaimDetails)res;
Contract contract = (Contract)res;
if (claimdetail.TaskID != null)
{
PMTask task = PXSelect <PMTask, Where <PMTask.taskID, Equal <Required <PMTask.taskID> > > > .Select(expenseclaim, claimdetail.TaskID);
if (task != null && !(bool)task.VisibleInAP)
{
throw new PXException(PM.Messages.TaskInvisibleInModule, task.TaskCD, BatchModule.AP);
}
}
APTran tran = new APTran();
tran.InventoryID = claimdetail.InventoryID;
tran.TranDesc = claimdetail.TranDesc;
tran.CuryUnitCost = claimdetail.CuryUnitCost;
tran.Qty = claimdetail.Qty;
tran.UOM = claimdetail.UOM;
tran.NonBillable = claimdetail.Billable != true;
tran.CuryLineAmt = claimdetail.CuryTranAmt;
tran.Date = claimdetail.ExpenseDate;
if (contract.BaseType == PM.PMProject.ProjectBaseType.Project)
{
tran.ProjectID = claimdetail.ContractID;
}
else
{
tran.ProjectID = PM.ProjectDefaultAttribute.NonProject(docgraph);
}
tran.TaskID = claimdetail.TaskID;
tran.AccountID = claimdetail.ExpenseAccountID;
tran.SubID = claimdetail.ExpenseSubID;
tran.TaxCategoryID = claimdetail.TaxCategoryID;
tran = docgraph.Transactions.Insert(tran);
if (epsetup.CopyNotesAP == true)
{
string note = PXNoteAttribute.GetNote(claimdetailcache, claimdetail);
if (note != null)
{
PXNoteAttribute.SetNote(docgraph.Transactions.Cache, tran, note);
}
}
if (epsetup.CopyFilesAP == true)
{
Guid[] files = PXNoteAttribute.GetFileNotes(claimdetailcache, claimdetail);
if (files != null && files.Length > 0)
{
PXNoteAttribute.SetFileNotes(docgraph.Transactions.Cache, tran, files);
}
}
claimdetail.Released = true;
expenseclaim.ExpenseClaimDetails.Update(claimdetail);
}
foreach (EPTaxTran tax in PXSelect <EPTaxTran, Where <EPTaxTran.refNbr, Equal <Required <EPTaxTran.refNbr> > > > .Select(docgraph, claim.RefNbr))
{
APTaxTran new_aptax = new APTaxTran();
new_aptax.TaxID = tax.TaxID;
new_aptax = docgraph.Taxes.Insert(new_aptax);
if (new_aptax != null)
{
new_aptax = PXCache <APTaxTran> .CreateCopy(new_aptax);
new_aptax.TaxRate = tax.TaxRate;
new_aptax.CuryTaxableAmt = tax.CuryTaxableAmt;
new_aptax.CuryTaxAmt = tax.CuryTaxAmt;
new_aptax = docgraph.Taxes.Update(new_aptax);
}
}
invoice.CuryOrigDocAmt = invoice.CuryDocBal;
invoice.Hold = false;
docgraph.Document.Update(invoice);
docgraph.Save.Press();
claim.Status = EPClaimStatus.Released;
claim.Released = true;
claim.APRefNbr = invoice.RefNbr;
claim.APDocType = invoice.DocType;
expenseclaim.ExpenseClaim.Update(claim);
#region EP History Update
EPHistory hist = new EPHistory();
hist.EmployeeID = invoice.VendorID;
hist.FinPeriodID = invoice.FinPeriodID;
hist = (EPHistory)expenseclaim.Caches[typeof(EPHistory)].Insert(hist);
hist.FinPtdClaimed += invoice.DocBal;
hist.FinYtdClaimed += invoice.DocBal;
if (invoice.FinPeriodID == invoice.TranPeriodID)
{
hist.TranPtdClaimed += invoice.DocBal;
hist.TranYtdClaimed += invoice.DocBal;
}
else
{
EPHistory tranhist = new EPHistory();
tranhist.EmployeeID = invoice.VendorID;
tranhist.FinPeriodID = invoice.TranPeriodID;
tranhist = (EPHistory)expenseclaim.Caches[typeof(EPHistory)].Insert(tranhist);
tranhist.TranPtdClaimed += invoice.DocBal;
tranhist.TranYtdClaimed += invoice.DocBal;
}
expenseclaim.Views.Caches.Add(typeof(EPHistory));
#endregion
expenseclaim.Save.Press();
ts.Complete();
}
}
if ((bool)epsetup.AutomaticReleaseAP == true)
{
List <APRegister> doclist = new List <APRegister>();
doclist.Add(docgraph.Document.Current);
APDocumentRelease.ReleaseDoc(doclist, false);
}
}
public static PXRedirectRequiredException CreatePOOrders2(
System.Collections.Generic.List <POFixedDemand> list,
DateTime?PurchDate,
bool extSort)
{
POOrderEntry docgraph = PXGraph.CreateInstance <POOrderEntry>();
docgraph.Views.Caches.Add(typeof(POOrderEntry.SOLineSplit3));
POSetup current = docgraph.POSetup.Current;
DocumentList <POOrder> documentList1 = new DocumentList <POOrder>((PXGraph)docgraph);
Dictionary <string, DocumentList <POLine> > dictionary = new Dictionary <string, DocumentList <POLine> >();
list.Sort((Comparison <POFixedDemand>)((a, b) =>
{
string empty1 = string.Empty;
string empty2 = string.Empty;
string str;
if (a.PlanType == "90")
{
PX.Objects.IN.InventoryItem inventoryItem = PX.Objects.IN.InventoryItem.PK.Find((PXGraph)docgraph, a.InventoryID);
str = string.Format("ZZ.{0}", inventoryItem == null ? (object)string.Empty : (object)inventoryItem.InventoryCD);
}
else
{
POOrderEntry.SOLineSplit3 soLineSplit3 = (POOrderEntry.SOLineSplit3)PXSelectBase <POOrderEntry.SOLineSplit3, PXSelect <POOrderEntry.SOLineSplit3, Where <POOrderEntry.SOLineSplit3.planID, Equal <Required <POOrderEntry.SOLineSplit3.planID> > > > .Config> .Select((PXGraph)docgraph, (object)a.PlanID);
str = soLineSplit3 == null ? string.Empty : string.Format("{0}.{1}.{2:D7}", (object)soLineSplit3.OrderType, (object)soLineSplit3.OrderNbr, (object)soLineSplit3.SortOrder.GetValueOrDefault());
}
string strB;
if (b.PlanType == "90")
{
PX.Objects.IN.InventoryItem inventoryItem = PX.Objects.IN.InventoryItem.PK.Find((PXGraph)docgraph, b.InventoryID);
strB = string.Format("ZZ.{0}", inventoryItem == null ? (object)string.Empty : (object)inventoryItem.InventoryCD);
}
else
{
POOrderEntry.SOLineSplit3 soLineSplit3 = (POOrderEntry.SOLineSplit3)PXSelectBase <POOrderEntry.SOLineSplit3, PXSelect <POOrderEntry.SOLineSplit3, Where <POOrderEntry.SOLineSplit3.planID, Equal <Required <POOrderEntry.SOLineSplit3.planID> > > > .Config> .Select((PXGraph)docgraph, (object)b.PlanID);
strB = soLineSplit3 == null ? string.Empty : string.Format("{0}.{1}.{2:D7}", (object)soLineSplit3.OrderType, (object)soLineSplit3.OrderNbr, (object)soLineSplit3.SortOrder.GetValueOrDefault());
}
return(str.CompareTo(strB));
}));
POOrder poOrder1 = (POOrder)null;
bool flag1 = false;
foreach (POFixedDemand demand in list)
{
if (!(demand.FixedSource != "P"))
{
string OrderType = demand.PlanType == "6D" ? "DP" : (demand.PlanType == "6E" ? "DP" : "RO");
string str1 = (string)null;
int? nullable1 = demand.VendorID;
int num1;
if (nullable1.HasValue)
{
nullable1 = demand.VendorLocationID;
num1 = !nullable1.HasValue ? 1 : 0;
}
else
{
num1 = 1;
}
if (num1 != 0)
{
PXProcessing <POFixedDemand> .SetWarning(list.IndexOf(demand), "Vendor and vendor location should be defined.");
}
else
{
PXErrorLevel pxErrorLevel = PXErrorLevel.RowInfo;
string empty = string.Empty;
try
{
PX.Objects.SO.SOOrder soOrder = (PX.Objects.SO.SOOrder) PXSelectBase <PX.Objects.SO.SOOrder, PXSelect <PX.Objects.SO.SOOrder, Where <PX.Objects.SO.SOOrder.noteID, Equal <Required <PX.Objects.SO.SOOrder.noteID> > > > .Config> .Select((PXGraph)docgraph, (object)demand.RefNoteID);
POOrderEntry.SOLineSplit3 soLineSplit3 = (POOrderEntry.SOLineSplit3) PXSelectBase <POOrderEntry.SOLineSplit3, PXSelect <POOrderEntry.SOLineSplit3, Where <POOrderEntry.SOLineSplit3.planID, Equal <Required <POOrderEntry.SOLineSplit3.planID> > > > .Config> .Select((PXGraph)docgraph, (object)demand.PlanID);
string str2 = (string)null;
string str3 = (string)null;
if (demand.PlanType == "6B" || demand.PlanType == "6E")
{
str2 = soLineSplit3.POType;
str3 = soLineSplit3.PONbr;
}
System.Collections.Generic.List <FieldLookup> fieldLookupList1 = new System.Collections.Generic.List <FieldLookup>()
{
(FieldLookup) new FieldLookup <POOrder.orderType>((object)OrderType),
(FieldLookup) new FieldLookup <POOrder.vendorID>((object)demand.VendorID),
(FieldLookup) new FieldLookup <POOrder.vendorLocationID>((object)demand.VendorLocationID),
(FieldLookup) new FieldLookup <POOrder.bLOrderNbr>((object)str3)
};
if (OrderType == "RO")
{
bool?projectPerDocument = docgraph.apsetup.Current.RequireSingleProjectPerDocument;
bool flag2 = true;
if (projectPerDocument.GetValueOrDefault() == flag2 & projectPerDocument.HasValue)
{
nullable1 = demand.ProjectID;
int?nullable2 = nullable1.HasValue ? nullable1 : ProjectDefaultAttribute.NonProject();
fieldLookupList1.Add((FieldLookup) new FieldLookup <POOrder.projectID>((object)nullable2));
}
int num2;
if (poOrder1 != null && poOrder1.ShipDestType == "L")
{
nullable1 = poOrder1.SiteID;
num2 = !nullable1.HasValue ? 1 : 0;
}
else
{
num2 = 0;
}
if (num2 == 0)
{
fieldLookupList1.Add((FieldLookup) new FieldLookup <POOrder.siteID>((object)demand.POSiteID));
}
}
else if (OrderType == "DP")
{
fieldLookupList1.Add((FieldLookup) new FieldLookup <POOrder.sOOrderType>((object)soLineSplit3.OrderType));
fieldLookupList1.Add((FieldLookup) new FieldLookup <POOrder.sOOrderNbr>((object)soLineSplit3.OrderNbr));
}
else
{
fieldLookupList1.Add((FieldLookup) new FieldLookup <POOrder.shipToBAccountID>((object)soOrder.CustomerID));
fieldLookupList1.Add((FieldLookup) new FieldLookup <POOrder.shipToLocationID>((object)soOrder.CustomerLocationID));
fieldLookupList1.Add((FieldLookup) new FieldLookup <POOrder.siteID>((object)demand.POSiteID));
}
poOrder1 = documentList1.Find(fieldLookupList1.ToArray()) ?? new POOrder();
if (poOrder1.OrderNbr == null)
{
docgraph.Clear();
poOrder1.OrderType = OrderType;
poOrder1 = PXCache <POOrder> .CreateCopy(docgraph.Document.Insert(poOrder1));
poOrder1.VendorID = demand.VendorID;
poOrder1.VendorLocationID = demand.VendorLocationID;
poOrder1.SiteID = demand.POSiteID;
nullable1 = demand.ProjectID;
if (nullable1.HasValue)
{
poOrder1.ProjectID = demand.ProjectID;
}
poOrder1.OrderDate = PurchDate;
poOrder1.BLType = str2;
poOrder1.BLOrderNbr = str3;
if (OrderType == "DP" | extSort)
{
poOrder1.SOOrderType = soLineSplit3.OrderType;
poOrder1.SOOrderNbr = soLineSplit3.OrderNbr;
}
if (!string.IsNullOrEmpty(poOrder1.BLOrderNbr))
{
POOrder poOrder2 = (POOrder)PXSelectBase <POOrder, PXSelect <POOrder, Where <POOrder.orderType, Equal <Current <POOrder.bLType> >, And <POOrder.orderNbr, Equal <Current <POOrder.bLOrderNbr> > > > > .Config> .SelectSingleBound((PXGraph)docgraph, new object[1]
{
(object)poOrder1
});
if (poOrder2 != null)
{
poOrder1.VendorRefNbr = poOrder2.VendorRefNbr;
}
}
if (OrderType == "DP")
{
poOrder1.ShipDestType = "C";
poOrder1.ShipToBAccountID = soOrder.CustomerID;
poOrder1.ShipToLocationID = soOrder.CustomerLocationID;
}
else if (current.ShipDestType == "S")
{
poOrder1.ShipDestType = "S";
poOrder1.SiteID = demand.POSiteID;
}
if (PXAccess.FeatureInstalled <PX.Objects.CS.FeaturesSet.multicurrency>())
{
docgraph.currencyinfo.Current.CuryID = (string)null;
}
poOrder1 = docgraph.Document.Update(poOrder1);
if (OrderType == "DP")
{
SOAddress soAddress = (SOAddress)PXSelectBase <SOAddress, PXSelect <SOAddress, Where <SOAddress.addressID, Equal <Required <PX.Objects.SO.SOOrder.shipAddressID> > > > .Config> .Select((PXGraph)docgraph, (object)soOrder.ShipAddressID);
bool?isDefaultAddress = soAddress.IsDefaultAddress;
bool flag2 = false;
if (isDefaultAddress.GetValueOrDefault() == flag2 & isDefaultAddress.HasValue)
{
SharedRecordAttribute.CopyRecord <POOrder.shipAddressID>(docgraph.Document.Cache, (object)poOrder1, (object)soAddress, true);
}
SOContact soContact = (SOContact)PXSelectBase <SOContact, PXSelect <SOContact, Where <SOContact.contactID, Equal <Required <PX.Objects.SO.SOOrder.shipContactID> > > > .Config> .Select((PXGraph)docgraph, (object)soOrder.ShipContactID);
bool?isDefaultContact = soContact.IsDefaultContact;
bool flag3 = false;
if (isDefaultContact.GetValueOrDefault() == flag3 & isDefaultContact.HasValue)
{
SharedRecordAttribute.CopyRecord <POOrder.shipContactID>(docgraph.Document.Cache, (object)poOrder1, (object)soContact, true);
}
DateTime?expectedDate = poOrder1.ExpectedDate;
DateTime?requestDate = soOrder.RequestDate;
if (expectedDate.HasValue & requestDate.HasValue && expectedDate.GetValueOrDefault() < requestDate.GetValueOrDefault())
{
poOrder1 = PXCache <POOrder> .CreateCopy(poOrder1);
poOrder1.ExpectedDate = soOrder.RequestDate;
poOrder1 = docgraph.Document.Update(poOrder1);
}
}
}
else if (!docgraph.Document.Cache.ObjectsEqual((object)docgraph.Document.Current, (object)poOrder1))
{
docgraph.Document.Current = (POOrder)docgraph.Document.Search <POOrder.orderNbr>((object)poOrder1.OrderNbr, (object)poOrder1.OrderType);
}
poOrder1.UpdateVendorCost = new bool?(false);
POLine poLine1 = (POLine)null;
DocumentList <POLine> documentList2;
if (!dictionary.TryGetValue(demand.PlanType, out documentList2))
{
documentList2 = dictionary[demand.PlanType] = new DocumentList <POLine>((PXGraph)docgraph);
}
if (OrderType == "RO" && demand.PlanType != "6B")
{
System.Collections.Generic.List <FieldLookup> fieldLookupList2 = new System.Collections.Generic.List <FieldLookup>();
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.vendorID>((object)demand.VendorID));
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.vendorLocationID>((object)demand.VendorLocationID));
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.siteID>((object)demand.POSiteID));
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.inventoryID>((object)demand.InventoryID));
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.subItemID>((object)demand.SubItemID));
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.requestedDate>((object)(DateTime?)soLineSplit3?.ShipDate));
int?nullable2;
if (soLineSplit3 == null)
{
nullable1 = new int?();
nullable2 = nullable1;
}
else
{
nullable2 = soLineSplit3.ProjectID;
}
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.projectID>((object)nullable2));
int?nullable3;
if (soLineSplit3 == null)
{
nullable1 = new int?();
nullable3 = nullable1;
}
else
{
nullable3 = soLineSplit3.TaskID;
}
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.taskID>((object)nullable3));
int?nullable4;
if (soLineSplit3 == null)
{
nullable1 = new int?();
nullable4 = nullable1;
}
else
{
nullable4 = soLineSplit3.CostCodeID;
}
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.costCodeID>((object)nullable4));
int?nullable5;
if (soLineSplit3 == null)
{
nullable1 = new int?();
nullable5 = nullable1;
}
else
{
nullable5 = soLineSplit3.LineNbr;
}
fieldLookupList2.Add((FieldLookup) new FieldLookup <POLine.lineNbr>((object)nullable5));
System.Collections.Generic.List <FieldLookup> fieldLookupList3 = fieldLookupList2;
bool?nullable6 = current.CopyLineDescrSO;
bool flag2 = true;
if (nullable6.GetValueOrDefault() == flag2 & nullable6.HasValue && soLineSplit3 != null)
{
fieldLookupList3.Add((FieldLookup) new FieldLookup <POLine.tranDesc>((object)soLineSplit3.TranDesc));
poLine1 = documentList2.Find(fieldLookupList3.ToArray());
int num2;
if (poLine1 != null)
{
nullable6 = current.CopyLineNoteSO;
bool flag3 = true;
if (nullable6.GetValueOrDefault() == flag3 & nullable6.HasValue)
{
num2 = PXNoteAttribute.GetNote(docgraph.Caches[typeof(POLine)], (object)poLine1) != null ? 1 : (PXNoteAttribute.GetNote(docgraph.Caches[typeof(POOrderEntry.SOLineSplit3)], (object)soLineSplit3) != null ? 1 : 0);
goto label_67;
}
}
num2 = 0;
label_67:
if (num2 != 0)
{
poLine1 = (POLine)null;
}
}
else
{
poLine1 = documentList2.Find(fieldLookupList3.ToArray());
}
}
POLine dest = poLine1 ?? new POLine();
POLine copy1;
if (dest.OrderNbr == null)
{
docgraph.FillPOLineFromDemand(dest, demand, OrderType, soLineSplit3);
POLine line = docgraph.Transactions.Insert(dest);
bool? copyLineNoteSo = current.CopyLineNoteSO;
bool flag2 = true;
if (copyLineNoteSo.GetValueOrDefault() == flag2 & copyLineNoteSo.HasValue && soLineSplit3 != null)
{
PXNoteAttribute.SetNote(docgraph.Transactions.Cache, (object)line, PXNoteAttribute.GetNote(docgraph.Caches[typeof(POOrderEntry.SOLineSplit3)], (object)soLineSplit3));
}
if (docgraph.onCopyPOLineFields != null)
{
docgraph.onCopyPOLineFields(demand, line);
}
copy1 = PXCache <POLine> .CreateCopy(line);
documentList2.Add(copy1);
}
else
{
copy1 = PXCache <POLine> .CreateCopy((POLine)PXSelectBase <POLine, PXSelect <POLine, Where <POLine.orderType, Equal <Current <POOrder.orderType> >, And <POLine.orderNbr, Equal <Current <POOrder.orderNbr> >, And <POLine.lineNbr, Equal <Current <POLine.lineNbr> > > > > > .Config> .SelectSingleBound((PXGraph)docgraph, new object[1]
{
(object)dest
}));
POLine poLine2 = copy1;
Decimal?orderQty1 = poLine2.OrderQty;
Decimal?orderQty2 = demand.OrderQty;
poLine2.OrderQty = orderQty1.HasValue & orderQty2.HasValue ? new Decimal?(orderQty1.GetValueOrDefault() + orderQty2.GetValueOrDefault()) : new Decimal?();
}
if (demand.PlanType == "6B" || demand.PlanType == "6E")
{
str1 = demand.PlanType == "6B" ? "66" : "6D";
demand.FixedSource = "P";
copy1.POType = soLineSplit3.POType;
copy1.PONbr = soLineSplit3.PONbr;
copy1.POLineNbr = soLineSplit3.POLineNbr;
POLine poLine2 = (POLine)PXSelectBase <POLine, PXSelect <POLine, Where <POLine.orderType, Equal <Current <POLine.pOType> >, And <POLine.orderNbr, Equal <Current <POLine.pONbr> >, And <POLine.lineNbr, Equal <Current <POLine.pOLineNbr> > > > > > .Config> .SelectSingleBound((PXGraph)docgraph, new object[1]
{
(object)copy1
});
if (poLine2 != null)
{
Decimal?nullable2 = demand.PlanQty;
Decimal?baseOpenQty = poLine2.BaseOpenQty;
if (nullable2.GetValueOrDefault() > baseOpenQty.GetValueOrDefault() & (nullable2.HasValue & baseOpenQty.HasValue))
{
POLine poLine3 = copy1;
Decimal?orderQty = poLine3.OrderQty;
nullable2 = demand.OrderQty;
poLine3.OrderQty = orderQty.HasValue & nullable2.HasValue ? new Decimal?(orderQty.GetValueOrDefault() - nullable2.GetValueOrDefault()) : new Decimal?();
if (string.Equals(copy1.UOM, poLine2.UOM))
{
POLine poLine4 = copy1;
nullable2 = poLine4.OrderQty;
Decimal?openQty = poLine2.OpenQty;
poLine4.OrderQty = nullable2.HasValue & openQty.HasValue ? new Decimal?(nullable2.GetValueOrDefault() + openQty.GetValueOrDefault()) : new Decimal?();
}
else
{
PXDBQuantityAttribute.CalcBaseQty <POLine.orderQty>(docgraph.Transactions.Cache, (object)copy1);
POLine poLine4 = copy1;
Decimal?baseOrderQty = poLine4.BaseOrderQty;
nullable2 = poLine2.BaseOpenQty;
poLine4.BaseOrderQty = baseOrderQty.HasValue & nullable2.HasValue ? new Decimal?(baseOrderQty.GetValueOrDefault() + nullable2.GetValueOrDefault()) : new Decimal?();
PXDBQuantityAttribute.CalcTranQty <POLine.orderQty>(docgraph.Transactions.Cache, (object)copy1);
}
pxErrorLevel = PXErrorLevel.RowWarning;
empty += PXMessages.LocalizeFormatNoPrefixNLA("Order Quantity reduced to Blanket Order: '{0}' Open Qty. for this item", (object)copy1.PONbr);
}
copy1.CuryUnitCost = poLine2.CuryUnitCost;
copy1.UnitCost = poLine2.UnitCost;
}
}
copy1.SiteID = POCreate_Extension.GetWasrehouseByBranch((PXGraph)docgraph, copy1.BranchID);
short? vleadTime = docgraph.location.Current.VLeadTime;
POLine poLine5 = copy1;
DateTime dateTime = soLineSplit3.ShipDate.Value;
ref DateTime local = ref dateTime;
short? nullable7 = vleadTime;
nullable1 = nullable7.HasValue ? new int?((int)nullable7.GetValueOrDefault()) : new int?();
int num3 = 0;
double num4 = nullable1.GetValueOrDefault() > num3 & nullable1.HasValue ? (double)-vleadTime.Value : -14.0;
DateTime?nullable8 = new DateTime?(local.AddDays(num4));
poLine5.RequestedDate = nullable8;
POLine poLine6 = docgraph.Transactions.Update(copy1);
PXCache cach = docgraph.Caches[typeof(INItemPlan)];
POCreate_Extension.CreateSplitDemand2(cach, demand);
cach.SetStatus((object)demand, PXEntryStatus.Updated);
demand.SupplyPlanID = poLine6.PlanID;
if (str1 != null)
{
cach.RaiseRowDeleted((object)demand);
demand.PlanType = str1;
cach.RaiseRowInserted((object)demand);
}
if (soLineSplit3 != null)
{
int num2;
if (demand.AlternateID != null)
{
nullable1 = demand.InventoryID;
num2 = nullable1.HasValue ? 1 : 0;
}
else
{
num2 = 0;
}
if (num2 != 0)
{
PXSelectBase <INItemXRef> pxSelectBase = (PXSelectBase <INItemXRef>) new PXSelect <INItemXRef, Where <INItemXRef.inventoryID, Equal <Required <INItemXRef.inventoryID> >, And <INItemXRef.alternateID, Equal <Required <INItemXRef.alternateID> > > > >((PXGraph)docgraph);
INItemXRef inItemXref1 = (INItemXRef)pxSelectBase.Select((object)demand.InventoryID, (object)demand.AlternateID);
if (inItemXref1 != null && inItemXref1.AlternateType == "GLBL")
{
int num5;
if (poLine6.AlternateID != null)
{
nullable1 = poLine6.InventoryID;
num5 = nullable1.HasValue ? 1 : 0;
}
else
{
num5 = 0;
}
if (num5 != 0)
{
INItemXRef inItemXref2 = (INItemXRef)pxSelectBase.Select((object)poLine6.InventoryID, (object)poLine6.AlternateID);
if (inItemXref2 != null && inItemXref2.AlternateType == "GLBL")
{
poLine6.AlternateID = demand.AlternateID;
}
}
else
{
poLine6.AlternateID = demand.AlternateID;
}
}
}
soLineSplit3.POType = poLine6.OrderType;
soLineSplit3.PONbr = poLine6.OrderNbr;
soLineSplit3.POLineNbr = poLine6.LineNbr;
soLineSplit3.RefNoteID = docgraph.Document.Current.NoteID;
PX.Objects.SO.SOLine soLine = SelectFrom <PX.Objects.SO.SOLine> .Where <PX.Objects.SO.SOLine.orderType.IsEqual <P.AsString>
.And <PX.Objects.SO.SOLine.orderNbr.IsEqual <P.AsString>
.And <PX.Objects.SO.SOLine.lineNbr.IsEqual <P.AsInt> > > > .View.ReadOnly.Select((PXGraph)docgraph, (object)soLineSplit3.OrderType, (object)soLineSplit3.OrderNbr, (object)soLineSplit3.LineNbr);
POLineExt extension1 = poLine6.GetExtension <POLineExt>();
SOLineExt extension2 = soLine.GetExtension <SOLineExt>();
extension1.UsrEndCustomerID = extension2.UsrEndCustomerID;
extension1.UsrNonStockItem = extension2.UsrNonStockItem;
extension1.UsrProjectNbr = extension2.UsrProjectNbr;
if (!string.IsNullOrEmpty(extension2.UsrProjectNbr))
{
FLXProject flxProject = SelectFrom <FLXProject> .Where <FLXProject.projectNbr.IsEqual <P.AsString> > .View.ReadOnly.Select((PXGraph)docgraph, (object)extension2.UsrProjectNbr);
extension1.UsrCust2Factory = flxProject.Cust2Factory;
extension1.UsrFactoryPN = flxProject.FactoryPN;
}
docgraph.GetExtension <POOrderEntry_Extension>().UpdateSOLine(soLineSplit3, docgraph.Document.Current.VendorID, true);
docgraph.FixedDemand.Cache.SetStatus((object)soLineSplit3, PXEntryStatus.Updated);
}
if (docgraph.Transactions.Cache.IsInsertedUpdatedDeleted)
{
using (PXTransactionScope transactionScope = new PXTransactionScope())
{
docgraph.Save.Press();
if (demand.PlanType == "90")
{
docgraph.Replenihment.Current = (INReplenishmentOrder)docgraph.Replenihment.Search <INReplenishmentOrder.noteID>((object)demand.RefNoteID);
if (docgraph.Replenihment.Current != null)
{
INReplenishmentLine copy2 = PXCache <INReplenishmentLine> .CreateCopy(docgraph.ReplenishmentLines.Insert(new INReplenishmentLine()));
copy2.InventoryID = poLine6.InventoryID;
copy2.SubItemID = poLine6.SubItemID;
copy2.UOM = poLine6.UOM;
copy2.VendorID = poLine6.VendorID;
copy2.VendorLocationID = poLine6.VendorLocationID;
copy2.Qty = poLine6.OrderQty;
copy2.POType = poLine6.OrderType;
copy2.PONbr = docgraph.Document.Current.OrderNbr;
copy2.POLineNbr = poLine6.LineNbr;
copy2.SiteID = demand.POSiteID;
copy2.PlanID = demand.PlanID;
docgraph.ReplenishmentLines.Update(copy2);
docgraph.Caches[typeof(INItemPlan)].Delete((object)demand);
docgraph.Save.Press();
}
}
transactionScope.Complete();
}
if (pxErrorLevel == PXErrorLevel.RowInfo)
{
PXProcessing <POFixedDemand> .SetInfo(list.IndexOf(demand), PXMessages.LocalizeFormatNoPrefixNLA("Purchase Order '{0}' created.", (object)docgraph.Document.Current.OrderNbr) + "\r\n" + empty);
}
else
{
PXProcessing <POFixedDemand> .SetWarning(list.IndexOf(demand), PXMessages.LocalizeFormatNoPrefixNLA("Purchase Order '{0}' created.", (object)docgraph.Document.Current.OrderNbr) + "\r\n" + empty);
}
if (documentList1.Find((object)docgraph.Document.Current) == null)
{
documentList1.Add(docgraph.Document.Current);
}
}
}
protected virtual IEnumerable UpdateOpenInvoice(PXAdapter adapter)
{
var order = Base.CurrentDocument.Current;
if (order != null)
{
string noteInfo = PXNoteAttribute.GetNote(Base.CurrentDocument.Cache, order);
APILibrary.Model.Root root = JsonConvert.DeserializeObject <APILibrary.Model.Root>(noteInfo);
if (root != null)
{
using (PXTransactionScope ts = new PXTransactionScope())
{
if (root.description == null)
{
goto Item;
}
order.OrderDesc = root.description;
Base.CurrentDocument.Cache.MarkUpdated(order);
PXUpdateJoin <Set <ARInvoice.docDesc, Required <SOOrder.orderDesc> >,
ARInvoice,
InnerJoin <SOOrderShipment, On <SOOrderShipment.invoiceType, Equal <ARInvoice.docType>,
And <SOOrderShipment.invoiceNbr, Equal <ARInvoice.refNbr> > > >,
Where <SOOrderShipment.orderNoteID, Equal <Required <SOOrder.noteID> > > > .Update(Base, root.description, order.NoteID);
Item:
for (int i = 0; i < root.item.Count; i++)
{
if (root.item[i].sku == null)
{
goto Invoice;
}
foreach (SOLine row in Base.Transactions.Select())
{
if (string.Format("{0}-{1}", (int)row.OrderQty, InventoryItem.PK.Find(Base, row.InventoryID).InventoryCD.TrimEnd()).CompareTo(root.item[i].qty + "-" + root.item[i].sku) == 0)
{
row.GetExtension <SOLineExt>().UsrAmazWHTaxAmt = (decimal)root.item[i].whTax;
Base.Transactions.Cache.MarkUpdated(row);
}
}
}
Base.Save.Press();
Invoice:
if (root.taxAmount != 0)
{
PXUpdateJoin <Set <TaxTran.curyTaxAmt, Required <TaxTran.curyTaxAmt> >,
TaxTran,
LeftJoin <ARInvoice, On <TaxTran.module, Equal <PX.Objects.GL.BatchModule.moduleAR>,
And <ARInvoice.docType, Equal <TaxTran.tranType>,
And <ARInvoice.refNbr, Equal <TaxTran.refNbr> > > >,
InnerJoin <SOOrderShipment, On <SOOrderShipment.invoiceType, Equal <ARInvoice.docType>,
And <SOOrderShipment.invoiceNbr, Equal <ARInvoice.refNbr> > > > >,
Where <SOOrderShipment.orderNoteID, Equal <Required <SOOrder.noteID> > > > .Update(Base, (decimal)root.taxAmount, order.NoteID);
PXUpdateJoin <Set <ARInvoice.curyTaxTotal, Required <ARInvoice.curyTaxTotal> >,
ARInvoice,
InnerJoin <SOOrderShipment, On <SOOrderShipment.invoiceType, Equal <ARInvoice.docType>,
And <SOOrderShipment.invoiceNbr, Equal <ARInvoice.refNbr> > > >,
Where <SOOrderShipment.orderNoteID, Equal <Required <SOOrder.noteID> > > > .Update(Base, (decimal)root.taxAmount, order.NoteID);
}
PXNoteAttribute.SetNote(Base.CurrentDocument.Cache, order, null);
ts.Complete();
}
}
}
return(adapter.Get());
}
public virtual void GenerateProc(Schedule s, short Times, DateTime runDate)
{
List <ScheduleDet> sd = GL.ScheduleProcess.MakeSchedule(this, s, Times, runDate);
ARInvoiceEntry docgraph = CreateGraph();
foreach (ScheduleDet sdet in sd)
{
foreach (PXResult <ARInvoice, Customer, CurrencyInfo> res in PXSelectJoin <ARInvoice, InnerJoin <Customer, On <Customer.bAccountID, Equal <ARInvoice.customerID> >, InnerJoin <CurrencyInfo, On <CurrencyInfo.curyInfoID, Equal <ARInvoice.curyInfoID> > > >, Where <ARInvoice.scheduleID, Equal <Required <ARInvoice.scheduleID> >, And <ARInvoice.scheduled, Equal <boolTrue> > > > .Select(this, s.ScheduleID))
{
docgraph.Clear();
docgraph.customer.Current = (Customer)res;
ARInvoice apdoc = (ARInvoice)res;
CurrencyInfo info = (CurrencyInfo)res;
CurrencyInfo new_info = PXCache <CurrencyInfo> .CreateCopy(info);
new_info.CuryInfoID = null;
new_info = docgraph.currencyinfo.Insert(new_info);
ARInvoice new_ardoc = PXCache <ARInvoice> .CreateCopy(apdoc);
new_ardoc.CuryInfoID = new_info.CuryInfoID;
new_ardoc.DocDate = sdet.ScheduledDate;
new_ardoc.FinPeriodID = sdet.ScheduledPeriod;
new_ardoc.TranPeriodID = null;
new_ardoc.DueDate = null;
new_ardoc.DiscDate = null;
new_ardoc.CuryOrigDiscAmt = null;
new_ardoc.OrigDiscAmt = null;
new_ardoc.RefNbr = null;
new_ardoc.Scheduled = false;
new_ardoc.CuryLineTotal = 0m;
new_ardoc.CuryVatTaxableTotal = 0m;
new_ardoc.CuryVatExemptTotal = 0m;
new_ardoc.NoteID = null;
bool forceClear = false;
bool clearPM = false;
if (new_ardoc.PMInstanceID.HasValue)
{
PXResult <CustomerPaymentMethod, CA.PaymentMethod> pmiResult = (PXResult <CustomerPaymentMethod, CA.PaymentMethod>) PXSelectJoin <CustomerPaymentMethod, InnerJoin <CA.PaymentMethod, On <CA.PaymentMethod.paymentMethodID, Equal <CustomerPaymentMethod.paymentMethodID> > >, Where <CustomerPaymentMethod.pMInstanceID, Equal <Required <CustomerPaymentMethod.pMInstanceID> > > > .Select(docgraph, new_ardoc.PMInstanceID);
if (pmiResult != null)
{
CustomerPaymentMethod pmInstance = pmiResult;
CA.PaymentMethod paymentMethod = pmiResult;
if (pmInstance == null || pmInstance.IsActive != true || paymentMethod.IsActive != true || paymentMethod.UseForAR != true)
{
clearPM = true;
forceClear = true;
}
}
else
{
clearPM = true;
forceClear = true;
}
}
else
{
if (string.IsNullOrEmpty(new_ardoc.PaymentMethodID) == false)
{
CA.PaymentMethod pm = PXSelect <CA.PaymentMethod, Where <CA.PaymentMethod.paymentMethodID, Equal <Required <CA.PaymentMethod.paymentMethodID> > > > .Select(docgraph, new_ardoc.PaymentMethodID);
if (pm == null || pm.IsActive != true || pm.UseForAR != true)
{
clearPM = true;
forceClear = true;
}
}
}
if (clearPM)
{
new_ardoc.PMInstanceID = null;
new_ardoc.PaymentMethodID = null;
new_ardoc.CashAccountID = null;
}
new_ardoc = docgraph.Document.Insert(new_ardoc);
//force creditrule back
docgraph.customer.Current = (Customer)res;
if (forceClear == true)
{
ARInvoice copy = PXCache <ARInvoice> .CreateCopy(new_ardoc);
copy.PMInstanceID = null;
copy.PaymentMethodID = null;
copy.CashAccountID = null;
new_ardoc = docgraph.Document.Update(copy);
}
AddressAttribute.CopyRecord <ARInvoice.billAddressID>(docgraph.Document.Cache, new_ardoc, apdoc, false);
ContactAttribute.CopyRecord <ARInvoice.billContactID>(docgraph.Document.Cache, new_ardoc, apdoc, false);
TaxAttribute.SetTaxCalc <ARTran.taxCategoryID, ARTaxAttribute>(docgraph.Transactions.Cache, null, TaxCalc.ManualCalc);
PXNoteAttribute.SetNote(docgraph.Document.Cache, new_ardoc, PXNoteAttribute.GetNote(Caches[typeof(ARInvoice)], apdoc));
PXNoteAttribute.SetFileNotes(docgraph.Document.Cache, new_ardoc, PXNoteAttribute.GetFileNotes(Caches[typeof(ARInvoice)], apdoc));
foreach (ARTran aptran in PXSelect <ARTran, Where <ARTran.tranType, Equal <Required <ARTran.tranType> >, And <ARTran.refNbr, Equal <Required <ARTran.refNbr> > > > > .Select(docgraph, apdoc.DocType, apdoc.RefNbr))
{
ARTran new_aptran = PXCache <ARTran> .CreateCopy(aptran);
new_aptran.RefNbr = null;
new_aptran.CuryInfoID = null;
docgraph.Transactions.Insert(new_aptran);
}
foreach (ARTaxTran tax in PXSelect <ARTaxTran, Where <ARTaxTran.tranType, Equal <Required <ARTaxTran.tranType> >, And <ARTaxTran.refNbr, Equal <Required <ARTaxTran.refNbr> > > > > .Select(docgraph, apdoc.DocType, apdoc.RefNbr))
{
ARTaxTran new_artax = new ARTaxTran();
new_artax.TaxID = tax.TaxID;
new_artax = docgraph.Taxes.Insert(new_artax);
if (new_artax != null)
{
new_artax = PXCache <ARTaxTran> .CreateCopy(new_artax);
new_artax.TaxRate = tax.TaxRate;
new_artax.CuryTaxableAmt = tax.CuryTaxableAmt;
new_artax.CuryTaxAmt = tax.CuryTaxAmt;
new_artax = docgraph.Taxes.Update(new_artax);
}
}
docgraph.Save.Press();
}
s.LastRunDate = sdet.ScheduledDate;
Running_Schedule.Cache.Update(s);
}
using (PXTransactionScope ts = new PXTransactionScope())
{
Running_Schedule.Cache.Persist(PXDBOperation.Update);
ts.Complete(this);
}
Running_Schedule.Cache.Persisted(false);
}
public virtual void GenerateProc(Schedule s, short Times, DateTime runDate)
{
List <ScheduleDet> sd = GL.ScheduleProcess.MakeSchedule(this, s, Times, runDate);
APInvoiceEntry docgraph = CreateGraph();
foreach (ScheduleDet sdet in sd)
{
foreach (PXResult <APInvoice, Vendor, CurrencyInfo> res in PXSelectJoin <APInvoice, InnerJoin <Vendor, On <Vendor.bAccountID, Equal <APInvoice.vendorID> >, InnerJoin <CurrencyInfo, On <CurrencyInfo.curyInfoID, Equal <APInvoice.curyInfoID> > > >, Where <APInvoice.scheduleID, Equal <Required <APInvoice.scheduleID> >, And <APInvoice.scheduled, Equal <boolTrue> > > > .Select(this, s.ScheduleID))
{
docgraph.Clear();
docgraph.vendor.Current = (Vendor)res;
APInvoice apdoc = (APInvoice)res;
CurrencyInfo info = (CurrencyInfo)res;
CurrencyInfo new_info = PXCache <CurrencyInfo> .CreateCopy(info);
new_info.CuryInfoID = null;
new_info = docgraph.currencyinfo.Insert(new_info);
APInvoice new_apdoc = PXCache <APInvoice> .CreateCopy(apdoc);
new_apdoc.CuryInfoID = new_info.CuryInfoID;
new_apdoc.DocDate = sdet.ScheduledDate;
new_apdoc.FinPeriodID = sdet.ScheduledPeriod;
new_apdoc.TranPeriodID = null;
new_apdoc.DueDate = null;
new_apdoc.DiscDate = null;
new_apdoc.PayDate = null;
new_apdoc.CuryOrigDiscAmt = null;
new_apdoc.OrigDiscAmt = null;
new_apdoc.RefNbr = null;
new_apdoc.Scheduled = false;
new_apdoc.CuryLineTotal = 0m;
new_apdoc.CuryVatTaxableTotal = 0m;
new_apdoc.CuryVatExemptTotal = 0m;
new_apdoc.NoteID = null;
new_apdoc = docgraph.Document.Insert(new_apdoc);
TaxAttribute.SetTaxCalc <APTran.taxCategoryID, APTaxAttribute>(docgraph.Transactions.Cache, null, TaxCalc.ManualCalc);
PXNoteAttribute.SetNote(docgraph.Document.Cache, new_apdoc, PXNoteAttribute.GetNote(Caches[typeof(APInvoice)], apdoc));
PXNoteAttribute.SetFileNotes(docgraph.Document.Cache, new_apdoc, PXNoteAttribute.GetFileNotes(Caches[typeof(APInvoice)], apdoc));
foreach (APTran aptran in PXSelect <APTran, Where <APTran.tranType, Equal <Required <APTran.tranType> >, And <APTran.refNbr, Equal <Required <APTran.refNbr> > > > > .Select(docgraph, apdoc.DocType, apdoc.RefNbr))
{
APTran new_aptran = PXCache <APTran> .CreateCopy(aptran);
new_aptran.RefNbr = null;
new_aptran.CuryInfoID = null;
docgraph.Transactions.Insert(new_aptran);
}
foreach (APTaxTran tax in PXSelect <APTaxTran, Where <APTaxTran.tranType, Equal <Required <APTaxTran.tranType> >, And <APTaxTran.refNbr, Equal <Required <APTaxTran.refNbr> > > > > .Select(docgraph, apdoc.DocType, apdoc.RefNbr))
{
APTaxTran new_aptax = new APTaxTran();
new_aptax.TaxID = tax.TaxID;
new_aptax = docgraph.Taxes.Insert(new_aptax);
if (new_aptax != null)
{
new_aptax = PXCache <APTaxTran> .CreateCopy(new_aptax);
new_aptax.TaxRate = tax.TaxRate;
new_aptax.CuryTaxableAmt = tax.CuryTaxableAmt;
new_aptax.CuryTaxAmt = tax.CuryTaxAmt;
new_aptax = docgraph.Taxes.Update(new_aptax);
}
}
docgraph.Save.Press();
}
s.LastRunDate = sdet.ScheduledDate;
Running_Schedule.Cache.Update(s);
}
using (PXTransactionScope ts = new PXTransactionScope())
{
Running_Schedule.Cache.Persist(PXDBOperation.Update);
ts.Complete(this);
}
Running_Schedule.Cache.Persisted(false);
}