public override void update()
{
CswNbtMetaDataObjectClass BatchOpOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.BatchOpClass );
CswNbtMetaDataObjectClassProp BatchOpOpNameOCP = BatchOpOC.getObjectClassProp( CswNbtObjClassBatchOp.PropertyName.OpName );
CswNbtMetaDataFieldType TextFieldType = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Text );
// Update object_class_props
CswTableUpdate ObjectClassPropsTableUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "object_class_props_tbl_update_case_30263", "object_class_props" );
DataTable OCPDataTable = ObjectClassPropsTableUpdate.getTable( "where objectclassid = " + BatchOpOC.ObjectClassId + " and propname = '" + BatchOpOpNameOCP.PropName + "'" );
if( OCPDataTable.Rows.Count > 0 )
{
OCPDataTable.Rows[0]["fieldtypeid"] = TextFieldType.FieldTypeId;
}
ObjectClassPropsTableUpdate.update( OCPDataTable );
//Update nodetype_props
foreach( CswNbtMetaDataNodeType BatchOpNT in BatchOpOC.getNodeTypes() )
{
CswTableUpdate NodetypePropsTableUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "nodetype_props_tbl_update_case_30263", "nodetype_props" );
DataTable NTPDataTable = NodetypePropsTableUpdate.getTable( "where nodetypeid = " + BatchOpNT.NodeTypeId + " and objectclasspropid = '" + BatchOpOpNameOCP.PropId + "'" );
if( NTPDataTable.Rows.Count > 0 )
{
NTPDataTable.Rows[0]["fieldtypeid"] = TextFieldType.FieldTypeId;
}
NodetypePropsTableUpdate.update( NTPDataTable );
}
} // update()
public bool MoveNext()
{
bool ReachedEnd = false;
bool FoundProp = false;
while (!ReachedEnd && !FoundProp)
{
_Position++;
if (_Position > (_PropList.Count - 1))
{
ReachedEnd = true;
}
else
{
CswNbtMetaDataFieldType CurrentFieldType = ((CswNbtNodePropWrapper)_PropList[_Position]).getFieldType();
if (CurrentFieldType.FieldType == _FieldType)
{
FoundProp = true;
}
}
}
return(!ReachedEnd);
}//MoveNext()
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 override void update()
{
CswNbtMetaDataObjectClass materialOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.MaterialClass );
CswNbtMetaDataObjectClassProp specificGravityOCP = materialOC.getObjectClassProp( CswNbtObjClassMaterial.PropertyName.SpecificGravity );
CswNbtMetaDataFieldType numberFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Number );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( specificGravityOCP, CswNbtMetaDataObjectClassProp.ObjectClassPropAttributes.fieldtypeid, numberFT.FieldTypeId );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( specificGravityOCP, CswNbtMetaDataObjectClassProp.ObjectClassPropAttributes.numberminvalue, 0 );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( specificGravityOCP, CswNbtMetaDataObjectClassProp.ObjectClassPropAttributes.numberprecision, 3 );
}
public override void update()
{
_CswNbtSchemaModTrnsctn.MetaData.makeNewFieldType( CswEnumNbtFieldType.Formula, CswEnumNbtFieldTypeDataType.TEXT );
CswNbtMetaDataObjectClass ChemicalOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ChemicalClass );
CswNbtMetaDataObjectClassProp FormulaOCP = ChemicalOC.getObjectClassProp( CswNbtObjClassChemical.PropertyName.Formula );
CswNbtMetaDataFieldType FormulaFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Formula );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( FormulaOCP, CswEnumNbtObjectClassPropAttributes.fieldtypeid, FormulaFT.FieldTypeId );
} // update()
public override void update()
{
CswNbtMetaDataFieldType FormulaFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Formula );
CswTableUpdate FieldTypeUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "31076_update_fieldtypes", "field_types" );
DataTable FieldTypeTable = FieldTypeUpdate.getTable( "fieldtypeid", FormulaFT.FieldTypeId );
if( FieldTypeTable.Rows.Count > 0 )
{
FieldTypeTable.Rows[0]["searchable"] = CswConvert.ToDbVal( true );
FieldTypeUpdate.update( FieldTypeTable );
}
} // update()
public override void update()
{
// REGULATORY LIST LIST CODE: Change ListCode OCP from Number to Text
CswNbtMetaDataObjectClass RegListListCodeOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RegulatoryListListCodeClass );
CswNbtMetaDataObjectClassProp ListCodeOCP = RegListListCodeOC.getObjectClassProp( CswNbtObjClassRegulatoryListListCode.PropertyName.ListCode );
CswNbtMetaDataFieldType TextFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Text );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( ListCodeOCP, CswEnumNbtObjectClassPropAttributes.fieldtypeid, TextFT.FieldTypeId );
} // update()
public override void update()
{
CswNbtFieldTypeRuleCASNo CasNo_FTRule = (CswNbtFieldTypeRuleCASNo) _CswNbtSchemaModTrnsctn.MetaData.getFieldTypeRule( CswNbtMetaDataFieldType.NbtFieldType.CASNo );
CswNbtMetaDataFieldType CasNo_FT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.CASNo );
foreach( CswNbtSubField subfield in CasNo_FTRule.SubFields )
{
_CswNbtSchemaModTrnsctn.createFieldTypesSubFieldsJunction( CasNo_FT, subfield.Column, subfield.Name, true );
}
} //Update()
public override void update()
{
CswNbtMetaDataFieldType BarcodeFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Barcode );
string SelectText = "select nodetypepropid from nodetype_props where fieldtypeid = " + BarcodeFT.FieldTypeId;
CswArbitrarySelect GetBarcodePropsSelect = _CswNbtSchemaModTrnsctn.makeCswArbitrarySelect( "Get Barcode Props Select", SelectText );
DataTable BarcodePropsTable = GetBarcodePropsSelect.getTable();
foreach( DataRow BarcodePropsRow in BarcodePropsTable.Rows )
{
CswNbtMetaDataNodeTypeProp BarcodeProp = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( CswConvert.ToInt32( BarcodePropsRow["nodetypepropid"] ) );
BarcodeProp.ReadOnly = true;
}
} // update()
}// getDesignNodeType()
public static void getDesignNodeTypePropDefinition( ICswResources CswResources, CswNbtDesignReturn Return, string FieldTypeId )
{
CswNbtResources _CswNbtResources = (CswNbtResources) CswResources;
Int32 FieldTypePk = CswConvert.ToInt32( FieldTypeId );
CswNbtMetaDataFieldType FT = _CswNbtResources.MetaData.getFieldType( FieldTypePk );
CswNbtMetaDataNodeType FieldTypeNT = _CswNbtResources.MetaData.getNodeType( CswNbtObjClassDesignNodeTypeProp.getNodeTypeName( FT.FieldType ) );
if( null != FieldTypeNT )
{
DesignResponse DesignResponse = new DesignResponse();
DesignResponse.NodeTypeId = FieldTypeNT.NodeTypeId;
DesignResponse.ObjectClassId = FieldTypeNT.ObjectClassId;
Return.Data = DesignResponse;
}
}
/// <summary>
/// For loading from a string (created by ToString())
/// </summary>
public CswNbtViewProperty(CswNbtResources CswNbtResources, CswNbtView View, CswDelimitedString PropertyString)
: base(CswNbtResources, View)
{
if (PropertyString[0] == CswEnumNbtViewNodeType.CswNbtViewProperty.ToString())
{
if (PropertyString[1] != string.Empty)
{
Type = PropertyString[1];
}
if (PropertyString[2] != string.Empty)
{
NodeTypePropId = CswConvert.ToInt32(PropertyString[2]);
}
if (PropertyString[3] != string.Empty)
{
Name = PropertyString[3];
}
//if( Values[4] != string.Empty )
// ArbitraryId = Values[4];
if (PropertyString[5] != string.Empty)
{
SortBy = Convert.ToBoolean(PropertyString[5]);
}
if (PropertyString[6] != string.Empty)
{
SortMethod = PropertyString[6];
}
if (PropertyString[7] != string.Empty)
{
FieldType = CswNbtMetaDataFieldType.getFieldTypeFromString(PropertyString[7]);
}
if (PropertyString[8] != string.Empty)
{
Order = CswConvert.ToInt32(PropertyString[8]);
}
if (PropertyString[9] != string.Empty)
{
Width = CswConvert.ToInt32(PropertyString[9]);
}
if (PropertyString[10] != string.Empty)
{
ObjectClassPropId = CswConvert.ToInt32(PropertyString[10]);
}
if (PropertyString[11] != string.Empty)
{
ShowInGrid = CswConvert.ToBoolean(PropertyString[11]);
}
}
}
public override void update()
{
//Part 4
CswNbtMetaDataObjectClass UserOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.UserClass );
CswNbtMetaDataObjectClass RequestItemOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.RequestItemClass );
CswNbtMetaDataObjectClassProp AssgnedToOcp = _CswNbtSchemaModTrnsctn.createObjectClassProp( RequestItemOc, new CswNbtWcfMetaDataModel.ObjectClassProp
{
PropName = CswNbtObjClassRequestItem.PropertyName.AssignedTo,
FieldType = CswNbtMetaDataFieldType.NbtFieldType.Relationship,
IsFk = true,
FkType = NbtViewRelatedIdType.ObjectClassId.ToString(),
FkValue = UserOc.ObjectClassId
} );
//Bug fix
CswNbtMetaDataObjectClassProp TypeOcp = RequestItemOc.getObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Type );
CswNbtMetaDataFieldType ListFt = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.List );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( TypeOcp, CswNbtMetaDataObjectClassProp.ObjectClassPropAttributes.fieldtypeid, ListFt.FieldTypeId );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( TypeOcp, CswNbtMetaDataObjectClassProp.ObjectClassPropAttributes.listoptions, CswNbtObjClassRequestItem.Types.Options.ToString() );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( TypeOcp, CswNbtMetaDataObjectClassProp.ObjectClassPropAttributes.readOnly, true );
//Part 5
CswNbtMetaDataObjectClassProp StatusOcp = RequestItemOc.getObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Status );
CswNbtView DispenseRequestsView = _CswNbtSchemaModTrnsctn.makeNewView( "Dispense Requests: Open", NbtViewVisibility.Global );
DispenseRequestsView.ViewMode = NbtViewRenderingMode.Tree;
DispenseRequestsView.Category = "Requests";
CswNbtViewRelationship RequestItemsVr = DispenseRequestsView.AddViewRelationship( RequestItemOc, true );
DispenseRequestsView.AddViewPropertyAndFilter( RequestItemsVr, AssgnedToOcp, "me" );
DispenseRequestsView.AddViewPropertyAndFilter( RequestItemsVr, TypeOcp, CswNbtObjClassRequestItem.Types.Dispense );
DispenseRequestsView.AddViewPropertyAndFilter( RequestItemsVr, StatusOcp, CswNbtObjClassRequestItem.Statuses.Completed, FilterMode: CswNbtPropFilterSql.PropertyFilterMode.NotEquals );
DispenseRequestsView.AddViewPropertyAndFilter( RequestItemsVr, StatusOcp, CswNbtObjClassRequestItem.Statuses.Cancelled, FilterMode: CswNbtPropFilterSql.PropertyFilterMode.NotEquals );
DispenseRequestsView.AddViewPropertyAndFilter( RequestItemsVr, StatusOcp, CswNbtObjClassRequestItem.Statuses.Dispensed, FilterMode: CswNbtPropFilterSql.PropertyFilterMode.NotEquals );
DispenseRequestsView.save();
//Part 6
_CswNbtSchemaModTrnsctn.createObjectClassProp( RequestItemOc, new CswNbtWcfMetaDataModel.ObjectClassProp
{
PropName = CswNbtObjClassRequestItem.PropertyName.Fulfill,
FieldType = CswNbtMetaDataFieldType.NbtFieldType.Button,
Extended = CswNbtNodePropButton.ButtonMode.menu,
ListOptions = CswNbtObjClassRequestItem.FulfillMenu.Options.ToString(),
StaticText = CswNbtObjClassRequestItem.FulfillMenu.Dispense
} );
}//Update()
public override void update()
{
CswNbtMetaDataObjectClass DesignSequenceOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.DesignSequenceClass );
CswNbtMetaDataNodeType DesignSequenceNT = DesignSequenceOC.getNodeTypes().FirstOrDefault();
if( null == DesignSequenceNT )
{
throw new CswDniException( CswEnumErrorType.Error, "No design sequence nodetype exists", "Cannot create a Sequence property for batch operations when no Design Sequence NT exists" );
}
Collection<CswNbtNode> Sequences = _getNodesByPropertyValue( DesignSequenceOC, CswNbtObjClassDesignSequence.PropertyName.Name, "BatchOpId" );
CswNbtObjClassDesignSequence SequenceNode = null;
if( Sequences.Count > 0 )
{
SequenceNode = Sequences[0];
}
else
{
SequenceNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( DesignSequenceNT.NodeTypeId, delegate( CswNbtNode NewNode )
{
CswNbtObjClassDesignSequence AsSequence = NewNode;
AsSequence.Name.Text = "BatchOpId";
AsSequence.Pre.Text = "Bat";
AsSequence.Pad.Value = 6;
} );
}
CswNbtMetaDataFieldType SequenceFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Sequence );
CswNbtMetaDataObjectClass BatchOpOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.BatchOpClass );
foreach( CswNbtMetaDataNodeType BatchOpNT in BatchOpOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp BatchOpIdNTP = BatchOpNT.getNodeTypeProp( "Batch Op Id" );
if( null == BatchOpIdNTP )
{
BatchOpIdNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( BatchOpNT, SequenceFT, "Batch Op Id" ) );
CswNbtMetaDataNodeTypeProp DesignSequenceNTP = BatchOpIdNTP.DesignNode.NodeType.getNodeTypeProp( "Sequence" );
if( null == DesignSequenceNTP )
{
throw new CswDniException(CswEnumErrorType.Error, "Cannot add sequence to Batch Operation when no Sequence relationship exists on the Sequence NTP Node", "The design node for Sequences does not have a Sequence NTP");
}
BatchOpIdNTP.DesignNode.Node.Properties[DesignSequenceNTP].AsRelationship.RelatedNodeId = SequenceNode.NodeId;
BatchOpIdNTP.DesignNode.postChanges( false );
}
}
} // update()
public override void update()
{
CswNbtMetaDataFieldType LinkFieldType = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Link );
string where = "where jctnodepropid in (select jnp.jctnodepropid from jct_nodes_props jnp" +
" join nodetype_props ntp on jnp.nodetypepropid = ntp.nodetypepropid" +
" where ntp.fieldtypeid = " + LinkFieldType.FieldTypeId + " and jnp.field2 is not null)";
CswTableUpdate linkTU = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "31057.UpdateLinkPropsHrefCol", "jct_nodes_props" );
DataTable jct_nodes_props = linkTU.getTable( new CswCommaDelimitedString() { "field1_big,field2" }, string.Empty, Int32.MinValue, where, false );
foreach( DataRow Row in jct_nodes_props.Rows )
{
Row["field1_big"] = Row["field2"];
Row["field2"] = string.Empty;
}
linkTU.update( jct_nodes_props );
} // update()
public override void update()
{
//Add Legacy Id NTP to all NTs and make sure it's hidden
string LegacyIdPropName = "Legacy Id";
CswNbtMetaDataFieldType numberFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Number );
foreach( CswNbtMetaDataNodeType NodeType in _CswNbtSchemaModTrnsctn.MetaData.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp legacyIdNTP = NodeType.getNodeTypeProp( LegacyIdPropName );
if( null == legacyIdNTP )
{
legacyIdNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( NodeType, numberFT, LegacyIdPropName ) );
legacyIdNTP.ServerManaged = true;
}
legacyIdNTP.removeFromAllLayouts();
}
} //Update()
/// <summary>
/// The actual update call
/// </summary>
public override void update()
{
CswNbtFieldTypeRuleQuantity QuantityFTRule = (CswNbtFieldTypeRuleQuantity)_CswNbtSchemaModTrnsctn.MetaData.getFieldTypeRule(CswEnumNbtFieldType.Quantity);
CswNbtMetaDataFieldType QuantityFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType(CswEnumNbtFieldType.Quantity);
//Fix "value" so that we don't get a duplicate with "Value"
CswTableUpdate FTSubUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate("QuantityFTUpdate", "field_types_subfields");
DataTable FTSubTable = FTSubUpdate.getTable("where fieldtypeid = " + QuantityFT.FieldTypeId + " and propcolname = '" + CswEnumNbtPropColumn.Field1_Numeric + "'");
if (FTSubTable.Rows.Count > 0)
{
FTSubTable.Rows[0].Delete();
FTSubUpdate.update(FTSubTable);
}
foreach (CswNbtSubField SubField in QuantityFTRule.SubFields)
{
_CswNbtSchemaModTrnsctn.createFieldTypesSubFieldsJunction(QuantityFT, SubField.Column, SubField.Name, true);
}
}
/// <summary>
/// The actual update call
/// </summary>
public override void update()
{
CswNbtMetaDataFieldType UserSelectFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType(CswEnumNbtFieldType.UserSelect);
CswTableUpdate FTSubUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate("UserSelectUpdate", "field_types_subfields");
DataTable FTSubTable = FTSubUpdate.getTable("where fieldtypeid = " + UserSelectFT.FieldTypeId + " and propcolname = '" + CswEnumNbtPropColumn.Field1 + "'");
if (FTSubTable.Rows.Count > 0)
{
FTSubTable.Rows[0]["propcolname"] = CswEnumNbtPropColumn.ClobData;
FTSubUpdate.update(FTSubTable);
}
_CswNbtSchemaModTrnsctn.execArbitraryPlatformNeutralSql(@"
update jct_nodes_props jnp
set clobdata = field1,
field1 = null
where jnp.nodetypepropid in
(select nodetypepropid
from nodetype_props ntp
where ntp.fieldtypeid = " + UserSelectFT.FieldTypeId + ")");
}
public override void update()
{
/*
* I realize that most of the time you do not want to go directly to the table, but in this specific case I was %100 guarenteed that there were
* no material nodes running wild and that I would be able to change the field type directly in the table without fear of having nodes with
* data filled in the Scientific property. If there were, that would mean this would result in nodes having Scientific prop type data in a
* Number prop type field...that's bad and would have dire consequences.
*
* tldr; DON'T USE THIS AS A TEMPLATE TO SOLVE SIMILIAR PROBLEMS!
*/
CswNbtMetaDataObjectClass materialOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.MaterialClass );
CswNbtMetaDataObjectClassProp specificGravityOCP = materialOC.getObjectClassProp( CswNbtObjClassMaterial.SpecificGravityPropertyName );
CswNbtMetaDataFieldType numberFieldType = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Number );
if( null != numberFieldType )
{
CswTableUpdate tableOCPUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "OCP_SpecGravity_26835", "object_class_props" );
DataTable ocpTable = tableOCPUpdate.getTable( "objectclasspropid", specificGravityOCP.ObjectClassPropId );
foreach( DataRow row in ocpTable.Rows )
{
row["fieldtypeid"] = numberFieldType.FieldTypeId;
}
tableOCPUpdate.update( ocpTable );
CswTableUpdate tableNTPUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "NTP_SpecGravity_26835", "nodetype_props" );
DataTable ntpTable = tableNTPUpdate.getTable( "objectclasspropid", specificGravityOCP.ObjectClassPropId );
foreach( DataRow row in ntpTable.Rows )
{
row["fieldtypeid"] = numberFieldType.FieldTypeId;
}
tableNTPUpdate.update( ntpTable );
}
_CswNbtSchemaModTrnsctn.MetaData.SetObjectClassPropDefaultValue( specificGravityOCP, specificGravityOCP.getFieldTypeRule().SubFields.Default.Name, 1 );
_CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp( specificGravityOCP, CswNbtMetaDataObjectClassProp.ObjectClassPropAttributes.isrequired, true );
}//Update()
public override void update()
{
CswNbtMetaDataObjectClass ContainerOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.ContainerClass );
foreach( CswNbtMetaDataNodeType ContainerNt in ContainerOc.getLatestVersionNodeTypes() )
{
CswNbtMetaDataNodeTypeProp StatusNtp = ContainerNt.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.StatusPropertyName );
StatusNtp.removeFromAllLayouts();
CswNbtMetaDataNodeTypeProp LocationVerifiedNtp = ContainerNt.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.LocationVerifiedPropertyName );
LocationVerifiedNtp.removeFromAllLayouts();
CswNbtMetaDataNodeTypeProp SourceContainerNtp = ContainerNt.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.SourceContainerPropertyName );
SourceContainerNtp.removeFromAllLayouts();
CswNbtMetaDataNodeTypeProp DisposedNtp = ContainerNt.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.DisposedPropertyName );
DisposedNtp.removeFromAllLayouts();
}
CswNbtMetaDataNodeType ChemicalNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Chemical" );
if( null != ChemicalNt )
{
CswNbtMetaDataFieldType Memo = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Memo );
CswNbtMetaDataNodeTypeProp SahNtp = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNt, Memo, "Storage and Handling" ) );
CswNbtMetaDataNodeTypeTab HazardsTab = ChemicalNt.getNodeTypeTab( "Hazards" );
if( null == HazardsTab )
{
HazardsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( ChemicalNt, "Hazards", Int32.MinValue );
}
SahNtp.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, HazardsTab.TabId );
CswNbtMetaDataFieldType Text = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Text );
CswNbtMetaDataNodeTypeProp IsoNtp = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNt, Text, "Isotope" ) );
CswNbtMetaDataNodeTypeTab PhysicalTab = ChemicalNt.getNodeTypeTab( "Physical" );
if( null == PhysicalTab )
{
PhysicalTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( ChemicalNt, "Physical", Int32.MinValue );
}
IsoNtp.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, PhysicalTab.TabId );
}
}//Update()
public override void update()
{
CswNbtMetaDataFieldType TextFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Text );
//update the FT of existing Legacy Id OC props
CswTableUpdate legacyIdOCPTU = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "LegacyIdTableUpdate_OCP", "object_class_props" );
DataTable ocpTbl = legacyIdOCPTU.getTable( "where propname = '" + CswNbtObjClass.PropertyName.LegacyId + "'" );
foreach( DataRow row in ocpTbl.Rows )
{
row["fieldtypeid"] = TextFT.FieldTypeId;
}
legacyIdOCPTU.update( ocpTbl );
CswTableUpdate legacyIdNTPTU = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "LegacyIdTableUpdate_NTP", "nodetype_props" );
DataTable ntpTbl = legacyIdNTPTU.getTable( "where propname = '" + CswNbtObjClass.PropertyName.LegacyId + "'" );
foreach( DataRow row in ntpTbl.Rows )
{
row["fieldtypeid"] = TextFT.FieldTypeId;
}
legacyIdNTPTU.update( ntpTbl );
//Create new Legacy Id props if needed
foreach( CswNbtMetaDataObjectClass ObjectClass in _CswNbtSchemaModTrnsctn.MetaData.getObjectClasses() )
{
CswNbtMetaDataObjectClassProp LegacyIdOCP = ObjectClass.getObjectClassProp( CswNbtObjClass.PropertyName.LegacyId );
if( null == LegacyIdOCP )
{
_CswNbtSchemaModTrnsctn.createObjectClassProp( new CswNbtWcfMetaDataModel.ObjectClassProp( ObjectClass )
{
FieldType = CswEnumNbtFieldType.Text,
PropName = CswNbtObjClass.PropertyName.LegacyId
} );
}
}
} // update()
public override void update()
{
//Move blob data from jct_nodes_props to blob_data
CswNbtMetaDataFieldType molFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.MOL );
CswNbtMetaDataFieldType imageFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Image );
CswNbtMetaDataFieldType fileFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.File );
string sql = "select distinct nodetypeid from nodetype_props where fieldtypeid in (" + molFT.FieldTypeId + "," + imageFT.FieldTypeId + "," + fileFT.FieldTypeId + ")";
CswArbitrarySelect arbSelect = _CswNbtSchemaModTrnsctn.makeCswArbitrarySelect( "findBlobDataNTs", sql );
DataTable nodeTypes = arbSelect.getTable();
foreach( DataRow Row in nodeTypes.Rows )
{
int NodeTypeId = CswConvert.ToInt32( Row["nodetypeid"].ToString() );
CswNbtMetaDataNodeType NodeType = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( NodeTypeId );
if( null != NodeType )
{
foreach( CswNbtNode Node in NodeType.getNodes( false, true, false, true ) )
{
foreach( CswNbtMetaDataNodeTypeProp Prop in NodeType.getNodeTypeProps() )
{
CswEnumNbtFieldType Type = Prop.getFieldTypeValue();
if( Type == CswEnumNbtFieldType.MOL ||
Type == CswEnumNbtFieldType.File ||
Type == CswEnumNbtFieldType.Image )
{
CswNbtNodePropWrapper propWrapper = Node.Properties[Prop];
_moveBlobData( propWrapper, Node );
}
}
}
}
}
} // update()
/// <summary>
/// New Filters to offer, based on Results
/// </summary>
public JArray FilterOptions(ICswNbtTree Tree)
{
JArray FiltersArr = new JArray();
Tree.goToRoot();
bool SingleNodeType = IsSingleNodeType();
if (false == SingleNodeType)
{
// Filter on NodeTypes only
SortedList <string, NodeTypeEntry> NodeTypeOptions = new SortedList <string, NodeTypeEntry>();
Int32 ChildCnt = Tree.getChildNodeCount();
for (Int32 n = 0; n < ChildCnt; n++)
{
Tree.goToNthChild(n);
CswNbtNodeKey NodeKey = Tree.getNodeKeyForCurrentPosition();
if (NodeKey != null)
{
CswNbtMetaDataNodeType NodeType = _CswNbtResources.MetaData.getNodeType(NodeKey.NodeTypeId);
string LatestName = NodeType.getNodeTypeLatestVersion().NodeTypeName;
if (false == NodeTypeOptions.ContainsKey(LatestName))
{
NodeTypeOptions.Add(LatestName, new NodeTypeEntry
{
NodeType = NodeType,
NodeTypeId = NodeType.NodeTypeId,
LatestName = LatestName,
Count = 0
});
}
NodeTypeOptions[LatestName].Count += 1;
}
Tree.goToParentNode();
} // for( Int32 n = 0; n < ChildCnt; n++ )
if (NodeTypeOptions.Keys.Count == 1)
{
if (false == IsSingleNodeType())
{
// If we have uniform results but no nodetype filter applied
// add the filter to the filters list for display
NodeTypeEntry entry = NodeTypeOptions.Values[0];
CswNbtSearchFilter NodeTypeFilter = makeFilter(entry.NodeType, entry.Count, false, CswEnumNbtSearchPropOrderSourceType.Unknown);
addFilter(NodeTypeFilter);
}
SingleNodeType = true;
}
else
{
JArray FilterSet = new JArray();
FiltersArr.Add(FilterSet);
foreach (NodeTypeEntry entry in NodeTypeOptions.Values)
{
CswNbtSearchFilter NodeTypeFilter = makeFilter(entry.NodeType, entry.Count, true, CswEnumNbtSearchPropOrderSourceType.Unknown);
FilterSet.Add(NodeTypeFilter.ToJObject());
}
}
} // if( false == SingleNodeType )
if (SingleNodeType)
{
// Filter on property values in the results
Collection <Int32> FilteredPropIds = getFilteredPropIds();
Dictionary <Int32, Dictionary <string, Int32> > PropCounts = new Dictionary <Int32, Dictionary <string, Int32> >();
SortedSet <CswNbtSearchPropOrder.SearchOrder> PropOrder = new SortedSet <CswNbtSearchPropOrder.SearchOrder>();
Int32 ChildCnt = Tree.getChildNodeCount();
for (Int32 n = 0; n < ChildCnt; n++)
{
Tree.goToNthChild(n);
if (0 == PropOrder.Count)
{
PropOrder = _CswNbtSearchPropOrder.getPropOrderDict(Tree.getNodeKeyForCurrentPosition());
}
Collection <CswNbtTreeNodeProp> Props = Tree.getChildNodePropsOfNode();
foreach (CswNbtTreeNodeProp Prop in Props)
{
CswNbtMetaDataFieldType FieldType = _CswNbtResources.MetaData.getFieldType(Prop.FieldType);
if (false == FilteredPropIds.Contains(Prop.NodeTypePropId) && FieldType.Searchable)
{
string Gestalt = Prop.Gestalt;
if (Gestalt.Length > 50)
{
Gestalt = Gestalt.Substring(0, 50);
}
if (false == PropCounts.ContainsKey(Prop.NodeTypePropId))
{
PropCounts[Prop.NodeTypePropId] = new Dictionary <string, Int32>();
}
if (false == PropCounts[Prop.NodeTypePropId].ContainsKey(Gestalt))
{
PropCounts[Prop.NodeTypePropId][Gestalt] = 0;
}
PropCounts[Prop.NodeTypePropId][Gestalt] += 1;
}
}
Tree.goToParentNode();
} // for( Int32 n = 0; n < ChildCnt; n++ )
foreach (Int32 NodeTypePropId in PropCounts.Keys.OrderBy(NodeTypePropId => PropOrder.First(Order => Order.NodeTypePropId == NodeTypePropId).Order))
{
CswNbtMetaDataNodeTypeProp NodeTypeProp = _CswNbtResources.MetaData.getNodeTypePropLatestVersion(NodeTypePropId);
if (false == NodeTypeProp.IsUnique()) // case 27649
{
CswNbtSearchPropOrder.SearchOrder order = PropOrder.First(Order => Order.NodeTypePropId == NodeTypePropId);
JArray FilterSet = new JArray();
FiltersArr.Add(FilterSet);
// Sort by count descending, then alphabetically by gestalt
Dictionary <string, Int32> sortedDict = (from entry
in PropCounts[NodeTypePropId]
orderby entry.Value descending, entry.Key ascending
select entry
).ToDictionary(pair => pair.Key, pair => pair.Value);
foreach (string Value in sortedDict.Keys)
{
Int32 Count = sortedDict[Value];
CswNbtSearchFilter Filter = makeFilter(NodeTypeProp, Value, Count, true, order.Source);
FilterSet.Add(Filter.ToJObject());
}
} // if( false == NodeTypeProp.IsUnique() )
} // foreach( Int32 NodeTypePropId in PropCounts.Keys.OrderBy( NodeTypePropId => PropOrder.First( Order => Order.NodeTypePropId == NodeTypePropId ).Order ) )
} // if( SingleNodeType )
return(FiltersArr);
} // FilterOptions()
/// <summary>
/// For loading from XML
/// </summary>
public CswNbtViewProperty(CswNbtResources CswNbtResources, CswNbtView View, XmlNode PropNode)
: base(CswNbtResources, View)
{
try
{
if (PropNode.Attributes["type"] != null)
{
Type = PropNode.Attributes["type"].Value;
}
if (PropNode.Attributes["value"] != null) //backwards compatibility
{
if (Type == CswEnumNbtViewPropType.NodeTypePropId)
{
NodeTypePropId = CswConvert.ToInt32(PropNode.Attributes["value"].Value);
}
else
{
ObjectClassPropId = CswConvert.ToInt32(PropNode.Attributes["value"].Value);
}
}
if (PropNode.Attributes["nodetypepropid"] != null)
{
NodeTypePropId = CswConvert.ToInt32(PropNode.Attributes["nodetypepropid"].Value);
}
if (PropNode.Attributes["objectclasspropid"] != null)
{
ObjectClassPropId = CswConvert.ToInt32(PropNode.Attributes["objectclasspropid"].Value);
}
if (PropNode.Attributes["name"] != null)
{
Name = PropNode.Attributes["name"].Value;
}
//if( PropNode.Attributes["arbitraryid"] != null )
// ArbitraryId = PropNode.Attributes["arbitraryid"].Value;
if (PropNode.Attributes["sortby"] != null)
{
SortBy = Convert.ToBoolean(PropNode.Attributes["sortby"].Value);
}
if (PropNode.Attributes["sortmethod"] != null)
{
SortMethod = PropNode.Attributes["sortmethod"].Value;
}
if (PropNode.Attributes["fieldtype"] != null && PropNode.Attributes["fieldtype"].Value != string.Empty)
{
FieldType = CswNbtMetaDataFieldType.getFieldTypeFromString(PropNode.Attributes["fieldtype"].Value);
}
if (PropNode.Attributes["order"] != null && PropNode.Attributes["order"].Value != string.Empty)
{
Order = CswConvert.ToInt32(PropNode.Attributes["order"].Value);
}
if (PropNode.Attributes["width"] != null && PropNode.Attributes["width"].Value != string.Empty)
{
Width = CswConvert.ToInt32(PropNode.Attributes["width"].Value);
}
if (PropNode.Attributes["showingrid"] != null && PropNode.Attributes["showingrid"].Value != string.Empty)
{
ShowInGrid = CswConvert.ToBoolean(PropNode.Attributes["showingrid"].Value);
}
}
catch (Exception ex)
{
throw new CswDniException(CswEnumErrorType.Error, "Misconfigured CswViewProperty",
"CswViewProperty.constructor(xmlnode) encountered an invalid attribute value",
ex);
}
try
{
foreach (XmlNode ChildNode in PropNode.ChildNodes)
{
if (ChildNode.Name.ToLower() == CswEnumNbtViewXmlNodeName.Filter.ToString().ToLower())
{
CswNbtViewPropertyFilter Filter = new CswNbtViewPropertyFilter(CswNbtResources, _View, ChildNode);
this.addFilter(Filter);
}
}
}
catch (Exception ex)
{
throw new CswDniException(CswEnumErrorType.Error, "Misconfigured CswViewProperty",
"CswViewProperty.constructor(xmlnode) encountered an invalid filter definition",
ex);
}
}
/// <summary>
/// For loading from JSON
/// </summary>
public CswNbtViewProperty(CswNbtResources CswNbtResources, CswNbtView View, JObject PropObj)
: base(CswNbtResources, View)
{
try
{
string _Type = CswConvert.ToString(PropObj["type"]);
if (!string.IsNullOrEmpty(_Type))
{
Type = _Type;
}
Int32 _Value = CswConvert.ToInt32(PropObj["value"]);
if (Int32.MinValue != _Value) //backwards compatibility
{
if (Type == CswEnumNbtViewPropType.NodeTypePropId)
{
NodeTypePropId = _Value;
}
else
{
ObjectClassPropId = _Value;
}
}
Int32 _NtPropId = CswConvert.ToInt32(PropObj["nodetypepropid"]);
if (Int32.MinValue != _NtPropId)
{
NodeTypePropId = _NtPropId;
}
Int32 _OcPropId = CswConvert.ToInt32(PropObj["objectclasspropid"]);
if (Int32.MinValue != _OcPropId)
{
ObjectClassPropId = _OcPropId;
}
string _Name = CswConvert.ToString(PropObj["name"]);
if (!string.IsNullOrEmpty(_Name))
{
Name = _Name;
}
if (PropObj["sortby"] != null)
{
bool _Sort = CswConvert.ToBoolean(PropObj["sortby"]);
SortBy = _Sort;
}
string _SortedMethod = CswConvert.ToString(PropObj["sortmethod"]);
if (!string.IsNullOrEmpty(_SortedMethod))
{
SortMethod = _SortedMethod;
}
string _FieldType = CswConvert.ToString(PropObj["fieldtype"]);
if (!string.IsNullOrEmpty(_FieldType))
{
FieldType = CswNbtMetaDataFieldType.getFieldTypeFromString(_FieldType);
}
Int32 _Order = CswConvert.ToInt32(PropObj["order"]);
if (Int32.MinValue != _Order)
{
Order = _Order;
}
Int32 _Width = CswConvert.ToInt32(PropObj["width"]);
if (Int32.MinValue != _Width)
{
Width = _Width;
}
ShowInGrid = CswConvert.ToBoolean(PropObj["showingrid"]);
}
catch (Exception ex)
{
throw new CswDniException(CswEnumErrorType.Error, "Misconfigured CswViewProperty",
"CswViewProperty.constructor(xmlnode) encountered an invalid attribute value",
ex);
}
try
{
JProperty FiltersProp = PropObj.Property(_FiltersName);
if (null != FiltersProp)
{
JObject FiltersObj = (JObject)FiltersProp.Value;
foreach (CswNbtViewPropertyFilter Filter in
from FilterProp
in FiltersObj.Properties()
select(JObject) FilterProp.Value
into FilterObj
let NodeName = CswConvert.ToString(FilterObj["nodename"])
where NodeName == CswEnumNbtViewXmlNodeName.Filter.ToString().ToLower()
select new CswNbtViewPropertyFilter(CswNbtResources, _View, FilterObj))
{
this.addFilter(Filter);
}
}
}
catch (Exception ex)
{
throw new CswDniException(CswEnumErrorType.Error, "Misconfigured CswViewProperty",
"CswViewProperty.constructor(xmlnode) encountered an invalid filter definition",
ex);
}
}
public override void update()
{
#region NodeTypes
CswNbtMetaDataObjectClass RequestOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.RequestClass );
string RequestNodeTypeName = "Request";
CswNbtMetaDataNodeType RequestNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( RequestNodeTypeName );
if( null != RequestNt && RequestNt.ObjectClassId != RequestOc.ObjectClassId )
{
RequestNodeTypeName = "CISPro Request";
RequestNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( RequestNodeTypeName );
}
if( null != RequestNt && RequestNt.ObjectClassId != RequestOc.ObjectClassId )
{
throw new CswDniException( ErrorType.Error, "Could not create a unique Request NodeType", "Request nodetypes named 'Request' and 'CISPro Request' already exist." );
}
if( null == RequestNt )
{
RequestNt = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( new CswNbtWcfMetaDataModel.NodeType( RequestOc )
{
Category = "Requests",
NodeTypeName = RequestNodeTypeName
} );
}
CswNbtMetaDataNodeTypeProp NameNtp = RequestNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequest.PropertyName.Name.ToString() );
CswNbtMetaDataNodeTypeProp UserNtp = RequestNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequest.PropertyName.Requestor.ToString() );
CswNbtMetaDataNodeTypeProp DateNtp = RequestNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequest.PropertyName.SubmittedDate.ToString() );
RequestNt.NameTemplateValue = "";
RequestNt.addNameTemplateText( NameNtp.PropName );
RequestNt.addNameTemplateText( UserNtp.PropName );
RequestNt.addNameTemplateText( DateNtp.PropName );
CswNbtMetaDataObjectClass RequestItemOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.RequestItemClass );
string RequestItemNodeTypeName = "Request Item";
CswNbtMetaDataNodeType RequestItemNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( RequestItemNodeTypeName );
if( null != RequestItemNt && RequestItemNt.ObjectClassId != RequestItemOc.ObjectClassId )
{
RequestItemNodeTypeName = "CISPro Request Item";
RequestNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( RequestItemNodeTypeName );
}
if( null != RequestItemNt && RequestItemNt.ObjectClassId != RequestItemOc.ObjectClassId )
{
throw new CswDniException( ErrorType.Error, "Could not create a unique Request Item NodeType", "Request nodetypes named 'Request Item' and 'CISPro Request Item' already exist." );
}
if( null == RequestItemNt )
{
RequestItemNt = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType(new CswNbtWcfMetaDataModel.NodeType(RequestItemOc)
{
Category = "Requests",
NodeTypeName = RequestItemNodeTypeName
});
}
CswNbtMetaDataNodeTypeProp RequestItemRequestNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Request );
RequestItemRequestNtp.SetFK( NbtViewRelatedIdType.NodeTypeId.ToString(), RequestNt.NodeTypeId );
CswNbtMetaDataNodeTypeProp TypeNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Type );
CswNbtMetaDataNodeTypeProp StatusNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Status );
CswNbtMetaDataNodeTypeProp ExternalOrderNoNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.ExternalOrderNumber );
CswNbtMetaDataNodeTypeProp QuantityNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Quantity );
CswNbtMetaDataNodeTypeProp CountNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Count );
CswNbtMetaDataNodeTypeProp SizeNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Size );
CswNbtMetaDataNodeTypeProp MaterialNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Material );
CswNbtMetaDataNodeTypeProp ContainerNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Container );
CswNbtMetaDataNodeTypeProp LocationNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Location );
CswNbtMetaDataNodeTypeProp NumberNtp = RequestItemNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestItem.PropertyName.Number );
Int32 SequenceId = _CswNbtSchemaModTrnsctn.makeSequence( new CswSequenceName( "Request Items" ), "R", "", 6, 1 );
NumberNtp.setSequence( SequenceId );
RequestItemNt.addNameTemplateText( RequestItemRequestNtp.PropName );
RequestItemNt.addNameTemplateText( NumberNtp.PropName );
RequestItemNt.addNameTemplateText( TypeNtp.PropName );
#endregion NodeTypes
#region Tabs
CswNbtMetaDataNodeTypeTab RequestItemsNtt = RequestNt.getNodeTypeTab( "Request Items" );
if( null == RequestItemsNtt )
{
RequestItemsNtt = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( RequestNt, "Request Items",
RequestNt.getNodeTypeTabIds().Count );
}
CswNbtMetaDataFieldType GridFt =
_CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Grid );
CswNbtMetaDataNodeTypeProp RequestItemsGridNtp =
_CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( RequestNt,
GridFt,
"Request Items" )
{
TabId = RequestItemsNtt.TabId
} );
CswNbtView GridView = _CswNbtSchemaModTrnsctn.ViewSelect.restoreView( RequestItemsGridNtp.ViewId );
GridView.ViewName = "Requested Items";
GridView.Visibility = NbtViewVisibility.Property;
GridView.ViewMode = NbtViewRenderingMode.Grid;
GridView.Category = "Requests";
GridView.Root.ChildRelationships.Clear();
CswNbtViewRelationship RequestRel = GridView.AddViewRelationship( RequestNt, false );
CswNbtViewRelationship RequestItemRel = GridView.AddViewRelationship( RequestRel,
NbtViewPropOwnerType.Second,
RequestItemRequestNtp, false );
GridView.AddViewProperty( RequestItemRel, NumberNtp );
GridView.AddViewProperty( RequestItemRel, TypeNtp );
GridView.AddViewProperty( RequestItemRel, ExternalOrderNoNtp );
GridView.AddViewProperty( RequestItemRel, StatusNtp );
GridView.AddViewProperty( RequestItemRel, QuantityNtp );
GridView.AddViewProperty( RequestItemRel, CountNtp );
GridView.AddViewProperty( RequestItemRel, SizeNtp );
GridView.AddViewProperty( RequestItemRel, MaterialNtp );
GridView.AddViewProperty( RequestItemRel, ContainerNtp );
GridView.AddViewProperty( RequestItemRel, LocationNtp );
GridView.save();
#endregion Tabs
#region Views
string MyRequestViewName = "My Request History";
bool UniqueView = _CswNbtSchemaModTrnsctn.restoreViews( MyRequestViewName ).Count == 0;
if( false == UniqueView )
{
MyRequestViewName = "My CISPro Request History";
UniqueView = _CswNbtSchemaModTrnsctn.restoreViews( MyRequestViewName ).Count == 0;
}
if( UniqueView )
{
CswNbtView MyRequestsView = _CswNbtSchemaModTrnsctn.makeView();
MyRequestsView.makeNew( MyRequestViewName, NbtViewVisibility.Global );
MyRequestsView.Category = "Requests";
MyRequestsView.ViewMode = NbtViewRenderingMode.Tree;
CswNbtViewRelationship RequestVr = MyRequestsView.AddViewRelationship( RequestNt, true );
MyRequestsView.AddViewPropertyAndFilter( RequestVr, RequestNt.getNodeTypePropByObjectClassProp( CswNbtObjClassRequest.PropertyName.SubmittedDate.ToString() ), FilterMode: CswNbtPropFilterSql.PropertyFilterMode.NotNull );
MyRequestsView.save();
}
#endregion Views
}//Update()
public override void update()
{
CswNbtMetaDataNodeType ContainerNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Container" );
if( null != ContainerNT )
{
CswNbtMetaDataNodeTypeTab ContainerTab = ContainerNT.getFirstNodeTypeTab();
CswNbtMetaDataNodeTypeProp StoragePressureNTP =
_CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp( ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.StoragePressure );
CswNbtMetaDataNodeTypeProp StorageTemperatureNTP =
_CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp( ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.StorageTemperature );
CswNbtMetaDataNodeTypeProp UseTypeNTP =
_CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp( ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.UseType );
StoragePressureNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
StorageTemperatureNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
UseTypeNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
StoragePressureNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, ContainerTab.TabId, 1, 2, "Fire Reporting");
StorageTemperatureNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, ContainerTab.TabId, 2, 2, "Fire Reporting" );
UseTypeNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, ContainerTab.TabId, 3, 2, "Fire Reporting" );
}
CswNbtMetaDataNodeType ChemicalNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Chemical" );
if( null != ChemicalNT )
{
foreach( CswNbtMetaDataNodeTypeTab Tab in ChemicalNT.getNodeTypeTabs() )
{
if( Tab.TabOrder >= 2 )
Tab.TabOrder += 1;
}
CswNbtMetaDataNodeTypeTab HazardsTab = ChemicalNT.getNodeTypeTab( "Hazards" );
if( null == HazardsTab )
{
HazardsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( ChemicalNT, "Hazards", 2 );
}
HazardsTab.TabOrder = 2;
CswNbtMetaDataFieldType ListFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.List );
CswNbtMetaDataFieldType MultiListFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.MultiList );
CswNbtMetaDataNodeTypeProp ChemicalMaterialTypeNTP =
_CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, ListFT, "Material Type" ) );
CswNbtMetaDataNodeTypeProp ChemicalSpecialFlagsNTP =
_CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, MultiListFT, "Special Flags" ) );
CswNbtMetaDataNodeTypeProp ChemicalHazardCategoriesNTP =
_CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, MultiListFT, "Hazard Categories" ) );
CswNbtMetaDataNodeTypeProp ChemicalHazardClassesNTP =
_CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, MultiListFT, "Hazard Classes" ) );
ChemicalMaterialTypeNTP.ListOptions = "Pure,Mixture";
ChemicalMaterialTypeNTP.DefaultValue.AsList.Value = "Pure";
ChemicalMaterialTypeNTP.IsRequired = true;
ChemicalSpecialFlagsNTP.ListOptions = "EHS,Waste,Not Reportable";
CswCommaDelimitedString SpecialFlags = new CswCommaDelimitedString();
SpecialFlags.FromString( "Not Reportable" );
ChemicalSpecialFlagsNTP.DefaultValue.AsMultiList.Value = SpecialFlags;
ChemicalHazardCategoriesNTP.ListOptions = "F = Fire,C = Chronic (delayed),I = Immediate (acute),R = Reactive,P = Pressure";
CswCommaDelimitedString FireHazardClassTypes = new CswCommaDelimitedString {
"Aero-1",
"Aero-2",
"Aero-3",
"Carc",
"CF/D (baled)",
"CF/D (loose)",
"CL-II",
"CL-IIIA",
"CL-IIIB",
"Corr",
"CRY-FG",
"CRY-OXY",
"Exp",
"FG (gaseous)",
"FG (liquified)",
"FL-1A",
"FL-1B",
"FL-1C",
"FS",
"HT",
"Irr",
"OHH",
"Oxy-1",
"Oxy-2",
"Oxy-3",
"Oxy-4",
"Oxy-Gas",
"Oxy-Gas (liquid)",
"Perox-Det",
"Perox-I",
"Perox-II",
"Perox-III",
"Perox-IV",
"Perox-V",
"Pyro",
"RAD-Alpha",
"RAD-Beta",
"RAD-Gamma",
"Sens",
"Tox",
"UR-1",
"UR-2",
"UR-3",
"UR-4",
"WR-1",
"WR-2",
"WR-3"
};
ChemicalHazardClassesNTP.ListOptions = FireHazardClassTypes.ToString();
ChemicalMaterialTypeNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalSpecialFlagsNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalHazardCategoriesNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalHazardClassesNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalMaterialTypeNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, HazardsTab.TabId, 2, 2, "Fire Reporting" );
ChemicalSpecialFlagsNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, HazardsTab.TabId, 3, 2, "Fire Reporting" );
ChemicalHazardCategoriesNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, HazardsTab.TabId, 4, 2, "Fire Reporting" );
ChemicalHazardClassesNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, HazardsTab.TabId, 5, 2, "Fire Reporting" );
foreach( CswNbtNode ChemicalNode in ChemicalNT.getNodes( false, false ) )
{
ChemicalNode.Properties[ChemicalMaterialTypeNTP].AsList.Value = "Pure";
ChemicalNode.Properties[ChemicalSpecialFlagsNTP].AsMultiList.Value = SpecialFlags;
ChemicalNode.postChanges( false );
}
}
}
public override void update()
{
//get field types used for this class
CswNbtMetaDataFieldType memoFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Memo );
CswNbtMetaDataFieldType logicalFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Logical );
CswNbtMetaDataFieldType textFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Text );
#region CREATE THE REGULATORY LIST OC AND IT'S PROPS
CswNbtMetaDataObjectClass regulatoryListOC = _CswNbtSchemaModTrnsctn.createObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.RegulatoryListClass, "doc.png", true, true );
CswNbtMetaDataObjectClassProp nameOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( new CswNbtWcfMetaDataModel.ObjectClassProp( regulatoryListOC )
{
PropName = CswNbtObjClassRegulatoryList.PropertyName.Name,
FieldType = CswNbtMetaDataFieldType.NbtFieldType.Text,
IsFk = false,
IsRequired = true,
IsUnique = true
} );
CswNbtMetaDataObjectClassProp casNumbersOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( new CswNbtWcfMetaDataModel.ObjectClassProp( regulatoryListOC )
{
PropName = CswNbtObjClassRegulatoryList.PropertyName.CASNumbers,
FieldType = CswNbtMetaDataFieldType.NbtFieldType.Memo,
IsFk = false,
IsRequired = true
} );
#endregion
#region CREATE THE REGULATORY LIST NODETYPE
CswNbtMetaDataNodeType regulatoryListNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( regulatoryListOC.ObjectClassId, "Regulatory List", "Materials" );
regulatoryListNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( CswNbtObjClassRegulatoryList.PropertyName.Name ) ); //set display name
CswNbtMetaDataNodeTypeProp casNosNTP = regulatoryListNT.getNodeTypePropByObjectClassProp( CswNbtObjClassRegulatoryList.PropertyName.CASNumbers );
casNosNTP.HelpText = "The CASNos property should be a comma delimited set of CASNos in this regulatory list. Example: \"CASNo1,CASNo2,CASNo3\"";
#endregion
#region CREATE REGULATORY LISTS VIEW
CswNbtObjClassRole cisProAdminRole = _CswNbtSchemaModTrnsctn.Nodes.makeRoleNodeFromRoleName( "CISPro_Admin" );
if( null != cisProAdminRole )
{
CswNbtView regListsView = _CswNbtSchemaModTrnsctn.makeNewView( "Regulatory Lists", NbtViewVisibility.Role, cisProAdminRole.NodeId );
regListsView.SetViewMode( NbtViewRenderingMode.Tree );
regListsView.Category = "CISPro Configuration";
CswNbtViewRelationship parent = regListsView.AddViewRelationship( regulatoryListOC, false );
regListsView.save();
}
#endregion
#region ADD REGULATORY LIST NODETYPE PERMISSIONS TO CISPro_Admin
if( null != cisProAdminRole )
{
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.View, regulatoryListNT, cisProAdminRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.Create, regulatoryListNT, cisProAdminRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.Edit, regulatoryListNT, cisProAdminRole, true );
_CswNbtSchemaModTrnsctn.Permit.set( CswNbtPermit.NodeTypePermission.Delete, regulatoryListNT, cisProAdminRole, true );
}
#endregion
}//Update()
private void _createLinkGridProp()
{
//Add the Assigned SDS link grid prop
CswNbtMetaDataObjectClass materialOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.MaterialClass );
CswNbtMetaDataNodeType materialDocumentNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Material Document" );
if( null != materialDocumentNT )
{
CswNbtMetaDataNodeTypeProp documentMaterialOCP = materialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Owner );
CswNbtMetaDataNodeTypeProp archivedOCP = materialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Archived );
CswNbtMetaDataNodeTypeProp docClassOCP = materialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.DocumentClass );
CswNbtMetaDataNodeTypeProp titleOCP = materialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Title );
CswNbtMetaDataNodeTypeProp languageOCP = materialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Language );
CswNbtMetaDataNodeTypeProp formatOCP = materialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Format );
CswNbtMetaDataNodeTypeProp revisionDateNTP = materialDocumentNT.getNodeTypeProp( "Revision Date" );
CswNbtMetaDataNodeTypeProp fileOCP = materialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.File );
CswNbtMetaDataNodeTypeProp linkOCP = materialDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Link );
Collection<CswNbtMetaDataNodeTypeProp> propsToAdd = new Collection<CswNbtMetaDataNodeTypeProp>();
propsToAdd.Add( titleOCP );
propsToAdd.Add( languageOCP );
propsToAdd.Add( formatOCP );
if( null != revisionDateNTP )
{
propsToAdd.Add( revisionDateNTP );
}
propsToAdd.Add( fileOCP );
propsToAdd.Add( linkOCP );
CswNbtView assignedSDSView_1 = _CswNbtSchemaModTrnsctn.makeNewView( "Assigned SDS", NbtViewVisibility.Property );
CswNbtView assignedSDSView_2 = _CswNbtSchemaModTrnsctn.makeNewView( "Assigned SDS", NbtViewVisibility.Property );
CswNbtView assignedSDSView_3 = _CswNbtSchemaModTrnsctn.makeNewView( "Assigned SDS", NbtViewVisibility.Property );
Collection<CswNbtView> sdsViews = new Collection<CswNbtView>();
sdsViews.Add( assignedSDSView_1 );
sdsViews.Add( assignedSDSView_2 );
sdsViews.Add( assignedSDSView_3 );
foreach( CswNbtView sdsView in sdsViews )
{
sdsView.SetViewMode( NbtViewRenderingMode.Grid );
CswNbtViewRelationship materialParent = sdsView.AddViewRelationship( materialOC, true );
CswNbtViewRelationship documentParent = sdsView.AddViewRelationship( materialParent, NbtViewPropOwnerType.Second, documentMaterialOCP, true );
sdsView.AddViewPropertyAndFilter( documentParent,
MetaDataProp: archivedOCP,
Value: CswConvert.ToDbVal( false ).ToString(),
FilterMode: CswNbtPropFilterSql.PropertyFilterMode.Equals,
ShowInGrid: false );
sdsView.AddViewPropertyAndFilter( documentParent,
MetaDataProp: docClassOCP,
Value: CswNbtObjClassDocument.DocumentClasses.SDS,
FilterMode: CswNbtPropFilterSql.PropertyFilterMode.Equals,
ShowInGrid: false );
foreach( CswNbtMetaDataNodeTypeProp prop in propsToAdd )
{
sdsView.AddViewProperty( documentParent, prop );
}
sdsView.save();
}
string ntpName = "Assigned SDS";
int num = 0;
foreach( CswNbtMetaDataNodeType materialNT in materialOC.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp assignedSDSNTP = materialNT.getNodeTypeProp( ntpName );
if( null == assignedSDSNTP )
{
CswNbtMetaDataFieldType gridFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Grid );
assignedSDSNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( materialNT, gridFT, ntpName ) );
assignedSDSNTP.Extended = CswNbtNodePropGrid.GridPropMode.Link._Name;
assignedSDSNTP.ViewId = sdsViews[num].ViewId;
num++;
if( materialNT.NodeTypeName.Equals( "Chemical" ) )
{
CswNbtMetaDataNodeTypeProp hazardousNTP = materialNT.getNodeTypeProp( "Hazardous" );
if( null != hazardousNTP )
{
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, assignedSDSNTP, hazardousNTP, true );
hazardousNTP.removeFromAllLayouts();
_CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, hazardousNTP, assignedSDSNTP, true );
}
}
else
{
assignedSDSNTP.removeFromAllLayouts();
}
}
}
}
}
public override void update()
{
CswNbtMetaDataObjectClass GenericOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.GenericClass );
CswNbtMetaDataObjectClass MaterialOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.MaterialClass );
CswNbtMetaDataFieldType TextFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Text );
CswNbtMetaDataFieldType ListFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.List );
CswNbtMetaDataFieldType GridFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Grid );
CswNbtMetaDataFieldType ImageListFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.ImageList );
CswNbtMetaDataFieldType RelationshipFT = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswNbtMetaDataFieldType.NbtFieldType.Relationship );
//// Jurisdiction NodeType
//CswNbtMetaDataNodeType JurisdictionNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( new CswNbtWcfMetaDataModel.NodeType( GenericOC )
//{
// NodeTypeName = "Jurisdiction",
// Category = "System",
// IconFileName = "globe.gif"
//} );
//CswNbtMetaDataNodeTypeProp JurisdictionNameNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( JurisdictionNT, TextFT, "Name" ) );
//JurisdictionNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( "Name" ) );
//// Default Jurisdictions
//CswNbtNode JurisNorthAmericaNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( JurisdictionNT.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode );
//JurisNorthAmericaNode.Properties[JurisdictionNameNTP].AsText.Text = "North America";
//JurisNorthAmericaNode.postChanges( false );
//CswNbtNode JurisEuropeNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( JurisdictionNT.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode );
//JurisEuropeNode.Properties[JurisdictionNameNTP].AsText.Text = "Europe";
//JurisEuropeNode.postChanges( false );
// GHS Phrase NodeType
CswNbtMetaDataNodeType GHSPhraseNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( new CswNbtWcfMetaDataModel.NodeType( GenericOC )
{
NodeTypeName = "GHS Phrase",
Category = "System",
IconFileName = "group.gif"
} );
CswNbtMetaDataNodeTypeProp GHSPhraseCodeNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, TextFT, "Code" ) );
CswNbtMetaDataNodeTypeProp GHSPhraseCategoryNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, ListFT, "Category" ) );
CswNbtMetaDataNodeTypeProp GHSPhraseEnglishNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, TextFT, "English" ) );
CswNbtMetaDataNodeTypeProp GHSPhraseChineseNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, TextFT, "Chinese" ) );
CswNbtMetaDataNodeTypeProp GHSPhraseDanishNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, TextFT, "Danish" ) );
CswNbtMetaDataNodeTypeProp GHSPhraseDutchNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, TextFT, "Dutch" ) );
CswNbtMetaDataNodeTypeProp GHSPhraseFrenchNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, TextFT, "French" ) );
CswNbtMetaDataNodeTypeProp GHSPhraseGermanNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, TextFT, "German" ) );
CswNbtMetaDataNodeTypeProp GHSPhraseSpanishNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSPhraseNT, TextFT, "Spanish" ) );
GHSPhraseCategoryNTP.ListOptions = "Physical,Health,Environmental";
GHSPhraseNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( "Code" ) );
_CswNbtSchemaModTrnsctn.createModuleNodeTypeJunction( CswNbtResources.CswNbtModule.CISPro, GHSPhraseNT.NodeTypeId );
// GHS NodeType
CswNbtMetaDataNodeType GHSNT = _CswNbtSchemaModTrnsctn.MetaData.makeNewNodeType( new CswNbtWcfMetaDataModel.NodeType( GenericOC )
{
NodeTypeName = "GHS",
Category = "Materials",
IconFileName = "ball_redS.gif"
} );
CswNbtMetaDataNodeTypeProp GHSTypeNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSNT, ListFT, "Type" ) { IsRequired = true } );
CswNbtMetaDataNodeTypeProp GHSMaterialNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSNT, RelationshipFT, "Material" ) { IsRequired = true } );
CswNbtMetaDataNodeTypeProp GHSGHSPhraseNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSNT, RelationshipFT, "GHS Phrase" ) { IsRequired = true } );
//CswNbtMetaDataNodeTypeProp GHSJurisdictionNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSNT, RelationshipFT, "Jurisdiction" ) { IsRequired = true } );
CswNbtMetaDataNodeTypeProp GHSJurisdictionNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( GHSNT, ListFT, "Jurisdiction" ) { IsRequired = true } );
GHSTypeNTP.ListOptions = "Class Code, Label Code";
GHSMaterialNTP.SetFK( NbtViewRelatedIdType.ObjectClassId.ToString(), MaterialOC.ObjectClassId );
GHSGHSPhraseNTP.SetFK( NbtViewRelatedIdType.NodeTypeId.ToString(), GHSPhraseNT.NodeTypeId );
//GHSJurisdictionNTP.SetFK( NbtViewRelatedIdType.NodeTypeId.ToString(), JurisdictionNT.NodeTypeId );
GHSJurisdictionNTP.ListOptions = "North America, China, Europe, Japan";
_CswNbtSchemaModTrnsctn.createModuleNodeTypeJunction( CswNbtResources.CswNbtModule.CISPro, GHSNT.NodeTypeId );
// Chemical GHS Tab
CswNbtMetaDataNodeType ChemicalNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Chemical" );
if( null != ChemicalNT )
{
foreach( CswNbtMetaDataNodeTypeTab Tab in ChemicalNT.getNodeTypeTabs() )
{
if( Tab.TabOrder >= 3 )
Tab.TabOrder += 1;
}
CswNbtMetaDataNodeTypeTab GHSTab = ChemicalNT.getNodeTypeTab( "GHS" );
if( null == GHSTab )
{
GHSTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( ChemicalNT, "GHS", 3 );
}
GHSTab.TabOrder = 3;
// Chemical GHS properties
CswNbtMetaDataNodeTypeProp ChemicalGHSClassificationNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, ListFT, "GHS Classification" ) );
CswNbtMetaDataNodeTypeProp ChemicalGHSClassCodesNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, GridFT, "GHS Class Codes" ) );
CswNbtMetaDataNodeTypeProp ChemicalGHSSignalWordNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, ListFT, "GHS Signal Word" ) );
CswNbtMetaDataNodeTypeProp ChemicalGHSLabelCodesNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, GridFT, "GHS Label Codes" ) );
CswNbtMetaDataNodeTypeProp ChemicalGHSPictosNTP = _CswNbtSchemaModTrnsctn.MetaData.makeNewProp( new CswNbtWcfMetaDataModel.NodeTypeProp( ChemicalNT, ImageListFT, "GHS Pictos" ) );
CswCommaDelimitedString GHSClasses = new CswCommaDelimitedString(){
"Category 1",
"Category 1 / 1A / 1B",
"Category 1A",
"Category 1A / 1B",
"Category 1A / 1B / 1C",
"Category 1B",
"Category 2",
"Category 2 (skin)/2A (eye)",
"Category 2A",
"Category 2B",
"Category 3",
"Category 4",
"Category 5",
"Type A",
"Type B",
"Type C&D",
"Type E&F",
"Compressed Gas",
"Liquified Gas",
"Dissolved Gas",
"Refridgerated Liquidified Gas"
};
ChemicalGHSClassificationNTP.ListOptions = GHSClasses.ToString();
ChemicalGHSSignalWordNTP.ListOptions = "Danger,Warning";
ChemicalGHSClassificationNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalGHSClassCodesNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalGHSSignalWordNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalGHSLabelCodesNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalGHSPictosNTP.removeFromLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Add );
ChemicalGHSClassificationNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, GHSTab.TabId, 1, 1, "Hazard Classification" );
ChemicalGHSClassCodesNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, GHSTab.TabId, 2, 1, "Hazard Classification" );
ChemicalGHSSignalWordNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, GHSTab.TabId, 3, 1, "Hazard Label" );
ChemicalGHSLabelCodesNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, GHSTab.TabId, 4, 1, "Hazard Label" );
ChemicalGHSPictosNTP.updateLayout( CswNbtMetaDataNodeTypeLayoutMgr.LayoutType.Edit, true, GHSTab.TabId, 5, 1, "Hazard Label" );
// Grid Views
CswNbtView GHSClassCodesView = _CswNbtSchemaModTrnsctn.restoreView( ChemicalGHSClassCodesNTP.ViewId );
GHSClassCodesView.Root.ChildRelationships.Clear();
CswNbtViewRelationship ChemicalVR1 = GHSClassCodesView.AddViewRelationship( ChemicalNT, false );
CswNbtViewRelationship GHSVR1 = GHSClassCodesView.AddViewRelationship( ChemicalVR1, NbtViewPropOwnerType.Second, GHSMaterialNTP, true );
CswNbtViewRelationship GHSPhraseVR1 = GHSClassCodesView.AddViewRelationship( GHSVR1, NbtViewPropOwnerType.First, GHSGHSPhraseNTP, true );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseCodeNTP );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseCategoryNTP );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseEnglishNTP );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseChineseNTP );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseDanishNTP );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseDutchNTP );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseFrenchNTP );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseGermanNTP );
GHSClassCodesView.AddViewProperty( GHSPhraseVR1, GHSPhraseSpanishNTP );
GHSClassCodesView.AddViewPropertyAndFilter( GHSVR1, GHSTypeNTP, Value: "Class Code" );
GHSClassCodesView.AddViewPropertyAndFilter( GHSVR1, GHSJurisdictionNTP, Value: "North America", ShowAtRuntime: true );
GHSClassCodesView.save();
CswNbtView GHSLabelCodesView = _CswNbtSchemaModTrnsctn.restoreView( ChemicalGHSLabelCodesNTP.ViewId );
GHSLabelCodesView.Root.ChildRelationships.Clear();
CswNbtViewRelationship ChemicalVR2 = GHSLabelCodesView.AddViewRelationship( ChemicalNT, false );
CswNbtViewRelationship GHSVR2 = GHSLabelCodesView.AddViewRelationship( ChemicalVR2, NbtViewPropOwnerType.Second, GHSMaterialNTP, true );
CswNbtViewRelationship GHSPhraseVR2 = GHSLabelCodesView.AddViewRelationship( GHSVR2, NbtViewPropOwnerType.First, GHSGHSPhraseNTP, true );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseCodeNTP );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseCategoryNTP );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseEnglishNTP );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseChineseNTP );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseDanishNTP );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseDutchNTP );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseFrenchNTP );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseGermanNTP );
GHSLabelCodesView.AddViewProperty( GHSPhraseVR2, GHSPhraseSpanishNTP );
GHSLabelCodesView.AddViewPropertyAndFilter( GHSVR2, GHSTypeNTP, Value: "Label Code" );
GHSLabelCodesView.AddViewPropertyAndFilter( GHSVR2, GHSJurisdictionNTP, Value: "North America", ShowAtRuntime: true );
GHSLabelCodesView.save();
// Picto Options
ChemicalGHSPictosNTP.Extended = "true"; // allow multiple values
ChemicalGHSPictosNTP.TextAreaColumns = 100;
ChemicalGHSPictosNTP.TextAreaRows = 100;
CswDelimitedString PictoNames = new CswDelimitedString( '\n' ) {
"Chemical",
"Explosive",
"Flammable",
"Natural",
"Oxidizer",
"Danger",
"X"
};
CswDelimitedString PictoPaths = new CswDelimitedString( '\n' ) {
//"Images/cispro/1-1.gif",
//"Images/cispro/1-2.gif",
//"Images/cispro/1-3.gif",
//"Images/cispro/1-4.gif",
//"Images/cispro/1-5.gif",
//"Images/cispro/1-6.gif",
//"Images/cispro/5-2.gif",
"Images/cispro/acide.gif",
//"Images/cispro/acide2.gif",
//"Images/cispro/blan-red.gif",
//"Images/cispro/bleu4.gif",
//"Images/cispro/bleu4-noir.gif",
"Images/cispro/bottle.gif",
"Images/cispro/exclam.gif",
"Images/cispro/explos.gif",
"Images/cispro/flamme.gif",
//"Images/cispro/jaune5-1.gif",
"Images/cispro/pollu.gif",
"Images/cispro/rondflam.gif",
//"Images/cispro/rouge2.gif",
//"Images/cispro/rouge2_noir.gif",
//"Images/cispro/rouge3.gif",
//"Images/cispro/rouge3_noir.gif",
"Images/cispro/silouete.gif",
"Images/cispro/skull.gif"
//"Images/cispro/skull_2.gif",
//"Images/cispro/skull6.gif",
//"Images/cispro/stripes.gif",
//"Images/cispro/vert.gif"
};
ChemicalGHSPictosNTP.ListOptions = PictoNames.ToString();
ChemicalGHSPictosNTP.ValueOptions = PictoPaths.ToString();
}
//GHS Phrase nodes
Dictionary<Int32, string> GHSPhraseCodes = new Dictionary<Int32, string>();
//Physical
GHSPhraseCodes.Add( 200, "Unstable explosive" );
GHSPhraseCodes.Add( 201, "Explosive; mass explosion hazard" );
GHSPhraseCodes.Add( 202, "Explosive; severe projection hazard" );
GHSPhraseCodes.Add( 203, "Explosive; fire, blast or projection hazard" );
GHSPhraseCodes.Add( 204, "Fire or projection hazard" );
GHSPhraseCodes.Add( 205, "May mass explode in fire" );
GHSPhraseCodes.Add( 220, "Extremely flammable gas" );
GHSPhraseCodes.Add( 221, "Flammable gas" );
GHSPhraseCodes.Add( 222, "Extremely flammable material" );
GHSPhraseCodes.Add( 223, "Flammable material" );
GHSPhraseCodes.Add( 224, "Extremely flammable liquid and vapour" );
GHSPhraseCodes.Add( 225, "Highly flammable liquid and vapour" );
GHSPhraseCodes.Add( 226, "Flammable liquid and vapour" );
GHSPhraseCodes.Add( 227, "Combustible liquid" );
GHSPhraseCodes.Add( 228, "Flammable solid" );
GHSPhraseCodes.Add( 240, "Heating may cause an explosion" );
GHSPhraseCodes.Add( 241, "Heating may cause a fire or explosion" );
GHSPhraseCodes.Add( 242, "Heating may cause a fire" );
GHSPhraseCodes.Add( 250, "Catches fire spontaneously if exposed to air" );
GHSPhraseCodes.Add( 251, "Self-heating; may catch fire" );
GHSPhraseCodes.Add( 252, "Self-heating in large quantities; may catch fire" );
GHSPhraseCodes.Add( 260, "In contact with water releases flammable gases which may ignite spontaneously" );
GHSPhraseCodes.Add( 261, "In contact with water releases flammable gas" );
GHSPhraseCodes.Add( 270, "May cause or intensify fire; oxidizer" );
GHSPhraseCodes.Add( 271, "May cause fire or explosion; strong oxidizer" );
GHSPhraseCodes.Add( 272, "May intensify fire; oxidizer" );
GHSPhraseCodes.Add( 280, "Contains gas under pressure; may explode if heated" );
GHSPhraseCodes.Add( 281, "Contains refrigerated gas; may cause cryogenic burns or injury" );
GHSPhraseCodes.Add( 290, "May be corrosive to metals" );
//Health
GHSPhraseCodes.Add( 300, "Fatal if swallowed" );
GHSPhraseCodes.Add( 301, "Toxic if swallowed" );
GHSPhraseCodes.Add( 302, "Harmful if swallowed" );
GHSPhraseCodes.Add( 303, "May be harmful if swallowed" );
GHSPhraseCodes.Add( 304, "May be fatal if swallowed and enters airways" );
GHSPhraseCodes.Add( 305, "May be harmful if swallowed and enters airways" );
GHSPhraseCodes.Add( 310, "Fatal in contact with skin" );
GHSPhraseCodes.Add( 311, "Toxic in contact with skin" );
GHSPhraseCodes.Add( 312, "Harmful in contact with skin" );
GHSPhraseCodes.Add( 313, "May be harmful in contact with skin" );
GHSPhraseCodes.Add( 314, "Causes severe skin burns and eye damage" );
GHSPhraseCodes.Add( 315, "Causes skin irritation" );
GHSPhraseCodes.Add( 316, "Causes mild skin irritation" );
GHSPhraseCodes.Add( 317, "May cause an allergic skin reaction" );
GHSPhraseCodes.Add( 318, "Causes serious eye damage" );
GHSPhraseCodes.Add( 319, "Causes serious eye irritation" );
GHSPhraseCodes.Add( 320, "Causes eye irritation" );
GHSPhraseCodes.Add( 330, "Fatal if inhaled" );
GHSPhraseCodes.Add( 331, "Toxic if inhaled" );
GHSPhraseCodes.Add( 332, "Harmful if inhaled" );
GHSPhraseCodes.Add( 333, "May be harmful if inhaled" );
GHSPhraseCodes.Add( 334, "May cause allergy or asthma symptoms of breathing difficulties if inhaled" );
GHSPhraseCodes.Add( 335, "May cause respiratory irritation" );
GHSPhraseCodes.Add( 336, "May cause drowsiness or dizziness" );
GHSPhraseCodes.Add( 340, "May cause genetic defects" );
GHSPhraseCodes.Add( 341, "Suspected of causing genetic defects" );
GHSPhraseCodes.Add( 350, "May cause cancer" );
GHSPhraseCodes.Add( 351, "Suspected of causing cancer" );
GHSPhraseCodes.Add( 360, "May damage fertility or the unborn child" );
GHSPhraseCodes.Add( 361, "Suspected of damaging fertility or the unborn child" );
GHSPhraseCodes.Add( 362, "May cause harm to breast-fed children" );
GHSPhraseCodes.Add( 370, "Causes damage to organs" );
GHSPhraseCodes.Add( 371, "May cause damage to organs" );
GHSPhraseCodes.Add( 372, "Causes damage to organs through prolonged or repeated exposure" );
GHSPhraseCodes.Add( 373, "May cause damage to organs through prolonged or repeated exposure" );
// Environmental
GHSPhraseCodes.Add( 400, "Very toxic to aquatic life" );
GHSPhraseCodes.Add( 401, "Toxic to aquatic life" );
GHSPhraseCodes.Add( 402, "Harmful to aquatic life" );
GHSPhraseCodes.Add( 410, "Very toxic to aquatic life with long lasting effects" );
GHSPhraseCodes.Add( 411, "Toxic to aquatic life with long lasting effects" );
GHSPhraseCodes.Add( 412, "Harmful to aquatic life with long lasting effects" );
GHSPhraseCodes.Add( 413, "May cause long lasting harmful effects to aquatic life" );
foreach( Int32 Code in GHSPhraseCodes.Keys )
{
string Category = "Physical";
if( Code > 299 )
{
Category = "Health";
}
else if( Code > 399 )
{
Category = "Environmental";
}
CswNbtNode GHSPhraseNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( GHSPhraseNT.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode );
GHSPhraseNode.Properties[GHSPhraseCodeNTP].AsText.Text = "H" + Code.ToString();
GHSPhraseNode.Properties[GHSPhraseCategoryNTP].AsList.Value = Category;
GHSPhraseNode.Properties[GHSPhraseEnglishNTP].AsText.Text = GHSPhraseCodes[Code];
GHSPhraseNode.postChanges( false );
} // foreach( Int32 Code in GHSPhraseCodes.Keys )
}//Update()
public override void update()
{
#region Create GHS Signal Word OC
CswNbtMetaDataObjectClass SignalWordOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.GHSSignalWordClass );
if( null == SignalWordOC )
{
SignalWordOC = _CswNbtSchemaModTrnsctn.createObjectClass( CswEnumNbtObjectClass.GHSSignalWordClass, "warning.png", false );
_CswNbtSchemaModTrnsctn.createObjectClassProp( SignalWordOC, new CswNbtWcfMetaDataModel.ObjectClassProp( SignalWordOC )
{
PropName = CswNbtObjClassGHSSignalWord.PropertyName.Code,
FieldType = CswEnumNbtFieldType.Text
} );
foreach( string Language in CswNbtPropertySetPhrase.SupportedLanguages.All )
{
_CswNbtSchemaModTrnsctn.createObjectClassProp( SignalWordOC, new CswNbtWcfMetaDataModel.ObjectClassProp( SignalWordOC )
{
PropName = Language,
FieldType = CswEnumNbtFieldType.Text
} );
}
//Attached this new OC to the Phrase PS
CswNbtMetaDataPropertySet PhrasePS = _CswNbtSchemaModTrnsctn.MetaData.getPropertySet( CswEnumNbtPropertySetName.PhraseSet );
CswTableUpdate TableUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "updatePhrasePropSets", "jct_propertyset_objectclass" );
DataTable ObjClassTbl = TableUpdate.getEmptyTable();
DataRow SignalWordRow = ObjClassTbl.NewRow();
SignalWordRow["propertysetid"] = PhrasePS.PropertySetId;
SignalWordRow["objectclassid"] = SignalWordOC.ObjectClassId;
ObjClassTbl.Rows.Add( SignalWordRow );
TableUpdate.update( ObjClassTbl );
}
#endregion
#region Make GHS Signal Word prop a relationship
CswNbtMetaDataObjectClass GHS_OC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.GHSClass );
CswNbtMetaDataObjectClassProp SignalWordOCP = GHS_OC.getObjectClassProp( CswNbtObjClassGHS.PropertyName.SignalWord );
CswNbtMetaDataFieldType RelationshipFieldType = _CswNbtSchemaModTrnsctn.MetaData.getFieldType( CswEnumNbtFieldType.Relationship );
CswTableUpdate SignalWordOCPTableUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "UpdateSignalWord", "object_class_props" );
DataTable ObjClassPropsTbl = SignalWordOCPTableUpdate.getTable( "where objectclasspropid = " + SignalWordOCP.ObjectClassPropId );
foreach( DataRow row in ObjClassPropsTbl.Rows )
{
row["fieldtypeid"] = RelationshipFieldType.FieldTypeId;
row["isfk"] = CswConvert.ToDbVal( true );
row["fkvalue"] = SignalWordOC.ObjectClassId;
row["fktype"] = "ObjectClassId";
}
SignalWordOCPTableUpdate.update( ObjClassPropsTbl );
CswTableUpdate SignalWordNTPTableUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "UpdateSignalWord", "nodetype_props" );
DataTable NodeTypePropsTbl = SignalWordNTPTableUpdate.getTable( "where objectclasspropid = " + SignalWordOCP.ObjectClassPropId );
foreach( DataRow row in NodeTypePropsTbl.Rows )
{
row["fieldtypeid"] = RelationshipFieldType.FieldTypeId;
row["isfk"] = CswConvert.ToDbVal( true );
row["fkvalue"] = SignalWordOC.ObjectClassId;
row["fktype"] = "ObjectClassId";
}
SignalWordNTPTableUpdate.update( NodeTypePropsTbl );
#endregion
} // update()
