/// <summary>
/// Get a landing page for a Material
/// </summary>
public static JObject getLandingPageData(CswNbtResources NbtResources, CswNbtNode MaterialNode, CswNbtView MaterialNodeView = null)
{
JObject Ret = new JObject();
if (null != MaterialNode)
{
MaterialNodeView = MaterialNodeView ?? CswNbtPropertySetMaterial.getMaterialNodeView(NbtResources, MaterialNode);
MaterialNodeView.SaveToCache(IncludeInQuickLaunch: false);
Ret["ActionId"] = NbtResources.Actions[CswEnumNbtActionName.Create_Material].ActionId.ToString();
//Used for Tab and Button items
Ret["NodeId"] = MaterialNode.NodeId.ToString();
Ret["NodeViewId"] = MaterialNodeView.SessionViewId.ToString();
//Used for node-specific Add items
Ret["RelatedNodeId"] = MaterialNode.NodeId.ToString();
Ret["RelatedNodeName"] = MaterialNode.NodeName;
//If (and when) action landing pages are slated to be roleId-specific, remove this line
Ret["isConfigurable"] = NbtResources.CurrentNbtUser.IsAdministrator();
//Used for viewing new material
Ret["ActionLinks"] = new JObject();
string ActionLinkName = MaterialNode.NodeId.ToString();
Ret["ActionLinks"][ActionLinkName] = new JObject();
Ret["ActionLinks"][ActionLinkName]["Text"] = MaterialNode.NodeName;
Ret["ActionLinks"][ActionLinkName]["ViewId"] = MaterialNodeView.SessionViewId.ToString();
}
return(Ret);
}
/// <summary>
/// Updates the default Expiration Date on containers to receive based on Receipt Lot's Manufactured Date
/// </summary>
public ContainerData.ReceivingData updateExpirationDate(ContainerData.ReceiptLotRequest Request)
{
ContainerData.ReceivingData ReceiveData = new ContainerData.ReceivingData();
JObject ReceiptLotPropsObj = CswConvert.ToJObject(Request.ReceiptLotProps);
if (ReceiptLotPropsObj.HasValues)
{
CswPrimaryKey ReceiptLotId = CswConvert.ToPrimaryKey(Request.ReceiptLotId);
if (CswTools.IsPrimaryKey(ReceiptLotId))
{
CswNbtObjClassReceiptLot ReceiptLot = _CswNbtResources.Nodes.GetNode(ReceiptLotId);
_CswNbtSdTabsAndProps.saveNodeProps(ReceiptLot.Node, ReceiptLotPropsObj);
CswPrimaryKey ContainerId = CswConvert.ToPrimaryKey(Request.ContainerId);
if (CswTools.IsPrimaryKey(ContainerId) &&
ReceiptLot.ManufacturedDate.DateTimeValue != DateTime.MinValue)
{
CswNbtObjClassContainer Container = _CswNbtResources.Nodes.GetNode(ContainerId);
CswNbtPropertySetMaterial Material = _CswNbtResources.Nodes.GetNode(Container.Material.RelatedNodeId);
Container.ExpirationDate.DateTimeValue = Material.getDefaultExpirationDate(ReceiptLot.ManufacturedDate.DateTimeValue);
Container.postChanges(false);
JObject ContainerProps = getContainerAddProps(Container);
ReceiveData.ContainerProps = ContainerProps.ToString();
}
}
}
return(ReceiveData);
}
public static JObject getImportBtnItems(CswNbtResources CswNbtResources)
{
JObject ImportableNodeTypes = new JObject();
Collection <CswEnumNbtObjectClass> MaterialPropSetMembers = CswNbtPropertySetMaterial.Members();
foreach (CswEnumNbtObjectClass ObjectClassName in MaterialPropSetMembers)
{
CswNbtMetaDataObjectClass ObjectClass = CswNbtResources.MetaData.getObjectClass(ObjectClassName);
foreach (CswNbtMetaDataNodeType CurrentNT in ObjectClass.getNodeTypes())
{
CswNbtMetaDataNodeTypeProp IsConstituentNTP = CurrentNT.getNodeTypePropByObjectClassProp(CswNbtPropertySetMaterial.PropertyName.IsConstituent);
if (IsConstituentNTP.HasDefaultValue() &&
CswEnumTristate.False == IsConstituentNTP.getDefaultValue(false).AsLogical.Checked)
{
JObject NodeType = new JObject();
ImportableNodeTypes[CurrentNT.NodeTypeName] = NodeType;
NodeType["nodetypename"] = CurrentNT.NodeTypeName;
NodeType["nodetypeid"] = CurrentNT.NodeTypeId.ToString();
NodeType["iconfilename"] = CswNbtMetaDataObjectClass.IconPrefix16 + CurrentNT.IconFileName;
NodeType["objclass"] = ObjectClassName.ToString();
}
}
}
return(ImportableNodeTypes);
}//getImportBtnItems()
}//_removeDuplicateSizes()
#endregion Private helper methods
public CswPrimaryKey createMaterialDocument(CswNbtPropertySetMaterial MaterialNode)
{
CswPrimaryKey NewSDSDocumentNodeId = null;
string MsdsUrl = _ProductToImport.MsdsUrl;
if (false == string.IsNullOrEmpty(MsdsUrl) && _CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.SDS))
{
CswNbtMetaDataObjectClass SDSDocClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.SDSDocumentClass);
CswNbtMetaDataNodeType SDSDocumentNT = SDSDocClass.FirstNodeType;
if (null != SDSDocumentNT)
{
CswNbtObjClassSDSDocument NewDoc = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(SDSDocumentNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
// This needs to be CswNbtObjClassSDSDocument NOT CswNbtObjClassDocument!
CswNbtObjClassSDSDocument NewSDSDocumentNode = NewNode;
NewSDSDocumentNode.Title.Text = "SDS: " + MaterialNode.TradeName.Text;
NewSDSDocumentNode.FileType.Value = CswNbtPropertySetDocument.CswEnumDocumentFileTypes.Link;
NewSDSDocumentNode.Link.Href = MsdsUrl;
NewSDSDocumentNode.Link.Text = MsdsUrl;
NewSDSDocumentNode.Owner.RelatedNodeId = MaterialNode.NodeId;
});
// Set the return object
NewSDSDocumentNodeId = NewDoc.NodeId;
}
}
return(NewSDSDocumentNodeId);
}
/// <summary>
/// Makes a temporary node of the Chemical nodetype. The reason we can't use createMaterial()
/// is because we don't have the any properties to provide to the method and tradename,
/// material type, and supplier are required.
/// </summary>
/// <param name="NodeId"></param>
/// <returns></returns>
public CswPrimaryKey makeTemp(string NodeId)
{
CswPrimaryKey Ret = new CswPrimaryKey();
CswPrimaryKey NodePk = CswConvert.ToPrimaryKey(NodeId);
if (false == CswTools.IsPrimaryKey(NodePk)) //node doesn't exist
{
CswNbtMetaDataObjectClass ChemicalOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ChemicalClass);
CswNbtMetaDataNodeType ChemicalNT = ChemicalOC.FirstNodeType;
if (null != ChemicalNT)
{
CswNbtPropertySetMaterial NewMaterialTempNode = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(ChemicalNT.NodeTypeId, IsTemp: true);
if (null != NewMaterialTempNode)
{
Ret = NewMaterialTempNode.Node.NodeId;
}
}
}
else //node exists
{
Ret = NodePk;
}
return(Ret);
}
/// <summary>
/// Get a landing page for a Material
/// </summary>
public static JObject getLandingPageData(CswNbtResources NbtResources, CswNbtNode MaterialNode, bool UseBatchOp, Collection <CswPrimaryKey> ContainerIds, CswNbtView MaterialNodeView = null)
{
JObject Ret = new JObject();
if (null != MaterialNode)
{
MaterialNodeView = MaterialNodeView ?? CswNbtPropertySetMaterial.getMaterialNodeView(NbtResources, MaterialNode, "Received: ");
MaterialNodeView.SaveToCache(IncludeInQuickLaunch: false);
Ret["ActionId"] = NbtResources.Actions[CswEnumNbtActionName.Receiving].ActionId.ToString();
//Used for Tab and Button items
Ret["NodeId"] = MaterialNode.NodeId.ToString();
Ret["NodeViewId"] = MaterialNodeView.SessionViewId.ToString();
//Used for node-specific Add items
Ret["RelatedNodeId"] = MaterialNode.NodeId.ToString();
Ret["RelatedNodeName"] = MaterialNode.NodeName;
//If (and when) action landing pages are slated to be roleId-specific, remove this line
Ret["isConfigurable"] = NbtResources.CurrentNbtUser.IsAdministrator();
//Used for viewing new material
Ret["ActionLinks"] = new JObject();
string ActionLinkName = MaterialNode.NodeId.ToString();
Ret["ActionLinks"][ActionLinkName] = new JObject();
Ret["ActionLinks"][ActionLinkName]["Text"] = MaterialNode.NodeName;
Ret["ActionLinks"][ActionLinkName]["ViewId"] = MaterialNodeView.SessionViewId.ToString();
if (UseBatchOp)
{
Ret["Title"] = "The containers for this material have been scheduled for creation, but may not be available immediately. Click 'View Batch Operations' to check their progress.";
Ret["ActionLinks"]["BatchOps"] = new JObject();
Ret["ActionLinks"]["BatchOps"]["ActionName"] = "These containers will be created in a batch operation and may not be immediately available. You can check the progress of their creation below:";
Ret["ActionLinks"]["BatchOps"]["Text"] = "View Batch Operations";
Ret["ActionLinks"]["BatchOps"]["ViewId"] = NbtResources.ViewSelect.getViewIdByName("My Batch Operations", CswEnumNbtViewVisibility.Global, null, null).ToString();
}
else
{
CswNbtMetaDataNodeType ContainerNT = NbtResources.MetaData.getNodeType("Container");
if (null != ContainerNT)
{
CswNbtView NewContainersView = new CswNbtView(NbtResources);
NewContainersView.ViewName = "New Containers";
CswNbtViewRelationship ContainerVr = NewContainersView.AddViewRelationship(ContainerNT, true);
ContainerVr.NodeIdsToFilterIn = ContainerIds;
NewContainersView.SaveToCache(false);
Ret["ActionLinks"]["NewContainers"] = new JObject();
Ret["ActionLinks"]["NewContainers"]["Text"] = "View Received Containers";
Ret["ActionLinks"]["NewContainers"]["ViewId"] = NewContainersView.SessionViewId.ToString();;
}
}
}
return(Ret);
}
private void _processRequest(String RequestItemId, CswNbtPropertySetMaterial Material)
{
CswNbtObjClassRequestItem RequestItemMaterialCreate = _CswNbtResources.Nodes[RequestItemId];
RequestItemMaterialCreate.Material.RelatedNodeId = Material.NodeId;
RequestItemMaterialCreate.Status.Value = CswNbtObjClassRequestItem.Statuses.Created;
RequestItemMaterialCreate.Type.Value = CswNbtObjClassRequestItem.Types.MaterialBulk;
RequestItemMaterialCreate.FulfillmentHistory.AddComment("Created " + Material.Node.NodeLink);
RequestItemMaterialCreate.postChanges(ForceUpdate: false);
}
public JObject initNewTempMaterialNode(Int32 NodeTypeId, string SupplierId, string Suppliername, string Tradename, string PartNo, string NodeId, bool IsConstituent, bool CorporateSupplier)
{
JObject Ret = new JObject();
//Check if the vendor needs to be created
if (false == CswTools.IsPrimaryKey(CswConvert.ToPrimaryKey(SupplierId)) && false == IsConstituent)
{
CswNbtMetaDataObjectClass VendorOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.VendorClass);
if (null != VendorOC)
{
CswNbtMetaDataNodeType VendorNT = VendorOC.FirstNodeType;
if (null != VendorNT)
{
CswNbtObjClassVendor NewVendorNode = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(VendorNT.NodeTypeId, IsTemp : true, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
CswNbtObjClassVendor NodeAsVendor = (CswNbtObjClassVendor)NewNode;
NodeAsVendor.VendorName.Text = Suppliername;
NodeAsVendor.VendorName.SyncGestalt();
if (CorporateSupplier)
{
NodeAsVendor.VendorType.Value = CswNbtObjClassVendor.VendorTypes.Corporate;
}
});
//Set the supplierId to the new vendor node
SupplierId = NewVendorNode.NodeId.ToString();
}
}
}
CswPrimaryKey CurrentTempNodePk = CswConvert.ToPrimaryKey(NodeId);
if (CswTools.IsPrimaryKey(CurrentTempNodePk))
{
CswNbtPropertySetMaterial CurrentTempNode = _CswNbtResources.Nodes.GetNode(CurrentTempNodePk);
if (null != CurrentTempNode)
{
Int32 CurrentNodeTypeId = CurrentTempNode.NodeTypeId;
if (NodeTypeId != CurrentNodeTypeId)
{
// Then we want to just forget about the first temp node created and create a new one with the new nodetype
Ret = _tryCreateTempMaterial(NodeTypeId, CswConvert.ToPrimaryKey(SupplierId), Tradename, PartNo, null, IsConstituent);
}
else
{
// If the nodetype isn't different then we want to get the props and check if it exsits
Ret = _tryCreateTempMaterial(NodeTypeId, CswConvert.ToPrimaryKey(SupplierId), Tradename, PartNo, CurrentTempNodePk.ToString(), IsConstituent);
}
}
}
return(Ret);
}
public CswNbtPropertySetMaterial existingMaterial(bool ForceRecalc = false)
{
if (ForceRecalc || null == _ExistingNode)
{
// If a preexisting material was provided, Node will not be null
// because it was set in the constructor
//_ExistingNode = Node;
if (null == _ExistingNode)
{
_ExistingNode = CswNbtPropertySetMaterial.getExistingMaterial(_NbtResources, NodeTypeId, SupplierId, TradeName, PartNo, IsConstituent);
}
}
return(_ExistingNode);
}
public void OpenItem()
{
CswNbtNode Node = _CswNbtResources.Nodes.GetNode(_OpenableObj.Material.RelatedNodeId);
CswNbtPropertySetMaterial Material = Node;
if (false == CanOpen())
{
throw new CswDniException(CswEnumErrorType.Warning,
"Cannot open container when Container does not have an expiration date set or the material does not have an open expiration interval set",
"Container.ExpirationDate isn't set or Container.Material.OpenExpirationInterval is not set, cannot open container");
}
_OpenableObj.OpenedDate.DateTimeValue = DateTime.Now;
_OpenableObj.ExpirationDate.DateTimeValue = (_OpenableObj.ExpirationDate.DateTimeValue < Material.getDefaultOpenExpirationDate(DateTime.Now) ? _OpenableObj.ExpirationDate.DateTimeValue : Material.getDefaultOpenExpirationDate(DateTime.Now));
_OpenableObj.Open.setHidden(true, true);
}
private JObject _tryCreateTempMaterial(Int32 MaterialNodeTypeId, CswPrimaryKey SupplierId, string TradeName, string PartNo, string NodeId, bool IsConstituent)
{
JObject Ret = new JObject();
NewMaterial PotentialMaterial = new NewMaterial(_CswNbtResources, MaterialNodeTypeId, TradeName, SupplierId, IsConstituent, PartNo, NodeId);
bool MaterialExists = PotentialMaterial.existsInDb();
Ret["materialexists"] = MaterialExists;
if (false == MaterialExists)
{
CswNbtPropertySetMaterial NodeAsMaterial = PotentialMaterial.Node;
if (null == NodeAsMaterial)
{
NodeAsMaterial = PotentialMaterial.commit();
}
if (null != NodeAsMaterial)
{
Ret["materialid"] = NodeAsMaterial.NodeId.ToString();
Ret["tradename"] = NodeAsMaterial.TradeName.Text;
Ret["partno"] = NodeAsMaterial.PartNumber.Text;
Ret["supplier"] = false == IsConstituent ? NodeAsMaterial.Supplier.CachedNodeName : "";
Ret["supplierid"] = false == IsConstituent?SupplierId.ToString() : "";
Ret["nodetypeid"] = NodeAsMaterial.NodeTypeId;
NodeAsMaterial.Save.setHidden(value: true, SaveToDb: true);
CswNbtSdTabsAndProps SdProps = new CswNbtSdTabsAndProps(_CswNbtResources);
Ret["properties"] = SdProps.getProps(NodeAsMaterial.Node, string.Empty, null, CswEnumNbtLayoutType.Add);
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.SDS))
{
CswNbtMetaDataObjectClass SDSDocOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.SDSDocumentClass);
CswNbtMetaDataNodeType SDSNodeType = SDSDocOC.FirstNodeType;
if (null != SDSNodeType)
{
Ret["documenttypeid"] = SDSNodeType.NodeTypeId;
}
}
Ret["noderef"] = NodeAsMaterial.Node.NodeLink; //for the link
}
}
else
{
CswNbtPropertySetMaterial ExisitingMaterial = PotentialMaterial.existingMaterial();
Ret["noderef"] = ExisitingMaterial.Node.NodeLink;
}
return(Ret);
}
public String getPhysicalState(CswNbtPropertySetMaterial MaterialNode)
{
String PhysicalState = "n/a";
if (MaterialNode.ObjectClass.ObjectClass == CswEnumNbtObjectClass.ChemicalClass)
{
CswNbtObjClassChemical ChemicalNode = MaterialNode.Node;
PhysicalState = ChemicalNode.PhysicalState.Value;
}
else if (MaterialNode.ObjectClass.ObjectClass == CswEnumNbtObjectClass.BiologicalClass)
{
CswNbtObjClassBiological ChemicalNode = MaterialNode.Node;
PhysicalState = ChemicalNode.PhysicalState.Value;
}
return(PhysicalState);
}
}//createSizeNodes()
public void createMaterialSynonyms(CswNbtPropertySetMaterial MaterialNode)
{
CswNbtMetaDataNodeType MaterialSynonymNT = _CswNbtResources.MetaData.getNodeType("Material Synonym");
if (null != MaterialSynonymNT)
{
for (int index = 0; index < _ProductToImport.Synonyms.Length; index++)
{
_CswNbtResources.Nodes.makeNodeFromNodeTypeId(MaterialSynonymNT.NodeTypeId, delegate(CswNbtNode NewNode)
{
CswNbtObjClassMaterialSynonym MaterialSynonymOC = NewNode;
MaterialSynonymOC.Name.Text = _ProductToImport.Synonyms[index];
MaterialSynonymOC.Material.RelatedNodeId = MaterialNode.NodeId;
});
}
}
}
public static void getPhysicalState(ICswResources CswResources, MaterialResponse Response, string NodeId)
{
if (null != CswResources)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswPrimaryKey pk = CswConvert.ToPrimaryKey(NodeId);
if (CswTools.IsPrimaryKey(pk))
{
Response.Data.PhysicalState = "n/a";
CswNbtPropertySetMaterial MaterialNode = NbtResources.Nodes[pk];
if (MaterialNode.ObjectClass.ObjectClass == CswEnumNbtObjectClass.ChemicalClass)
{
CswNbtObjClassChemical ChemicalNode = MaterialNode.Node;
Response.Data.PhysicalState = ChemicalNode.PhysicalState.Value;
}
}
}
}
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()
/// <summary>
/// Instance a new Material Request Item based on the selected button option - the type will either be By Bulk or By Size.
/// </summary>
public CswNbtObjClassRequestItem makeMaterialRequestItem(CswNbtPropertySetMaterial Material, CswNbtObjClass.NbtButtonData ButtonData)
{
checkForCentralInventoryGroups(_CswNbtResources);
CswNbtObjClassRequestItem RequestItem = null;
CswNbtMetaDataObjectClass RequestItemOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RequestItemClass);
CswNbtMetaDataNodeType RequestItemNT = RequestItemOC.getNodeTypes().FirstOrDefault();
CswNbtSdTabsAndProps PropsAction = new CswNbtSdTabsAndProps(_CswNbtResources);
if (null != RequestItemNT)
{
RequestItem = PropsAction.getAddNodeAndPostChanges(RequestItemNT, delegate(CswNbtNode NewNode)
{
CswNbtObjClassRequestItem RequestItemNode = NewNode;
RequestItemNode.Material.RelatedNodeId = Material.NodeId;
if (null != _ThisUser.DefaultLocationId)
{
CswNbtObjClassLocation DefaultAsLocation = _CswNbtResources.Nodes.GetNode(_ThisUser.DefaultLocationId);
if (null != DefaultAsLocation)
{
RequestItemNode.Location.SelectedNodeId = DefaultAsLocation.NodeId;
RequestItemNode.Location.CachedNodeName = DefaultAsLocation.Location.CachedNodeName;
RequestItemNode.Location.CachedPath = DefaultAsLocation.Location.CachedPath;
}
}
switch (ButtonData.SelectedText)
{
case CswNbtPropertySetMaterial.CswEnumRequestOption.Size:
RequestItemNode.Type.Value = CswNbtObjClassRequestItem.Types.MaterialSize;
break;
default: //Request by Bulk
RequestItemNode.Type.Value = CswNbtObjClassRequestItem.Types.MaterialBulk;
break;
}
});
}
return(RequestItem);
}
public JObject saveMaterialProps(CswPrimaryKey NodePk, JObject PropsObj, Int32 NodeTypeId)
{
JObject Ret = new JObject();
if (CswTools.IsPrimaryKey(NodePk))
{
CswNbtPropertySetMaterial MaterialNode = _CswNbtResources.Nodes.GetNode(NodePk);
CswNbtSdTabsAndProps SdTabsAndProps = new CswNbtSdTabsAndProps(_CswNbtResources);
SdTabsAndProps.saveNodeProps(MaterialNode.Node, PropsObj);
switch (MaterialNode.ObjectClass.ObjectClass)
{
case CswEnumNbtObjectClass.ChemicalClass:
CswNbtObjClassChemical ChemicalNode = MaterialNode.Node;
Ret["PhysicalState"] = ChemicalNode.PhysicalState.Value;
// Add more properties here if you want.
break;
case CswEnumNbtObjectClass.NonChemicalClass:
Ret["PhysicalState"] = CswNbtPropertySetMaterial.CswEnumPhysicalState.NA;
// Add properties here!
break;
case CswEnumNbtObjectClass.BiologicalClass:
CswNbtObjClassBiological BioNode = MaterialNode.Node;
Ret["PhysicalState"] = BioNode.PhysicalState.Value;
break;
}
}
return(Ret);
}
public static C3CreateMaterialResponse importC3Product(ICswResources CswResources, CswNbtC3Import.Request Request)
{
C3CreateMaterialResponse ret = new C3CreateMaterialResponse();
CswNbtResources _CswNbtResources = (CswNbtResources)CswResources;
CswC3SearchParams CswC3SearchParams = new CswC3SearchParams();
CswC3Product C3ProductDetails = new CswC3Product();
if (Int32.MinValue != Request.Cdbregno && Int32.MinValue != Request.C3ProductId)
{
CswC3SearchParams.ACDSearchParams = new ACDSearchParams();
CswC3SearchParams.ACDSearchParams.ProductId = Request.C3ProductId;
CswC3SearchParams.ACDSearchParams.Cdbregno = Request.Cdbregno;
}
else if (Int32.MinValue != Request.C3ProductId)
{
CswC3SearchParams.C3SearchParams = new C3SearchParams();
CswC3SearchParams.C3SearchParams.ProductId = Request.C3ProductId;
}
else
{
throw new CswDniException(CswEnumErrorType.Error, "Cannot run import, missing parameters.", "Cannot import C3 or ACD data without a Product Id or CdbRegNo.");
}
CswNbtC3ClientManager CswNbtC3ClientManager = new CswNbtC3ClientManager(_CswNbtResources, CswC3SearchParams);
SearchClient C3SearchClient = CswNbtC3ClientManager.initializeC3Client();
if (null != C3SearchClient)
{
// Perform C3 search to get the product details
CswRetObjSearchResults SearchResults = C3SearchClient.getProductDetails(CswC3SearchParams);
if (SearchResults.CswC3SearchResults.Length > 0)
{
C3ProductDetails = SearchResults.CswC3SearchResults[0];
string NodeTypeName = Request.NodeTypeName;
if (false == string.IsNullOrEmpty(NodeTypeName))
{
CswNbtMetaDataNodeType NodeTypeToBeImported = _CswNbtResources.MetaData.getNodeType(NodeTypeName);
if (null != NodeTypeToBeImported)
{
// Instance the ImportManger
ImportManager C3Import = new ImportManager(_CswNbtResources, C3ProductDetails);
// Create the temporary material node
CswNbtPropertySetMaterial C3ProductTempNode = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(NodeTypeToBeImported.NodeTypeId, IsTemp : true, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
//Set the c3productid property
((CswNbtPropertySetMaterial)NewNode).C3ProductId.Text = C3ProductDetails.ProductId.ToString();
// Add props to the tempnode
C3Import.addNodeTypeProps(NewNode);
// Sync Hazard Classes and PCID data if C3ProductTempNode is of type Chemical
if (NewNode.getObjectClass().ObjectClass == CswEnumNbtObjectClass.ChemicalClass)
{
CswNbtObjClassChemical ChemicalNode = NewNode;
ChemicalNode.syncFireDbData();
ChemicalNode.syncPCIDData();
}
//C3ProductTempNode.postChanges( false );
});
// Get or create a vendor node
C3CreateMaterialResponse.State.Supplier Supplier = C3Import.constructVendorObject(C3ProductDetails.SupplierName);
// Create size node(s)
Collection <C3CreateMaterialResponse.State.SizeRecord> ProductSizes = C3Import.constructSizeObjects();
// Create synonyms node(s)
C3Import.createMaterialSynonyms(C3ProductTempNode);
// Create a document node if C3ProductTempNode is of type Chemical
CswPrimaryKey SDSDocumentNodeId = new CswPrimaryKey();
if (C3ProductTempNode.ObjectClass.ObjectClass == CswEnumNbtObjectClass.ChemicalClass)
{
SDSDocumentNodeId = C3Import.createMaterialDocument(C3ProductTempNode);
}
#region Return Object
ret.success = true;
ret.actionname = "create material";
C3CreateMaterialResponse.State.MaterialType MaterialType = new C3CreateMaterialResponse.State.MaterialType();
MaterialType.name = Request.NodeTypeName;
MaterialType.val = Request.NodeTypeId;
C3CreateMaterialResponse.State State = new C3CreateMaterialResponse.State();
State.materialId = C3ProductTempNode.NodeId.ToString();
State.tradeName = C3ProductTempNode.TradeName.Text;
State.partNo = C3ProductTempNode.PartNumber.Text;
ret.state = State;
//State.useExistingTempNode = true;
State.supplier = Supplier;
if (string.IsNullOrEmpty(State.supplier.val))
{
State.addNewC3Supplier = true;
}
State.materialType = MaterialType;
State.sizes = ProductSizes;
if (null != SDSDocumentNodeId)
{
State.sds.sdsDocId = SDSDocumentNodeId.ToString();
}
#endregion Return Object
} //if (null != NodeTypeToBeImported)
} //if( false == string.IsNullOrEmpty( NodeTypeName ) )
} //if( SearchResults.CswC3SearchResults.Length > 0 )
} //if( null != C3SearchClient )
return(ret);
}//importC3Product()
/// <summary>
/// Default implementation that checks if the Openable has an Expiration Date and that the chemical has an open expiration interval set
/// </summary>
public bool CanOpen()
{
CswNbtPropertySetMaterial Material = _CswNbtResources.Nodes.GetNode(_OpenableObj.Material.RelatedNodeId);
return(DateTime.MinValue != _OpenableObj.ExpirationDate.DateTimeValue && (false == String.IsNullOrEmpty(Material.OpenExpireInterval.CachedNodeName) && false == Double.IsNaN(Material.OpenExpireInterval.Quantity)));
}
public static void getCopyData(ICswResources _CswResources, CopyDataReturn Copy, CopyDataRequest Request)
{
CswNbtResources _CswNbtResources = (CswNbtResources)_CswResources;
//If we get any more copy types in the future, extract them out into their own classes and instantiate them via factory
#region Create_Material Copy Data
if (Request.CopyType == CswEnumNbtActionName.Create_Material)
{
CswPrimaryKey OriginalNodeId = CswConvert.ToPrimaryKey(Request.NodeId);
if (CswTools.IsPrimaryKey(OriginalNodeId))
{
CswNbtPropertySetMaterial OriginalMaterial = _CswNbtResources.Nodes.GetNode(OriginalNodeId);
if (null != OriginalMaterial)
{
#region Material Properties
CswNbtPropertySetMaterial MaterialCopy = OriginalMaterial.CopyNode();
Copy.Data.Create_Material = new C3CreateMaterialResponse
{
actionname = CswEnumNbtActionName.Create_Material,
state = new C3CreateMaterialResponse.State
{
materialId = MaterialCopy.NodeId.ToString(),
materialType = new C3CreateMaterialResponse.State.MaterialType
{
name = MaterialCopy.NodeType.NodeTypeName,
val = CswConvert.ToInt32(MaterialCopy.NodeTypeId)
},
tradeName = OriginalMaterial.TradeName.Text,
partNo = OriginalMaterial.PartNumber.Text,
supplier = new C3CreateMaterialResponse.State.Supplier
{
name = OriginalMaterial.Supplier.CachedNodeName,
val = OriginalMaterial.Supplier.RelatedNodeId.ToString()
},
sizes = new Collection <C3CreateMaterialResponse.State.SizeRecord>(),
showOriginalUoM = false
}
};
#endregion Material Properties
#region Sizes
CswNbtMetaDataObjectClass SizeOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.SizeClass);
CswNbtMetaDataObjectClassProp MaterialOCP = SizeOC.getObjectClassProp(CswNbtObjClassSize.PropertyName.Material);
CswNbtView SizesView = new CswNbtView(_CswNbtResources)
{
ViewName = "MaterialCopySizes"
};
CswNbtViewRelationship SizeVR = SizesView.AddViewRelationship(SizeOC, false);
SizesView.AddViewPropertyAndFilter(SizeVR, MaterialOCP, OriginalMaterial.NodeId.PrimaryKey.ToString(), CswEnumNbtSubFieldName.NodeID);
ICswNbtTree SizesTree = _CswNbtResources.Trees.getTreeFromView(SizesView, false, false, false);
for (int i = 0; i < SizesTree.getChildNodeCount(); i++)
{
SizesTree.goToNthChild(i);
CswNbtObjClassSize SizeNode = SizesTree.getNodeForCurrentPosition();
Copy.Data.Create_Material.state.sizes.Add(new C3CreateMaterialResponse.State.SizeRecord
{
nodeTypeId = new C3CreateMaterialResponse.State.SizeRecord.SizeData
{
value = SizeNode.NodeTypeId.ToString(),
readOnly = true,
hidden = true
},
unitCount = new C3CreateMaterialResponse.State.SizeRecord.SizeData
{
value = CswConvert.ToString(SizeNode.UnitCount.Value),
readOnly = true,
hidden = false
},
quantity = new C3CreateMaterialResponse.State.SizeRecord.SizeData
{
value = CswConvert.ToString(SizeNode.InitialQuantity.Quantity),
readOnly = true,
hidden = false
},
uom = new C3CreateMaterialResponse.State.SizeRecord.SizeData
{
value = SizeNode.InitialQuantity.CachedUnitName,
readOnly = false == string.IsNullOrEmpty(SizeNode.InitialQuantity.CachedUnitName),
hidden = false,
id = SizeNode.InitialQuantity.UnitId.ToString()
},
catalogNo = new C3CreateMaterialResponse.State.SizeRecord.SizeData
{
value = SizeNode.CatalogNo.Text,
readOnly = true,
hidden = false
},
quantityEditable = new C3CreateMaterialResponse.State.SizeRecord.SizeData
{
value = SizeNode.QuantityEditable.Checked,
},
dispensible = new C3CreateMaterialResponse.State.SizeRecord.SizeData
{
value = SizeNode.Dispensable.Checked
}
});
SizesTree.goToParentNode();
}
#endregion Sizes
#region Synonyms
CswNbtMetaDataObjectClass MaterialSynonymOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.MaterialSynonymClass);
CswNbtMetaDataObjectClassProp SynMaterialOCP = MaterialSynonymOC.getObjectClassProp(CswNbtObjClassMaterialSynonym.PropertyName.Material);
CswNbtView SynonymsView = new CswNbtView(_CswNbtResources)
{
ViewName = "MaterialCopySynonyms"
};
CswNbtViewRelationship SynonymsVR = SynonymsView.AddViewRelationship(MaterialSynonymOC, false);
SynonymsView.AddViewPropertyAndFilter(SynonymsVR, SynMaterialOCP, OriginalMaterial.NodeId.PrimaryKey.ToString(), CswEnumNbtSubFieldName.NodeID);
ICswNbtTree SynonymsTree = _CswNbtResources.Trees.getTreeFromView(SynonymsView, false, false, false);
for (int i = 0; i < SynonymsTree.getChildNodeCount(); i++)
{
SynonymsTree.goToNthChild(i);
CswNbtObjClassMaterialSynonym SynonymNode = SynonymsTree.getNodeForCurrentPosition();
CswNbtObjClassMaterialSynonym SynonymCopy = SynonymNode.CopyNode();
SynonymCopy.Material.RelatedNodeId = MaterialCopy.NodeId;
SynonymCopy.postChanges(false);
SynonymsTree.goToParentNode();
}
#endregion Synonyms
if (MaterialCopy.ObjectClass.ObjectClass == CswEnumNbtObjectClass.ChemicalClass)
{
if (CswEnumTristate.False == MaterialCopy.IsConstituent.Checked)
{
#region SDS
CswNbtView SDSView = CswNbtObjClassSDSDocument.getAssignedSDSDocumentsView(_CswNbtResources, OriginalMaterial.NodeId);
ICswNbtTree SDSTree = _CswNbtResources.Trees.getTreeFromView(SDSView, false, false, false);
SDSTree.goToNthChild(0);
for (int i = 0; i < SDSTree.getChildNodeCount(); i++)
{
SDSTree.goToNthChild(i);
CswNbtObjClassSDSDocument SDSDoc = SDSTree.getNodeForCurrentPosition();
CswNbtObjClassSDSDocument SDSCopy = SDSDoc.CopyNode(IsNodeTemp: true);
SDSCopy.Owner.RelatedNodeId = MaterialCopy.NodeId;
SDSCopy.postChanges(false);
if (i == 0)
{
Copy.Data.Create_Material.state.sds.sdsDocId = SDSCopy.NodeId.ToString();
}
SDSTree.goToParentNode();
}
#endregion SDS
#region Components
CswNbtMetaDataObjectClass MaterialComponentOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.MaterialComponentClass);
CswNbtMetaDataObjectClassProp CompMaterialOCP = MaterialComponentOC.getObjectClassProp(CswNbtObjClassMaterialComponent.PropertyName.Mixture);
CswNbtView ComponentsView = new CswNbtView(_CswNbtResources)
{
ViewName = "MaterialCopyComponents"
};
CswNbtViewRelationship ComponentsVR = ComponentsView.AddViewRelationship(MaterialComponentOC, false);
ComponentsView.AddViewPropertyAndFilter(ComponentsVR, CompMaterialOCP, OriginalMaterial.NodeId.PrimaryKey.ToString(), CswEnumNbtSubFieldName.NodeID);
ICswNbtTree ComponentsTree = _CswNbtResources.Trees.getTreeFromView(ComponentsView, false, false, false);
for (int i = 0; i < ComponentsTree.getChildNodeCount(); i++)
{
ComponentsTree.goToNthChild(i);
CswNbtObjClassMaterialComponent ComponentNode = ComponentsTree.getNodeForCurrentPosition();
CswNbtObjClassMaterialComponent ComponentCopy = ComponentNode.CopyNode();
ComponentCopy.Mixture.RelatedNodeId = MaterialCopy.NodeId;
ComponentCopy.Constituent.RelatedNodeId = ComponentNode.Constituent.RelatedNodeId;
ComponentCopy.postChanges(false);
ComponentsTree.goToParentNode();
}
#endregion Components
}
#region GHS
CswNbtMetaDataObjectClass GHSOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.GHSClass);
CswNbtMetaDataObjectClassProp GHSMaterialOCP = GHSOC.getObjectClassProp(CswNbtObjClassGHS.PropertyName.Material);
CswNbtView GHSView = new CswNbtView(_CswNbtResources)
{
ViewName = "MaterialCopyGHS"
};
CswNbtViewRelationship GHSVR = GHSView.AddViewRelationship(GHSOC, false);
GHSView.AddViewPropertyAndFilter(GHSVR, GHSMaterialOCP, OriginalMaterial.NodeId.PrimaryKey.ToString(), CswEnumNbtSubFieldName.NodeID);
ICswNbtTree GHSTree = _CswNbtResources.Trees.getTreeFromView(GHSView, false, false, false);
for (int i = 0; i < GHSTree.getChildNodeCount(); i++)
{
GHSTree.goToNthChild(i);
CswNbtObjClassGHS GHSNode = GHSTree.getNodeForCurrentPosition();
CswNbtObjClassGHS GHSCopy = GHSNode.CopyNode();
GHSCopy.Material.RelatedNodeId = MaterialCopy.NodeId;
GHSCopy.postChanges(false);
GHSTree.goToParentNode();
}
#endregion GHS
}
}
}
}
#endregion Create_Material Copy Data
}
public bool existsInDb(bool ForceRecalc = false)
{
CswNbtPropertySetMaterial ExistingMaterial = existingMaterial(ForceRecalc);
return(ExistingMaterial != null && false == ExistingMaterial.IsTemp);
}
private CswNbtNode _commitMaterialNode(JObject MaterialObj)
{
CswNbtNode Ret = null;
Int32 MaterialNodeTypeId = CswConvert.ToInt32(MaterialObj["materialnodetypeid"]);
if (Int32.MinValue != MaterialNodeTypeId)
{
CswNbtMetaDataNodeType MaterialNt = _CswNbtResources.MetaData.getNodeType(MaterialNodeTypeId);
if (null != MaterialNt)
{
Ret = _CswNbtResources.Nodes[CswConvert.ToString(MaterialObj["materialId"])];
if (null != Ret)
{
// Set the Vendor node property isTemp = false if necessary
bool IsConstituent = CswConvert.ToBoolean(MaterialObj["isConstituent"]);
CswPrimaryKey VendorNodePk = CswConvert.ToPrimaryKey(CswConvert.ToString(MaterialObj["supplierid"]));
if (CswTools.IsPrimaryKey(VendorNodePk) && false == IsConstituent)
{
CswNbtObjClassVendor VendorNode = _CswNbtResources.Nodes.GetNode(VendorNodePk);
if (null != VendorNode && VendorNode.IsTemp)
{
VendorNode.PromoteTempToReal();
}
}
//Ret.IsTemp = false;
JObject MaterialProperties = (JObject)MaterialObj["properties"];
CswNbtSdTabsAndProps SdTabsAndProps = new CswNbtSdTabsAndProps(_CswNbtResources);
SdTabsAndProps.saveProps(Ret.NodeId, Int32.MinValue, MaterialProperties, Ret.NodeTypeId, null, IsIdentityTab: false, setIsTempToFalse: false);
NewMaterial FinalMaterial = new NewMaterial(_CswNbtResources, Ret);
FinalMaterial.TradeName = CswConvert.ToString(MaterialObj["tradename"]);
if (false == IsConstituent)
{
FinalMaterial.SupplierId = CswConvert.ToPrimaryKey(CswConvert.ToString(MaterialObj["supplierid"]));
FinalMaterial.PartNo = CswConvert.ToString(MaterialObj["partno"]);
}
CswNbtPropertySetMaterial NodeAsMaterial = FinalMaterial.commit();
NodeAsMaterial.Save.setHidden(value: false, SaveToDb: true);
JObject RequestObj = CswConvert.ToJObject(MaterialObj["request"]);
if (RequestObj.HasValues)
{
_processRequest(CswConvert.ToString(RequestObj["requestitemid"]), NodeAsMaterial);
}
CswNbtActReceiving Receiving = new CswNbtActReceiving(_CswNbtResources);
CswPrimaryKey SDSNodeId = new CswPrimaryKey();
if (null != MaterialObj["sdsDocId"])
{
SDSNodeId.FromString(MaterialObj["sdsDocId"].ToString());
JObject SDSProps = CswConvert.ToJObject(MaterialObj["sdsDocProperties"]);
Receiving.commitSDSDocNode(NodeAsMaterial.NodeId, SDSNodeId, SDSProps);
}
Ret.PromoteTempToReal();
}
}
if (null == Ret)
{
throw new CswDniException(CswEnumErrorType.Error,
"Failed to create new material.",
"Attempted to call _commitMaterialNode failed.");
}
}
return(Ret);
}
