Example #1
0
        public void Execute()
        {
            bool noPipe      = false;
            bool difTypeSize = false;

            foreach (Prizm.Domain.Entity.Mill.Railcar r in viewModel.ReleaseNote.Railcars)
            {
                if (r.Pipes.Count == 0)
                {
                    noPipe = true;
                }
            }

            if (noPipe)
            {
                notify.ShowError(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_PipesAbsent),
                                 Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                return;
            }

            foreach (Prizm.Domain.Entity.Mill.Railcar r in viewModel.ReleaseNote.Railcars)
            {
                int distinctSizes = r.Pipes.Select(p => p.Type).Distinct().Count();
                if (distinctSizes > 1)
                {
                    difTypeSize = true;
                }
            }

            if (difTypeSize)
            {
                notify.ShowError(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_DifferentTypeSizeInRailcar),
                                 Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
            }


            if (!noPipe && !difTypeSize)
            {
                foreach (Prizm.Domain.Entity.Mill.Railcar r in viewModel.Railcars)
                {
                    foreach (var pipe in r.Pipes)
                    {
                        pipe.Status = PipeMillStatus.Shipped;

                        pipe.ToExport = true;
                    }
                }
                viewModel.Shipped = true;
                notify.ShowSuccess(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_Shipped) + " #" + viewModel.ReleaseNote.Number,
                                   Program.LanguageManager.GetString(StringResources.Alert_InfoHeader));

                log.Info(string.Format("Shipment is successful. Release Note #{0}, id:{1}.",
                                       viewModel.ReleaseNote.Number,
                                       viewModel.ReleaseNote.Id));

                viewModel.SaveCommand.Execute();
            }

            RefreshVisualStateEvent();
        }
Example #2
0
        public void Execute()
        {
            if (!viewModel.Shipped)
            {
                notify.ShowError(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_NotShipped),
                                 Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
            }
            else
            {
                foreach (Prizm.Domain.Entity.Mill.Railcar r in viewModel.Railcars)
                {
                    foreach (var pipe in r.Pipes)
                    {
                        pipe.Status   = PipeMillStatus.ReadyToShip;
                        pipe.ToExport = false;
                    }
                }

                viewModel.Shipped = false;
                notify.ShowSuccess(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_Unshipped),
                                   Program.LanguageManager.GetString(StringResources.Alert_InfoHeader));

                viewModel.SaveCommand.Execute();
            }
            RefreshVisualStateEvent();
        }
        public void Execute()
        {
            try
            {
                bool noPipe = false;

                foreach (SimpleRailcar r in viewModel.ReleaseNote.Railcars)
                {
                    if (r.Pipes.Count == 0)
                    {
                        noPipe = true;
                    }
                }

                if (noPipe)
                {
                    notify.ShowError(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_PipesAbsent),
                                     Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                    return;
                }

                if (!noPipe)
                {
                    foreach (SimpleRailcar r in viewModel.Railcars)
                    {
                        r.IsShipped = true;
                        foreach (var pipe in r.Pipes)
                        {
                            pipe.Status = PipeMillStatus.Shipped;

                            pipe.ToExport = true;
                        }
                    }
                    viewModel.Shipped = true;
                    notify.ShowSuccess(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_Shipped) + " #" + viewModel.ReleaseNote.Number,
                                       Program.LanguageManager.GetString(StringResources.Alert_InfoHeader));

                    log.Info(string.Format("Shipment is successful. Release Note #{0}, id:{1}.",
                                           viewModel.ReleaseNote.Number,
                                           viewModel.ReleaseNote.Id));

                    viewModel.SaveCommand.Execute();
                }

                RefreshVisualStateEvent();
            }
            catch (RepositoryException ex)
            {
                log.Warn(this.GetType().Name + " | " + ex.ToString());
                notify.ShowWarning(Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Message),
                                   Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Header));
            }
        }
        public void Execute()
        {
            if (viewModel.Spool.IsAvailableToJoint && viewModel.Spool.ConstructionStatus != PartConstructionStatus.Welded)
            {
                if (notify.ShowYesNo(
                        Program.LanguageManager.GetString(StringResources.Spool_DeactivationQuestion),
                        Program.LanguageManager.GetString(StringResources.Spool_DeactivationQuestionHeader)))
                {
                    try
                    {
                        viewModel.PipeLength = viewModel.PipeLength + viewModel.SpoolLength;

                        viewModel.Spool.IsActive = false;

                        viewModel.ModifiableView.IsModified = true;
                        viewModel.ModifiableView.UpdateState();

                        notify.ShowSuccess(
                            string.Concat(Program.LanguageManager.GetString(
                                              StringResources.Spool_Deactivated), viewModel.SpoolNumber),
                            Program.LanguageManager.GetString(
                                StringResources.Spool_DeactivatedHeader));

                        log.Info(string.Format("The Spool #{0}, id:{1} has been deactivated.",
                                               viewModel.Pipe.Number, viewModel.Pipe.Id));
                    }
                    catch (RepositoryException ex)
                    {
                        log.Error(ex.Message);
                        notify.ShowFailure(ex.InnerException.Message, ex.Message);
                    }
                }
                else
                {
                    //Refresh property so that binded control become unchecked
                    viewModel.SpoolIsActive = false;
                    viewModel.SpoolIsActive = true;
                }
            }
            else
            {
                notify.ShowInfo(
                    Program.LanguageManager.GetString(StringResources.Message_DeactivationConnectedSpool),
                    Program.LanguageManager.GetString(StringResources.Message_DeactivationConnectedSpoolHeader));

                //Refresh property so that binded control become unchecked
                viewModel.SpoolIsActive = false;
                viewModel.SpoolIsActive = true;
            }
            RefreshVisualStateEvent();
        }
Example #5
0
        public void Execute()
        {
            if (!IsComponentsConnected(viewModel.Component))
            {
                if (notify.ShowYesNo(
                        Program.LanguageManager.GetString(StringResources.Message_ComponentDeactivationQuestion),
                        Program.LanguageManager.GetString(StringResources.Message_ComponentDeactivationQuestionHeader)))
                {
                    try
                    {
                        viewModel.ComponentIsActive = false;

                        viewModel.ModifiableView.IsModified = true;
                        viewModel.ModifiableView.UpdateState();

                        notify.ShowSuccess(
                            string.Concat(Program.LanguageManager.GetString(
                                              StringResources.ComponentNewEdit_DeactivatedAction), viewModel.Number),
                            Program.LanguageManager.GetString(
                                StringResources.ComponentNewEdit_DeactivatedActionHeader));

                        log.Info(string.Format("The entity #{0}, id:{1} has been deactivated.",
                                               viewModel.Component.Number, viewModel.Component.Id));
                    }
                    catch (RepositoryException ex)
                    {
                        log.Error(ex.Message);
                        notify.ShowFailure(ex.InnerException.Message, ex.Message);
                    }
                }
                else
                {
                    //Refresh property so that binded control become unchecked
                    viewModel.ComponentIsActive = false;
                    viewModel.ComponentIsActive = true;
                }
            }
            else
            {
                notify.ShowInfo(
                    Program.LanguageManager.GetString(StringResources.Message_DeactivationConnectedComponent),
                    Program.LanguageManager.GetString(StringResources.Message_DeactivationConnectedComponentHeader));

                //Refresh property so that binded control become unchecked
                viewModel.ComponentIsActive = false;
                viewModel.ComponentIsActive = true;
            }
            RefreshVisualStateEvent();
        }
Example #6
0
        public void Execute()
        {
            if (notify.ShowYesNo(
                    Program.LanguageManager.GetString(StringResources.Spool_DeactivationQuestion),
                    Program.LanguageManager.GetString(StringResources.Spool_DeactivationQuestionHeader)))
            {
                try
                {
                    viewModel.PipeLength = viewModel.PipeLength + viewModel.SpoolLength;

                    viewModel.Spool.IsActive = false;

                    repo.BeginTransaction();
                    repo.PipeRepo.SaveOrUpdate(viewModel.Pipe);
                    repo.SpoolRepo.SaveOrUpdate(viewModel.Spool);

                    repo.Commit();

                    repo.PipeRepo.Evict(viewModel.Pipe);
                    repo.SpoolRepo.Evict(viewModel.Spool);

                    viewModel.ModifiableView.IsEditMode = false;
                    viewModel.ModifiableView.IsModified = false;
                    viewModel.ModifiableView.UpdateState();

                    notify.ShowSuccess(
                        string.Concat(Program.LanguageManager.GetString(
                                          StringResources.Spool_Deactivated), viewModel.SpoolNumber),
                        Program.LanguageManager.GetString(
                            StringResources.Spool_DeactivatedHeader));

                    log.Info(string.Format("The Spool #{0}, id:{1} has been deactivated.",
                                           viewModel.Pipe.Number, viewModel.Pipe.Id));
                }
                catch (RepositoryException ex)
                {
                    log.Error(ex.Message);
                    notify.ShowFailure(ex.InnerException.Message, ex.Message);
                }
            }
            else
            {
                //Refresh property so that binded control become unchecked
                viewModel.SpoolIsActive = false;
                viewModel.SpoolIsActive = true;
            }
            RefreshVisualStateEvent();
        }
        public void Execute()
        {
            try
            {
                if (!viewModel.Shipped)
                {
                    notify.ShowError(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_NotShipped),
                                     Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                }
                else
                {
                    foreach (SimpleRailcar r in viewModel.Railcars)
                    {
                        r.IsShipped = false;
                        foreach (var pipe in r.Pipes)
                        {
                            pipe.Status   = PipeMillStatus.ReadyToShip;
                            pipe.ToExport = false;
                        }
                    }

                    viewModel.Shipped = false;
                    notify.ShowSuccess(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_Unshipped),
                                       Program.LanguageManager.GetString(StringResources.Alert_InfoHeader));

                    viewModel.SaveCommand.Execute();
                }
                RefreshVisualStateEvent();
            }
            catch (RepositoryException ex)
            {
                log.Warn(this.GetType().Name + " | " + ex.ToString());
                notify.ShowWarning(Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Message),
                                   Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Header));
            }
        }
Example #8
0
        public void Execute()
        {
            if (!viewModel.ValidatableView.Validate())
            {
                return;
            }

            foreach (var result in viewModel.InspectionTestResults)
            {
                if (!result.Date.IsValid())
                {
                    notify.ShowInfo(Program.LanguageManager.GetString(StringResources.WrongDate),
                                    Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                    log.Warn("Date limits not valid!");
                    return;
                }
            }

            var c = repos.ComponentRepo.GetActiveByNumber(viewModel.Component);

            foreach (var component in c)
            {
                repos.ComponentRepo.Evict(component);
            }
            var    duplicateNumber = repo.GetAllActiveDuplicateEntityByNumber(viewModel.Number, viewModel.Component.Id).Distinct(new DuplicateNumberEntityComparer()).ToList();
            String resultString    = string.Empty;

            if (duplicateNumber != null && duplicateNumber.Count > 0)
            {
                for (int i = 0; i <= duplicateNumber.Count - 1; i++)
                {
                    DuplicateNumberEntityType translate = (DuplicateNumberEntityType)Enum.Parse(typeof(DuplicateNumberEntityType),
                                                                                                duplicateNumber[i].EntityType);
                    resultString = resultString + viewModel.localizedAllType[(int)((object)translate) - 1] + (i < duplicateNumber.Count - 1 ? ", " : "");;
                }

                notify.ShowInfo(
                    string.Concat(Program.LanguageManager.GetString(StringResources.DuplicateEntity_Message) + resultString),
                    Program.LanguageManager.GetString(StringResources.DuplicateEntity_MessageHeader));
                viewModel.Number = string.Empty;
            }
            else
            {
                foreach (InspectionTestResult t in viewModel.InspectionTestResults)
                {
                    if (t.Status != PartInspectionStatus.Pending && t.Inspectors.Count <= 0)
                    {
                        numberOfOperationWithoutInspectors++;
                    }
                }
                if (numberOfOperationWithoutInspectors == 0)
                {
                    try
                    {
                        viewModel.Component.InspectionStatus = viewModel.Component.GetPartInspectionStatus();
                        viewModel.Component.ToExport         = true;
                        repos.BeginTransaction();
                        viewModel.Component.Number = viewModel.Component.Number.ToUpper();
                        repos.ComponentRepo.SaveOrUpdate(viewModel.Component);

                        var filesViewModel = viewModel.FilesFormViewModel;

                        //saving attached documents
                        bool fileCopySuccess = true;
                        if (null != filesViewModel)
                        {
                            filesViewModel.FileRepo           = repos.FileRepo;
                            viewModel.FilesFormViewModel.Item = viewModel.Component.Id;
                            if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.Component))
                            {
                                fileCopySuccess = false;
                                repos.Rollback();
                            }
                        }

                        if (fileCopySuccess)
                        {
                            repos.Commit();
                        }

                        repos.ComponentRepo.Evict(viewModel.Component);
                        viewModel.ModifiableView.IsModified = false;
                        viewModel.ModifiableView.Id         = viewModel.Component.Id;
                        viewModel.ModifiableView.UpdateState();

                        if (fileCopySuccess)
                        {
                            if (null != filesViewModel)
                            {
                                filesViewModel.DetachFileEntities();
                            }

                            notify.ShowSuccess(
                                string.Concat(Program.LanguageManager.GetString(StringResources.ComponentNewEdit_Saved), viewModel.Number),
                                Program.LanguageManager.GetString(StringResources.ComponentNewEdit_SavedHeader));

                            log.Info(string.Format("The entity #{0}, id:{1} has been saved in DB.",
                                                   viewModel.Component.Number, viewModel.Component.Id));
                        }
                        else
                        {
                            notify.ShowError(Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied),
                                             Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied_Header));
                            log.Info(string.Format("File for entity #{0}, id:{1} hasn't been saved ",
                                                   viewModel.Component.Number, viewModel.Component.Id));
                        }
                    }
                    catch (RepositoryException ex)
                    {
                        log.Error(ex.Message);
                        notify.ShowFailure(ex.InnerException.Message, ex.Message);
                    }
                }
                else
                {
                    notify.ShowError(
                        Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResult),
                        Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResultHeader));
                    numberOfOperationWithoutInspectors = 0;
                }
            }
            RefreshVisualStateEvent();
        }
Example #9
0
        public void Execute()
        {
            if (!viewModel.ValidatableView.Validate())
            {
                return;
            }

            if (!DateValidate())
            {
                notify.ShowInfo(Program.LanguageManager.GetString(StringResources.WrongDate),
                                Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                log.Warn("Date limits not valid!");
                return;
            }

            //Uppercase for db
            viewModel.Pipe.Plate.Number = viewModel.Pipe.Plate.Number.ToUpper();
            viewModel.Pipe.Number       = viewModel.Pipe.Number.ToUpper();


            var p = repo.RepoPipe.GetActiveByNumber(viewModel.Pipe);

            foreach (var pipe in p)
            {
                repo.RepoPipe.Evict(pipe);
            }

            var    duplicateNumber = duplicateNumberRepo.GetAllActiveDuplicateEntityByNumber(viewModel.Number, viewModel.Pipe.Id).Distinct(new DuplicateNumberEntityComparer()).ToList();
            String result          = string.Empty;

            if (duplicateNumber != null && duplicateNumber.Count > 0)
            {
                for (int i = 0; i <= duplicateNumber.Count - 1; i++)
                {
                    DuplicateNumberEntityType translate = (DuplicateNumberEntityType)Enum.Parse(typeof(DuplicateNumberEntityType),
                                                                                                duplicateNumber[i].EntityType);
                    result = result + viewModel.localizedAllType[(int)((object)translate) - 1] + (i < duplicateNumber.Count - 1 ? ", " : "");
                }

                notify.ShowInfo(
                    string.Concat(Program.LanguageManager.GetString(StringResources.DuplicateEntity_Message) + result),
                    Program.LanguageManager.GetString(StringResources.DuplicateEntity_MessageHeader));
                viewModel.Number = string.Empty;
            }
            else
            {
                if (viewModel.CheckStatus())
                {
                    try
                    {
                        viewModel.UpdatePipeSubStatus();
                        viewModel.Pipe.PipeTestResult = viewModel.PipeTestResults;
                        repo.BeginTransaction();
                        repo.RepoPipe.SaveOrUpdate(viewModel.Pipe);

                        var filesViewModel = viewModel.FilesFormViewModel;

                        //saving attached existingDocuments
                        bool fileCopySuccess = true;
                        if (null != filesViewModel)
                        {
                            filesViewModel.FileRepo           = repo.FileRepo;
                            viewModel.FilesFormViewModel.Item = viewModel.Pipe.Id;
                            if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.Pipe))
                            {
                                fileCopySuccess = false;
                                repo.Rollback();
                            }
                        }

                        if (fileCopySuccess)
                        {
                            repo.Commit();
                            viewModel.PipeNotifier.UpdateNotifications(viewModel.Pipe);
                            viewModel.SelectiveOperationPipeNotifier.UpdateNotifications(viewModel.Pipe);
                        }

                        repo.RepoPipe.Evict(viewModel.Pipe);

                        if (fileCopySuccess)
                        {
                            if (null != filesViewModel)
                            {
                                filesViewModel.DetachFileEntities();
                            }

                            notify.ShowSuccess(
                                string.Concat(Program.LanguageManager.GetString(StringResources.MillPipe_PipeSaved), viewModel.Number),
                                Program.LanguageManager.GetString(StringResources.MillPipe_PipeSavedHeader));

                            log.Info(string.Format("The entity #{0}, id:{1} has been saved in DB.", viewModel.Pipe.Number,
                                                   viewModel.Pipe.Id));
                        }
                        else
                        {
                            notify.ShowError(Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied),
                                             Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied_Header));
                            log.Info(string.Format("File for entity #{0}, id:{1} hasn't been saved", viewModel.Pipe.Number,
                                                   viewModel.Pipe.Id));
                        }

                        viewModel.ModifiableView.IsModified = false;
                        viewModel.ModifiableView.IsEditMode = viewModel.PipeIsActive;
                        viewModel.ModifiableView.Id         = viewModel.Pipe.Id;
                        viewModel.ModifiableView.UpdateState();
                    }
                    catch (RepositoryException ex)
                    {
                        log.Error(ex.Message);
                        notify.ShowFailure(ex.InnerException.Message, ex.Message);
                    }
                }
                else
                {
                    notify.ShowInfo(
                        Program.LanguageManager.GetString(StringResources.MillPipe_ErrorEditingInspectionOperationPipeInRailcar),
                        Program.LanguageManager.GetString(StringResources.MillPipe_PipeSavedHeader));
                }
            }

            RefreshVisualStateEvent();
        }
        public void Execute()
        {
            if (!viewModel.validatableView.Validate())
            {
                return;
            }

            if (!viewModel.Date.IsValid())
            {
                notify.ShowInfo(Program.LanguageManager.GetString(StringResources.WrongDate),
                                Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                log.Warn("Date limits not valid!");
                return;
            }

            if (string.IsNullOrWhiteSpace(viewModel.Number))
            {
                notify.ShowError(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_MissingReleaseNoteNumber),
                                 Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                return;
            }


            try
            {
                var emptyRailcars = viewModel.Railcars.Where(x => x.Pipes.Count == 0).ToList <SimpleRailcar>();

                var empty = viewModel.Railcars.Where(x => x.Pipes.Count == 0).ToList <SimpleRailcar>();
                foreach (var item in empty)
                {
                    viewModel.Railcars.Remove(item);
                }

                foreach (var r in viewModel.Railcars)
                {
                    r.ReleaseNote = viewModel.ReleaseNote;
                }

                viewModel.ReleaseNote.Number = viewModel.ReleaseNote.Number.ToUpper();

                foreach (var item in viewModel.Railcars)
                {
                    item.Number = item.Number.ToUpper();
                }

                repos.BeginTransaction();
                repos.SimpleNoteRepo.SaveOrUpdate(viewModel.ReleaseNote);

                var filesViewModel = viewModel.FilesFormViewModel;


                //saving attached existingDocuments
                bool fileCopySuccess = true;
                if (null != filesViewModel)
                {
                    filesViewModel.FileRepo           = repos.FileRepo;
                    viewModel.FilesFormViewModel.Item = viewModel.ReleaseNote.Id;
                    if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.ReleaseNote))
                    {
                        fileCopySuccess = false;
                        repos.Rollback();
                    }
                }

                if (fileCopySuccess)
                {
                    repos.Commit();
                }

                repos.SimpleNoteRepo.Evict(viewModel.ReleaseNote);
                viewModel.ModifiableView.IsModified = false;
                viewModel.ModifiableView.Id         = viewModel.ReleaseNote.Id;

                if (fileCopySuccess)
                {
                    if (null != filesViewModel)
                    {
                        filesViewModel.DetachFileEntities();
                    }

                    notify.ShowSuccess(Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_SaveSuccess),
                                       Program.LanguageManager.GetString(StringResources.ReleaseNoteNewEdit_SaveSuccessHeader));

                    log.Info(string.Format("The entity #{0}, id:{1} has been saved in DB.", viewModel.ReleaseNote.Number,
                                           viewModel.ReleaseNote.Id));
                }
                else
                {
                    notify.ShowError(Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied),
                                     Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied_Header));
                    log.Info(string.Format("File for entity #{0}, id:{1} hasn't been saved.", viewModel.ReleaseNote.Number,
                                           viewModel.ReleaseNote.Id));
                }
            }
            catch (RepositoryException ex)
            {
                log.Error(String.Format("An error occured on saving release note {0},{1}: {2}", viewModel.ReleaseNote.Id, viewModel.ReleaseNote.Number, ex.Message));
                notify.ShowFailure(ex.InnerException.Message, ex.Message);
            }
            RefreshVisualStateEvent();
        }
Example #11
0
        public void Execute()
        {
            if (viewModel.Pipe.Railcar == null)
            {
                if (notify.ShowYesNo(
                        Program.LanguageManager.GetString(StringResources.MillPipe_DeactivatePipeQuestion),
                        Program.LanguageManager.GetString(StringResources.MillPipe_DeactivatePipeQuestionHeader)))
                {
                    try
                    {
                        viewModel.Pipe.IsActive = false;
                        viewModel.CheckStatus();
                        viewModel.UpdatePipeSubStatus();
                        viewModel.Pipe.PipeTestResult = viewModel.PipeTestResults;

                        repo.BeginTransaction();
                        repo.RepoPipe.SaveOrUpdate(viewModel.Pipe);
                        repo.Commit();

                        repo.RepoPipe.Evict(viewModel.Pipe);

                        viewModel.ModifiableView.IsEditMode = false;
                        viewModel.ModifiableView.IsModified = false;
                        viewModel.ModifiableView.UpdateState();

                        notify.ShowSuccess(
                            string.Concat(Program.LanguageManager.GetString(
                                              StringResources.Pipe_Deactivated), viewModel.Number),
                            Program.LanguageManager.GetString(
                                StringResources.Pipe_DeactivatedHeader));

                        log.Info(string.Format("The Pipe #{0}, id:{1} has been deactivated.",
                                               viewModel.Pipe.Number, viewModel.Pipe.Id));
                    }
                    catch (RepositoryException ex)
                    {
                        log.Error(ex.Message);
                        notify.ShowFailure(ex.InnerException.Message, ex.Message);
                    }
                }
                else
                {
                    //Refresh property so that binded control become unchecked
                    viewModel.PipeIsActive = false;
                    viewModel.PipeIsActive = true;
                }
            }
            else if (viewModel.PipeStatus == PipeMillStatus.Shipped)
            {
                notify.ShowInfo(
                    Program.LanguageManager.GetString(StringResources.MillPipe_DeactivatePipeShippedError),
                    Program.LanguageManager.GetString(StringResources.MillPipe_DeactivatePipeShippedErrorHeader));
            }
            else
            {
                notify.ShowInfo(
                    Program.LanguageManager.GetString(StringResources.MillPipe_DeactivatePipeInRailcarError),
                    Program.LanguageManager.GetString(StringResources.MillPipe_DeactivatePipeInRailcarErrorHeader));
            }
            RefreshVisualStateEvent();
        }
Example #12
0
        public void Execute()
        {
            if (!viewModel.ValidatableView.Validate())
            {
                return;
            }

            if (!DateValidate())
            {
                notify.ShowInfo(Program.LanguageManager.GetString(StringResources.WrongDate),
                                Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                log.Warn("Date limits not valid!");
                return;
            }

            //Uppercase for db
            viewModel.Pipe.Plate.Number = viewModel.Pipe.Plate.Number.ToUpper();
            viewModel.Pipe.Number       = viewModel.Pipe.Number.ToUpper();


            var p = repo.RepoPipe.GetActiveByNumber(viewModel.Pipe);

            foreach (var pipe in p)
            {
                repo.RepoPipe.Evict(pipe);
            }

            if (p != null && p.Count > 0)
            {
                notify.ShowInfo(
                    string.Concat(Program.LanguageManager.GetString(StringResources.MillPipe_ExistingNumberError), viewModel.Number),
                    Program.LanguageManager.GetString(StringResources.MillPipe_ExistingNumberErrorHeader));
                viewModel.Number = string.Empty;
            }
            else
            {
                if (viewModel.CheckStatus())
                {
                    try
                    {
                        viewModel.UpdatePipeSubStatus();
                        viewModel.Pipe.PipeTestResult = viewModel.PipeTestResults;
                        repo.BeginTransaction();
                        repo.RepoPipe.SaveOrUpdate(viewModel.Pipe);

                        var filesViewModel = viewModel.FilesFormViewModel;

                        //saving attached documents
                        bool fileCopySuccess = true;
                        if (null != filesViewModel)
                        {
                            filesViewModel.FileRepo           = repo.FileRepo;
                            viewModel.FilesFormViewModel.Item = viewModel.Pipe.Id;
                            if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.Pipe))
                            {
                                fileCopySuccess = false;
                                repo.Rollback();
                            }
                        }

                        repo.Commit();
                        repo.RepoPipe.Evict(viewModel.Pipe);

                        if (fileCopySuccess)
                        {
                            if (null != filesViewModel)
                            {
                                filesViewModel.DetachFileEntities();
                            }


                            notify.ShowSuccess(
                                string.Concat(Program.LanguageManager.GetString(StringResources.MillPipe_PipeSaved), viewModel.Number),
                                Program.LanguageManager.GetString(StringResources.MillPipe_PipeSavedHeader));
                        }
                        else
                        {
                            notify.ShowError(Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied),
                                             Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied_Header));
                        }

                        viewModel.ModifiableView.IsModified = false;
                        viewModel.ModifiableView.UpdateState();
                        notify.ShowNotify(
                            string.Concat(Program.LanguageManager.GetString(StringResources.MillPipe_PipeSaved), viewModel.Number),
                            Program.LanguageManager.GetString(StringResources.MillPipe_PipeSavedHeader));

                        log.Info(string.Format("The entity #{0}, id:{1} has been saved in DB.",
                                               viewModel.Pipe.Number,
                                               viewModel.Pipe.Id));
                    }
                    catch (RepositoryException ex)
                    {
                        log.Error(ex.Message);
                        notify.ShowFailure(ex.InnerException.Message, ex.Message);
                    }
                }
                else
                {
                    notify.ShowInfo(
                        Program.LanguageManager.GetString(StringResources.MillPipe_ErrorEditingInspectionOperationPipeInRailcar),
                        Program.LanguageManager.GetString(StringResources.MillPipe_PipeSavedHeader));
                }
            }

            RefreshVisualStateEvent();
        }
Example #13
0
        public void Execute()
        {
            try
            {
                foreach (JointTestResult t in viewModel.JointTestResults)
                {
                    if (t.Inspectors.Count <= 0)
                    {
                        numberOfOperationWithoutInspectors++;
                    }
                }
                if (numberOfOperationWithoutInspectors == 0)
                {
                    try
                    {
                        var    duplicateNumber = duplicateNumberRepo.GetAllActiveDuplicateEntityByNumber(viewModel.Number, viewModel.Joint.Id).Distinct(new DuplicateNumberEntityComparer()).ToList();
                        String result          = string.Empty;

                        if (duplicateNumber != null && duplicateNumber.Count > 0)
                        {
                            for (int i = 0; i <= duplicateNumber.Count - 1; i++)
                            {
                                DuplicateNumberEntityType translate = (DuplicateNumberEntityType)Enum.Parse(typeof(DuplicateNumberEntityType),
                                                                                                            duplicateNumber[i].EntityType);
                                result = result + ", " + viewModel.localizedAllType[(int)((object)translate) - 1];
                            }

                            notify.ShowInfo(
                                string.Concat(Program.LanguageManager.GetString(StringResources.DuplicateEntity_Message) + result),
                                Program.LanguageManager.GetString(StringResources.DuplicateEntity_MessageHeader));
                            viewModel.Number = string.Empty;
                        }
                        else
                        {
                            viewModel.Joint.Number   = viewModel.Joint.Number.ToUpper();
                            viewModel.Joint.ToExport = true;
                            repo.BeginTransaction();
                            repo.RepoJoint.SaveOrUpdate(viewModel.Joint);

                            var filesViewModel = viewModel.FilesFormViewModel;


                            bool fileCopySuccess = true;
                            if (null != filesViewModel)
                            {
                                filesViewModel.FileRepo           = repo.FileRepo;
                                viewModel.FilesFormViewModel.Item = viewModel.Joint.Id;
                                if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.Joint))
                                {
                                    fileCopySuccess = false;
                                    repo.Rollback();
                                }
                            }

                            if (fileCopySuccess)
                            {
                                repo.Commit();
                            }
                            repo.RepoJoint.Evict(viewModel.Joint);

                            if (fileCopySuccess)
                            {
                                if (null != filesViewModel)
                                {
                                    filesViewModel.DetachFileEntities();
                                }

                                notify.ShowSuccess(
                                    string.Concat(Program.LanguageManager.GetString(StringResources.Joint_Saved), viewModel.Number),
                                    Program.LanguageManager.GetString(StringResources.Joint_SavedHeader));

                                log.Info(string.Format("The entity #{0}, id:{1} has been saved in DB.",
                                                       viewModel.Joint.Number,
                                                       viewModel.Joint.Id));
                            }
                            else
                            {
                                notify.ShowError(
                                    Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied),
                                    Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied_Header));
                                log.Info(string.Format("File for entity #{0}, id:{1} hasn't been saved ",
                                                       viewModel.Joint.Number,
                                                       viewModel.Joint.Id));
                            }

                            viewModel.ModifiableView.IsModified = false;
                            viewModel.ModifiableView.Id         = viewModel.Joint.Id;
                            viewModel.ModifiableView.UpdateState();
                        }
                    }
                    catch (RepositoryException ex)
                    {
                        log.Error(ex.Message);
                        notify.ShowFailure(ex.InnerException.Message, ex.Message);
                    }
                }
                else
                {
                    notify.ShowError(
                        Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResult),
                        Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResultHeader));
                }
            }
            catch (RepositoryException ex)
            {
                log.Warn(this.GetType().Name + " | " + ex.ToString());
                notify.ShowWarning(Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Message),
                                   Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Header));
            }
        }
Example #14
0
        public void Execute()
        {
            if (!viewModel.ValidatableView.Validate())
            {
                return;
            }

            foreach (var result in viewModel.InspectionTestResults)
            {
                if (!result.Date.IsValid())
                {
                    notify.ShowInfo(Program.LanguageManager.GetString(StringResources.WrongDate),
                                    Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                    log.Warn("Date limits not valid!");
                    return;
                }
            }

            var c = repos.ComponentRepo.GetActiveByNumber(viewModel.Component);

            foreach (var component in c)
            {
                repos.ComponentRepo.Evict(component);
            }

            if (c != null && c.Count > 0)
            {
                notify.ShowInfo(
                    string.Concat(Program.LanguageManager.GetString(StringResources.ComponentNewEdit_Duplicate), " ", viewModel.Number),
                    Program.LanguageManager.GetString(StringResources.ComponentNewEdit_DuplicateHeader));
                viewModel.Number = string.Empty;
            }
            else
            {
                foreach (InspectionTestResult t in viewModel.InspectionTestResults)
                {
                    if (t.Status != PartInspectionStatus.Pending && t.Inspectors.Count <= 0)
                    {
                        numberOfOperationWithoutInspectors++;
                    }
                }
                if (numberOfOperationWithoutInspectors == 0)
                {
                    try
                    {
                        viewModel.Component.InspectionStatus = viewModel.Component.GetPartInspectionStatus();
                        repos.BeginTransaction();
                        viewModel.Component.Number = viewModel.Component.Number.ToUpper();
                        repos.ComponentRepo.SaveOrUpdate(viewModel.Component);

                        var filesViewModel = viewModel.FilesFormViewModel;

                        //saving attached documents
                        bool fileCopySuccess = true;
                        if (null != filesViewModel)
                        {
                            filesViewModel.FileRepo           = repos.FileRepo;
                            viewModel.FilesFormViewModel.Item = viewModel.Component.Id;
                            if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.Component))
                            {
                                fileCopySuccess = false;
                                repos.Rollback();
                            }
                        }

                        repos.Commit();
                        repos.ComponentRepo.Evict(viewModel.Component);
                        viewModel.ModifiableView.IsModified = false;
                        viewModel.ModifiableView.UpdateState();

                        if (fileCopySuccess)
                        {
                            if (null != filesViewModel)
                            {
                                filesViewModel.DetachFileEntities();
                            }

                            notify.ShowSuccess(
                                string.Concat(Program.LanguageManager.GetString(StringResources.ComponentNewEdit_Saved), viewModel.Number),
                                Program.LanguageManager.GetString(StringResources.ComponentNewEdit_SavedHeader));
                        }
                        else
                        {
                            notify.ShowError(Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied),
                                             Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied_Header));
                        }

                        log.Info(string.Format("The entity #{0}, id:{1} has been saved in DB.",
                                               viewModel.Component.Number, viewModel.Component.Id));
                    }
                    catch (RepositoryException ex)
                    {
                        log.Error(ex.Message);
                        notify.ShowFailure(ex.InnerException.Message, ex.Message);
                    }
                }
                else
                {
                    notify.ShowError(
                        Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResult),
                        Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResultHeader));
                    numberOfOperationWithoutInspectors = 0;
                }
            }
            RefreshVisualStateEvent();
        }
Example #15
0
        public void Execute()
        {
            foreach (JointTestResult t in viewModel.JointTestResults)
            {
                if (t.Inspectors.Count <= 0)
                {
                    numberOfOperationWithoutInspectors++;
                }
            }
            if (numberOfOperationWithoutInspectors == 0)
            {
                try
                {
                    viewModel.Joint.Number = viewModel.Joint.Number.ToUpper();
                    repo.BeginTransaction();
                    repo.RepoJoint.SaveOrUpdate(viewModel.Joint);

                    var filesViewModel = viewModel.FilesFormViewModel;


                    bool fileCopySuccess = true;
                    if (null != filesViewModel)
                    {
                        filesViewModel.FileRepo           = repo.FileRepo;
                        viewModel.FilesFormViewModel.Item = viewModel.Joint.Id;
                        if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.Joint))
                        {
                            fileCopySuccess = false;
                            repo.Rollback();
                        }
                    }

                    repo.Commit();
                    repo.RepoJoint.Evict(viewModel.Joint);

                    if (fileCopySuccess)
                    {
                        if (null != filesViewModel)
                        {
                            filesViewModel.DetachFileEntities();
                        }

                        notify.ShowSuccess(
                            string.Concat(Program.LanguageManager.GetString(StringResources.Joint_Saved), viewModel.Number),
                            Program.LanguageManager.GetString(StringResources.Joint_SavedHeader));
                    }
                    else
                    {
                        notify.ShowError(
                            Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied),
                            Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied_Header));
                    }

                    viewModel.ModifiableView.IsModified = false;
                    viewModel.ModifiableView.UpdateState();

                    notify.ShowNotify(
                        string.Concat(Program.LanguageManager.GetString(StringResources.Joint_Saved), viewModel.Number),
                        Program.LanguageManager.GetString(StringResources.Joint_SavedHeader));

                    log.Info(string.Format("The entity #{0}, id:{1} has been saved in DB.",
                                           viewModel.Joint.Number,
                                           viewModel.Joint.Id));
                }
                catch (RepositoryException ex)
                {
                    log.Error(ex.Message);
                    notify.ShowFailure(ex.InnerException.Message, ex.Message);
                }
            }
            else
            {
                notify.ShowError(
                    Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResult),
                    Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResultHeader));
            }
        }
Example #16
0
        public void Execute()
        {
            if (!viewModel.InspectionTestResults.All(x => x.Date.IsValid()))
            {
                notify.ShowInfo(Program.LanguageManager.GetString(StringResources.WrongDate),
                                Program.LanguageManager.GetString(StringResources.Message_ErrorHeader));
                log.Warn("Date limits not valid!");
                return;
            }

            if (viewModel.Spool.Length != 0)
            {
                if (viewModel.CanCut)
                {
                    foreach (InspectionTestResult t in viewModel.InspectionTestResults)
                    {
                        if (t.Status != PartInspectionStatus.Pending && t.Inspectors.Count <= 0)
                        {
                            numberOfOperationWithoutInspectors++;
                        }
                    }

                    if (numberOfOperationWithoutInspectors == 0)
                    {
                        try
                        {
                            viewModel.Pipe.ToExport          = true;
                            viewModel.Pipe.IsCutOnSpool      = true;
                            viewModel.Spool.Number           = viewModel.Spool.Number.ToUpper();
                            viewModel.Spool.InspectionStatus = viewModel.Spool.GetPartInspectionStatus();
                            repos.BeginTransaction();
                            repos.PipeRepo.SaveOrUpdate(viewModel.Pipe);
                            repos.SpoolRepo.SaveOrUpdate(viewModel.Spool);

                            var filesViewModel = viewModel.FilesFormViewModel;

                            //saving attached documents
                            bool fileCopySuccess = true;
                            if (null != filesViewModel)
                            {
                                filesViewModel.FileRepo           = repos.FileRepo;
                                viewModel.FilesFormViewModel.Item = viewModel.Pipe.Id;
                                if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.Pipe))
                                {
                                    fileCopySuccess = false;
                                    repos.Rollback();
                                }
                            }

                            repos.Commit();
                            repos.PipeRepo.Evict(viewModel.Pipe);
                            repos.SpoolRepo.Evict(viewModel.Spool);

                            if (fileCopySuccess)
                            {
                                if (null != filesViewModel)
                                {
                                    filesViewModel.DetachFileEntities();
                                }

                                notify.ShowSuccess(
                                    string.Concat(Program.LanguageManager.GetString(StringResources.Spool_CutSpoolFromPipe), viewModel.Spool.Id),
                                    Program.LanguageManager.GetString(StringResources.Spool_CutSpoolFromPipeHeader));
                            }
                            else
                            {
                                notify.ShowError(Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied),
                                                 Program.LanguageManager.GetString(StringResources.ExternalFiles_NotCopied_Header));
                            }

                            viewModel.ModifiableView.IsModified = false;

                            notify.ShowNotify(
                                Program.LanguageManager.GetString(StringResources.Spool_CutSpoolFromPipe),
                                Program.LanguageManager.GetString(StringResources.Spool_CutSpoolFromPipeHeader));

                            log.Info(string.Format("The entity #{0}, id:{1} has been saved in DB.",
                                                   viewModel.Spool.Number,
                                                   viewModel.Spool.Id));

                            string oldPipeNumber = viewModel.Pipe.Number;
                            viewModel.NewSpool();
                            viewModel.PipeNumber = oldPipeNumber;
                            RefreshVisualStateEvent();
                        }
                        catch (RepositoryException ex)
                        {
                            log.Error(ex.Message);
                            notify.ShowFailure(ex.InnerException.Message, ex.Message);
                        }
                    }
                    else
                    {
                        notify.ShowError(
                            Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResult),
                            Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResultHeader));
                        viewModel.ModifiableView.IsEditMode = true;
                    }
                }
                else
                {
                    notify.ShowError(
                        Program.LanguageManager.GetString(StringResources.Spool_SpoolLengtBigerThenPipeLength),
                        Program.LanguageManager.GetString(StringResources.Spool_CutSpoolFromPipeHeader));
                    viewModel.ModifiableView.IsEditMode = true;
                    numberOfOperationWithoutInspectors  = 0;
                }
            }
            else
            {
                notify.ShowError(
                    Program.LanguageManager.GetString(StringResources.Spool_NullSpoolLength),
                    Program.LanguageManager.GetString(StringResources.Spool_CutSpoolFromPipeHeader));
                viewModel.ModifiableView.IsEditMode = true;
            }
        }