private void OKButton_Click(object sender, RoutedEventArgs e)
        {
            if (mPipeRevisionHistoryViewModel.AreAllValid())
            {
                var mCmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

                mCmsWebServiceClient.AddPipeRevisionHistoryCompleted +=
                    (s1, e1) =>
                    {
                        AddedPipeRevisionHistory.Revision = e1.Result.Revision;
                        DialogResult = true;
                    };

                mPipeRevisionHistoryViewModel.User = CMS.User;
                mPipeRevisionHistoryViewModel.UserId = CMS.User.Id;
                mPipeRevisionHistoryViewModel.Date = DateTime.Now;
                AddedPipeRevisionHistory = mPipeRevisionHistoryViewModel.PipeRevisionHistory;
                mCmsWebServiceClient.AddPipeRevisionHistoryAsync(mPipeRevisionHistoryViewModel.PipeRevisionHistory);
            }
        }
Пример #2
0
        private void SavePipeComponents(Pipe pipe, CmsEntities cee, int pipeId, int userId)
        {
            foreach (var pipeComponent in pipe.PipeComponents)
            {
                var q = (from x in cee.PipeComponents
                         where x.Id == pipeComponent.Id
                         select x).FirstOrDefault();

                if (q != null)
                {
                    if (q.LastInspectedDate != pipeComponent.LastInspectedDate)
                    {
                        PipeRevisionHistory rv = new PipeRevisionHistory
                        {
                            PipeId = pipeId,
                            Date = DateTime.Now,
                            UserId = userId,
                            Description = string.Format("Component '{0}': Last Inspected Date changed from '{1}' to '{2}'.", pipeComponent.Name, q.LastInspectedDate, pipeComponent.LastInspectedDate),
                            IsSystemMessage = true
                        };

                        AddPipeRevisionHistoryInternal(rv, cee);
                    }

                    //Update Pipe Componet
                    cee.Entry(q).CurrentValues.SetValues(pipeComponent);
                }
                else
                {
                    q = new PipeComponent
                    {
                        PipeId = pipeComponent.PipeId,
                        PipeComponentTypeId = pipeComponent.PipeComponentTypeId,
                        SpecialFeature = pipeComponent.SpecialFeature,
                        Ordinal = pipeComponent.Ordinal,
                        Description = pipeComponent.Description,
                        SubArea = pipeComponent.SubArea,
                        Number = pipeComponent.Number,
                        DrawingId = pipeComponent.DrawingId,
                        NextInspectionDate = pipeComponent.NextInspectionDate,
                        LastInspectedById = pipeComponent.LastInspectedById,
                        LastInspectedDate = pipeComponent.LastInspectedDate,
                        LastModifiedDate = pipeComponent.LastModifiedDate,
                        LastModifiedById = pipeComponent.LastModifiedById,
                        ManufacturerId = pipeComponent.ManufacturerId,
                        ModelId = pipeComponent.ModelId,
                        AreaId = pipeComponent.AreaId
                    };

                    //Add new Pipe Component
                    cee.PipeComponents.Add(q);
                }

                foreach (var pipeComponentPropertyValue in pipeComponent.PipePropertyValues)
                {
                    var qq = (from x in cee.PipePropertyValues
                              where x.Id == pipeComponentPropertyValue.Id
                              select x).FirstOrDefault();

                    if (qq != null)
                    {
                        cee.Entry(qq).CurrentValues.SetValues(pipeComponentPropertyValue);
                    }
                    else
                    {
                        cee.PipePropertyValues.Add(pipeComponentPropertyValue);
                    }
                }
            }
            cee.SaveChanges();
        }
Пример #3
0
        private void DeletePipeAddHistory(Pipe pipe, int userId, Pipe originalPipe, CmsEntities cee)
        {
            IEnumerable<PipeComponent> componentsToBeDeleted = (from x in originalPipe.PipeComponents
                                                                where !pipe.PipeComponents.Any(x1 => x1.Id == x.Id)
                                                                select x);

            PipeRevisionHistory rh = new PipeRevisionHistory();

            string[] componentMessages = (from x in componentsToBeDeleted select "Name: " + x.Name + " Type: " + x.PipeComponentType.Name).ToArray();

            if (componentMessages.Length > 0)
            {
                string removedItems = string.Join(",", componentMessages);

                rh.Description = string.Format("Pipe Components were removed : {0}", removedItems);
                rh.PipeId = pipe.Id;
                rh.Date = DateTime.Now;
                rh.UserId = userId;
                rh.IsSystemMessage = true;

                var latestPrh = (from x in cee.PipeRevisionHistories
                                 where x.PipeId == pipe.Id
                                 select x.Revision).ToList();

                if (latestPrh.Count > 0)
                {
                    rh.Revision = latestPrh.AsQueryable().Max() + VERSIONINCREMENT;
                }
                else
                {
                    rh.Revision = VERSIONINCREMENT;
                }
                cee.PipeRevisionHistories.Add(rh);
            }
            cee.SaveChanges();

            foreach (var pipeComponent in componentsToBeDeleted)
            {
                DeletePipeComponent(pipeComponent);
            }
        }
Пример #4
0
        public PipeRevisionHistory AddPipeRevisionHistoryInternal(PipeRevisionHistory prh, CmsEntities cee)
        {
            const decimal incrediment = 0.001m;

            var latestPrh = (from x in cee.PipeRevisionHistories
                             where x.PipeId == prh.PipeId
                             select x.Revision).ToList();

            if (latestPrh.Count > 0)
            {
                prh.Revision = latestPrh.AsQueryable().Max() + incrediment;
            }
            else
            {
                prh.Revision = incrediment;
            }

            prh.User = null;
            //int issueId = prh.Issue.Id;
            prh.Issue = null;
            //prh.IssueId = issueId;

            cee.PipeRevisionHistories.Add(prh);
            cee.SaveChanges();

            return prh;
        }
Пример #5
0
 public PipeRevisionHistory AddPipeRevisionHistory(PipeRevisionHistory prh)
 {
     using (CmsEntities cee = new CmsEntities())
     {
         return AddPipeRevisionHistoryInternal(prh, cee);
     }
 }
Пример #6
0
        private void AddPipe()
        {
            var dialog = new AddPipeDialog();
            dialog.Show();

            dialog.Closed += (s1, e1) =>
            {
                if (dialog.DialogResult == true)
                {
                    var cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

                    cmsWebServiceClient.SavePipeCompleted +=
                        (s2, e2) =>
                        {
                            //insert new pipe into cached pipes list
                            QuickPipe savedQuickPipe = e2.Result.EntityResult;
                            EventAggregator.GetEvent<PrismEvents.OpenTabPrismEvent>().Publish(savedQuickPipe);
                        };

                    Pipe newPipe = dialog.NewPipe;
                    newPipe.PipeRevisionHistories = new List<PipeRevisionHistory>();
                    var rh = new PipeRevisionHistory();
                    rh.Date = DateTime.Now;
                    rh.Description = "Initial Creation";
                    rh.Revision = new decimal(0.001);
                    rh.UserId = CMS.User.Id;
                    newPipe.PipeRevisionHistories.Add(rh);

                    cmsWebServiceClient.SavePipeAsync(newPipe, CMS.User.Id);
                }
            };
        }
Пример #7
0
        private void BuildMoveComponentRevisionHistory(PipeComponentsControl componentsControl)
        {
            if (componentsControl == null || componentsControl.Model == null || componentsControl.Model.MovedComponent == null)
            {
                return;
            }

            PipeRevisionHistory rv = new PipeRevisionHistory();
            rv.Date = DateTime.Now;
            rv.UserId = CMS.User.Id;
            rv.PipeId = mPipe.Id;
            rv.Description = string.Format("Moved Component {0} to Pipe {1}.", componentsControl.Model.MovedComponent.Name, componentsControl.Model.MovedComponent.Pipe.Name);
            mPipe.PipeRevisionHistories.Add(rv);
        }
        private void SaveAcceptanceTestButton_Click(object sender, RoutedEventArgs e)
        {
            var mCmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

            mCmsWebServiceClient.AddPipeRevisionHistoryCompleted +=
                (s1, e1) =>
                {
                    AddedPipeRevisionHistory = e1.Result;
                    DialogResult = true;
                };

            mPipeRevisionHistoryViewModel.User = CMS.User;
            mPipeRevisionHistoryViewModel.UserId = CMS.User.Id;
            mPipeRevisionHistoryViewModel.Date = DateTime.Now;
            mPipeRevisionHistoryViewModel.Description = "Site Acceptance Testing";
            mPipeRevisionHistoryViewModel.Issue = null;
            mPipeRevisionHistoryViewModel.IssueId = null;
            mCmsWebServiceClient.AddPipeRevisionHistoryAsync(mPipeRevisionHistoryViewModel.PipeRevisionHistory);
        }
Пример #9
0
        private PipeRevisionHistory BuildRevisionHistory(PipeComponent existingPipeComponent)
        {
            const decimal incrediment = 0.001m;
            var revision = new decimal(1.000);

            List<decimal> foo = (from x in Cee.PipeRevisionHistories where x.PipeId == existingPipeComponent.PipeId orderby x.Revision descending select x.Revision).ToList();

            if (foo.Count > 0)
            {
                revision = foo[0] + incrediment;
            }

            var rvh = new PipeRevisionHistory
            {
                Date = DateTime.Now,
                PipeId = existingPipeComponent.PipeId,
                UserId = MetaData.UserId,
                Description = BuildRevisionHistoryUpdateComment(MetaData.RevisionHistoryComment),
                Revision = revision,
                IsSystemMessage = true
            };
            return rvh;
        }
 public PipeRevisionHistoryViewModel(PipeRevisionHistory prh)
 {
     mPipeRevisionHistory = prh;
 }