public override void update()
{
CswNbtMetaDataNodeType ChemicalNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Chemical" );
if( null != ChemicalNT )
{
CswNbtView MHCView = _CswNbtSchemaModTrnsctn.makeNewView( "Missing Hazard Classes", NbtViewVisibility.Global );
MHCView.Category = "Materials";
MHCView.Visibility = NbtViewVisibility.Global;
MHCView.ViewMode = NbtViewRenderingMode.Tree;
CswNbtViewRelationship RootRel = MHCView.AddViewRelationship( ChemicalNT, true );
CswNbtMetaDataNodeTypeProp SpecialFlagsNTP = ChemicalNT.getNodeTypeProp( "Special Flags" );
CswNbtViewProperty SpecialFlagsVP = MHCView.AddViewProperty( RootRel, SpecialFlagsNTP );
MHCView.AddViewPropertyFilter( SpecialFlagsVP,
CswNbtPropFilterSql.PropertyFilterConjunction.And,
CswNbtPropFilterSql.FilterResultMode.Hide,
CswNbtSubField.SubFieldName.Value,
CswNbtPropFilterSql.PropertyFilterMode.NotContains,
"Not Reportable");
CswNbtMetaDataNodeTypeProp HazardClassesNTP = ChemicalNT.getNodeTypeProp( "Hazard Classes" );
CswNbtViewProperty HazardClassesVP = MHCView.AddViewProperty( RootRel, HazardClassesNTP );
MHCView.AddViewPropertyFilter( HazardClassesVP,
CswNbtPropFilterSql.PropertyFilterConjunction.And,
CswNbtPropFilterSql.FilterResultMode.Hide,
CswNbtSubField.SubFieldName.Value,
CswNbtPropFilterSql.PropertyFilterMode.Null);
MHCView.save();
}
}//Update()
public override void update()
{
CswNbtMetaDataObjectClass DocumentOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.DocumentClass );
CswNbtMetaDataNodeType SDSNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( new CswNbtWcfMetaDataModel.NodeType( DocumentOC )
{
NodeTypeName = "SDS Document",
Category = "Materials"
} );
CswNbtMetaDataNodeTypeProp TradeNameNTP = SDSNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Owner );
CswNbtMetaDataNodeType ChemicalNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Chemical" );
if( null != ChemicalNT )
{
TradeNameNTP.SetFK( NbtViewRelatedIdType.NodeTypeId.ToString(), ChemicalNT.NodeTypeId );
}
TradeNameNTP.PropName = "Tradename";
CswNbtMetaDataNodeTypeProp RevisionDateNTP =
_CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp(
SDSNT,
_CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.DateTime ),
"Revision Date" )
);
CswNbtMetaDataNodeTypeProp LanguageNTP = SDSNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Language );
LanguageNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add, true, SDSNT.getFirstNodeTypeTab().TabId );
CswNbtMetaDataNodeTypeProp FormatNTP = SDSNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Format );
FormatNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add, true, SDSNT.getFirstNodeTypeTab().TabId );
SDSNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassDocument.PropertyName.Title ) );
foreach( CswNbtMetaDataNodeType DocNT in DocumentOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp DocClassNTP = DocNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.DocumentClass );
DocClassNTP.removeFromAllLayouts();
}
} //Update()
public void CopyPropToNewPropRow(CswNbtMetaDataNodeTypeProp NewProp) //DataRow NewPropRow )
{
CswTableSelect MappingSelect = _CswNbtMetaDataResources.CswNbtResources.makeCswTableSelect("PropCollDataRelational_mapping", "jct_dd_ntp");
DataTable MappingTable = MappingSelect.getTable();
foreach (DataColumn Column in _ObjectClassPropRow.Table.Columns)
{
string ColumnName = Column.ColumnName;
if (ColumnName != "display_rowadd" &&
ColumnName != "display_coladd" &&
ColumnName != "setvalonadd" &&
ColumnName != "defaultvalueid")
{
if (false == _ObjectClassPropRow.IsNull(ColumnName))
{
if (_CswNbtMetaDataResources.CswNbtResources.DataDictionary.isColumnDefined("nodetype_props", Column.ColumnName))
{
_CswNbtMetaDataResources.CswNbtResources.DataDictionary.setCurrentColumn("nodetype_props", Column.ColumnName);
DataRow MappingRow = MappingTable.Rows.Cast <DataRow>()
.FirstOrDefault(r => NewProp.DesignNode.NodeType.getNodeTypePropIds().Contains(CswConvert.ToInt32(r["nodetypepropid"])) &&
CswConvert.ToInt32(r["datadictionaryid"]) == _CswNbtMetaDataResources.CswNbtResources.DataDictionary.TableColId);
if (null != MappingRow)
{
NewProp.DesignNode.Node.Properties[CswConvert.ToInt32(MappingRow["nodetypepropid"])].SetSubFieldValue((CswEnumNbtSubFieldName)MappingRow["subfieldname"].ToString(), _ObjectClassPropRow[ColumnName]);
}
} // if( _CswNbtMetaDataResources.CswNbtResources.DataDictionary.isColumnDefined( "nodetype_props", Column.ColumnName ) )
} // if( false == _ObjectClassPropRow.IsNull( ColumnName ) )
} // if( ColumnName != "displayrowadd" && ... )
} // foreach( DataColumn Column in _ObjectClassPropRow.Table.Columns )
} // CopyPropToNewPropRow()
public override void update()
{
CswNbtMetaDataNodeType sizeNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Size" );
if( null != sizeNT )
{
CswNbtMetaDataNodeTypeProp containerTypeNTP = sizeNT.getNodeTypeProp( "Container Type" );
if( null != containerTypeNTP )
{
containerTypeNTP.ListOptions = "Aboveground Tank [A]," +
"Bag [J]," +
"Belowground Tank [B]," +
"Box [K]," +
"Can [F]," +
"Carboy [G]," +
"Cylinder [L]," +
"Fiberdrum [I]," +
"Glass Bottle or Jug [M]," +
"Plastic [N]," +
"Plastic or Non-Metal Drum [E]," +
"Steel Drum [D]," +
"Tank Inside Building [C]," +
"Tank Wagon [P]," +
"Tote Bin [O]";
}
}
}//Update()
/// <summary>
/// Update logic
/// </summary>
public override void update()
{
CswNbtMetaDataNodeType TimeNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Unit (Time)" );
if( null != TimeNT )
{
foreach( CswNbtObjClassUnitOfMeasure TimeNode in TimeNT.getNodes( false, false ) )
{
if( "Months" == TimeNode.Name.Text )
{
//According to Google, 1 month = 30.4368 days (based on averages, I'm assuming)
TimeNode.ConversionFactor.Base = 3.285496;
TimeNode.ConversionFactor.Exponent = -2;
TimeNode.postChanges( false );
}
}
}
CswNbtMetaDataObjectClass MaterialOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.MaterialClass );
foreach( CswNbtMetaDataNodeType MaterialNt in MaterialOc.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp SpecificGravityNtp = MaterialNt.getNodeTypePropByObjectClassProp( CswNbtObjClassMaterial.PropertyName.SpecificGravity );
if( null != SpecificGravityNtp )
{
SpecificGravityNtp.Attribute1 = CswConvert.ToDbVal( true ).ToString();
}
}
}
/// <summary>
/// Update logic
/// </summary>
public override void update()
{
CswNbtMetaDataObjectClass SizeOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.SizeClass );
// moved to RunBeforeEveryExecutionOfUpdater_01OC
//CswNbtMetaDataObjectClassProp UnitCountOcp = _CswNbtSchemaModTrnsctn.createObjectClassProp( new CswNbtWcfMetaDataModel.ObjectClassProp( SizeOc )
//{
// PropName = CswNbtObjClassSize.PropertyName.UnitCount,
// FieldType = CswNbtMetaDataFieldType.NbtFieldType.Number,
// IsRequired = true,
// SetValOnAdd = true,
// NumberMinValue = 1,
// NumberPrecision = 0
//} );
CswNbtMetaDataNodeType SizeNt = SizeOc.FirstNodeType;
if( null != SizeNt )
{
CswNbtMetaDataNodeTypeProp UnitCountNtp = SizeNt.getNodeTypePropByObjectClassProp( CswNbtObjClassSize.PropertyName.UnitCount );
UnitCountNtp.DefaultValue.AsNumber.Value = 1;
}
foreach( CswNbtObjClassSize SizeNode in SizeOc.getNodes( false, false ) )
{
SizeNode.UnitCount.Value = 1;
SizeNode.postChanges( false );
}
}
public override void update()
{
//Add TierII Reporting Action
_CswNbtSchemaModTrnsctn.createAction( CswNbtActionName.Tier_II_Reporting, true, "", "Materials" );
_CswNbtSchemaModTrnsctn.createModuleActionJunction( CswNbtModuleName.CISPro, CswNbtActionName.Tier_II_Reporting );
//Add Trade Secret Chemical Prop
CswNbtMetaDataNodeType ChemicalNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Chemical" );
if( null != ChemicalNT )
{
CswNbtMetaDataNodeTypeProp ChemicalSpecialFlagsNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp(ChemicalNT.NodeTypeId, "Special Flags");
if( null != ChemicalSpecialFlagsNTP )
{
ChemicalSpecialFlagsNTP.ListOptions = "EHS,Waste,Not Reportable,Trade Secret";
}
}
//Add Container fire reporting props to Audit Table
CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.ContainerClass );
CswNbtMetaDataNodeType ContainerNT = ContainerOC.FirstNodeType;
if( null != ContainerNT )
{
CswNbtMetaDataNodeTypeProp StorageTemperatureNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp(ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.StorageTemperature);
StorageTemperatureNTP.AuditLevel = AuditLevel.PlainAudit;
CswNbtMetaDataNodeTypeProp StoragePressureNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp(ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.StoragePressure);
StoragePressureNTP.AuditLevel = AuditLevel.PlainAudit;
CswNbtMetaDataNodeTypeProp UseTypeNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp(ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.UseType);
UseTypeNTP.AuditLevel = AuditLevel.PlainAudit;
}
}//Update()
public override void update()
{
// For each Location Node type that isn't Site, the Full Path should be Path + > + Name
// and for Sites, the Full Path should be Name.
CswNbtMetaDataObjectClass LocationOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.LocationClass);
foreach (CswNbtMetaDataNodeType LocationNT in LocationOC.getNodeTypes())
{
CswNbtMetaDataNodeTypeProp FullPathNTP = LocationNT.getNodeTypePropByObjectClassProp(CswNbtObjClassLocation.PropertyName.FullPath);
CswNbtMetaDataNodeTypeProp LocationNTP = LocationNT.getNodeTypePropByObjectClassProp(CswNbtObjClassLocation.PropertyName.Location);
CswNbtMetaDataNodeTypeProp NameNTP = LocationNT.getNodeTypePropByObjectClassProp(CswNbtObjClassLocation.PropertyName.Name);
if (null != FullPathNTP)
{
// Set the value of the property
if (LocationNT.NodeTypeName != "Site")
{
FullPathNTP.DesignNode.AttributeProperty[CswNbtFieldTypeRuleComposite.AttributeName.Template].AsText.Text = "{" + LocationNTP.PropId + "} > " + "{" + NameNTP.PropId + "}";
}
else
{
FullPathNTP.DesignNode.AttributeProperty[CswNbtFieldTypeRuleComposite.AttributeName.Template].AsText.Text = "{" + NameNTP.PropId + "}";
}
// Set the layout position and remove from the add layout
FullPathNTP.removeFromLayout(CswEnumNbtLayoutType.Add);
FullPathNTP.updateLayout(CswEnumNbtLayoutType.Edit, LocationNTP, true);
}
}
_setLocationsPendingUpdate();
}
protected override void OnEnable()
{
CswNbtMetaDataObjectClass UserOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.UserClass);
foreach (CswNbtMetaDataNodeType UserNT in UserOC.getNodeTypes())
{
CswNbtMetaDataNodeTypeProp UserJurisdictionNTP = UserNT.getNodeTypePropByObjectClassProp(CswNbtObjClassUser.PropertyName.Jurisdiction);
_CswNbtResources.Modules.ShowProp(UserJurisdictionNTP);
}
//Case 27862 - show...
// All CISPro roles and users
// Unit of measure and work units views
//_CswNbtResources.Modules.ToggleRoleNodes()
_CswNbtResources.Modules.ToggleRoleNodes(false, "cispro");
_CswNbtResources.Modules.ToggleUserNodes(false, "cispro");
_CswNbtResources.Modules.ToggleView(false, "Units of Measurement", CswEnumNbtViewVisibility.Global);
//CISPro_Request_Fulfiller Role/User gets turned on by the above line, but should only be on if Containers is enabled
_CswNbtResources.Modules.ToggleRoleNodes(true, "request_fulfiller");
_CswNbtResources.Modules.ToggleUserNodes(true, "request_fulfiller");
_CswNbtResources.Modules.ToggleScheduledRule(CswEnumNbtScheduleRuleNames.ExtChemDataSync, Disabled: false);
_CswNbtResources.Modules.ToggleScheduledRule(CswEnumNbtScheduleRuleNames.TierII, Disabled: false);
//Mail Reports
_CswNbtResources.Modules.ToggleNode(false, "Deficient Inventory Levels", CswEnumNbtObjectClass.MailReportClass);
}
public override void update()
{
// add active to constituent grid
CswNbtMetaDataObjectClass ChemicalOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ChemicalClass );
CswNbtMetaDataObjectClass ComponentOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.MaterialComponentClass );
foreach( CswNbtMetaDataNodeType ChemicalNT in ChemicalOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp ChemicalComponentsNTP = ChemicalNT.getNodeTypeProp( "Components" );
if( null != ChemicalComponentsNTP )
{
CswNbtView ComponentsView = _CswNbtSchemaModTrnsctn.restoreView( ChemicalComponentsNTP.ViewId );
if( ComponentsView.Root.ChildRelationships.Count > 0 )
{
CswNbtViewRelationship ChemRel = ComponentsView.Root.ChildRelationships[0];
if( ChemRel.ChildRelationships.Count > 0 )
{
CswNbtViewRelationship CompRel = ChemRel.ChildRelationships[0];
Int32 order = 1;
foreach( CswNbtViewProperty vp in CompRel.Properties )
{
vp.Order = order;
order++;
}
ComponentsView.AddViewProperty( CompRel, ComponentOC.getObjectClassProp( CswNbtObjClassMaterialComponent.PropertyName.Active ), order );
}
}
ComponentsView.save();
} // if( null != ChemicalComponentsNTP )
} // foreach( CswNbtMetaDataNodeType ChemicalNT in ChemicalOC.getNodeTypes() )
} // update()
public override void update()
{
//New Document NT
CswNbtMetaDataObjectClass ReceiptLotOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ReceiptLotClass );
CswNbtMetaDataObjectClass CofADocOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.CofADocumentClass );
CswNbtMetaDataNodeType CofANT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "C of A Document" ) ??
_CswNbtSchemaModTrnsctn.MetaData.makeNewNodeTypeDeprecated( CofADocOC.ObjectClassId, "C of A Document", "Materials" );
_CswNbtSchemaModTrnsctn.createModuleNodeTypeJunction( CswEnumNbtModuleName.CofA, CofANT.NodeTypeId );
//Default Title
CswNbtMetaDataNodeTypeProp TitleNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Title );
TitleNTP.DefaultValue.AsText.Text = "Certificate of Analysis";
TitleNTP.removeFromLayout( CswEnumNbtLayoutType.Add );
//Set Owner FK to ReceiptLot OC (This needs to be done explicitly for the NTP - see Case 26605)
CswNbtMetaDataNodeTypeProp OwnerNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Owner );
OwnerNTP.PropName = "Receipt Lot";
OwnerNTP.SetFK( CswEnumNbtViewRelatedIdType.ObjectClassId.ToString(), ReceiptLotOC.ObjectClassId );
//Set Prop Filters (This needs to be done explicitly for the NTP - see Case 26605)
CswNbtMetaDataNodeTypeProp FileTypeNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.FileType );
CswNbtMetaDataNodeTypeProp FileNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.File );
FileNTP.setFilter( FileTypeNTP, FileTypeNTP.getFieldTypeRule().SubFields.Default, CswEnumNbtFilterMode.Equals, CswNbtPropertySetDocument.CswEnumDocumentFileTypes.File );
CswNbtMetaDataNodeTypeProp LinkNTP = CofANT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Link );
LinkNTP.setFilter( FileTypeNTP, FileTypeNTP.getFieldTypeRule().SubFields.Default, CswEnumNbtFilterMode.Equals, CswNbtPropertySetDocument.CswEnumDocumentFileTypes.Link );
//NT Permission
CswNbtObjClassRole RoleNode = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "CISPro_Admin" );
if( null != RoleNode )
{
_CswNbtSchemaModTrnsctn.Permit.set( NTPermissions, CofANT, RoleNode, true );
}
} // update()
} // getBulkEditProperties()
public static void DownloadBulkEditData(ICswResources CswResources, BulkEditDownload ret, BulkEditParams Params)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswNbtMetaDataNodeType NodeType = NbtResources.MetaData.getNodeType(Params.NodeTypeId);
if (null != NodeType)
{
ret.CsvData = new DataTable();
ret.CsvData.Columns.Add("nodeid");
foreach (Int32 PropId in Params.PropIds)
{
CswNbtMetaDataNodeTypeProp Prop = NodeType.getNodeTypeProp(PropId);
if (Prop.getFieldTypeRule().SubFields.Count > 1)
{
foreach (CswNbtSubField SubField in Prop.getFieldTypeRule().SubFields)
{
ret.CsvData.Columns.Add(Prop.PropName + " " + SubField.Name);
}
}
else
{
ret.CsvData.Columns.Add(Prop.PropName);
}
}
CswNbtView View = NbtResources.ViewSelect.restoreView(new CswNbtViewId(Params.ViewId));
ICswNbtTree Tree = NbtResources.Trees.getTreeFromView(View, RequireViewPermissions: true, IncludeSystemNodes: false, IncludeHiddenNodes: false);
_recurseBulkEditData(NodeType, Tree, ret, Params);
}
} // DownloadBulkEditData()
private void _removeTargetsNotMatchingSelectedParent()
{
//If only one Parent NT is allowed (and selected), cycle through selected Target NTs and remove any that aren't related to the selected Parent NT
if( Node.getNodeType().getFirstVersionNodeType().NodeTypeName == InspectionGeneratorNodeTypeName &&
ParentType.SelectMode == CswEnumNbtPropertySelectMode.Single &&
ParentType.SelectedNodeTypeIds.Count > 0 )
{
CswCommaDelimitedString InvalidNodeTypes = new CswCommaDelimitedString();
foreach( Int32 InspectionDesignNodeTypeId in TargetType.SelectedNodeTypeIds.ToIntCollection() )
{
CswNbtMetaDataNodeType InspectionDesignNt = _CswNbtResources.MetaData.getNodeType( InspectionDesignNodeTypeId );
if( null != InspectionDesignNt )
{
Int32 InspectionTargetNTId = CswConvert.ToInt32( ParentType.SelectedNodeTypeIds[0] );
CswNbtMetaDataNodeTypeProp DesignTargetNtp = InspectionDesignNt.getNodeTypePropByObjectClassProp( CswNbtObjClassInspectionDesign.PropertyName.Target );
if( _fkIsValid( DesignTargetNtp ) && InspectionTargetNTId != DesignTargetNtp.FKValue )
{
InvalidNodeTypes.Add( InspectionDesignNt.NodeTypeName );
TargetType.SelectedNodeTypeIds.Remove( InspectionDesignNt.NodeTypeId.ToString() );
}
}
}
if( InvalidNodeTypes.Count > 0 && false == Owner.wasAnySubFieldModified() )
{
throw new CswDniException( CswEnumErrorType.Warning,
"Unable to add the following " + TargetType.PropName + " options because they do not belong to " + Owner.CachedNodeName +
": <br/>" + InvalidNodeTypes.ToString().Replace( ",", "<br/>" ),
"Invalid Target Type options selected: " + InvalidNodeTypes );
}
}
}
} // GeneratedNodeCount
public CswNbtView GetGeneratedTargetsView( DateTime TargetDay )
{
CswNbtView View = new CswNbtView( _CswNbtResources );
View.ViewName = "Generated Node Count";
CswNbtMetaDataNodeType TargetNT = _CswNbtResources.MetaData.getNodeType( CswConvert.ToInt32( TargetType.SelectedNodeTypeIds[0] ) );
CswNbtMetaDataNodeTypeProp GeneratorNTP = TargetNT.getNodeTypePropByObjectClassProp( CswNbtPropertySetGeneratorTarget.PropertyName.Generator );
CswNbtMetaDataNodeTypeProp CreatedDateNTP = TargetNT.getNodeTypePropByObjectClassProp( CswNbtPropertySetGeneratorTarget.PropertyName.CreatedDate );
CswNbtViewRelationship TargetRel = View.AddViewRelationship( TargetNT, false );
View.AddViewPropertyAndFilter( TargetRel,
GeneratorNTP,
Conjunction: CswEnumNbtFilterConjunction.And,
ResultMode: CswEnumNbtFilterResultMode.Hide,
Value: this.NodeId.PrimaryKey.ToString(),
SubFieldName: ( (CswNbtFieldTypeRuleRelationship) GeneratorNTP.getFieldTypeRule() ).NodeIDSubField.Name,
FilterMode: CswEnumNbtFilterMode.Equals );
if( DateTime.MinValue != TargetDay )
{
View.AddViewPropertyAndFilter( TargetRel,
CreatedDateNTP,
Conjunction: CswEnumNbtFilterConjunction.And,
ResultMode: CswEnumNbtFilterResultMode.Hide,
Value: TargetDay.Date.ToString(),
FilterMode: CswEnumNbtFilterMode.Equals );
}
return View;
}
internal void SetPPENodeTypeProp(string ListOptions, string Delimiter = ",", int HideThreshold = 5)
{
CswNbtMetaDataNodeType ChemicalNT = _CswNbtResources.MetaData.getNodeType("Chemical");
if (ChemicalNT != null)
{
CswNbtMetaDataNodeTypeProp PPENTP = _CswNbtResources.MetaData.getNodeTypeProp(ChemicalNT.NodeTypeId, "PPE");
if (PPENTP != null)
{
_ChangedNodeTypePropListOptions.Add(PPENTP.PropId, ListOptions);
_ChangedNodeTypePropExtended.Add(PPENTP.PropId, Delimiter);
_ChangedNodeTypePropMaxValue.Add(PPENTP.PropId, HideThreshold);
//PPENTP.ListOptions = ListOptions;
//PPENTP.Extended = Delimiter;
//PPENTP.MaxValue = HideThreshold;
CswNbtFieldTypeAttribute ListOptionsAttr = PPENTP.getFieldTypeRule().getAttributes().FirstOrDefault(a => a.Column == CswEnumNbtPropertyAttributeColumn.Listoptions);
CswNbtFieldTypeAttribute ExtendedAttr = PPENTP.getFieldTypeRule().getAttributes().FirstOrDefault(a => a.Column == CswEnumNbtPropertyAttributeColumn.Extended);
CswNbtFieldTypeAttribute MaxValueAttr = PPENTP.getFieldTypeRule().getAttributes().FirstOrDefault(a => a.Column == CswEnumNbtPropertyAttributeColumn.Numbermaxvalue);
PPENTP.DesignNode.AttributeProperty[ListOptionsAttr.Name].SetSubFieldValue(ListOptionsAttr.SubFieldName, ListOptions);
PPENTP.DesignNode.AttributeProperty[ExtendedAttr.Name].SetSubFieldValue(ExtendedAttr.SubFieldName, Delimiter);
PPENTP.DesignNode.AttributeProperty[MaxValueAttr.Name].SetSubFieldValue(MaxValueAttr.SubFieldName, HideThreshold);
PPENTP.DesignNode.postChanges(false);
}
}
}
public override void update()
{
CswNbtMetaDataObjectClass MailReportOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.MailReportClass );
foreach( CswNbtMetaDataNodeType MailReportNT in MailReportOC.getNodeTypes() )
{
// remove 'Nodes to Report' from all layouts
CswNbtMetaDataNodeTypeProp NodesToReportNTP = MailReportNT.getNodeTypePropByObjectClassProp( CswNbtObjClassMailReport.PropertyName.NodesToReport );
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.removePropFromAllLayouts( NodesToReportNTP );
// remove Run Status from Add layout
CswNbtMetaDataNodeTypeProp RunStatusNTP = MailReportNT.getNodeTypePropByObjectClassProp( CswNbtObjClassMailReport.PropertyName.RunStatus );
RunStatusNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
// set Target Type and Event to be conditional on Type = View
CswNbtMetaDataNodeTypeProp TypeNTP = MailReportNT.getNodeTypePropByObjectClassProp( CswNbtObjClassMailReport.PropertyName.Type );
CswNbtMetaDataNodeTypeProp TargetTypeNTP = MailReportNT.getNodeTypePropByObjectClassProp( CswNbtObjClassMailReport.PropertyName.TargetType );
CswNbtMetaDataNodeTypeProp EventNTP = MailReportNT.getNodeTypePropByObjectClassProp( CswNbtObjClassMailReport.PropertyName.Event );
TargetTypeNTP.setFilter( TypeNTP, TypeNTP.getFieldTypeRule().SubFields.Default, CswNbtPropFilterSql.PropertyFilterMode.Equals, CswNbtObjClassMailReport.TypeOptionView );
EventNTP.setFilter( TypeNTP, TypeNTP.getFieldTypeRule().SubFields.Default, CswNbtPropFilterSql.PropertyFilterMode.Equals, CswNbtObjClassMailReport.TypeOptionView );
// add help text to Report View
CswNbtMetaDataNodeTypeProp ReportViewNTP = MailReportNT.getNodeTypePropByObjectClassProp( CswNbtObjClassMailReport.PropertyName.ReportView );
ReportViewNTP.HelpText = "For 'Exists' events, a report is generated if the view returns any results that match the Target Type. For 'Edit' events, a report is only generated if one of the properties in the view was modified.";
// set target type and event for existing mail reports
foreach( CswNbtObjClassMailReport MailReportNode in MailReportNT.getNodes( false, true ) )
{
if( CswNbtObjClassMailReport.TypeOptionView == MailReportNode.Type.Value &&
0 == MailReportNode.TargetType.SelectedNodeTypeIds.Count )
{
CswNbtView View = _CswNbtSchemaModTrnsctn.restoreView( MailReportNode.ReportView.ViewId );
if( View.Root.ChildRelationships.Count > 0 )
{
CswNbtViewRelationship RootRel = View.Root.ChildRelationships[0];
if( RootRel.SecondType == NbtViewRelatedIdType.NodeTypeId )
{
MailReportNode.TargetType.SelectedNodeTypeIds.Add( RootRel.SecondId.ToString() );
}
else
{
CswNbtMetaDataObjectClass RootOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( RootRel.SecondId.ToString() );
if( null != RootOC.FirstNodeType )
{
MailReportNode.TargetType.SelectedNodeTypeIds.Add( RootOC.FirstNodeType.NodeTypeId.ToString() );
}
}
}
}
if( MailReportNode.Event.Empty )
{
MailReportNode.Event.Value = CswNbtObjClassMailReport.EventOption.Exists.ToString();
}
MailReportNode.postChanges( false );
} // foreach( CswNbtObjClassMailReport MailReportNode in MailReportNT.getNodes( false, true ) )
} // foreach( CswNbtMetaDataNodeType MailReportNT in MailReportOC.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()
}//_addMaterialComponentPermissions()
private void _addTitleToDocumentsView()
{
CswNbtMetaDataPropertySet MaterialPS = _CswNbtSchemaModTrnsctn.MetaData.getPropertySet( CswEnumNbtPropertySetName.MaterialSet );
foreach( CswNbtMetaDataObjectClass MaterialOC in MaterialPS.getObjectClasses() )
{
foreach( CswNbtMetaDataNodeType MaterialNT in MaterialOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp DocumentsNTP = MaterialNT.getNodeTypePropByObjectClassProp( CswNbtPropertySetMaterial.PropertyName.Documents );
CswNbtMetaDataNodeType MaterialDocumentNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Material Document" );
if( null != MaterialDocumentNT )
{
CswNbtMetaDataObjectClass DocumentOC = MaterialDocumentNT.getObjectClass();
CswNbtMetaDataNodeTypeProp[] propsToAdd =
{
MaterialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Title )
};
CswNbtView DocumentsView = _CswNbtSchemaModTrnsctn.restoreView( DocumentsNTP.ViewId );
if( null != DocumentsView )
{
_addPropertiesToView( DocumentsView, DocumentsView.Root.ChildRelationships, DocumentOC, MaterialDocumentNT, propsToAdd );
}
}
}
}
}
}//_createNodeType()
private CswNbtViewId _createMaterialPropertyView(CswNbtMetaDataNodeTypeProp materialprop, string nodetype)
{
CswNbtViewId ViewId = null;
CswNbtView View = _CswNbtSchemaModTrnsctn.makeSafeView("CertDefMaterialProp_" + nodetype, CswEnumNbtViewVisibility.Property);
if (nodetype == "CertDef EP")
{
CswNbtMetaDataObjectClass EPOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.EnterprisePartClass);
View.AddViewRelationship(EPOC, true);
materialprop.DesignNode.AttributeProperty[CswEnumNbtPropertyAttributeName.Target].AsMetaDataList.setValue(CswEnumNbtViewRelatedIdType.ObjectClassId, EPOC.ObjectClassId);
}
else
{
CswNbtMetaDataPropertySet MaterialPS = _CswNbtSchemaModTrnsctn.MetaData.getPropertySet("MaterialSet");
View.AddViewRelationship(MaterialPS, true);
materialprop.DesignNode.AttributeProperty[CswEnumNbtPropertyAttributeName.Target].AsMetaDataList.setValue(CswEnumNbtViewRelatedIdType.PropertySetId, MaterialPS.PropertySetId);
}
View.save();
ViewId = View.ViewId;
return(ViewId);
}
public CswViewBuilderProp(CswNbtMetaDataNodeTypeProp NodeTypeProp)
{
CswNbtMetaDataNodeType nt = NodeTypeProp.getNodeType();
if (null != nt)
{
OwnerName = nt.NodeTypeName;
}
FieldType = NodeTypeProp.getFieldTypeValue();
//ListOptions.FromString( NodeTypeProp.ListOptions );
ListOptions.FromString(NodeTypeProp.DesignNode.AttributeProperty[CswEnumNbtPropertyAttributeName.Options].AsText.Text);
RelatedIdType = CswEnumNbtViewRelatedIdType.NodeTypeId;
MetaDataPropNameWithQuestionNo = NodeTypeProp.PropNameWithQuestionNo;
MetaDataPropId = NodeTypeProp.FirstPropVersionId;
MetaDataPropName = NodeTypeProp.PropName;
MetaDataTypeName = NodeTypeProp.getNodeType().NodeTypeName;
FieldTypeRule = NodeTypeProp.getFieldTypeRule();
Type = CswEnumNbtViewPropType.NodeTypePropId;
PropName = MetaDataPropName;
AssociatedPropIds.Add(MetaDataPropId.ToString());
if (NodeTypeProp.ObjectClassPropId != Int32.MinValue)
{
AssociatedPropIds.Add(NodeTypeProp.ObjectClassPropId.ToString());
}
} //ctor Ntp
public override void update()
{
CswNbtMetaDataObjectClass MEPOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ManufacturerEquivalentPartClass );
CswNbtMetaDataObjectClass ManufacturerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ManufacturerClass );
if( null != ManufacturerOC )
{
CswNbtMetaDataObjectClassProp MaterialOCP = MEPOC.getObjectClassProp( "Material" );
if( null != MaterialOCP )
{
_CswNbtSchemaModTrnsctn.MetaData.DeleteObjectClassProp( MaterialOCP, true );
}
CswNbtMetaDataObjectClassProp ManufacturerOCP = MEPOC.getObjectClassProp( CswNbtObjClassManufacturerEquivalentPart.PropertyName.Manufacturer );
if( null != ManufacturerOCP )
{
CswNbtView ManufacturerView = _CswNbtSchemaModTrnsctn.makeView();
CswNbtViewRelationship parent = ManufacturerView.AddViewRelationship( ManufacturerOC, true );
ManufacturerView.Visibility = CswEnumNbtViewVisibility.Property;
ManufacturerView.ViewName = "Manufacturer";
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( ManufacturerOCP, CswEnumNbtObjectClassPropAttributes.viewxml, ManufacturerView.ToString() );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( ManufacturerOCP, CswEnumNbtObjectClassPropAttributes.fktype, CswEnumNbtViewRelatedIdType.ObjectClassId.ToString() );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( ManufacturerOCP, CswEnumNbtObjectClassPropAttributes.fkvalue, ManufacturerOC.ObjectClassId.ToString() );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( ManufacturerOCP, CswEnumNbtObjectClassPropAttributes.isrequired, true );
CswNbtMetaDataObjectClassProp EPOCP = MEPOC.getObjectClassProp( CswNbtObjClassManufacturerEquivalentPart.PropertyName.EnterprisePart );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( EPOCP, CswEnumNbtObjectClassPropAttributes.isrequired, true );
foreach( CswNbtMetaDataNodeType MEPNT in MEPOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp ManufacturerNTP = MEPNT.getNodeTypePropByObjectClassProp( ManufacturerOCP );
ManufacturerNTP.DesignNode.syncFromObjectClassProp();
CswNbtMetaDataNodeTypeProp EPNTP = MEPNT.getNodeTypePropByObjectClassProp( EPOCP );
EPNTP.DesignNode.syncFromObjectClassProp();
}
}
_CswNbtSchemaModTrnsctn.createModuleObjectClassJunction( CswEnumNbtModuleName.MLM, MEPOC.ObjectClassId );
}
} // update()
public CswNbtView setupPhraseView(CswNbtView View, CswCommaDelimitedString SelectedPhraseIds)
{
CswNbtMetaDataObjectClass GhsPhraseOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.GHSPhraseClass);
CswNbtMetaDataNodeType GhsPhraseNT = GhsPhraseOC.FirstNodeType;
View.SetVisibility(CswEnumNbtViewVisibility.Hidden, null, null);
View.ViewMode = CswEnumNbtViewRenderingMode.Grid;
View.Root.ChildRelationships.Clear();
if (SelectedPhraseIds.Count > 0)
{
CswNbtViewRelationship PhraseVR = View.AddViewRelationship(GhsPhraseOC, false);
foreach (string PhraseId in SelectedPhraseIds)
{
CswPrimaryKey PhrasePk = new CswPrimaryKey();
PhrasePk.FromString(PhraseId);
PhraseVR.NodeIdsToFilterIn.Add(PhrasePk);
}
View.AddViewProperty(PhraseVR, GhsPhraseOC.getObjectClassProp(CswNbtObjClassGHSPhrase.PropertyName.Code));
if (null != GhsPhraseNT)
{
CswNbtMetaDataNodeTypeProp LanguageProp = GhsPhraseNT.getNodeTypePropByObjectClassProp(_getLanguageForTranslation());
CswNbtViewProperty LanguageVP = View.AddViewProperty(PhraseVR, LanguageProp);
LanguageVP.Width = 100;
}
} // if( SelectedPhraseIds.Count > 0 )
return(View);
} // setupPhraseView()
private void _populateUnitViewRelationships(CswNbtView UnitView, string PhysicalState, bool ExcludeEach)
{
CswNbtMetaDataObjectClass UnitOfMeasureOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.UnitOfMeasureClass);
CswNbtMetaDataNodeType EachNT = null;
foreach (CswNbtMetaDataNodeType UnitOfMeasureNodeType in UnitOfMeasureOC.getNodeTypes())
{
CswNbtMetaDataNodeTypeProp UnitTypeProp = UnitOfMeasureNodeType.getNodeTypePropByObjectClassProp(CswNbtObjClassUnitOfMeasure.PropertyName.UnitType);
if (UnitTypeProp.HasDefaultValue())
{
CswEnumNbtUnitTypes UnitType = (CswEnumNbtUnitTypes)UnitTypeProp.getDefaultValue(false).AsList.Value;
if (_physicalStateMatchesUnitType(PhysicalState, UnitType, ExcludeEach))
{
if (UnitType == CswEnumNbtUnitTypes.Each)
{
EachNT = UnitOfMeasureNodeType;
}
else
{
UnitView.AddViewRelationship(UnitOfMeasureNodeType, true);
}
}
}
}
if (null != EachNT) //Case 29933 - Each units always go at the end of the list
{
UnitView.AddViewRelationship(EachNT, true);
}
}
} // setupPhraseView()
private void _setupClassificationView(CswNbtView View, CswCommaDelimitedString SelectedClassIds)
{
CswNbtMetaDataObjectClass GhsClassOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.GHSClassificationClass);
CswNbtMetaDataNodeType GhsClassNT = GhsClassOC.FirstNodeType;
View.SetVisibility(CswEnumNbtViewVisibility.Hidden, null, null);
View.ViewMode = CswEnumNbtViewRenderingMode.Grid;
View.Root.ChildRelationships.Clear();
if (SelectedClassIds.Count > 0)
{
CswNbtViewRelationship ClassVR = View.AddViewRelationship(GhsClassOC, false);
foreach (string ClassId in SelectedClassIds)
{
CswPrimaryKey ClassPk = new CswPrimaryKey();
ClassPk.FromString(ClassId);
ClassVR.NodeIdsToFilterIn.Add(ClassPk);
}
View.AddViewProperty(ClassVR, GhsClassOC.getObjectClassProp(CswNbtObjClassGHSClassification.PropertyName.Category));
if (null != GhsClassNT)
{
CswNbtMetaDataNodeTypeProp LanguageProp = GhsClassNT.getNodeTypePropByObjectClassProp(_getLanguageForTranslation());
CswNbtViewProperty LanguageVP = View.AddViewProperty(ClassVR, LanguageProp);
LanguageVP.Width = 100;
}
} // if( SelectedClassIds.Count > 0 )
View.SaveToCache(IncludeInQuickLaunch: false, UpdateCache: true, KeepInQuickLaunch: false);
} // _setupClassificationView()
public override void update()
{
//add supplier and catalog number to size name template
CswNbtMetaDataNodeType sizeNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Size" );
if( null != sizeNT )
{
CswNbtMetaDataNodeTypeProp materialNTP = sizeNT.getNodeTypeProp( CswNbtObjClassSize.MaterialPropertyName );
CswNbtMetaDataObjectClass materialOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( materialNTP.FKValue );
CswNbtMetaDataObjectClassProp supplierOCP = materialOC.getObjectClassProp( CswNbtObjClassMaterial.SupplierPropertyName );
CswNbtMetaDataObjectClass sizeOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.SizeClass );
CswNbtMetaDataObjectClassProp materialOCP = sizeOC.getObjectClassProp( CswNbtObjClassSize.MaterialPropertyName );
CswNbtMetaDataNodeTypeTab sizeTab = _getTab( sizeNT, "Size", 1 );
CswNbtMetaDataNodeTypeProp sizeSupplierNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( sizeNT, CswNbtMetaDataFieldType.NbtFieldType.PropertyReference, "Supplier", sizeTab.TabId );
sizeSupplierNTP.SetFK( NbtViewPropIdType.ObjectClassPropId.ToString(), materialOCP.PropId, NbtViewPropIdType.ObjectClassPropId.ToString(), supplierOCP.PropId );
string templateText = sizeNT.NameTemplateValue;
templateText += CswNbtMetaData.MakeTemplateEntry( sizeSupplierNTP.PropName ); //add supplier (NTP) name to template
templateText += " " + CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassSize.CatalogNoPropertyName ); //add catalog number to name template
sizeNT.setNameTemplateText( templateText );
}
}//Update()
public static void clearBlob(ICswResources CswResources, BlobDataReturn Return, BlobDataParams Request)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswPropIdAttr PropId = new CswPropIdAttr(Request.propid);
CswNbtNode Node = NbtResources.Nodes[PropId.NodeId];
if (null != Node)
{
CswNbtMetaDataNodeTypeProp MetaDataProp = NbtResources.MetaData.getNodeTypeProp(PropId.NodeTypePropId);
if (null != MetaDataProp)
{
CswNbtNodePropWrapper FileProp = Node.Properties[MetaDataProp];
if (NbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Edit, MetaDataProp.getNodeType(), NbtResources.CurrentNbtUser) &&
NbtResources.Permit.isPropWritable(CswEnumNbtNodeTypePermission.Edit, MetaDataProp, null, FileProp))
{
CswNbtSdTabsAndProps tabsandprops = new CswNbtSdTabsAndProps(NbtResources);
tabsandprops.ClearPropValue(Request.propid, true);
Request.Blob = new CswNbtSdBlobData.CswNbtBlob();
Request.success = true;
Return.Data = Request;
}
else
{
throw new CswDniException(CswEnumErrorType.Warning, "You do not have sufficient priveledges to clear this File property", "User " + NbtResources.CurrentNbtUser.UserId + " attempted to call clearBlob without sufficient priviledges.");
}
}
}
}
public override void update()
{
CswNbtMetaDataObjectClass MaterialOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.MaterialClass );
foreach( CswNbtMetaDataNodeType MaterialNT in MaterialOC.getNodeTypes() )
{
if( MaterialNT.NodeTypeName == "Biological" )
{
CswNbtMetaDataNodeTypeProp PictureNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( MaterialNT.NodeTypeId, "Picture" );
if( null != PictureNTP )
{
PictureNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
}
CswNbtMetaDataNodeTypeProp RefNoNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( MaterialNT.NodeTypeId, "Reference Number" );
if( null != RefNoNTP )
{
RefNoNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add, true );
}
CswNbtMetaDataNodeTypeProp TypeNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( MaterialNT.NodeTypeId, "Type" );
if( null != TypeNTP )
{
TypeNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add, true );
}
}
else if( MaterialNT.NodeTypeName == "Chemical" )
{
CswNbtMetaDataNodeTypeProp CasNoNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp( MaterialNT.NodeTypeId, CswNbtObjClassMaterial.PropertyName.CasNo );
CasNoNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add, true );
}
}
}//Update()
public override void update()
{
// Make sure all Location nodetypes are using the Location sequence
CswSequenceName LocationSeqName = new CswSequenceName( "Locations" );
Int32 LocationSeqId;
if(_CswNbtSchemaModTrnsctn.doesSequenceExist(LocationSeqName ))
{
DataTable SeqTable = _CswNbtSchemaModTrnsctn.getSequence( LocationSeqName );
LocationSeqId = CswConvert.ToInt32( SeqTable.Rows[0]["sequenceid"] );
}
else
{
LocationSeqId = _CswNbtSchemaModTrnsctn.makeSequence( LocationSeqName, "LS", string.Empty, 6, 1 );
}
if(Int32.MinValue != LocationSeqId )
{
CswNbtMetaDataObjectClass LocationOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.LocationClass );
foreach( CswNbtMetaDataNodeType LocationNT in LocationOC.getNodeTypes() )
{
// Set sequence id
CswNbtMetaDataNodeTypeProp BarcodeNTP = LocationNT.getNodeTypePropByObjectClassProp( CswNbtObjClassLocation.PropertyName.Barcode );
BarcodeNTP.setSequence( LocationSeqId );
} // foreach( CswNbtMetaDataNodeType LocationNT in LocationOC.getNodeTypes() )
} // if(Int32.MinValue != LocationSeqId )
} //Update()
private void _setEditLayout( string PropName, int ColNum, int RowNum, string TabGroup = "", bool RemoveFromAdd = true )
{
CswNbtMetaDataNodeTypeProp FireClassExemptAmountNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp( FireClassExemptAmountNT.NodeTypeId, PropName );
if( RemoveFromAdd )
FireClassExemptAmountNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
FireClassExemptAmountNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, FireClassExemptAmountNT.getFirstNodeTypeTab().TabId, RowNum, ColNum, TabGroup );
}
public override void update()
{
const string ViewName = "PI Schedule ParentView";
CswNbtMetaDataNodeType InspectionGeneratorNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Inspection Schedule" );
if( null != InspectionGeneratorNT )
{
CswNbtMetaDataNodeTypeProp ParentViewNTP = InspectionGeneratorNT.getNodeTypePropByObjectClassProp( CswNbtObjClassGenerator.PropertyName.ParentView );
CswNbtView ExistingView = _CswNbtSchemaModTrnsctn.ViewSelect.restoreView( ParentViewNTP.DefaultValue.AsViewReference.ViewId );
if( null != ExistingView && ExistingView.ViewName == ViewName )
{
foreach( CswNbtObjClassGenerator InspectionSchedNode in InspectionGeneratorNT.getNodes( false, true, false, true ) )
{
CswNbtView ParentView = _CswNbtSchemaModTrnsctn.ViewSelect.restoreView( InspectionSchedNode.ParentView.ViewId );
if( ParentView.IsEmpty() )
{
ParentView.CopyFromView( ExistingView );
ParentView.save();
InspectionSchedNode.postChanges( false );
}
}
}
else
{
throw new CswDniException( CswEnumErrorType.Error, "Default Value for Inspection Schedule Parent View is invalid", "InspectionSchedule.ParentView NTP default value got an unexpected view" );
}
}
} // update()
