@rodolfobarrios52 On the record insertion, have you provided all these values? 

Also, I doubt how are you fetching the BudgetFilter DAC filter values in the custom screen.

Can you please confirm that Budget view is working fine properly?

The records are inserted correctly; the issue arises when trying to save a modification we made in the grid. It is at this point that the values from the table are not obtained because they become null.

Not all values from my DAC are being inserted because they are not necessary in the table; some are references to names filled through methods. The values that are inserted are keys and amounts, as I had planned.

The Budget view is working correctly. This is a new screen that does not alter the original Budget screen.

@rodolfobarrios52  Your SAVE should be like below right?

public PXSave<PESRCustomer> Save;

Because of you mentioned BudgetFilter, hence is showing the NULL values. Please check

public PXSave<BudgetFilter> Save;

Yes, I tried to do it that way, but it's a FormDetail. When I use PXSave with the PESRCustomer DAC, the Save button is not displayed on the screen.

Right now, this is how the screen looks:

and this is how it looks with the recommended modification.

@rodolfobarrios52  Understood. Since “BudgetFilter” is the Primary view hence it is not displayed.

Please keep the SAVE like as is public PXSave<BudgetFilter> Save;

I have modified code a bit, can you please try with this code and if it not working. Please share the customization code.

  public class BudgetCustomer : PXGraph<BudgetCustomer>
        {
            public PXCancel<BudgetFilter> Cancel;
            public PXSave<BudgetFilter> Save;
            public PXFilter<BudgetFilter> Filter;


            public SelectFrom<PESRCustomer>
                      .Where<
                          PESRCustomer.branchID.IsEqual<BudgetFilter.branchID.FromCurrent>
                          .And<PESRCustomer.ledgerID.IsEqual<BudgetFilter.ledgerID.FromCurrent>>
                          .And<PESRCustomer.finYear.IsEqual<BudgetFilter.finYear.FromCurrent>>
                          >
                      .View Budget;

            protected void PESRCustomer_CustomerID_FieldUpdated(PXCache cache, PXFieldUpdatedEventArgs e)
            {
                PESRCustomer miRegistro = (PESRCustomer)e.Row;
                if (miRegistro != null)
                    UpdateName(4, miRegistro);
            }
            protected virtual void _(Events.FieldUpdated<PESRCustomer, PESRCustomer.customerClassID> e)
            {
                PESRCustomer miRegistro = e.Row;
                if (miRegistro != null)
                    UpdateName(3, miRegistro);

                throw new PXRedirectRequiredException()
            }
            protected virtual void _(Events.FieldUpdated<PESRCustomer, PESRCustomer.busenissID> e)
            {
                PESRCustomer miRegistro = e.Row;
                if (miRegistro != null)
                    UpdateName(1, miRegistro);
            }
            protected virtual void _(Events.FieldUpdated<PESRCustomer, PESRCustomer.productClassID> e)
            {
                PESRCustomer miRegistro = e.Row;
                if (miRegistro != null)
                    UpdateName(2, miRegistro);
            }

            //protected virtual void _(Events.RowSelected<PESRCustomer> e)
            //{
            //    PESRCustomer miRegistro = e.Row;

            //    UpdateName(1, miRegistro);
            //    UpdateName(2, miRegistro);
            //    UpdateName(3, miRegistro);
            //    UpdateName(4, miRegistro);
            //}

            protected void UpdateName(int Indices, PESRCustomer miRegistro)
            {
                switch (Indices)
                {
                    case 1:
                        if (miRegistro != null)
                        {
                            CSAttributeDetail busniss =
                            SelectFrom<CSAttributeDetail>
                            .Where<CSAttributeDetail.attributeID.IsEqual<@P.AsString>
                                .And<CSAttributeDetail.valueID.IsEqual<@P.AsString>>
                                >.View.Select(this, "SRBUSINESS", miRegistro.BusenissID);

                            if (busniss != null)
                            {
                                miRegistro.BusenissName = busniss.Description;
                            }
                        }
                        break;
                    case 2:
                        if (miRegistro != null)
                        {
                            INItemClass itemclasses = SelectFrom<INItemClass>.Where<INItemClass.itemClassID.IsEqual<@P.AsInt>>.View.Select(this, miRegistro.ProductClassID);
                            if (itemclasses != null)
                            {
                                miRegistro.ProductClassName = itemclasses.Descr;
                            }
                        }

                        break;
                    case 3:
                        if (miRegistro != null)
                        {
                            CustomerClass customerclassDescripcion = SelectFrom<CustomerClass>.Where<CustomerClass.customerClassID.IsEqual<@P.AsString>>.View.Select(this, miRegistro.CustomerClassID);
                            if (customerclassDescripcion != null)
                            {
                                miRegistro.CustomerClassName = customerclassDescripcion.Descr;
                            }
                        }

                        break;
                    case 4:
                        if (miRegistro != null)
                        {
                            Customer customer = PXSelect<Customer, Where<Customer.bAccountID, Equal<Required<Customer.bAccountID>>>>.Select(this, miRegistro.CustomerID);
                            if (customer != null)
                            {
                                miRegistro.CustomerName = customer.AcctName;
                            }
                        }
                        break;

                }
            }
        }

I didn't get it to work. The customization code is in the question, but I'll resend it in case it didn't copy correctly. As for BudgetFilter, it hasn't been altered; it's only being used to provide a list for filters.

using System;
using System.Runtime.CompilerServices;
using PX.Common;
using PX.CS;
using PX.Data;
using PX.Data.BQL;

using PX.Data.BQL.Fluent;
using PX.Data.Maintenance.GI;
using PX.Data.ReferentialIntegrity.Attributes;
using PX.Objects.AR;
using PX.Objects.CR;
using PX.Objects.CS;
using PX.Objects.GL;
using PX.Objects.IN;
using static PX.SM.RowNewFile;
using CSAttribute = PX.CS.CSAttribute;
using CSAttributeDetail = PX.CS.CSAttributeDetail;


namespace SalesReport
{
    public class BudgetCustomer : PXGraph<BudgetCustomer>
    {

        public PXCancel<BudgetFilter> Cancel;
        public PXSave<BudgetFilter> Save;


        public PXFilter<BudgetFilter> Filter;

         PXImport(typeof(BudgetFilter))]
        public SelectFrom<PESRCustomer>
                  .Where<
                      PESRCustomer.branchID.IsEqual<BudgetFilter.branchID.FromCurrent>
                      .And<PESRCustomer.ledgerID.IsEqual<BudgetFilter.ledgerID.FromCurrent>>
                      .And<PESRCustomer.finYear.IsEqual<BudgetFilter.finYear.FromCurrent>>
                      >
                  .View Budget;

        protected void PESRCustomer_CustomerID_FieldUpdated(PXCache cache, PXFieldUpdatedEventArgs e)
        {
            PESRCustomer miRegistro = (PESRCustomer)e.Row;
            UpdateName(4, miRegistro);
        }
        protected virtual void _(Events.FieldUpdated<PESRCustomer, PESRCustomer.customerClassID> e)
        {
            PESRCustomer miRegistro = e.Row;
            UpdateName(3, miRegistro);
        }
        protected virtual void _(Events.FieldUpdated<PESRCustomer, PESRCustomer.busenissID> e)
        {
            PESRCustomer miRegistro = e.Row;
            UpdateName(1, miRegistro);
        }
        protected virtual void _(Events.FieldUpdated<PESRCustomer, PESRCustomer.productClassID> e)
        {
            PESRCustomer miRegistro = e.Row;
            UpdateName(2, miRegistro);
        }

        protected virtual void _(Events.RowSelected<PESRCustomer> e)
        {
            PESRCustomer miRegistro = e.Row;

            UpdateName(1, miRegistro);
            UpdateName(2, miRegistro);
            UpdateName(3, miRegistro);
            UpdateName(4, miRegistro);
        }

        protected void UpdateName(int Indices, PESRCustomer miRegistro)
        {
            switch (Indices)
            {
                case 1:
                    if (miRegistro != null)
                    {
                        CSAttributeDetail busniss = 
                        SelectFrom<CSAttributeDetail>
                        .Where<CSAttributeDetail.attributeID.IsEqual<@P.AsString>
                            .And<CSAttributeDetail.valueID.IsEqual<@P.AsString>>
                            >.View.Select(this, "SRBUSINESS", miRegistro.BusenissID);

                        if (busniss != null)
                        {
                            miRegistro.BusenissName = busniss.Description;
                        }
                    }
                    break;
                case 2:
                    if (miRegistro != null)
                    {
                        INItemClass itemclasses = SelectFrom<INItemClass>.Where<INItemClass.itemClassID.IsEqual<@P.AsInt>>.View.Select(this, miRegistro.ProductClassID);
                        if (itemclasses != null)
                        {
                            miRegistro.ProductClassName = itemclasses.Descr;
                        }
                    }

                    break;
                case 3:
                    if (miRegistro != null)
                    {
                        CustomerClass customerclassDescripcion = SelectFrom<CustomerClass>.Where<CustomerClass.customerClassID.IsEqual<@P.AsString>>.View.Select(this, miRegistro.CustomerClassID);
                        if (customerclassDescripcion != null)
                        {
                            miRegistro.CustomerClassName = customerclassDescripcion.Descr;
                        }
                    }

                    break;
                case 4:
                    if (miRegistro != null)
                    {
                        Customer customer = PXSelect<Customer, Where<Customer.bAccountID, Equal<Required<Customer.bAccountID>>>>.Select(this, miRegistro.CustomerID);
                        if (customer != null)
                        {
                            miRegistro.CustomerName = customer.AcctName;
                        }
                    }
                    break;

            }
        }
    }
    #region PESRCustomer
    rSerializable]
    rPXCacheName("PESRCustomer")]
    public class PESRCustomer : IBqlTable
    {


        #region Constantes
        public static class SRBUSINESSConstants
        {
            public const string SRBusiness = "SRBUSINESS";
        }
        public class srbusiness : PX.Data.BQL.BqlString.Constant<srbusiness>
        {
            public srbusiness() : base(SRBUSINESSConstants.SRBusiness) { }
        }
        #endregion


        #region BranchID
         Branch(typeof(BudgetFilter.branchID))]
        // Branch(Required = true)]
        public virtual int? BranchID { get; set; }
        public abstract class branchID : PX.Data.BQL.BqlInt.Field<branchID> { }
        #endregion
        //#region BranchID
        // Branch()]
        // PXUIField(DisplayName = "Branch ID")]
        //public virtual int? BranchID { get; set; }
        //public abstract class branchID : PX.Data.BQL.BqlInt.Field<branchID> { }
        //#endregion
        #region LedgerID
         PXDBInt(IsKey = true)]
         PXDefault(typeof(BudgetFilter.ledgerID))]
         PXUIField(Enabled = false, Visible = false)]//, Visible = false, Visibility = PXUIVisibility.Invisible
         PXSelector(typeof(Ledger.ledgerID), SubstituteKey = typeof(Ledger.ledgerCD))]
        public virtual int? LedgerID { get; set; }
        public abstract class ledgerID : PX.Data.BQL.BqlInt.Field<ledgerID> { }
        #endregion
        #region FinYear
         PXDBString(4, IsKey = true, IsFixed = true, InputMask = "")]
         PXDefault(typeof(BudgetFilter.finYear))]
         PXUIField(DisplayName = "Fin Year", Visible = false)]
        public virtual string FinYear { get; set; }
        public abstract class finYear : PX.Data.BQL.BqlString.Field<finYear> { }
        #endregion



        #region BusenissID
         PXDBString(9, IsKey = true)]
         PXUIField(DisplayName = "Business")]
         PXSelector(typeof(Search5<CSAttributeDetail.valueID,
              InnerJoin<CSAttribute, On<CSAttribute.attributeID, Equal<CSAttributeDetail.attributeID>>>,
              Where<CSAttribute.attributeID, Equal<srbusiness>>,
              Aggregate<GroupBy<CSAttributeDetail.valueID>>,
              OrderBy<Asc<CSAttributeDetail.valueID>>
              >),
          typeof(CSAttributeDetail.valueID), typeof(CSAttributeDetail.description),
          DescriptionField = typeof(CSAttributeDetail.description)

        )]
        public virtual string BusenissID { get; set; }
        public abstract class busenissID : PX.Data.BQL.BqlString.Field<busenissID> { }
        #endregion
        #region BusenissName

         PXString(250)]
         PXUIField(DisplayName = "Buseniss Name", IsReadOnly = true)]

        public virtual string BusenissName { get; set; }
        public abstract class busenissName : PX.Data.BQL.BqlString.Field<busenissName> { }
        #endregion
        #region ProductClassID
         PXDBInt(IsKey = true)]
         PXUIField(DisplayName = "Item Class ID", Visibility = PXUIVisibility.SelectorVisible)]
         PXSelector(typeof(Search<INItemClass.itemClassID>),
            SubstituteKey = typeof(INItemClass.itemClassCD),
            DescriptionField = typeof(INItemClass.descr), ValidateValue = false)]
        public virtual int? ProductClassID { get; set; }
        public abstract class productClassID : PX.Data.BQL.BqlInt.Field<productClassID> { }
        #endregion
        #region ProductClassName
         PXString(250)]
         PXUIField(DisplayName = "Item Class Name", IsReadOnly = true)]

        public virtual string ProductClassName { get; set; }
        public abstract class productClassName : PX.Data.BQL.BqlString.Field<productClassName> { }
        #endregion
        #region CustomerClassID
         PXDBString(18, IsKey = true, IsUnicode = true)]
         PXSelector(typeof(Search<CustomerClass.customerClassID>),
            typeof(CustomerClass.customerClassID),
           SubstituteKey = typeof(CustomerClass.customerClassID),
            DescriptionField = typeof(CustomerClass.descr))]
         PXUIField(DisplayName = "Customer Class ID", Visibility = PXUIVisibility.SelectorVisible)]
        public virtual string CustomerClassID { get; set; }
        public abstract class customerClassID : PX.Data.BQL.BqlString.Field<customerClassID> { }
        #endregion
        #region CustomerClassName
         PXString(250)]
         PXUIField(DisplayName = "Customer Class Name", IsReadOnly = true)]
        public virtual string CustomerClassName { get; set; }
        public abstract class customerClassName : PX.Data.BQL.BqlString.Field<customerClassName> { }
        #endregion
        #region CustomerID  
         PXDBInt(IsKey = true)]
         PXSelector(typeof(Customer.bAccountID), typeof(Customer.acctCD), typeof(Customer.acctName),
            SubstituteKey = typeof(Customer.acctCD),
            DescriptionField = typeof(Customer.acctName))]
         PXUIField(DisplayName = "Customer ID")]
        public virtual int? CustomerID { get; set; }
        public abstract class customerID : PX.Data.BQL.BqlInt.Field<customerID> { }
        #endregion
        #region CustomerName
         PXString(250)]
         PXUIField(DisplayName = "Customer Name", IsReadOnly = true)]

        public virtual string CustomerName { get; set; }
        public abstract class customerName : PX.Data.BQL.BqlString.Field<customerName> { }
        #endregion

        #region Amount
         PXDBDecimal()]
         PXUIField(DisplayName = "Amount")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? Amount { get; set; }
        public abstract class amount : PX.Data.BQL.BqlDecimal.Field<amount> { }
        #endregion

        #region AllocatedAmount
         PXDBDecimal()]
         PXUIField(DisplayName = "Allocated Amount", Enabled = false)]
         PXDefault(TypeCode.Decimal, "0.0")]

         PXFormula(typeof(Add<finPeriod01, Add<finPeriod02, Add<finPeriod03, Add<finPeriod04, Add<finPeriod05, Add<finPeriod06, Add<finPeriod07, Add<finPeriod08, Add<finPeriod09, Add<finPeriod10, Add<finPeriod11, Add<finPeriod12, finPeriod13>>>>>>>>>>>>))]
        public virtual Decimal? AllocatedAmount { get; set; }

        protected Decimal? _AllocatedAmount;
        public abstract class allocatedAmount : PX.Data.BQL.BqlDecimal.Field<allocatedAmount> { }
        #endregion
        #region FinPeriod01
         PXDBDecimal()]
         PXUIField(DisplayName = "January")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod01 { get; set; }
        public abstract class finPeriod01 : PX.Data.BQL.BqlDecimal.Field<finPeriod01> { }
        #endregion

        #region FinPeriod02
         PXDBDecimal()]
         PXUIField(DisplayName = "February")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod02 { get; set; }
        public abstract class finPeriod02 : PX.Data.BQL.BqlDecimal.Field<finPeriod02> { }
        #endregion

        #region FinPeriod03
         PXDBDecimal()]
         PXUIField(DisplayName = "March")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod03 { get; set; }
        public abstract class finPeriod03 : PX.Data.BQL.BqlDecimal.Field<finPeriod03> { }
        #endregion

        #region FinPeriod04
         PXDBDecimal()]
         PXUIField(DisplayName = "April")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod04 { get; set; }
        public abstract class finPeriod04 : PX.Data.BQL.BqlDecimal.Field<finPeriod04> { }
        #endregion

        #region FinPeriod05
         PXDBDecimal()]
         PXUIField(DisplayName = "May")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod05 { get; set; }
        public abstract class finPeriod05 : PX.Data.BQL.BqlDecimal.Field<finPeriod05> { }
        #endregion

        #region FinPeriod06
         PXDBDecimal()]
         PXUIField(DisplayName = "June")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod06 { get; set; }
        public abstract class finPeriod06 : PX.Data.BQL.BqlDecimal.Field<finPeriod06> { }
        #endregion

        #region FinPeriod07
         PXDBDecimal()]
         PXUIField(DisplayName = "July")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod07 { get; set; }
        public abstract class finPeriod07 : PX.Data.BQL.BqlDecimal.Field<finPeriod07> { }
        #endregion

        #region FinPeriod08
         PXDBDecimal()]
         PXUIField(DisplayName = "August")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod08 { get; set; }
        public abstract class finPeriod08 : PX.Data.BQL.BqlDecimal.Field<finPeriod08> { }
        #endregion

        #region FinPeriod09
         PXDBDecimal()]
         PXUIField(DisplayName = "September")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod09 { get; set; }
        public abstract class finPeriod09 : PX.Data.BQL.BqlDecimal.Field<finPeriod09> { }
        #endregion

        #region FinPeriod10
         PXDBDecimal()]
         PXUIField(DisplayName = "October")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod10 { get; set; }
        public abstract class finPeriod10 : PX.Data.BQL.BqlDecimal.Field<finPeriod10> { }
        #endregion

        #region FinPeriod11
         PXDBDecimal()]
         PXUIField(DisplayName = "November")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod11 { get; set; }
        public abstract class finPeriod11 : PX.Data.BQL.BqlDecimal.Field<finPeriod11> { }
        #endregion

        #region FinPeriod12
         PXDBDecimal()]
         PXUIField(DisplayName = "December")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod12 { get; set; }
        public abstract class finPeriod12 : PX.Data.BQL.BqlDecimal.Field<finPeriod12> { }
        #endregion

        #region FinPeriod13
         PXDBDecimal()]
         PXUIField(DisplayName = "Fin Period13")]
         PXDefault(TypeCode.Decimal, "0.0")]
        public virtual Decimal? FinPeriod13 { get; set; }
        public abstract class finPeriod13 : PX.Data.BQL.BqlDecimal.Field<finPeriod13> { }
        #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 CreatedDateTime
         PXDBCreatedDateTime()]
        public virtual DateTime? CreatedDateTime { get; set; }
        public abstract class createdDateTime : PX.Data.BQL.BqlDateTime.Field<createdDateTime> { }
        #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 LastModifiedDateTime
         PXDBLastModifiedDateTime()]
        public virtual DateTime? LastModifiedDateTime { get; set; }
        public abstract class lastModifiedDateTime : PX.Data.BQL.BqlDateTime.Field<lastModifiedDateTime> { }
        #endregion

        #region Tstamp
         PXDBTimestamp()]
         PXUIField(DisplayName = "Tstamp")]
        public virtual byteu] 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
    }
    #endregion
}

@rodolfobarrios52 As this is a custom screen, we need .aspx files/screens to test this, hence requested for thr customization package.

<%@ Page Language="C#" MasterPageFile="~/MasterPages/FormDetail.master" AutoEventWireup="true" ValidateRequest="false" CodeFile="XT302000.aspx.cs" Inherits="Page_XT302000" Title="Untitled Page" %>
<%@ MasterType VirtualPath="~/MasterPages/FormDetail.master" %>

<asp:Content ID="cont1" ContentPlaceHolderID="phDS" Runat="Server">
	<px:PXDataSource PageLoadBehavior="PopulateSavedValues" EnableAttributes="True" ID="ds" runat="server" Visible="True" Width="100%"
        TypeName="SalesReport.BudgetCustomerMaint"
        PrimaryView="Filter"
        >
		<CallbackCommands>

		</CallbackCommands>
	</px:PXDataSource>
</asp:Content>
<asp:Content ID="cont2" ContentPlaceHolderID="phF" Runat="Server">
	<px:PXFormView ID="form" runat="server" DataSourceID="ds" DataMember="Filter" Width="100%" Height="100px" AllowAutoHide="false">
		<Template>
			<px:PXLayoutRule ID="PXLayoutRule1" runat="server" StartRow="True"></px:PXLayoutRule>
			<px:PXSelector CommitChanges="True" runat="server" ID="CstPXSelector2" DataField="LedgerID" ></px:PXSelector>
			<px:PXSelector CommitChanges="True" runat="server" ID="CstPXSelector1" DataField="FinYear" ></px:PXSelector></Template>
	</px:PXFormView>
</asp:Content>
<asp:Content ID="cont3" ContentPlaceHolderID="phG" Runat="Server">
	<px:PXGrid SyncPosition="True" ID="grid" runat="server" DataSourceID="ds" Width="100%" Height="150px" SkinID="Details" AllowAutoHide="false">
		<Levels>
			<px:PXGridLevel DataMember="Budget">
			    <Columns>
				<px:PXGridColumn CommitChanges="True" DataField="BusenissID" Width="108" ></px:PXGridColumn>
				<px:PXGridColumn DataField="BusenissName" Width="70" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="ProductClassID" Width="108" ></px:PXGridColumn>
				<px:PXGridColumn DataField="ProductClassName" Width="70" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="CustomerClassID" Width="140" ></px:PXGridColumn>
				<px:PXGridColumn DataField="CustomerClassName" Width="70" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="CustomerID" Width="70" ></px:PXGridColumn>
				<px:PXGridColumn DataField="CustomerName" Width="280" ></px:PXGridColumn>
				<px:PXGridColumn DataField="Amount" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn DataField="AllocatedAmount" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod01" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod02" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod03" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod04" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod05" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod06" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod07" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod08" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod09" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod10" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod11" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod12" Width="100" ></px:PXGridColumn>
				<px:PXGridColumn CommitChanges="True" DataField="FinPeriod13" Width="100" ></px:PXGridColumn></Columns>
			</px:PXGridLevel>
		</Levels>
		<AutoSize Container="Window" Enabled="True" MinHeight="150" ></AutoSize>
		<ActionBar >
		</ActionBar>

		<Mode AllowUpload="True" /></px:PXGrid>
</asp:Content>

@rodolfobarrios52 We cannot work if you can share the individual code. Please share the customization project.

Hi @rodolfobarrios52 were you able to find a solution? Thank you!