/// <summary>
/// Metodo per la costruzione dell'oggetto InfoDocumentDelivered contenente informazioni
/// su ciò che è stato effettivamente recapitato a destinazione.
/// </summary>
/// <param name="schedaDocumento"></param>
/// <returns></returns>
private static InfoDocumentDelivered BuildInfoDocumentDelivered(SchedaDocumento schedaDocumento)
{
InfoDocumentDelivered infoDocDelivered = new InfoDocumentDelivered();
if (schedaDocumento != null && !string.IsNullOrEmpty(schedaDocumento.docNumber))
{
try
{
//Aggiungo le informazioni per il documento principale
FileRequest fileReq = (Documento)schedaDocumento.documenti[0];
DocsPaDB.Query_DocsPAWS.Documenti doc = new DocsPaDB.Query_DocsPAWS.Documenti();
string impronta = string.Empty;
if (Int32.Parse(fileReq.fileSize) > 0)
{
doc.GetImpronta(out impronta, fileReq.versionId, fileReq.docNumber);
}
infoDocDelivered.MainDocument = new DocumentInfo
{
Name = schedaDocumento.oggetto.descrizione,
FileName = doc.GetNomeOriginale(fileReq.versionId, fileReq.docNumber),
Fingerprint = impronta
};
//Aggiungo le informazioni per gli allegati
infoDocDelivered.Attachments = new List <DocumentInfo>();
schedaDocumento.allegati = doc.GetAllegati(schedaDocumento.docNumber, "user");
if (schedaDocumento.allegati != null && schedaDocumento.allegati.Count > 0)
{
DocumentInfo infoAttach;
foreach (Allegato allegato in schedaDocumento.allegati)
{
impronta = string.Empty;
if (Int32.Parse(allegato.fileSize) > 0)
{
doc.GetImpronta(out impronta, allegato.versionId, allegato.docNumber);
}
infoAttach = new DocumentInfo
{
Name = allegato.descrizione,
VersionLabel = allegato.versionLabel,
FileName = doc.GetNomeOriginale(allegato.versionId, allegato.docNumber),
Fingerprint = impronta
};
infoDocDelivered.Attachments.Add(infoAttach);
}
}
}
catch (Exception e)
{
logger.Error("BusinessLogic.interoperabilita.Semplificata.SimplifiedInteroperabilityRequestManager.BuildInfoDocumentDelivered. Errore durante la costruzione dell'oggetto contenente l'infomazione della spedizione : " + e.Message);
}
}
return(infoDocDelivered);
}
/// <summary>
/// Metodo per la generazione della ricevuta di avvenuta consegna
/// </summary>
/// <param name="interoperabilityMessage">Messaggio per cui generare la ricevuta</param>
/// <param name="messageId">Id del messaggio ricevuto</param>
/// <param name="receiver">Destinatario raggiunto</param>
public static void GenerateProof(Interoperability.Domain.InteroperabilityMessage interoperabilityMessage, String messageId, ReceiverInfo receiver, InfoDocumentDelivered documentDelivered)
{
// Inizializzazione della ricevuta
SuccessfullyDeliveredGenerator proof = new SuccessfullyDeliveredGenerator(
interoperabilityMessage.Record.Subject, documentDelivered);
// Generazione ricevuta
ProofMessage message = proof.GenerateProof(
interoperabilityMessage.Sender.Code,
receiver.Code,
messageId);
AddProofToDocument(
interoperabilityMessage.MainDocument.DocumentNumber,
messageId,
message.ProofContent,
message.ProofDate,
message.Receiver);
// PEC 4 Modifica Maschera Caratteri
InteroperabilitaSemplificataManager.AggiornaStatusMask("ANVAAAN", receiver.AOOCode, receiver.AdministrationCode, interoperabilityMessage.MainDocument.DocumentNumber);
}
/// <summary>
/// Metodo per l'analisi di una richiesta di interoperabilità. Al termine dell'esecuzione di questo metodo
/// nel sistema saranno presenti dei documenti in ingresso contenenti i dati prelevati dalla richiesta.
/// </summary>
/// <param name="interoperabilityMessage">Informazioni sulla richiesta di interoperabilità</param>
/// <param name="messageId">Guid del messaggio di interoperabilità in fase di analisi</param>
public static InfoDocumentDelivered AnalyzeInteroperabilityMessage(InteroperabilityMessage interoperabilityMessage, String messageId)
{
// Mittente della spedizione
Corrispondente senderInfo = null;
// Utente e ruolo da utilizzare per la creazione del predisposto
Utente user = null;
Ruolo userRole = null;
InfoDocumentDelivered infoDocDelivered = null;
// E' necessario creare un predisposto per ogni AOO, quindi bisogna analizzare tutti i destinatari e
// capire quanti crearne.
// Caricamento delle impostazioni sulle AOO destinatarie del messaggio
Dictionary <InteroperabilitySettings, List <ReceiverInfo> > interopSettings = null;
try
{
interopSettings = InteroperabilitaSemplificataManager.LoadSettings(interoperabilityMessage.Receivers, interoperabilityMessage.ReceiverAdministrationCode);
}
catch (Exception e)
{
SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(String.Empty, true,
String.Format("{0} Id messaggio: {1}", e.Message, messageId));
throw new SimplifiedInteroperabilityLoadSettingsException("Errore durante il caricamento delle impostazioni sui registri coinvolti dalla richiesta di interoperabilità");
}
// Eventuale eccezione da sollevare
SimplifiedInteroperabilityException simplifiedInteroperabilityException = new SimplifiedInteroperabilityException();
// Creazione di un predisposto per ogni AOO
foreach (var settings in interopSettings.Keys)
{
try
{
// Caricamento di utente e ruolo da utilizzare per la creazione del documento
user = UserManager.getUtenteById(settings.UserId.ToString());
user.dst = UserManager.getSuperUserAuthenticationToken();
userRole = UserManager.getRuoloByIdGruppo(settings.RoleId.ToString());
if (user == null || userRole == null)
{
//pork.. per generare l'eccezione almeno nel log di IS scrive che non è configurato bene il ruolo, altrimenti
//scrive solo errore generico..
string Eccezione = userRole.systemId;
Eccezione = user.systemId;
}
logger.DebugFormat("interopSettings[settings]: {0} - messageId: {1} - interoperabilityMessage: {2} - user: {3}",
interopSettings[settings],
messageId,
interoperabilityMessage.Sender.Url,
user.userId);
}
catch (Exception retrivingUserAndRole)
{
// Errore durante il recupero delle informazioni su utente e ruolo per la creazione del predisposto.
simplifiedInteroperabilityException.Requests.Add(
new SingleRequest()
{
ErrorMessage = "Destinatario non configurato correttamente",
ReceiverInfoes = interopSettings[settings]
});
SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(
String.Empty,
true,
"Errore durante il recupero di utente e ruolo per la creazione del predisposto.");
}
try
{
// Recupero delle informazioni sul mittente del messaggio di interoperabilità. Il corrispondente
// deve essere censito in Rubrica Comune, quindi viene effettuata una ricerca mirata.
// (Viene fatta solo se non è già stato scaricato)
if (senderInfo == null)
{
senderInfo = UserManager.getCorrispondenteByCodRubricaRubricaComune(
interoperabilityMessage.Sender.Code,
UserManager.GetInfoUtente(user, userRole));
}
if (senderInfo == null)
{
throw new RetrivingSenderInfoException(String.Format("Errore durante il reperimento del mittente del messaggio di interoperabilità. Id messaggio: {0}, Codice mittente: {1}",
messageId,
interoperabilityMessage.Sender.Code));
}
}
catch (Exception e)
{
SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(String.Empty, true, e.Message);
throw new RetrivingSenderInfoException(e.Message);
}
try
{
infoDocDelivered = GenerateInteroperabilityDocument(settings, senderInfo, interoperabilityMessage, interopSettings[settings], messageId, user, userRole);
}
catch (RegistryNotInteroperableException registryNotInteroperable)
{
// Il registro non è interoperante
simplifiedInteroperabilityException.Requests.Add(
new SingleRequest()
{
ErrorMessage = registryNotInteroperable.Message,
ReceiverInfoes = interopSettings[settings]
});
}
catch (CreatingDocumentException creatingDocumentException)
{
// Errore durante la creazione del documento
simplifiedInteroperabilityException.Requests.Add(
new SingleRequest()
{
ErrorMessage = creatingDocumentException.Message,
ReceiverInfoes = interopSettings[settings]
});
}
catch (DownloadDocumentException downloadDocumentException)
{
// Errore durante l'associazione di un file ad un documento
simplifiedInteroperabilityException.Requests.Add(
new SingleRequest()
{
ErrorMessage = downloadDocumentException.Message,
ReceiverInfoes = interopSettings[settings]
});
}
catch (RetrivingTransmissionReceiverException retrivingTransmissionReceiver)
{
// Errore durante il recupero dei destinatati cui trasmettere il predisposto.
simplifiedInteroperabilityException.Requests.Add(
new SingleRequest()
{
ErrorMessage = retrivingTransmissionReceiver.Message,
ReceiverInfoes = interopSettings[settings]
});
}
catch (RetrivingSomeTransmissionReceiverException retrivingSomeTransmissionReceiverException)
{
// Errore durante il recupero di alcuni destinatari cui trasmettere il predisposto.
simplifiedInteroperabilityException.Requests.Add(
new SingleRequest()
{
ErrorMessage = retrivingSomeTransmissionReceiverException.Message,
ReceiverInfoes = retrivingSomeTransmissionReceiverException.Receivers
});
}
catch (ExecuteTransmissionException executeTransmission)
{
// Errore durante la trasmissione del documento ai destinatari interni.
simplifiedInteroperabilityException.Requests.Add(
new SingleRequest()
{
ErrorMessage = executeTransmission.Message,
ReceiverInfoes = interopSettings[settings]
});
}
catch (Exception general)
{
// Eccezione generica
simplifiedInteroperabilityException.Requests.Add(
new SingleRequest()
{
ErrorMessage = "Errore non identificato",
ReceiverInfoes = interopSettings[settings]
});
}
}
// Se per almeno un destinatario è stata generata una eccezione, viene rilanciata l'eccezione SimplifiedInteroperabilityException
if (simplifiedInteroperabilityException.Requests.Count > 0)
{
throw simplifiedInteroperabilityException;
}
return(infoDocDelivered);
}
/// <summary>
/// Metodo per la creazione del predisposto e per la sua trasmissione agli utenti impostati nel sistema
/// </summary>
/// <param name="settings">Impostazioni relative al particolare registro su cui creare il predisposto</param>
/// <param name="senderInfo">Informazioni sul mittente del messaggio</param>
/// <param name="interoperabilityMessage">Informazioni sulla richiesta di interoperabilità</param>
///
private static InfoDocumentDelivered GenerateInteroperabilityDocument(InteroperabilitySettings settings, Corrispondente senderInfo, InteroperabilityMessage interoperabilityMessage, List <ReceiverInfo> receivers, String messageId, Utente user, Ruolo userRole)
{
// Se per il registro è disabilitata l'interoperabilità, non si può procedere.
if (!settings.IsEnabledInteroperability)
{
throw new RegistryNotInteroperableException(String.Format("Registro {0} non interoperante", RegistriManager.getRegistro(settings.RegistryId).codice));
}
// Creazione della scheda documento
SchedaDocumento document = CreateDocument(settings, senderInfo, interoperabilityMessage, userRole, user, messageId);
// Trasmissione dei documenti ai ruoli
List <ReceiverInfo> uneachableReceivers = TransmitDocument(settings, document, userRole, user, interoperabilityMessage.IsPrivate, receivers);
// Se il documento è stato marcato privato a causa delle impostazioni sulla gestione
// viene eliminato il flag privato
if (!interoperabilityMessage.IsPrivate && document.privato == "1")
{
DocManager.SetNotPrivate(document.systemId);
}
InfoDocumentDelivered infoDocDelivered = BuildInfoDocumentDelivered(document);
// Se per il registro è impostata la modalità automatica, si procede con la protocollazione del documento
if (settings.ManagementMode == ManagementType.A)
{
try
{
InfoUtente userInfo = UserManager.GetInfoUtente(user, userRole);
// Impostazione della data e ora di protocollazione
document.protocollo.dataProtocollazione = DateTime.Now.ToString("dd/MM/yyyy");
document.protocollo.anno = DateTime.Now.Year.ToString();
ResultProtocollazione protoResult = ResultProtocollazione.OK;
ProtoManager.protocolla(document, userRole, userInfo, out protoResult);
// Invio della ricevuta di conferma di ricezione al mittente per tutti i destinatari
SimplifiedInteroperabilityProtoManager.SendDocumentReceivedProofToSender(
interoperabilityMessage,
new DocsPaVO.Interoperabilita.Semplificata.RecordInfo()
{
AdministrationCode = document.registro.codAmministrazione,
AOOCode = document.registro.codRegistro,
RecordDate = DateTime.Parse(document.protocollo.dataProtocollazione),
RecordNumber = document.protocollo.numero
},
document.systemId,
userInfo);
}
catch (Exception e)
{
SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(
document.systemId,
true,
"Errore durante la creazione del protocollo");
throw new CreatingDocumentException("Errore durante la protocollazione del documento predisposto");
}
}
// Se qualche corrispondente non è stato trovato, viene sollevata un'eccezione
// di tipo RetrivingSomeTransmissionReceiverException
if (uneachableReceivers != null && uneachableReceivers.Count > 0)
{
throw new RetrivingSomeTransmissionReceiverException(
"Nessun destinatario trovato per la trasmissione del documento",
uneachableReceivers);
}
return(infoDocDelivered);
}
