public void setMaterialProps(CswNbtObjClassChemical MaterialNode)
{
if (MaterialNode != null)
{
_MaterialSpecificGravity = MaterialNode.SpecificGravity.Value;
}
}
public void MyTestInitialize()
{
TestData = new TestData();
CswNbtMetaDataNodeType ChemicalNT = TestData.CswNbtResources.MetaData.getNodeType("Chemical");
_FirstChemicalNode = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(ChemicalNT.NodeTypeId);
_ReceivingAction = new CswNbtActReceiving(TestData.CswNbtResources, _FirstChemicalNode.NodeId);
CswNbtObjClassUnitOfMeasure GramNode = TestData.CswNbtResources.Nodes.GetNode(new CswPrimaryKey("nodes", 26745));
CswNbtMetaDataNodeType SizeNT = TestData.CswNbtResources.MetaData.getNodeType("Size");
_SizeOne = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(SizeNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
CswNbtObjClassSize AsSize = NewNode;
AsSize.Material.RelatedNodeId = _FirstChemicalNode.NodeId;
AsSize.UnitCount.Value = 5;
AsSize.InitialQuantity.Quantity = 10;
AsSize.InitialQuantity.UnitId = GramNode.NodeId;
}, OverrideUniqueValidation: true);
_SizeTwo = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(SizeNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
CswNbtObjClassSize AsSize = NewNode;
AsSize.Material.RelatedNodeId = _FirstChemicalNode.NodeId;
AsSize.UnitCount.Value = 10;
AsSize.InitialQuantity.Quantity = 100;
AsSize.InitialQuantity.UnitId = GramNode.NodeId;
}, OverrideUniqueValidation: true);
}
public void _RegulatoryList_OnChange(CswNbtNodeProp Prop, bool Creating)
{
if (null != RegulatoryList.RelatedNodeId &&
RegulatoryList.RelatedNodeId.PrimaryKey != CswConvert.ToInt32(RegulatoryList.GetOriginalPropRowValue(CswNbtFieldTypeRuleRelationship.SubFieldName.NodeID)))
{
// case 28303 - set ByUser to current user when regulatory list is modified
if (false == SetByChemical && false == _CswNbtResources.CurrentNbtUser is CswNbtSystemUser)
{
ByUser.RelatedNodeId = _CswNbtResources.CurrentNbtUser.UserId;
// case 28303 - remove list from Chemical's Suppressed list
if (CswTools.IsPrimaryKey(Chemical.RelatedNodeId))
{
CswNbtObjClassChemical ChemicalNode = _CswNbtResources.Nodes[Chemical.RelatedNodeId];
if (null != ChemicalNode)
{
if (ChemicalNode.isRegulatoryListSuppressed(RegulatoryList.RelatedNodeId)) // important to prevent an infinite loop
{
ChemicalNode.removeSuppressedRegulatoryList(RegulatoryList.RelatedNodeId);
ChemicalNode.postChanges(false);
}
}
}
}
}
} // _RegulatoryList_OnChange()
private static readonly CookieManagerBehavior _cookieBehavior = new CookieManagerBehavior(); //All ChemWatch service clients must share this
public static CswNbtChemWatchRequest Initialize(ICswResources CswResources, CswNbtChemWatchRequest Request)
{
CswNbtChemWatchRequest Return = new CswNbtChemWatchRequest();
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswNbtObjClassChemical ChemicalNode = NbtResources.Nodes[Request.NbtMaterialId];
Return.Supplier = ChemicalNode.Supplier.CachedNodeName;
Return.PartNo = ChemicalNode.PartNumber.Text;
Return.MaterialName = ChemicalNode.TradeName.Text;
Return.NbtMaterialId = ChemicalNode.NodeId;
string errorMsg;
if (_authenticate(NbtResources, out errorMsg))
{
CommonServiceClient cwCommonClient = new CommonServiceClient();
cwCommonClient.Endpoint.Behaviors.Add(_cookieBehavior);
// Populate Language list
List <ChemWatchMultiSlctListItem> Languages = new List <ChemWatchMultiSlctListItem>();
Languages cwLanguages = cwCommonClient.GetLanguages();
foreach (Language cwLanguage in cwLanguages)
{
if (cwLanguage.UILanguage)
{
Languages.Add(new ChemWatchMultiSlctListItem()
{
Name = cwLanguage.Name,
Id = CswConvert.ToString(cwLanguage.Id)
});
}
}
IEnumerable <ChemWatchMultiSlctListItem> SortedLanguages = Languages.OrderBy(si => si.Name);
Return.Languages.options = SortedLanguages.ToList();
// Populate Country list
List <ChemWatchMultiSlctListItem> Countries = new List <ChemWatchMultiSlctListItem>();
Countries cwCountries = cwCommonClient.GetCountries();
foreach (Country cwCountry in cwCountries)
{
Countries.Add(new ChemWatchMultiSlctListItem()
{
Name = cwCountry.Name,
Id = CswConvert.ToString(cwCountry.Id)
});
}
IEnumerable <ChemWatchMultiSlctListItem> SortedCountries = Countries.OrderBy(si => si.Name);
Return.Countries.options = SortedCountries.ToList();
// Attempt to populate the Suppliers list
_getMatchingSuppliers(Return.Supplier, Return);
}
else
{
throw new CswDniException(CswEnumErrorType.Error, "There was a problem authenticating with ChemWatch", errorMsg);
}
return(Return);
}
internal CswNbtNode createMaterialNode(string NodeTypeName = "Chemical", string State = "Liquid", double SpecificGravity = 1.0,
string PPE = "", string Hazards = "", string SpecialFlags = "", string CASNo = "12-34-0", CswEnumTristate IsTierII = null,
Collection <CswNbtNode> Constituents = null, int ConstPercentage = 10)
{
IsTierII = IsTierII ?? CswEnumTristate.True;
CswNbtNode ret = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(_getNodeTypeId(NodeTypeName), delegate(CswNbtNode NewNode)
{
CswNbtObjClassChemical MaterialNode = NewNode;
if (CswTools.IsDouble(SpecificGravity))
{
MaterialNode.SpecificGravity.Value = SpecificGravity;
}
MaterialNode.PhysicalState.Value = State;
MaterialNode.TradeName.Text = "Fake Chemical " + Sequence;
MaterialNode.PartNumber.Text = "ABC00" + Sequence;
if (NodeTypeName == "Chemical")
{
if (false == String.IsNullOrEmpty(PPE))
{
_setMultiListValue(MaterialNode.Node, PPE, "PPE");
}
if (false == String.IsNullOrEmpty(Hazards))
{
_setMultiListValue(MaterialNode.Node, Hazards, "Hazard Classes");
}
MaterialNode.postChanges(true);
_setMultiListValue(MaterialNode.Node, SpecialFlags, "Special Flags");
MaterialNode.CasNo.Text = CASNo;
MaterialNode.IsTierII.Checked = IsTierII;
if (null != Constituents)
{
foreach (CswNbtNode Constituent in Constituents)
{
_CswNbtResources.Nodes.makeNodeFromNodeTypeId(_getNodeTypeId("Material Component"), delegate(CswNbtNode Node)
{
CswNbtObjClassMaterialComponent MaterialComponentNode = Node;
MaterialComponentNode.Mixture.RelatedNodeId = MaterialNode.NodeId;
MaterialComponentNode.Constituent.RelatedNodeId = Constituent.NodeId;
//MaterialComponentNode.LowPercentageValue.Value = ConstPercentage;
//MaterialComponentNode.TargetPercentageValue.Value = ConstPercentage;
//MaterialComponentNode.HighPercentageValue.Value = ConstPercentage;
//MaterialComponentNode.Percentage.Value = ConstPercentage;
MaterialComponentNode.PercentageRange.Lower = ConstPercentage;
MaterialComponentNode.PercentageRange.Target = ConstPercentage;
MaterialComponentNode.PercentageRange.Upper = ConstPercentage;
});
}
}
}
}, OverrideUniqueValidation: true);
_finalize();
return(ret);
}
public void testReceivingBarcodesNoBarcode()
{
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);
int NumContainers = 2;
CswNbtReceivingDefinition ReceiptDef = new CswNbtReceivingDefinition()
{
ContainerNodeId = InitialContainer.NodeId,
ContainerNodeTypeId = ContainerNT.NodeTypeId,
ContainerProps = ContainerAddProps,
MaterialNodeId = ChemicalNode.NodeId,
Quantities = new Collection <CswNbtAmountsGridQuantity>()
{
new CswNbtAmountsGridQuantity()
{
NumContainers = NumContainers,
Quantity = 10,
SizeName = Size.NodeName,
SizeNodeId = Size.NodeId,
UnitNodeId = GramNode.NodeId,
ContainerIds = new Collection <string>()
{
InitialContainer.NodeId.ToString()
}
}
}
};
CswNbtMetaDataNodeTypeProp BarcodeNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Barcode);
string Before = BarcodeNTP.Sequence.getCurrent();
ReceivingAction.receiveMaterial(ReceiptDef);
string After = BarcodeNTP.Sequence.getCurrent();
Assert.AreNotEqual(Before, After, "Creating containers in receiving with no custom barcodes specified did not consume sequence values when it should have");
}
protected override void afterDeleteNodeLogic()
{
// case 28303 - add list to Chemical's Suppressed list
if (false == SetByChemical && CswTools.IsPrimaryKey(Chemical.RelatedNodeId))
{
CswNbtObjClassChemical ChemicalNode = _CswNbtResources.Nodes[Chemical.RelatedNodeId];
if (null != ChemicalNode)
{
ChemicalNode.addSuppressedRegulatoryList(RegulatoryList.RelatedNodeId);
ChemicalNode.postChanges(false);
}
}
}//afterDeleteNode()
public void threadCallBack(ICswResources CswResources)
{
_LogicRunStatus = CswEnumScheduleLogicRunStatus.Running;
CswNbtResources CswNbtResources = (CswNbtResources)CswResources;
CswNbtResources.AuditContext = "Scheduler Task: " + RuleName;
if (CswEnumScheduleLogicRunStatus.Stopping != _LogicRunStatus)
{
try
{
if (_SyncModules.Any(SyncModule => CswNbtResources.Modules.IsModuleEnabled(SyncModule)))
{
// Check C3 Status
CswC3Params CswC3Params = new CswC3Params();
CswNbtC3ClientManager CswNbtC3ClientManager = new CswNbtC3ClientManager(CswNbtResources, CswC3Params);
SearchClient SearchClient = CswNbtC3ClientManager.initializeC3Client();
if (null != SearchClient)
{
int MaterialsProcessedPerIteration = CswConvert.ToInt32(CswNbtResources.ConfigVbls.getConfigVariableValue(CswEnumConfigurationVariableNames.NodesProcessedPerCycle));
int TotalProcessedThisIteration = 0;
while (TotalProcessedThisIteration < MaterialsProcessedPerIteration && _MaterialPks.Count > 0 && (CswEnumScheduleLogicRunStatus.Stopping != _LogicRunStatus))
{
CswNbtObjClassChemical MaterialNode = CswNbtResources.Nodes[_MaterialPks[0]];
if (null != MaterialNode)
{
_setPendingUpdate(CswNbtResources, CswConvert.ToString(MaterialNode.NodeId.PrimaryKey));
_MaterialPks.RemoveAt(0);
TotalProcessedThisIteration++;
} //if (null != MaterialNode)
}
}
else
{
// TODO: What should we do with the error in the case of the schedule service?
}
}
_CswScheduleLogicDetail.StatusMessage = "Completed without error";
_LogicRunStatus = CswEnumScheduleLogicRunStatus.Succeeded; //last line
}//try
catch (Exception Exception)
{
_CswScheduleLogicDetail.StatusMessage = "CswScheduleLogicNbtExtChemDataSync exception: " + Exception.Message + "; " + Exception.StackTrace;
CswNbtResources.logError(new CswDniException(_CswScheduleLogicDetail.StatusMessage));
_LogicRunStatus = CswEnumScheduleLogicRunStatus.Failed;
}
}
}
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);
}
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;
}
}
}
}
internal CswNbtNode createConstituentNode(string NodeTypeName = "Chemical", string State = "Liquid", double SpecificGravity = 1.0,
string CASNo = "12-34-0", CswEnumTristate IsTierII = null)
{
IsTierII = IsTierII ?? CswEnumTristate.True;
CswNbtNode ret = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(_getNodeTypeId("Constituent"), delegate(CswNbtNode NewNode)
{
CswNbtObjClassChemical MaterialNode = NewNode;
if (CswTools.IsDouble(SpecificGravity))
{
MaterialNode.SpecificGravity.Value = SpecificGravity;
}
MaterialNode.PhysicalState.Value = State;
MaterialNode.TradeName.Text = "Fake Constituent " + Sequence;
MaterialNode.PartNumber.Text = "ABC00" + Sequence;
MaterialNode.CasNo.Text = CASNo;
MaterialNode.IsTierII.Checked = IsTierII;
}, OverrideUniqueValidation: true);
_finalize();
return(ret);
}
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()
public override void update()
{
//get all Structure NTP ids
CswNbtMetaDataObjectClass ChemicalOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ChemicalClass );
CswNbtMetaDataObjectClassProp StructureOCP = ChemicalOC.getObjectClassProp( CswNbtObjClassChemical.PropertyName.Structure );
CswCommaDelimitedString StructreNTPIds = new CswCommaDelimitedString();
foreach( CswNbtMetaDataNodeTypeProp StructureNTP in StructureOCP.getNodeTypeProps() )
{
StructreNTPIds.Add( StructureNTP.PropId.ToString() );
}
//get all node ids from jct_nodes_props that have more than one record for the Structure prop
Collection<CswPrimaryKey> NodeIds = new Collection<CswPrimaryKey>();
string sql = "select nodeid, count(nodeid) as cnt from jct_nodes_props where nodetypepropid in (" + StructreNTPIds.ToString() + ") group by nodeid";
CswArbitrarySelect ArbSelect = _CswNbtSchemaModTrnsctn.makeCswArbitrarySelect( "GetDuplicateStructureRecords", sql );
DataTable jnpTbl = ArbSelect.getTable();
foreach( DataRow row in jnpTbl.Rows )
{
if( CswConvert.ToInt32( row["cnt"] ) > 1 )
{
NodeIds.Add( new CswPrimaryKey( "nodes", CswConvert.ToInt32( row["nodeid"] ) ) );
}
}
//Fix the Nodes
foreach( CswPrimaryKey NodeId in NodeIds )
{
CswCommaDelimitedString JctNodePropRowsToDelete = new CswCommaDelimitedString();
CswNbtObjClassChemical ChemicalNode = _CswNbtSchemaModTrnsctn.Nodes[NodeId];
if( String.IsNullOrEmpty( ChemicalNode.Structure.Mol ) ) //if there is no Mol, a user never uploaded a new Mol, find the JctNodeProp row that has the clob data and set it correctly
{
int newJctNodePropId = Int32.MinValue;
DataTable JnpTbl = _getJNPTblUpdate( NodeId, StructreNTPIds );
foreach( DataRow row in JnpTbl.Rows )
{
if( String.IsNullOrEmpty( row["clobdata"].ToString() ) )
{
JctNodePropRowsToDelete.Add( CswConvert.ToInt32( row["jctnodepropid"] ).ToString() );
}
else
{
newJctNodePropId = CswConvert.ToInt32( row["jctnodepropid"] );
}
}
CswTableUpdate blobDataTblUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "getBlobDataTblUpdate", "blob_data" );
DataTable blobDataTbl = blobDataTblUpdate.getTable( "where jctnodepropid in (" + JctNodePropRowsToDelete.ToString() + ")" );
if( blobDataTbl.Rows.Count > 0 )
{
blobDataTbl.Rows[0]["jctnodepropid"] = newJctNodePropId;
}
blobDataTblUpdate.update( blobDataTbl );
}
else //the user uploaded a new mol to the Chemical, throw out the old data and use the new data
{
DataTable JnpTbl = _getJNPTblUpdate( NodeId, StructreNTPIds );
foreach( DataRow row in JnpTbl.Rows )
{
if( CswConvert.ToInt32( row["jctnodepropid"] ) != ChemicalNode.Structure.JctNodePropId )
{
JctNodePropRowsToDelete.Add( CswConvert.ToInt32( row["jctnodepropid"] ).ToString() );
}
}
if( JctNodePropRowsToDelete.Count > 0 )
{
CswTableUpdate BlobDataTblUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "DeleteOldBlobDataRows", "blob_data" );
DataTable blobDataTbl = BlobDataTblUpdate.getTable( "where jctnodepropid in (" + JctNodePropRowsToDelete.ToString() + ")" );
foreach( DataRow row in blobDataTbl.Rows )
{
row.Delete();
}
BlobDataTblUpdate.update( blobDataTbl );
}
}
CswTableUpdate JnpTblUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "DeleteBadJnpDataRows", "jct_nodes_props" );
DataTable jnpDataTbl = JnpTblUpdate.getTable( "where jctnodepropid in (" + JctNodePropRowsToDelete.ToString() + ")" );
foreach( DataRow row in jnpDataTbl.Rows )
{
row.Delete();
}
JnpTblUpdate.update( jnpDataTbl );
}
} // update()
/// <summary>
/// Create an ObjClass instance for given ObjectClass and Node
/// </summary>
public static CswNbtObjClass makeObjClass(CswNbtResources CswNbtResources, CswNbtMetaDataObjectClass ObjectClass, CswNbtNode Node = null)
{
CswNbtObjClass ReturnVal = null;
switch (ObjectClass.ObjectClass)
{
case CswEnumNbtObjectClass.BalanceClass:
ReturnVal = new CswNbtObjClassBalance(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.BalanceConfigurationClass:
ReturnVal = new CswNbtObjClassBalanceConfiguration(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.BatchOpClass:
ReturnVal = new CswNbtObjClassBatchOp(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.BiologicalClass:
ReturnVal = new CswNbtObjClassBiological(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertDefCharacteristicLimitClass:
ReturnVal = new CswNbtObjClassCertDefCharacteristicLimit(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertDefSpecClass:
ReturnVal = new CswNbtObjClassCertDefSpec(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertificateDefinitionClass:
ReturnVal = new CswNbtObjClassCertificateDefinition(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertDefConditionClass:
ReturnVal = new CswNbtObjClassCertDefCondition(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertDefSpecLevelClass:
ReturnVal = new CswNbtObjClassCertDefSpecLevel(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CofADocumentClass:
ReturnVal = new CswNbtObjClassCofADocument(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CofAMethodClass:
ReturnVal = new CswNbtObjClassCofAMethod(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CofAMethodTemplateClass:
ReturnVal = new CswNbtObjClassCofAMethodTemplate(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ContainerClass:
ReturnVal = new CswNbtObjClassContainer(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ContainerDispenseTransactionClass:
ReturnVal = new CswNbtObjClassContainerDispenseTransaction(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ContainerGroupClass:
ReturnVal = new CswNbtObjClassContainerGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ContainerLocationClass:
ReturnVal = new CswNbtObjClassContainerLocation(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ControlZoneClass:
ReturnVal = new CswNbtObjClassControlZone(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CustomerClass:
ReturnVal = new CswNbtObjClassCustomer(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DepartmentClass:
ReturnVal = new CswNbtObjClassDepartment(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DesignNodeTypeClass:
ReturnVal = new CswNbtObjClassDesignNodeType(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DesignNodeTypePropClass:
ReturnVal = new CswNbtObjClassDesignNodeTypeProp(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DesignNodeTypeTabClass:
ReturnVal = new CswNbtObjClassDesignNodeTypeTab(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DesignSequenceClass:
ReturnVal = new CswNbtObjClassDesignSequence(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DocumentClass:
ReturnVal = new CswNbtObjClassDocument(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DSDPhraseClass:
ReturnVal = new CswNbtObjClassDSDPhrase(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.EnterprisePartClass:
ReturnVal = new CswNbtObjClassEnterprisePart(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.EquipmentAssemblyClass:
ReturnVal = new CswNbtObjClassEquipmentAssembly(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.EquipmentClass:
ReturnVal = new CswNbtObjClassEquipment(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.EquipmentTypeClass:
ReturnVal = new CswNbtObjClassEquipmentType(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.FeedbackClass:
ReturnVal = new CswNbtObjClassFeedback(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.FireClassExemptAmountClass:
ReturnVal = new CswNbtObjClassFireClassExemptAmount(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.FireClassExemptAmountSetClass:
ReturnVal = new CswNbtObjClassFireClassExemptAmountSet(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GenericClass:
ReturnVal = new CswNbtObjClassGeneric(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GHSClass:
ReturnVal = new CswNbtObjClassGHS(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GHSClassificationClass:
ReturnVal = new CswNbtObjClassGHSClassification(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GHSPhraseClass:
ReturnVal = new CswNbtObjClassGHSPhrase(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GHSSignalWordClass:
ReturnVal = new CswNbtObjClassGHSSignalWord(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InspectionDesignClass:
ReturnVal = new CswNbtObjClassInspectionDesign(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InspectionRouteClass:
ReturnVal = new CswNbtObjClassInspectionRoute(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InspectionTargetClass:
ReturnVal = new CswNbtObjClassInspectionTarget(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InspectionTargetGroupClass:
ReturnVal = new CswNbtObjClassInspectionTargetGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InventoryGroupClass:
ReturnVal = new CswNbtObjClassInventoryGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InventoryGroupPermissionClass:
ReturnVal = new CswNbtObjClassInventoryGroupPermission(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InventoryLevelClass:
ReturnVal = new CswNbtObjClassInventoryLevel(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.JurisdictionClass:
ReturnVal = new CswNbtObjClassJurisdiction(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.Level:
ReturnVal = new CswNbtObjClassLevel(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.LocationClass:
ReturnVal = new CswNbtObjClassLocation(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.LQNoClass:
ReturnVal = new CswNbtObjClassLQNo(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ManufacturerClass:
ReturnVal = new CswNbtObjClassManufacturer(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ManufacturerEquivalentPartClass:
ReturnVal = new CswNbtObjClassManufacturerEquivalentPart(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ChemicalClass:
ReturnVal = new CswNbtObjClassChemical(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MaterialComponentClass:
ReturnVal = new CswNbtObjClassMaterialComponent(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MaterialSynonymClass:
ReturnVal = new CswNbtObjClassMaterialSynonym(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MailReportClass:
ReturnVal = new CswNbtObjClassMailReport(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MailReportGroupClass:
ReturnVal = new CswNbtObjClassMailReportGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MailReportGroupPermissionClass:
ReturnVal = new CswNbtObjClassMailReportGroupPermission(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MethodClass:
ReturnVal = new CswNbtObjClassMethod(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MethodCharacteristicClass:
ReturnVal = new CswNbtObjClassMethodCharacteristic(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MethodConditionClass:
ReturnVal = new CswNbtObjClassMethodCondition(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.NonChemicalClass:
ReturnVal = new CswNbtObjClassNonChemical(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.PrinterClass:
ReturnVal = new CswNbtObjClassPrinter(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.PrintJobClass:
ReturnVal = new CswNbtObjClassPrintJob(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.PrintLabelClass:
ReturnVal = new CswNbtObjClassPrintLabel(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ProblemClass:
ReturnVal = new CswNbtObjClassProblem(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ReceiptLotClass:
ReturnVal = new CswNbtObjClassReceiptLot(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RegulatoryListClass:
ReturnVal = new CswNbtObjClassRegulatoryList(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RegulatoryListCasNoClass:
ReturnVal = new CswNbtObjClassRegulatoryListCasNo(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RegulatoryListMemberClass:
ReturnVal = new CswNbtObjClassRegulatoryListMember(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RegulatoryListListCodeClass:
ReturnVal = new CswNbtObjClassRegulatoryListListCode(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ReportClass:
ReturnVal = new CswNbtObjClassReport(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ReportGroupClass:
ReturnVal = new CswNbtObjClassReportGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ReportGroupPermissionClass:
ReturnVal = new CswNbtObjClassReportGroupPermission(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RequestClass:
ReturnVal = new CswNbtObjClassRequest(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RequestItemClass:
ReturnVal = new CswNbtObjClassRequestItem(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RoleClass:
ReturnVal = new CswNbtObjClassRole(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.SDSDocumentClass:
ReturnVal = new CswNbtObjClassSDSDocument(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.TestingLabClass:
ReturnVal = new CswNbtObjClassTestingLab(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GeneratorClass:
ReturnVal = new CswNbtObjClassGenerator(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.SizeClass:
ReturnVal = new CswNbtObjClassSize(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.TaskClass:
ReturnVal = new CswNbtObjClassTask(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.TestingLabUserAssignmentClass:
ReturnVal = new CswNbtObjClassTestingLabUserAssignment(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.TestingLabMethodAssignmentClass:
ReturnVal = new CswNbtObjClassTestingLabMethodAssignment(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.UnitOfMeasureClass:
ReturnVal = new CswNbtObjClassUnitOfMeasure(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.UserClass:
ReturnVal = new CswNbtObjClassUser(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.VendorClass:
ReturnVal = new CswNbtObjClassVendor(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.WorkUnitClass:
ReturnVal = new CswNbtObjClassWorkUnit(CswNbtResources, Node);
break;
default:
//ReturnVal = new CswNbtObjClassDefault( CswNbtResources, _CswNbtNode );
throw (new CswDniException("There is no NbtObjClass derivative for object class " + ObjectClass.ObjectClass.ToString()));
}//switch
return(ReturnVal);
} //makeObjClass()
