/// <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);
}
