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 ) )
}
public override void update()
{
CswNbtMetaDataObjectClass MethodOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.MethodClass );
if( null != MethodOc )
{
CswNbtMetaDataNodeType MethodNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Method" );
if( null == MethodNt )
{
//Create new NodeType
MethodNt = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( MethodOc.ObjectClassId, "Method", "MLM" );
_CswNbtSchemaModTrnsctn.createModuleNodeTypeJunction( CswNbtModuleName.MLM, MethodNt.NodeTypeId );
MethodNt.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassMethod.PropertyName.MethodNo ) );
//Create Demo Data
CswNbtObjClassMethod MethodNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( MethodNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode );
MethodNode.MethodNo.Text = "000001";
MethodNode.MethodDescription.Text = "Demo Method";
MethodNode.IsDemo = true;
MethodNode.postChanges( false );
}
CswNbtView MethodView = _CswNbtSchemaModTrnsctn.restoreView( "Methods" );
if( null == MethodView )
{
//Create new View
MethodView = _CswNbtSchemaModTrnsctn.makeNewView( "Methods", NbtViewVisibility.Global );
MethodView.Category = "MLM (demo)";
MethodView.IsDemo = true;
MethodView.ViewMode = NbtViewRenderingMode.Tree;
MethodView.AddViewRelationship( MethodOc, true );
MethodView.save();
}
}
} //Update()
public override void update()
{
CswNbtMetaDataObjectClass JurisdictionOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.JurisdictionClass );
if( null != JurisdictionOc )
{
CswNbtMetaDataNodeType JurisdictionNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Jurisdiction" );
if( null == JurisdictionNt )
{
//Create new NodeType
JurisdictionNt = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( JurisdictionOc.ObjectClassId, "Jurisdiction", "MLM" );
_CswNbtSchemaModTrnsctn.createModuleNodeTypeJunction( CswNbtModuleName.CISPro, JurisdictionNt.NodeTypeId );
JurisdictionNt.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassJurisdiction.PropertyName.Name ) );
//Create Demo Data
CswNbtObjClassJurisdiction JurisdictionNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( JurisdictionNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode );
JurisdictionNode.Name.Text = "Default Jurisdiction";
JurisdictionNode.IsDemo = true;
JurisdictionNode.postChanges( false );
}
CswNbtView JurisdictionView = _CswNbtSchemaModTrnsctn.restoreView( "Jurisdictions" );
if( null == JurisdictionView )
{
//Create demo View
JurisdictionView = _CswNbtSchemaModTrnsctn.makeNewView( "Jurisdictions", NbtViewVisibility.Global );
JurisdictionView.Category = "MLM (demo)";
JurisdictionView.IsDemo = true;
JurisdictionView.ViewMode = NbtViewRenderingMode.Tree;
JurisdictionView.AddViewRelationship( JurisdictionOc, true );
JurisdictionView.save();
}
}
} //Update()
public override void update()
{
// Add nodetypes for new object classes
CswNbtMetaDataObjectClass RegListMemberOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RegulatoryListMemberClass );
CswNbtMetaDataObjectClassProp RegListMemberChemicalOCP = RegListMemberOC.getObjectClassProp( CswNbtObjClassRegulatoryListMember.PropertyName.Chemical );
CswNbtMetaDataNodeType RegListMemberNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeTypeDeprecated( new CswNbtWcfMetaDataModel.NodeType( RegListMemberOC )
{
NodeTypeName = "Regulatory List Member",
Category = "Materials",
SearchDeferObjectClassPropId = RegListMemberChemicalOCP.ObjectClassPropId
} );
RegListMemberNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListMember.PropertyName.Chemical ) + "-" + CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListMember.PropertyName.RegulatoryList ) );
RegListMemberNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRegulatoryListMember.PropertyName.ByUser ).removeFromLayout( CswEnumNbtLayoutType.Add );
CswNbtMetaDataObjectClass RegListCasNoOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RegulatoryListCasNoClass );
CswNbtMetaDataObjectClassProp RegListCasNoRegListOCP = RegListCasNoOC.getObjectClassProp( CswNbtObjClassRegulatoryListCasNo.PropertyName.RegulatoryList );
CswNbtMetaDataNodeType RegListCasNoNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeTypeDeprecated( new CswNbtWcfMetaDataModel.NodeType( RegListCasNoOC )
{
NodeTypeName = "Regulatory List CAS",
Category = "Materials",
SearchDeferObjectClassPropId = RegListCasNoRegListOCP.ObjectClassPropId
} );
RegListCasNoNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListCasNo.PropertyName.RegulatoryList ) + "-" + CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListCasNo.PropertyName.CASNo ) );
// Grant permissions to cispro_admin
CswNbtObjClassRole CISProAdminRole = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "CISPro_Admin" );
CswEnumNbtNodeTypePermission[] AllPerms = new CswEnumNbtNodeTypePermission[]
{
CswEnumNbtNodeTypePermission.Create, CswEnumNbtNodeTypePermission.Delete, CswEnumNbtNodeTypePermission.Edit, CswEnumNbtNodeTypePermission.View
};
_CswNbtSchemaModTrnsctn.Permit.set( AllPerms, RegListMemberNT, CISProAdminRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( AllPerms, RegListCasNoNT, CISProAdminRole, true );
} // 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 override void SyncGestalt()
{
//string gestaltVal = CswNbtMetaData.TemplateValueToDisplayValue( _CswNbtResources.MetaData.getNodeTypeProps( _CswNbtMetaDataNodeTypeProp.NodeTypeId ), TemplateValue, this );
string gestaltVal = CswNbtMetaData.TemplateValueToDisplayValue(_CswNbtResources.MetaData.getNodeTypeProps(_CswNbtNodePropData.NodeTypeId), TemplateValue, this);
SetPropRowValue(CswEnumNbtSubFieldName.Gestalt, CswEnumNbtPropColumn.Gestalt, gestaltVal);
}
public override void update()
{
CswNbtMetaDataObjectClass CertDefSpecOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.CertDefSpecClass);
CswNbtMetaDataNodeType CertDefSpecDefaultNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType(new CswNbtWcfMetaDataModel.NodeType(CertDefSpecOC)
{
Category = "MLM",
ObjectClass = CertDefSpecOC,
ObjectClassId = CertDefSpecOC.ObjectClassId,
NodeTypeName = "CertDef Spec",
Searchable = true,
NameTemplate = CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassCertDefSpec.PropertyName.NameForTestingConditions)
});
CswNbtMetaDataNodeTypeTab ConditionsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab(CertDefSpecDefaultNT,
"Conditions",
2);
CswNbtMetaDataNodeTypeTab CharacteristicsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab(CertDefSpecDefaultNT,
"Characteristics",
3);
CswNbtMetaDataNodeTypeProp ConditionsNTP = CertDefSpecDefaultNT.getNodeTypePropByObjectClassProp(CswNbtObjClassCertDefSpec.PropertyName.Conditions);
ConditionsNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, ConditionsTab.TabId, 1, 1);
CswNbtMetaDataNodeTypeProp CharacteristicsNTP = CertDefSpecDefaultNT.getNodeTypePropByObjectClassProp(CswNbtObjClassCertDefSpec.PropertyName.Characteristics);
CharacteristicsNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, CharacteristicsTab.TabId, 1, 1);
}
public CswNbtMetaDataResources(CswNbtResources Resources, CswNbtMetaData MetaData)
{
CswNbtResources = Resources;
CswNbtMetaData = MetaData;
CswNbtFieldResources = new CswNbtFieldResources(Resources);
_ExcludeDisabledModules = ExcludeDisabledModules;
ObjectClassTableSelect = CswNbtResources.makeCswTableSelect("MetaData_ObjectClass_Select", "object_class");
ObjectClassPropTableSelect = CswNbtResources.makeCswTableSelect("MetaData_ObjectClassProp_Select", "object_class_props");
NodeTypeTableSelect = CswNbtResources.makeCswTableSelect("MetaData_NodeType_Select", "nodetypes");
FieldTypeTableSelect = CswNbtResources.makeCswTableSelect("MetaData_FieldType_Select", "field_types");
NodeTypePropTableSelect = CswNbtResources.makeCswTableSelect("MetaData_NodeTypeProp_Select", "nodetype_props");
NodeTypeTabTableSelect = CswNbtResources.makeCswTableSelect("MetaData_NodeTypeTab_Select", "nodetype_tabset");
PropertySetTableSelect = CswNbtResources.makeCswTableSelect("MetaData_PropertySet_Select", "property_set");
ObjectClassTableUpdate = CswNbtResources.makeCswTableUpdate("MetaData_ObjectClass_update", "object_class");
ObjectClassPropTableUpdate = CswNbtResources.makeCswTableUpdate("MetaData_ObjectClassProp_update", "object_class_props");
NodeTypeTableUpdate = CswNbtResources.makeCswTableUpdate("MetaData_NodeType_update", "nodetypes");
FieldTypeTableUpdate = CswNbtResources.makeCswTableUpdate("MetaData_FieldType_update", "field_types");
NodeTypePropTableUpdate = CswNbtResources.makeCswTableUpdate("MetaData_NodeTypeProp_update", "nodetype_props");
NodeTypeTabTableUpdate = CswNbtResources.makeCswTableUpdate("MetaData_NodeTypeTab_update", "nodetype_tabset");
PropertySetTableUpdate = CswNbtResources.makeCswTableUpdate("MetaData_PropertySet_update", "property_set");
JctNodesPropsTableUpdate = CswNbtResources.makeCswTableUpdate("MetaData_JctNodesProps_update", "jct_nodes_props");
ObjectClassesCollection = new CswNbtMetaDataCollectionObjectClass(this);
ObjectClassPropsCollection = new CswNbtMetaDataCollectionObjectClassProp(this);
FieldTypesCollection = new CswNbtMetaDataCollectionFieldType(this);
NodeTypesCollection = new CswNbtMetaDataCollectionNodeType(this);
NodeTypePropsCollection = new CswNbtMetaDataCollectionNodeTypeProp(this);
NodeTypeTabsCollection = new CswNbtMetaDataCollectionNodeTypeTab(this);
PropertySetsCollection = new CswNbtMetaDataCollectionPropertySet(this);
}
public override void update()
{
// Add nodetypes for the new object class
CswNbtMetaDataObjectClass RegListListCodeOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RegulatoryListListCodeClass );
CswNbtMetaDataObjectClassProp RegListListCodeRegListOCP = RegListListCodeOC.getObjectClassProp( CswNbtObjClassRegulatoryListListCode.PropertyName.RegulatoryList );
CswNbtMetaDataNodeType RegListListCodeNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Regulatory List List Code" );
if( null == RegListListCodeNT )
{
RegListListCodeNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( new CswNbtWcfMetaDataModel.NodeType( RegListListCodeOC )
{
NodeTypeName = "Regulatory List List Code",
Category = "Materials",
SearchDeferObjectClassPropId = RegListListCodeRegListOCP.ObjectClassPropId
} );
}
// Set the Name Template
RegListListCodeNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListListCode.PropertyName.RegulatoryList )
+ "-"
+ CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryListListCode.PropertyName.LOLIListName ) );
// Hide the LOLI List Code Property from Users
CswNbtMetaDataNodeTypeProp RegListListCodeListCodeNTP = RegListListCodeNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRegulatoryListListCode.PropertyName.LOLIListCode );
RegListListCodeListCodeNTP.removeFromAllLayouts();
} // update()
} // getAttributes()
public static CswNbtView setDefaultView(CswNbtMetaData MetaData, CswNbtObjClassDesignNodeTypeProp DesignNTPNode, CswNbtView View, CswEnumNbtViewRelatedIdType RelatedIdType, Int32 inFKValue, bool OnlyCreateIfNull)
{
if (RelatedIdType != CswEnumNbtViewRelatedIdType.Unknown &&
(null == View ||
View.Root.ChildRelationships.Count == 0 ||
false == OnlyCreateIfNull))
{
if (null != View)
{
View.Root.ChildRelationships.Clear();
}
ICswNbtMetaDataDefinitionObject targetObj = MetaData.getDefinitionObject(RelatedIdType, inFKValue);
if (null != targetObj)
{
CswNbtViewId OldViewId = View.ViewId;
View = targetObj.CreateDefaultView();
View.ViewId = OldViewId;
}
else
{
throw new CswDniException(CswEnumErrorType.Error, "Cannot create a relationship without a valid target.", "setDefaultView() got an invalid RelatedIdType: " + RelatedIdType + " or value: " + inFKValue);
}
View.Visibility = CswEnumNbtViewVisibility.Property;
View.ViewMode = CswEnumNbtViewRenderingMode.Tree;
View.ViewName = DesignNTPNode.PropName.Text;
View.save();
}
return(View);
}
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 override void update()
{
CswNbtMetaDataObjectClass MethodCharacteristicOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.MethodCharacteristicClass);
CswNbtMetaDataNodeType MethodCharacteristicNT = MethodCharacteristicOC.FirstNodeType;
CswNbtMetaDataNodeTypeProp MethodCharResultTypeNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.ResultType);
// CertDef Characteristic Limit NodeType
CswNbtMetaDataObjectClass CertDefCharLimitOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.CertDefCharacteristicLimitClass);
CswNbtMetaDataNodeType CertDefCharLimitNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType(new CswNbtWcfMetaDataModel.NodeType(CertDefCharLimitOC)
{
NodeTypeName = "CertDef Characteristic Limit",
NameTemplate = CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassCertDefCharacteristicLimit.PropertyName.CertDefSpec) + ": " +
CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassCertDefCharacteristicLimit.PropertyName.MethodCharacteristic),
Category = "MLM"
});
CswNbtMetaDataNodeTypeProp MethodCharacteristicNTP = CertDefCharLimitNT.getNodeTypePropByObjectClassProp(CswNbtObjClassCertDefCharacteristicLimit.PropertyName.MethodCharacteristic);
CswNbtMetaDataNodeTypeProp CertDefSpecNTP = CertDefCharLimitNT.getNodeTypePropByObjectClassProp(CswNbtObjClassCertDefCharacteristicLimit.PropertyName.CertDefSpec);
CswNbtMetaDataNodeTypeProp ResultTypeNTP = CertDefCharLimitNT.getNodeTypePropByObjectClassProp(CswNbtObjClassCertDefCharacteristicLimit.PropertyName.ResultType);
CswNbtMetaDataNodeTypeProp LimitsNTP = CertDefCharLimitNT.getNodeTypePropByObjectClassProp(CswNbtObjClassCertDefCharacteristicLimit.PropertyName.Limits);
CswNbtMetaDataNodeTypeProp PassOptionsNTP = CertDefCharLimitNT.getNodeTypePropByObjectClassProp(CswNbtObjClassCertDefCharacteristicLimit.PropertyName.PassOptions);
CswNbtMetaDataNodeTypeProp PassValueNTP = CertDefCharLimitNT.getNodeTypePropByObjectClassProp(CswNbtObjClassCertDefCharacteristicLimit.PropertyName.PassValue);
// Layout
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, CertDefCharLimitNT.NodeTypeId, MethodCharacteristicNTP, true, CertDefCharLimitNT.getFirstNodeTypeTab().TabId, 1, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, CertDefCharLimitNT.NodeTypeId, CertDefSpecNTP, true, CertDefCharLimitNT.getFirstNodeTypeTab().TabId, 2, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, CertDefCharLimitNT.NodeTypeId, ResultTypeNTP, true, CertDefCharLimitNT.getFirstNodeTypeTab().TabId, 3, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, CertDefCharLimitNT.NodeTypeId, LimitsNTP, true, CertDefCharLimitNT.getFirstNodeTypeTab().TabId, 4, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, CertDefCharLimitNT.NodeTypeId, PassOptionsNTP, true, CertDefCharLimitNT.getFirstNodeTypeTab().TabId, 5, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, CertDefCharLimitNT.NodeTypeId, PassValueNTP, true, CertDefCharLimitNT.getFirstNodeTypeTab().TabId, 6, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, CertDefCharLimitNT.NodeTypeId, MethodCharacteristicNTP, true, 1, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, CertDefCharLimitNT.NodeTypeId, CertDefSpecNTP, true, 2, 1);
// Set up 'Result Type' property reference
ResultTypeNTP.DesignNode.AttributeProperty[CswNbtFieldTypeRulePropertyReference.AttributeName.FKType].AsText.Text = CswEnumNbtViewPropType.NodeTypePropId.ToString();
ResultTypeNTP.DesignNode.AttributeProperty[CswNbtFieldTypeRulePropertyReference.AttributeName.Relationship].AsList.Value = MethodCharacteristicNTP.PropId.ToString();
ResultTypeNTP.DesignNode.AttributeProperty[CswNbtFieldTypeRulePropertyReference.AttributeName.RelatedPropType].AsText.Text = CswEnumNbtViewPropType.NodeTypePropId.ToString();
ResultTypeNTP.DesignNode.AttributeProperty[CswNbtFieldTypeRulePropertyReference.AttributeName.RelatedProperty].AsList.Value = MethodCharResultTypeNTP.PropId.ToString();
// Set display conditions
LimitsNTP.DesignNode.DisplayConditionProperty.RelatedNodeId = ResultTypeNTP.DesignNode.NodeId;
LimitsNTP.DesignNode.DisplayConditionSubfield.Value = CswNbtFieldTypeRulePropertyReference.SubFieldName.Value.ToString();
LimitsNTP.DesignNode.DisplayConditionFilterMode.Value = CswEnumNbtFilterMode.Equals.ToString();
LimitsNTP.DesignNode.DisplayConditionValue.Text = CswNbtObjClassMethodCharacteristic.ResultTypeOption.Quantitative;
PassOptionsNTP.DesignNode.DisplayConditionProperty.RelatedNodeId = ResultTypeNTP.DesignNode.NodeId;
PassOptionsNTP.DesignNode.DisplayConditionSubfield.Value = CswNbtFieldTypeRulePropertyReference.SubFieldName.Value.ToString();
PassOptionsNTP.DesignNode.DisplayConditionFilterMode.Value = CswEnumNbtFilterMode.Equals.ToString();
PassOptionsNTP.DesignNode.DisplayConditionValue.Text = CswNbtObjClassMethodCharacteristic.ResultTypeOption.Qualitative;
PassValueNTP.DesignNode.DisplayConditionProperty.RelatedNodeId = ResultTypeNTP.DesignNode.NodeId;
PassValueNTP.DesignNode.DisplayConditionSubfield.Value = CswNbtFieldTypeRulePropertyReference.SubFieldName.Value.ToString();
PassValueNTP.DesignNode.DisplayConditionFilterMode.Value = CswEnumNbtFilterMode.Equals.ToString();
PassValueNTP.DesignNode.DisplayConditionValue.Text = CswNbtObjClassMethodCharacteristic.ResultTypeOption.Match;
}
public override void update()
{
CswNbtMetaDataObjectClass ChemicalOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ChemicalClass );
CswNbtMetaDataObjectClass RequestItemOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RequestItemClass );
foreach( CswNbtMetaDataNodeType RequestItemNT in RequestItemOC.getNodeTypes() )
{
//Set NewMaterialType default value
CswNbtMetaDataNodeTypeProp NewMaterialTypeNTP = RequestItemNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.NewMaterialType );
if( null != ChemicalOC.FirstNodeType && null != NewMaterialTypeNTP )
{
NewMaterialTypeNTP.DefaultValue.AsNodeTypeSelect.SelectedNodeTypeIds.Add( ChemicalOC.FirstNodeType.NodeTypeId.ToString() );
}
CswNbtMetaDataNodeTypeProp DescriptionNTP = RequestItemNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Description );
//Set RequestItem name template
RequestItemNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( DescriptionNTP.PropName ) );
//Hide Internal Flags and States
CswNbtMetaDataNodeTypeProp TypeNTP = RequestItemNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Type );
TypeNTP.Hidden = true;
CswNbtMetaDataNodeTypeProp IsFavoriteNTP = RequestItemNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.IsFavorite );
IsFavoriteNTP.Hidden = true;
CswNbtMetaDataNodeTypeProp IsRecurringNTP = RequestItemNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.IsRecurring );
IsRecurringNTP.Hidden = true;
//Remove all props from all layouts
foreach( CswNbtMetaDataNodeTypeProp Prop in RequestItemNT.getNodeTypeProps() )
{
if( Prop.PropName != CswNbtObjClass.PropertyName.Save )
{
Prop.removeFromAllLayouts();
}
}
//Give CRUD permissions to applicable Roles and Users
CswNbtMetaDataObjectClass RoleOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RoleClass );
foreach( CswNbtObjClassRole RoleNode in RoleOC.getNodes( false, false, false, true ) )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.View, RequestItemNT, RoleNode,
RoleNode.Administrator.Checked == CswEnumTristate.True || RoleNode.Name.Text.Contains( "CISPro" ) );
if( RoleNode.Administrator.Checked == CswEnumTristate.True ||
( RoleNode.Name.Text.Contains( "CISPro" ) && RoleNode.Name.Text != "CISPro_View_Only" ) )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtActionName.Submit_Request, RoleNode, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Edit, RequestItemNT, RoleNode, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Create, RequestItemNT, RoleNode, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswEnumNbtNodeTypePermission.Delete, RequestItemNT, RoleNode, true );
}
}
}
_updateAddLayout();
_updateEditLayout();
_updatePreviewLayout();
_updateTableLayout();
_updateRequestViews();
} // update()
public string RecalculateCompositeValue()
{
//string Value = CswNbtMetaData.TemplateValueToDisplayValue( _CswNbtResources.MetaData.getNodeTypeProps( _CswNbtMetaDataNodeTypeProp.NodeTypeId ), TemplateValue, this );
string Value = CswNbtMetaData.TemplateValueToDisplayValue(_CswNbtResources.MetaData.getNodeTypeProps(_CswNbtNodePropData.NodeTypeId), TemplateValue, this);
SetPropRowValue(_CachedValueSubField, Value);
Gestalt = Value;
PendingUpdate = false;
return(Value);
}
public override void update()
{
CswNbtMetaDataObjectClass mepOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.ManufacturerEquivalentPartClass );
//create the MEP NT
CswNbtMetaDataNodeType mepNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Manufacturing Equivalent Part" );
if( null == mepNT )
{
mepNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( mepOC.ObjectClassId, "Manufacturing Equivalent Part", "MLM" );
string mepNameTemplate = CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassManufacturerEquivalentPart.PropertyName.Manufacturer );
mepNameTemplate += CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassManufacturerEquivalentPart.PropertyName.EnterprisePart );
mepNameTemplate += CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassManufacturerEquivalentPart.PropertyName.Material );
mepNT.setNameTemplateText( mepNameTemplate );
CswNbtMetaDataNodeTypeProp materialNTP = mepNT.getNodeTypePropByObjectClassProp( CswNbtObjClassManufacturerEquivalentPart.PropertyName.Material );
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add, mepNT.NodeTypeId, materialNTP.PropId, true );
CswNbtMetaDataNodeTypeProp epNTP = mepNT.getNodeTypePropByObjectClassProp( CswNbtObjClassManufacturerEquivalentPart.PropertyName.EnterprisePart );
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add, mepNT.NodeTypeId, epNTP.PropId, true );
CswNbtMetaDataNodeTypeProp manufactufacturerNTP = mepNT.getNodeTypePropByObjectClassProp( CswNbtObjClassManufacturerEquivalentPart.PropertyName.Manufacturer );
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add, mepNT.NodeTypeId, manufactufacturerNTP.PropId, true );
//create demo MEP node
CswNbtObjClassManufacturerEquivalentPart mepNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( mepNT.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode );
//get the default EP node and set it o the demo MEP nodes EP prop
CswNbtMetaDataNodeType epNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Enterprise Part" );
if( null != epNT )
{
foreach( CswNbtObjClassEnterprisePart epNode in epNT.getNodes( false, false ) )
{
if( epNode.GCAS.Text.Equals( "EP123" ) ) //the default EP node had its GCAS set to this in CswUpdateSchema_01T_Case27865_part1
{
mepNode.EnterprisePart.RelatedNodeId = epNode.NodeId;
}
}
}
mepNode.IsDemo = true;
mepNode.postChanges( false );
}
//create the MEPs view
CswNbtView mepsView = _CswNbtSchemaModTrnsctn.restoreView( "Manufacturing Equivalent Parts" );
if( null == mepsView )
{
mepsView = _CswNbtSchemaModTrnsctn.makeNewView( "Manufacturing Equivalent Parts", NbtViewVisibility.Global );
mepsView.Category = "MLM (demo)";
mepsView.ViewMode = NbtViewRenderingMode.Tree;
mepsView.AddViewRelationship( mepOC, true );
mepsView.IsDemo = true;
mepsView.save();
}
}
} // update()
private CswNbtMetaDataNodeType _createPermissionNT( CswEnumNbtObjectClass PermissionClass, string PermissionNTName )
{
CswNbtMetaDataObjectClass PermissionOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( PermissionClass );
CswNbtMetaDataNodeType PermissionNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( PermissionOC.ObjectClassId, PermissionNTName, "System" );
PermissionNT.setNameTemplateText(
CswNbtMetaData.MakeTemplateEntry( CswNbtPropertySetPermission.PropertyName.PermissionGroup ) + "-" +
CswNbtMetaData.MakeTemplateEntry( CswNbtPropertySetPermission.PropertyName.Role ) + "-" +
CswNbtMetaData.MakeTemplateEntry( CswNbtPropertySetPermission.PropertyName.WorkUnit ) );
_setPermissionPropFilters( PermissionNT );
return PermissionNT;
}
/// <summary>
/// Update logic
/// </summary>
public override void update()
{
CswNbtMetaDataObjectClass MaterialOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.MaterialClass );
foreach( CswNbtMetaDataNodeType MaterialNt in MaterialOc.getNodeTypes() )
{
MaterialNt.setNameTemplateText(
CswNbtMetaData.MakeTemplateEntry( MaterialNt.getNodeTypePropByObjectClassProp( CswNbtObjClassMaterial.PropertyName.Tradename ).PropName ) + " " +
CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassMaterial.PropertyName.Supplier ) + " " +
CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassMaterial.PropertyName.PartNumber )
);
}
}//Update()
/// <summary>
/// Update logic
/// </summary>
public override void update()
{
CswNbtMetaDataNodeType materialComponentNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Material Component" );
if( null != materialComponentNT )
{
string templateText = CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassMaterialComponent.PropertyName.Constituent );
materialComponentNT.setNameTemplateText( templateText );
}
}//Update()
}//update()
private void _createNodeType(CswNbtMetaDataObjectClass objectClass, string nodeTypeName)
{
CswNbtMetaDataNodeType NewNodeType = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType(new CswNbtWcfMetaDataModel.NodeType(objectClass)
{
Category = "MLM",
IconFileName = "doc.png",
NodeTypeName = nodeTypeName,
NameTemplate = CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassCertificateDefinition.PropertyName.CertDefId)
});
_newNodeTypes.Add(NewNodeType);
}//_createNodeType()
private CswNbtMetaDataNodeType _createGroupNT( CswEnumNbtObjectClass GroupClass, string GroupNTName, string TargetsGridPropName )
{
CswNbtMetaDataObjectClass GroupOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( GroupClass );
CswNbtMetaDataNodeType GroupNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( GroupOC.ObjectClassId, GroupNTName, "System" );
GroupNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassReportGroup.PropertyName.Name ) );
CswNbtMetaDataNodeTypeTab TaregetsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( GroupNT, TargetsGridPropName );
CswNbtMetaDataNodeTypeProp TargetsNTP = GroupNT.getNodeTypePropByObjectClassProp( TargetsGridPropName );
TargetsNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TaregetsTab.TabId );
CswNbtMetaDataNodeTypeTab PermissionsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( GroupNT, CswNbtObjClassReportGroup.PropertyName.Permissions );
CswNbtMetaDataNodeTypeProp PermissionsNTP = GroupNT.getNodeTypePropByObjectClassProp( CswNbtObjClassReportGroup.PropertyName.Permissions );
PermissionsNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, PermissionsTab.TabId );
return GroupNT;
}
public override void update()
{
// Set container name template to include Disposed
CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.ContainerClass );
foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp BarcodeNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.Barcode );
CswNbtMetaDataNodeTypeProp DisposedNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.Disposed );
ContainerNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( BarcodeNTP.PropName ) +
" " +
CswNbtMetaData.MakeTemplateEntry( DisposedNTP.PropName ) );
}
} //update()
}//delete()
private void _synchNodeName(CswNbtNode Node)
{
string OldNodeName = Node.NodeName;
string NewNodeName = string.Empty;
string NameTemplate = Node.getNodeType().NameTemplateValue;
if (NameTemplate.Length > 0)
{
//we assume that the nodetype has nodetype_props corresponding to all "[]"
//parameters in the nametemplate.
if (Node.Properties.Count > 0)
{
NewNodeName = NameTemplate;
RegexOptions RegExOpts = new RegexOptions();
RegExOpts |= RegexOptions.IgnoreCase;
foreach (CswNbtNodePropWrapper CurrentProp in Node.Properties)
{
string TemplateParamCandidate = CswNbtMetaData.MakeTemplateEntry(CurrentProp.NodeTypePropId.ToString());
int TemplateParamStartIdx = NewNodeName.ToLower().IndexOf(TemplateParamCandidate);
if (TemplateParamStartIdx > -1)
{
Regex RegExObj = new Regex("\\" + TemplateParamCandidate, RegExOpts);
NewNodeName = RegExObj.Replace(NewNodeName, CurrentProp.ValueForNameTemplate);
} //if current property is used in the name template
} //iterate props
} // if( Node.Properties.Count > 0 )
} // if( NameTemplate.Length > 0 )
//Case 31057 - nodename can only be 255 chars max
if (NewNodeName.Length > 255)
{
NewNodeName = NewNodeName.Substring(0, 255);
}
NewNodeName = NewNodeName.Trim();
if (NewNodeName != string.Empty)
{
Node.NodeName = NewNodeName;
}
else
{
Node.NodeName = _makeDefaultNodeName(Node);
}
// When a node's name changes, we need to update any relationships (and locations) referencing that node
if (Node.NodeName != OldNodeName)
{
updateRelationsToThisNode(Node);
}
}//_synchNodeName()
public override void update()
{
CswNbtMetaDataObjectClass MethodCharacteristicOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.MethodCharacteristicClass);
CswNbtMetaDataNodeType MethodCharacteristicNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType(new CswNbtWcfMetaDataModel.NodeType(MethodCharacteristicOC)
{
NodeTypeName = "Method Characteristic",
Category = "Testing",
NameTemplate = CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassMethodCharacteristic.PropertyName.Method) + ": " +
CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassMethodCharacteristic.PropertyName.Characteristic)
});
CswNbtMetaDataNodeTypeProp CharacteristicNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.Characteristic);
CswNbtMetaDataNodeTypeProp ConstituentMaterialNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.ConstituentMaterial);
CswNbtMetaDataNodeTypeProp MethodNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.Method);
CswNbtMetaDataNodeTypeProp ObsoleteNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.Obsolete);
CswNbtMetaDataNodeTypeProp PrecisionNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.Precision);
CswNbtMetaDataNodeTypeProp ResultOptionsNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.ResultOptions);
CswNbtMetaDataNodeTypeProp ResultTypeNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.ResultType);
CswNbtMetaDataNodeTypeProp ResultUnitsNTP = MethodCharacteristicNT.getNodeTypePropByObjectClassProp(CswNbtObjClassMethodCharacteristic.PropertyName.ResultUnits);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, MethodCharacteristicNT.NodeTypeId, MethodNTP, true, MethodCharacteristicNT.getFirstNodeTypeTab().TabId, 1, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, MethodCharacteristicNT.NodeTypeId, CharacteristicNTP, true, MethodCharacteristicNT.getFirstNodeTypeTab().TabId, 2, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, MethodCharacteristicNT.NodeTypeId, ResultTypeNTP, true, MethodCharacteristicNT.getFirstNodeTypeTab().TabId, 3, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, MethodCharacteristicNT.NodeTypeId, ResultUnitsNTP, true, MethodCharacteristicNT.getFirstNodeTypeTab().TabId, 4, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, MethodCharacteristicNT.NodeTypeId, PrecisionNTP, true, MethodCharacteristicNT.getFirstNodeTypeTab().TabId, 5, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, MethodCharacteristicNT.NodeTypeId, ResultOptionsNTP, true, MethodCharacteristicNT.getFirstNodeTypeTab().TabId, 6, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, MethodCharacteristicNT.NodeTypeId, ConstituentMaterialNTP, true, MethodCharacteristicNT.getFirstNodeTypeTab().TabId, 7, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, MethodCharacteristicNT.NodeTypeId, ObsoleteNTP, true, MethodCharacteristicNT.getFirstNodeTypeTab().TabId, 8, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, MethodCharacteristicNT.NodeTypeId, MethodNTP, true, 1, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, MethodCharacteristicNT.NodeTypeId, CharacteristicNTP, true, 2, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, MethodCharacteristicNT.NodeTypeId, ResultTypeNTP, true, 3, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, MethodCharacteristicNT.NodeTypeId, ResultUnitsNTP, true, 4, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, MethodCharacteristicNT.NodeTypeId, PrecisionNTP, true, 5, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, MethodCharacteristicNT.NodeTypeId, ResultOptionsNTP, true, 6, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, MethodCharacteristicNT.NodeTypeId, ConstituentMaterialNTP, true, 7, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Add, MethodCharacteristicNT.NodeTypeId, ObsoleteNTP, true, 8, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Preview, MethodCharacteristicNT.NodeTypeId, MethodNTP, true, 1, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Preview, MethodCharacteristicNT.NodeTypeId, CharacteristicNTP, true, 2, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Preview, MethodCharacteristicNT.NodeTypeId, ResultTypeNTP, true, 3, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Table, MethodCharacteristicNT.NodeTypeId, MethodNTP, true, 1, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Table, MethodCharacteristicNT.NodeTypeId, CharacteristicNTP, true, 2, 1);
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Table, MethodCharacteristicNT.NodeTypeId, ResultTypeNTP, true, 3, 1);
CharacteristicNTP.DesignNode.AttributeProperty[CswNbtFieldTypeRuleList.AttributeName.Options].AsText.Text = "pH,Arsenic,Lead,Cadmium,Mercury";
} // update()
}//_addBalanceNT()
public void _addBalanceConfigurationNT()
{
CswNbtMetaDataObjectClass BalanceConfigurationOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.BalanceConfigurationClass );
if( null == BalanceConfigurationOC.FirstNodeType )
{
CswNbtMetaDataNodeType BalanceConfigurationNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( new CswNbtWcfMetaDataModel.NodeType( BalanceConfigurationOC )
{
NodeTypeName = "Balance Configuration",
Category = "System",
} );
BalanceConfigurationNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassBalanceConfiguration.PropertyName.Name ) );
}
}//_addBalanceConfigurationNT()
public override void update()
{
CswNbtMetaDataObjectClass TestingLabMethodAssignmentOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.TestingLabMethodAssignmentClass);
_CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType(new CswNbtWcfMetaDataModel.NodeType(TestingLabMethodAssignmentOC)
{
Category = "MLM",
ObjectClass = TestingLabMethodAssignmentOC,
ObjectClassId = TestingLabMethodAssignmentOC.ObjectClassId,
NodeTypeName = "Testing Lab Method Assignment",
Searchable = true,
NameTemplate = CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassTestingLabMethodAssignment.PropertyName.TestingLab) + ": " +
CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassTestingLabMethodAssignment.PropertyName.Method)
});
}
public override void update()
{
CswNbtMetaDataObjectClass CertDefConditionOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.CertDefConditionClass);
_CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType(new CswNbtWcfMetaDataModel.NodeType(CertDefConditionOC)
{
Category = "MLM",
ObjectClass = CertDefConditionOC,
ObjectClassId = CertDefConditionOC.ObjectClassId,
NodeTypeName = "CertDef Condition",
Searchable = true,
NameTemplate = CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassCertDefCondition.PropertyName.CertDefSpec) + ": " +
CswNbtMetaData.MakeTemplateEntry(CswNbtObjClassCertDefCondition.PropertyName.MethodCondition)
});
}
public override void update()
{
CswNbtMetaDataObjectClass DesignSequenceOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.DesignSequenceClass );
// Make 'Name' unique
CswNbtMetaDataObjectClassProp DesignSequenceNameOCP = DesignSequenceOC.getObjectClassProp( CswNbtObjClassDesignSequence.PropertyName.Name );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( DesignSequenceNameOCP, CswEnumNbtObjectClassPropAttributes.isunique, true );
// Set name template
foreach( CswNbtMetaDataNodeType DesignSequenceNT in DesignSequenceOC.getNodeTypes() )
{
DesignSequenceNT.DesignNode.NameTemplateText.Text = CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassDesignSequence.PropertyName.Name );
DesignSequenceNT.DesignNode.postChanges( false );
}
} // update()
} // afterPromoteNode()
private void _OnMakeNewInspectionDesignNodeType(CswNbtMetaDataNodeType NewNodeType)
{
CswNbtMetaDataNodeTypeProp NameProp = NewNodeType.getNodeTypePropByObjectClassProp(CswNbtObjClassInspectionDesign.PropertyName.Name);
CswNbtMetaDataNodeTypeProp DateProp = NewNodeType.getNodeTypePropByObjectClassProp(CswNbtObjClassInspectionDesign.PropertyName.DueDate);
CswNbtMetaDataNodeTypeProp SetPreferredProp = NewNodeType.getNodeTypePropByObjectClassProp(CswNbtObjClassInspectionDesign.PropertyName.SetPreferred);
CswNbtMetaDataNodeTypeProp FinishedProp = NewNodeType.getNodeTypePropByObjectClassProp(CswNbtObjClassInspectionDesign.PropertyName.Finish);
CswNbtMetaDataNodeTypeProp CancelledProp = NewNodeType.getNodeTypePropByObjectClassProp(CswNbtObjClassInspectionDesign.PropertyName.Cancel);
CswNbtMetaDataNodeTypeProp CancelReasonProp = NewNodeType.getNodeTypePropByObjectClassProp(CswNbtObjClassInspectionDesign.PropertyName.CancelReason);
// CIS-52810 - properties can be null if the nodetype is being copied instead of created
if (null != NameProp)
{
// Set 'Name' default value = nodetypename
NameProp.getDefaultValue(true).AsText.Text = NewNodeType.NodeTypeName;
// The following changes for new forms only
if (NewNodeType.VersionNo == 1 && false == InternalCreate)
{
// Set nametemplate = Name + Date
this.NameTemplateText.Text = CswNbtMetaData.MakeTemplateEntry(NameProp.PropName) + " " + CswNbtMetaData.MakeTemplateEntry(DateProp.PropName);
// Set first tab to be "Details"
CswNbtMetaDataNodeTypeTab FirstTab = NewNodeType.getNodeTypeTab(NewNodeType.NodeTypeName);
if (null != FirstTab)
{
//FirstTab = NewNodeType.getSecondNodeTypeTab();
FirstTab.DesignNode.TabName.Text = "Details";
FirstTab.DesignNode.Order.Value = 10;
FirstTab.DesignNode.IncludeInReport.Checked = CswEnumTristate.False;
FirstTab.DesignNode.postChanges(false);
}
// case 20951 - Add an Action tab
CswNbtMetaDataNodeTypeTab ActionTab = NewNodeType.getNodeTypeTab("Action");
if (ActionTab == null)
{
ActionTab = _CswNbtResources.MetaData.makeNewTab(NewNodeType, "Action", 9);
}
_CswNbtResources.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, NewNodeType.NodeTypeId, SetPreferredProp, true, ActionTab.TabId, 1, 1);
_CswNbtResources.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, NewNodeType.NodeTypeId, FinishedProp, true, ActionTab.TabId, 2, 1);
_CswNbtResources.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, NewNodeType.NodeTypeId, CancelledProp, true, ActionTab.TabId, 3, 1);
_CswNbtResources.MetaData.NodeTypeLayout.updatePropLayout(CswEnumNbtLayoutType.Edit, NewNodeType.NodeTypeId, CancelReasonProp, true, ActionTab.TabId, 4, 1);
} // if( NewNodeType.VersionNo == 1 && !IsCopy )
} // if( null != NameProp )
} // OnMakeNewInspectionDesignNodeType()
public override void update()
{
//Set Size NTs name template to "[{Unit Count}] x {Initial Quantity} {Catalog No}"
CswNbtMetaDataObjectClass sizeOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.SizeClass );
foreach( CswNbtMetaDataNodeType sizeNT in sizeOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp unitCountNTP = sizeNT.getNodeTypePropByObjectClassProp( CswNbtObjClassSize.PropertyName.UnitCount );
CswNbtMetaDataNodeTypeProp initQuantNTP = sizeNT.getNodeTypePropByObjectClassProp( CswNbtObjClassSize.PropertyName.InitialQuantity );
CswNbtMetaDataNodeTypeProp catalogNoNTP = sizeNT.getNodeTypePropByObjectClassProp( CswNbtObjClassSize.PropertyName.CatalogNo );
string unitCountTmp = CswNbtMetaData.MakeTemplateEntry( unitCountNTP.PropName );
string initQuantTmp = CswNbtMetaData.MakeTemplateEntry( initQuantNTP.PropName );
string catNoTmp = CswNbtMetaData.MakeTemplateEntry( catalogNoNTP.PropName );
sizeNT.setNameTemplateText( "[" + unitCountTmp + "] x " + initQuantTmp + " " + catNoTmp );
}
} //Update()
public override void update()
{
//change the Request NT name to '{Name} {Date Submitted}' and change the submitted date to unclude the time
CswNbtMetaDataObjectClass requestOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.RequestClass );
foreach( CswNbtMetaDataNodeType requestNT in requestOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp nameNTP = requestNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRequest.PropertyName.Name );
CswNbtMetaDataNodeTypeProp dateSubmittedNTP = requestNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRequest.PropertyName.SubmittedDate );
dateSubmittedNTP.Extended = CswNbtNodePropDateTime.DateDisplayMode.DateTime.ToString();
string newNameTemplate = CswNbtMetaData.MakeTemplateEntry( nameNTP.PropName ) + " " + CswNbtMetaData.MakeTemplateEntry( dateSubmittedNTP.PropName );
requestNT.setNameTemplateText( newNameTemplate );
}
} //Update()
