private PreservationTaskViewModel ArchivePreservationModel(Guid id)
        {
            var service  = new PreservationService();
            var archive  = ArchiveService.GetArchive(id);
            var schedule = service.GetPreservationScheduleWithinArchive(id);
            var SelectedScheduleIndex = -1;
            var schedulePeriod        = GetArchivePeriods(id);
            var tasks = service.GetPreservationTasks(new System.ComponentModel.BindingList <DocumentArchive> {
                new DocumentArchive(id)
            }, 0, 2);
            DateTime             nextPreservationDate = DateTime.Now;
            PreservationSchedule objSched             = null;

            if (schedule != null)
            {
                objSched = schedulePeriod.Where(x => x.IdPreservationSchedule == schedule.IdPreservationSchedule).FirstOrDefault();
                if (objSched != null)
                {
                    SelectedScheduleIndex = schedulePeriod.IndexOf(objSched);
                }
            }

            if (tasks.Tasks.Count > 0)
            {
                nextPreservationDate = tasks.Tasks.First().EndDocumentDate.Value.AddDays(1);
            }
            var viewModel = new PreservationTaskViewModel {
                IdArchive = id, ArchiveName = archive.Name, SelectedScheduleIndex = SelectedScheduleIndex, PeriodSchedulers = schedulePeriod, NextPreservationTaskStartDocumentDate = nextPreservationDate
            };

            return(viewModel);
        }
        public ActionResult PreservationTaskDetails(Guid id)
        {
            PreservationTaskResponse  query = new PreservationService().GetAllChildPreservationTasks(id, 0, 10);
            PreservationTaskViewModel model = new PreservationTaskViewModel();

            model.Tasks                = query.Tasks.OrderByDescending(x => x.EstimatedDate).ToList();
            model.VerifyTask           = query.Tasks.FirstOrDefault(x => x.TaskType.Type == Library.Common.Objects.Enums.PreservationTaskTypes.Verify);
            model.HasVerifyTaskDefined = (model.VerifyTask != null);
            model.Archive              = query.Tasks.First().Archive;
            model.ArchiveName          = query.Tasks.First().Archive.Name;
            model.IdArchive            = query.Tasks.First().Archive.IdArchive;
            model.Company              = ArchiveService.GetCompanyFromArchive(model.IdArchive);
            model.HasCompanyDefined    = (model.Company != null);

            foreach (PreservationTask task in model.Tasks)
            {
                if (task.IdPreservation != null)
                {
                    try
                    {
                        string preservationPath = new PreservationService().GetPreservationPathByIdTask(task.IdPreservationTask);
                        if (Directory.Exists(preservationPath))
                        {
                            DirectoryInfo path = new DirectoryInfo(preservationPath);

                            logger.InfoFormat("caricamento file di chiusura {0}", path.FullName);

                            task.PreservationCloseFile = path.GetFiles("CHIUSURA*", SearchOption.TopDirectoryOnly).First().FullName;
                        }
                    }
                    catch (Exception ex)
                    {
                        task.PreservationCloseFile = null;
                    }
                }
            }

            model.HasArchiveConfigurationFile = false;
            if (!string.IsNullOrEmpty(model.ArchiveName))
            {
                if (string.IsNullOrEmpty(model.Archive.PreservationConfiguration))
                {
                    logger.InfoFormat("L'archivio {0} non è stato configurato", model.Tasks.FirstOrDefault().Archive.Name);
                    model.HasArchiveConfigurationFile = false;
                }
                else
                {
                    model.HasArchiveConfigurationFile = true;
                }
            }

            return(View(model));
        }