Esempio n. 1
0
 public void Execute()
 {
     if (viewModel.StartDate > viewModel.EndDate)
     {
         notify.ShowNotify(Program.LanguageManager.GetString(StringResources.Message_FailureReportDate),
                           Program.LanguageManager.GetString(StringResources.Message_FailureReportDateHeader));
     }
     try
     {
         if (viewModel.SelectedReportType == MillReportType.ByProducing)
         {
             data = repo.GetPipes(viewModel.StartDate, viewModel.EndDate);
             AdditionToTheReport  report = new AdditionToTheReport();
             BindingList <double> counts = repo.CountPipe(viewModel.StartDate, viewModel.EndDate);
             report.PipesCount  = counts[0];
             report.PipesLength = counts[1];
             report.PipesWeight = counts[2];
             report.DataSource  = data;
             report.CreateDocument();
             var tool = new ReportPrintTool(report);
             tool.AutoShowParametersPanel = false;
             tool.ShowPreview();
         }
         else if (viewModel.SelectedReportType == MillReportType.General)
         {
             data = repo.CountWeldInf(viewModel.StartDate, viewModel.EndDate);
             GeneralInformationXtraReport report = new GeneralInformationXtraReport();
             report.DataSource = data;
             var tool = new ReportPrintTool(report);
             tool.AutoShowParametersPanel = false;
             tool.ShowPreview();
         }
         else if (viewModel.SelectedReportType == MillReportType.ByShipped)
         {
             LoadingXtraReport report = new LoadingXtraReport();
             report.DataSource = repo.GetReleaseNotes(viewModel.StartDate, viewModel.EndDate);
             SubReportShippingRailCar report2 = new SubReportShippingRailCar();
             report.RequestParameters         = false;
             report.xrSubreport1.ReportSource = report2;
             var tool = new ReportPrintTool(report);
             tool.AutoShowParametersPanel = false;
             tool.ShowPreview();
         }
         else
         {
             data = repo.GetPipesByStatus(viewModel.StartDate, viewModel.EndDate, viewModel.SearchIds, viewModel.SelectedReportType, viewModel.SearchStatuses);
             MillReportsXtraReport report = new MillReportsXtraReport();
             report.DataSource = data;
             report.CreateDocument();
             var tool = new ReportPrintTool(report);
             tool.AutoShowParametersPanel = false;
             tool.ShowPreview();
         }
     }
     catch (RepositoryException ex)
     {
         log.Error(string.Concat(ex.InnerException.Message, ex.Message));
         notify.ShowFailure(ex.InnerException.Message, ex.Message);
     }
 }
Esempio n. 2
0
        public void Execute()
        {
            string sourceFile = Path.Combine(Directories.TargetPath, viewModel.SelectedFile.NewName);

            if (File.Exists(sourceFile))
            {
                File.Copy(sourceFile, viewModel.SelectedPath, true);
                notify.ShowNotify(Program.LanguageManager.GetString(StringResources.ExternalFiles_FileDownloadSuccess), Program.LanguageManager.GetString(StringResources.ExternalFiles_FileDownloadHeader));
            }
        }
Esempio n. 3
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;
            }

            foreach (InspectionTestResult t in viewModel.InspectionTestResults)
            {
                if (t.Status != PartInspectionStatus.Pending && t.Inspectors.Count <= 0)
                {
                    numberOfOperationWithoutInspectors++;
                }
            }
            if (numberOfOperationWithoutInspectors == 0)
            {
                try
                {
                    viewModel.ConvertedPart.InspectionStatus = viewModel.ConvertedPart.GetPartInspectionStatus();
                    repo.BeginTransaction();
                    foreach (InspectionTestResult itr in viewModel.InspectionTestResults)
                    {
                        repo.SaveOrUpdate(itr);
                    }
                    repo.Commit();
                    foreach (InspectionTestResult itr in viewModel.InspectionTestResults)
                    {
                        repo.Evict(itr);
                    }
                    notify.ShowNotify(string.Concat(Program.LanguageManager.GetString(StringResources.PartInspection_InspectionsSaved), viewModel.SelectedElement.Number), Program.LanguageManager.GetString(StringResources.PartInspection_InspectionsSavedHeader));

                    log.Info(string.Format("The Inspection Test Results for entity #{0}, id:{1} has been saved in DB.",
                                           viewModel.SelectedElement.Number,
                                           viewModel.SelectedElement.Id));
                }
                catch (RepositoryException ex)
                {
                    log.Error(ex.Message);
                    notify.ShowFailure(ex.InnerException.Message, ex.Message);
                }
                RefreshVisualStateEvent();
            }
            else
            {
                notify.ShowError(
                    Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResult),
                    Program.LanguageManager.GetString(StringResources.SelectInspectorsForTestResultHeader));
                numberOfOperationWithoutInspectors = 0;
            }
        }
Esempio n. 4
0
        public void Execute()
        {
            if (CanExecute())
            {
                if (!Directory.Exists(Directories.TargetPath))
                {
                    Directory.CreateDirectory(Directories.TargetPath);
                    DirectoryInfo directoryInfo = new DirectoryInfo(Directories.TargetPath);
                    directoryInfo.Attributes |= FileAttributes.Hidden;
                }
                try
                {
                    foreach (KeyValuePair <string, string> kvp in viewModel.FilesToAttach)
                    {
                        Prizm.Domain.Entity.File fileEntity = new Domain.Entity.File()
                        {
                            FileName   = kvp.Value,
                            UploadDate = DateTime.Now,
                            Item       = viewModel.Item,
                            IsActive   = true,
                            NewName    = kvp.Key
                        };
                        repo.BeginTransaction();
                        repo.Save(fileEntity);
                        repo.Commit();
                        repo.Evict(fileEntity);
                        System.IO.File.Copy(Directories.FilesToAttachFolder + fileEntity.NewName, Directories.TargetPath + fileEntity.NewName);

                        log.Info(string.Format("The file #{0}, id:{1} has been added to entity.",
                                               fileEntity.FileName,
                                               fileEntity.Id));
                    }
                    viewModel.FilesToAttach.Clear();
                    viewModel.RefreshFiles(viewModel.Item);
                }
                catch (RepositoryException ex)
                {
                    log.Error(ex.Message);
                    notify.ShowFailure(ex.InnerException.Message, ex.Message);
                }

                Directory.Delete(Directories.FilesToAttachFolder, true);
                notify.ShowNotify(Program.LanguageManager.GetString(StringResources.ExternalFiles_FileAttachSuccess), Program.LanguageManager.GetString(StringResources.ExternalFiles_FileAttachSuccessHeader));
            }
        }
Esempio n. 5
0
        public void PersistFiles(Domain.Entity.Item item)
        {
            foreach (KeyValuePair <string, string> kvp in FilesToAttach)
            {
                Prizm.Domain.Entity.File fileEntity = new Domain.Entity.File()
                {
                    FileName   = kvp.Value,
                    UploadDate = DateTime.Now,
                    Item       = Item,
                    IsActive   = true,
                    NewName    = kvp.Key
                };
                repos.FileRepo.Save(fileEntity);
            }

            FilesToAttach.Clear();

            notify.ShowNotify(Program.LanguageManager.GetString(StringResources.ExternalFiles_FileAttachSuccess),
                              Program.LanguageManager.GetString(StringResources.ExternalFiles_FileAttachSuccessHeader));
        }
Esempio n. 6
0
 public void Execute()
 {
     if (viewModel.StartDate > viewModel.EndDate)
     {
         notify.ShowNotify(Program.LanguageManager.GetString(StringResources.Message_FailureReportDate),
                           Program.LanguageManager.GetString(StringResources.Message_FailureReportDateHeader));
     }
     try
     {
         data = repo.GetPipesFromInspection(viewModel.StartDate, viewModel.EndDate);
         IncomingReportsXtraReport report = new IncomingReportsXtraReport();
         report.DataSource = data;
         report.CreateDocument();
         viewModel.PreviewSource = report;
     }
     catch (RepositoryException ex)
     {
         log.Error(string.Concat(ex.InnerException.Message, ex.Message));
         notify.ShowFailure(ex.InnerException.Message, ex.Message);
     }
 }
Esempio n. 7
0
        public void PersistFiles(Domain.Entity.Item item)
        {
            foreach (KeyValuePair <string, string> kvp in FilesToAttach)
            {
                Prizm.Domain.Entity.File fileEntity = new Domain.Entity.File()
                {
                    FileName   = kvp.Value,
                    UploadDate = DateTime.Now,
                    Item       = Item,
                    IsActive   = true,
                    NewName    = kvp.Key
                };

                try
                {
                    repos.FileRepo.Save(fileEntity);
                }
                catch (RepositoryException ex)
                {
                    log.Warn("ExternalFilesViewModel " + ex.ToString());
                    notify.ShowWarning(Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Message),
                                       Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Header));
                }


                if (System.IO.File.Exists(Directories.FilesToAttachFolder + kvp.Key))
                {
                    System.IO.File.Delete(Directories.FilesToAttachFolder + kvp.Key);
                }
            }

            FilesToAttach.Clear();

            notify.ShowNotify(Program.LanguageManager.GetString(StringResources.ExternalFiles_FileAttachSuccess),
                              Program.LanguageManager.GetString(StringResources.ExternalFiles_FileAttachSuccessHeader));
        }
Esempio n. 8
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();
        }
Esempio n. 9
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;
            }

            var duplicateNumber = repo.GetAllActiveDuplicateEntityByNumber(viewModel.Spool.Number, viewModel.Spool.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.localizedAllPartType[(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.SpoolNumber = string.Empty;
            }
            else
            {
                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 existingDocuments
                                bool fileCopySuccess = true;
                                if (null != filesViewModel)
                                {
                                    filesViewModel.FileRepo           = repos.FileRepo;
                                    viewModel.FilesFormViewModel.Item = viewModel.Spool.Id;
                                    if (!viewModel.FilesFormViewModel.TrySaveFiles(viewModel.Pipe))
                                    {
                                        fileCopySuccess = false;
                                        repos.Rollback();
                                    }
                                }

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

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

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

                                    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));
                                }
                                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.Spool.Number,
                                                           viewModel.Spool.Id));
                                }

                                viewModel.ModifiableView.IsModified = false;

                                string oldPipeNumber = viewModel.Pipe.Number;
                                viewModel.NewSpool();
                                viewModel.ModifiableView.Id = viewModel.Spool.Id;
                                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;
                }
            }
        }
Esempio n. 10
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));
            }
        }
Esempio n. 11
0
        public void Execute()
        {
            if (!viewModel.validatableView.Validate())
            {
                notify.ShowError(
                    Program.LanguageManager.GetString(StringResources.Settings_CheckValues),
                    Program.LanguageManager.GetString(StringResources.Settings_ErrorHeader));

                return;
            }

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

            StringBuilder types             = new StringBuilder();
            List <string> typesList         = new List <string>();
            bool          controlValidation = true;

            foreach (PipeMillSizeType s in viewModel.PipeMillSizeType)
            {
                if (s.Thickness == 0 || s.SeamType == null || s.Length == 0 || s.Diameter == 0)
                {
                    typesList.Add(s.Type);
                    controlValidation = false;
                }
                foreach (PipeTest t in s.PipeTests)
                {
                    if (t.Code == string.Empty || t.Name == string.Empty || t.Category == null)
                    {
                        typesList.Add(s.Type);
                        controlValidation = false;
                    }
                }
            }

            if (controlValidation)
            {
                try
                {
                    repos.BeginTransaction();
                    SaveWelders();
                    SaveInspectors();
                    SaveMillSizeTypes();
                    SavePlateManufacturers();
                    repos.ProjectRepo.SaveOrUpdate(viewModel.CurrentProjectSettings);
                    SaveRoles();
                    SaveUsers();
                    SaveCategories();
                    SaveJointOperations();
                    SaveComponentryType();
                    SaveInspectorCertificateType();
                    SaveSeamType();
                    repos.Commit();
                    EvictMillSizeTypes();
                    EvictWelders();
                    EvictInspectors();
                    EvictPlateManufacturers();
                    EvictRoles();
                    EvictUsers();
                    EvictJointOperations();
                    repos.ProjectRepo.Evict(viewModel.CurrentProjectSettings);
                    EvictCategories();
                    EvictComponentryType();
                    EvictInspectorCertificateType();
                    EvictSeamType();
                    viewModel.ModifiableView.IsModified = false;

                    notify.ShowNotify(
                        Program.LanguageManager.GetString(StringResources.Settings_SetupSaves),
                        Program.LanguageManager.GetString(StringResources.Settings_SetupSavedHeader));
                }
                catch (RepositoryException ex)
                {
                    log.Error(ex.Message);
                    notify.ShowFailure(ex.InnerException.Message, ex.Message);
                }

                RefreshVisualStateEvent();
            }
            else
            {
                foreach (string s in typesList.Distinct())
                {
                    types.Append(s + " ");
                }
                notify.ShowError
                    (Program.LanguageManager.GetString(StringResources.Settings_PipeControlOperationValidation) + types.ToString(),
                    Program.LanguageManager.GetString(StringResources.Settings_PipeControlOperationValidationHeader));
            }
        }
Esempio n. 12
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;
            }
        }