private bool IsSegmentValueExist(SegmentValue segValue)
{
PXSelectBase select = new PXSelect <SegmentValue,
Where <SegmentValue.dimensionID, Equal <Required <SegmentValue.dimensionID> >,
And <SegmentValue.segmentID, Equal <Required <SegmentValue.segmentID> >,
And <SegmentValue.value, Equal <Required <SegmentValue.value> > > > > >(this);
var result = select.View.SelectSingle(segValue.DimensionID, segValue.SegmentID, segValue.Value);
return(result != null);
}
private void InsertNumberingValue(Dimension dimension)
{
foreach (Segment segrow in GetDetails(dimension.DimensionID))
{
if (segrow.Inherited == true)
{
continue;
}
if (segrow.AutoNumber == true)
{
segrow.EditMask = "C";
segrow.Validate = false;
//segrow.CaseConvert = 0;
segrow.FillCharacter = " ";
Detail.Update(segrow);
Numbering numb = PXSelect <Numbering,
Where <Numbering.numberingID, Equal <Required <Numbering.numberingID> > > > .
Select(this, dimension.NumberingID);
bool numvalueexists = false;
if (numb == null)
{
throw new PXException(Messages.NumberingIDRequired);
}
var valuesCache = Caches[typeof(SegmentValue)];
foreach (SegmentValue val in
PXSelect <SegmentValue,
Where <SegmentValue.dimensionID, Equal <Required <SegmentValue.dimensionID> >,
And <SegmentValue.segmentID, Equal <Required <SegmentValue.segmentID> > > > > .
Select(this, segrow.DimensionID, segrow.SegmentID))
{
if (!object.Equals(val.Value, numb.NewSymbol))
{
valuesCache.Delete(val);
}
else
{
numvalueexists = true;
}
}
if (!numvalueexists)
{
SegmentValue val = new SegmentValue();
val.DimensionID = segrow.DimensionID;
val.SegmentID = segrow.SegmentID;
val.Value = numb.NewSymbol;
valuesCache.Insert(val);
}
}
}
}
protected virtual void SegmentValue_IsConsolidatedValue_FieldUpdated(PXCache cache, PXFieldUpdatedEventArgs e)
{
SegmentValue currow = e.Row as SegmentValue;
if ((bool)currow.IsConsolidatedValue)
{
foreach (SegmentValue segrow in Values.Select(currow.DimensionID, currow.SegmentID))
{
if ((bool)segrow.IsConsolidatedValue && segrow.Value != currow.Value)
{
segrow.IsConsolidatedValue = (bool)false;
Values.Cache.Update(segrow);
}
}
}
Values.View.RequestRefresh();
}
protected virtual void SegmentValue_RowInserting(PXCache cache, PXRowInsertingEventArgs e)
{
SegmentValue segValue = (SegmentValue)e.Row;
if (segValue != null && segValue.SegmentID.HasValue && string.IsNullOrEmpty(segValue.Value) == false)
{
if (IsSegmentValueExist(segValue))
{
if (segValue.IsConsolidatedValue != true)
{
cache.RaiseExceptionHandling <SegmentValue.value>(e.Row, segValue.Value, new PXException(Messages.SegmentValueExistsType));
e.Cancel = true;
}
else
{
throw new PXException(Messages.SegmentValueExistsType);
}
}
}
}
private void AddNewInjection(PXCache target, string specificModule)
{
var graph = target.Graph;
foreach (PX.SM.RelationGroup group in PXSelect <PX.SM.RelationGroup,
Where <PX.SM.RelationGroup.specificModule, Equal <Required <Dimension.specificModule> >,
And <PX.SM.RelationGroup.specificType, Equal <Required <PX.SM.RelationGroup.specificType> > > > >
.Select(graph, specificModule, typeof(SegmentValue).FullName))
{
string name = @group.GroupName;
byte[] mask = @group.GroupMask;
if (!target.Fields.Contains(name) && mask != null)
{
PXFieldSelecting fieldSelectingHandler = delegate(PXCache cache, PXFieldSelectingEventArgs a)
{
a.ReturnState = PXFieldState.CreateInstance(a.ReturnState, typeof(Boolean), null, null, null, null, null, null, name, null, null, null, PXErrorLevel.Undefined, null, null, null, PXUIVisibility.Dynamic, null, null, null);
SegmentValue value = (SegmentValue)a.Row;
if (value != null)
{
a.ReturnValue = false;
if (value.GroupMask != null)
{
for (int i = 0; i < value.GroupMask.Length && i < mask.Length; i++)
{
if (mask[i] != 0x00 && (mask[i] & value.GroupMask[i]) == mask[i])
{
a.ReturnValue = true;
return;
}
}
}
}
};
PXFieldUpdating fieldUpdatingHandler = delegate(PXCache cache, PXFieldUpdatingEventArgs a)
{
SegmentValue value = (SegmentValue)a.Row;
if (value != null && a.NewValue != null)
{
bool included = false;
if (a.NewValue is string)
{
bool.TryParse((string)a.NewValue, out included);
}
else
{
included = (bool)a.NewValue;
}
if (value.GroupMask == null)
{
value.GroupMask = new byte[mask.Length];
}
else if (value.GroupMask.Length < mask.Length)
{
byte[] arr = value.GroupMask;
Array.Resize <byte>(ref arr, mask.Length);
value.GroupMask = arr;
}
for (int i = 0; i < mask.Length; i++)
{
if (mask[i] != 0x00)
{
if (included)
{
value.GroupMask[i] = (byte)(value.GroupMask[i] | mask[i]);
}
else
{
value.GroupMask[i] = (byte)(value.GroupMask[i] & ~mask[i]);
}
if (target.Locate(value) != null && target.GetStatus(value) == PXEntryStatus.Notchanged)
{
target.SetStatus(value, PXEntryStatus.Updated);
}
return;
}
}
}
};
_items.Add(new Box(name, fieldSelectingHandler, fieldUpdatingHandler));
target.Fields.Add(name);
graph.FieldSelecting.AddHandler(typeof(SegmentValue), name, fieldSelectingHandler);
graph.FieldUpdating.AddHandler(typeof(SegmentValue), name, fieldUpdatingHandler);
}
}
}
