Reg : Select Boolean issue in Processing screen

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
    }
}