Saving a field depending on the Tab selected - acumatica

Question

I am having trouble to find a solution in how to save a char type field depending on the Tab that the user is positioned. I have "Fringe", "Overhead" and "G&A" tabs where the 3 of them share the same database table. The problem is that I want to save this Type field ("F","O" or "G") depending on the Tab that I am in.
Tabs and Type field in the grid
The solution that I am trying, was to create 3 different DAC Unbounded for each tab and save the information on the datamembers bounded to these tabs (the type field is included on each tab). After doing this, I used the Event Handler RowPersisting to insert manually on database (which it worked correctly) and also I needed to implement the RowDeleting to delete a row if needed. This is where this solution is not working.
Basically the RowDeleting EventHandler is not showing the correct information of the current row in which this event was triggered.
IU Row vs What the event is showing as the current row

Answer 1

I would look into using projections (PXProjection) in Acumatica so you can create additional DACs representing your different types (as they are located on different Tabs but stored in the same table). This way you don not have to use any events to do any complex/tricky logic against the framework as you have described you are doing.
I put together a simple example below. Note the 3 projection DACs that point to the same main dac. This allows the records to be all stored inMyTable in the database but each will have their own cache.
Here I define my different types...
public class MyDacType
{
public const string TypeA = "A";
public const string TypeB = "B";
public const string TypeC = "B";
public class typeA : Constant<string>
{
public typeA() : base(TypeA) { }
}
public class typeB : Constant<string>
{
public typeB() : base(TypeB) { }
}
public class typeC : Constant<string>
{
public typeC() : base(TypeC) { }
}
/// <summary>
/// List attribute for display of user friendly value
/// </summary>
public class ListAttribute : PXStringListAttribute
{
public ListAttribute()
: base(new string[]
{
TypeA,
TypeB,
TypeC
}, new string[]
{
"Type A",
"Type B",
"Type C"
})
{
}
}
}
This is my main table...
/// <summary>
/// Main database DAC
/// </summary>
[Serializable]
public class MyTable : IBqlTable
{
#region SomeKeyField
public abstract class someKeyField : PX.Data.IBqlField
{
}
protected string _SomeKeyField;
[PXDBString(10, IsKey = true, IsUnicode = true)]
[PXDefault]
[PXUIField(DisplayName = "My Key Field", Enabled = false)]
public virtual string SomeKeyField
{
get
{
return this._SomeKeyField;
}
set
{
this._SomeKeyField = value;
}
}
#endregion
#region DacType
public abstract class dacType : PX.Data.IBqlField
{
}
protected string _DacType;
[PXDBString(1)]
[PXDefault]
[MyDacType.List]
[PXUIField(DisplayName = "Dac Type")]
public virtual string DacType
{
get
{
return this._DacType;
}
set
{
this._DacType = value;
}
}
#endregion
#region Description
public abstract class description : PX.Data.IBqlField
{
}
protected string _Description;
[PXDBString(256, IsUnicode = true)]
[PXUIField(DisplayName = "Description")]
public virtual string Description
{
get
{
return this._Description;
}
set
{
this._Description = value;
}
}
#endregion
}
I created 3 projections (one for each tab)...
/// <summary>
/// DAC representing Type A (data stored in MyTable)
/// </summary>
[Serializable]
[PXProjection(typeof(Select<MyTable, Where<MyTable.dacType, Equal<MyDacType.typeA>>>), Persistent = true)]
public class MyTableTypeA : IBqlTable
{
#region SomeKeyField
public abstract class someKeyField : PX.Data.IBqlField
{
}
protected string _SomeKeyField;
[PXDBString(10, IsKey = true, IsUnicode = true, BqlField = typeof(MyTable.someKeyField))]
[PXDefault]
[PXUIField(DisplayName = "My Key Field", Enabled = false)]
public virtual string SomeKeyField
{
get
{
return this._SomeKeyField;
}
set
{
this._SomeKeyField = value;
}
}
#endregion
#region DacType
public abstract class dacType : PX.Data.IBqlField
{
}
protected string _DacType;
[PXDBString(1, BqlField = typeof(MyTable.dacType))]
[PXDefault(MyDacType.TypeA)]
[MyDacType.List]
[PXUIField(DisplayName = "Dac Type", Enabled = false, Visible = false)]
public virtual string DacType
{
get
{
return this._DacType;
}
set
{
this._DacType = value;
}
}
#endregion
#region Description
public abstract class description : PX.Data.IBqlField
{
}
protected string _Description;
[PXDBString(256, IsUnicode = true, BqlField = typeof(MyTable.description))]
[PXUIField(DisplayName = "Description")]
public virtual string Description
{
get
{
return this._Description;
}
set
{
this._Description = value;
}
}
#endregion
}
/// <summary>
/// DAC representing Type B (data stored in MyTable)
/// </summary>
[Serializable]
[PXProjection(typeof(Select<MyTable, Where<MyTable.dacType, Equal<MyDacType.typeB>>>), Persistent = true)]
public class MyTableTypeB : IBqlTable
{
#region SomeKeyField
public abstract class someKeyField : PX.Data.IBqlField
{
}
protected string _SomeKeyField;
[PXDBString(10, IsKey = true, IsUnicode = true, BqlField = typeof(MyTable.someKeyField))]
[PXDefault]
[PXUIField(DisplayName = "My Key Field", Enabled = false)]
public virtual string SomeKeyField
{
get
{
return this._SomeKeyField;
}
set
{
this._SomeKeyField = value;
}
}
#endregion
#region DacType
public abstract class dacType : PX.Data.IBqlField
{
}
protected string _DacType;
[PXDBString(1, BqlField = typeof(MyTable.dacType))]
[PXDefault(MyDacType.TypeB)]
[MyDacType.List]
[PXUIField(DisplayName = "Dac Type", Enabled = false, Visible = false)]
public virtual string DacType
{
get
{
return this._DacType;
}
set
{
this._DacType = value;
}
}
#endregion
#region Description
public abstract class description : PX.Data.IBqlField
{
}
protected string _Description;
[PXDBString(256, IsUnicode = true, BqlField = typeof(MyTable.description))]
[PXUIField(DisplayName = "Description")]
public virtual string Description
{
get
{
return this._Description;
}
set
{
this._Description = value;
}
}
#endregion
}
/// <summary>
/// DAC representing Type C (data stored in MyTable)
/// </summary>
[Serializable]
[PXProjection(typeof(Select<MyTable, Where<MyTable.dacType, Equal<MyDacType.typeC>>>), Persistent = true)]
public class MyTableTypeC : IBqlTable
{
#region SomeKeyField
public abstract class someKeyField : PX.Data.IBqlField
{
}
protected string _SomeKeyField;
[PXDBString(10, IsKey = true, IsUnicode = true, BqlField = typeof(MyTable.someKeyField))]
[PXDefault]
[PXUIField(DisplayName = "My Key Field", Enabled = false)]
public virtual string SomeKeyField
{
get
{
return this._SomeKeyField;
}
set
{
this._SomeKeyField = value;
}
}
#endregion
#region DacType
public abstract class dacType : PX.Data.IBqlField
{
}
protected string _DacType;
[PXDBString(1, BqlField = typeof(MyTable.dacType))]
[PXDefault(MyDacType.TypeC)]
[MyDacType.List]
[PXUIField(DisplayName = "Dac Type", Enabled = false, Visible = false)]
public virtual string DacType
{
get
{
return this._DacType;
}
set
{
this._DacType = value;
}
}
#endregion
#region Description
public abstract class description : PX.Data.IBqlField
{
}
protected string _Description;
[PXDBString(256, IsUnicode = true, BqlField = typeof(MyTable.description))]
[PXUIField(DisplayName = "Description")]
public virtual string Description
{
get
{
return this._Description;
}
set
{
this._Description = value;
}
}
#endregion
}
Now in my graph I create 3 views (1 for each PXProjection dac). I also do not need to display the DacType field since it will automatically default to the correct value.
public class MyGraph : PXGraph<MyGraph>
{
// Some other views...
/// <summary>
/// View for tab 1
/// </summary>
public PXSelect<MyTableTypeA> TypeA;
/// <summary>
/// View for tab 2
/// </summary>
public PXSelect<MyTableTypeB> TypeB;
/// <summary>
/// View for tab 3
/// </summary>
public PXSelect<MyTableTypeC> TypeC;
// When using events and cache attached you use the DAC name. Ex:
// protected virtual void MyTableTypeB_RowDeleting(PXCache cache, RowDeletingEvents e) { }
}