public ActionResult Index(Guid id)
{
return(ActionResultHelper.TryCatchWithLogger(() =>
{
Preservation preservation = _preservationService.GetPreservation(id, false);
if (preservation == null)
{
_loggerService.Warn(string.Format("Nessuna conservazione trovata con id {0}", id));
return HttpNotFound();
}
IpdaIndexViewModel model = new IpdaIndexViewModel()
{
Preservation = preservation
};
string preservationPath = preservation.Path;
string closeFile = IpdaUtil.GetCloseFile(preservationPath);
string ipdaXmlFile = IpdaUtil.GetIpdaXmlFile(preservationPath);
string ipdaTsdFile = IpdaUtil.GetIpdaTsdFile(preservationPath);
model.ToCreate = (!string.IsNullOrEmpty(closeFile) && string.IsNullOrEmpty(ipdaXmlFile) && string.IsNullOrEmpty(ipdaTsdFile));
model.ToSign = !model.ToCreate && (!string.IsNullOrEmpty(ipdaXmlFile) && string.IsNullOrEmpty(ipdaTsdFile));
model.ToClose = !model.ToCreate && !model.ToSign && (!string.IsNullOrEmpty(ipdaXmlFile) && !string.IsNullOrEmpty(ipdaTsdFile) && !preservation.CloseDate.HasValue);
return View(model);
}, _loggerService));
}
public ActionResult ExistingPreservationVerifyDoAction(Guid id)
{
var service = new PreservationService();
Preservation pres = service.GetPreservation(id);
service.VerifyExistingPreservation(id);
TempData["ErrorMessages"] = service.ErrorMessages;
return(RedirectToAction("PreservationDetails", new { id = id }));
}
public ActionResult ClosePreservation(Preservation preservation)
{
var service = new PreservationService();
preservation = service.GetPreservation(preservation.IdPreservation, false);
if (!preservation.CloseDate.HasValue)
{
service.ClosePreservation(preservation.IdPreservation);
}
return(RedirectToAction("PreservationDetails", new { id = preservation.IdPreservation }));
}
public ActionResult PreservationCheck(Guid id)
{
return(ActionResultHelper.TryCatchWithLogger(() =>
{
Preservation preservation = _preservationService.GetPreservation(id, false);
if (preservation == null)
{
throw new Exception(string.Format("PreservationCheck -> conservazione con id {0} non trovata", id));
}
PreservationCheckViewModel model = new PreservationCheckViewModel()
{
IdArchive = preservation.IdArchive,
IdPreservation = preservation.IdPreservation,
ArchiveName = preservation.Archive.Name,
ConservationDescription = string.Concat("dal <b>", preservation.StartDate.GetValueOrDefault().ToString("dd/MM/yyyy"), "</b> al <b>", preservation.EndDate.GetValueOrDefault().ToString("dd/MM/yyyy"), "</b>"),
Path = preservation.Path,
Manager = preservation.User != null ? string.Concat(preservation.User.Name, " ", preservation.User.Surname) : string.Empty,
CloseDateLabel = preservation.CloseDate.HasValue ? preservation.CloseDate.Value.ToString("dd/MM/yyyy") : "#",
LastVerifiedDateLabel = preservation.LastVerifiedDate.HasValue ? preservation.LastVerifiedDate.Value.ToString("dd/MM/yyyy") : "#",
PathExist = !string.IsNullOrEmpty(preservation.Path) && Directory.Exists(preservation.Path),
IsClosed = preservation.CloseDate.HasValue
};
if (model.PathExist)
{
DirectoryInfo directoryInfo = new DirectoryInfo(model.Path);
FileInfo[] files = directoryInfo.GetFiles("*verifica conservazione*", SearchOption.TopDirectoryOnly).OrderByDescending(t => t.LastWriteTime).ToArray();
model.VerifyFiles = files.Select(s => new PreservationCheckVerifyFileViewModel()
{
FileName = s.Name,
Success = !s.Name.Contains("negativo"),
DateCreatedLabel = string.Concat(s.LastWriteTime.ToShortDateString(), " ", s.LastWriteTime.ToShortTimeString())
}).ToList();
}
return View(model);
}, _loggerService));
}
public ActionResult PreservationUploadFiles(Guid idPreservation, string preservationPath)
{
var errorMessage = string.Empty;
if (Request.Files != null)
{
try
{
var service = new PreservationService();
var preservation = service.GetPreservation(idPreservation, false);
string fileName, type;
HttpPostedFileBase file;
foreach (string formName in Request.Files)
{
file = Request.Files[formName];
fileName = Path.Combine(preservationPath, Path.GetFileName(file.FileName));
type = file.ContentType;
file.SaveAs(fileName);
//try
//{
// if (fileName.ToUpper().Contains("CHIUSURA_"))
// {
// if (!checkPreservationFilesIntegrity(idPreservation, fileName, null, false))
// throw new Exception("La verifica del file di chiusura ha avuto esito negativo");
// }
//}
//catch
//{
// throw;
//}
}
}
catch (Exception ex)
{
logger.Error(ex);
errorMessage = ex.ToString();
}
}
else
{
errorMessage = "Nessun file passato.";
}
return(Content(errorMessage));
}
public ActionResult ExportPDD(string data)
{
return(ActionResultHelper.TryCatchWithLogger(() =>
{
ICollection <Guid> ids = JsonConvert.DeserializeObject <ICollection <Guid> >(HttpUtility.UrlDecode(data));
Guid processId = Guid.NewGuid();
string path = Path.Combine(ConfigurationHelper.GetAppDataPath(), processId.ToString());
Directory.CreateDirectory(path);
try
{
foreach (Guid id in ids)
{
Document document = DocumentService.GetDocument(id);
using (DocumentsClient client = new DocumentsClient())
{
document.Content = client.GetDocumentContentById(id);
}
//Copied from preservation logic
document.AttributeValues = AttributeService.GetAttributeValues(document.IdDocument);
var fileName = string.Concat(_preservationService.PreservationDocumentFileName(document), (Path.GetExtension(document.Name)));
System.IO.File.WriteAllBytes(Path.Combine(path, fileName), document.Content.Blob);
if (document.IdPreservation.HasValue)
{
Preservation preservation = _preservationService.GetPreservation(document.IdPreservation.Value, false);
string[] files = Directory.GetFiles(preservation.Path).Where(x => x.Contains("INDICE_") || x.Contains("CHIUSURA_") || x.Contains("IPDA_") || x.Contains("LOTTI_")).ToArray();
foreach (string file in files.Where(f => !System.IO.File.Exists(Path.Combine(path, Path.GetFileName(f)))))
{
System.IO.File.Copy(file, Path.Combine(path, Path.GetFileName(file)), true);
}
}
}
string zipPath = CreatePDDZip(path);
return File(System.IO.File.ReadAllBytes(zipPath), System.Net.Mime.MediaTypeNames.Application.Zip);
}
finally
{
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
}
}, _loggerService));
}
public ExecutePreservationVerifyResponseModel Process(ExecutePreservationVerifyRequestModel request)
{
try
{
_logger.Info($"Process -> execute verify for preservation {request.IdPreservation}");
ExecutePreservationVerifyResponseModel responseModel = new ExecutePreservationVerifyResponseModel(request.IdPreservation);
if (request.IdPreservation == Guid.Empty)
{
return(responseModel);
}
Preservation preservation = _preservationService.GetPreservation(request.IdPreservation, false);
if (preservation == null)
{
_logger.Warn($"Process -> preservation with id {request.IdPreservation} not found");
responseModel.Status = PreservationVerifyStatus.Error;
responseModel.Errors.Add($"Nessuna conservazione trovata con ID {request.IdPreservation}");
return(responseModel);
}
bool isVerified = _preservationService.VerifyExistingPreservation(request.IdPreservation);
string[] tokens = Path.GetFileName(_preservationService.VerifyFile).Split(' ');
string title = Path.GetFileNameWithoutExtension(String.Join(" ", tokens, 1, tokens.Length - 1));
responseModel.Status = isVerified ? PreservationVerifyStatus.Ok : PreservationVerifyStatus.Error;
responseModel.VerifyTitle = title;
responseModel.Errors = _preservationService.ErrorMessages;
_logger.Info($"Process -> preservation is verified with status {responseModel.Status.ToString()}");
return(responseModel);
}
catch (Exception ex)
{
_logger.Error($"Error on verify preservation {request.IdPreservation}", ex);
return(new ExecutePreservationVerifyResponseModel(request.IdPreservation)
{
Status = PreservationVerifyStatus.Error,
Errors = new List <string>()
{
ex.Message
}
});
}
}
public ActionResult ClosePreservation(Preservation preservation)
{
var service = new PreservationService();
preservation = service.GetPreservation(preservation.IdPreservation, false);
if (!preservation.CloseDate.HasValue)
{
if (service.VerifyExistingPreservation(preservation.IdPreservation))
{
service.ClosePreservation(preservation.IdPreservation);
TempData["ErrorMessages"] = new string[] { "Conservazione eseguita e chiusa con successo" }.ToList();
}
else
{
TempData["ErrorMessages"] = service.ErrorMessages;
}
}
return(RedirectToAction("PreservationCheck", "Preservation", new { id = preservation.IdPreservation }));
}
public async Task <ActionResult> DoVerify(PreservationVerifyExecuteModel model, CancellationToken cancellationToken)
{
return(await Task.Factory.StartNew(() =>
{
return ActionResultHelper.TryCatchWithLogger(() =>
{
ICollection <PreservationVerifyJob> jobResults = new List <PreservationVerifyJob>();
string cacheKey = $"{User.Identity.Name}_{model.executionId}";
if (!_cache_jobs.TryAdd(cacheKey, jobResults))
{
_loggerService.Error("E' avvenuto un errore nella fase di inizializzazione della cache per i risultati di verifica conservazione");
throw new Exception("Errore in inizializzazione cache risultati");
}
if (model == null || model.jobs == null || model.jobs.Length == 0)
{
_loggerService.Warn("Nessuna conservazione da verificare nel periodo indicato");
return Json(string.Empty);
}
ExecutePreservationVerifyInteractor interactor;
ExecutePreservationVerifyRequestModel requestModel;
foreach (PreservationVerifyJob job in model.jobs)
{
Preservation currentPreservation = _preservationService.GetPreservation(Guid.Parse(job.idPreservation), false);
if (currentPreservation == null)
{
jobResults.Add(new PreservationVerifyJob()
{
idArchive = job.idArchive,
archiveName = job.archiveName,
idPreservation = job.idPreservation.ToString(),
preservationLabel = "Nessuna conservazione da verificare nel periodo indicato",
verifyTitle = string.Empty,
result = "ok",
errors = string.Empty
});
_cache_jobs.AddOrUpdate(cacheKey, jobResults, (key, existingValue) => jobResults);
continue;
}
interactor = new ExecutePreservationVerifyInteractor(_loggerService);
requestModel = new ExecutePreservationVerifyRequestModel()
{
IdPreservation = Guid.Parse(job.idPreservation)
};
ExecutePreservationVerifyResponseModel responseModel = interactor.Process(requestModel);
jobResults.Add(new PreservationVerifyJob
{
idArchive = job.idArchive,
archiveName = job.archiveName,
idPreservation = responseModel.IdPreservation.ToString(),
preservationLabel = $"Conservazione {currentPreservation.Label}",
verifyTitle = responseModel.VerifyTitle,
result = responseModel.Status == PreservationVerifyStatus.Ok ? "ok" : "bad",
errors = string.Join("<br />", responseModel.Errors)
});
_cache_jobs.AddOrUpdate(cacheKey, jobResults, (key, existingVal) => jobResults);
}
CreatePreservationVerifyReportInteractor reportInteractor = new CreatePreservationVerifyReportInteractor(_loggerService);
model.jobs = jobResults.ToArray();
PreservationVerifyReportRequestModel reportRequestModel = new PreservationVerifyReportRequestModel()
{
VerifyModel = model
};
PreservationVerifyReportResponseModel reportResponseModel = reportInteractor.Process(reportRequestModel);
return Json(new
{
Jobs = jobResults,
Response = reportResponseModel
});
}, _loggerService);
}));
}
public override async Task Execute(CommandModel commandModel)
{
try
{
if (!(commandModel is CommandPurgePreservation))
{
_logger.Error($"Command is not of type {nameof(CommandPurgePreservation)}");
await SendNotification(commandModel.ReferenceId, "E' avvenuto un errore durante la gestione del comando di pulizia storage", NotifyLevel.Error, true);
return;
}
CommandPurgePreservation @command = commandModel as CommandPurgePreservation;
_logger.Info($"Process command {command.Id} with preservation id {command.IdPreservation}");
await SendNotification(command.ReferenceId, "Inizio attività di pulizia archivio corrente degli elementi conservati", NotifyLevel.Info);
if (command.IdPreservation == Guid.Empty)
{
_logger.Error($"Preservation reference not setted for command {command.Id}");
await SendNotification(command.ReferenceId, "E' avvenuto un errore durante la gestione del comando di pulizia archivio corrente", NotifyLevel.Error, true);
return;
}
if (string.IsNullOrEmpty(command.Executor))
{
_logger.Error($"Process executor not setted for command {command.Id}");
await SendNotification(command.ReferenceId, "E' avvenuto un errore durante la gestione del comando di pulizia archivio corrente", NotifyLevel.Error, true);
return;
}
Preservation preservation = _preservationService.GetPreservation(command.IdPreservation, false);
if (preservation == null)
{
_logger.Error($"Preservation {command.IdPreservation} not found");
await SendNotification(command.ReferenceId, $"Nessuna conservazione trovata con id {command.IdPreservation}", NotifyLevel.Error, true);
return;
}
if (!preservation.CloseDate.HasValue)
{
_logger.Error($"Preservation {command.IdPreservation} is not closed. Please close preservation before execute this task.");
await SendNotification(command.ReferenceId, $"Non è possibile procedere alla pulizia dell'archivio corrente di una conservazione non chiusa", NotifyLevel.Error, true);
return;
}
Logging.AddLog(LoggingOperationType.BiblosDS_General, preservation.IdArchive,
Guid.Empty, preservation.IdPreservation,
$"Attività di pulizia storage per la conservazione {preservation.IdPreservation} richiesta dall'utente {command.Executor}",
command.Executor);
int preservedDocumentsCount = _preservationService.CountPreservationDocumentsToPurge(command.IdPreservation);
_logger.Info($"Found {preservedDocumentsCount} to process");
if (preservedDocumentsCount == 0)
{
await SendNotification(command.ReferenceId, $"Nessun documento trovato per la conservazione {command.IdPreservation}", NotifyLevel.Info, true);
return;
}
await SendNotification(command.ReferenceId, $"Trovati {preservedDocumentsCount} documenti da eliminare dall'archivio corrente", NotifyLevel.Info);
int processedItems = 0;
decimal pulsePercentageLimit = 20;
decimal percentage;
EntityProvider entityProvider;
await SendNotification(command.ReferenceId, $"Inizio cancellazione documenti, l'attività può richiedere alcuni minuti", NotifyLevel.Info);
Status statusToChange = new Status(DocumentStatus.MovedToPreservation);
ICollection <Document> preservedDocuments = _preservationService.GetPreservationDocumentsToPurge(command.IdPreservation);
string documentPath = string.Empty;
bool hasMoveErrors = false;
foreach (Document document in preservedDocuments)
{
processedItems++;
_logger.Info($"Process document {document.IdDocument}");
documentPath = DocumentService.GetPreservationDocumentPath(document);
_logger.Info($"Document {document.IdDocument} with preservation path: {documentPath}");
if (string.IsNullOrEmpty(documentPath))
{
_logger.Info($"Document {document.IdDocument} hasn't preservation path defined. Document skipped");
await SendNotification(command.ReferenceId, $"Il documento {document.IdDocument} non ha l'indicazione del percorso di conservazione e pertanto non può essere eliminato dall'archivio corrente", NotifyLevel.Error);
continue;
}
if (!File.Exists(documentPath))
{
_logger.Info($"File {documentPath} not found on disk for document {document.IdDocument}");
await SendNotification(command.ReferenceId, $"Il documento {document.IdDocument} non esiste nel percorso di conservazione {documentPath}", NotifyLevel.Error);
continue;
}
entityProvider = new EntityProvider();
using (IDbTransaction transaction = entityProvider.BeginNoSave())
{
try
{
_logger.Info($"Document {document.IdDocument} -> change document state to {DocumentStatus.MovedToPreservation.ToString()}");
entityProvider.UpdateDocumentStatus(document, statusToChange);
entityProvider.SaveChanges();
_logger.Info($"Document {document.IdDocument} -> delete document from storage");
_storageService.DeleteDocument(document, false);
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
_logger.Info($"Error on delete document {document.IdDocument} from storage. Document skipped.", ex);
hasMoveErrors = true;
}
}
percentage = ((decimal)processedItems / preservedDocumentsCount) * 100.0m;
if (Math.Ceiling(percentage) > pulsePercentageLimit)
{
await SendNotification(command.ReferenceId, $"Pulizia documenti nell'archivio corrente ({pulsePercentageLimit}%).", NotifyLevel.Info);
pulsePercentageLimit += 20;
}
}
string completeMessage = $"Il processo di pulizia archivio corrente per la conservazione {command.IdPreservation} è terminato correttamente.";
if (hasMoveErrors)
{
completeMessage = $"Il processo di pulizia archivio corrente per la conservazione {command.IdPreservation} è terminato con errori. Verificare il file di log per ulteriori dettagli.";
}
await SendNotification(command.ReferenceId, completeMessage, hasMoveErrors?NotifyLevel.Error : NotifyLevel.Info, true);
}
catch (Exception ex)
{
_logger.Error($"Error on purge preservation", ex);
await SendNotification(commandModel.ReferenceId, $"E' avvenuto un errore durante l'esecuzione dell'attività corrente", NotifyLevel.Error, true);
}
}