} // setupPhraseView()
private void _setupClassificationView(CswNbtView View, CswCommaDelimitedString SelectedClassIds)
{
CswNbtMetaDataObjectClass GhsClassOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.GHSClassificationClass);
CswNbtMetaDataNodeType GhsClassNT = GhsClassOC.FirstNodeType;
View.SetVisibility(CswEnumNbtViewVisibility.Hidden, null, null);
View.ViewMode = CswEnumNbtViewRenderingMode.Grid;
View.Root.ChildRelationships.Clear();
if (SelectedClassIds.Count > 0)
{
CswNbtViewRelationship ClassVR = View.AddViewRelationship(GhsClassOC, false);
foreach (string ClassId in SelectedClassIds)
{
CswPrimaryKey ClassPk = new CswPrimaryKey();
ClassPk.FromString(ClassId);
ClassVR.NodeIdsToFilterIn.Add(ClassPk);
}
View.AddViewProperty(ClassVR, GhsClassOC.getObjectClassProp(CswNbtObjClassGHSClassification.PropertyName.Category));
if (null != GhsClassNT)
{
CswNbtMetaDataNodeTypeProp LanguageProp = GhsClassNT.getNodeTypePropByObjectClassProp(_getLanguageForTranslation());
CswNbtViewProperty LanguageVP = View.AddViewProperty(ClassVR, LanguageProp);
LanguageVP.Width = 100;
}
} // if( SelectedClassIds.Count > 0 )
View.SaveToCache(IncludeInQuickLaunch: false, UpdateCache: true, KeepInQuickLaunch: false);
} // _setupClassificationView()
private Collection <CswNbtNodeKey> _loadNodeAsChildFromRow(CswNbtNodeKey ParentNodeKey, DataRow DataRowToAdd,
bool UseGrouping, string GroupName,
CswNbtViewRelationship Relationship, bool Selectable,
bool ShowInTree,
CswEnumNbtViewAddChildrenSetting AddChildren, Int32 RowCount,
bool Included = true, bool Favorited = false)
{
CswNbtMetaDataNodeType NodeType = _CswNbtResources.MetaData.getNodeType(CswConvert.ToInt32(DataRowToAdd[_CswNbtColumnNames.NodeTypeId.ToLower()].ToString()));
//string TableName = NodeType.TableName;
//string PkColumnName = _CswNbtResources.getPrimeKeyColName( TableName );
return(_loadNodeAsChild(ParentNodeKey, UseGrouping, GroupName, Relationship, Selectable, ShowInTree,
AddChildren, RowCount, Included,
DataRowToAdd[_CswNbtColumnNames.IconFileName.ToLower()].ToString(),
DataRowToAdd[_CswNbtColumnNames.NameTemplate.ToLower()].ToString(),
new CswPrimaryKey("nodes", CswConvert.ToInt32(DataRowToAdd["nodeid"])),
new CswPrimaryKey(CswConvert.ToString(DataRowToAdd["relationaltable"]), CswConvert.ToInt32(DataRowToAdd["relationalid"])),
DataRowToAdd[_CswNbtColumnNames.NodeName.ToLower()].ToString(),
CswConvert.ToInt32(DataRowToAdd[_CswNbtColumnNames.NodeTypeId.ToLower()].ToString()),
DataRowToAdd[_CswNbtColumnNames.NodeTypeName.ToLower()].ToString(),
CswConvert.ToInt32(DataRowToAdd[_CswNbtColumnNames.ObjectClassId.ToLower()].ToString()),
DataRowToAdd[_CswNbtColumnNames.ObjectClassName.ToLower()].ToString(),
CswConvert.ToBoolean(DataRowToAdd[_CswNbtColumnNames.Locked.ToLower()]),
Favorited
));
}
private void _addNodeTypeAttributes(CswNbtMetaDataNodeType NodeType, JObject ReturnVal)
{
CswEnumNbtObjectClass ObjectClass = NodeType.getObjectClassValue();
string NtName = "nodetype_" + NodeType.NodeTypeId;
ReturnVal[NtName] = new JObject();
ReturnVal[NtName]["id"] = NodeType.NodeTypeId;
ReturnVal[NtName]["name"] = NodeType.NodeTypeName;
ReturnVal[NtName]["iconfilename"] = CswNbtMetaDataObjectClass.IconPrefix16 + NodeType.IconFileName;
ReturnVal[NtName]["objectclass"] = ObjectClass.ToString();
ReturnVal[NtName]["objectclassid"] = NodeType.ObjectClassId.ToString();
switch (ObjectClass)
{
// This is expensive, and as far as I can tell, not used by anyone
//case CswEnumNbtObjectClass.InspectionDesignClass:
// CswNbtMetaDataNodeTypeProp InspectionTargetNTP = NodeType.getNodeTypePropByObjectClassProp( CswNbtObjClassInspectionDesign.PropertyName.Target );
// ReturnVal[NtName]["targetnodetypeid"] = InspectionTargetNTP.FKValue.ToString();
// if( InspectionTargetNTP.FKType == CswEnumNbtViewPropIdType.NodeTypePropId.ToString() )
// {
// ReturnVal[NtName]["targetnodetypeid"] = InspectionTargetNTP.FKValue.ToString();
// }
// break;
case CswEnumNbtObjectClass.NonChemicalClass:
case CswEnumNbtObjectClass.ChemicalClass:
ReturnVal["action"] = CswEnumNbtActionName.Create_Material;
break;
}
}
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 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()
/// <summary>
/// Creates a new user for testing with. It is the consumers responsibility to provide valid values for properties. Supplying a non-existant Role name will throw an error
/// </summary>
private CswNbtObjClassUser _createTestUser(string Username, string RoleName, int PageSize, string Language)
{
CswNbtMetaDataNodeType UserNT = TestData.CswNbtResources.MetaData.getNodeType("User");
if (null == UserNT)
{
throw new CswDniException(CswEnumErrorType.Error, "Unable to create a test User for REST API unit tests - no User NT was found", "Could not find a user NT by name 'User'");
}
CswNbtObjClassRole RoleNode = TestData.CswNbtResources.Nodes.makeRoleNodeFromRoleName(RoleName);
if (null == RoleNode)
{
throw new CswDniException(CswEnumErrorType.Error, "Unable to create a test User for REST API unit tests - no Role with name '" + RoleName + "'", "Could not find a role by name '" + RoleName + "'");
}
CswNbtObjClassUser TestUser = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(UserNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
CswNbtObjClassUser AsUser = NewNode;
AsUser.UsernameProperty.Text = Username;
AsUser.Role.RelatedNodeId = RoleNode.NodeId;
AsUser.PageSizeProperty.Value = PageSize;
AsUser.LanguageProperty.Value = Language;
});
return(TestUser);
}
public CswCommaDelimitedString SelectedNodeTypeNames()
{
CswCommaDelimitedString NodeTypeNames = new CswCommaDelimitedString();
foreach (string NodeTypeId in SelectedNodeTypeIds)
{
if (string.Empty != NodeTypeId)
{
CswNbtMetaDataNodeType NodeType = _CswNbtResources.MetaData.getNodeType(CswConvert.ToInt32(NodeTypeId));
if (null != NodeType)
{
NodeTypeNames.Add(NodeType.getNodeTypeLatestVersion().NodeTypeName);
}
}
} // foreach(string NodeTypeId in SelectedNodeTypeIds)
if (0 == NodeTypeNames.Count)
{
NodeTypeNames.Add("[none]");
}
// Sort alphabetically
NodeTypeNames.Sort();
return(NodeTypeNames);
} // SelectedNodeTypeNames()
internal void SetPPENodeTypeProp(string ListOptions, string Delimiter = ",", int HideThreshold = 5)
{
CswNbtMetaDataNodeType ChemicalNT = _CswNbtResources.MetaData.getNodeType("Chemical");
if (ChemicalNT != null)
{
CswNbtMetaDataNodeTypeProp PPENTP = _CswNbtResources.MetaData.getNodeTypeProp(ChemicalNT.NodeTypeId, "PPE");
if (PPENTP != null)
{
_ChangedNodeTypePropListOptions.Add(PPENTP.PropId, ListOptions);
_ChangedNodeTypePropExtended.Add(PPENTP.PropId, Delimiter);
_ChangedNodeTypePropMaxValue.Add(PPENTP.PropId, HideThreshold);
//PPENTP.ListOptions = ListOptions;
//PPENTP.Extended = Delimiter;
//PPENTP.MaxValue = HideThreshold;
CswNbtFieldTypeAttribute ListOptionsAttr = PPENTP.getFieldTypeRule().getAttributes().FirstOrDefault(a => a.Column == CswEnumNbtPropertyAttributeColumn.Listoptions);
CswNbtFieldTypeAttribute ExtendedAttr = PPENTP.getFieldTypeRule().getAttributes().FirstOrDefault(a => a.Column == CswEnumNbtPropertyAttributeColumn.Extended);
CswNbtFieldTypeAttribute MaxValueAttr = PPENTP.getFieldTypeRule().getAttributes().FirstOrDefault(a => a.Column == CswEnumNbtPropertyAttributeColumn.Numbermaxvalue);
PPENTP.DesignNode.AttributeProperty[ListOptionsAttr.Name].SetSubFieldValue(ListOptionsAttr.SubFieldName, ListOptions);
PPENTP.DesignNode.AttributeProperty[ExtendedAttr.Name].SetSubFieldValue(ExtendedAttr.SubFieldName, Delimiter);
PPENTP.DesignNode.AttributeProperty[MaxValueAttr.Name].SetSubFieldValue(MaxValueAttr.SubFieldName, HideThreshold);
PPENTP.DesignNode.postChanges(false);
}
}
}
/// <summary>
/// Update logic
/// </summary>
public override void update()
{
CswNbtMetaDataObjectClass SizeOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.SizeClass );
// moved to RunBeforeEveryExecutionOfUpdater_01OC
//CswNbtMetaDataObjectClassProp UnitCountOcp = _CswNbtSchemaModTrnsctn.createObjectClassProp( new CswNbtWcfMetaDataModel.ObjectClassProp( SizeOc )
//{
// PropName = CswNbtObjClassSize.PropertyName.UnitCount,
// FieldType = CswNbtMetaDataFieldType.NbtFieldType.Number,
// IsRequired = true,
// SetValOnAdd = true,
// NumberMinValue = 1,
// NumberPrecision = 0
//} );
CswNbtMetaDataNodeType SizeNt = SizeOc.FirstNodeType;
if( null != SizeNt )
{
CswNbtMetaDataNodeTypeProp UnitCountNtp = SizeNt.getNodeTypePropByObjectClassProp( CswNbtObjClassSize.PropertyName.UnitCount );
UnitCountNtp.DefaultValue.AsNumber.Value = 1;
}
foreach( CswNbtObjClassSize SizeNode in SizeOc.getNodes( false, false ) )
{
SizeNode.UnitCount.Value = 1;
SizeNode.postChanges( false );
}
}
/// <summary>
/// Makes a temporary node of the Chemical nodetype. The reason we can't use createMaterial()
/// is because we don't have the any properties to provide to the method and tradename,
/// material type, and supplier are required.
/// </summary>
/// <param name="NodeId"></param>
/// <returns></returns>
public CswPrimaryKey makeTemp(string NodeId)
{
CswPrimaryKey Ret = new CswPrimaryKey();
CswPrimaryKey NodePk = CswConvert.ToPrimaryKey(NodeId);
if (false == CswTools.IsPrimaryKey(NodePk)) //node doesn't exist
{
CswNbtMetaDataObjectClass ChemicalOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ChemicalClass);
CswNbtMetaDataNodeType ChemicalNT = ChemicalOC.FirstNodeType;
if (null != ChemicalNT)
{
CswNbtPropertySetMaterial NewMaterialTempNode = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(ChemicalNT.NodeTypeId, IsTemp: true);
if (null != NewMaterialTempNode)
{
Ret = NewMaterialTempNode.Node.NodeId;
}
}
}
else //node exists
{
Ret = NodePk;
}
return(Ret);
}
public override void CommitOperation(ref OperationData OpData)
{
CswNbtNode itemToMove = _CswNbtResources.Nodes[OpData.Field2.NodeId];
CswNbtMetaDataNodeType thisNT = itemToMove.getNodeType();
string itemType = thisNT.NodeTypeName;
if (_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Edit, itemToMove.getNodeType()) && false == thisNT.getLocationProperty().ReadOnly)
{
ICswNbtKioskModeMoveable AsMoveable = (ICswNbtKioskModeMoveable)itemToMove.ObjClass;
string specificStatusError = string.Empty;
if (AsMoveable.CanMove(out specificStatusError))
{
CswNbtObjClassLocation locationToMoveTo = _CswNbtResources.Nodes[OpData.Field1.NodeId];
AsMoveable.Move(locationToMoveTo);
itemToMove.postChanges(false);
OpData.Log.Add(DateTime.Now + " - Moved " + itemType + " " + OpData.Field2.Value + " to " + locationToMoveTo.Location.Gestalt + " > " + locationToMoveTo.Name.Text + " (" + OpData.Field1.Value + ")");
base.CommitOperation(ref OpData);
}
else
{
OpData.Field2.FoundObjClass = string.Empty;
OpData.Field2.StatusMsg = specificStatusError;
OpData.Field2.ServerValidated = false;
OpData.Log.Add(DateTime.Now + " - ERROR: " + specificStatusError);
}
}
else
{
string statusMsg = "You do not have permission to edit " + itemType + " (" + OpData.Field2.Value + ")";
OpData.Field2.FoundObjClass = string.Empty;
OpData.Field2.StatusMsg = statusMsg;
OpData.Field2.ServerValidated = false;
OpData.Log.Add(DateTime.Now + " - ERROR: " + statusMsg);
}
}
} // update()
private CswNbtObjClassReportGroup _createReportGroup(string Name)
{
CswNbtObjClassReportGroup SystemReportGroup = null;
CswNbtMetaDataObjectClass ReportGroupOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.ReportGroupClass);
if (null != ReportGroupOC)
{
CswNbtMetaDataNodeType ReportGroupNT = ReportGroupOC.FirstNodeType;
if (null != ReportGroupNT)
{
SystemReportGroup = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId(ReportGroupNT.NodeTypeId,
OnAfterMakeNode: (CswNbtNode) =>
{
CswNbtObjClassReportGroup NewNode = CswNbtNode;
NewNode.Name.Text = Name;
});
}
}
return(SystemReportGroup);
}
public override void update()
{
CswNbtMetaDataNodeType ReportNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType("Report");
if (null != ReportNT)
{
CswNbtObjClassReport ReportNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId(ReportNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode newNode)
{
CswNbtObjClassReport report = newNode;
report.ReportName.Text = "Custom Text Barcode";
report.Category.Text = "System Reports";
report.SQL.Text = "select UPPER('{text}') as text from dual";
CswNbtMetaDataObjectClass ReportGroupOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.ReportGroupClass);
CswNbtObjClassReportGroup SystemReportGroup = ReportGroupOC.getNodes(forceReInit: false, includeSystemNodes: true)
.FirstOrDefault(ReportGroup => ((CswNbtObjClassReportGroup)ReportGroup).Name.Text == "System Reports");
if (null != SystemReportGroup)
{
report.ReportGroup.RelatedNodeId = SystemReportGroup.NodeId;
}
});
// upload .RPT
string Filename = "customtextbarcode.rpt";
CswPropIdAttr PropId = new CswPropIdAttr(ReportNode.Node, ReportNode.RPTFile.NodeTypeProp);
string Filepath = CswFilePath.getConfigurationFilePath(CswEnumSetupMode.NbtExe) + "\\" + Filename;
byte[] ReportFile = File.ReadAllBytes(Filepath);
const string ContentType = "application/octet-stream";
string Href;
CswNbtSdBlobData SdBlobData = _CswNbtSchemaModTrnsctn.CswNbtSdBlobData;
SdBlobData.saveFile(PropId.ToString(), ReportFile, ContentType, Filename, out Href);
} // if( null != ReportNT )
} // update()
}//if we got any result
public static void getImageProp(ICswResources CswResources, NodePropImageReturn Return, BlobDataParams Request)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswPropIdAttr PropIdAttr = new CswPropIdAttr(Request.propid);
CswNbtNode node = NbtResources.Nodes[PropIdAttr.NodeId];
if (null != node)
{
CswNbtMetaDataNodeType NodeType = node.getNodeType();
CswNbtNodePropWrapper prop = node.Properties[PropIdAttr.NodeTypePropId];
if (NbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.View, NodeType, NbtResources.CurrentNbtUser))
{
if (Int32.MinValue == prop.JctNodePropId)
{
prop.makePropRow(); //if we don't have a jct_node_prop row for this prop, we do now
node.postChanges(true);
}
prop.AsImage.SetImages(Request.date);
if (null != prop)
{
Return.Data = prop;
}
}
else
{
throw new CswDniException(CswEnumErrorType.Warning, "You do not have sufficient priviledges to get this image property", "User " + NbtResources.CurrentNbtUser.UserId + " attempted to call getImageProp on prop " + prop.JctNodePropId);
}
}
}
public override void update()
{
CswCommaDelimitedString NewFireHazardClasses = new CswCommaDelimitedString {"Corr (liquified gas)",
"CRY-NFG",
"Exp-1.1",
"Exp-1.2",
"Exp-1.3",
"Exp-1.4",
"Exp-1.4G",
"Exp-1.5",
"Exp-1.6",
"H.T. (liquified gas)",
"N/R",
"NFG",
"NFG (liquified)",
"NFS",
"Tox (liquified gas)"};
FireClassExemptAmountNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Fire Class Exempt Amount" );
if( null != FireClassExemptAmountNT )
{
FireClassExemptAmountSetOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.FireClassExemptAmountSetClass );
if( null != FireClassExemptAmountSetOC )
{
FireClassExemptAmountSetNT = FireClassExemptAmountSetOC.FirstNodeType;
if( null != FireClassExemptAmountSetNT )
{
foreach( KeyValuePair<CswPrimaryKey, string> NodeIdAndName in FireClassExemptAmountSetNT.getNodeIdAndNames( false, true ) )
{
if( NodeIdAndName.Value.Equals( "Default" ) )
{
SetNameNodeId = NodeIdAndName.Key;
}
}
#region FireClassExemptAmount Nodes
_createFireClassExemptAmountNode( 301.2, NewFireHazardClasses[0], "(liquified gas)", "Health", "Corrosives" );
_createFireClassExemptAmountNode( 212.2, NewFireHazardClasses[1], "NFG", "Physical", "Cryogenic" );
_createFireClassExemptAmountNode( 213.1, NewFireHazardClasses[2], "1.1", "Physical", "Explosive" );
_createFireClassExemptAmountNode( 213.2, NewFireHazardClasses[3], "1.2", "Physical", "Explosive" );
_createFireClassExemptAmountNode( 213.3, NewFireHazardClasses[4], "1.3", "Physical", "Explosive" );
_createFireClassExemptAmountNode( 213.4, NewFireHazardClasses[5], "1.4", "Physical", "Explosive" );
_createFireClassExemptAmountNode( 213.5, NewFireHazardClasses[6], "1.4G", "Physical", "Explosive" );
_createFireClassExemptAmountNode( 213.6, NewFireHazardClasses[7], "1.5", "Physical", "Explosive" );
_createFireClassExemptAmountNode( 213.7, NewFireHazardClasses[8], "1.6", "Physical", "Explosive" );
_createFireClassExemptAmountNode( 301.4, NewFireHazardClasses[9], "(liquified gas)", "Health", "Highly Toxic" );
_createFireClassExemptAmountNode( 1000.0, NewFireHazardClasses[10], "", "", "Non-Regulated" );
_createFireClassExemptAmountNode( 1000.0, NewFireHazardClasses[11], "", "", "Non-Flammable Gas" );
_createFireClassExemptAmountNode( 1000.0, NewFireHazardClasses[12], "(liquified)", "", "Non-Flammable Gas" );
_createFireClassExemptAmountNode( 1000.0, NewFireHazardClasses[13], "", "", "Non-Flammable Solid" );
_createFireClassExemptAmountNode( 308.1, NewFireHazardClasses[14], "(liquified gas)", "Health", "Toxic" );
#endregion FireClassExemptAmount Nodes
}//if( null != FireClassExemptAmountSetNT )
}
}//if( null != FireClassExemptAmountNT )
} // update()
public override void CommitOperation(ref OperationData OpData)
{
bool succeeded = false;
CswNbtObjClassUser newOwner = _CswNbtResources.Nodes[OpData.Field1.NodeId];
CswNbtNode node = _CswNbtResources.Nodes[OpData.Field2.NodeId];
CswNbtMetaDataNodeType NodeType = node.getNodeType();
string itemName = NodeType.NodeTypeName;
string statusMsg = null;
ICswNbtKioskModeOwnerable AsOwnerable = (ICswNbtKioskModeOwnerable)node.ObjClass;
if (AsOwnerable.CanUpdateOwner(out statusMsg))
{
AsOwnerable.UpdateOwner(newOwner);
succeeded = true;
}
if (null != node && succeeded)
{
node.postChanges(false);
OpData.Log.Add(DateTime.Now + " - Changed owner of " + itemName + " " + OpData.Field2.Value + " to " + newOwner.Username + " (" + OpData.Field1.Value + ")");
base.CommitOperation(ref OpData);
}
else
{
statusMsg = statusMsg ?? "You do not have permission to edit " + itemName + " (" + OpData.Field2.Value + ")";
OpData.Field2.StatusMsg = statusMsg;
OpData.Field2.ServerValidated = false;
OpData.Log.Add(DateTime.Now + " - ERROR: " + statusMsg);
}
}
public override void update()
{
CswNbtMetaDataNodeType sizeNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Size" );
if( null != sizeNT )
{
CswNbtMetaDataNodeTypeProp containerTypeNTP = sizeNT.getNodeTypeProp( "Container Type" );
if( null != containerTypeNTP )
{
containerTypeNTP.ListOptions = "Aboveground Tank [A]," +
"Bag [J]," +
"Belowground Tank [B]," +
"Box [K]," +
"Can [F]," +
"Carboy [G]," +
"Cylinder [L]," +
"Fiberdrum [I]," +
"Glass Bottle or Jug [M]," +
"Plastic [N]," +
"Plastic or Non-Metal Drum [E]," +
"Steel Drum [D]," +
"Tank Inside Building [C]," +
"Tank Wagon [P]," +
"Tote Bin [O]";
}
}
}//Update()
///<summary>
/// Instance a new container according to Object Class rules. Note: this does not get the properties.
/// </summary>
public CswNbtObjClassContainer makeContainer(Action <CswNbtNode> After)
{
CswNbtObjClassContainer ret = null;
CswNbtMetaDataNodeType ContainerNt = _ContainerOc.getLatestVersionNodeTypes().FirstOrDefault();
if (null != ContainerNt)
{
Action <CswNbtNode> After2 = delegate(CswNbtNode NewNode)
{
CswNbtObjClassContainer RetAsContainer = NewNode;
RetAsContainer.Material.RelatedNodeId = _MaterialId;
//cases 30647 and 31079
//RetAsContainer.Material.setHidden( value: true, SaveToDb: false );
//RetAsContainer.Size.setHidden( value: true, SaveToDb: false );
if (null != After)
{
After(NewNode);
}
};
ret = _CswNbtSdTabsAndProps.getAddNodeAndPostChanges(ContainerNt, After2);
if (null == ret)
{
throw new CswDniException(CswEnumErrorType.Error, "Could not create a new container.", "Failed to create a new Container node.");
}
}
return(ret);
} // makeContainer()
private void _populateUnitViewRelationships(CswNbtView UnitView, string PhysicalState, bool ExcludeEach)
{
CswNbtMetaDataObjectClass UnitOfMeasureOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.UnitOfMeasureClass);
CswNbtMetaDataNodeType EachNT = null;
foreach (CswNbtMetaDataNodeType UnitOfMeasureNodeType in UnitOfMeasureOC.getNodeTypes())
{
CswNbtMetaDataNodeTypeProp UnitTypeProp = UnitOfMeasureNodeType.getNodeTypePropByObjectClassProp(CswNbtObjClassUnitOfMeasure.PropertyName.UnitType);
if (UnitTypeProp.HasDefaultValue())
{
CswEnumNbtUnitTypes UnitType = (CswEnumNbtUnitTypes)UnitTypeProp.getDefaultValue(false).AsList.Value;
if (_physicalStateMatchesUnitType(PhysicalState, UnitType, ExcludeEach))
{
if (UnitType == CswEnumNbtUnitTypes.Each)
{
EachNT = UnitOfMeasureNodeType;
}
else
{
UnitView.AddViewRelationship(UnitOfMeasureNodeType, true);
}
}
}
}
if (null != EachNT) //Case 29933 - Each units always go at the end of the list
{
UnitView.AddViewRelationship(EachNT, true);
}
}
public override void update()
{
//Add TierII Reporting Action
_CswNbtSchemaModTrnsctn.createAction( CswNbtActionName.Tier_II_Reporting, true, "", "Materials" );
_CswNbtSchemaModTrnsctn.createModuleActionJunction( CswNbtModuleName.CISPro, CswNbtActionName.Tier_II_Reporting );
//Add Trade Secret Chemical Prop
CswNbtMetaDataNodeType ChemicalNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Chemical" );
if( null != ChemicalNT )
{
CswNbtMetaDataNodeTypeProp ChemicalSpecialFlagsNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp(ChemicalNT.NodeTypeId, "Special Flags");
if( null != ChemicalSpecialFlagsNTP )
{
ChemicalSpecialFlagsNTP.ListOptions = "EHS,Waste,Not Reportable,Trade Secret";
}
}
//Add Container fire reporting props to Audit Table
CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.ContainerClass );
CswNbtMetaDataNodeType ContainerNT = ContainerOC.FirstNodeType;
if( null != ContainerNT )
{
CswNbtMetaDataNodeTypeProp StorageTemperatureNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp(ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.StorageTemperature);
StorageTemperatureNTP.AuditLevel = AuditLevel.PlainAudit;
CswNbtMetaDataNodeTypeProp StoragePressureNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp(ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.StoragePressure);
StoragePressureNTP.AuditLevel = AuditLevel.PlainAudit;
CswNbtMetaDataNodeTypeProp UseTypeNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypePropByObjectClassProp(ContainerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.UseType);
UseTypeNTP.AuditLevel = AuditLevel.PlainAudit;
}
}//Update()
/// <summary>
/// Update logic
/// </summary>
public override void update()
{
CswNbtMetaDataNodeType TimeNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Unit (Time)" );
if( null != TimeNT )
{
foreach( CswNbtObjClassUnitOfMeasure TimeNode in TimeNT.getNodes( false, false ) )
{
if( "Months" == TimeNode.Name.Text )
{
//According to Google, 1 month = 30.4368 days (based on averages, I'm assuming)
TimeNode.ConversionFactor.Base = 3.285496;
TimeNode.ConversionFactor.Exponent = -2;
TimeNode.postChanges( false );
}
}
}
CswNbtMetaDataObjectClass MaterialOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.MaterialClass );
foreach( CswNbtMetaDataNodeType MaterialNt in MaterialOc.getNodeTypes() )
{
CswNbtMetaDataNodeTypeProp SpecificGravityNtp = MaterialNt.getNodeTypePropByObjectClassProp( CswNbtObjClassMaterial.PropertyName.SpecificGravity );
if( null != SpecificGravityNtp )
{
SpecificGravityNtp.Attribute1 = CswConvert.ToDbVal( true ).ToString();
}
}
}
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()
private void _createNotScannedContainerLocation(ContainerData.ReconciliationActions Action, CswEnumNbtContainerLocationTypeOptions Type)
{
CswNbtMetaDataObjectClass ContLocOc = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerLocationClass);
CswNbtMetaDataNodeType ContLocNt = ContLocOc.FirstNodeType;
if (null != ContLocNt)
{
_CswNbtResources.Nodes.makeNodeFromNodeTypeId(ContLocNt.NodeTypeId, delegate(CswNbtNode NewNode)
{
CswNbtObjClassContainerLocation ContLocNode = NewNode;
ContLocNode.Container.RelatedNodeId = CswConvert.ToPrimaryKey(Action.ContainerId);
ContLocNode.Location.SelectedNodeId = CswConvert.ToPrimaryKey(Action.LocationId);
ContLocNode.Type.Value = Type.ToString();
ContLocNode.Status.Value = CswEnumNbtContainerLocationStatusOptions.NotScanned.ToString();
ContLocNode.ActionApplied.Checked = CswEnumTristate.False;
if (Type == CswEnumNbtContainerLocationTypeOptions.Missing)
{
ContLocNode.Action.Value = CswEnumNbtContainerLocationActionOptions.MarkMissing.ToString();
}
else if (Type == CswEnumNbtContainerLocationTypeOptions.Ignore)
{
ContLocNode.Action.Value = CswEnumNbtContainerLocationActionOptions.Ignore.ToString();
}
ContLocNode.ActionByUser.RelatedNodeId = _CswNbtResources.CurrentNbtUser.UserId;
ContLocNode.ScanDate.DateTimeValue = DateTime.Now;
ContLocNode.User.RelatedNodeId = _CswNbtResources.CurrentNbtUser.UserId;
});
}
}
}//_removeDuplicateSizes()
#endregion Private helper methods
public CswPrimaryKey createMaterialDocument(CswNbtPropertySetMaterial MaterialNode)
{
CswPrimaryKey NewSDSDocumentNodeId = null;
string MsdsUrl = _ProductToImport.MsdsUrl;
if (false == string.IsNullOrEmpty(MsdsUrl) && _CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.SDS))
{
CswNbtMetaDataObjectClass SDSDocClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.SDSDocumentClass);
CswNbtMetaDataNodeType SDSDocumentNT = SDSDocClass.FirstNodeType;
if (null != SDSDocumentNT)
{
CswNbtObjClassSDSDocument NewDoc = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(SDSDocumentNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
// This needs to be CswNbtObjClassSDSDocument NOT CswNbtObjClassDocument!
CswNbtObjClassSDSDocument NewSDSDocumentNode = NewNode;
NewSDSDocumentNode.Title.Text = "SDS: " + MaterialNode.TradeName.Text;
NewSDSDocumentNode.FileType.Value = CswNbtPropertySetDocument.CswEnumDocumentFileTypes.Link;
NewSDSDocumentNode.Link.Href = MsdsUrl;
NewSDSDocumentNode.Link.Text = MsdsUrl;
NewSDSDocumentNode.Owner.RelatedNodeId = MaterialNode.NodeId;
});
// Set the return object
NewSDSDocumentNodeId = NewDoc.NodeId;
}
}
return(NewSDSDocumentNodeId);
}
public override void update()
{
CswNbtMetaDataObjectClass MaterialOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ChemicalClass );
NonChemicalOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.NonChemicalClass );
CswNbtMetaDataNodeType SupplyNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Supply" );
CswNbtMetaDataNodeType BiologicalNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Biological" );
Int32 SupplyId = 0, BiologicalId = 0;
if( null != SupplyNT )
{
SupplyId = SupplyNT.NodeTypeId;
}
if( null != BiologicalNT )
{
BiologicalId = BiologicalNT.NodeTypeId;
}
//Change Supply and Biological's OC to NonChemical
CswTableUpdate NTUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate( "28690_nt_update", "nodetypes" );
DataTable NTTable = NTUpdate.getTable( "where objectclassid = " + MaterialOC.ObjectClassId );
foreach( DataRow NTRow in NTTable.Rows )
{
if( NTRow["nodetypeid"].ToString() == SupplyId.ToString() || NTRow["nodetypeid"].ToString() == BiologicalId.ToString() )
{
NTRow["objectclassid"] = NonChemicalOC.ObjectClassId;
}
}
NTUpdate.update( NTTable );
_CswNbtSchemaModTrnsctn.MetaData.makeMissingNodeTypeProps();
} // update()
/// <summary>
/// Add new Order entries to a definition (for use by CswNbtImporter)
/// </summary>
public static void addOrderEntries(CswNbtResources CswNbtResources, DataTable OrderDataTable)
{
CswTableUpdate importOrderUpdate = CswNbtResources.makeCswTableUpdate("CswNbtImportDefOrder_addOrderEntries_Update", CswNbtImportTables.ImportDefOrder.TableName);
foreach (DataRow OrderRow in OrderDataTable.Select())
{
//set blank instances to min value
if (OrderRow["instance"] == DBNull.Value || String.IsNullOrEmpty(OrderRow["instance"].ToString()))
{
OrderRow["instance"] = Int32.MinValue;
}
string NTName = OrderRow["nodetypename"].ToString();
CswNbtMetaDataNodeType NodeType = CswNbtResources.MetaData.getNodeType(NTName);
if (null == NodeType)
{
throw new CswDniException(CswEnumErrorType.Error, "Error reading definition", "Invalid NodeType defined in 'Order' sheet: " + NTName);
} // if(false == string.IsNullOrEmpty(SheetName) )
} // foreach( DataRow OrderRow in OrderDataTable.Rows )
//this is a hack, and the fact that we can even do this makes me sad
importOrderUpdate._DoledOutTables.Add(OrderDataTable);
importOrderUpdate.update(OrderDataTable);
} // addOrderEntries()
private void _upgradeLQNoToObjectClass()
{
CswNbtMetaDataObjectClass LQNoOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.LQNoClass);
if (null == LQNoOC)
{
LQNoOC = _CswNbtSchemaModTrnsctn.createObjectClass(CswEnumNbtObjectClass.LQNoClass, "folder.png", false);
_CswNbtSchemaModTrnsctn.createObjectClassProp(LQNoOC, new CswNbtWcfMetaDataModel.ObjectClassProp
{
PropName = CswNbtObjClassLQNo.PropertyName.LQNo,
FieldType = CswEnumNbtFieldType.Text,
IsUnique = true
});
CswNbtMetaDataNodeType WeightNt = _CswNbtSchemaModTrnsctn.MetaData.getNodeType("Unit_Weight");
_CswNbtSchemaModTrnsctn.createObjectClassProp(LQNoOC, new CswNbtWcfMetaDataModel.ObjectClassProp
{
PropName = CswNbtObjClassLQNo.PropertyName.Limit,
FieldType = CswEnumNbtFieldType.Quantity,
IsRequired = true,
IsFk = true,
FkType = CswEnumNbtViewRelatedIdType.NodeTypeId.ToString(),
FkValue = WeightNt != null ? WeightNt.NodeTypeId : Int32.MinValue
});
CswNbtMetaDataNodeType LQNoNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType("LQNo");
if (null != LQNoNT)
{
_CswNbtSchemaModTrnsctn.MetaData.ConvertObjectClass(LQNoNT, LQNoOC);
}
}
}
public override void setItemDataForUI(DataRow LandingPageRow, LandingPageData.Request Request)
{
Int32 NodeTypeId = CswConvert.ToInt32(LandingPageRow["to_nodetypeid"]);
Int32 TabId = CswConvert.ToInt32(LandingPageRow["to_tabid"]);
if (NodeTypeId != Int32.MinValue && TabId != Int32.MinValue)
{
CswNbtMetaDataNodeType NodeType = _CswNbtResources.MetaData.getNodeType(NodeTypeId);
if (NodeType != null)
{
CswNbtMetaDataNodeTypeTab Tab = NodeType.getNodeTypeTab(TabId);
if (null != Tab)
{
CswNbtView TabView = getTabView(Request.NodeId, Request.NodeViewId, NodeType);
if (null != TabView && TabView.IsFullyEnabled())
{
String DisplayText = LandingPageRow["displaytext"].ToString();
_ItemData.Text = false == String.IsNullOrEmpty(DisplayText) ? DisplayText : TabView.ViewName + " " + Tab.TabName;
_ItemData.ViewId = TabView.SessionViewId.ToString();
_ItemData.ViewMode = TabView.ViewMode.ToString().ToLower();
_ItemData.Type = "view";
_ItemData.TabId = TabId.ToString();
_ItemData.ButtonIcon = CswNbtMetaDataObjectClass.IconPrefix100 + NodeType.IconFileName;
_setCommonItemDataForUI(LandingPageRow);
}
}
}
}
}
/// <summary>
/// Deletes the node from the database.
/// </summary>
/// <param name="DeleteAllRequiredRelatedNodes"></param>
/// <param name="OverridePermissions">For internal use only. When set to true, ignores user permissions.</param>
public void delete(bool DeleteAllRequiredRelatedNodes = false, bool OverridePermissions = false)
{
if (null == OnRequestDeleteNode)
{
throw (new CswDniException("There is no delete handler"));
}
CswNbtMetaDataNodeType thisNT = this.getNodeType();
if (false == OverridePermissions && false == _CswNbtResources.Permit.canNodeType(Security.CswEnumNbtNodeTypePermission.Delete, thisNT))
{
throw (new CswDniException(CswEnumErrorType.Warning, "You do not have permission to delete this " + thisNT.NodeTypeName, "User attempted to delete a " + thisNT.NodeTypeName + " without Delete permissions"));
}
if (null != _CswNbtObjClass)
{
_CswNbtObjClass.beforeDeleteNode(DeleteAllRequiredRelatedNodes: DeleteAllRequiredRelatedNodes);
}
OnRequestDeleteNode(this);
if (null != _CswNbtObjClass)
{
_CswNbtObjClass.afterDeleteNode();
}
_NodeModificationState = CswEnumNbtNodeModificationState.Deleted;
}//delete()
public CswNbtView setupPhraseView(CswNbtView View, CswCommaDelimitedString SelectedPhraseIds)
{
CswNbtMetaDataObjectClass GhsPhraseOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.GHSPhraseClass);
CswNbtMetaDataNodeType GhsPhraseNT = GhsPhraseOC.FirstNodeType;
View.SetVisibility(CswEnumNbtViewVisibility.Hidden, null, null);
View.ViewMode = CswEnumNbtViewRenderingMode.Grid;
View.Root.ChildRelationships.Clear();
if (SelectedPhraseIds.Count > 0)
{
CswNbtViewRelationship PhraseVR = View.AddViewRelationship(GhsPhraseOC, false);
foreach (string PhraseId in SelectedPhraseIds)
{
CswPrimaryKey PhrasePk = new CswPrimaryKey();
PhrasePk.FromString(PhraseId);
PhraseVR.NodeIdsToFilterIn.Add(PhrasePk);
}
View.AddViewProperty(PhraseVR, GhsPhraseOC.getObjectClassProp(CswNbtObjClassGHSPhrase.PropertyName.Code));
if (null != GhsPhraseNT)
{
CswNbtMetaDataNodeTypeProp LanguageProp = GhsPhraseNT.getNodeTypePropByObjectClassProp(_getLanguageForTranslation());
CswNbtViewProperty LanguageVP = View.AddViewProperty(PhraseVR, LanguageProp);
LanguageVP.Width = 100;
}
} // if( SelectedPhraseIds.Count > 0 )
return(View);
} // setupPhraseView()