/// <summary> /// Metodo per il salvataggio di una reference per il messaggio di interoperabilità /// </summary> /// <param name="profileId">Id del documento creato a seguito della richiesta di interoperabilità</param> /// <param name="interoperabilityMessage">Informazioni sul messaggio di interoperabilità</param> /// <returns>Identificativo del messaggio</returns> public static String SaveMessageReference(InteroperabilityMessage interoperabilityMessage) { // Creazione di un riga nel registro del'IS e restituzione dell'id del messaggio String messageId = Guid.NewGuid().ToString(); StringBuilder receiverCode = new StringBuilder(); foreach (var rec in interoperabilityMessage.Receivers) { receiverCode.AppendFormat("'{0}', ", rec.Code); } receiverCode = receiverCode.Remove(receiverCode.Length - 2, 2); try { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInRegistry( messageId, interoperabilityMessage.IsPrivate, interoperabilityMessage.Record.Subject, interoperabilityMessage.Sender.Code, interoperabilityMessage.Sender.Url, interoperabilityMessage.Record.AdministrationCode, interoperabilityMessage.Record.AOOCode, interoperabilityMessage.Record.RecordDate, interoperabilityMessage.Record.RecordNumber, receiverCode.ToString()); } catch (Exception e) { throw new SaveMessageReferenceException("Errore durante il salvataggio delle informazioni sulla richiesta di interoperabilità."); } return(messageId); }
/// <summary> /// Metodo per l'invio della ricevuta di conferma di ricezione /// al mittente del messaggio di interoperabilità /// </summary> /// <param name="idProfile">Id del documento per cui inviare la conferma di ricezione</param> /// <param name="userId">Usr id dell'utente mittente dell'invio della ricevuta</param> /// <param name="adminId">Id dell'amministrazione mittente della ricevuta</param> /// <param name="recCode">Codice del destinatario che invia la conferma di ricezione</param> private static void SendDocumentReceivedProofToSender(String idProfile, String userId, String adminId, String recCode) { logger.DebugFormat("Invio ricevuta di conferma di ricezione per interoperabilità semplificata del documento con id {0}", idProfile); // Recupero delle informazioni sul mittente del documento using (DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata dbManager = new DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata()) { RecordInfo sender, receiver; String senderUrl, receiverCode; if (dbManager.LoadSenderDocInfo(idProfile, out sender, out receiver, out senderUrl, out receiverCode)) { String rec = recCode; // Se la recCode è vuoto, la notifica viene inviata per tutti i destinatari if (String.IsNullOrEmpty(recCode)) { rec = receiverCode; } // Invio della ricevuta di conferma ricezione SendProof(sender, receiver, senderUrl, idProfile, userId, adminId, rec); } else { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(idProfile, true, String.Format("Errore nel recupero dei dati per la creazione della ricevuta di conferma ricezione")); logger.ErrorFormat("Errore nel recupero dei dati per la creazione della ricevuta di conferma ricezione per il documento con id {0}", idProfile); } } }
/// <summary> /// Metodo per la generazione della ricevuta e per il suo invio /// </summary> /// <param name="reason">Ragione di annullamento o dettaglio dell'eccezione</param> /// <param name="documentId">Id del documento</param> /// <param name="adminId">Id dell'amministrazione</param> /// <param name="dropped">Flag utilizzato per indicare se il documento è stato cancellato</param> /// <returns>Esito dell'operazione</returns> private static bool GenerateAndSendProof(String reason, String documentId, String adminId, bool dropped) { bool retVal = false; using (InteroperabilitaSemplificata dbManager = new InteroperabilitaSemplificata()) { RecordInfo sender, receiver; String senderUrl, receiverCode; if (dbManager.LoadSenderDocInfo(documentId, out sender, out receiver, out senderUrl, out receiverCode)) { // Invio della ricevuta di conferma ricezione SendProof(sender, receiver, senderUrl, reason, adminId, dropped, receiverCode); retVal = true; } else { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, true, String.Format("Errore nel recupero dei dati per la creazione della ricevuta di {0}", dropped ? "annullamento del protocollo" : "rifiuto del documento")); logger.ErrorFormat("Errore nel recupero dei dati per la creazione della ricevuta di {1} per il documento con id {0}", documentId, dropped ? "annullamento del protocollo" : "rifiuto del documento"); } } return(retVal); }
/// <summary> /// Metodo per l'invio della ricevuta di conferma ricezione /// </summary> /// <param name="senderRecordInfo">Informazioni sul protocollo mittente</param> /// <param name="receiverRecordInfo">Informaizoni sul protocollo destinatario</param> /// <param name="senderUrl">Url del mittente della richiesta di interoperabilità</param> /// <param name="idProfile">Id del documento creato a seguito della richiesta di interoperabilità</param> /// <param name="userId">User id dell'utente mittente della ricevuta</param> /// <param name="adminId">Id dell'amministrazione mittente</param> /// <param name="receiverCode">Codice del destinatario per cui generare la ricevuta</param> internal static void SendProof(RecordInfo senderRecordInfo, RecordInfo receiverRecordInfo, String senderUrl, String idProfile, String userId, String adminId, String receiverCode) { InteroperabilityController interoperabilityController = new InteroperabilityController(); try { // Invio della ricevuta al mittente try { interoperabilityController.AnalyzeDocumentReceivedProof( new Interoperability.Domain.RecordInfo() { AdministrationCode = senderRecordInfo.AdministrationCode, AOOCode = senderRecordInfo.AOOCode, RecordDate = senderRecordInfo.RecordDate, RecordNumber = senderRecordInfo.RecordNumber }, new Interoperability.Domain.RecordInfo() { AdministrationCode = receiverRecordInfo.AdministrationCode, AOOCode = receiverRecordInfo.AOOCode, RecordDate = receiverRecordInfo.RecordDate, RecordNumber = receiverRecordInfo.RecordNumber }, senderUrl, InteroperabilitaSemplificataManager.GetUrl(adminId), receiverCode); } catch (Exception e) { logger.Error("Errore durante l'invio della ricevuta di conferma ricezione al mittente: " + e.Message); SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(idProfile, true, String.Format("Errore durante l'invio della ricevuta di conferma ricezione al mittente da parte dell'utente {0}", userId)); logger.ErrorFormat("Errore durante l'invio della ricevuta di conferma ricezione al mittente da parte dell'utente {0}", userId); } // Aggiunta voce di log SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(idProfile, false, String.Format("Ricevuta di conferma di ricezione al mittente con indirizzo '{0}' da parte dell'utente {1} inviata correttamente.", senderUrl, userId)); } catch (Exception e) { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(idProfile, true, String.Format("Errore durante l'invio della ricevuta di conferma di ricezione al mittente con indirizzo '{0}' da parte dell'utente {1}", senderUrl, userId)); logger.Error( String.Format("Errore durante l'invio della ricevuta di conferma di ricezione al mittente con indirizzo '{0}' da parte dell'utente {1}", senderUrl, userId), e); } }
/// <summary> /// Metodo per l'aggiunta dell'allegato al documento spedito /// </summary> /// <param name="documentId">Id del documento a aggiungere l'allegato</param> /// <param name="recData">Contenuto della ricevuta</param> /// <param name="userInfo">Informazioni sull'utente da utilizzare per l'aggiunta dell'allegato</param> /// <param name="messageId">Identificativo del messaggio</param> /// <param name="proofDate">Data di generazione della ricevuta</param> /// <param name="receiverCode">Codice del destinatario che ha generato la mancata consegna</param> /// <param name="senderUrl">Url del mittente</param> private static void AddAttachmentToDocument(String documentId, byte[] recData, InfoUtente userInfo, String messageId, DateTime proofDate, String receiverCode, String senderUrl) { // Creazione dell'oggetto allegato Allegato a = new Allegato(); // Impostazione delle proprietà dell'allegato a.descrizione = String.Format("Ricevuta di mancata consegna - " + receiverCode); a.docNumber = documentId; a.version = "0"; a.numeroPagine = 1; a.TypeAttachment = 3; try { // Aggiunta dell'allegato al documento principale a = AllegatiManager.aggiungiAllegato(userInfo, a); // Set del flag in CHA_ALLEGATI_ESTERNO in Versions BusinessLogic.Documenti.AllegatiManager.setFlagAllegati_PEC_IS_EXT(a.versionId, a.docNumber, "I"); // Associazione dell'immagine all'allegato FileDocumento fileDocument = new FileDocumento() { content = recData, length = recData.Length, name = "MancataConsegna.pdf" }; FileRequest request = a as FileRequest; String err; FileManager.putFileRicevuteIs(ref request, fileDocument, userInfo, out err); // Aggiunta della notifica alla tabella delle notifiche SaveProofInRegistry(a, messageId, receiverCode, senderUrl, proofDate, documentId); if (!String.IsNullOrEmpty(err)) { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, true, String.Format("Errore durante l'associazione della ricevuta di mancata consegna al documento")); } else { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, false, String.Format("Ricevuta di mancata consegna associata correttamente al documento")); } } catch (Exception e) { string message = e.Message + " " + e.StackTrace; message = message.Length > 3700 ? message.Substring(0, 3700) : message; SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, true, String.Format("Errore durante l'aggiunta dell'allegato con la ricevuta di mancata consegna al documento " + documentId + " : " + message)); } }
/// <summary> /// Metodo per il salvataggio delle informazioni su una ricevuta di conferma di ricezione /// </summary> /// <param name="senderRecordInfo">Informazioni sul protocollo mittente</param> /// <param name="receiverRecordInfo">Informaizoni sul protocollo destinatario</param> /// <param name="receiverUrl">Url del destinatario della spedizione</param> /// <param name="receiverCode">Codice del destinatario che ha inviato la conferma di ricezione</param> public static void SaveReceivedProofData( RecordInfo senderRecordInfo, RecordInfo receiverRecordInfo, String receiverUrl, String receiverCode) { using (DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata interopDb = new DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata()) { bool retVal = interopDb.SaveReceivedProofData(senderRecordInfo, receiverRecordInfo, receiverUrl, receiverCode); SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog("", !retVal, String.Format("Salvataggio delle informazioni sulla ricevuta di conferma di ricezione relativa al protocollo {0} creato in data {1}, {2}", senderRecordInfo.RecordNumber, senderRecordInfo.RecordDate, retVal ? "riuscito correttamente" : "non riuscito")); logger.DebugFormat("Salvataggio delle informazioni sulla ricevuta di conferma di ricezione, per l'interoperabilità semplificata, relativa al protocollo {0} creato in data {1}, {2}", senderRecordInfo.RecordNumber, senderRecordInfo.RecordDate, retVal ? "riuscito correttamente" : "non riuscito"); } }
/// <summary> /// Metodo per l'aggiunta della ricevuta di avvenuta consegna al documento spedito /// </summary> /// <param name="documentId">Id del documento cui aggiungere l'allegato</param> /// <param name="messageId">Identificativo del messaggio ricevuto</param> /// <param name="data">Contenuto della ricevuta</param> /// <param name="proofDate">Data di generazione della ricevuta</param> /// <param name="receiverCode">Codice del destinatario raggiunto</param> private static void AddProofToDocument(String documentId, String messageId, byte[] data, DateTime proofDate, String receiverCode) { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, false, "Aggiunta della Ricevuta di avvenuta consegna al documento"); String authorId, creatorRole; using (DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata dbInterop = new DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata()) { // Recupero dell'id del documento e degli id di utente e ruolo con cui creare l'allegato dbInterop.LoadDataForDeliveredProof(documentId, out authorId, out creatorRole); // Recupero delle informazioni sull'utente Utente user = UserManager.getUtenteById(authorId); user.dst = UserManager.getSuperUserAuthenticationToken(); Ruolo role = UserManager.getRuoloById(creatorRole); InfoUtente userInfo = UserManager.GetInfoUtente(user, role); // Creazione e aggiunta dell'allegato AddAttachmentToDocument(documentId, data, userInfo, messageId, proofDate, receiverCode, InteroperabilitaSemplificataManager.GetUrl(userInfo.idAmministrazione)); } }
/// <summary> /// Metodo per l'aggiunta dell'allegato al documento /// </summary> /// <param name="documentId">Id del documento cui aggiungere l'allegato</param> /// <param name="recData">Contenuto della ricevuta</param> /// <param name="userInfo">Inormazioni sull'utente utilizzato per la generazione dell'allegato</param> /// <param name="messageId">Identificativo del messaggio ricevuto</param> /// <param name="proofDate">Data di generazione della ricevuta</param> /// <param name="receiverCode">Codice del destinatario per cui generare la ricevuta</param> /// <param name="senderUrl">Url del mittente</param> private static void AddAttachmentToDocument(String documentId, byte[] recData, InfoUtente userInfo, String messageId, DateTime proofDate, String receiverCode, String senderUrl) { // Creazione dell'oggetto allegato Allegato a = new Allegato(); // Impostazione delle proprietà dell'allegato a.descrizione = String.Format("Ricevuta di avvenuta consegna - " + receiverCode); a.docNumber = documentId; a.version = "0"; a.numeroPagine = 1; a.TypeAttachment = 3; try { bool usingTransactionContext = string.IsNullOrEmpty(DocsPaUtils.Configuration.InitConfigurationKeys.GetValue("0", "BE_NOT_USING_TRANSACTION_CONTEXT")) || !DocsPaUtils.Configuration.InitConfigurationKeys.GetValue("0", "BE_NOT_USING_TRANSACTION_CONTEXT").Equals("1"); // Aggiunta dell'allegato al documento principale if (usingTransactionContext) { using (DocsPaDB.TransactionContext transactionContext = new DocsPaDB.TransactionContext()) { logger.Debug("INIZIO aggiungiAllegato per il documento " + documentId); a = AllegatiManager.aggiungiAllegato(userInfo, a); logger.Debug("FINE aggiungiAllegato per il documento " + documentId + ". Id allegato creato: " + a.docNumber + " con id versione: " + a.versionId); // Set del flag in CHA_ALLEGATI_ESTERNO in Versions logger.Debug("INIZIO setFlagAllegati_PEC_IS_EXT per l'allegato con docnumber" + a.docNumber + "e version id: " + a.versionId + ". Documento principale:" + documentId); bool resultSetFlag = BusinessLogic.Documenti.AllegatiManager.setFlagAllegati_PEC_IS_EXT(a.versionId, a.docNumber, "I"); logger.Debug("FINE setFlagAllegati_PEC_IS_EXT per l'allegato " + a.docNumber + "con esito: " + resultSetFlag + ". Documento principale:" + documentId); // Associazione dell'immagine all'allegato FileDocumento fileDocument = new FileDocumento() { content = recData, length = recData.Length, name = "AvvenutaConsegna.pdf" }; FileRequest request = a as FileRequest; String err; logger.Debug("INIZIO putFile per l'allegato " + a.docNumber); FileManager.putFileRicevuteIs(ref request, fileDocument, userInfo, out err); logger.Debug("FINE putFile per l'allegato " + a.docNumber); // Aggiunta della notifica alla tabella delle notifiche SaveProofInRegistry(a, messageId, receiverCode, senderUrl, proofDate, documentId); if (!String.IsNullOrEmpty(err)) { logger.Error("Errore durante la procedura di putfile per l'allegato: " + a.docNumber + ". Testo dell'errore: " + err); SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, true, String.Format("Errore durante l'associazione della ricevuta di avvenuta consegna inviata da al documento")); } else { logger.Debug("Putfile avvenuta correttamente per l'allegato " + a.docNumber); SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, false, String.Format("Ricevuta di avvenuta consegna associata correttamente al documento")); } if (resultSetFlag && string.IsNullOrEmpty(err)) { transactionContext.Complete(); } } } else { logger.Debug("INIZIO aggiungiAllegato per il documento " + documentId); a = AllegatiManager.aggiungiAllegato(userInfo, a); logger.Debug("FINE aggiungiAllegato per il documento " + documentId + ". Id allegato creato: " + a.docNumber + " con id versione: " + a.versionId); // Set del flag in CHA_ALLEGATI_ESTERNO in Versions logger.Debug("INIZIO setFlagAllegati_PEC_IS_EXT per l'allegato con docnumber" + a.docNumber + "e version id: " + a.versionId + ". Documento principale:" + documentId); bool resultSetFlag = BusinessLogic.Documenti.AllegatiManager.setFlagAllegati_PEC_IS_EXT(a.versionId, a.docNumber, "I"); logger.Debug("FINE setFlagAllegati_PEC_IS_EXT per l'allegato " + a.docNumber + "con esito: " + resultSetFlag + ". Documento principale:" + documentId); // Associazione dell'immagine all'allegato FileDocumento fileDocument = new FileDocumento() { content = recData, length = recData.Length, name = "AvvenutaConsegna.pdf" }; FileRequest request = a as FileRequest; String err; logger.Debug("INIZIO putFile per l'allegato " + a.docNumber); FileManager.putFileRicevuteIs(ref request, fileDocument, userInfo, out err); logger.Debug("FINE putFile per l'allegato " + a.docNumber); // Aggiunta della notifica alla tabella delle notifiche SaveProofInRegistry(a, messageId, receiverCode, senderUrl, proofDate, documentId); if (!String.IsNullOrEmpty(err)) { logger.Error("Errore durante la procedura di putfile per l'allegato: " + a.docNumber + ". Testo dell'errore: " + err); SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, true, String.Format("Errore durante l'associazione della ricevuta di avvenuta consegna inviata da al documento")); } else { logger.Debug("Putfile avvenuta correttamente per l'allegato " + a.docNumber); SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, false, String.Format("Ricevuta di avvenuta consegna associata correttamente al documento")); } } } catch (Exception e) { logger.Error("Errore in AddAttachmentToDocument per l'allegato: " + a.docNumber + ". Errore: " + e.Message); string message = e.Message + " " + e.StackTrace; message = message.Length > 3700 ? message.Substring(0, 3700) : message; SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(documentId, true, String.Format("Errore durante l'aggiunta dell'allegato con la ricevuta di avvenuta consegna al documento " + documentId + " : " + message)); } }
/// <summary> /// Metodo per il salvataggio dei dati di una ricevuta di eccezione o di annullamento /// </summary> /// <param name="senderRecordInfo">Informazioni sul protocollo mittente</param> /// <param name="receiverRecordInfo">Informazioni sul protocollo destinatario</param> /// <param name="reason">Ragione di annullamento o dettaglio dell'eccezione</param> /// <param name="receiverUrl">Url del destinatario</param> /// <param name="droppedProof">Flag utilizzato per indicare se si tratta di una ricevuta di annullamento</param> /// <param name="receiverCode">Codice del destinatario</param> public static void SaveProofData(RecordInfo senderRecordInfo, RecordInfo receiverRecordInfo, string reason, string receiverUrl, bool droppedProof, String receiverCode) { using (DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata interopDb = new DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata()) { bool retVal = interopDb.SaveDocumentDroppedOrExceptionProofData(senderRecordInfo, receiverRecordInfo, reason, receiverUrl, droppedProof, receiverCode); SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(String.Empty, !retVal, String.Format("Salvataggio delle informazioni sulla ricevuta di {0} relativa al protocollo {1} creato in data {2}, {3}", droppedProof ? "annullamento" : "eccezione", senderRecordInfo.RecordNumber, senderRecordInfo.RecordDate, retVal ? "riuscito correttamente" : "non riuscito")); logger.DebugFormat("Salvataggio delle informazioni sulla ricevuta di {0}, per l'interoperabilità semplificata, relativa al protocollo {1} creato in data {2}, {3}", droppedProof ? "annullamento" : "eccezione", senderRecordInfo.RecordNumber, senderRecordInfo.RecordDate, retVal ? "riuscito correttamente" : "non riuscito"); // Recupero dell'id del documento cui si riferisce l'eccezione String idProfile = String.Empty; using (DocsPaDB.Query_DocsPAWS.Documenti docDb = new DocsPaDB.Query_DocsPAWS.Documenti()) { idProfile = docDb.GetIdProfileFromProtoInfo(senderRecordInfo.RecordDate, senderRecordInfo.RecordNumber, senderRecordInfo.AOOCode, senderRecordInfo.AdministrationCode); } // Se è una eccezione, viene inserita una riga nel registro delle ricevute if (!droppedProof) { SaveExceptionInRegistry( String.Empty, InteroperabilitaSemplificataManager.GetUrl(OrganigrammaManager.GetIDAmm(senderRecordInfo.AdministrationCode)), DateTime.Now, idProfile, receiverCode, reason); String userId = BusinessLogic.Documenti.DocManager.GetDocumentAttribute( senderRecordInfo.RecordDate, senderRecordInfo.RecordNumber, senderRecordInfo.AOOCode, senderRecordInfo.AdministrationCode, DocsPaDB.Query_DocsPAWS.Documenti.DocumentAttribute.UserId); //Recupero il ruolo che ha effettuato l'ultima spedizione IS, dallo storico delle spedizioni. ArrayList listHistorySendDoc = SpedizioneManager.GetElementiStoricoSpedizione(idProfile); if (listHistorySendDoc != null && listHistorySendDoc.Count > 0) { Object lastSendIs = (from record in listHistorySendDoc.ToArray() where ((ElStoricoSpedizioni)record).Mail_mittente.Equals("N.A.") select record).ToList().OrderBy(z => ((ElStoricoSpedizioni)z).Id).LastOrDefault(); Ruolo role = UserManager.getRuoloByIdGruppo(((ElStoricoSpedizioni)lastSendIs).IdGroupSender); Utente user = UserManager.getUtente(userId); // LOG per documento string desc = "Notifica di eccezione: " + reason.Replace("’", "'") + "<br/>Destinatario spedizione: " + receiverCode; BusinessLogic.UserLog.UserLog.WriteLog(user.userId, user.idPeople, role.idGruppo, user.idAmministrazione, "EXCEPTION_SEND_SIMPLIFIED_INTEROPERABILITY", idProfile, desc, DocsPaVO.Logger.CodAzione.Esito.OK, null, "1"); } } } }
/// <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 trasmissione del documento ai destinatari interni (utenti che si trovano in ruoli cui sono associate /// le microfunzioni relative all'IS) /// </summary> /// <param name="settings">Impostazioni relative all'interoperabilità semplificata per il registro su cui è stato creato il documento</param> /// <param name="document">Documento da trasmettere</param> /// <param name="userRole">Ruolo utilizzato per la trasmissione</param> /// <param name="user">Utente mittente della trasmissione</param> /// <param name="privateDocument">Flag utilizzato per indicare se il documento è stato ricevuto marcato come privato dal mittente della spedizione</param> /// <param name="receiversInfo">Informaizoni sui destinari da contattare</param> /// <returns>Lista dei destinatari per cui si è verificato un problema</returns> private static List <ReceiverInfo> TransmitDocument(InteroperabilitySettings settings, SchedaDocumento document, Ruolo userRole, Utente user, bool privateDocument, List <ReceiverInfo> receiversInfo) { logger.Debug("RAFFREDDORE - Start"); logger.Debug("RAFFREDDORE - " + (document == null ? "Documento nullo" : document.systemId)); // Recupero delle informazioni sui corrispondenti interni all'amministrazione che devono ricevere // la trasmissione del documento List <Corrispondente> corrs = null; // Lista dei destinatari della spedizione per cui non sono stati individuati destinatari List <ReceiverInfo> uneachableReceivers = new List <ReceiverInfo>(); try { logger.Debug("RAFFREDDORE - prima del caricamento destinatari"); corrs = InteroperabilitaSemplificataManager.LoadTransmissionReceivers(settings, privateDocument, receiversInfo, out uneachableReceivers); if (corrs == null || corrs.Count == 0) { logger.Error("Nessun destinatario trovato per la trasmissione del documento"); throw new RetrivingTransmissionReceiverException("Nessun destinatario trovato per la trasmissione del documento"); } } catch (Exception e) { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(document.systemId, true, e.Message); throw new RetrivingTransmissionReceiverException(e.Message); } // Creazione dell'oggetto trasmissione Trasmissione transmission = new Trasmissione(); transmission.ruolo = userRole; transmission.utente = user; transmission.noteGenerali = receiversInfo.Select(r => r.Code).Aggregate((r1, r2) => String.Format("{0} {1}", r1, r2)); transmission.infoDocumento = new InfoDocumento(document); // Creazione della ragione di trasmissione per interoperabilità semplificata RagioneTrasmissione reason = InteroperabilitaSegnatura.getRagioneTrasm(user.idAmministrazione, "S"); if (reason != null && privateDocument) { reason.eredita = "0"; } if (reason != null) { logger.DebugFormat("IS - Effettuato caricamento della ragione di trasmissione per interoperabilità. Id ragione: {0}; Eredita: {1}", reason.systemId, reason.eredita); } // Creazione delle trasmissioni singole transmission.trasmissioniSingole = new System.Collections.ArrayList(); foreach (var corr in corrs) { // Creazione della trasmissione singola TrasmissioneSingola singleTransmission = new TrasmissioneSingola() { ragione = reason, corrispondenteInterno = corr, tipoTrasm = "S", tipoDest = TipoDestinatario.RUOLO }; // Caricamento degli utenti del ruolo singleTransmission.trasmissioneUtente = new System.Collections.ArrayList(); // Caricamento utenti del ruolo QueryCorrispondente qc = new QueryCorrispondente(); qc.codiceRubrica = ((DocsPaVO.utente.Ruolo)corr).codiceRubrica; qc.idRegistri = new System.Collections.ArrayList(); qc.idRegistri.Add(settings.RegistryId); qc.idAmministrazione = user.idAmministrazione; qc.getChildren = true; qc.fineValidita = true; ArrayList users = addressBookManager.listaCorrispondentiIntMethod(qc); // Costruzione delle trasmissioni utente foreach (Utente u in users) { u.dst = user.dst; singleTransmission.trasmissioneUtente.Add(new TrasmissioneUtente() { utente = u }); } transmission.trasmissioniSingole.Add(singleTransmission); } // Esecuzione della trasmissione try { // INCIDENT 104707 // modifica PALUMBO per consentire invio mail di notifica in caso di trasmissione ricevuta per IS // necessaria chiave "URL_PATH_IS" webconfig ws . string path = String.Empty; if (System.Configuration.ConfigurationManager.AppSettings["URL_PATH_IS"] != null) { path = System.Configuration.ConfigurationManager.AppSettings["URL_PATH_IS"].ToString(); } logger.Debug("RAFFREDDORE - url path is " + path); //ExecTrasmManager.saveExecuteTrasmMethod(String.Empty, transmission); Trasmissione resultTrasm = ExecTrasmManager.saveExecuteTrasmMethod(path, transmission); logger.Debug("RAFFREDDORE - Trasmissione nulla? " + (resultTrasm == null?"Nulla":"NON nulla")); //traccio l'evento di trasmssione string method = string.Empty, desc = string.Empty; if (resultTrasm != null && resultTrasm.infoDocumento != null && !string.IsNullOrEmpty(resultTrasm.infoDocumento.docNumber)) { List <string> includedList = new List <string>(); string idCorr = string.Empty; foreach (DocsPaVO.trasmissione.TrasmissioneSingola single in resultTrasm.trasmissioniSingole) { logger.Warn("DEBUG: WriteLog-IS- " + resultTrasm.utente.userId + " " + resultTrasm.infoDocumento.docNumber + " " + resultTrasm.utente.idPeople + " " + resultTrasm.ruolo.idGruppo + " " + resultTrasm.utente.idAmministrazione + " " + resultTrasm.utente.idPeople + " " + method + " " + desc + " " + single.systemId); method = "TRASM_DOC_" + single.ragione.descrizione.ToUpper().Replace(" ", "_"); desc = "Trasmesso Documento predisposto in arrivo : " + resultTrasm.infoDocumento.docNumber.ToString(); idCorr = single.corrispondenteInterno.systemId; if (!includedList.Contains(idCorr)) { BusinessLogic.UserLog.UserLog.WriteLog(resultTrasm.utente.userId, resultTrasm.utente.idPeople, resultTrasm.ruolo.idGruppo, resultTrasm.utente.idAmministrazione, method, resultTrasm.infoDocumento.docNumber, desc, DocsPaVO.Logger.CodAzione.Esito.OK, null, "1", single.systemId); includedList.Add(idCorr); } else { BusinessLogic.UserLog.UserLog.WriteLog(resultTrasm.utente.userId, resultTrasm.utente.idPeople, resultTrasm.ruolo.idGruppo, resultTrasm.utente.idAmministrazione, method, resultTrasm.infoDocumento.docNumber, desc, DocsPaVO.Logger.CodAzione.Esito.OK, null, "0", single.systemId); } logger.Warn("DEBUG: WriteLog-IS- OK"); } } } catch (Exception e) { logger.Error("RAFFREDDORE - Errore durante la trasmissione del documento ai destinatari"); SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(document.systemId, true, "Errore nella trasmissione del documento ai ruoli designati"); throw new ExecuteTransmissionException("Errore durante la trasmissione del documento ai destinatari"); } // Se si è arrivati fin qui la trasmissione è stata effettuata correttamente, quindi viene aggiunta // una voce al log SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(document.systemId, false, String.Format("Documento con id {0} trasmesso correttamente ai destinatari", document.systemId)); // Restituzione dei corrispondenti non troviati return(uneachableReceivers); }
/// <summary> /// Metodo per l'aggiunta degli allegati ad un documento /// </summary> /// <param name="docNumber">Numero del documento cui aggiungere gli allegati</param> /// <param name="attachments">Informazioni sugli allegati da creare</param> /// <param name="userInfo">Informazioni sull'utente utilizzato per la creazione del predisposto in ingresso</param> /// <param name="senderAdministrationId">Id dell'amministrazione mittente della richiesta di interoperabilità</param> /// <param name="senderFileManagerUrl">Url del file manager per il download dell'eventuale file associato ad un allegato</param> private static void AddAttachments(String docNumber, List <DocumentInfo> attachments, InfoUtente userInfo, String senderAdministrationId, String senderFileManagerUrl) { int i = 0; foreach (DocumentInfo attachment in attachments) { // Creazione dell'oggetto allegato Allegato a = new Allegato(); // Impostazione delle proprietà dell'allegato if (String.IsNullOrEmpty(attachment.Name)) { a.descrizione = String.Format("Allegato {0}", i); } else { a.descrizione = attachment.Name; } a.docNumber = docNumber; a.fileName = InteroperabilitaSegnatura.getFileName(attachment.FileName); a.version = "0"; a.numeroPagine = attachment.NumberOfPages; // Aggiunta dell'allegato al documento principale try { a = AllegatiManager.aggiungiAllegato(userInfo, a); } catch (Exception ex) { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog( docNumber, true, String.Format("Errore durante l'aggiunta dell'allegato '{0}'. Messaggio eccezione: {1}", a.descrizione, ex.Message)); throw new CreatingDocumentException( String.Format("Errore durante l'aggiunta dell'allegato '{0}'", attachment.Name)); } string errPutFile = ""; try { // Associazione dell'immagine all'allegato FileRequest request = a as FileRequest; if (!String.IsNullOrEmpty(attachment.FileName)) { SimplifiedInteroperabilityFileManager.DownloadFile( attachment, senderAdministrationId, request, userInfo, senderFileManagerUrl, out errPutFile); } if (!string.IsNullOrEmpty(errPutFile)) { throw new Exception("Errore durante l'associazione dell'immagine al documento principale"); } } catch (Exception e) { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog( a.docNumber, true, String.Format("Errore durante l'associazione dell'immagine per l'allegato '{0}'. Messaggio eccezione: {1}", a.descrizione, e.Message)); if (!string.IsNullOrEmpty(errPutFile) && errPutFile.Contains("formato file")) { throw new DownloadDocumentException( String.Format("Errore durante l'associazione dell'immagine all'allegato '{0}'. {1} destinataria.", attachment.Name, errPutFile)); } else { throw new DownloadDocumentException( String.Format("Errore durante l'associazione dell'immagine all'allegato '{0}'", attachment.Name)); } } i++; } }
/// <summary> /// Creazione del documento nel sistema /// </summary> /// <param name="settings">Impostazioni relative al registro su cui creare il documento</param> /// <param name="senderInfo">Informazioni sul mittente della richiesta</param> /// <param name="interoperabilityMessage">Messaggio con le informazioni sulla richiesta di interoperabilità</param> /// <param name="userRole">Ruolo dell'utente da utilizzare per la creazione del documento</param> /// <param name="user">Utente da utilizzare per la creazione del documento</param> /// <returns>Scheda del documento creato</returns> private static SchedaDocumento CreateDocument(InteroperabilitySettings settings, Corrispondente senderInfo, InteroperabilityMessage interoperabilityMessage, Ruolo userRole, Utente user, String messageId) { // Recupero delle informazioni sull'utente da utilizzare come creatore del documento InfoUtente userInfo = UserManager.GetInfoUtente(user, userRole); // Creazione della scheda documento da restituire SchedaDocumento document = DocManager.NewSchedaDocumento(userInfo); // Recupero del registro su cui creare il predisposto Registro registry = RegistriManager.getRegistro(settings.RegistryId); // Recupero del mezzo di spedizione MezzoSpedizione channel = InfoDocManager.GetMezzoSpedizioneDaCodice("SIMPLIFIEDINTEROPERABILITY"); // Impostazione delle proprietà del documento try { if (!String.IsNullOrEmpty(interoperabilityMessage.MainDocument.FileName)) { document.appId = InteroperabilitaSegnatura.getApp(interoperabilityMessage.MainDocument.FileName).application; } } catch (Exception e) {} document.idPeople = user.idPeople; document.userId = user.userId; document.oggetto = new Oggetto() { descrizione = interoperabilityMessage.Record.Subject }; document.predisponiProtocollazione = true; document.registro = registry; document.tipoProto = "A"; document.typeId = "SIMPLIFIEDINTEROPERABILITY"; document.mezzoSpedizione = channel.IDSystem; document.descMezzoSpedizione = channel.Descrizione; document.interop = "S"; document.protocollatore = new Protocollatore(userInfo, userRole); document.privato = interoperabilityMessage.IsPrivate ? "1" : "0"; // Se la gestione dell'interoperabilità è manuale con mantenimento // del documento pendente, il documento viene creato privato e subito dopo // la creazione viene rimarcato come non privato if (settings.ManagementMode == ManagementType.M && settings.KeepPrivate) { document.privato = "1"; } // Preparazione dell'oggetto protocollo entrata ProtocolloEntrata proto = new ProtocolloEntrata(); proto.mittente = senderInfo; proto.dataProtocolloMittente = interoperabilityMessage.Record.RecordDate.ToString("dd/MM/yyyy HH:mm:ss"); proto.descrizioneProtocolloMittente = String.Format("{0}{1}{2}", interoperabilityMessage.Record.AOOCode, DocsPaDB.Utils.Personalization.getInstance(registry.idAmministrazione).getSepSegnatura(), interoperabilityMessage.Record.RecordNumber); document.protocollo = proto; // Se per l'amministrazione è configurata l'aggiunta di una nota visibile a tutti, // ne viene aggiunta una String value = DocsPaUtils.Configuration.InitConfigurationKeys.GetValue("0", "BE_NOTE_IN_SEGNATURA"); if (!String.IsNullOrEmpty(value) && value == "1" && !String.IsNullOrEmpty(interoperabilityMessage.Note)) { document.noteDocumento = new List <DocsPaVO.Note.InfoNota>() { new DocsPaVO.Note.InfoNota(interoperabilityMessage.Note, userInfo.idPeople, userInfo.idGruppo, DocsPaVO.Note.TipiVisibilitaNotaEnum.Tutti, String.Empty) { DaInserire = true } } } ; // Salvataggio del documento try { document = DocSave.addDocGrigia(document, userInfo, userRole); // Associazione del canale di spedizione al documento ProtoManager.collegaMezzoSpedizioneDocumento(userInfo, channel.IDSystem, document.systemId); } catch (Exception e) { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(String.Empty, true, e.Message + " Id messaggio: " + messageId); throw new CreatingDocumentException("Errore durante la creazione del documento"); } // Se tutto è andato bene, la scheda documento ha ora il campo system id popolato, quindi viene aggiunta // una voce al log e viene aggiornato l'id profile per la voce nel registro dei messaggi ricevuti SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(document.systemId, false, String.Format("Documento relativo alla richiesta con id {0}, creato correttamente.", messageId)); SimplifiedInteroperabilityLogAndRegistryManager.SetIdProfileForMessage(messageId, document.systemId); // Impostazione delle informazioni aggiuntive e salvataggio del documento ((Documento)document.documenti[0]).dataArrivo = DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss"); bool toUpdate; document = DocSave.save(userInfo, document, false, out toUpdate, userRole); string errPutFile = ""; try { // Associazione dell'immagine al documento String err = String.Empty; FileRequest request = document.documenti[0] as FileRequest; logger.DebugFormat("IS - Associa documento. Versionid {0}, Versionlabel {1}, version {2}", request.versionId, request.versionLabel, request.version); if (!String.IsNullOrEmpty(interoperabilityMessage.MainDocument.FileName)) { SimplifiedInteroperabilityFileManager.DownloadFile( interoperabilityMessage.MainDocument, interoperabilityMessage.Sender.AdministrationId, request, userInfo, interoperabilityMessage.Sender.FileManagerUrl, out errPutFile); } if (!string.IsNullOrEmpty(errPutFile)) { throw new Exception("Errore durante l'associazione dell'immagine al documento principale"); } } catch (Exception e) { SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog( document.systemId, true, String.Format("Errore durante l'associazione dell'immagine per il documento principale. Messaggio eccezione: {0}", e.Message)); if (!string.IsNullOrEmpty(errPutFile) && errPutFile.Contains("formato file")) { throw new DownloadDocumentException("Errore durante l'associazione dell'immagine al documento principale." + errPutFile + " destinataria."); } else { throw new DownloadDocumentException("Errore durante l'associazione dell'immagine al documento principale"); } } AddAttachments(document.docNumber, interoperabilityMessage.Attachments, userInfo, interoperabilityMessage.Sender.AdministrationId, interoperabilityMessage.Sender.FileManagerUrl); // Restituzione del documento salvato return(document); }
/// <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); }