Hi Team,
I have created the Processing screen when i run process all fine. But when i click on selected checkbox it is causing following issue.
Regards,
Sakthi
Hi Team,
I have created the Processing screen when i run process all fine. But when i click on selected checkbox it is causing following issue.
Regards,
Sakthi
Please fiind my DAC code.
Regards,
Sakthi
using System;
using PX.Data;
using PX.Data.BQL;
using PX.Data.EP;
using PX.Data.ReferentialIntegrity.Attributes;
using PX.Objects.AP;
using PX.Objects.CA;
using PX.Objects.CA;
using PX.Objects.CM;
using PX.Objects.CR;
using PX.Objects.CS;
using PX.Objects.EP;
using PX.Objects.FS;
using PX.Objects.GL;
using PX.Objects.PM;
using PX.Objects.PO;
using PX.TM;
using TradeFacilities.FD.DAC;
using YTLDBFCustomization.DAC;
namespace YTLDBFCustomization
{
[Serializable]
[PXCacheName("CRTDBFApplication")]
[PXPrimaryGraph(typeof(DigitalBankFacilitiesMaint))]
[PXEMailSource]
public class CRTDBFApplication : IBqlTable, IAssign
{
#region DBFId
[PXDBIdentity]
public virtual int? DBFId { get; set; }
public abstract class dBFId : PX.Data.BQL.BqlInt.Field<dBFId> { }
#endregion
#region Dbfrefnbr
[PXDBString(50, InputMask = "", IsKey = true, IsUnicode = true)]
[PXCheckUnique]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
[AutoNumber(typeof(CASetupExt.usrDBFNumberingSequence), typeof(AccessInfo.businessDate))]
[PXUIField(DisplayName = "DBF Ref No", Visibility = PXUIVisibility.SelectorVisible)]
[PXSelector(typeof(Search3<dbfrefnbr, OrderBy<Desc<dbfrefnbr>>>), typeof(dbfrefnbr), typeof(description), SubstituteKey = typeof(dbfrefnbr), Filterable = true)]
public virtual string Dbfrefnbr { get; set; }
public abstract class dbfrefnbr : PX.Data.BQL.BqlString.Field<dbfrefnbr> { }
#endregion
#region Dbfrefnbr
[PXDBString(50, InputMask = "", IsUnicode = true)]
[PXUIField(DisplayName = "AP Bill No")]
public virtual string APBillNo { get; set; }
public abstract class apBillNo : PX.Data.BQL.BqlString.Field<apBillNo> { }
#endregion
#region Type
[PXDBString(20, IsUnicode = true)]
[PXDefault(DBFType.BankDraft)]
[PXUIField(DisplayName = "Type")]
[PXStringList(
new string[]
{
DBFType.BankDraft,
DBFType.Cheque,
DBFType.Cash,
DBFType.BankGuarantee,
DBFType.EPayment,
DBFType.Others
},
new string[]
{
"BankDraft",
"Cheque",
"Cash",
"BankGuarantee",
"EPayment",
"Others"
})]
public virtual string Type { get; set; }
public abstract class type : PX.Data.BQL.BqlString.Field<type> { }
#endregion
#region Status
[PXDBString(20, IsUnicode = true, InputMask = "")]
[PXDefault(StatusType.OnHold)]
[PXUIField(DisplayName = "Status")]
[DBFApprovalStatus.DBFApprovalStatusList]
public virtual string Status { get; set; }
public abstract class status : PX.Data.BQL.BqlString.Field<status> { }
#endregion
#region ApplicationDate
[PXDBDate()]
[PXUIField(DisplayName = "Date")]
public virtual DateTime? ApplicationDate { get; set; }
public abstract class applicationDate : PX.Data.BQL.BqlDateTime.Field<applicationDate> { }
#endregion
#region Description
[PXDBString(500, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Description")]
public virtual string Description { get; set; }
public abstract class description : PX.Data.BQL.BqlString.Field<description> { }
#endregion
#region ApplicationInfo
[PXDBString(500, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Company", Enabled = false)]
[PXDefault(typeof(AccessInfo.companyName))]
public virtual string ApplicationInfo { get; set; }
public abstract class applicationInfo : PX.Data.BQL.BqlString.Field<applicationInfo> { }
#endregion
#region CashAccount
[PXDBString(32)]
[PXUIField(DisplayName = "Cash Account", Visibility = PXUIVisibility.SelectorVisible)]
[PXSelector(typeof(Search<PX.Objects.CA.CashAccount.cashAccountCD>))]
public virtual string CashAccount { get; set; }
public abstract class cashAccount : PX.Data.BQL.BqlString.Field<cashAccount> { }
#endregion
#region CashAccountExtRefNo
[PXDBString(50)]
[PXUIField(DisplayName = "Cash Account - Ext.Ref.No", Visibility = PXUIVisibility.SelectorVisible)]
public virtual string CashAccountExtRefNo { get; set; }
public abstract class cashAccountExtRefNo : PX.Data.BQL.BqlString.Field<cashAccountExtRefNo> { }
#endregion
#region GauranteeDraft
[PXDBString(255, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Gaurantee Draft")]
public virtual string GauranteeDraft { get; set; }
public abstract class gauranteeDraft : PX.Data.BQL.BqlString.Field<gauranteeDraft> { }
#endregion
#region CreatedBy
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Created By")]
public virtual string CreatedBy { get; set; }
public abstract class createdBy : PX.Data.BQL.BqlString.Field<createdBy> { }
#endregion
#region Date
[PXDBDate()]
[PXUIField(DisplayName = "Date", Required = true)]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
public virtual DateTime? Date { get; set; }
public abstract class date : PX.Data.BQL.BqlDateTime.Field<date> { }
#endregion
#region CuryID
public abstract class curyID : PX.Data.BQL.BqlString.Field<curyID> { }
protected String _CuryID;
[PXDBString(5, IsUnicode = true, InputMask = ">LLLLL")]
[PXUIField(DisplayName = "Currency", Visibility = PXUIVisibility.SelectorVisible)]
[PXDefault(typeof(AccessInfo.baseCuryID))]
[PXSelector(typeof(Currency.curyID))]
public virtual String CuryID
{
get
{
return this._CuryID;
}
set
{
this._CuryID = value;
}
}
#endregion
#region CuryInfoID
public abstract class curyInfoID : PX.Data.BQL.BqlLong.Field<curyInfoID> { }
/// <summary>
/// The identifier of the exchange rate record for the deposit.
/// </summary>
/// <value>
/// Corresponds to the <see cref="CurrencyInfo.CuryInfoID"/> field.
/// </value>
[PXDBLong()]
[CurrencyInfo()]
public virtual long? CuryInfoID
{
get;
set;
}
#endregion
#region Amount
[PXDBDecimal()]
[PXUIField(DisplayName = "Bank Facilities Amount")]
public virtual Decimal? Amount { get; set; }
public abstract class amount : PX.Data.BQL.BqlDecimal.Field<amount> { }
#endregion
#region TenorFrom
[PXDBDate()]
[PXUIField(DisplayName = "Tenor From", Required = true)]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
public virtual DateTime? TenorFrom { get; set; }
public abstract class tenorFrom : PX.Data.BQL.BqlDateTime.Field<tenorFrom> { }
#endregion
#region TenorTo
[PXDBDate()]
[PXUIField(DisplayName = "Tenor To")]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
public virtual DateTime? TenorTo { get; set; }
public abstract class tenorTo : PX.Data.BQL.BqlDateTime.Field<tenorTo> { }
#endregion
#region TotalTenor
[PXDBInt()]
[PXUIField(DisplayName = "Total Tenor(Days)")]
public virtual int? TotalTenor { get; set; }
public abstract class totalTenor : PX.Data.BQL.BqlInt.Field<totalTenor> { }
#endregion
#region IsRefundable
[PXDBBool()]
[PXUIField(DisplayName = "Refundable")]
public virtual bool? IsRefundable { get; set; }
public abstract class isRefundable : PX.Data.BQL.BqlBool.Field<isRefundable> { }
#endregion
#region Remarks
[PXDBString(500, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Refund Remarks")]
public virtual string RefundRemarks { get; set; }
public abstract class refundRemarks : PX.Data.BQL.BqlString.Field<refundRemarks> { }
#endregion
#region Refund Amount
[PXDBDecimal()]
[PXUIField(DisplayName = "Refund Amount")]
public virtual Decimal? RefundAmount { get; set; }
public abstract class refundAmount : PX.Data.BQL.BqlDecimal.Field<refundAmount> { }
#endregion
#region RefundDate
[PXDBDate()]
[PXUIField(DisplayName = "Refund Date")]
public virtual DateTime? RefundDate { get; set; }
public abstract class refundDate : PX.Data.BQL.BqlDateTime.Field<refundDate> { }
#endregion
#region Remarks
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Confirm Received By Accounts")]
public virtual string ConfirmReceivedByAccounts { get; set; }
public abstract class confirmReceivedByAccounts : PX.Data.BQL.BqlString.Field<confirmReceivedByAccounts> { }
#endregion
#region ConfirmReceivedDate
[PXDBDate()]
[PXUIField(DisplayName = "Confirm Received Date")]
public virtual DateTime? ConfirmReceivedDate { get; set; }
public abstract class confirmReceivedDate : PX.Data.BQL.BqlDateTime.Field<confirmReceivedDate> { }
#endregion
#region
[PXDBBool()]
[PXUIField(DisplayName = "Amendment", Enabled = false)]
public virtual bool? IsAmendment { get; set; }
public abstract class isAmendment : PX.Data.BQL.BqlBool.Field<isAmendment> { }
#endregion
#region
[PXDBBool()]
[PXUIField(DisplayName = "Renewal", Enabled = false)]
public virtual bool? IsRenewal { get; set; }
public abstract class isRenewal : PX.Data.BQL.BqlBool.Field<isRenewal> { }
#endregion
#region AmendmentIndex
[PXDBInt]
[PXUIField(DisplayName = "Amendment Count", Enabled = false)]
public virtual int? AmendmentIndex { get; set; }
public abstract class amendmentIndex : PX.Data.BQL.BqlInt.Field<amendmentIndex> { }
#endregion
#region AmendmentNo
[PXDBString(50)]
[PXUIField(DisplayName = "AmendmentNo", Enabled = false)]
public virtual string AmendmentNo { get; set; }
public abstract class amendmentNo : PX.Data.BQL.BqlString.Field<amendmentNo> { }
#endregion
#region ProgramEndDate
[PXDBDate()]
[PXUIField(DisplayName = "Project Master Program End Date", Required = true)]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
public virtual DateTime? ProgramEndDate { get; set; }
public abstract class programEndDate : PX.Data.BQL.BqlDateTime.Field<programEndDate> { }
#endregion
#region ClaimPeriod
[PXDBInt()]
[PXUIField(DisplayName = "Claim Period")]
public virtual int? ClaimPeriod { get; set; }
public abstract class claimPeriod : PX.Data.BQL.BqlInt.Field<claimPeriod> { }
#endregion
#region ClaimDate
[PXDBDate()]
[PXUIField(DisplayName = "Claim Date")]
public virtual DateTime? ClaimDate { get; set; }
public abstract class claimDate : PX.Data.BQL.BqlDateTime.Field<claimDate> { }
#endregion
#region AccountID
public abstract class glaccountID : PX.Data.BQL.BqlInt.Field<glaccountID> { }
[PXDefault(1149, PersistingCheck = PXPersistingCheck.NullOrBlank)]
[Account(Visibility = PXUIVisibility.SelectorVisible, AvoidControlAccounts = true, DisplayName = "GL Account")]
public virtual int? GLAccountID
{
get;
set;
}
#endregion
#region SubID
[PXDBInt()]
[PXUIField(DisplayName = "Sub Account")]
public abstract class subID : PX.Data.BQL.BqlInt.Field<subID> { }
public virtual int? SubID
{
get;
set;
}
#endregion
#region AccountID
// //[PXSelector(
// // typeof(Search<Vendor.bAccountID>),
// // typeof(Vendor.acctCD),
// // typeof(Vendor.acctName), SubstituteKey = typeof(Vendor.acctCD),
// // DescriptionField = typeof(Vendor.acctName),
// // SelectorMode = PXSelectorMode.DisplayModeText)]
// [POVendor(Visibility = PXUIVisibility.SelectorVisible, DescriptionField = typeof(Vendor.acctName), CacheGlobal = true, Filterable = true, DisplayName = "^Account ID")]
// //[VendorActive(DisplayName = "Account ID", Required = true)]
// // [VendorNonEmployeeActive(DisplayName = "Account ID", Required = true)]
//// [RestrictVendorByBranch(typeof(AccessInfo.branchID))]
[PXDBInt()]
[PXUIField(DisplayName = "Account ID", Required = true)]
[PXDimensionSelector("VENDOR", typeof(Search<VendorR.bAccountID, Where<VendorR.vStatus, Equal<VendorStatus.active>>>),
typeof(VendorR.acctCD),
new Type[] { typeof(VendorR.acctCD),
typeof(VendorR.acctName),
typeof(VendorR.vendorClassID),
typeof(VendorR.taxRegistrationID)},
Filterable = true,
SelectorMode = PXSelectorMode.TextModeSearch,
DescriptionField = typeof(VendorR.acctName))]
[PXDBDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
public virtual int? AccountID { get; set; }
public abstract class accountID : PX.Data.BQL.BqlInt.Field<accountID> { }
#endregion
#region AccountName
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Account Name", Enabled = false)]
public virtual string AccountName { get; set; }
public abstract class accountName : PX.Data.BQL.BqlString.Field<accountName> { }
#endregion
#region Attention
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Attention", Enabled = false)]
public virtual string Attention { get; set; }
public abstract class attention : PX.Data.BQL.BqlString.Field<attention> { }
#endregion
#region Phone1
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Phone1", Enabled = false)]
public virtual string Phone1 { get; set; }
public abstract class phone1 : PX.Data.BQL.BqlString.Field<phone1> { }
#endregion
#region Email
[PXDBString(200, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Email", Enabled = false)]
public virtual string Email { get; set; }
public abstract class email : PX.Data.BQL.BqlString.Field<email> { }
#endregion
#region BeneficiaryAddress
[PXDBString(500, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Beneficiary Address")]
public virtual string BeneficiaryAddress { get; set; }
public abstract class beneficiaryAddress : PX.Data.BQL.BqlString.Field<beneficiaryAddress> { }
#endregion
#region ProjectCodeID
[Project(DisplayName = "Project Code", Required = true)]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
public virtual int? ProjectCodeID { get; set; }
public abstract class projectCodeID : PX.Data.BQL.BqlInt.Field<projectCodeID> { }
#endregion
#region UsrTaskID
[PXDBInt()]
[PXUIField(DisplayName = "Project Task", Required = true)]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
[PXSelector(
typeof(Search<PMTask.taskID, Where<PMTask.projectID, Equal<Current<projectCodeID>>>>),
typeof(PMTask.taskCD),
typeof(PMTask.description),
typeof(PMTask.status), SubstituteKey = typeof(PMTask.taskCD),
DescriptionField = typeof(PMTask.taskCD),
SelectorMode = PXSelectorMode.DisplayModeText)]
public virtual int? UsrTaskID { get; set; }
public abstract class usrTaskID : PX.Data.BQL.BqlInt.Field<usrTaskID> { }
#endregion
#region UsrCostCode
[CostCode(DisplayName = "Cost Code", Required = true)]
[PXDefault(PersistingCheck = PXPersistingCheck.NullOrBlank)]
public virtual int? UsrCostCode { get; set; }
public abstract class usrCostCode : PX.Data.BQL.BqlInt.Field<usrCostCode> { }
#endregion
#region PurposeCode
[PXDBString(50)]
[PXUIField(DisplayName = "Purpose")]
[PXSelector(
typeof(Search<DBFPurpose.code>),
typeof(DBFPurpose.code),
typeof(DBFPurpose.description), SubstituteKey = typeof(DBFPurpose.code),
DescriptionField = typeof(DBFPurpose.description),
SelectorMode = PXSelectorMode.DisplayModeText)]
public virtual String PurposeCode { get; set; }
public abstract class purposeCode : PX.Data.BQL.BqlString.Field<purposeCode> { }
#endregion
#region Remarks
[PXDBString(500, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Applicant's Remark (If Any)")]
public virtual string Remarks { get; set; }
public abstract class remarks : PX.Data.BQL.BqlString.Field<remarks> { }
#endregion
#region ConsultantID
[PXDBInt]
[PXUIField(DisplayName = "Consultant")]
[PXEPEPEmployeeSelector]
public virtual int? ConsultantID { get; set; }
public abstract class consultantID : PX.Data.BQL.BqlInt.Field<consultantID> { }
#endregion
#region UsrConsultantCD
[PXDBString(30, IsUnicode = true, InputMask = "")]
[PXDefault(PersistingCheck = PXPersistingCheck.Nothing)]
[PXUIField(DisplayName = "ConsultantCD", Visibility = PXUIVisibility.SelectorVisible)]
[PXDimensionSelector("VENDOR", typeof(Search<VendorR.bAccountID, Where<VendorR.vStatus, Equal<VendorStatus.active>>>),
typeof(VendorR.acctCD),
new Type[] { typeof(VendorR.acctCD),
typeof(VendorR.acctName),
typeof(VendorR.vendorClassID),
typeof(VendorR.taxRegistrationID)},
Filterable = true,
SelectorMode = PXSelectorMode.TextModeSearch,
DescriptionField = typeof(VendorR.acctName))]
[PXRestrictor(typeof(Where<FSxVendor.sDEnabled, Equal<True>>), PX.Objects.EP.Messages.EmployeeIsNotLinkedToUser)]
public virtual string UsrConsultantCD { get; set; }
public abstract class usrConsultantCD : PX.Data.BQL.BqlString.Field<usrConsultantCD> { }
#endregion
#region ApplicationID
[PXDBInt]
[PXUIField(DisplayName = "Applicant Name")]
[PXDefault(typeof(Search<EPEmployee.bAccountID, Where<EPEmployee.userID, Equal<Current<AccessInfo.userID>>>>))]
[PXEPEPEmployeeSelector]
public virtual int? ApplicationID { get; set; }
public abstract class applicationID : PX.Data.BQL.BqlInt.Field<applicationID> { }
#endregion
#region ApplicationID
[PXDBInt]
[PXDefault(PersistingCheck = PXPersistingCheck.Nothing)]
[PXUIField(DisplayName = "Reporting HOD")]
public virtual int? ReportingHOD { get; set; }
public abstract class reportingHOD : PX.Data.BQL.BqlInt.Field<reportingHOD> { }
#endregion
#region PromisedDate
[PXDBDate()]
[PXUIField(DisplayName = "Promised Date")]
public virtual DateTime? PromisedDate { get; set; }
public abstract class promisedDate : PX.Data.BQL.BqlDateTime.Field<promisedDate> { }
#endregion
#region ReceiptAddressTo
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Receipt Address To")]
public virtual string ReceiptAddressTo { get; set; }
public abstract class receiptAddressTo : PX.Data.BQL.BqlString.Field<receiptAddressTo> { }
#endregion
#region AddressOverride
[PXDBBool()]
[PXUIField(DisplayName = "Override")]
public virtual bool? AddressOverride { get; set; }
public abstract class addressOverride : PX.Data.BQL.BqlBool.Field<addressOverride> { }
#endregion
#region AddressLine1
[PXDBString(100, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Address Line 1")]
public virtual string AddressLine1 { get; set; }
public abstract class addressLine1 : PX.Data.BQL.BqlString.Field<addressLine1> { }
#endregion
#region AddressLine2
[PXDBString(100, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Address Line 2")]
public virtual string AddressLine2 { get; set; }
public abstract class addressLine2 : PX.Data.BQL.BqlString.Field<addressLine2> { }
#endregion
#region City
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "City")]
public virtual string City { get; set; }
public abstract class city : PX.Data.BQL.BqlString.Field<city> { }
#endregion
#region Country
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Country")]
public virtual string Country { get; set; }
public abstract class country : PX.Data.BQL.BqlString.Field<country> { }
#endregion
#region State
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "State")]
public virtual string State { get; set; }
public abstract class state : PX.Data.BQL.BqlString.Field<state> { }
#endregion
#region PostalCode
[PXDBString(10, IsFixed = true, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Postal Code")]
public virtual string PostalCode { get; set; }
public abstract class postalCode : PX.Data.BQL.BqlString.Field<postalCode> { }
#endregion
#region ChecklistNo
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Authority Checklist No")]
public virtual string ChecklistNo { get; set; }
public abstract class checklistNo : PX.Data.BQL.BqlString.Field<checklistNo> { }
#endregion
#region TradeFacilitiesNo
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Trade Facilities No")]
[PXSelector(typeof(Search<FDDrawdown.refNbr>))]
public virtual string TradeFacilitiesNo { get; set; }
public abstract class tradeFacilitiesNo : PX.Data.BQL.BqlString.Field<tradeFacilitiesNo> { }
#endregion
#region Bank
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Bank")]
public virtual string Bank { get; set; }
public abstract class bank : PX.Data.BQL.BqlString.Field<bank> { }
#endregion
#region BankAddress
[PXDBString(200, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Bank Address")]
public virtual string BankAddress { get; set; }
public abstract class bankAddress : PX.Data.BQL.BqlString.Field<bankAddress> { }
#endregion
#region AccountNo
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Account No")]
public virtual string AccountNo { get; set; }
public abstract class accountNo : PX.Data.BQL.BqlString.Field<accountNo> { }
#endregion
#region DateReceived
[PXDBDate()]
[PXUIField(DisplayName = "Date Received")]
public virtual DateTime? DateReceived { get; set; }
public abstract class dateReceived : PX.Data.BQL.BqlDateTime.Field<dateReceived> { }
#endregion
#region DateCollected
[PXDBDate()]
[PXUIField(DisplayName = "Date Collected")]
public virtual DateTime? DateCollected { get; set; }
public abstract class dateCollected : PX.Data.BQL.BqlDateTime.Field<dateCollected> { }
#endregion
#region DBFExternalNo
[PXDBString(50, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "DBF External No")]
public virtual string DBFExternalNo { get; set; }
public abstract class dBFExternalNo : PX.Data.BQL.BqlString.Field<dBFExternalNo> { }
#endregion
#region InterestRate
[PXDBDecimal()]
[PXUIField(DisplayName = "Int. Rate %")]
public virtual Decimal? InterestRate { get; set; }
public abstract class interestRate : PX.Data.BQL.BqlDecimal.Field<interestRate> { }
#endregion
#region MinRate
[PXDBDecimal()]
[PXUIField(DisplayName = "Min. Rate", Enabled = false)]
public virtual Decimal? MinRate { get; set; }
public abstract class minRate : PX.Data.BQL.BqlDecimal.Field<minRate> { }
#endregion
#region FinanceOverride
[PXDBBool()]
[PXUIField(DisplayName = "Override")]
public virtual bool? FinanceOverride { get; set; }
public abstract class financeOverride : PX.Data.BQL.BqlBool.Field<financeOverride> { }
#endregion
#region StampDuty
[PXDBDecimal()]
[PXUIField(DisplayName = "Stamp Duty")]
[PXDefault(TypeCode.Decimal, "10.0")]
public virtual Decimal? StampDuty { get; set; }
public abstract class stampDuty : PX.Data.BQL.BqlDecimal.Field<stampDuty> { }
#endregion
#region Postage
[PXDBDecimal()]
[PXUIField(DisplayName = "Postage")]
[PXDefault(TypeCode.Decimal, "5.0")]
public virtual Decimal? Postage { get; set; }
public abstract class postage : PX.Data.BQL.BqlDecimal.Field<postage> { }
#endregion
#region BankCommission
[PXDBDecimal()]
[PXUIField(DisplayName = "Bank Commission", Enabled = false)]
public virtual Decimal? BankCommission { get; set; }
public abstract class bankCommission : PX.Data.BQL.BqlDecimal.Field<bankCommission> { }
#endregion
#region TotalBGChargeable
[PXDBDecimal()]
[PXUIField(DisplayName = "Total BG Chargeable", Enabled = false)]
public virtual Decimal? TotalBGChargeable { get; set; }
public abstract class totalBGChargeable : PX.Data.BQL.BqlDecimal.Field<totalBGChargeable> { }
#endregion
#region BGImage
[PXDBString(255, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Upload BG")]
public virtual string BGImage { get; set; }
public abstract class bGImage : PX.Data.BQL.BqlString.Field<bGImage> { }
#endregion
#region SupportDocument
[PXDBString(255, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Upload Supporting Documents")]
public virtual string SupportDocument { get; set; }
public abstract class supportDocument : PX.Data.BQL.BqlString.Field<supportDocument> { }
#endregion
#region UploadReceipt
[PXDBString(255, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Upload Receipt")]
public virtual string UploadReceipt { get; set; }
public abstract class uploadReceipt : PX.Data.BQL.BqlString.Field<uploadReceipt> { }
#endregion
#region PreContruction
[PXDBString(255, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Pre Construction")]
public virtual string PreConstruction { get; set; }
public abstract class preConstruction : PX.Data.BQL.BqlString.Field<preConstruction> { }
#endregion
#region PreContruction
[PXDBString(255, IsUnicode = true, InputMask = "")]
[PXUIField(DisplayName = "Post Construction")]
public virtual string PostConstruction { get; set; }
public abstract class postConstruction : PX.Data.BQL.BqlString.Field<postConstruction> { }
#endregion
#region IsPreConstruction
[PXDBBool()]
[PXUIField(DisplayName = "IsPreConstruction")]
public virtual bool? IsPreConstruction { get; set; }
public abstract class isPreConstruction : PX.Data.BQL.BqlBool.Field<isPreConstruction> { }
#endregion
#region IsPostConstruction
[PXDBBool()]
[PXUIField(DisplayName = "IsPostConstruction")]
public virtual bool? IsPostConstruction { get; set; }
public abstract class isPostConstruction : PX.Data.BQL.BqlBool.Field<isPostConstruction> { }
#endregion
#region Selected
[PXBool]
[PXDefault(false)]
[PXUIField(DisplayName = "Selected")]
public abstract class selected : PX.Data.BQL.BqlBool.Field<selected> { }
public virtual bool? Selected { get; set; }
#endregion
#region CreatedDateTime
[PXDBCreatedDateTime()]
public virtual DateTime? CreatedDateTime { get; set; }
public abstract class createdDateTime : PX.Data.BQL.BqlDateTime.Field<createdDateTime> { }
#endregion
#region CreatedByID
[PXDBCreatedByID()]
public virtual Guid? CreatedByID { get; set; }
public abstract class createdByID : PX.Data.BQL.BqlGuid.Field<createdByID> { }
#endregion
#region CreatedByScreenID
[PXDBCreatedByScreenID()]
public virtual string CreatedByScreenID { get; set; }
public abstract class createdByScreenID : PX.Data.BQL.BqlString.Field<createdByScreenID> { }
#endregion
#region LastModifiedDateTime
[PXDBLastModifiedDateTime()]
public virtual DateTime? LastModifiedDateTime { get; set; }
public abstract class lastModifiedDateTime : PX.Data.BQL.BqlDateTime.Field<lastModifiedDateTime> { }
#endregion
#region LastModifiedByID
[PXDBLastModifiedByID()]
public virtual Guid? LastModifiedByID { get; set; }
public abstract class lastModifiedByID : PX.Data.BQL.BqlGuid.Field<lastModifiedByID> { }
#endregion
#region LastModifiedByScreenID
[PXDBLastModifiedByScreenID()]
public virtual string LastModifiedByScreenID { get; set; }
public abstract class lastModifiedByScreenID : PX.Data.BQL.BqlString.Field<lastModifiedByScreenID> { }
#endregion
#region Tstamp
[PXDBTimestamp()]
public virtual byte[] Tstamp { get; set; }
public abstract class tstamp : PX.Data.BQL.BqlByteArray.Field<tstamp> { }
#endregion
#region Noteid
[PXNote]
public virtual Guid? Noteid { get; set; }
public abstract class noteid : PX.Data.BQL.BqlGuid.Field<noteid> { }
#endregion
#region Hold
public abstract class hold : PX.Data.BQL.BqlBool.Field<hold> { }
protected Boolean? _Hold;
[PXDBBool]
[PXUIField(DisplayName = "Hold", Visibility = PXUIVisibility.Visible)]
[PXDefault(true, PersistingCheck = PXPersistingCheck.Nothing)]
public virtual Boolean? Hold
{
get
{
return this._Hold;
}
set
{
this._Hold = value;
}
}
#endregion
#region Approved
public abstract class approved : PX.Data.BQL.BqlBool.Field<approved> { }
protected Boolean? _Approved;
[PXDBBool()]
[PXDefault(false, PersistingCheck = PXPersistingCheck.Nothing)]
[PXUIField(DisplayName = "Approved", Visibility = PXUIVisibility.Visible, Enabled = false)]
public virtual Boolean? Approved
{
get
{
return this._Approved;
}
set
{
this._Approved = value;
}
}
#endregion
#region Rejected
public abstract class rejected : PX.Data.BQL.BqlBool.Field<rejected> { }
protected bool? _Rejected = false;
[PXBool]
[PXDefault(false, PersistingCheck = PXPersistingCheck.Nothing)]
[PXUIField(DisplayName = "Reject", Visibility = PXUIVisibility.Visible)]
public bool? Rejected
{
get
{
return _Rejected;
}
set
{
_Rejected = value;
}
}
#endregion
#region WorkgroupID
public abstract class workgroupID : PX.Data.BQL.BqlInt.Field<workgroupID> { }
protected int? _WorkgroupID;
[PXDBInt]
[PXDefault(typeof(workgroupID), PersistingCheck = PXPersistingCheck.Nothing)]
[PXCompanyTreeSelector]
public virtual int? WorkgroupID
{
get
{
return this._WorkgroupID;
}
set
{
this._WorkgroupID = value;
}
}
#endregion
#region OwnerID
public abstract class ownerID : PX.Data.BQL.BqlInt.Field<ownerID> { }
protected int? _OwnerID;
[PXDefault(typeof(ownerID), PersistingCheck = PXPersistingCheck.Nothing)]
[Owner(IsDBField = false, DisplayName = "Approver", Enabled = false)]
public virtual int? OwnerID
{
get
{
return this._OwnerID;
}
set
{
this._OwnerID = value;
}
}
#endregion
#region ApprovalWorkgroupID
public abstract class approvalWorkgroupID : PX.Data.BQL.BqlInt.Field<approvalWorkgroupID> { }
protected int? _ApprovalWorkgroupID;
[PXInt]
[PXSelector(typeof(Search<EPCompanyTree.workGroupID>), SubstituteKey = typeof(EPCompanyTree.description))]
[PXUIField(DisplayName = "Approval Workgroup ID", Enabled = false)]
public virtual int? ApprovalWorkgroupID
{
get
{
return this._ApprovalWorkgroupID;
}
set
{
this._ApprovalWorkgroupID = value;
}
}
#endregion
#region ApprovalOwnerID
public abstract class approvalOwnerID : PX.Data.BQL.BqlGuid.Field<approvalOwnerID> { }
protected int? _ApprovalOwnerID;
[PX.TM.Owner(IsDBField = false, DisplayName = "Approver", Enabled = false)]
public virtual int? ApprovalOwnerID
{
get
{
return this._ApprovalOwnerID;
}
set
{
this._ApprovalOwnerID = value;
}
}
#endregion
#region IsApprover
public abstract class isApprover : BqlDecimal.Field<isApprover>
{
}
[PXBool]
public virtual bool? IsApprover { get; set; }
#endregion
#region IAssign Members
int? PX.Data.EP.IAssign.WorkgroupID
{
get { return ApprovalWorkgroupID; }
set { ApprovalWorkgroupID = value; }
}
int? PX.Data.EP.IAssign.OwnerID
{
get { return ApprovalOwnerID; }
set { ApprovalOwnerID = value; }
}
#endregion
}
}
HI
Can you please share the customization project, so that, will review it and share the details if I found anything?
Enter your E-mail address. We'll send you an e-mail with instructions to reset your password.