public override void ReadDataRow(DataRow PropRow, Dictionary <string, Int32> NodeMap, Dictionary <Int32, Int32> NodeTypeMap)
{
string StringVal = CswTools.XmlRealAttributeName(PropRow[_QuantitySubField.ToXmlNodeName()].ToString());
if (CswTools.IsFloat(StringVal))
{
Quantity = Convert.ToDouble(StringVal);
}
CachedUnitName = CswTools.XmlRealAttributeName(PropRow[_UnitNameSubField.ToXmlNodeName()].ToString());
string NodeId = CswTools.XmlRealAttributeName(PropRow[_UnitIdSubField.ToXmlNodeName()].ToString());
if (NodeMap != null && NodeMap.ContainsKey(NodeId.ToLower()))
{
UnitId = new CswPrimaryKey("nodes", NodeMap[NodeId.ToLower()]);
}
else if (CswTools.IsInteger(NodeId))
{
UnitId = new CswPrimaryKey("nodes", CswConvert.ToInt32(NodeId));
}
else
{
UnitId = null;
}
if (null != UnitId)
{
PendingUpdate = true;
}
}
/// <summary>
/// Changes a checkbox for a particular set of values
/// </summary>
public void SetValue(string XValue, string YValue, bool Checked)
{
XmlNode YValueNode = LogicalSetXmlDoc.ChildNodes[0].SelectSingleNode("YValue[@y='" + CswTools.XPathSafeParameter(YValue) + "']");
if (YValueNode == null)
{
YValueNode = LogicalSetXmlDoc.CreateElement("YValue");
XmlAttribute YAttribute = LogicalSetXmlDoc.CreateAttribute("y");
YAttribute.Value = CswTools.XPathSafeParameter(YValue);
YValueNode.Attributes.Append(YAttribute);
LogicalSetXmlDoc.ChildNodes[0].AppendChild(YValueNode);
}
XmlNode XValueNode = YValueNode.SelectSingleNode(XValue);
if (XValueNode == null)
{
XValueNode = LogicalSetXmlDoc.CreateElement(XValue);
YValueNode.AppendChild(XValueNode);
}
if (Checked)
{
XValueNode.InnerText = "1";
}
else
{
XValueNode.InnerText = "0";
}
}
public CswNbtNode GetNode(string NodeId, string NodeKey, CswDateTime Date = null)
{
CswNbtNode Node = null;
if (!string.IsNullOrEmpty(NodeKey))
{
//CswNbtNodeKey RealNodeKey = new CswNbtNodeKey( CswNbtResources, FromSafeJavaScriptParam( NodeKey ) );
CswNbtNodeKey RealNodeKey = new CswNbtNodeKey(NodeKey);
Node = _CswNbtResources.getNode(RealNodeKey, Date);
}
else if (!string.IsNullOrEmpty(NodeId))
{
CswPrimaryKey RealNodeId = new CswPrimaryKey();
if (CswTools.IsInteger(NodeId))
{
RealNodeId.TableName = "nodes";
RealNodeId.PrimaryKey = CswConvert.ToInt32(NodeId);
}
else
{
RealNodeId.FromString(NodeId);
}
Node = _CswNbtResources.getNode(RealNodeId, Date);
}
return(Node);
} // getNode()
public static void getUserDefaults(ICswResources CswResources, CswNbtAuthReturn Ret, object Request)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
if (CswTools.IsPrimaryKey(NbtResources.CurrentNbtUser.DefaultLocationId))
{
Ret.Data.DefaultLocationId = NbtResources.CurrentNbtUser.DefaultLocationId.ToString();
}
if (CswTools.IsPrimaryKey(NbtResources.CurrentNbtUser.DefaultPrinterId))
{
Ret.Data.DefaultPrinterId = NbtResources.CurrentNbtUser.DefaultPrinterId.ToString();
}
if (CswTools.IsPrimaryKey(NbtResources.CurrentNbtUser.DefaultBalanceId))
{
Ret.Data.DefaultBalanceId = NbtResources.CurrentNbtUser.DefaultBalanceId.ToString();
}
if (CswTools.IsPrimaryKey(NbtResources.CurrentNbtUser.JurisdictionId))
{
Ret.Data.JurisdictionId = NbtResources.CurrentNbtUser.JurisdictionId.ToString();
}
if (CswTools.IsPrimaryKey(NbtResources.CurrentNbtUser.CurrentWorkUnitId))
{
Ret.Data.WorkUnitId = NbtResources.CurrentNbtUser.CurrentWorkUnitId.ToString();
}
Ret.Data.DateFormatDn = NbtResources.CurrentNbtUser.DateFormat;
Ret.Data.TimeFormatDn = NbtResources.CurrentNbtUser.TimeFormat;
Ret.Data.DateFormatJs = CswTools.ConvertNetToPHP(NbtResources.CurrentNbtUser.DateFormat);
Ret.Data.TimeFormatJs = CswTools.ConvertNetToPHP(NbtResources.CurrentNbtUser.TimeFormat);
}
/// <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);
}
private void OnCompanyIdPropChange( CswNbtNodeProp NodeProp, bool Creating )
{
if ( false == CswTools.IsValidUsername( CompanyID.Text ) )
{
throw new CswDniException( CswEnumErrorType.Warning, "The suppplied CustomerId is not in a valid format.", "CustomerId: {" + CompanyID.Text + "} is not well-formed." );
}
}
/// <summary>
/// Finalize the new Material
/// </summary>
public JObject commitMaterial(string MaterialDefinition)
{
JObject RetObj = new JObject();
JObject MaterialObj = CswConvert.ToJObject(MaterialDefinition);
if (MaterialObj.HasValues)
{
JArray SizesArray = CswConvert.ToJArray(MaterialObj["sizeNodes"]);
CswPrimaryKey MaterialId = new CswPrimaryKey();
MaterialId.FromString(CswConvert.ToString(MaterialObj["materialId"]));
if (CswTools.IsPrimaryKey(MaterialId))
{
CswNbtNode MaterialNode = _CswNbtResources.Nodes[MaterialId];
if (null != MaterialNode)
{
/* 1. Validate the new material and get its properties */
MaterialNode = _commitMaterialNode(MaterialObj);
RetObj["createdmaterial"] = true;
/* 2. Add the sizes */
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.Containers))
{
SizesArray = _removeDuplicateSizes(SizesArray);
_addMaterialSizes(SizesArray, MaterialNode);
RetObj["sizescount"] = SizesArray.Count;
}
/* 3. Add landingpage data */
RetObj["landingpagedata"] = _getLandingPageData(MaterialNode);
}
}
}
return(RetObj);
}
private void _updateAvailableWorkUnits()
{
//Case 30817 (Case 30843: moved to here from onBeforeCreate)
if (CswTools.IsPrimaryKey(CurrentWorkUnitId) &&
false == AvailableWorkUnits.CheckValue(CurrentWorkUnitId.ToString()))
{
AvailableWorkUnits.AddValue(CurrentWorkUnitId.ToString());
CurrentWorkUnitProperty.RelatedNodeId = CurrentWorkUnitId;
CurrentWorkUnitProperty.SyncGestalt();
}
CswNbtView View = _CswNbtResources.ViewSelect.restoreView(CurrentWorkUnitProperty.NodeTypeProp.ViewId);
View.Clear();
View.SetVisibility(CswEnumNbtViewVisibility.Property, null, null);
CswNbtMetaDataObjectClass WorkUnitOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.WorkUnitClass);
CswNbtViewRelationship WorkUnitParent = View.AddViewRelationship(WorkUnitOC, false);
foreach (string WorkUnitNodeId in AvailableWorkUnits.Value)
{
CswPrimaryKey pk = CswConvert.ToPrimaryKey(WorkUnitNodeId);
WorkUnitParent.NodeIdsToFilterIn.Add(pk);
}
CurrentWorkUnitProperty.OverrideView(View);
}
public static void getReportInfo( ICswResources CswResources, CswNbtWebServiceReport.ReportReturn Return, CswNbtWebServiceReport.ReportData reportParams )
{
CswNbtResources NBTResources = (CswNbtResources) CswResources;
reportParams.ReportNode = NBTResources.Nodes[reportParams.NodeId];
if( null != reportParams.ReportNode )
{
reportParams.doesSupportCrystal = ( false == reportParams.ReportNode.RPTFile.Empty );
CswNbtNode SourceNode = null;
if( CswTools.IsPrimaryKey( reportParams.SourceId ) )
{
SourceNode = NBTResources.Nodes[reportParams.SourceId];
}
reportParams.reportParams = new Collection<ReportData.ReportParam>();
foreach( var paramPair in reportParams.ReportNode.ExtractReportParams( NBTResources.Nodes[NBTResources.CurrentNbtUser.UserId], SourceNode ) )
{
ReportData.ReportParam paramObj = new ReportData.ReportParam();
paramObj.name = paramPair.Key;
paramObj.value = paramPair.Value;
reportParams.reportParams.Add( paramObj );
}
}
Return.Data = reportParams;
}
private void onRolePropChange(CswNbtNodeProp NodeProp, bool Creating)
{
if (null != _CswNbtResources.CurrentNbtUser &&
CswTools.IsPrimaryKey(Role.RelatedNodeId) &&
Role.RelatedNodeId.PrimaryKey != CswConvert.ToInt32(Role.GetOriginalPropRowValue(CswEnumNbtPropColumn.Field1_FK)))
{
if (false == _CswNbtResources.CurrentNbtUser.IsAdministrator())
{
throw new CswDniException(CswEnumErrorType.Warning, "Only Administrators can change user roles",
"Current user (" + _CswNbtResources.CurrentUser.Username +
") attempted to edit a user role.");
}
if (this.Username != ChemSWAdminUsername &&
((CswNbtObjClassRole)_CswNbtResources.Nodes[Role.RelatedNodeId]).Name.Text ==
CswNbtObjClassRole.ChemSWAdminRoleName)
{
throw new CswDniException(CswEnumErrorType.Warning,
"New users may not be assigned to the '" +
CswNbtObjClassRole.ChemSWAdminRoleName + "' role",
"Current user (" + _CswNbtResources.CurrentUser.Username +
") attempted to assign a new user to the '" +
CswNbtObjClassRole.ChemSWAdminRoleName + "' role.");
}
}
}
public void OnCurrentWorkUnitPropertyChange(CswNbtNodeProp Prop, bool Creating)
{
CswPrimaryKey UsersCurrentWorkUnitId = CurrentWorkUnitId;
//Case 30817
//if( null != UsersWorkUnitId )
if (false == CswTools.IsPrimaryKey(UsersCurrentWorkUnitId))
{
UsersCurrentWorkUnitId = GetFirstAvailableWorkUnitNodeId();
}
if (false == AvailableWorkUnits.CheckValue(UsersCurrentWorkUnitId.ToString()))
{
if (false == _CswNbtResources.CurrentNbtUser is CswNbtSystemUser &&
_CswNbtResources.CurrentNbtUser.Username != ChemSWAdminUsername)
{
throw new CswDniException(CswEnumErrorType.Warning,
CurrentWorkUnitProperty.CachedNodeName +
" is not an available Work Unit for user " + Username,
_CswNbtResources.CurrentNbtUser.Username + " attempted to assign User: "******" to Work Unit: " + UsersCurrentWorkUnitId +
" when Users available Work Units are: " + AvailableWorkUnits.Value);
}
// We add the work unit to the list and then check it!
AvailableWorkUnits.AddValue(UsersCurrentWorkUnitId.ToString());
CurrentWorkUnitProperty.RelatedNodeId = UsersCurrentWorkUnitId;
CurrentWorkUnitProperty.SyncGestalt();
_updateAvailableWorkUnits();
}
}
public static bool IsUserNameUnique(CswNbtResources Resources, string UserName)
{
CswNbtObjClassUser ExistingUserNode = Resources.Nodes.makeUserNodeFromUsername(UserName);
return(null == ExistingUserNode ||
false == CswTools.IsPrimaryKey(ExistingUserNode.NodeId));
}
public void onBeforeWriteDesignNode(CswNbtObjClassDesignNodeTypeProp DesignNTPNode)
{
// Copy value of 'Add To Template' to the Template
CswNbtNodePropText TemplateProp = DesignNTPNode.AttributeProperty[AttributeName.Template].AsText;
CswNbtNodePropRelationship AddToTemplateProp = DesignNTPNode.AttributeProperty[AttributeName.AddToTemplate].AsRelationship;
if (CswTools.IsPrimaryKey(AddToTemplateProp.RelatedNodeId))
{
CswNbtObjClassDesignNodeTypeProp SelectedProp = _CswNbtFieldResources.CswNbtResources.Nodes[AddToTemplateProp.RelatedNodeId];
if (null != SelectedProp)
{
string newTemplate = TemplateProp.Text;
if (false == string.IsNullOrEmpty(newTemplate))
{
newTemplate += " ";
}
newTemplate += CswNbtMetaData.MakeTemplateEntry(SelectedProp.RelationalNodeTypeProp.FirstPropVersionId.ToString());
TemplateProp.Text = newTemplate;
// Clear the selected value
AddToTemplateProp.RelatedNodeId = null;
AddToTemplateProp.CachedNodeName = string.Empty;
AddToTemplateProp.PendingUpdate = false;
} // if( null != SelectedProp )
} // if( CswTools.IsPrimaryKey( AddToTemplateProp.RelatedNodeId ) )
}
protected override void beforeWriteNodeLogic(bool Creating, bool OverrideUniqueValidation)
{
if (CswEnumTristate.False == this.QuantityEditable.Checked && false == CswTools.IsDouble(this.InitialQuantity.Quantity))
{
throw new CswDniException(CswEnumErrorType.Warning, "Cannot have a null Initial Quantity if Quantity Editable is unchecked.", "Cannot have a null Initial Quantity if Quantity Editable is unchecked.");
}
}//beforeWriteNode()
private void OnOwnerPropChange( CswNbtNodeProp NodeProp, bool Creating )
{
if( CswTools.IsPrimaryKey( Owner.RelatedNodeId ) )
{
archiveMatchingDocs();
}
}
} // LoadReport()
private static string _saveCrystalReport( CswNbtResources CswNbtResources, string ReportTempFileName, string ReportName, DataTable ReportTable )
{
CswTempFile TempFile = new CswTempFile( CswNbtResources );
string DestinationFileName = DateTime.Now.Ticks + "_" + CswTools.SafeFileName( ReportName ) + ".pdf";
string DestFilePath, DestWebPath;
TempFile.getFullTempFilePath( DestinationFileName, out DestFilePath, out DestWebPath );
DiskFileDestinationOptions dFileDOpts = new DiskFileDestinationOptions();
dFileDOpts.DiskFileName = DestFilePath;
ReportDocument oRD = new ReportDocument();
oRD.Load( ReportTempFileName );
oRD.SetDataSource( ReportTable );
ExportOptions eOpts = new ExportOptions();
eOpts = oRD.ExportOptions;
eOpts.ExportDestinationType = ExportDestinationType.DiskFile;
eOpts.ExportFormatType = ExportFormatType.PortableDocFormat;
eOpts.DestinationOptions = dFileDOpts;
oRD.Export();
oRD.Close();
return DestWebPath;
}
public CswNbtNodePropViewReference(CswNbtResources CswNbtResources, CswNbtNodePropData CswNbtNodePropData, CswNbtMetaDataNodeTypeProp CswNbtMetaDataNodeTypeProp, CswNbtNode Node)
: base(CswNbtResources, CswNbtNodePropData, CswNbtMetaDataNodeTypeProp, Node)
{
_ViewIdSubField = ((CswNbtFieldTypeRuleViewReference)_FieldTypeRule).ViewIdSubField;
_CachedViewNameSubField = ((CswNbtFieldTypeRuleViewReference)_FieldTypeRule).CachedViewNameSubField;
// Associate subfields with methods on this object, for SetSubFieldValue()
_SubFieldMethods.Add(_ViewIdSubField.Name, new Tuple <Func <dynamic>, Action <dynamic> >(() => ViewId,
x =>
{
if (CswTools.IsInteger(x))
{
ViewId = new CswNbtViewId(CswConvert.ToInt32(x));
}
else if (x is CswNbtViewId)
{
ViewId = x;
}
else if (string.IsNullOrEmpty(x))
{
ViewId = null;
}
else
{
throw new CswDniException(CswEnumErrorType.Error, "Invalid parameter", "CswNbtNodePropViewReference got an invalid parameter for setting ViewId: " + x.ToString());
}
}));
_SubFieldMethods.Add(_CachedViewNameSubField.Name, new Tuple <Func <dynamic>, Action <dynamic> >(() => CachedViewName, x => CachedViewName = CswConvert.ToString(x)));
}
public override void ReadDataRow(DataRow PropRow, Dictionary <string, Int32> NodeMap, Dictionary <Int32, Int32> NodeTypeMap)
{
if (PropRow.Table.Columns.Contains(_LowerSubField.ToXmlNodeName()))
{
string Val = CswTools.XmlRealAttributeName(PropRow[_LowerSubField.ToXmlNodeName()].ToString());
if (Val != string.Empty)
{
Lower = Convert.ToDouble(PropRow[_LowerSubField.ToXmlNodeName()].ToString());
}
}
if (PropRow.Table.Columns.Contains(_TargetSubField.ToXmlNodeName()))
{
string Val = CswTools.XmlRealAttributeName(PropRow[_TargetSubField.ToXmlNodeName()].ToString());
if (Val != string.Empty)
{
Target = Convert.ToDouble(PropRow[_TargetSubField.ToXmlNodeName()].ToString());
}
}
if (PropRow.Table.Columns.Contains(_UpperSubField.ToXmlNodeName()))
{
string Val = CswTools.XmlRealAttributeName(PropRow[_UpperSubField.ToXmlNodeName()].ToString());
if (Val != string.Empty)
{
Upper = Convert.ToDouble(PropRow[_UpperSubField.ToXmlNodeName()].ToString());
}
}
if (PropRow.Table.Columns.Contains(_LowerInclusiveSubField.ToXmlNodeName()))
{
LowerInclusive = CswConvert.ToBoolean(CswTools.XmlRealAttributeName(PropRow[_LowerInclusiveSubField.ToXmlNodeName()].ToString()));
}
if (PropRow.Table.Columns.Contains(_UpperInclusiveSubField.ToXmlNodeName()))
{
UpperInclusive = CswConvert.ToBoolean(CswTools.XmlRealAttributeName(PropRow[_UpperInclusiveSubField.ToXmlNodeName()].ToString()));
}
}
/// <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);
}
public override void update()
{
// This fixes what CswUpdateSchema_02G_Case30473 failed to do correctly
CswNbtMetaDataObjectClass GhsOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.GHSClass );
foreach( CswNbtMetaDataNodeType GhsNT in GhsOC.getNodeTypes() )
{
foreach( CswNbtObjClassGHS GhsNode in GhsNT.getNodes( false, true ) )
{
CswDelimitedString oldVals = GhsNode.Pictograms.Value;
CswDelimitedString newVals = new CswDelimitedString( CswNbtNodePropImageList.Delimiter );
foreach( string oldVal in oldVals )
{
if( oldVal.IndexOf( "/ghs/" ) >= 0 )
{
char testChar = oldVal[( oldVal.IndexOf( "/ghs/" ) + "/ghs/".Length )];
string newVal;
if( CswTools.IsNumeric( testChar ) )
{
newVal = oldVal.Replace( "/ghs/600/", "/ghs/512/" );
}
else
{
newVal = oldVal.Replace( "/ghs/", "/ghs/512/" );
}
newVals.Add( newVal );
}
}
GhsNode.Pictograms.Value = newVals;
GhsNode.postChanges( false );
} // foreach( CswNbtObjClassGHS GhsNode in GhsNT.getNodes( false, true ) )
} // foreach( CswNbtMetaDataNodeType GhsNT in GhsOC.getNodeTypes() )
} // update()
protected override void afterPromoteNodeLogic()
{
// ------------------------------------------------------------
// This logic from makeNewTab in CswNbtMetaData.cs
// ------------------------------------------------------------
if (CswTools.IsPrimaryKey(RelationalId))
{
Int32 TabId = RelationalId.PrimaryKey;
//CswTableUpdate TabsUpdate = _CswNbtResources.makeCswTableUpdate( "DesignNodeTypeTab_afterCreateNode_TabsUpdate", "nodetype_tabset" );
//DataTable TabsTable = TabsUpdate.getTable( "nodetypetabsetid", TabId );
//if( TabsTable.Rows.Count > 0 )
//{
// Version, if necessary
//NodeType = CheckVersioning( NodeType );
//DataRow Row = TabsTable.Rows[0];
DataRow Row = RelationalNodeTypeTab._DataRow;
if (null != Row)
{
Row["firsttabversionid"] = CswConvert.ToDbVal(TabId);
//TabsUpdate.update( TabsTable );
}
CswNbtMetaDataNodeTypeProp SaveNtp = NodeType.getNodeTypeProp(CswNbtObjClass.PropertyName.Save);
if (null != SaveNtp) //Case 29181 - Save prop on new tabs
{
//Note - when first creating a new NodeType and creating its first tab this will be null, which is expected
SaveNtp.updateLayout(CswEnumNbtLayoutType.Edit, false, TabId: TabId, DisplayColumn: 1, DisplayRow: Int32.MaxValue);
}
//} // if( TabsTable.Rows.Count > 0 )
} // if( CswTools.IsPrimaryKey( RelationalId ) )
} // afterPromoteNode()
public override void update()
{
// Fix existing barcode values
CswNbtMetaDataObjectClass LocationOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.LocationClass );
foreach( CswNbtMetaDataNodeType LocationNT in LocationOC.getNodeTypes() )
{
foreach( CswNbtObjClassLocation LocationNode in LocationNT.getNodes( false, false ) )
{
if( false == LocationNode.Barcode.Barcode.StartsWith( "LS" ) )
{
LocationNode.Barcode.setBarcodeValue( OverrideExisting: true );
}
if( LocationNode.Barcode.SequenceNumber == Int32.MinValue )
{
LocationNode.Barcode.resetSequenceNumber();
}
if( LocationNode.Barcode.Barcode.Length < 8 )
{
string NewBarcodeValue = "LS" + CswTools.PadInt( CswConvert.ToInt32( LocationNode.Barcode.SequenceNumber ), 6 );
LocationNode.Barcode.setBarcodeValueOverride( NewBarcodeValue, false );
}
LocationNode.postChanges( false );
} // foreach( CswNbtObjClassLocation LocationNode in LocationNT.getNodes( false, false ) )
} // foreach( CswNbtMetaDataNodeType LocationNT in LocationOC.getNodeTypes() )
} //Update()
public override void update()
{
CswNbtMetaDataFieldType QuantityFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType(CswEnumNbtFieldType.Quantity);
CswTableUpdate QtyUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate("QuantityVal_kgLiters_Update", "jct_nodes_props");
DataTable QtyPropsTable = QtyUpdate.getTable("where nodetypepropid in (select nodetypepropid from nodetype_props where fieldtypeid = " + QuantityFT.FieldTypeId + ") ");
foreach (DataRow Row in QtyPropsTable.Rows)
{
CswPrimaryKey UnitId = new CswPrimaryKey("nodes", CswConvert.ToInt32(Row["field1_fk"].ToString()));
CswNbtObjClassUnitOfMeasure CurrentUnit = _CswNbtSchemaModTrnsctn.Nodes[UnitId];
if (null != CurrentUnit &&
(CurrentUnit.UnitType.Value == CswEnumNbtUnitTypes.Weight.ToString() ||
CurrentUnit.UnitType.Value == CswEnumNbtUnitTypes.Volume.ToString()))
{
Double Quantity = CswConvert.ToDouble(Row["field1_numeric"].ToString());
if (CswTools.IsDouble(Quantity))
{
CswNbtObjClassUnitOfMeasure kgUnit = getUnit("kg", "Unit_Weight");
CswNbtObjClassUnitOfMeasure LitersUnit = getUnit("Liters", "Unit_Volume");
if (null != kgUnit && CurrentUnit.UnitType.Value == kgUnit.UnitType.Value)
{
Double Val_kg = Quantity * CurrentUnit.ConversionFactor.RealValue / kgUnit.ConversionFactor.RealValue;
Row["field2_numeric"] = Val_kg.ToString();
}
if (null != LitersUnit && CurrentUnit.UnitType.Value == LitersUnit.UnitType.Value)
{
Double Val_Liters = Quantity * CurrentUnit.ConversionFactor.RealValue / LitersUnit.ConversionFactor.RealValue;
Row["field3_numeric"] = Val_Liters.ToString();
}
}
}
}
QtyUpdate.update(QtyPropsTable);
}
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()
public override void ReadDataRow(DataRow PropRow, Dictionary <string, Int32> NodeMap, Dictionary <Int32, Int32> NodeTypeMap)
{
Red = CswTools.XmlRealAttributeName(PropRow[_RedSubField.ToXmlNodeName()].ToString());
Yellow = CswTools.XmlRealAttributeName(PropRow[_YellowSubField.ToXmlNodeName()].ToString());
Blue = CswTools.XmlRealAttributeName(PropRow[_BlueSubField.ToXmlNodeName()].ToString());
White = CswTools.XmlRealAttributeName(PropRow[_WhiteSubField.ToXmlNodeName()].ToString());
}
/// <summary>
/// Determines if a set of values are valid for unit conversion.
/// </summary>
private void _validateValuesForConversion(Double ValueToConvert, Double OldConversionFactor, Double NewConversionFactor, Double SpecificGravity)
{
string ErrorMessage = String.Empty;
if (false == CswTools.IsDouble(ValueToConvert))
{
ErrorMessage = "Value to convert is undefined: " + ValueToConvert;
}
else if (false == CswTools.IsDouble(OldConversionFactor) || OldConversionFactor <= 0)
{
ErrorMessage = "Current unit's conversion factor is invalid: " + OldConversionFactor;
}
else if (false == CswTools.IsDouble(NewConversionFactor) || NewConversionFactor <= 0)
{
ErrorMessage = "New unit's conversion factor is invalid: " + NewConversionFactor;
}
else if (false == CswTools.IsDouble(SpecificGravity) || SpecificGravity <= 0)
{
ErrorMessage = "Material's specific gravity is invalid: " + SpecificGravity;
}
if (false == String.IsNullOrEmpty(ErrorMessage))
{
throw new CswDniException(CswEnumErrorType.Warning, ErrorMessage, "Unit conversion failed.");
}
}
public void saveContainerActions(ContainerData.ReconciliationRequest Request)
{
if (null != Request.ContainerActions)
{
foreach (ContainerData.ReconciliationActions Action in Request.ContainerActions)
{
if (Action.Action == CswEnumNbtContainerLocationActionOptions.MarkMissing.ToString())
{
_createNotScannedContainerLocation(Action, CswEnumNbtContainerLocationTypeOptions.Missing);
}
else
{
CswPrimaryKey ContLocNodeId = CswConvert.ToPrimaryKey(Action.ContainerLocationId);
if (CswTools.IsPrimaryKey(ContLocNodeId))
{
CswNbtObjClassContainerLocation ContLocNode = _CswNbtResources.Nodes.GetNode(ContLocNodeId);
ContLocNode.Action.Value = Action.Action;
ContLocNode.ActionByUser.RelatedNodeId = _CswNbtResources.CurrentNbtUser.UserId;
ContLocNode.postChanges(false);
}
else if (Action.Action == CswEnumNbtContainerLocationActionOptions.Ignore.ToString())
{
_createNotScannedContainerLocation(Action, CswEnumNbtContainerLocationTypeOptions.Ignore);
}
}
}
}
}
} // ToJSON()
public override void ReadDataRow(DataRow PropRow, Dictionary <string, Int32> NodeMap, Dictionary <Int32, Int32> NodeTypeMap)
{
CswCommaDelimitedString NewValue = new CswCommaDelimitedString();
NewValue.FromString(CswTools.XmlRealAttributeName(PropRow[_ValueSubField.ToXmlNodeName()].ToString()));
Value = NewValue;
}
private void onQuantityPropChange(CswNbtNodeProp Prop)
{
if (CswTools.IsPrimaryKey(Quantity.UnitId) && TotalDispensed.UnitId != Quantity.UnitId)
{
TotalDispensed.UnitId = Quantity.UnitId;
}
}
//mark any property references to this property on other nodes as pending update
private void _markExternalPropRefsDirty(CswNbtNodePropWrapper CurrentProp)
{
if (CswTools.IsPrimaryKey(CurrentProp.NodeId))
{
CswNbtFieldTypeRulePropertyReference PropRefFTR = (CswNbtFieldTypeRulePropertyReference)_CswNbtResources.MetaData.getFieldTypeRule(CswEnumNbtFieldType.PropertyReference);
CswEnumNbtPropColumn PropRefColumn = PropRefFTR.CachedValueSubField.Column;
string SQL = @"update jct_nodes_props
set pendingupdate = '" + CswConvert.ToDbVal(true) + @"',
" + PropRefColumn.ToString() + @" = ''
where jctnodepropid in (select j.jctnodepropid
from jct_nodes_props j
join nodes n on n.nodeid = j.nodeid
join nodetype_props p on p.nodetypepropid = j.nodetypepropid
join field_types f on p.fieldtypeid = f.fieldtypeid
left outer join jct_nodes_props jntp on (jntp.nodetypepropid = p.fkvalue
and jntp.nodeid = n.nodeid
and jntp.field1_fk = " + CurrentProp.NodeId.PrimaryKey.ToString() + @")
left outer join (select jx.jctnodepropid, ox.objectclasspropid, jx.nodeid
from jct_nodes_props jx
join nodetype_props px on jx.nodetypepropid = px.nodetypepropid
join object_class_props ox on px.objectclasspropid = ox.objectclasspropid
where jx.field1_fk = " + CurrentProp.NodeId.PrimaryKey.ToString() + @") jocp
on (jocp.objectclasspropid = p.fkvalue
and jocp.nodeid = n.nodeid)
where f.fieldtype = 'PropertyReference'
and ((lower(p.fktype) = 'nodetypepropid' and jntp.jctnodepropid is not null)
or (lower(p.fktype) = 'objectclasspropid' and jocp.jctnodepropid is not null))
and ((lower(p.valueproptype) = 'nodetypepropid' and p.valuepropid = " + CurrentProp.NodeTypePropId.ToString() + @")
or (lower(p.valueproptype) = 'objectclasspropid' and p.valuepropid = " + CurrentProp.ObjectClassPropId + @")))";
// We're not doing this in a CswTableUpdate because it might be a large operation,
// and we don't care about auditing for this change.
_CswNbtResources.execArbitraryPlatformNeutralSql(SQL);
}
}
