protected virtual void PrepareMatrixItemList() { MatrixItemsForCreation.Cache.Clear(); var templateItem = GetTemplateItem(); int cnt = 0; var helper = GetHelper(Base); List <INMatrixGenerationRule> idGenerationRules, descrGenerationRules; GetGenerationRules(helper, out idGenerationRules, out descrGenerationRules); foreach (EntryMatrix row in this.Matrix.Cache.Cached.Cast <EntryMatrix>().Where(row => row.IsPreliminary != true)) { for (int i = 0; i < row.InventoryIDs.Length; i++) { MatrixInventoryItem newItem = helper.CreateMatrixItemFromTemplate(row, i, templateItem, idGenerationRules, descrGenerationRules); if (newItem != null) { bool firstItem = (cnt == 0); if (firstItem) { for (int j = 0; j < newItem.AttributeIDs.Length; j++) { AddItemAttributeColumn(j); } } newItem.InventoryID = ++cnt; MatrixItemsForCreation.Cache.Hold(newItem); if (firstItem) { MatrixItemsForCreation.Current = newItem; } } } } }
protected virtual string GetGenerationRuleSample(IEnumerable <INMatrixGenerationRule> rules) { try { var helper = GetCreateMatrixItemsHelper(); var tempItem = new MatrixInventoryItem(); tempItem.TemplateItemID = Item.Current.TemplateItemID; tempItem.AttributeIDs = Answers.SelectMain().Select(a => a.AttributeID).ToArray(); tempItem.AttributeValues = new string[tempItem.AttributeIDs.Length]; tempItem.AttributeValueDescrs = new string[tempItem.AttributeIDs.Length]; for (int attributeIndex = 0; attributeIndex < tempItem.AttributeIDs.Length; attributeIndex++) { var attributeID = tempItem.AttributeIDs[attributeIndex]; var values = CRAttribute.Attributes[attributeID].Values; var value = values.Where(v => !v.Disabled).FirstOrDefault(); tempItem.AttributeValues[attributeIndex] = value?.ValueID; tempItem.AttributeValueDescrs[attributeIndex] = value?.Description; } return(helper.GenerateMatrixItemID(Item.Current, rules.ToList(), tempItem, true)); } catch (Exception exception) { return(exception.Message); } }
protected virtual void OnNewItemSelected(int?templateItemID, MatrixInventoryItem row) { InventoryItem templateItem = InventoryItem.PK.Find(Base, templateItemID); if (templateItem == null) { throw new RowNotFoundException(Base.Caches <InventoryItem>(), templateItemID); } var createHelper = GetCreateMatrixItemsHelper(Base); createHelper.GetGenerationRules(templateItemID, out List <INMatrixGenerationRule> idGenerationRules, out List <INMatrixGenerationRule> descrGenerationRules); object newCD = createHelper.GenerateMatrixItemID(templateItem, idGenerationRules, row); MatrixItems.Cache.RaiseFieldUpdating <MatrixInventoryItem.inventoryCD>(row, ref newCD); row.InventoryCD = (string)newCD; row.InventoryID = null; row.Descr = createHelper.GenerateMatrixItemID(templateItem, descrGenerationRules, row); row.New = true; row.BasePrice = templateItem.BasePrice; row.TaxCategoryID = templateItem.TaxCategoryID; row.Exists = (InventoryItem.UK.Find(Base, row.InventoryCD) != null); row.Qty = 0m; MatrixItems.Cache.Normalize(); }
public virtual string GenerateMatrixItemID( InventoryItem template, List<INMatrixGenerationRule> genRules, MatrixInventoryItem newItem, bool useLastAutoNumberValue = false) { StringBuilder res = new StringBuilder(); for (int i = 0; i < genRules.Count; i++) { bool isLastSegment = (i == genRules.Count - 1); AppendMatrixItemIDSegment(res, template, genRules[i], isLastSegment, newItem, useLastAutoNumberValue); } return res.ToString(); }
protected IEnumerable copyMatItem(PXAdapter adapter) { MatrixInventoryItem current1 = (MatrixInventoryItem)this.Base1.MatrixItems.Current; AdditionalAttributes current2 = this.Base3.AdditionalAttributes.Current; bool?selected = current1.Selected; bool flag = true; if (selected.GetValueOrDefault() == flag & selected.HasValue) { for (int index1 = 0; index1 < current2.AttributeIdentifiers.Length; ++index1) { int index2 = Array.IndexOf <string>(current1.AttributeIDs, current2.AttributeIdentifiers[index1]); current2.Values[index1] = current1.AttributeValues[index2]; } } this.Base3.AdditionalAttributes.Insert(current2); return(adapter.Get()); }
protected virtual void OnExisingItemSelected(MatrixInventoryItem row, int?inventoryID) { var inventoryItem = InventoryItem.PK.Find(Base, inventoryID); if (inventoryItem == null) { throw new RowNotFoundException(Base.Caches <InventoryItem>(), inventoryID); } row.InventoryCD = inventoryItem.InventoryCD; row.InventoryID = inventoryItem.InventoryID; row.Descr = inventoryItem.Descr; row.New = false; row.BasePrice = inventoryItem.BasePrice; row.TaxCategoryID = inventoryItem.TaxCategoryID; row.Exists = false; row.Qty = IsItemStatusDisabled(inventoryItem) ? (decimal?)null : 0m; MatrixItems.Cache.Normalize(); }
protected virtual int?FindInventoryItem(MatrixInventoryItem row) { int?lastInventoryId = null; string[] attributeValues = new string[row.AttributeIDs.Length]; foreach (PXResult <CSAnswers, CSAttributeGroup, InventoryItem> result in SelectInventoryWithAttributes()) { InventoryItem inventoryItem = result; CSAnswers attribute = result; if (lastInventoryId != inventoryItem.InventoryID) { lastInventoryId = inventoryItem.InventoryID; for (int attributeIndex = 0; attributeIndex < attributeValues.Length; attributeIndex++) { attributeValues[attributeIndex] = null; } } for (int attributeIndex = 0; attributeIndex < attributeValues.Length; attributeIndex++) { if (string.Equals(row.AttributeIDs[attributeIndex], attribute.AttributeID, StringComparison.OrdinalIgnoreCase) && row.AttributeValues[attributeIndex] == attribute.Value) { attributeValues[attributeIndex] = attribute.Value; break; } } if (lastInventoryId != null && attributeValues.All(v => v != null)) { return(lastInventoryId); } } return(null); }
protected virtual void AssignInventoryAttributes(InventoryItemMaintBase graph, MatrixInventoryItem itemToCreateUpdate, Dictionary<string, string> templateAttrValues) { CSAnswers[] answers = graph.Answers.Select().RowCast<CSAnswers>().ToArray(); foreach (CSAnswers answer in answers) { string value = null; for (int i = 0; i < itemToCreateUpdate.AttributeIDs.Length; i++) { if (itemToCreateUpdate.AttributeIDs[i].Equals(answer.AttributeID, StringComparison.OrdinalIgnoreCase)) { value = itemToCreateUpdate.AttributeValues[i]; break; } } if (value == null) { templateAttrValues.TryGetValue(answer.AttributeID, out value); } answer.Value = value; graph.Answers.Update(answer); } }
protected virtual bool AllAttributesArePopulated(MatrixInventoryItem row) => row?.AttributeValues?.Any(v => string.IsNullOrEmpty(v)) == false;
public IEnumerable insertFromExcel(PXAdapter adapter) { if (this.MatrixItems4Creation.AskExt() == WebDialogResult.OK) { int num1 = 1; FileInfo fileInfo = PXContext.SessionTyped <PXSessionStatePXData>().FileInfo["ImportMatrixFile"]; //HttpContext.Current.Session.Remove("ImportMatrixFile"); using (XLSXReader xlsxReader = new XLSXReader(fileInfo.BinData)) { xlsxReader.Reset(); xlsxReader.IndexKeyPairs.ToDictionary <KeyValuePair <int, string>, int, string>((Func <KeyValuePair <int, string>, int>)(p => p.Key), (Func <KeyValuePair <int, string>, string>)(p => p.Value)); xlsxReader.MoveNext(); while (xlsxReader.MoveNext()) { try { InventoryItem template = InventoryItem.PK.Find((PXGraph)this.Base, this.Base1.Header.Current.TemplateItemID); CreateMatrixItemsHelper matrixItemsHelper = new CreateMatrixItemsHelper((PXGraph)this.Base); System.Collections.Generic.List <INMatrixGenerationRule> idGenerationRules; System.Collections.Generic.List <INMatrixGenerationRule> descrGenerationRules; matrixItemsHelper.GetGenerationRules(this.Base1.Header.Current.TemplateItemID, out idGenerationRules, out descrGenerationRules); foreach (EntryMatrix row in this.Base1.Matrix.Cache.Cached.Cast <EntryMatrix>().Where <EntryMatrix>((Func <EntryMatrix, bool>)(entry => { bool?isPreliminary = entry.IsPreliminary; bool flag = true; return(!(isPreliminary.GetValueOrDefault() == flag & isPreliminary.HasValue)); }))) { for (int attributeNumber = 0; attributeNumber < row.InventoryIDs.Length; ++attributeNumber) { MatrixInventoryItem newItem = matrixItemsHelper.CreateMatrixItemFromTemplate(row, attributeNumber, template, idGenerationRules, descrGenerationRules); if (newItem != null) { newItem.InventoryCD = xlsxReader.GetValue(2); newItem.Descr = xlsxReader.GetValue(3); newItem.InventoryID = new int?(++num1); newItem.Duplicate = new bool?(this.Base.Caches[typeof(MatrixInventoryItem)].Cached.RowCast <MatrixInventoryItem>().Any <MatrixInventoryItem>((Func <MatrixInventoryItem, bool>)(mi => mi.InventoryCD == newItem.InventoryCD))); MatrixInventoryItem matrixInventoryItem = newItem; bool?exists = newItem.Exists; bool flag1 = true; int num2; if (!(exists.GetValueOrDefault() == flag1 & exists.HasValue)) { bool?duplicate = newItem.Duplicate; bool flag2 = true; num2 = !(duplicate.GetValueOrDefault() == flag2 & duplicate.HasValue) ? 1 : 0; } else { num2 = 0; } bool?nullable = new bool?(num2 != 0); matrixInventoryItem.Selected = nullable; System.Collections.Generic.List <string> stringList = new System.Collections.Generic.List <string>(); for (int index = 15; index <= xlsxReader.IndexKeyPairs.Count; ++index) { stringList.Add(xlsxReader.GetValue(index)); } newItem.AttributeValues = stringList.ToArray(); this.Base1.MatrixItemsForCreation.Cache.Hold((object)newItem); } } } } catch (Exception ex) { throw ex; } finally { xlsxReader.Dispose(); } } } } return(adapter.Get()); }
protected virtual void AppendMatrixItemIDSegment( StringBuilder res, InventoryItem template, INMatrixGenerationRule genRule, bool isLastSegment, MatrixInventoryItem newItem, bool useLastAutoNumberValue) { string segValue = string.Empty; switch (genRule.SegmentType) { case INMatrixGenerationRule.segmentType.TemplateID: segValue = template.InventoryCD; break; case INMatrixGenerationRule.segmentType.TemplateDescription: segValue = template.Descr; break; case INMatrixGenerationRule.segmentType.AttributeCaption: for (int i = 0; i < newItem.AttributeIDs.Length; i++) { if (newItem.AttributeIDs[i].Equals(genRule.AttributeID, StringComparison.OrdinalIgnoreCase)) { segValue = newItem.AttributeValueDescrs[i]; break; } } break; case INMatrixGenerationRule.segmentType.AttributeValue: for (int i = 0; i < newItem.AttributeIDs.Length; i++) { if (newItem.AttributeIDs[i].Equals(genRule.AttributeID, StringComparison.OrdinalIgnoreCase)) { segValue = newItem.AttributeValues[i]; break; } } break; case INMatrixGenerationRule.segmentType.Constant: segValue = genRule.Constant; break; case INMatrixGenerationRule.segmentType.Space: segValue = " "; break; case INMatrixGenerationRule.segmentType.AutoNumber when !useLastAutoNumberValue: segValue = AutoNumberAttribute.GetNextNumber(_graph.Caches[typeof(InventoryItem)], null, genRule.NumberingID, _graph.Accessinfo.BusinessDate); break; case INMatrixGenerationRule.segmentType.AutoNumber when useLastAutoNumberValue: var numberingSequence = AutoNumberAttribute.GetNumberingSequence(genRule.NumberingID, _graph.Accessinfo.BranchID, _graph.Accessinfo.BusinessDate); segValue = numberingSequence?.LastNbr; if (string.IsNullOrEmpty(segValue)) segValue = AutoNumberAttribute.GetNextNumber(_graph.Caches[typeof(InventoryItem)], null, genRule.NumberingID, _graph.Accessinfo.BusinessDate); break; default: throw new PXArgumentException(nameof(INMatrixGenerationRule)); } segValue = segValue ?? string.Empty; if (segValue.Length > genRule.NumberOfCharacters) { segValue = segValue.Substring(0, (int)genRule.NumberOfCharacters); } else if (segValue.Length < genRule.NumberOfCharacters) { segValue = segValue.PadRight((int)genRule.NumberOfCharacters); } res.Append(segValue); if (!isLastSegment) { if (genRule.UseSpaceAsSeparator == true) { res.Append(' '); } else { res.Append(genRule.Separator); } } }