public static void RenewContract(ContractMaint docgraph, ContractsList item)
{
docgraph.Contracts.Current = PXSelect <CT.Contract, Where <CT.Contract.contractID, Equal <Required <CT.Contract.contractID> > > > .Select(docgraph, item.ContractID);
docgraph.Billing.Current = docgraph.Billing.Select();
docgraph.RenewContract();
}
protected virtual void CRCaseClass_DefaultContractID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
if (e.NewValue == null)
{
return;
}
Contract contract = PXSelectReadonly <Contract,
Where <Contract.contractID, Equal <Required <CRCase.contractID> > > > .
Select(this, e.NewValue);
if (contract != null)
{
int daysLeft;
if (ContractMaint.IsExpired(contract, (DateTime)Accessinfo.BusinessDate))
{
e.NewValue = null;
throw new PXSetPropertyException(Messages.ContractExpired, PXErrorLevel.Error);
}
if (ContractMaint.IsInGracePeriod(contract, (DateTime)Accessinfo.BusinessDate, out daysLeft))
{
e.NewValue = contract.ContractCD;
throw new PXSetPropertyException(Messages.ContractInGracePeriod, PXErrorLevel.Warning, daysLeft);
}
}
}
public static void RenewContract(ContractMaint docgraph, ContractsList item, RenewalContractFilter filter)
{
docgraph.Contracts.Current = PXSelect <Contract, Where <Contract.contractID, Equal <Required <Contract.contractID> > > > .Select(docgraph, item.ContractID);
docgraph.Billing.Current = docgraph.Billing.Select();
docgraph.RenewContract(filter.RenewalDate.Value);
}
protected static void UpdatePrices(ContractMaint graph, ContractDetail item)
{
Contract contract = PXSelect <Contract, Where <Contract.contractID, Equal <Required <Contract.contractID> > > > .Select(graph, item.ContractID);
using (PXTransactionScope ts = new PXTransactionScope())
{
if (CTPRType.IsTemplate(contract.BaseType) != true)
{
ContractMaintExt contractMaintExt = CreateInstance <ContractMaintExt>();
contractMaintExt.Contracts.Current = contract;
if (contract.IsActive == true &&
contract.IsPendingUpdate != true &&
contract.Status != Contract.status.PendingActivation)
{
CTBillEngine engine = CreateInstance <CTBillEngine>();
engine.Upgrade(contract.ContractID);
engine.Clear();
contractMaintExt.Contracts.Current = PXSelect <Contract, Where <Contract.contractID, Equal <Required <Contract.contractID> > > > .Select(engine, item.ContractID);
item = PXSelect <ContractDetail,
Where <ContractDetail.contractID, Equal <Required <ContractDetail.contractID> >,
And <ContractDetail.lineNbr, Equal <Required <ContractDetail.lineNbr> > > > > .Select(engine, item.ContractID, item.LineNbr);
}
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.basePriceOption>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.basePrice>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.renewalPriceOption>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.renewalPrice>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.fixedRecurringPriceOption>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.fixedRecurringPrice>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.usagePriceOption>(item);
contractMaintExt.ContractDetails.Cache.SetDefaultExt <ContractDetail.usagePrice>(item);
contractMaintExt.ContractDetails.Update(item);
contractMaintExt.Actions.PressSave();
}
else
{
TemplateMaint templateMaint = CreateInstance <TemplateMaint>();
templateMaint.Templates.Current = PXSelect <ContractTemplate, Where <ContractTemplate.contractID, Equal <Required <ContractTemplate.contractID> > > > .Select(graph, item.ContractID);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.basePriceOption>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.basePrice>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.renewalPriceOption>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.renewalPrice>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.fixedRecurringPriceOption>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.fixedRecurringPrice>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.usagePriceOption>(item);
templateMaint.ContractDetails.Cache.SetDefaultExt <ContractDetail.usagePrice>(item);
templateMaint.ContractDetails.Update(item);
templateMaint.Actions.PressSave();
}
ts.Complete();
}
}
private Contract CreateActivateContract(ContractMaint contractMaint,
DateTime?invoiceDate, int?customerID, int?customerLocationID,
string simCardID, string phoneNumber, CTBillEngine engine)
{
contractMaint.Clear();
// Initialize new contract
Contract contract =
(Contract)contractMaint.Contracts.Cache.CreateInstance();
contract = contractMaint.Contracts.Insert(contract);
// Look up contract template ID
Contract template = PXSelect <Contract,
Where <Contract.isTemplate, Equal <boolTrue>,
And <Contract.contractCD, Equal <Required <Contract.contractCD> > > > >
.Select(Base, "SIMCARD");
if (template == null)
{
throw new
PXException("The SIMCARD contract template was not found.");
}
// Set required fields
contract.TemplateID = template.ContractID;
contract.CustomerID = customerID;
contract = contractMaint.Contracts.Update(contract);
contract.LocationID = customerLocationID;
contract.StartDate = invoiceDate;
contract.ActivationDate = invoiceDate;
contract = contractMaint.Contracts.Update(contract);
// Store simCardID and phoneNumber into the contract attributes
foreach (CSAnswers attribute in contractMaint.Answers.Select())
{
switch (attribute.AttributeID)
{
case "SIMCARDID":
attribute.Value = simCardID;
contractMaint.Answers.Update(attribute);
break;
case "PHONENUM":
attribute.Value = phoneNumber;
contractMaint.Answers.Update(attribute);
break;
}
}
// Save the generated contract
contractMaint.Save.Press();
// Set up and activate the contract
engine.SetupAndActivate(contract.ContractID, contract.ActivationDate);
return(contract);
}
public virtual IEnumerable ViewContract(PXAdapter adapter)
{
if (Contracts.Current != null)
{
ContractMaint target = PXGraph.CreateInstance <ContractMaint>();
target.Clear();
target.Contracts.Current = Contracts.Current;
throw new PXRedirectRequiredException(target, true, "ViewContract")
{
Mode = PXBaseRedirectException.WindowMode.NewWindow
};
}
return(adapter.Get());
}
public virtual IEnumerable ViewContract(PXAdapter adapter)
{
if (Items.Current != null)
{
ContractMaint target = PXGraph.CreateInstance <ContractMaint>();
target.Clear();
target.Contracts.Current = PXSelect <CT.Contract, Where <CT.Contract.contractID, Equal <Current <ContractsList.contractID> > > > .Select(this);
throw new PXRedirectRequiredException(target, true, "ViewContract")
{
Mode = PXBaseRedirectException.WindowMode.NewWindow
};
}
return(adapter.Get());
}
public void Persist(PersistDelegate baseMethod)
{
ARRegister invoice = Base.ARDocument.Current;
List <Contract> setupContracts = new List <Contract>();
if (SetupContract)
{
// Create, set up, and activate contracts
ContractMaint contractMaint = PXGraph.CreateInstance <ContractMaint>();
CTBillEngine engine = PXGraph.CreateInstance <CTBillEngine>();
int seq = 1;
// Reuse ARTran_TranType_RefNbr from ARReleaseProcess
foreach (ARTran tran in
PXSelect <ARTran,
Where <ARTran.tranType, Equal <Required <ARInvoice.docType> >,
And <ARTran.refNbr, Equal <Required <ARInvoice.refNbr> >,
And <ARTranExt.usrSIMCardID, IsNotNull,
And <ARTranExt.usrContractID, IsNull> > > >,
OrderBy <Asc <ARTran.tranType, Asc <ARTran.refNbr,
Asc <ARTran.lineNbr> > > > >
.Select(Base, invoice.DocType, invoice.RefNbr))
{
// Create, set up, and activate contract for a particular SOInvoice line
ARTranExt tranExt = PXCache <ARTran> .GetExtension <ARTranExt>(tran);
Contract contract = CreateActivateContract(contractMaint,
invoice.DocDate, invoice.CustomerID, invoice.CustomerLocationID,
tranExt.UsrSIMCardID, tranExt.UsrPhoneNumber, engine);
setupContracts.Add(contract);
// Associate the generated contract with the SOInvoice line
tranExt.UsrContractID = contract.ContractID;
Base.ARTran_TranType_RefNbr.Cache.SetValueExt(tran, "UsrContractID", contract.ContractID);
Base.ARTran_TranType_RefNbr.Cache.SetStatus(tran, PXEntryStatus.Modified);
Base.ARTran_TranType_RefNbr.Cache.Update(tran);
Base.ARTran_TranType_RefNbr.Cache.IsDirty = true;
seq++;
}
}
baseMethod();
}
public virtual IEnumerable viewContract(PXAdapter adapter)
{
ContractDetail contractDetail = Items.Current;
if (contractDetail != null)
{
PXGraph graph = null;
string message = null;
Contract contract = ContractMaint.FindContract(this, contractDetail.ContractID);
if (CTPRType.IsTemplate(contract.BaseType) == true)
{
TemplateMaint templateMaint = PXGraph.CreateInstance <TemplateMaint>();
templateMaint.Templates.Current = templateMaint.Templates.Search <ContractTemplate.contractID>(contractDetail.ContractID);
graph = templateMaint;
message = CT.Messages.ViewContractTemplate;
}
else
{
ContractMaint contractMaint = PXGraph.CreateInstance <ContractMaint>();
contractMaint.Contracts.Current = contract;
graph = contractMaint;
message = CT.Messages.ViewContract;
}
throw new PXRedirectRequiredException(graph, true, message)
{
Mode = PXBaseRedirectException.WindowMode.NewWindow
};
}
return(Filter.Select());
}
protected virtual void UsageFilter_ContractID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
if (e.NewValue != null)
{
Contract contract = PXSelectReadonly <Contract,
Where <Contract.contractID, Equal <Required <CRCase.contractID> > > > .Select(this, e.NewValue);
if (contract != null)
{
#region Set Warnings for expired and 'In Grace Period' contracts
int daysLeft;
if (ContractMaint.IsExpired(contract, Accessinfo.BusinessDate.Value))
{
sender.RaiseExceptionHandling <UsageFilter.contractID>(e.Row, contract.ContractCD, new PXSetPropertyException(CR.Messages.ContractExpired, PXErrorLevel.Warning));
}
else if (ContractMaint.IsInGracePeriod(contract, Accessinfo.BusinessDate.Value, out daysLeft))
{
sender.RaiseExceptionHandling <UsageFilter.contractID>(e.Row, contract.ContractCD, new PXSetPropertyException(CR.Messages.ContractInGracePeriod, PXErrorLevel.Warning, daysLeft));
}
#endregion
}
}
}
