/// <summary> /// Metodo per l'invio della ricevuta /// </summary> /// <param name="sender">Informazioni sul mittente della spedizione</param> /// <param name="receiver">Informazioni sul destinatario della spedizione</param> /// <param name="senderUrl">Url del mittente</param> /// <param name="reason">Ragione di annullamento o dettaglio dell'eccezione</param> /// <param name="adminId">Id dell'amministrazione</param> /// <param name="dropped">Flag utilizzato per indicare se si deve inviare una richiesta di eliminazione</param> /// <param name="receiverCode">Codice del destinatario</param> private static void SendProof(RecordInfo sender, RecordInfo receiver, string senderUrl, String reason, String adminId, bool dropped, String receiverCode) { InteroperabilityController interoperabilityController = new InteroperabilityController(); interoperabilityController.AnalyzeDocumentDroppedOrErrorProof( new Interoperability.Domain.RecordInfo() { AdministrationCode = sender.AdministrationCode, AOOCode = sender.AOOCode, RecordDate = sender.RecordDate, RecordNumber = sender.RecordNumber }, new Interoperability.Domain.RecordInfo() { AdministrationCode = receiver.AdministrationCode, AOOCode = receiver.AOOCode, RecordDate = receiver.RecordDate, RecordNumber = receiver.RecordNumber }, reason, InteroperabilitaSemplificataManager.GetUrl(adminId), senderUrl, dropped ? Interoperability.Domain.OperationDiscriminator.Drop : Interoperability.Domain.OperationDiscriminator.Error, receiverCode); }
/// <summary> /// Metodo per la creazione delle informazioni sul mittente della spedizione /// </summary> /// <param name="schedaDocumento">Documento da cui estrarre le informazioni</param> /// <param name="infoUtente">Informazioni sull'utente richiedente</param> /// <param name="destinatari">Lista dei destinatari della spedizione</param> /// <returns>Informazioni sul mittente della spedizione</returns> private SenderInfo CreateSendersInfo(SchedaDocumento schedaDocumento, InfoUtente infoUtente, Corrispondente[] destinatari) { // Recupero del codice del mittente String senderCode = InteroperabilitaSemplificataManager.LoadSenderInfoFromUoId(((ProtocolloUscita)schedaDocumento.protocollo).mittente.systemId); // Se il mittente non è interoperante o se non è presente in RC, non si può procedere con la spedizione if (!InteroperabilitaSemplificataManager.IsCorrEnabledToInterop( ((ProtocolloUscita)schedaDocumento.protocollo).mittente.systemId) || RubricaComune.RubricaServices.GetElementoRubricaComune(infoUtente, senderCode, false) == null) { throw new SenderNotInteroperableException(); } SenderInfo senderInfo = new SenderInfo() { AdministrationId = infoUtente.idAmministrazione, //Code = String.Format("{0}-{1}", // ((ProtocolloUscita)schedaDocumento.protocollo).mittente.codiceAmm, // ((ProtocolloUscita)schedaDocumento.protocollo).mittente.descrizione), Code = senderCode, Url = InteroperabilitaSemplificataManager.GetUrl(infoUtente.idAmministrazione), UserId = infoUtente.userId, FileManagerUrl = InteroperabilitaSemplificataManager.GetFileManagerUrl(schedaDocumento.registro.idAmministrazione) }; return(senderInfo); }
/// <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'invio di una richiesta di generazione di una ricevuta di annullamento o eccezione realtiva ad un documento ricevuto per IS /// </summary> /// <param name="reason">Ragione di annullamento o dettaglio dell'eccezione</param> /// <param name="documentId">Id del documento</param> /// <param name="adminCode">Codice dell'amministrazione</param> /// <param name="dropped">Flag utilizzato per indicare se il documento è stato cancellato</param> /// <returns>Esito dell'operazione</returns> public static bool SendDocumentDroppedOrExceptionProofToSender(String reason, String documentId, String adminCode, bool dropped) { bool sendSucceded = false; String ammId = new DocsPaDB.Query_DocsPAWS.Amministrazione().GetIDAmm(adminCode); // Se non è attiva l'interoperabilità semplificata non si può procedere if (InteroperabilitaSemplificataManager.IsEnabledSimplifiedInteroperability(ammId)) { sendSucceded = GenerateAndSendProof(reason, documentId, ammId, dropped); } return(sendSucceded); }
/// <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'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 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); }