/// <summary>
/// Metodo per il caricamento delle impostazioni di interoperabilità semplificata per un registro / RF
/// </summary>
/// <param name="registryId">Id del registro / RF</param>
/// <returns>Impostazioni</returns>
public static InteroperabilitySettings LoadSettings(String registryId)
{
logger.DebugFormat("Caricamento impostazioni di interoperabilità semplificata per il registro con id {0}",
registryId);
InteroperabilitySettings loadedData = null;
using (DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata interoperabilitaSemplificataDb = new DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata())
{
loadedData = interoperabilitaSemplificataDb.LoadSettings(registryId);
}
logger.DebugFormat("Caricamento impostazioni di interoperabilità semplificata per il registro con id {0}, {1}",
registryId,
loadedData != null ? "effettuato con successo" : "non riuscito.");
return(loadedData);
}
/// <summary>
/// Metodo per la validazione dei dati da salvare
/// </summary>
/// <param name="interoperabilitySettings">Impostazioni da salvare</param>
private static void ValidateData(InteroperabilitySettings interoperabilitySettings)
{
SimplifiedInteroperabilitySaveSettingsException exc = new SimplifiedInteroperabilitySaveSettingsException();
// Se è attiva l'interoperabilità ma non c'è nè un ruolo nè un utente impostato per la creazione del
// predisposto
if (interoperabilitySettings.IsEnabledInteroperability && interoperabilitySettings.RoleId == 0 &&
interoperabilitySettings.UserId == 0)
{
exc.AddInvalidField("Specificare ruolo e utente da utilizzare per la creazione del documento predisposto");
}
// Se c'è almeno un avviso, viene lanciata l'eccezione
if (exc.GetInvalidFields().Count > 0)
{
throw exc;
}
}
/// <summary>
/// Metodo per il salvataggio delle impostazioni relative all'interoperabilità semplificata
/// </summary>
/// <param name="interoperabilitySettings">Impostazioni da salvare</param>
/// <returns>Esito del sdalvataggio</returns>
public static bool SaveSettings(InteroperabilitySettings interoperabilitySettings)
{
logger.DebugFormat("Salvataggio impostazioni di interoperabilità semplificata per il registro con id {0}",
interoperabilitySettings.RegistryId);
// Validazione dei dati prima di salvare
ValidateData(interoperabilitySettings);
bool saved = false;
using (DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata interoperabilitaSemplificataDb = new DocsPaDB.Query_DocsPAWS.InteroperabilitaSemplificata())
{
saved = interoperabilitaSemplificataDb.SaveSettings(interoperabilitySettings);
}
logger.DebugFormat("Salvataggio impostazioni di interoperabilità semplificata per il registro con id {0}, {1}",
interoperabilitySettings.RegistryId,
saved ? "effettuato con successo" : "non riuscito.");
return(saved);
}
/// <summary>
/// Metodo per il caricamento delle impostazioni relative ad registro
/// </summary>
/// <param name="registryId">Id del registro</param>
/// <returns>Impostazioni</returns>
public InteroperabilitySettings LoadSettings(String registryId)
{
InteroperabilitySettings retVal = new InteroperabilitySettings();
int roleId = 0, userId = 0, isEnabledInteroperability = 0, keepPrivate = 0;
String managementMode = String.Empty;
using (DBProvider dbProvider = new DBProvider())
{
ArrayList parameters = new ArrayList();
parameters.Add(new ParameterSP("RegistryId", registryId, 100, DirectionParameter.ParamInput, System.Data.DbType.Int32));
parameters.Add(new ParameterSP("RoleId", roleId, 100, DirectionParameter.ParamOutput, System.Data.DbType.Int32));
parameters.Add(new ParameterSP("UserId", userId, 100, DirectionParameter.ParamOutput, System.Data.DbType.Int32));
parameters.Add(new ParameterSP("IsEnabledInteroperability", isEnabledInteroperability, 100, DirectionParameter.ParamOutput, System.Data.DbType.Int32));
parameters.Add(new ParameterSP("KeepPrivate", keepPrivate, 100, DirectionParameter.ParamOutput, System.Data.DbType.Int32));
parameters.Add(new ParameterSP("ManagementMode", managementMode, 100, DirectionParameter.ParamOutput, System.Data.DbType.AnsiString));
if (dbProvider.ExecuteStoredProcedure("IS_LoadSettings", parameters, null) == 1)
{
// Lettura dei valori aggiornati
ParameterSP[] convertedParams = (ParameterSP[])parameters.ToArray(typeof(ParameterSP));
roleId = Int32.Parse(convertedParams.Where(p => p.Nome == "RoleId").First().Valore.ToString());
userId = Int32.Parse(convertedParams.Where(p => p.Nome == "UserId").First().Valore.ToString());
isEnabledInteroperability = Int32.Parse(convertedParams.Where(p => p.Nome == "IsEnabledInteroperability").First().Valore.ToString());
keepPrivate = Int32.Parse(convertedParams.Where(p => p.Nome == "KeepPrivate").First().Valore.ToString());
managementMode = convertedParams.Where(p => p.Nome == "ManagementMode").First().Valore.ToString();
}
}
return(new InteroperabilitySettings()
{
IsEnabledInteroperability = isEnabledInteroperability == 1,
RegistryId = registryId,
RoleId = roleId,
UserId = userId,
KeepPrivate = keepPrivate == 1,
ManagementMode = String.IsNullOrEmpty(managementMode) ?
ManagementType.M : (ManagementType)Enum.Parse(typeof(ManagementType), managementMode)
});
}
/// <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>
/// 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);
}
