private CswNbtObjClassUnitOfMeasure getUnit(String UnitName, String NodeTypeName)
{
CswNbtObjClassUnitOfMeasure Unit = null;
CswNbtMetaDataNodeType UnitNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType(NodeTypeName);
if (null != UnitNT)
{
foreach (CswNbtObjClassUnitOfMeasure UnitNode in UnitNT.getNodes(false, false))
{
if (UnitName == UnitNode.Name.Text)
{
Unit = UnitNode;
break;
}
}
}
return(Unit);
}
public override void update()
{
List<CswPrimaryKey> MaterialPKs = new List<CswPrimaryKey>();
//Rename all existing material demo data
CswNbtMetaDataPropertySet MaterialPS = _CswNbtSchemaModTrnsctn.MetaData.getPropertySet( CswEnumNbtPropertySetName.MaterialSet );
foreach( CswNbtMetaDataObjectClass MatOC in MaterialPS.getObjectClasses() )
{
foreach( CswNbtPropertySetMaterial DemoMaterial in MatOC.getNodes( false, false, false ) )
{
if( DemoMaterial.IsDemo )
{
MaterialPKs.Add( DemoMaterial.NodeId );
DemoMaterial.TradeName.Text = DemoMaterial.TradeName.Text.Replace( "Default", "(demo)" );
DemoMaterial.ApprovedForReceiving.Checked = CswEnumTristate.True;
DemoMaterial.postChanges( false );
}
}
}
//Fix existing demo material sizes
CswNbtMetaDataObjectClass SizeOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.SizeClass );
foreach( CswNbtObjClassSize DemoSize in SizeOC.getNodes( false, false ) )
{
if( DemoSize.IsDemo && MaterialPKs.Contains( DemoSize.Material.RelatedNodeId ) )
{
DemoSize.InitialQuantity.Quantity = 10;
CswNbtPropertySetMaterial DemoMaterial = _CswNbtSchemaModTrnsctn.Nodes[DemoSize.Material.RelatedNodeId];
if( DemoMaterial.ObjectClass.ObjectClass == CswEnumNbtObjectClass.NonChemicalClass )
{
CswNbtObjClassUnitOfMeasure CasesUnit = _getUnit( "Unit (Each)", "Cases" );
if( null != CasesUnit )
{
DemoSize.InitialQuantity.UnitId = CasesUnit.NodeId;
DemoSize.InitialQuantity.View.Root.ChildRelationships.Clear();
DemoSize.InitialQuantity.View.AddViewRelationship( CasesUnit.NodeType, true );
DemoSize.InitialQuantity.View.save();
}
}
DemoSize.postChanges( false );
}
}
} // update()
public CswNbtUnitConversion(CswNbtResources _CswNbtResourcesIn, CswPrimaryKey OldUnitNodeId, CswPrimaryKey NewUnitNodeId, CswPrimaryKey MaterialNodeId = null)
{
_CswNbtResources = _CswNbtResourcesIn;
if (OldUnitNodeId != null && NewUnitNodeId != null)
{
CswNbtObjClassUnitOfMeasure OldUnitNode = _CswNbtResources.Nodes.GetNode(OldUnitNodeId);
CswNbtObjClassUnitOfMeasure NewUnitNode = _CswNbtResources.Nodes.GetNode(NewUnitNodeId);
setOldUnitProps(OldUnitNode);
setNewUnitProps(NewUnitNode);
if (MaterialNodeId != null)
{
CswNbtNode MaterialNode = _CswNbtResources.Nodes.GetNode(MaterialNodeId);
if (MaterialNode.ObjClass.ObjectClass.ObjectClass == CswEnumNbtObjectClass.ChemicalClass)
{
setMaterialProps(MaterialNode);
}
}
}
}
public static JObject getMaterialUnitsOfMeasure(string PhysicalStateValue, CswNbtResources CswNbtResources)
{
JObject ret = new JObject();
string PhysicalState = "n/a";
foreach (string CurrentPhysicalState in CswNbtPropertySetMaterial.CswEnumPhysicalState.Options)
{
if (PhysicalStateValue.Equals(CurrentPhysicalState))
{
PhysicalState = CurrentPhysicalState;
}
}
if (false == string.IsNullOrEmpty(PhysicalState))
{
CswNbtUnitViewBuilder unitViewBuilder = new CswNbtUnitViewBuilder(CswNbtResources);
CswNbtView unitsView = unitViewBuilder.getQuantityUnitOfMeasureView(PhysicalState);
Collection <CswNbtNode> _UnitNodes = new Collection <CswNbtNode>();
ICswNbtTree UnitsTree = CswNbtResources.Trees.getTreeFromView(CswNbtResources.CurrentNbtUser, unitsView,
RequireViewPermissions: true,
IncludeSystemNodes: false,
IncludeHiddenNodes: false);
UnitsTree.goToRoot();
for (int i = 0; i < UnitsTree.getChildNodeCount(); i++)
{
UnitsTree.goToNthChild(i);
_UnitNodes.Add(UnitsTree.getNodeForCurrentPosition());
UnitsTree.goToParentNode();
}
foreach (CswNbtNode unitNode in _UnitNodes)
{
CswNbtObjClassUnitOfMeasure nodeAsUnitOfMeasure = (CswNbtObjClassUnitOfMeasure)unitNode;
ret[nodeAsUnitOfMeasure.NodeId.ToString()] = nodeAsUnitOfMeasure.Name.Gestalt;
}
}
return(ret);
}
internal CswNbtNode createUnitOfMeasureNode(string NodeTypeName, string Name, double ConversionFactorBase, int ConversionFactorExponent, CswEnumTristate Fractional)
{
CswNbtNode ret = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(_getNodeTypeId("Unit_" + NodeTypeName), delegate(CswNbtNode NewNode)
{
CswNbtObjClassUnitOfMeasure UnitOfMeasureNode = NewNode;
UnitOfMeasureNode.Name.Text = Name + "Test";
if (CswTools.IsDouble(ConversionFactorBase))
{
UnitOfMeasureNode.ConversionFactor.Base = ConversionFactorBase;
}
if (ConversionFactorExponent != Int32.MinValue)
{
UnitOfMeasureNode.ConversionFactor.Exponent = ConversionFactorExponent;
}
UnitOfMeasureNode.Fractional.Checked = Fractional;
UnitOfMeasureNode.UnitType.Value = NodeTypeName;
});
_finalize();
return(ret);
}
public JObject getQuantityFromSize(CswPrimaryKey SizeId, string Action)
{
JObject Ret = new JObject();
CswNbtObjClassSize Size = _CswNbtResources.Nodes.GetNode(SizeId);
if (null != Size)
{
CswNbtNodePropQuantity InitialQuantity = Size.InitialQuantity;
InitialQuantity.ToJSON(Ret);
Ret["unitName"] = Ret["name"];
Ret["qtyReadonly"] = false;
Ret["isUnitReadOnly"] = false;
Ret["unitCount"] = "1";
Ret["isRequired"] = InitialQuantity.Required.ToString();
if (Action.ToLower() == ChemSW.Nbt.ObjClasses.CswEnumNbtButtonAction.receive.ToString())
{
Ret["isUnitReadOnly"] = true;
if (Size.QuantityEditable.Checked == CswEnumTristate.False)
{
Ret["qtyReadonly"] = true;
}
Ret["unitCount"] = CswTools.IsDouble(Size.UnitCount.Value) ? Size.UnitCount.Value.ToString() : "";
}
else if (Action.ToLower() == ChemSW.Nbt.ObjClasses.CswEnumNbtButtonAction.dispense.ToString())
{
CswNbtObjClassUnitOfMeasure UnitNode = _CswNbtResources.Nodes.GetNode(Size.InitialQuantity.UnitId);
if (null != UnitNode &&
(UnitNode.UnitType.Value == CswEnumNbtUnitTypes.Each.ToString() ||
false == CswTools.IsDouble(UnitNode.ConversionFactor.Base)))
{
Ret["isUnitReadOnly"] = true;
}
}
}
return(Ret);
}
/// <summary>
/// Takes the current Quantity value, converts it to the proper kg and Liters values, and stores it in Val_kg and Val_Liters
/// </summary>
public void SyncConvertedVals(CswPrimaryKey MaterialId = null)
{
if (null != UnitId)
{
CswNbtObjClassUnitOfMeasure CurrentUnit = _CswNbtResources.Nodes[UnitId];
if (CurrentUnit.UnitType.Value == CswEnumNbtUnitTypes.Weight.ToString() ||
CurrentUnit.UnitType.Value == CswEnumNbtUnitTypes.Volume.ToString())
{
CswNbtUnitViewBuilder UnitBuilder = new CswNbtUnitViewBuilder(_CswNbtResources);
CswNbtObjClassUnitOfMeasure kgUnit = UnitBuilder.getUnit("kg", "Unit_Weight");
CswNbtObjClassUnitOfMeasure LitersUnit = UnitBuilder.getUnit("Liters", "Unit_Volume");
if (null != kgUnit && (CurrentUnit.UnitType.Value == kgUnit.UnitType.Value || MaterialId != null))
{
CswNbtUnitConversion Conversion = new CswNbtUnitConversion(_CswNbtResources, UnitId, kgUnit.NodeId, MaterialId);
Val_kg = Conversion.convertUnit(Quantity);
}
if (null != LitersUnit && (CurrentUnit.UnitType.Value == LitersUnit.UnitType.Value || MaterialId != null))
{
CswNbtUnitConversion Conversion = new CswNbtUnitConversion(_CswNbtResources, UnitId, LitersUnit.NodeId, MaterialId);
Val_Liters = Conversion.convertUnit(Quantity);
}
}
}
}
public void testReceivingBarcodes()
{
CswNbtMetaDataNodeType ChemicalNT = TestData.CswNbtResources.MetaData.getNodeType("Chemical");
CswNbtObjClassChemical ChemicalNode = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(ChemicalNT.NodeTypeId);
CswNbtObjClassUnitOfMeasure GramNode = TestData.CswNbtResources.Nodes.GetNode(new CswPrimaryKey("nodes", 26745));
CswNbtMetaDataNodeType SizeNT = TestData.CswNbtResources.MetaData.getNodeType("Size");
CswNbtObjClassSize Size = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(SizeNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
CswNbtObjClassSize AsSize = NewNode;
AsSize.Material.RelatedNodeId = ChemicalNode.NodeId;
AsSize.UnitCount.Value = 5;
AsSize.InitialQuantity.Quantity = 10;
AsSize.InitialQuantity.UnitId = GramNode.NodeId;
}, OverrideUniqueValidation: true);
CswNbtActReceiving ReceivingAction = new CswNbtActReceiving(TestData.CswNbtResources, ChemicalNode.NodeId);
CswNbtMetaDataNodeType ContainerNT = TestData.CswNbtResources.MetaData.getNodeType("Container");
CswNbtObjClassContainer InitialContainer = ReceivingAction.makeContainer(null);
JObject ContainerAddProps = ReceivingAction.getContainerAddProps(InitialContainer);
CswCommaDelimitedString Barcodes = new CswCommaDelimitedString();
Barcodes.Add("testbarcode1");
Barcodes.Add("testbarcode2");
int NumContainers = 2;
CswNbtAmountsGridQuantity Quantity = new CswNbtAmountsGridQuantity()
{
NumContainers = NumContainers,
Quantity = 10,
SizeName = Size.NodeName,
SizeNodeId = Size.NodeId,
UnitNodeId = GramNode.NodeId,
ContainerIds = new Collection <string>()
{
InitialContainer.NodeId.ToString()
},
};
foreach (string Barcode in Barcodes)
{
Quantity.AddBarcode(Barcode);
}
CswNbtReceivingDefinition ReceiptDef = new CswNbtReceivingDefinition()
{
ContainerNodeId = InitialContainer.NodeId,
ContainerNodeTypeId = ContainerNT.NodeTypeId,
ContainerProps = ContainerAddProps,
MaterialNodeId = ChemicalNode.NodeId,
Quantities = new Collection <CswNbtAmountsGridQuantity>()
{
Quantity
}
};
CswNbtMetaDataNodeTypeProp BarcodeNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Barcode);
string Before = BarcodeNTP.Sequence.getCurrent();
ReceivingAction.receiveMaterial(ReceiptDef);
string After = BarcodeNTP.Sequence.getCurrent();
Assert.AreEqual(Before, After, "Creating containers in Receiving with custom barcodes consumed barcode sequence values when it shouldn't have");
}
public override void update()
{
CswNbtMetaDataObjectClass InventoryGroupOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.InventoryGroupClass );
CswNbtObjClassInventoryGroup DefaultNodeAsInventoryGroup = null;
foreach( CswNbtNode Group in InventoryGroupOc.getNodes( true, false ) )
{
CswNbtObjClassInventoryGroup NodeAsInventoryGroup = Group;
if( null != NodeAsInventoryGroup )
{
if( NodeAsInventoryGroup.Name.Text.ToLower() == "cispro" )
{
DefaultNodeAsInventoryGroup = NodeAsInventoryGroup;
DefaultNodeAsInventoryGroup.Name.Text = "Default Inventory Group";
DefaultNodeAsInventoryGroup.IsDemo = true;
DefaultNodeAsInventoryGroup.postChanges( ForceUpdate: false );
}
}
}
if( null == DefaultNodeAsInventoryGroup )
{
CswNbtMetaDataNodeType InventoryGroupNt = InventoryGroupOc.getLatestVersionNodeTypes().FirstOrDefault();
if( null != InventoryGroupNt )
{
DefaultNodeAsInventoryGroup = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( InventoryGroupNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
DefaultNodeAsInventoryGroup.Name.Text = "Default Inventory Group";
DefaultNodeAsInventoryGroup.postChanges( ForceUpdate: false );
}
}
CswNbtMetaDataObjectClass LocationOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.LocationClass );
CswNbtObjClassLocation DefaultLocation = null;
if( null != DefaultNodeAsInventoryGroup )
{
foreach( CswNbtObjClassLocation Location in LocationOc.getNodes( true, false ) )
{
if( null != Location )
{
if( Location.Name.Text.ToLower() == "center hall" )
{
DefaultLocation = Location;
}
if( null == Location.InventoryGroup.RelatedNodeId || Int32.MinValue == Location.InventoryGroup.RelatedNodeId.PrimaryKey )
{
Location.InventoryGroup.RelatedNodeId = DefaultNodeAsInventoryGroup.NodeId;
Location.postChanges( ForceUpdate: false );
}
}
}
}
CswNbtMetaDataObjectClass WorkUnitOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.WorkUnitClass );
CswNbtMetaDataNodeType WorkUnitNt = WorkUnitOc.getLatestVersionNodeTypes().FirstOrDefault();
if( null != WorkUnitNt )
{
WorkUnitNt.NameTemplateValue = "";
WorkUnitNt.addNameTemplateText( CswNbtObjClassWorkUnit.NamePropertyName );
CswNbtObjClassWorkUnit DefaultWorkUnit = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( WorkUnitNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
DefaultWorkUnit.Name.Text = "Default Work Unit";
DefaultWorkUnit.IsDemo = true;
DefaultWorkUnit.postChanges( ForceUpdate: false );
CswNbtMetaDataObjectClass UserOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.UserClass );
Collection<Int32> RoleIdsWithUsers = new Collection<Int32>();
CswNbtMetaDataNodeType UserNt = null;
foreach( CswNbtObjClassUser User in UserOc.getNodes( true, false ) )
{
if( null != User )
{
UserNt = UserNt ?? User.NodeType;
RoleIdsWithUsers.Add( User.RoleId.PrimaryKey );
if( null == User.WorkUnitProperty.RelatedNodeId || Int32.MinValue == User.WorkUnitProperty.RelatedNodeId.PrimaryKey )
{
User.WorkUnitProperty.RelatedNodeId = DefaultWorkUnit.NodeId;
}
if( null != DefaultLocation && ( null == User.DefaultLocationProperty.SelectedNodeId || Int32.MinValue == User.DefaultLocationProperty.SelectedNodeId.PrimaryKey ) )
{
User.DefaultLocationProperty.SelectedNodeId = DefaultLocation.NodeId;
}
User.postChanges( ForceUpdate: false );
}
}
CswNbtMetaDataObjectClass RoleOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.RoleClass );
if( null == UserNt )
{
UserNt = UserOc.getLatestVersionNodeTypes().FirstOrDefault();
}
if( null != UserNt )
{
foreach( CswNbtObjClassRole Role in RoleOc.getNodes( true, false ) )
{
if( null != Role && false == RoleIdsWithUsers.Contains( Role.NodeId.PrimaryKey ) )
{
string ValidUserName = CswNbtObjClassUser.getValidUserName( Role.Name.Text.ToLower() );
if( ValidUserName != CswNbtObjClassUser.ChemSWAdminUsername )
{
if( CswNbtObjClassUser.IsUserNameUnique( _CswNbtSchemaModTrnsctn.MetaData._CswNbtMetaDataResources.CswNbtResources, ValidUserName ) )
{
CswNbtObjClassUser NewUser = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( UserNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
NewUser.IsDemo = false;
NewUser.Role.RelatedNodeId = Role.NodeId;
NewUser.UsernameProperty.Text = ValidUserName;
NewUser.WorkUnitProperty.RelatedNodeId = DefaultWorkUnit.NodeId;
if( null != DefaultLocation )
{
NewUser.DefaultLocationProperty.SelectedNodeId = DefaultLocation.NodeId;
}
NewUser.PasswordProperty.Password = Role.Name.Text.ToLower();
NewUser.postChanges( ForceUpdate: false );
}
}
}
}
}
CswNbtMetaDataObjectClass IgPermissionOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.InventoryGroupPermissionClass );
foreach( CswNbtObjClassInventoryGroupPermission Permission in IgPermissionOc.getNodes( true, false ) )
{
if( null != Permission )
{
if( null != DefaultNodeAsInventoryGroup && ( null == Permission.InventoryGroup.RelatedNodeId || Int32.MinValue == Permission.InventoryGroup.RelatedNodeId.PrimaryKey ) )
{
Permission.InventoryGroup.RelatedNodeId = DefaultNodeAsInventoryGroup.NodeId;
}
if( null == Permission.WorkUnit.RelatedNodeId || Int32.MinValue == Permission.WorkUnit.RelatedNodeId.PrimaryKey )
{
Permission.WorkUnit.RelatedNodeId = DefaultWorkUnit.NodeId;
}
Permission.postChanges( ForceUpdate: false );
}
}
}
CswNbtMetaDataObjectClass MaterialOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.MaterialClass );
CswNbtMetaDataObjectClass SynonymOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.MaterialSynonymClass );
CswNbtMetaDataObjectClass SizeOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.SizeClass );
CswNbtMetaDataObjectClass VendorOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.VendorClass );
CswNbtMetaDataObjectClass UnitOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.UnitOfMeasureClass );
CswNbtObjClassVendor DefaultVendor = null;
CswNbtMetaDataNodeType VendorNt = VendorOc.getLatestVersionNodeTypes().FirstOrDefault();
if( null != VendorNt )
{
DefaultVendor = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( VendorNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
DefaultVendor.VendorName.Text = "Default Vendor";
DefaultVendor.IsDemo = true;
DefaultVendor.postChanges( ForceUpdate: false );
}
CswNbtMetaDataNodeType SizeNt = SizeOc.getLatestVersionNodeTypes().FirstOrDefault();
CswNbtMetaDataNodeType SynonymNt = SynonymOc.getLatestVersionNodeTypes().FirstOrDefault();
CswNbtObjClassUnitOfMeasure DefaultSizeUnit = null;
CswNbtObjClassUnitOfMeasure DefaultTimeUnit = null;
foreach( CswNbtObjClassUnitOfMeasure Unit in UnitOc.getNodes( true, false ) )
{
if( null != Unit )
{
if( Unit.Name.Text.ToLower() == "g" )
{
DefaultSizeUnit = Unit;
}
else if( Unit.Name.Text.ToLower() == "years" )
{
DefaultTimeUnit = Unit;
}
}
}
foreach( CswNbtMetaDataNodeType MaterialNt in MaterialOc.getLatestVersionNodeTypes() )
{
CswNbtObjClassMaterial Material = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( MaterialNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
Material.IsDemo = true;
Material.TradeName.Text = "Default " + MaterialNt.NodeTypeName;
if( null != DefaultVendor )
{
Material.Supplier.RelatedNodeId = DefaultVendor.NodeId;
}
Material.PartNumber.Text = "658-35AB";
Material.PhysicalState.Value = CswNbtObjClassMaterial.PhysicalStates.Solid;
Material.ExpirationInterval.Quantity = 1;
if( null != DefaultTimeUnit )
{
Material.ExpirationInterval.UnitId = DefaultTimeUnit.NodeId;
}
Material.postChanges( ForceUpdate: false );
if( null != SizeNt )
{
CswNbtObjClassSize Size = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( SizeNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
Size.IsDemo = true;
Size.Material.RelatedNodeId = Material.NodeId;
Size.CatalogNo.Text = "NE-H5/3";
Size.InitialQuantity.Quantity = 1;
if( null != DefaultSizeUnit )
{
Size.InitialQuantity.UnitId = DefaultSizeUnit.NodeId;
}
Size.postChanges( ForceUpdate: false );
}
if( null != SynonymNt )
{
CswNbtObjClassMaterialSynonym Synonym = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( SynonymNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
Synonym.IsDemo = true;
Synonym.Material.RelatedNodeId = Material.NodeId;
Synonym.Name.Text = Material.TradeName.Text + " Synonym";
Synonym.postChanges( ForceUpdate: false );
}
}
}//Update()
public TierIIData getTierIIData_old(TierIIData.TierIIDataRequest Request)
{
BaseUnit = _setBaseUnit("kg", "Unit_Weight");
CswNbtObjClassUnitOfMeasure PoundsUnit = _setBaseUnit("lb", "Unit_Weight");
CswNbtUnitConversion Conversion = (BaseUnit != null && PoundsUnit != null) ?
new CswNbtUnitConversion(_CswNbtResources, BaseUnit.NodeId, PoundsUnit.NodeId) :
new CswNbtUnitConversion();
LocationIds = _setLocationIds(Request.LocationId);
DataTable MaterialsTable = _getTierIIMaterials(Request);
foreach (DataRow MaterialRow in MaterialsTable.Rows)
{
CswPrimaryKey BaseUnitId = CswConvert.ToPrimaryKey("nodes_" + MaterialRow["unitid"]);
if (null != BaseUnit && BaseUnit.NodeId != BaseUnitId)
{
//Theoretically, this should never happen
//(unless we decide, one day, to change the unit in which we're storing TierII quantity data)
BaseUnit = _CswNbtResources.Nodes.GetNode(BaseUnitId);
Conversion.setOldUnitProps(BaseUnit);
}
Double MaxQty = Math.Round(Conversion.convertUnit(CswConvert.ToDouble(MaterialRow["maxqty"])), 3);
Double AverageQty = Math.Round(Conversion.convertUnit(CswConvert.ToDouble(MaterialRow["avgqty"])), 3);
TierIIData.TierIIMaterial Material = new TierIIData.TierIIMaterial
{
MaterialId = MaterialRow["materialid"].ToString(),
TradeName = MaterialRow["tradename"].ToString(),
CASNo = MaterialRow["casno"].ToString(),
MaterialType = MaterialRow["materialtype"].ToString(),
PhysicalState = MaterialRow["physicalstate"].ToString(),
EHS = MaterialRow["specialflags"].ToString().Contains("EHS"),
TradeSecret = MaterialRow["specialflags"].ToString().Contains("Trade Secret"),
MaxQty = MaxQty,
MaxQtyRangeCode = _getRangeCode(MaxQty),
AverageQty = AverageQty,
AverageQtyRangeCode = _getRangeCode(AverageQty),
DaysOnSite = CswConvert.ToInt32(MaterialRow["daysonsite"]),
Unit = PoundsUnit != null ? PoundsUnit.Name.Text : "lb"
};
CswCommaDelimitedString Hazards = new CswCommaDelimitedString();
Hazards.FromString(MaterialRow["hazardcategories"].ToString());
foreach (String Hazard in Hazards)
{
Material.HazardCategories.Add(Hazard);
}
DataTable ContainerStorageCodesTable = _getContainerStorageProps(Material.MaterialId, Request);
foreach (DataRow ContainerPropsRow in ContainerStorageCodesTable.Rows)
{
TierIIData.StorageCodes StorageCodes = new TierIIData.StorageCodes
{
Pressure = ContainerPropsRow["pressure"].ToString(),
Temperature = ContainerPropsRow["temperature"].ToString(),
UseType = ContainerPropsRow["usetype"].ToString()
};
Material.Storage.Add(StorageCodes);
}
DataTable ContainerLocationsTable = _getContainerLocations(Material.MaterialId, Request);
foreach (DataRow ContainerLocsRow in ContainerLocationsTable.Rows)
{
TierIIData.StorageLocations Location = new TierIIData.StorageLocations
{
LocationId = ContainerLocsRow["locationid"].ToString(),
Location = ContainerLocsRow["fulllocation"].ToString()
};
Material.Locations.Add(Location);
}
Data.Materials.Add(Material);
}
return(Data);
}
public static void UpdateBalanceData( ICswResources CswResources, SerialBalance Return, SerialBalance Request )
{
CswNbtResources NbtResources = (CswNbtResources) CswResources;
CswNbtMetaDataObjectClass BalanceOC = NbtResources.MetaData.getObjectClass( CswEnumNbtObjectClass.BalanceClass );
if( null != BalanceOC )
{
CswNbtMetaDataObjectClassProp BalanceNameOCP = BalanceOC.getObjectClassProp( CswNbtObjClassBalance.PropertyName.Name );
CswNbtObjClassBalance Balance;
Action<CswNbtNode> UpdateBalance = delegate( CswNbtNode NewNode )
{
CswNbtObjClassBalance thisBalance = NewNode;
thisBalance.Name.Text = Request.NbtName;
thisBalance.Quantity.Quantity = Request.CurrentWeight;
thisBalance.LastActive.DateTimeValue = DateTime.Now;
thisBalance.Device.Text = Request.DeviceDescription;
thisBalance.Manufacturer.Text = Request.Manufacturer;
thisBalance.Operational.Checked = CswConvert.ToTristate( Request.Operational );
thisBalance.BalanceConfiguration.RelatedNodeId = _findConfigurationWithName( NbtResources, Request.Configuration ).NodeId;
CswNbtObjClassUnitOfMeasure Unit = _mapUnitToNode( NbtResources, Request.UnitOfMeasurement );
if( null != Unit )
{
thisBalance.Quantity.UnitId = Unit.NodeId;
}
};
if( string.IsNullOrEmpty(Request.NodeId) )
{
CswNbtView ExistingBalancesView = new CswNbtView( NbtResources );
ExistingBalancesView.ViewName = "Existing Balances";
CswNbtViewRelationship BalanceRel = ExistingBalancesView.AddViewRelationship( BalanceOC, false );
ExistingBalancesView.AddViewPropertyAndFilter( BalanceRel, BalanceNameOCP,
Value: Request.NbtName,
FilterMode: CswEnumNbtFilterMode.Equals );
ICswNbtTree ExistingBalancesTree = NbtResources.Trees.getTreeFromView( ExistingBalancesView, false, true, true );
if( ExistingBalancesTree.getChildNodeCount() == 0 )
{
//there is no balance with this name yet. Make a new one.
CswNbtMetaDataNodeType BalanceNT = BalanceOC.FirstNodeType;
Balance = NbtResources.Nodes.makeNodeFromNodeTypeId( BalanceNT.NodeTypeId, UpdateBalance );
}
else
{
//this balance already exists, grab a reference to it.
ExistingBalancesTree.goToNthChild( 0 );
Balance = ExistingBalancesTree.getCurrentNode();
UpdateBalance( Balance.Node );
Balance.postChanges( false );
}
}//if null == request.nodeid
else
{
Balance = NbtResources.Nodes[new CswPrimaryKey( "nodes", Convert.ToInt32( Request.NodeId ) )];
UpdateBalance( Balance.Node );
Balance.postChanges( false );
}
//return the requested balance back, plus what nodeId it was assigned
Return = Request;
Return.NodeId = Balance.NodeId.PrimaryKey.ToString();
}//if ( null != BalanceOC )
}//UpdateBalanceData()
