Exemple #1
0
        }//createSizeNodes()

        public void createMaterialSynonyms(CswNbtPropertySetMaterial MaterialNode)
        {
            CswNbtMetaDataNodeType MaterialSynonymNT = _CswNbtResources.MetaData.getNodeType("Material Synonym");

            if (null != MaterialSynonymNT)
            {
                for (int index = 0; index < _ProductToImport.Synonyms.Length; index++)
                {
                    _CswNbtResources.Nodes.makeNodeFromNodeTypeId(MaterialSynonymNT.NodeTypeId, delegate(CswNbtNode NewNode)
                    {
                        CswNbtObjClassMaterialSynonym MaterialSynonymOC = NewNode;
                        MaterialSynonymOC.Name.Text = _ProductToImport.Synonyms[index];
                        MaterialSynonymOC.Material.RelatedNodeId = MaterialNode.NodeId;
                    });
                }
            }
        }
Exemple #2
0
        public override void update()
        {
            CswNbtMetaDataObjectClass InventoryGroupOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.InventoryGroupClass );

            CswNbtObjClassInventoryGroup DefaultNodeAsInventoryGroup = null;
            foreach( CswNbtNode Group in InventoryGroupOc.getNodes( true, false ) )
            {
                CswNbtObjClassInventoryGroup NodeAsInventoryGroup = Group;
                if( null != NodeAsInventoryGroup )
                {
                    if( NodeAsInventoryGroup.Name.Text.ToLower() == "cispro" )
                    {
                        DefaultNodeAsInventoryGroup = NodeAsInventoryGroup;
                        DefaultNodeAsInventoryGroup.Name.Text = "Default Inventory Group";
                        DefaultNodeAsInventoryGroup.IsDemo = true;
                        DefaultNodeAsInventoryGroup.postChanges( ForceUpdate: false );
                    }
                }
            }
            if( null == DefaultNodeAsInventoryGroup )
            {
                CswNbtMetaDataNodeType InventoryGroupNt = InventoryGroupOc.getLatestVersionNodeTypes().FirstOrDefault();
                if( null != InventoryGroupNt )
                {
                    DefaultNodeAsInventoryGroup = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( InventoryGroupNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
                    DefaultNodeAsInventoryGroup.Name.Text = "Default Inventory Group";
                    DefaultNodeAsInventoryGroup.postChanges( ForceUpdate: false );
                }
            }
            CswNbtMetaDataObjectClass LocationOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.LocationClass );
            CswNbtObjClassLocation DefaultLocation = null;
            if( null != DefaultNodeAsInventoryGroup )
            {
                foreach( CswNbtObjClassLocation Location in LocationOc.getNodes( true, false ) )
                {
                    if( null != Location )
                    {
                        if( Location.Name.Text.ToLower() == "center hall" )
                        {
                            DefaultLocation = Location;
                        }
                        if( null == Location.InventoryGroup.RelatedNodeId || Int32.MinValue == Location.InventoryGroup.RelatedNodeId.PrimaryKey )
                        {
                            Location.InventoryGroup.RelatedNodeId = DefaultNodeAsInventoryGroup.NodeId;
                            Location.postChanges( ForceUpdate: false );
                        }
                    }
                }
            }

            CswNbtMetaDataObjectClass WorkUnitOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.WorkUnitClass );
            CswNbtMetaDataNodeType WorkUnitNt = WorkUnitOc.getLatestVersionNodeTypes().FirstOrDefault();
            if( null != WorkUnitNt )
            {
                WorkUnitNt.NameTemplateValue = "";
                WorkUnitNt.addNameTemplateText( CswNbtObjClassWorkUnit.NamePropertyName );
                CswNbtObjClassWorkUnit DefaultWorkUnit = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( WorkUnitNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
                DefaultWorkUnit.Name.Text = "Default Work Unit";
                DefaultWorkUnit.IsDemo = true;
                DefaultWorkUnit.postChanges( ForceUpdate: false );

                CswNbtMetaDataObjectClass UserOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.UserClass );
                Collection<Int32> RoleIdsWithUsers = new Collection<Int32>();
                CswNbtMetaDataNodeType UserNt = null;
                foreach( CswNbtObjClassUser User in UserOc.getNodes( true, false ) )
                {
                    if( null != User )
                    {
                        UserNt = UserNt ?? User.NodeType;
                        RoleIdsWithUsers.Add( User.RoleId.PrimaryKey );
                        if( null == User.WorkUnitProperty.RelatedNodeId || Int32.MinValue == User.WorkUnitProperty.RelatedNodeId.PrimaryKey )
                        {
                            User.WorkUnitProperty.RelatedNodeId = DefaultWorkUnit.NodeId;
                        }
                        if( null != DefaultLocation && ( null == User.DefaultLocationProperty.SelectedNodeId || Int32.MinValue == User.DefaultLocationProperty.SelectedNodeId.PrimaryKey ) )
                        {
                            User.DefaultLocationProperty.SelectedNodeId = DefaultLocation.NodeId;
                        }
                        User.postChanges( ForceUpdate: false );
                    }
                }

                CswNbtMetaDataObjectClass RoleOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.RoleClass );
                if( null == UserNt )
                {
                    UserNt = UserOc.getLatestVersionNodeTypes().FirstOrDefault();
                }
                if( null != UserNt )
                {
                    foreach( CswNbtObjClassRole Role in RoleOc.getNodes( true, false ) )
                    {
                        if( null != Role && false == RoleIdsWithUsers.Contains( Role.NodeId.PrimaryKey ) )
                        {
                            string ValidUserName = CswNbtObjClassUser.getValidUserName( Role.Name.Text.ToLower() );
                            if( ValidUserName != CswNbtObjClassUser.ChemSWAdminUsername )
                            {
                                if( CswNbtObjClassUser.IsUserNameUnique( _CswNbtSchemaModTrnsctn.MetaData._CswNbtMetaDataResources.CswNbtResources, ValidUserName ) )
                                {
                                    CswNbtObjClassUser NewUser = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( UserNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
                                    NewUser.IsDemo = false;
                                    NewUser.Role.RelatedNodeId = Role.NodeId;
                                    NewUser.UsernameProperty.Text = ValidUserName;
                                    NewUser.WorkUnitProperty.RelatedNodeId = DefaultWorkUnit.NodeId;
                                    if( null != DefaultLocation )
                                    {
                                        NewUser.DefaultLocationProperty.SelectedNodeId = DefaultLocation.NodeId;
                                    }
                                    NewUser.PasswordProperty.Password = Role.Name.Text.ToLower();
                                    NewUser.postChanges( ForceUpdate: false );
                                }
                            }
                        }
                    }
                }
                CswNbtMetaDataObjectClass IgPermissionOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.InventoryGroupPermissionClass );
                foreach( CswNbtObjClassInventoryGroupPermission Permission in IgPermissionOc.getNodes( true, false ) )
                {
                    if( null != Permission )
                    {
                        if( null != DefaultNodeAsInventoryGroup && ( null == Permission.InventoryGroup.RelatedNodeId || Int32.MinValue == Permission.InventoryGroup.RelatedNodeId.PrimaryKey ) )
                        {
                            Permission.InventoryGroup.RelatedNodeId = DefaultNodeAsInventoryGroup.NodeId;
                        }
                        if( null == Permission.WorkUnit.RelatedNodeId || Int32.MinValue == Permission.WorkUnit.RelatedNodeId.PrimaryKey )
                        {
                            Permission.WorkUnit.RelatedNodeId = DefaultWorkUnit.NodeId;
                        }
                        Permission.postChanges( ForceUpdate: false );
                    }
                }
            }

            CswNbtMetaDataObjectClass MaterialOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.MaterialClass );
            CswNbtMetaDataObjectClass SynonymOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.MaterialSynonymClass );
            CswNbtMetaDataObjectClass SizeOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.SizeClass );
            CswNbtMetaDataObjectClass VendorOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.VendorClass );
            CswNbtMetaDataObjectClass UnitOc = _CswNbtSchemaModTrnsctn.MetaData.getObjectClass( CswNbtMetaDataObjectClass.NbtObjectClass.UnitOfMeasureClass );

            CswNbtObjClassVendor DefaultVendor = null;
            CswNbtMetaDataNodeType VendorNt = VendorOc.getLatestVersionNodeTypes().FirstOrDefault();
            if( null != VendorNt )
            {
                DefaultVendor = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( VendorNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
                DefaultVendor.VendorName.Text = "Default Vendor";
                DefaultVendor.IsDemo = true;
                DefaultVendor.postChanges( ForceUpdate: false );
            }
            CswNbtMetaDataNodeType SizeNt = SizeOc.getLatestVersionNodeTypes().FirstOrDefault();
            CswNbtMetaDataNodeType SynonymNt = SynonymOc.getLatestVersionNodeTypes().FirstOrDefault();
            CswNbtObjClassUnitOfMeasure DefaultSizeUnit = null;
            CswNbtObjClassUnitOfMeasure DefaultTimeUnit = null;
            foreach( CswNbtObjClassUnitOfMeasure Unit in UnitOc.getNodes( true, false ) )
            {
                if( null != Unit )
                {
                    if( Unit.Name.Text.ToLower() == "g" )
                    {
                        DefaultSizeUnit = Unit;
                    }
                    else if( Unit.Name.Text.ToLower() == "years" )
                    {
                        DefaultTimeUnit = Unit;
                    }
                }
            }

            foreach( CswNbtMetaDataNodeType MaterialNt in MaterialOc.getLatestVersionNodeTypes() )
            {
                CswNbtObjClassMaterial Material = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( MaterialNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
                Material.IsDemo = true;
                Material.TradeName.Text = "Default " + MaterialNt.NodeTypeName;
                if( null != DefaultVendor )
                {
                    Material.Supplier.RelatedNodeId = DefaultVendor.NodeId;
                }
                Material.PartNumber.Text = "658-35AB";
                Material.PhysicalState.Value = CswNbtObjClassMaterial.PhysicalStates.Solid;
                Material.ExpirationInterval.Quantity = 1;
                if( null != DefaultTimeUnit )
                {
                    Material.ExpirationInterval.UnitId = DefaultTimeUnit.NodeId;
                }
                Material.postChanges( ForceUpdate: false );

                if( null != SizeNt )
                {
                    CswNbtObjClassSize Size = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( SizeNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
                    Size.IsDemo = true;
                    Size.Material.RelatedNodeId = Material.NodeId;
                    Size.CatalogNo.Text = "NE-H5/3";
                    Size.InitialQuantity.Quantity = 1;
                    if( null != DefaultSizeUnit )
                    {
                        Size.InitialQuantity.UnitId = DefaultSizeUnit.NodeId;
                    }
                    Size.postChanges( ForceUpdate: false );
                }

                if( null != SynonymNt )
                {
                    CswNbtObjClassMaterialSynonym Synonym = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( SynonymNt.NodeTypeId, CswNbtNodeCollection.MakeNodeOperation.WriteNode, OverrideUniqueValidation: false );
                    Synonym.IsDemo = true;
                    Synonym.Material.RelatedNodeId = Material.NodeId;
                    Synonym.Name.Text = Material.TradeName.Text + " Synonym";
                    Synonym.postChanges( ForceUpdate: false );
                }
            }


        }//Update()
Exemple #3
0
        public static void getCopyData(ICswResources _CswResources, CopyDataReturn Copy, CopyDataRequest Request)
        {
            CswNbtResources _CswNbtResources = (CswNbtResources)_CswResources;

            //If we get any more copy types in the future, extract them out into their own classes and instantiate them via factory
            #region Create_Material Copy Data

            if (Request.CopyType == CswEnumNbtActionName.Create_Material)
            {
                CswPrimaryKey OriginalNodeId = CswConvert.ToPrimaryKey(Request.NodeId);
                if (CswTools.IsPrimaryKey(OriginalNodeId))
                {
                    CswNbtPropertySetMaterial OriginalMaterial = _CswNbtResources.Nodes.GetNode(OriginalNodeId);
                    if (null != OriginalMaterial)
                    {
                        #region Material Properties

                        CswNbtPropertySetMaterial MaterialCopy = OriginalMaterial.CopyNode();
                        Copy.Data.Create_Material = new C3CreateMaterialResponse
                        {
                            actionname = CswEnumNbtActionName.Create_Material,
                            state      = new C3CreateMaterialResponse.State
                            {
                                materialId   = MaterialCopy.NodeId.ToString(),
                                materialType = new C3CreateMaterialResponse.State.MaterialType
                                {
                                    name = MaterialCopy.NodeType.NodeTypeName,
                                    val  = CswConvert.ToInt32(MaterialCopy.NodeTypeId)
                                },
                                tradeName = OriginalMaterial.TradeName.Text,
                                partNo    = OriginalMaterial.PartNumber.Text,
                                supplier  = new C3CreateMaterialResponse.State.Supplier
                                {
                                    name = OriginalMaterial.Supplier.CachedNodeName,
                                    val  = OriginalMaterial.Supplier.RelatedNodeId.ToString()
                                },
                                sizes           = new Collection <C3CreateMaterialResponse.State.SizeRecord>(),
                                showOriginalUoM = false
                            }
                        };

                        #endregion Material Properties

                        #region Sizes

                        CswNbtMetaDataObjectClass     SizeOC      = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.SizeClass);
                        CswNbtMetaDataObjectClassProp MaterialOCP = SizeOC.getObjectClassProp(CswNbtObjClassSize.PropertyName.Material);
                        CswNbtView SizesView = new CswNbtView(_CswNbtResources)
                        {
                            ViewName = "MaterialCopySizes"
                        };
                        CswNbtViewRelationship SizeVR = SizesView.AddViewRelationship(SizeOC, false);
                        SizesView.AddViewPropertyAndFilter(SizeVR, MaterialOCP, OriginalMaterial.NodeId.PrimaryKey.ToString(), CswEnumNbtSubFieldName.NodeID);
                        ICswNbtTree SizesTree = _CswNbtResources.Trees.getTreeFromView(SizesView, false, false, false);
                        for (int i = 0; i < SizesTree.getChildNodeCount(); i++)
                        {
                            SizesTree.goToNthChild(i);
                            CswNbtObjClassSize SizeNode = SizesTree.getNodeForCurrentPosition();
                            Copy.Data.Create_Material.state.sizes.Add(new C3CreateMaterialResponse.State.SizeRecord
                            {
                                nodeTypeId = new C3CreateMaterialResponse.State.SizeRecord.SizeData
                                {
                                    value    = SizeNode.NodeTypeId.ToString(),
                                    readOnly = true,
                                    hidden   = true
                                },
                                unitCount = new C3CreateMaterialResponse.State.SizeRecord.SizeData
                                {
                                    value    = CswConvert.ToString(SizeNode.UnitCount.Value),
                                    readOnly = true,
                                    hidden   = false
                                },
                                quantity = new C3CreateMaterialResponse.State.SizeRecord.SizeData
                                {
                                    value    = CswConvert.ToString(SizeNode.InitialQuantity.Quantity),
                                    readOnly = true,
                                    hidden   = false
                                },
                                uom = new C3CreateMaterialResponse.State.SizeRecord.SizeData
                                {
                                    value    = SizeNode.InitialQuantity.CachedUnitName,
                                    readOnly = false == string.IsNullOrEmpty(SizeNode.InitialQuantity.CachedUnitName),
                                    hidden   = false,
                                    id       = SizeNode.InitialQuantity.UnitId.ToString()
                                },
                                catalogNo = new C3CreateMaterialResponse.State.SizeRecord.SizeData
                                {
                                    value    = SizeNode.CatalogNo.Text,
                                    readOnly = true,
                                    hidden   = false
                                },
                                quantityEditable = new C3CreateMaterialResponse.State.SizeRecord.SizeData
                                {
                                    value = SizeNode.QuantityEditable.Checked,
                                },
                                dispensible = new C3CreateMaterialResponse.State.SizeRecord.SizeData
                                {
                                    value = SizeNode.Dispensable.Checked
                                }
                            });
                            SizesTree.goToParentNode();
                        }

                        #endregion Sizes

                        #region Synonyms

                        CswNbtMetaDataObjectClass     MaterialSynonymOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.MaterialSynonymClass);
                        CswNbtMetaDataObjectClassProp SynMaterialOCP    = MaterialSynonymOC.getObjectClassProp(CswNbtObjClassMaterialSynonym.PropertyName.Material);
                        CswNbtView SynonymsView = new CswNbtView(_CswNbtResources)
                        {
                            ViewName = "MaterialCopySynonyms"
                        };
                        CswNbtViewRelationship SynonymsVR = SynonymsView.AddViewRelationship(MaterialSynonymOC, false);
                        SynonymsView.AddViewPropertyAndFilter(SynonymsVR, SynMaterialOCP, OriginalMaterial.NodeId.PrimaryKey.ToString(), CswEnumNbtSubFieldName.NodeID);
                        ICswNbtTree SynonymsTree = _CswNbtResources.Trees.getTreeFromView(SynonymsView, false, false, false);
                        for (int i = 0; i < SynonymsTree.getChildNodeCount(); i++)
                        {
                            SynonymsTree.goToNthChild(i);
                            CswNbtObjClassMaterialSynonym SynonymNode = SynonymsTree.getNodeForCurrentPosition();
                            CswNbtObjClassMaterialSynonym SynonymCopy = SynonymNode.CopyNode();
                            SynonymCopy.Material.RelatedNodeId = MaterialCopy.NodeId;
                            SynonymCopy.postChanges(false);
                            SynonymsTree.goToParentNode();
                        }

                        #endregion Synonyms

                        if (MaterialCopy.ObjectClass.ObjectClass == CswEnumNbtObjectClass.ChemicalClass)
                        {
                            if (CswEnumTristate.False == MaterialCopy.IsConstituent.Checked)
                            {
                                #region SDS

                                CswNbtView  SDSView = CswNbtObjClassSDSDocument.getAssignedSDSDocumentsView(_CswNbtResources, OriginalMaterial.NodeId);
                                ICswNbtTree SDSTree = _CswNbtResources.Trees.getTreeFromView(SDSView, false, false, false);
                                SDSTree.goToNthChild(0);
                                for (int i = 0; i < SDSTree.getChildNodeCount(); i++)
                                {
                                    SDSTree.goToNthChild(i);
                                    CswNbtObjClassSDSDocument SDSDoc  = SDSTree.getNodeForCurrentPosition();
                                    CswNbtObjClassSDSDocument SDSCopy = SDSDoc.CopyNode(IsNodeTemp: true);

                                    SDSCopy.Owner.RelatedNodeId = MaterialCopy.NodeId;
                                    SDSCopy.postChanges(false);

                                    if (i == 0)
                                    {
                                        Copy.Data.Create_Material.state.sds.sdsDocId = SDSCopy.NodeId.ToString();
                                    }
                                    SDSTree.goToParentNode();
                                }

                                #endregion SDS

                                #region Components

                                CswNbtMetaDataObjectClass     MaterialComponentOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.MaterialComponentClass);
                                CswNbtMetaDataObjectClassProp CompMaterialOCP     = MaterialComponentOC.getObjectClassProp(CswNbtObjClassMaterialComponent.PropertyName.Mixture);
                                CswNbtView ComponentsView = new CswNbtView(_CswNbtResources)
                                {
                                    ViewName = "MaterialCopyComponents"
                                };
                                CswNbtViewRelationship ComponentsVR = ComponentsView.AddViewRelationship(MaterialComponentOC, false);
                                ComponentsView.AddViewPropertyAndFilter(ComponentsVR, CompMaterialOCP, OriginalMaterial.NodeId.PrimaryKey.ToString(), CswEnumNbtSubFieldName.NodeID);
                                ICswNbtTree ComponentsTree = _CswNbtResources.Trees.getTreeFromView(ComponentsView, false, false, false);
                                for (int i = 0; i < ComponentsTree.getChildNodeCount(); i++)
                                {
                                    ComponentsTree.goToNthChild(i);
                                    CswNbtObjClassMaterialComponent ComponentNode = ComponentsTree.getNodeForCurrentPosition();
                                    CswNbtObjClassMaterialComponent ComponentCopy = ComponentNode.CopyNode();
                                    ComponentCopy.Mixture.RelatedNodeId     = MaterialCopy.NodeId;
                                    ComponentCopy.Constituent.RelatedNodeId = ComponentNode.Constituent.RelatedNodeId;
                                    ComponentCopy.postChanges(false);
                                    ComponentsTree.goToParentNode();
                                }

                                #endregion Components
                            }

                            #region GHS

                            CswNbtMetaDataObjectClass     GHSOC          = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.GHSClass);
                            CswNbtMetaDataObjectClassProp GHSMaterialOCP = GHSOC.getObjectClassProp(CswNbtObjClassGHS.PropertyName.Material);
                            CswNbtView GHSView = new CswNbtView(_CswNbtResources)
                            {
                                ViewName = "MaterialCopyGHS"
                            };
                            CswNbtViewRelationship GHSVR = GHSView.AddViewRelationship(GHSOC, false);
                            GHSView.AddViewPropertyAndFilter(GHSVR, GHSMaterialOCP, OriginalMaterial.NodeId.PrimaryKey.ToString(), CswEnumNbtSubFieldName.NodeID);
                            ICswNbtTree GHSTree = _CswNbtResources.Trees.getTreeFromView(GHSView, false, false, false);
                            for (int i = 0; i < GHSTree.getChildNodeCount(); i++)
                            {
                                GHSTree.goToNthChild(i);
                                CswNbtObjClassGHS GHSNode = GHSTree.getNodeForCurrentPosition();
                                CswNbtObjClassGHS GHSCopy = GHSNode.CopyNode();
                                GHSCopy.Material.RelatedNodeId = MaterialCopy.NodeId;
                                GHSCopy.postChanges(false);
                                GHSTree.goToParentNode();
                            }

                            #endregion GHS
                        }
                    }
                }
            }

            #endregion Create_Material Copy Data
        }