private InstrumentPropertyValue GetPropertyValue(InstrumentComponent controlSystemComponent,
            InstrumentComponentTypeProperty controlSystemComponentProperty)
        {
            var propertyValue = (from x in controlSystemComponent.InstrumentPropertyValues
                                 where x.InstrumentPropertyId == controlSystemComponentProperty.InstrumentPropertyId &&
                                       x.InstrumentComponentId == controlSystemComponent.Id
                                 select x).FirstOrDefault();

            if (propertyValue == null)
            {
                propertyValue = new InstrumentPropertyValue
                {
                    InstrumentComponentId = controlSystemComponent.Id,
                    InstrumentPropertyId = controlSystemComponentProperty.InstrumentPropertyId,
                    Value = controlSystemComponentProperty.InstrumentProperty.DefaultValue
                };

                controlSystemComponent.InstrumentPropertyValues.Add(propertyValue);
            }
            return propertyValue;
        }
        private void AddExistingInstrumentComponentProperty(NodeView nodeView)
        {
            int instrumentEquipmentComponentTypeId = nodeView.Id;
            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

            cmsWebServiceClient.GetInstrumentComponentTypeCompleted +=
                (s, e) =>
                {
                    AddEditExistingInstrumentComponentPropertyDialog addEditExistingInstrumentComponentProperty = new AddEditExistingInstrumentComponentPropertyDialog(e.Result);
                    addEditExistingInstrumentComponentProperty.Show();

                    addEditExistingInstrumentComponentProperty.Closed += (s1, e1) =>
                    {
                        if (addEditExistingInstrumentComponentProperty.DialogResult.HasValue && addEditExistingInstrumentComponentProperty.DialogResult.Value)
                        {
                            EventHandler<AddUpdateInstrumentComponentTypePropertyCompletedEventArgs> addCompleted = null;
                            addCompleted = (s2, eventArgs) =>
                            {
                                InstrumentComponentTypeProperty pcpt = eventArgs.Result;

                                if (pcpt != null)
                                {
                                    NodeView child = new NodeView(nodeView)
                                    {
                                        Id = pcpt.Id,
                                        Name = addEditExistingInstrumentComponentProperty.InstrumentComponentTypeProperty.InstrumentProperty.Name,
                                        Description = addEditExistingInstrumentComponentProperty.InstrumentComponentTypeProperty.InstrumentProperty.Description,
                                        Icon = "/CmsEquipmentDatabase;component/Images/Configuration.png",
                                        Type = NodeType.InstrumentComponentTypeProperty,
                                        HasChildren = false,
                                        SortField = pcpt.Ordinal.ToString()
                                    };
                                    if (nodeView.ChildrenLoaded)
                                    {
                                        nodeView.Children.Add(child);
                                        nodeView.Sort();
                                    }
                                }

                                cmsWebServiceClient.AddUpdateInstrumentComponentTypePropertyCompleted -= addCompleted;

                            };
                            cmsWebServiceClient.AddUpdateInstrumentComponentTypePropertyCompleted += addCompleted;

                            InstrumentComponentTypeProperty instrumentEquipmentComponentTypeProperty = new InstrumentComponentTypeProperty
                            {
                                InstrumentComponentTypeId = instrumentEquipmentComponentTypeId,
                                InstrumentPropertyId = addEditExistingInstrumentComponentProperty.InstrumentComponentTypeProperty.InstrumentPropertyId,
                                Ordinal = addEditExistingInstrumentComponentProperty.InstrumentComponentTypeProperty.Ordinal
                            };

                            cmsWebServiceClient.AddUpdateInstrumentComponentTypePropertyAsync(instrumentEquipmentComponentTypeProperty);
                        }
                    };
                };
            cmsWebServiceClient.GetInstrumentComponentTypeAsync(instrumentEquipmentComponentTypeId);
        }
Пример #3
0
        public InstrumentComponentTypeProperty AddUpdateInstrumentComponentTypeProperty(InstrumentComponentTypeProperty ictp)
        {
            using (CmsEntities cee = new CmsEntities())
            {
                //Check if this component property already exist
                InstrumentComponentTypeProperty temp = (from x in cee.InstrumentComponentTypeProperties
                                                        where x.InstrumentPropertyId == ictp.InstrumentPropertyId &&
                                                              x.InstrumentComponentTypeId == ictp.InstrumentComponentTypeId
                                                        select x).FirstOrDefault();

                if (temp == null)
                {
                    temp = new InstrumentComponentTypeProperty();
                    cee.InstrumentComponentTypeProperties.Add(temp);
                }

                temp.InstrumentPropertyId = ictp.InstrumentPropertyId;
                temp.InstrumentComponentTypeId = ictp.InstrumentComponentTypeId;
                temp.Ordinal = ictp.Ordinal;

                cee.SaveChanges();

                return temp;
            }
        }
        private void EditInstrumentComponentTypeProperty(NodeView nodeView)
        {
            AddEditExistingInstrumentComponentPropertyDialog dialog = new AddEditExistingInstrumentComponentPropertyDialog(nodeView.Id);
            dialog.Title = "Edit Instrument Component Property";

            dialog.Closed +=
                (s1, e1) =>
                {
                    if (dialog.DialogResult.HasValue && dialog.DialogResult.Value)
                    {
                        CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
                        EventHandler<AddUpdateInstrumentComponentTypePropertyCompletedEventArgs> addCompleted = null;
                        addCompleted = (s2, eventArgs) =>
                        {
                            InstrumentComponentTypeProperty pcpt = eventArgs.Result;
                            if (pcpt != null)
                            {
                                nodeView.Name = dialog.InstrumentComponentTypeProperty.InstrumentProperty.Name;
                                nodeView.Description = dialog.InstrumentComponentTypeProperty.InstrumentProperty.Description;
                                nodeView.SortField = dialog.InstrumentComponentTypeProperty.Ordinal.ToString();
                            }
                            cmsWebServiceClient.AddUpdateInstrumentComponentTypePropertyCompleted -= addCompleted;
                            nodeView.Parent.Sort();
                        };
                        cmsWebServiceClient.AddUpdateInstrumentComponentTypePropertyCompleted += addCompleted;

                        InstrumentComponentTypeProperty instrumentEquipmentComponentTypeProperty = new InstrumentComponentTypeProperty
                        {
                            InstrumentComponentTypeId = dialog.InstrumentComponentTypeProperty.InstrumentComponentTypeId,
                            InstrumentPropertyId = dialog.InstrumentComponentTypeProperty.InstrumentPropertyId,
                            Ordinal = dialog.InstrumentComponentTypeProperty.Ordinal
                        };
                        cmsWebServiceClient.AddUpdateInstrumentComponentTypePropertyAsync(instrumentEquipmentComponentTypeProperty);
                    }
                };
            dialog.Show();
        }
        private void BuildPropertyValues(InstrumentComponent componentIn, InstrumentComponentDataAdapter adapter)
        {
            foreach (KeyValuePair<string, string> pair in adapter.PropertyValues)
            {
                //DOES PROPERTY EXIST?
                InstrumentProperty property = (from x in mExistingProperties where x.Name.ToLower() == pair.Key.ToLower() select x).FirstOrDefault();
                if (property == null)
                {
                    if (CanCreateProperties)
                    {
                        property = new InstrumentProperty { Name = pair.Key, DefaultValue = pair.Value, Description = " (created by importer)." };
                        mExistingProperties.Add(property);//update cache
                    }
                    else
                    {
                        //ERROR!
                        RaiseMessage(CommonUtils.MessageType.Error, string.Format("WorkSheet '{0}' Line '{1} Tag {2} Component Name {3}' : The property does not exist.",
                            WorkSheetName, adapter.RowNumber, adapter.Tag, adapter.ComponentName));
                        continue;
                    }
                }

                //CHECK InstrumentComponentTypeProperty Exists
                InstrumentComponentTypeProperty equipmentComponentTypeProperty = null;
                if (mExistingEquipmentComponentTypeProperty.Any())
                {
                    equipmentComponentTypeProperty =
                        (from x in mExistingEquipmentComponentTypeProperty
                         where x.InstrumentComponentType.Name.ToLower() == componentIn.InstrumentComponentType.Name.ToLower()
                         && x.InstrumentProperty.Name.ToLower() == property.Name.ToLower()
                         select x).FirstOrDefault();
                }

                if (equipmentComponentTypeProperty == null)
                {
                    if (CanCreateProperties)
                    {
                        //CREATE JOIN ROW
                        equipmentComponentTypeProperty = new InstrumentComponentTypeProperty
                        {
                            InstrumentComponentType = componentIn.InstrumentComponentType,
                            InstrumentProperty = property
                        };
                        mExistingEquipmentComponentTypeProperty.Add(equipmentComponentTypeProperty);//update cache
                    }
                    else
                    {
                        //ERROR!
                        RaiseMessage(CommonUtils.MessageType.Warning, string.Format("WorkSheet '{0}' Row '{1} Tag {2} Component Type {3}' : The property {4} does not belong to the Component Type.",
                            WorkSheetName, adapter.RowNumber, adapter.Tag, componentIn.InstrumentComponentType.Name, property.Name));
                        continue;
                    }
                }
                property.InstrumentComponentTypeProperties.Add(equipmentComponentTypeProperty);

                //CHECK PROPERTYVALUE EXISTS
                InstrumentPropertyValue propertyValue = null;
                //if (mCee.InstrumentPropertyValues.Any())
                //{

                propertyValue = (from x in Cee.InstrumentPropertyValues
                                 where x.InstrumentComponent.Name.ToLower() == componentIn.Name.ToLower()
                                       && x.InstrumentProperty.Name.ToLower() == property.Name.ToLower()
                                 select x).FirstOrDefault();
                //}

                if (propertyValue == null)
                {
                    propertyValue = new InstrumentPropertyValue
                    {
                        InstrumentComponent = componentIn,
                        InstrumentProperty = property
                    };
                    //mExistingPropertyValues.Add(propertyValue);//update cache
                }

                //set value
                if (!string.IsNullOrEmpty(pair.Value))
                {
                    propertyValue.Value = pair.Value.ChangeNullToEmptyString();
                }
                componentIn.InstrumentPropertyValues.Add(propertyValue);
            }
        }