public override void update()
        {

            CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ContainerClass );
            foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
            {
                CswNbtMetaDataNodeTypeProp ViewSDS_NTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.ViewSDS );
                CswNbtMetaDataNodeTypeTab ContainerIdentityTab = ContainerNT.getIdentityTab();
                ViewSDS_NTP.updateLayout( CswEnumNbtLayoutType.Edit, true, ContainerIdentityTab.TabId, 1, 2 );
            }

        } // update()
 public override void update()
 {
     // Set container name template to include Disposed
     CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( NbtObjectClass.ContainerClass );
     foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
     {
         CswNbtMetaDataNodeTypeProp BarcodeNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.Barcode );
         CswNbtMetaDataNodeTypeProp DisposedNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.Disposed );
         ContainerNT.setNameTemplateText( CswNbtMetaData.MakeTemplateEntry( BarcodeNTP.PropName ) +
                                          " " +
                                          CswNbtMetaData.MakeTemplateEntry( DisposedNTP.PropName ) );
     }
 } //update()
        public override void update()
        {
            CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ContainerClass );
            foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
            {
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.clearLayout( CswEnumNbtLayoutType.Add, ContainerNT.NodeTypeId );

                CswNbtMetaDataNodeTypeProp OwnerNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.Owner );
                CswNbtMetaDataNodeTypeProp LocationNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.Location );
                CswNbtMetaDataNodeTypeProp LabelFormatNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.LabelFormat );
                CswNbtMetaDataNodeTypeProp ExpirationDateNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.ExpirationDate );

                OwnerNTP.updateLayout( CswEnumNbtLayoutType.Add, false, DisplayRow: 1, DisplayColumn: 1 );
                LocationNTP.updateLayout( CswEnumNbtLayoutType.Add, false, DisplayRow: 2, DisplayColumn: 1 );
                LabelFormatNTP.updateLayout( CswEnumNbtLayoutType.Add, false, DisplayRow: 3, DisplayColumn: 1 );
                ExpirationDateNTP.updateLayout( CswEnumNbtLayoutType.Add, false, DisplayRow: 4, DisplayColumn: 1 );
            }
        } // update()
        public override void update()
        {
            CswNbtMetaDataNodeType ContainerDocumentNT = _CswNbtSchemaModTrnsctn.MetaData.getNodeType( "Container Document" );
            CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ContainerClass );
            foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
            {
                CswNbtMetaDataNodeTypeProp DocumentsNTP = ContainerNT.getNodeTypeProp( "Documents" );
                if( null != DocumentsNTP && null != ContainerDocumentNT )
                {
                    CswNbtView ContainerDocsView = _CswNbtSchemaModTrnsctn.restoreView( DocumentsNTP.ViewId );
                    if( null == ContainerDocsView )
                    {
                        ContainerDocsView = _CswNbtSchemaModTrnsctn.makeSafeView( "Documents", CswEnumNbtViewVisibility.Property );
                        ContainerDocsView.ViewMode = CswEnumNbtViewRenderingMode.Grid;
                    }
                    ContainerDocsView.Root.ChildRelationships.Clear();

                    CswNbtMetaDataNodeTypeProp OwnerNTP = ContainerDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Owner );
                    CswNbtMetaDataNodeTypeProp ArchivedNTP = ContainerDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Archived );
                    CswNbtMetaDataNodeTypeProp FileNTP = ContainerDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.File );
                    CswNbtMetaDataNodeTypeProp LinkNTP = ContainerDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Link );
                    CswNbtMetaDataNodeTypeProp TitleNTP = ContainerDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.Title );
                    CswNbtMetaDataNodeTypeProp AcquiredDateNTP = ContainerDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.AcquiredDate );
                    CswNbtMetaDataNodeTypeProp ExpirationDateNTP = ContainerDocumentNT.getNodeTypePropByObjectClassProp( CswNbtObjClassDocument.PropertyName.ExpirationDate );

                    CswNbtViewRelationship RootRel = ContainerDocsView.AddViewRelationship( ContainerNT, false );
                    CswNbtViewRelationship DocRel = ContainerDocsView.AddViewRelationship( RootRel, CswEnumNbtViewPropOwnerType.Second, OwnerNTP, true );
                    ContainerDocsView.AddViewPropertyAndFilter( DocRel, ArchivedNTP, CswEnumTristate.False.ToString(),
                                                        FilterMode: CswEnumNbtFilterMode.Equals,
                                                        ShowAtRuntime: true,
                                                        ShowInGrid: false );
                    ContainerDocsView.AddViewProperty( DocRel, FileNTP, 1 );
                    ContainerDocsView.AddViewProperty( DocRel, LinkNTP, 2 );
                    ContainerDocsView.AddViewProperty( DocRel, TitleNTP, 3 );
                    ContainerDocsView.AddViewProperty( DocRel, AcquiredDateNTP, 4 );
                    ContainerDocsView.AddViewProperty( DocRel, ExpirationDateNTP, 5 );
                    ContainerDocsView.save();
                    DocumentsNTP.ViewId = ContainerDocsView.ViewId;
                }
            }
        } // update()
Esempio n. 5
0
 public override void update()
 {
     CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ContainerClass );
     foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
     {
         CswNbtMetaDataNodeTypeProp ReceiptLotNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.ReceiptLot );
         if( null != ReceiptLotNTP )
         {
             ReceiptLotNTP.Hidden = false;
             if( _CswNbtSchemaModTrnsctn.Modules.IsModuleEnabled( CswEnumNbtModuleName.MLM ) )
             {
                 CswNbtMetaDataNodeTypeProp DateCreatedNTP = ContainerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.DateCreated );
                 ReceiptLotNTP.updateLayout( CswEnumNbtLayoutType.Edit, DateCreatedNTP, true );
             }
             else
             {
                 ReceiptLotNTP.removeFromAllLayouts();
             }
         }
     }
 }
Esempio n. 6
0
        protected override void OnEnable()
        {
            //Show the following ReceiptLot properties...
            //   Assigned CofA
            //   View CofA
            CswNbtMetaDataObjectClass ReceiptLotOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ReceiptLotClass);

            foreach (CswNbtMetaDataNodeType ReceiptLotNT in ReceiptLotOC.getNodeTypes())
            {
                _CswNbtResources.Modules.AddPropToTab(ReceiptLotNT.NodeTypeId, "Assigned C of A", ReceiptLotNT.getFirstNodeTypeTab(), 7, 1);
                _CswNbtResources.Modules.AddPropToTab(ReceiptLotNT.NodeTypeId, "View C of A", ReceiptLotNT.getIdentityTab(), 1, 1);
            }

            //Show the following Container properties...
            //   View CofA
            CswNbtMetaDataObjectClass ContainerOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);

            foreach (CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes())
            {
                _CswNbtResources.Modules.AddPropToTab(ContainerNT.NodeTypeId, "View C of A", ContainerNT.getIdentityTab(), 1, 3);
            }
        }
        /// <summary>
        /// The actual update call
        /// </summary>
        public override void update()
        {
            CswNbtMetaDataObjectClass ReceiptLotOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.ReceiptLotClass);
            //Put Manufacturer on add layout
            CswNbtMetaDataObjectClassProp ManufacturerOCP = ReceiptLotOC.getObjectClassProp(CswNbtObjClassReceiptLot.PropertyName.Manufacturer);

            foreach (CswNbtMetaDataNodeType ReceiptLotNT in ReceiptLotOC.getNodeTypes())
            {
                CswNbtMetaDataNodeTypeProp ManufacturerNTP = ReceiptLotNT.getNodeTypePropByObjectClassProp(ManufacturerOCP);
                ManufacturerNTP.updateLayout(CswEnumNbtLayoutType.Add, false);
            }
            //Add new props to ReceiptLot
            CswNbtMetaDataObjectClassProp ManufacturerLotNoOCP = ReceiptLotOC.getObjectClassProp(CswNbtObjClassReceiptLot.PropertyName.ManufacturerLotNo);

            if (null == ManufacturerLotNoOCP)
            {
                ManufacturerLotNoOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp(ReceiptLotOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                {
                    PropName    = CswNbtObjClassReceiptLot.PropertyName.ManufacturerLotNo,
                    FieldType   = CswEnumNbtFieldType.Text,
                    SetValOnAdd = true
                });
            }
            CswNbtMetaDataObjectClassProp ManufacturedDateOCP = ReceiptLotOC.getObjectClassProp(CswNbtObjClassReceiptLot.PropertyName.ManufacturedDate);

            if (null == ManufacturedDateOCP)
            {
                ManufacturedDateOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp(ReceiptLotOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                {
                    PropName    = CswNbtObjClassReceiptLot.PropertyName.ManufacturedDate,
                    FieldType   = CswEnumNbtFieldType.DateTime,
                    SetValOnAdd = true
                });
            }
            _CswNbtSchemaModTrnsctn.MetaData.makeMissingNodeTypeProps();
            //Upgrade AssignedCofA to OCP
            CswNbtMetaDataObjectClassProp AssignedCofAOCP = ReceiptLotOC.getObjectClassProp(CswNbtObjClassReceiptLot.PropertyName.AssignedCofA);

            if (null == AssignedCofAOCP)
            {
                AssignedCofAOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp(ReceiptLotOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                {
                    PropName  = CswNbtObjClassReceiptLot.PropertyName.AssignedCofA,
                    FieldType = CswEnumNbtFieldType.Grid
                });
                CswNbtView AssignedCofAView = _CswNbtSchemaModTrnsctn.restoreView("Assigned C of A");
                if (null != AssignedCofAView)
                {
                    _CswNbtSchemaModTrnsctn.MetaData.UpdateObjectClassProp(AssignedCofAOCP, CswEnumNbtObjectClassPropAttributes.viewxml, AssignedCofAView.ToString());
                }
            }
            //Remove the ManufacturerLotNo property off Container
            CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);

            foreach (CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes())
            {
                CswNbtMetaDataNodeTypeProp ManufacturerLotNoNTP = ContainerNT.getNodeTypeProp("Manufacturer Lot Number");
                if (null != ManufacturerLotNoNTP)
                {
                    _CswNbtSchemaModTrnsctn.MetaData.DeleteNodeTypeProp(ManufacturerLotNoNTP);
                }
            }
            //Rename "C of A" module to "Manufacturer Lot Info"
            CswTableUpdate ModulesTableUpdate = _CswNbtSchemaModTrnsctn.makeCswTableUpdate("ModulesSelect_29700", "modules");
            DataTable      ModulesTable       = ModulesTableUpdate.getTable("where name = 'C of A'");

            if (ModulesTable.Rows.Count > 0)
            {
                ModulesTable.Rows[0]["name"]        = CswEnumNbtModuleName.ManufacturerLotInfo;
                ModulesTable.Rows[0]["description"] = "Manufacturer Lot Info";
                ModulesTableUpdate.update(ModulesTable);
            }
        }
        public override void update()
        {
            if (_CswNbtSchemaModTrnsctn.isMaster())
            {
                CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);

                foreach (CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes())
                {
                    CswNbtMetaDataNodeTypeTab firstTab = ContainerNT.getFirstNodeTypeTab();

                    CswNbtMetaDataNodeTypeTab identityTab = ContainerNT.getIdentityTab();

                    //update the edit layout
                    CswNbtMetaDataNodeTypeProp BarcodeNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Barcode);
                    BarcodeNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, identityTab.TabId, 1, 1);

                    CswNbtMetaDataNodeTypeProp MaterialNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Material);
                    MaterialNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, identityTab.TabId, 2, 1);

                    CswNbtMetaDataNodeTypeProp QuantityNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Quantity);
                    QuantityNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, identityTab.TabId, 3, 1);

                    CswNbtMetaDataNodeTypeProp OwnerNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Owner);
                    OwnerNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 1, 1);
                    OwnerNTP.updateLayout(CswEnumNbtLayoutType.Add, true, firstTab.TabId, 1, 1);

                    CswNbtMetaDataNodeTypeProp LocationNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Location);
                    LocationNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 2, 1);
                    LocationNTP.updateLayout(CswEnumNbtLayoutType.Add, true, firstTab.TabId, 2, 1);

                    CswNbtMetaDataNodeTypeProp OpenButtonNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Open);
                    OpenButtonNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 4, 1);

                    CswNbtMetaDataNodeTypeProp OpenedDateNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.OpenedDate);
                    OpenedDateNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 5, 1);

                    CswNbtMetaDataNodeTypeProp DateCreatedNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.DateCreated);
                    DateCreatedNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 6, 1);

                    CswNbtMetaDataNodeTypeProp LabelFormatNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.LabelFormat);
                    LabelFormatNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 7, 1);
                    LabelFormatNTP.updateLayout(CswEnumNbtLayoutType.Add, true, firstTab.TabId, 5, 1);

                    CswNbtMetaDataNodeTypeProp ExpDateNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.ExpirationDate);
                    ExpDateNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 3, 1);
                    ExpDateNTP.updateLayout(CswEnumNbtLayoutType.Add, true, firstTab.TabId, 3, 1);

                    CswNbtMetaDataNodeTypeProp MissingNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Missing);
                    MissingNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 2, 2);

                    CswNbtMetaDataNodeTypeProp StatusNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Status);
                    StatusNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 3, 2);

                    CswNbtMetaDataNodeTypeProp RecieptLotNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.ReceiptLot);
                    RecieptLotNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 4, 2);

                    CswNbtMetaDataNodeTypeProp ContainerGroupNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.ContainerGroup);
                    ContainerGroupNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 5, 2);

                    CswNbtMetaDataNodeTypeProp ContainerFamilyNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.ContainerFamily);
                    ContainerFamilyNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 6, 2);

                    CswNbtMetaDataNodeTypeProp UndisposeContainerNTP = ContainerNT.getNodeTypePropByObjectClassProp
                                                                           (CswNbtObjClassContainer.PropertyName.Undispose);
                    UndisposeContainerNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 7, 2);

                    CswNbtMetaDataNodeTypeProp DisposeContainerNTP = ContainerNT.getNodeTypePropByObjectClassProp
                                                                         (CswNbtObjClassContainer.PropertyName.Dispose);
                    DisposeContainerNTP.updateLayout(CswEnumNbtLayoutType.Edit, true, firstTab.TabId, 8, 2);

                    //update the preview layout
                    BarcodeNTP.updateLayout(CswEnumNbtLayoutType.Preview, true, identityTab.TabId, 1, 1);
                    MaterialNTP.updateLayout(CswEnumNbtLayoutType.Preview, true, identityTab.TabId, 2, 1);
                    QuantityNTP.updateLayout(CswEnumNbtLayoutType.Preview, true, identityTab.TabId, 3, 1);
                }
            }
        }
        public override void update()
        {

            #region Update all NTPs "Hidden" column to "false"

            _CswNbtSchemaModTrnsctn.execArbitraryPlatformNeutralSql( "update nodetype_props set hidden = " + CswConvert.ToDbVal( false ) );

            #endregion

            #region CISPro

            CswNbtMetaDataObjectClass UserOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.UserClass );
            foreach( CswNbtMetaDataNodeType UserNT in UserOC.getNodeTypes() )
            {
                CswNbtMetaDataNodeTypeProp UserJurisdictionNTP = UserNT.getNodeTypePropByObjectClassProp( CswNbtObjClassUser.PropertyName.Jurisdiction );
                if( null != UserJurisdictionNTP )
                {
                    UserJurisdictionNTP.updateLayout( CswEnumNbtLayoutType.Add, false );
                    UserJurisdictionNTP.updateLayout( CswEnumNbtLayoutType.Edit, DoMove: false, TabId: UserNT.getFirstNodeTypeTab().TabId );
                }
            }

            #endregion

            #region Containers

            CswNbtMetaDataObjectClass locationOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.LocationClass );
            foreach( int NodeTypeId in locationOC.getNodeTypeIds() )
            {
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( NodeTypeId, CswNbtObjClassLocation.PropertyName.Containers, "Containers" );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( NodeTypeId, "Inventory Levels", "Inventory Levels", 2 );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToFirstTab( NodeTypeId, CswNbtObjClassLocation.PropertyName.AllowInventory );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToFirstTab( NodeTypeId, CswNbtObjClassLocation.PropertyName.InventoryGroup );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToFirstTab( NodeTypeId, CswNbtObjClassLocation.PropertyName.StorageCompatibility );

                CswNbtMetaDataNodeTypeProp AllowInvNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( NodeTypeId, CswNbtObjClassLocation.PropertyName.AllowInventory );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Add, NodeTypeId, AllowInvNTP, false );

                CswNbtMetaDataNodeTypeProp InvGrpNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( NodeTypeId, CswNbtObjClassLocation.PropertyName.InventoryGroup );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Add, NodeTypeId, InvGrpNTP, false );

                CswNbtMetaDataNodeTypeProp StorageCompatNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( NodeTypeId, CswNbtObjClassLocation.PropertyName.StorageCompatibility );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Add, NodeTypeId, StorageCompatNTP, false );
            }

            CswNbtMetaDataPropertySet MaterialSet = _CswNbtSchemaModTrnsctn.MetaData.getPropertySet( CswEnumNbtPropertySetName.MaterialSet );
            foreach( CswNbtMetaDataObjectClass materialOC in MaterialSet.getObjectClasses() )
            {
                foreach( CswNbtMetaDataNodeType materialNT in _CswNbtSchemaModTrnsctn.MetaData.getNodeTypes( materialOC.ObjectClassId ) )
                {
                    string sizesNTPName = materialNT.NodeTypeName + " Sizes";
                    _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( materialNT.NodeTypeId, sizesNTPName, "Containers", 99 );

                    _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( materialNT.NodeTypeId, "Inventory Levels", "Containers", 99 );

                    string containersNTPName = materialNT.NodeTypeName + " Containers";
                    _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( materialNT.NodeTypeId, containersNTPName, "Containers", 99 );

                    CswNbtMetaDataNodeTypeTab materialNTT = materialNT.getFirstNodeTypeTab();
                    _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( materialNT.NodeTypeId, CswNbtObjClassChemical.PropertyName.ApprovedForReceiving, materialNTT );

                    CswNbtMetaDataNodeTypeTab materialIdentityNTT = materialNT.getIdentityTab();
                    _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( materialNT.NodeTypeId, CswNbtObjClassChemical.PropertyName.Receive, materialIdentityNTT, 2, 2 );
                    _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( materialNT.NodeTypeId, CswNbtObjClassChemical.PropertyName.Request, materialIdentityNTT, 1, 2 );

                    _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( materialNT.NodeTypeId, CswNbtObjClassChemical.PropertyName.StorageCompatibility, "Hazards" );
                }
            }

            #endregion

            #region Fire Code

            CswNbtMetaDataObjectClass LocationOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.LocationClass );
            foreach( int LocationNTId in LocationOC.getNodeTypeIds() )
            {
                _CswNbtSchemaModTrnsctn.Modules.AddPropToFirstTab( LocationNTId, CswNbtObjClassLocation.PropertyName.ControlZone );

                CswNbtMetaDataNodeTypeProp CtrlZoneNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( LocationNTId, CswNbtObjClassLocation.PropertyName.ControlZone );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Add, LocationNTId, CtrlZoneNTP, false );
            }

            CswNbtMetaDataObjectClass ChemicalOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ChemicalClass );
            foreach( CswNbtMetaDataNodeType ChemicalNT in _CswNbtSchemaModTrnsctn.MetaData.getNodeTypes( ChemicalOC.ObjectClassId ) )
            {
                foreach( CswNbtMetaDataNodeTypeTab Tab in ChemicalNT.getNodeTypeTabs() )
                {
                    if( Tab.TabOrder >= 4 )
                        Tab.TabOrder += 1;
                }
                CswNbtMetaDataNodeTypeTab HazardsTab = ChemicalNT.getNodeTypeTab( "Hazards" );
                if( null == HazardsTab )
                {
                    HazardsTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( ChemicalNT, "Hazards", 4 );
                }
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ChemicalNT.NodeTypeId, "Material Type", HazardsTab, 4, 2, "Fire Reporting" );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ChemicalNT.NodeTypeId, "Special Flags", HazardsTab, 5, 2, "Fire Reporting" );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ChemicalNT.NodeTypeId, "Hazard Categories", HazardsTab, 6, 2, "Fire Reporting" );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ChemicalNT.NodeTypeId, "Hazard Classes", HazardsTab, 7, 2, "Fire Reporting" );
            }

            CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ContainerClass );
            foreach( int ContainerNTId in ContainerOC.getNodeTypeIds() )
            {
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ContainerNTId, "Storage Pressure", "Fire Code" );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ContainerNTId, "Storage Temperature", "Fire Code" );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ContainerNTId, "Use Type", "Fire Code" );
            }

            #endregion

            #region Manufacturer Lot Info

            CswNbtMetaDataObjectClass ReceiptLotOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ReceiptLotClass );
            foreach( CswNbtMetaDataNodeType ReceiptLotNT in ReceiptLotOC.getNodeTypes() )
            {
                CswNbtMetaDataNodeTypeProp ManufacturerNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( ReceiptLotNT.NodeTypeId, CswNbtObjClassReceiptLot.PropertyName.Manufacturer );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Edit, ReceiptLotNT.NodeTypeId, ManufacturerNTP, true, ReceiptLotNT.getFirstNodeTypeTab().TabId, 7, 1 );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Add, ReceiptLotNT.NodeTypeId, ManufacturerNTP, true );
                CswNbtMetaDataNodeTypeProp ManufacturerLotNoNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( ReceiptLotNT.NodeTypeId, CswNbtObjClassReceiptLot.PropertyName.ManufacturerLotNo );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Edit, ReceiptLotNT.NodeTypeId, ManufacturerLotNoNTP, true, ReceiptLotNT.getFirstNodeTypeTab().TabId, 8, 1 );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Add, ReceiptLotNT.NodeTypeId, ManufacturerLotNoNTP, true );
                CswNbtMetaDataNodeTypeProp ManufacturedDateNTP = _CswNbtSchemaModTrnsctn.MetaData.getNodeTypeProp( ReceiptLotNT.NodeTypeId, CswNbtObjClassReceiptLot.PropertyName.ManufacturedDate );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Edit, ReceiptLotNT.NodeTypeId, ManufacturedDateNTP, true, ReceiptLotNT.getFirstNodeTypeTab().TabId, 9, 1 );
                _CswNbtSchemaModTrnsctn.MetaData.NodeTypeLayout.updatePropLayout( CswEnumNbtLayoutType.Add, ReceiptLotNT.NodeTypeId, ManufacturedDateNTP, true );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ReceiptLotNT.NodeTypeId, CswNbtObjClassReceiptLot.PropertyName.AssignedCofA, ReceiptLotNT.getFirstNodeTypeTab(), 10, 1 );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ReceiptLotNT.NodeTypeId, CswNbtObjClassReceiptLot.PropertyName.ViewCofA, ReceiptLotNT.getIdentityTab(), 1, 1 );
            }

            foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
            {
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ContainerNT.NodeTypeId, "View C of A", ContainerNT.getIdentityTab(), 1, 3 );
            }

            #endregion

            #region MLM

            CswNbtMetaDataObjectClass containerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ContainerClass );
            foreach( CswNbtMetaDataNodeType containerNT in containerOC.getNodeTypes() )
            {
                CswNbtMetaDataNodeTypeTab cmgTab = containerNT.getNodeTypeTab( "Central Material Group" );
                if( null == cmgTab )
                {
                    cmgTab = _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( containerNT, "Central Material Group", containerNT.getMaximumTabOrder() + 1 );
                }
                CswNbtMetaDataNodeTypeProp lotControlledNTP = containerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.LotControlled );
                lotControlledNTP.updateLayout( CswEnumNbtLayoutType.Edit, false, TabId: cmgTab.TabId );

                CswNbtMetaDataNodeTypeProp requisitionableNTP = containerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.Requisitionable );
                requisitionableNTP.updateLayout( CswEnumNbtLayoutType.Edit, false, TabId: cmgTab.TabId );

                CswNbtMetaDataNodeTypeProp reservedForNTP = containerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.ReservedFor );
                reservedForNTP.updateLayout( CswEnumNbtLayoutType.Edit, false, TabId: cmgTab.TabId );

                CswNbtMetaDataNodeTypeProp receiptLotNTP = containerNT.getNodeTypePropByObjectClassProp( CswNbtObjClassContainer.PropertyName.ReceiptLot );
                CswNbtMetaDataNodeTypeTab firstTab = containerNT.getFirstNodeTypeTab();
                receiptLotNTP.updateLayout( CswEnumNbtLayoutType.Edit, false, TabId: firstTab.TabId );
            }

            CswNbtMetaDataObjectClass RequestMatDispOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.RequestMaterialDispenseClass );
            foreach( CswNbtMetaDataNodeType NodeType in RequestMatDispOc.getLatestVersionNodeTypes() )
            {
                CswNbtMetaDataNodeTypeTab CmgTab = NodeType.getNodeTypeTab( "Central Material Group" )
                    ?? _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( NodeType, "Central Material Group", NodeType.getNextTabOrder() );

                CswNbtMetaDataNodeTypeProp RofNtp = NodeType.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestMaterialDispense.PropertyName.RecurringFrequency );
                RofNtp.updateLayout( CswEnumNbtLayoutType.Edit, true, CmgTab.TabId );
                CswNbtMetaDataNodeTypeProp NrdNtp = NodeType.getNodeTypePropByObjectClassProp( CswNbtObjClassRequestMaterialDispense.PropertyName.NextReorderDate );
                NrdNtp.updateLayout( CswEnumNbtLayoutType.Edit, RofNtp, true );

                CswNbtMetaDataNodeTypeProp LastNtp = NrdNtp;
                foreach( string CmgTabProp in CswNbtObjClassRequestMaterialDispense.PropertyName.MLMCmgTabProps )
                {
                    CswNbtMetaDataNodeTypeProp CmgNtp = NodeType.getNodeTypePropByObjectClassProp( CmgTabProp );
                    CmgNtp.updateLayout( CswEnumNbtLayoutType.Edit, LastNtp, true );
                    LastNtp = CmgNtp;
                }

                CswNbtMetaDataNodeTypeTab ReceiveTab = NodeType.getNodeTypeTab( "Receive" )
                    ?? _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( NodeType, "Receive", NodeType.getNextTabOrder() );
                foreach( string ReceiveTabProp in CswNbtObjClassRequestMaterialDispense.PropertyName.MLMReceiveTabProps )
                {
                    CswNbtMetaDataNodeTypeProp ReceiveNtp = NodeType.getNodeTypePropByObjectClassProp( ReceiveTabProp );
                    ReceiveNtp.updateLayout( CswEnumNbtLayoutType.Edit, true, ReceiveTab.TabId );
                }
            }

            //Case 28339
            //   Show Vendor.VendorType and CorporateEntity
            //   Add a filter to Material.Supplier where VendorType = 'Coporate'
            CswNbtMetaDataObjectClass vendorOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.VendorClass );
            foreach( CswNbtMetaDataNodeType vendorNT in vendorOC.getNodeTypes() )
            {
                CswNbtMetaDataNodeTypeTab firstTab = vendorNT.getFirstNodeTypeTab();
                CswNbtMetaDataNodeTypeProp vendorTypeNTP = vendorNT.getNodeTypePropByObjectClassProp( CswNbtObjClassVendor.PropertyName.VendorTypeName );
                vendorTypeNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TabId: firstTab.TabId );
                vendorTypeNTP.updateLayout( CswEnumNbtLayoutType.Add, true, TabId: firstTab.TabId );

                CswNbtMetaDataNodeTypeProp corporateEntityNTP = vendorNT.getNodeTypePropByObjectClassProp( CswNbtObjClassVendor.PropertyName.CorporateEntityName );
                corporateEntityNTP.updateLayout( CswEnumNbtLayoutType.Edit, true, TabId: firstTab.TabId );
            }

            _toggleMaterialRequestApprovalLevel( CswEnumNbtObjectClass.RequestMaterialCreateClass, false );
            _toggleMaterialRequestApprovalLevel( CswEnumNbtObjectClass.RequestMaterialDispenseClass, false );

            #endregion

            #region SDS

            foreach( CswNbtMetaDataNodeType ChemicalNT in ChemicalOC.getNodeTypes() )
            {
                foreach( CswNbtMetaDataNodeTypeTab Tab in ChemicalNT.getNodeTypeTabs() )
                {
                    if( Tab.TabOrder >= 3 )
                        Tab.TabOrder += 1;
                }
                CswNbtMetaDataNodeTypeTab HazardsTab = ChemicalNT.getNodeTypeTab( "Hazards" ) ?? _CswNbtSchemaModTrnsctn.MetaData.makeNewTab( ChemicalNT, "Hazards", 3 );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ChemicalNT.NodeTypeId, "Assigned SDS", HazardsTab, 1, 1 );
                _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ChemicalNT.NodeTypeId, "View SDS", ChemicalNT.getIdentityTab(), 3, 2 );
            }

            //Show the following Container properties...
            //   View SDS
            if( _CswNbtSchemaModTrnsctn.Modules.IsModuleEnabled( CswEnumNbtModuleName.Containers ) )
            {
                foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
                {
                    _CswNbtSchemaModTrnsctn.Modules.AddPropToTab( ContainerNT.NodeTypeId, "View SDS", ContainerNT.getIdentityTab(), 1, 2 );
                }
            }

            #endregion

        } // update()
        public override void update()
        {
            CswNbtMetaDataObjectClass ContainerOC = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswEnumNbtObjectClass.ContainerClass );
            if( null != ContainerOC )
            {
                CswNbtMetaDataObjectClassProp HomeLocationOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( ContainerOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                    {
                        FieldType = CswEnumNbtFieldType.Relationship,
                        PropName = CswNbtObjClassContainer.PropertyName.HomeLocation,
                        ReadOnly = true,
                        IsFk = true,
                        FkType = CswEnumNbtViewRelatedIdType.ObjectClassId.ToString(),
                        FkValue = _CswNbtSchemaModTrnsctn.MetaData.getObjectClassId( CswEnumNbtObjectClass.LocationClass )
                    } );

                CswNbtMetaDataObjectClassProp ProjectOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( ContainerOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                    {
                        FieldType = CswEnumNbtFieldType.Text,
                        PropName = CswNbtObjClassContainer.PropertyName.Project,
                        ReadOnly = true,
                    } );
                
                CswNbtMetaDataObjectClassProp TareQuantityOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( ContainerOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                    {
                        FieldType = CswEnumNbtFieldType.Quantity,
                        PropName = CswNbtObjClassContainer.PropertyName.TareQuantity,
                        ReadOnly = true,
                        IsFk = true,
                        FkType = CswEnumNbtViewRelatedIdType.ObjectClassId.ToString(),
                        FkValue = _CswNbtSchemaModTrnsctn.MetaData.getObjectClassId( CswEnumNbtObjectClass.UnitOfMeasureClass )
                    } );

                CswNbtMetaDataObjectClassProp SpecificActivityOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( ContainerOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                    {
                        FieldType = CswEnumNbtFieldType.Text,
                        PropName = CswNbtObjClassContainer.PropertyName.SpecificActivity,
                        ReadOnly = true,
                    } );

                CswNbtMetaDataObjectClassProp ConcentrationOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( ContainerOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                    {
                        FieldType = CswEnumNbtFieldType.Text,
                        PropName = CswNbtObjClassContainer.PropertyName.Concentration,
                        ReadOnly = true,
                    } );

                CswNbtMetaDataObjectClassProp NotesOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( ContainerOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                    {
                        FieldType = CswEnumNbtFieldType.Comments,
                        PropName = CswNbtObjClassContainer.PropertyName.Notes,
                        ReadOnly = true,
                    } );

                CswNbtMetaDataObjectClassProp OpenedDateOCP = _CswNbtSchemaModTrnsctn.createObjectClassProp( ContainerOC, new CswNbtWcfMetaDataModel.ObjectClassProp
                    {
                        FieldType = CswEnumNbtFieldType.DateTime,
                        PropName = CswNbtObjClassContainer.PropertyName.OpenedDate,
                        ReadOnly = true,
                    } );
                _CswNbtSchemaModTrnsctn.MetaData.makeMissingNodeTypeProps(); //in order to cascade hidden status to the nodetype props

                Collection<CswNbtMetaDataObjectClassProp> ObjectClassProps = new Collection<CswNbtMetaDataObjectClassProp>
                    {
                        HomeLocationOCP, ProjectOCP, TareQuantityOCP, SpecificActivityOCP, ConcentrationOCP, NotesOCP, OpenedDateOCP
                    }; 


                foreach( CswNbtMetaDataNodeType ContainerNT in ContainerOC.getNodeTypes() )
                {
                    foreach( CswNbtMetaDataObjectClassProp ObjectClassProp in ObjectClassProps )
                    {
                        if( null != ObjectClassProp )
                        {
                            CswNbtMetaDataNodeTypeProp NodetypeProp = ContainerNT.getNodeTypePropByObjectClassProp( ObjectClassProp );
                            if( null != NodetypeProp )
                            {
                                NodetypeProp.removeFromAllLayouts();
                            }
                        }
                    }

                }

            }//if null != ContainerOC
        } // update()