protected virtual void EPLoginType_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
EPLoginType row = (EPLoginType)e.Row;
if (row == null)
{
return;
}
Users u = PXSelect <Users,
Where <Users.loginTypeID, Equal <Required <EPLoginType.loginTypeID> > > > .
SelectWindowed(this, 0, 1, row.LoginTypeID);
if (u != null)
{
throw new PXException(Messages.RecordIsReferenced);
}
}
protected virtual void FADepreciationMethod_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
FADepreciationMethod meth = (FADepreciationMethod)e.Row;
if (meth == null)
{
return;
}
FABookSettings sett = PXSelect <FABookSettings, Where <FABookSettings.depreciationMethodID, Equal <Required <FADepreciationMethod.methodID> > > > .Select(this, meth.MethodID);
FABookBalance bal = PXSelect <FABookBalance, Where <FABookBalance.depreciationMethodID, Equal <Required <FADepreciationMethod.methodID> > > > .Select(this, meth.MethodID);
if (sett != null || bal != null)
{
throw new PXSetPropertyException(Messages.FADeprMethodUsedInAssets);
}
}
protected virtual void Schedule_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
foreach (DocumentSelection b in PXSelect <DocumentSelection, Where <DocumentSelection.scheduleID, Equal <Required <Schedule.scheduleID> > > > .Select(this, ((Schedule)e.Row).ScheduleID))
{
if ((bool)b.Scheduled)
{
b.Voided = true;
b.Scheduled = false;
}
b.ScheduleID = null;
if (Document_Detail.Cache.GetStatus(b) == PXEntryStatus.Notchanged)
{
Document_Detail.Cache.SetStatus(b, PXEntryStatus.Updated);
}
PXDBDefaultAttribute.SetDefaultForUpdate <DocumentSelection.scheduleID>(Document_Detail.Cache, b, false);
}
}
protected virtual void Schedule_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
foreach (DocumentSelection document in PXSelect <
DocumentSelection,
Where <DocumentSelection.scheduleID, Equal <Required <Schedule.scheduleID> > > >
.Select(this, ((Schedule)e.Row).ScheduleID))
{
if ((bool)document.Scheduled)
{
document.Voided = true;
document.Scheduled = false;
}
document.ScheduleID = null;
PXDBDefaultAttribute.SetDefaultForUpdate <DocumentSelection.scheduleID>(Document_Detail.Cache, document, false);
Document_Detail.Cache.Update(document);
}
}
protected virtual void CSAttributeGroup_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
var attributeGroup = (CSAttributeGroup)e.Row;
if (attributeGroup == null)
{
return;
}
if (attributeGroup.IsActive == true)
{
throw new PXSetPropertyException(CR.Messages.AttributeCannotDeleteActive);
}
if (Mapping.Ask("Warning", CR.Messages.AttributeDeleteWarning, MessageButtons.OKCancel) != WebDialogResult.OK)
{
e.Cancel = true;
return;
}
CSAttributeGroupList <CSAttributeGroup, CSAttributeGroup> .DeleteAttributesForGroup(this, attributeGroup);
}
protected virtual void TaxCategory_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
TaxCategory row = e.Row as TaxCategory;
if (row != null)
{
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(AP.APTran.taxCategoryID), typeof(Search <AP.APTran.taxCategoryID, Where <AP.APTran.released, Equal <False> > >));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(AR.ARTran.taxCategoryID), typeof(Search <AR.ARTran.taxCategoryID, Where <AR.ARTran.released, Equal <False> > >));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(AR.ARFinCharge.taxCategoryID));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(CA.CASplit.taxCategoryID), typeof(Search2 <CA.CASplit.taxCategoryID, InnerJoin <CA.CAAdj,
On <CA.CASplit.adjRefNbr, Equal <CA.CAAdj.adjRefNbr> > >, Where <CA.CAAdj.released, Equal <False> > >));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(EP.EPExpenseClaimDetails.taxCategoryID));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(PO.POLine.taxCategoryID));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(SO.SOLine.taxCategoryID));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(SO.SOOrder.freightTaxCategoryID));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(CR.CROpportunityProducts.taxCategoryID));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(IN.INItemClass.taxCategoryID));
PXSelectorAttribute.CheckAndRaiseForeignKeyException(sender, e.Row, typeof(IN.InventoryItem.taxCategoryID));
}
}
protected virtual void CSAnswers_RowDeleting(PXCache sender, PXRowDeletingEventArgs e, PXRowDeleting del)
{
if (del != null)
{
del.Invoke(sender, e);
}
CSAnswers row = (CSAnswers)e.Row;
InventoryItem current = Base.Item.Current;
if (row == null)
{
return;
}
if (current == null)
{
e.Cancel = true;
}
}
protected virtual void EPActivityApprove_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
EPActivityApprove row = (EPActivityApprove)e.Row;
if (row == null)
{
return;
}
if (row.UIStatus == CR.ActivityStatusListAttribute.Approved || row.Released == true)
{
Filter.View.Ask((string.Format(Messages.ActivityIs, sender.GetValueExt <EPActivityApprove.uistatus>(row))), MessageButtons.OK);
e.Cancel = true;
}
else if (row.TimeCardCD != null)
{
Filter.View.Ask(Messages.ActivityAssignedToTimeCard, MessageButtons.OK);
e.Cancel = true;
}
}
protected virtual void INSite_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
INSite row = (INSite)e.Row;
if (row != null)
{
PXResult <INSiteStatus, InventoryItem> status =
(PXResult <INSiteStatus, InventoryItem>)
PXSelectJoin <INSiteStatus,
InnerJoin <InventoryItem, On <InventoryItem.inventoryID, Equal <INSiteStatus.inventoryID> > >,
Where <INSiteStatus.siteID, Equal <Required <INSiteStatus.siteID> > > >
.SelectWindowed(this, 0, 1, row.SiteID, 0m);
if (status != null && ((InventoryItem)status).InventoryCD != null)
{
e.Cancel = true;
throw new PXRowPersistingException(typeof(INSite).Name, row, Messages.SiteUsageDeleted, ((InventoryItem)status).InventoryCD);
}
}
}
protected virtual void PaymentMethodAccount_RowDeleting(PXCache cache, PXRowDeletingEventArgs e)
{
PaymentMethodAccount row = (PaymentMethodAccount)e.Row;
PXEntryStatus status = cache.GetStatus(e.Row);
if (row.CashAccountID != null && status != PXEntryStatus.Inserted && status != PXEntryStatus.InsertedDeleted)
{
CustomerPaymentMethod cpm = PXSelect <CustomerPaymentMethod, Where <CustomerPaymentMethod.paymentMethodID, Equal <Required <CustomerPaymentMethod.paymentMethodID> >,
And <CustomerPaymentMethod.cashAccountID, Equal <Required <CustomerPaymentMethod.cashAccountID> > > > > .SelectWindowed(this, 0, 1, row.PaymentMethodID, row.CashAccountID);
if (cpm != null)
{
throw new PXException(Messages.PaymentMethodAccountIsInUseAndCantBeDeleted);
}
CashAccount cashAccount = CashAccount.PK.Find(this, row.CashAccountID);
VerifyCashAccountLinkOrMethodCanBeDeleted(cashAccount);
}
}
protected virtual void BranchBAccount_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
BranchBAccount item = e.Row as BranchBAccount;
if (item != null)
{
Ledger ledger = PXSelectJoin <Ledger,
InnerJoin <Branch, On <Branch.branchID, Equal <Ledger.defBranchID> > >,
Where <Branch.branchCD, Equal <Required <Branch.branchCD> > > > .Select(this, item.BranchBranchCD);
if (ledger != null)
{
GLHistory hist = PXSelect <GLHistory, Where <GLHistory.ledgerID, Equal <Required <GLHistory.ledgerID> > > > .Select(this, ledger.LedgerID);
if (hist != null)
{
throw new PXSetPropertyException(ErrorMessages.CantDeleteRecord);
}
}
}
}
protected virtual void RUTROTWorkType_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
RUTROTWorkType workType = (RUTROTWorkType)e.Row;
if (workType != null && workType.WorkTypeID != null)
{
if (PXSelect<ARTran, Where<ARTranRUTROT.rUTROTWorkTypeID, Equal<Required<RUTROTWorkType.workTypeID>>>>.Select(this, workType.WorkTypeID).Any())
{
throw new PXException(RUTROTMessages.CannotDeleteWorkType);
}
if (PXSelect<SOLine, Where<SOLineRUTROT.rUTROTWorkTypeID, Equal<Required<RUTROTWorkType.workTypeID>>>>.Select(this, workType.WorkTypeID).Any())
{
throw new PXException(RUTROTMessages.CannotDeleteWorkType);
}
if (PXSelect<InventoryItem, Where<InventoryItemRUTROT.rUTROTWorkTypeID, Equal<Required<RUTROTWorkType.workTypeID>>>>.Select(this, workType.WorkTypeID).Any())
{
throw new PXException(RUTROTMessages.CannotDeleteWorkType);
}
}
}
protected virtual void CSAttributeDetail_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
var row = e.Row as CSAttributeDetail;
if (row != null)
{
CSAnswers ans = PXSelect <CSAnswers,
Where <CSAnswers.attributeID, Equal <Required <CSAnswers.attributeID> >,
And <CSAnswers.value, Equal <Required <CSAnswers.value> > > > > .
SelectWindowed(this, 0, 1, row.AttributeID, row.ValueID);
CSAttributeGroup group = PXSelect <CSAttributeGroup,
Where <CSAttributeGroup.attributeID, Equal <Required <CSAttribute.attributeID> > > > .
SelectWindowed(this, 0, 1, row.AttributeID);
if (ans != null && group != null)
{
throw new PXSetPropertyException <CSAttributeDetail.attributeID>(Messages.AttributeDetailCanNotBeDeletedAsItUsed, PXErrorLevel.RowError);
}
}
}
protected virtual void ShipmentLine_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
ShipmentLine line = (ShipmentLine)e.Row;
if (!e.ExternalCall)
{
return;
}
if (line.Gift == true)
{
throw new PXException("Product {0} cannot be deleted", ShipmentLine.GiftCard);
}
else if (sender.GetStatus(line) != PXEntryStatus.InsertedDeleted)
{
if (ShipmentLines.Ask("Confirm Delete", "Are you sure?", MessageButtons.YesNo) != WebDialogResult.Yes)
{
e.Cancel = true;
}
}
}
// Deleting order control. Prevents break of consecutive enumeration.
protected virtual void ARDunningSetup_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
int MaxRN = 0;
foreach (PXResult <ARDunningSetup> ii in PXSelect <ARDunningSetup> .Select(this))
{
ARDunningSetup v = ii;
int MaxR = v.DunningLetterLevel.Value;
MaxRN = MaxRN < MaxR ? MaxR : MaxRN;
}
ARDunningSetup row = e.Row as ARDunningSetup;
if (row != null)
{
if (row.DunningLetterLevel.Value < MaxRN)
{
throw new PXException(Messages.OnlyLastRowCanBeDeleted);
}
}
}
protected virtual void Schedule_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
foreach (BatchSelection batch in PXSelect <
BatchSelection,
Where <
BatchSelection.scheduleID, Equal <Required <Schedule.scheduleID> > > >
.Select(this, ((Schedule)e.Row).ScheduleID))
{
if (batch.Scheduled == true)
{
batch.Voided = true;
batch.Scheduled = false;
}
batch.ScheduleID = null;
Batch_Detail.Cache.MarkUpdated(batch);
PXDBDefaultAttribute.SetDefaultForUpdate <BatchSelection.scheduleID>(Batch_Detail.Cache, batch, false);
}
}
protected virtual void CSAttributeDetail_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
var row = e.Row as CSAttributeDetail;
if (row != null)
{
CSAnswers ans = PXSelect <CSAnswers,
Where <CSAnswers.attributeID, Equal <Required <CSAnswers.attributeID> >,
And <CSAnswers.value, Equal <Required <CSAnswers.value> > > > > .
SelectWindowed(this, 0, 1, row.AttributeID, row.ValueID);
CSAttributeGroup group = PXSelect <CSAttributeGroup,
Where <CSAttributeGroup.attributeID, Equal <Required <CSAttribute.attributeID> > > > .
SelectWindowed(this, 0, 1, row.AttributeID);
if (ans != null && group != null)
{
e.Cancel = true;
}
}
}
protected virtual void INSubItem_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
INSubItem row = e.Row as INSubItem;
if (row != null)
{
INSiteStatus status = PXSelect <INSiteStatus, Where <INSiteStatus.subItemID, Equal <Required <INSubItem.subItemID> > > > .SelectWindowed(this, 0, 1, row.SubItemID);
if (status != null)
{
throw new PXSetPropertyException(Messages.SubitemDeleteError);
}
INItemXRef itemRef = PXSelect <INItemXRef, Where <INItemXRef.subItemID, Equal <Required <INSubItem.subItemID> > > > .SelectWindowed(this, 0, 1, row.SubItemID);
if (itemRef != null)
{
throw new PXSetPropertyException(Messages.SubitemDeleteError);
}
}
}
protected virtual void PMAccountGroup_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
PMAccountGroup row = e.Row as PMAccountGroup;
if (row != null)
{
if (IsAccountsExist())
{
e.Cancel = true;
throw new PXException(Messages.Account_FK);
}
PMBudget ps = PXSelect <PMBudget, Where <PMBudget.accountGroupID, Equal <Required <PMAccountGroup.groupID> > > > .SelectWindowed(this, 0, 1, row.GroupID);
if (ps != null)
{
e.Cancel = true;
throw new PXException(Messages.ProjectStatus_FK);
}
}
}
protected virtual void CATranExt_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
CATran tran = (CATran)e.Row;
if (tran.Released == true ||
tran.OrigModule != BatchModule.CA ||
tran.OrigTranType != CATranType.CAAdjustment)
{
throw new PXException(ErrorMessages.CantDeleteRecord);
}
CAAdj adj = caadj_adjRefNbr.Select(tran.OrigRefNbr);
if (adj != null)
{
caadj_adjRefNbr.Delete(adj);
}
foreach (CASplit split in casplit_adjRefNbr.Select(tran.OrigRefNbr))
{
casplit_adjRefNbr.Delete(split);
}
}
protected virtual void CSCalendar_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
CSCalendar row = e.Row as CSCalendar;
if (row != null)
{
EPEmployeeClass refEmpClass = PXSelect <EPEmployeeClass, Where <EPEmployeeClass.calendarID, Equal <Current <CSCalendar.calendarID> > > > .SelectWindowed(this, 0, 1);
if (refEmpClass != null)
{
e.Cancel = true;
throw new PXException(Messages.ReferencedByEmployeeClass, refEmpClass.VendorClassID);
}
Carrier refCarrier = PXSelect <Carrier, Where <Carrier.calendarID, Equal <Current <CSCalendar.calendarID> > > > .SelectWindowed(this, 0, 1);
if (refCarrier != null)
{
e.Cancel = true;
throw new PXException(Messages.ReferencedByCarrier, refCarrier.CarrierID);
}
Contract refContract = PXSelect <Contract, Where <Contract.calendarID, Equal <Current <CSCalendar.calendarID> > > > .SelectWindowed(this, 0, 1);
if (refContract != null)
{
e.Cancel = true;
throw new PXException(Messages.ReferencedByContract, refContract.ContractID);
}
EPEmployee refEmployee = PXSelect <EPEmployee, Where <EPEmployee.calendarID, Equal <Current <CSCalendar.calendarID> > > > .SelectWindowed(this, 0, 1);
if (refEmployee != null)
{
e.Cancel = true;
throw new PXException(Messages.ReferencedByEmployee, refEmployee.ClassID);
}
}
}
protected virtual void FixedAsset_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
FixedAsset cls = (FixedAsset)e.Row;
if (cls == null)
{
return;
}
FixedAsset asset = PXSelect <FixedAsset, Where <FixedAsset.classID, Equal <Required <FixedAsset.assetID> > > > .Select(this, cls.AssetID);
if (asset != null)
{
throw new PXSetPropertyException(Messages.FAClassUsedInAssets);
}
FixedAsset child = PXSelect <FixedAsset, Where <FixedAsset.parentAssetID, Equal <Required <FixedAsset.assetID> > > > .Select(this, cls.AssetID);
if (child != null)
{
throw new PXSetPropertyException(Messages.FAClassIsParent);
}
}
protected virtual void EPCustomWeek_RowDeleting(PXCache cache, PXRowDeletingEventArgs e)
{
EPCustomWeek row = (EPCustomWeek)e.Row;
if (row == null)
{
return;
}
if (cache.GetStatus(row) != PXEntryStatus.Inserted && cache.GetStatus(row) != PXEntryStatus.InsertedDeleted)
{
if ((EPTimeCard)PXSelect <EPTimeCard> .Search <EPTimeCard.weekId>(this, row.WeekID) != null || (PMTimeActivity)PXSelect <PMTimeActivity> .Search <PMTimeActivity.weekID>(this, row.WeekID) != null)
{
throw new PXException(Messages.WeekInUse);
}
}
EPCustomWeek lastWeek = (EPCustomWeek)PXSelectOrderBy <EPCustomWeek, OrderBy <Desc <EPCustomWeek.weekID> > > .Select(this);
if (lastWeek != null && lastWeek.WeekID > row.WeekID)
{
throw new PXSetPropertyException(Messages.WeekNotLast, PXErrorLevel.RowWarning);
}
}
protected virtual void AccountClass_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
if (e.Row == null)
{
return;
}
AccountClass row = (AccountClass)e.Row;
Account account_rec = (Account)PXSelect <Account, Where <Account.accountClassID, Equal <Required <AccountClass.accountClassID> > > > .SelectWindowed(this, 0, 1, row.AccountClassID);
if (account_rec != null)
{
throw new PXException(Messages.ThisAccountClassMayNotBeDeletedBecauseItIsUsedIn, "Account: " + account_rec.AccountCD);
}
RMDataSource rmds_rec = PXSelect <RMDataSource, Where <RMDataSourceGL.accountClassID, Equal <Required <AccountClass.accountClassID> > > > .SelectWindowed(this, 0, 1, row.AccountClassID);
if (rmds_rec != null)
{
throw new PXException(Messages.ThisAccountClassMayNotBeDeletedBecauseItIsUsedIn, "Analitycal Report Manager");
}
}
protected virtual void PMTask_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
PMTask row = e.Row as PMTask;
if (row == null)
{
return;
}
if (row.IsActive == true && row.IsCancelled == false)
{
throw new PXException(Messages.OnlyPlannedCanbeDeleted);
}
//validate that all child records can be deleted:
PMTran tran = PXSelect <PMTran, Where <PMTran.projectID, Equal <Required <PMTask.projectID> >, And <PMTran.taskID, Equal <Required <PMTask.taskID> > > > > .SelectWindowed(this, 0, 1, row.ProjectID, row.TaskID);
if (tran != null)
{
throw new PXException(Messages.HasTranData);
}
PMTimeActivity activity = PXSelect <PMTimeActivity, Where <PMTimeActivity.projectID, Equal <Required <PMTask.projectID> >, And <PMTimeActivity.projectTaskID, Equal <Required <PMTask.taskID> > > > > .SelectWindowed(this, 0, 1, row.ProjectID, row.TaskID);
if (activity != null)
{
throw new PXException(Messages.HasActivityData);
}
EP.EPTimeCardItem timeCardItem = PXSelect <EP.EPTimeCardItem, Where <EP.EPTimeCardItem.projectID, Equal <Required <PMTask.projectID> >, And <EP.EPTimeCardItem.taskID, Equal <Required <PMTask.taskID> > > > > .SelectWindowed(this, 0, 1, row.ProjectID, row.TaskID);
if (timeCardItem != null)
{
throw new PXException(Messages.HasTimeCardItemData);
}
}
public virtual void EPCompanyTreeMaster_RowDeleting(PXCache cache, PXRowDeletingEventArgs e)
{
EPCompanyTreeMaster row = (EPCompanyTreeMaster)e.Row;
if (row == null)
{
return;
}
string res = "";
foreach (EPAssignmentMap map in PXSelectJoin <EPAssignmentMap,
InnerJoin <EPRule, On <EPRule.assignmentMapID, Equal <EPAssignmentMap.assignmentMapID> > >,
Where <EPRule.workgroupID, Equal <Required <EPRule.workgroupID> > > > .
Select(this, row.WorkGroupID))
{
if (map == null)
{
throw new PXException(Objects.EP.Messages.WorkgroupIsInUse);
}
string MapType = "";
if (map.MapType == EPMapType.Assignment)
{
MapType = Objects.EP.Messages.Assignment;
}
else
{
MapType = Objects.EP.Messages.Approval;
}
res = res + string.Format(Objects.EP.Messages.WorkgroupIsInUseAtAssignmentMap, row.Description, MapType, map.Name) + "\n";
}
if (!String.IsNullOrEmpty(res))
{
throw new PXException(res);
}
}
//protected virtual void SOOrder_CuryOrderTotal_FieldUpdating(PXCache sender, PXFieldUpdatingEventArgs e)
//{
// if (!(e.Row is SOOrder row)) return;
// e.NewValue = GetOrderTotals(row);
//}
//protected virtual void SOOrder_RowInserting(PXCache sender, PXRowInsertingEventArgs e)
//{
// if (!(e.Row is SOOrder row)) return;
// row.CuryOrderTotal = GetOrderTotals(row);
//}
//protected virtual void SOOrder_RowPersisted(PXCache sender, PXRowPersistedEventArgs e, PXRowPersisted baseHandler )
//{
// if (!(e.Row is SOOrder row)) return;
// if (KCTaxZoneId.SelectSingle(Base.CurrentDocument.Current.TaxZoneID)?.IsExternal ?? false)
// Base.RecalculateExternalTaxesSync = true;
// baseHandler?.Invoke(sender, e);
//}
protected virtual void SOTaxTran_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
if (!(e.Row is SOTaxTran row))
{
return;
}
bool?isFromCA = Base.Document.Current.GetExtension <KCSOOrderExt>().UsrKCSiteName?.EndsWith("FBA");
if (Base.Accessinfo.ScreenID == "SO.30.10.00" && !isFromCA.GetValueOrDefault())
{
return;
}
SOOrder order = Base.Document.Current;
if (order == null)
{
return;
}
if (isFromCA.GetValueOrDefault() && order != null && order.CuryTaxTotal > 0 && e.ExternalCall == false)
{
Base.Caches["SOTaxTran"].SetStatus(row, PXEntryStatus.Notchanged);
}
}
protected virtual void RQRequestClass_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
RQRequestClass row = (RQRequestClass)e.Row;
if (row != null)
{
RQSetup setup = PXSelect <RQSetup,
Where <RQSetup.defaultReqClassID, Equal <Required <RQSetup.defaultReqClassID> > > > .Select(this, row.ReqClassID);
if (setup != null)
{
e.Cancel = true;
throw new PXRowPersistingException(sender.GetItemType().Name, row, Messages.DeleteSetupClass);
}
RQRequest req = PXSelect <RQRequest, Where <RQRequest.reqClassID, Equal <Required <RQRequest.reqClassID> > > > .SelectWindowed(this, 0, 1, row.ReqClassID);
if (req != null)
{
e.Cancel = true;
throw new PXRowPersistingException(sender.GetItemType().Name, row, Messages.UnableDeleteReqClass);
}
}
}
protected virtual void EPActivityType_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
ValidateUsage(e.Row, epsetup, Messages.ActivityTypeUsage);
ValidateUsage(e.Row, Activities, Messages.ActivityTypeUsage);
}
protected virtual void Terms_RowDeleting(PXCache cache, PXRowDeletingEventArgs e)
{
this.isMassDelete = true; //Prevent normal validation logic for installments
}
