private static void AcquireFileFromModel(DocumentRowData rowData, InfoUtente userInfo, Ruolo role, bool isSmistamentoEnabled, SchedaDocumento schedaDocumento, string ftpAddress, String ftpUsername, String ftpPassword)
{
// L'oggetto fileRequest
FileRequest fileRequest;
// L'oggetto fileDocumento
FileDocumento fileDocumento;
string tipologia = rowData.DocumentTipology;
TemplateManager tempManager = new TemplateManager(userInfo, role, isSmistamentoEnabled, tipologia, TemplateType.RTF);
byte[] content = tempManager.BuildDocumentFromTemplate(rowData, schedaDocumento);
// Creazione dell'oggetto fileDocumento
fileDocumento = new FileDocumento();
// Impostazione del nome del file
fileDocumento.name = Path.GetFileName(schedaDocumento.systemId + ".rtf");
// Impostazione del full name
fileDocumento.fullName = schedaDocumento.systemId + ".rtf";
fileDocumento.estensioneFile = "rtf";
// Impostazione del path
//fileDocumento.path = Path.GetPathRoot(rowData.Pathname);
// Impostazione della grandezza del file
fileDocumento.length = content.Length;
// Impostazione del content del documento
fileDocumento.content = content;
fileRequest = (FileRequest)schedaDocumento.documenti[0];
try
{
FileManager.putFile(fileRequest, fileDocumento, userInfo);
}
catch (Exception e)
{
// Aggiunta del problema alla lista dei problemi
throw new Exception("Errore durante l'upload del file.");
}
}
/// <summary>
/// Funzione per l'estrazione dei dati da una riga del foglio excel
/// </summary>
/// <param name="row">L'oggetto da cui estrarre i dati</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <returns>L'oggetto con i dati estratti</returns>
private DocumentRowData ReadDataFromCurrentRow(OleDbDataReader row, InfoUtente userInfo, Ruolo role)
{
#region Dichiarazione Variabili
// L'oggetto da restituire
DocumentRowData toReturn;
#endregion
// Creazione dell'oggetto da restituire
toReturn = new DocumentRowData();
// Prelevamento dell'ordinale
toReturn.OrdinalNumber = row["Ordinale"].ToString();
// Prelevamento del codice amministrazione
toReturn.AdminCode = row["Codice Amministrazione"].ToString();
// Prelevamento dell'ordinale del documento principale
toReturn.MainOrdinal = row["Ordinale principale"].ToString().Trim();
// Prelevamento della descrizione dell'allegato
toReturn.Obj = row["Descrizione"].ToString().Trim();
// Prelevamento del pathname
toReturn.Pathname = row["Pathname"].ToString().Trim();
// Restituzione dell'oggetto creato
return(toReturn);
}
public static ImportResult ImportAndAcquireDocument(
DocumentRowData documentToImport,
ProtoType protoType,
string serverPath,
InfoUtente userInfo,
Ruolo role,
ref ResultsContainer resultsContainer)
{
// Impostazione del timeout ad infinito
ws.Timeout = System.Threading.Timeout.Infinite;
// Lettura del valore di configurazione utilizzato per indicare
// se è obbligatoria la profilazione del documento
bool isProfilationRequired = false;
//Boolean.TryParse(
// ConfigurationManager.AppSettings["TIPO_ATTO_REQUIRED"],
// out isProfilationRequired);
string idAmm = userInfo.idAmministrazione;
if (DocumentManager.GetTipoDocObbl(idAmm).Equals("1"))
{
isProfilationRequired = true;
}
// Lettura del valore di configurazione utilizzato per indicare
// se è obbligatoria la classificazione del documento
bool isClassificationRequired = false;
if (!string.IsNullOrEmpty(Utils.InitConfigurationKeys.GetValue(UserManager.GetInfoUser().idAmministrazione, DBKeys.FE_FASC_RAPIDA_REQUIRED.ToString())))
{
isClassificationRequired = bool.Parse(Utils.InitConfigurationKeys.GetValue(UserManager.GetInfoUser().idAmministrazione, DBKeys.FE_FASC_RAPIDA_REQUIRED.ToString()));
}
try
{
// Chiamata del webservice per l'importazione dei documenti da
// foglio Excel e restituzione della lista dei risultati
return(ws.ImportAndAcquireDocument(
documentToImport,
protoType,
serverPath,
userInfo,
role,
isProfilationRequired,
isClassificationRequired,
false,
ref resultsContainer,
importazionePregressiAbilitata()));
}
catch (Exception e)
{
throw new Exception("Ricevuto errore dal servizio.");
}
}
/// <summary>
/// Funzione per la creazione dell'allegato
/// </summary>
/// <param name="rowData">L'oggetto con le informazioni sull'allegato da creare</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <param name="identificationData">I dati identificativi dell'allegato</param>
/// <param name="sharedDirectoryPath">Il path i cui è posizionato il file da allegare al documento</param>
/// <param name="importResults">L'oggetto con le informazioni sul documento cui si desidera aggiungere l'allegato</param>
protected void CreateDocument(DocumentRowData rowData, InfoUtente userInfo, Ruolo role, out string identificationData, string ftpAddress, ImportResult importResults, String ftpUsername, String ftpPassword)
{
#region Dichiarazione variabili
// L'allegato da agggiungere
Allegato attachment = null;
#endregion
// Se il documento non è stato creato, eccezione
if (String.IsNullOrEmpty(importResults.DocNumber))
{
throw new Exception("Il documento cui si desidera aggiungere un allegato non è stato creato con successo.");
}
// Creazione dell'oggetto Allegato
attachment = this.CreateAttachmentObject(
rowData.Obj,
importResults.DocNumber);
// Aggiunta dell'allegato al documento
try
{
AllegatiManager.aggiungiAllegato(userInfo, attachment);
}
catch
{
throw new Exception("Errore durante l'aggiunta dell'allegato al documento specificato.");
}
// Acquisizione del file (se specificato il path)
if (!String.IsNullOrEmpty(rowData.Pathname))
{
this.AcquireFile(
rowData.Pathname,
rowData.AdminCode,
userInfo,
ftpAddress,
attachment,
ftpUsername,
ftpPassword,
rowData);
}
// Impostazione delle informazioni sull'allegato creato
identificationData = String.Format(
"Id documento: {0}",
attachment.docNumber);
}
/// <summary>
/// Funzione per la validazione dei dati
/// </summary>
/// <param name="rowData">L'oggetto con i dati da validare</param>
/// <param name="validationProblems">La lista dei problemi riscontrati in fase di validazione</param>
/// <returns>True se la validazione passa</returns>
private bool CheckDataValidity(DocumentRowData rowData, out List <string> validationProblems)
{
#region Dichiarazione variabili
// Il risultato della validazione
bool toReturn = true;
// La lista dei problemi rilevati in fase di validazione
List <String> validationResult;
#endregion
// Creazione della lista dei problemi di validazione
validationResult = new List <string>();
// L'ordinale è obbligatorio
if (String.IsNullOrEmpty(rowData.OrdinalNumber))
{
toReturn = false;
validationResult.Add("Il campo 'Ordinale' è obbligatorio.");
}
// L'ordinale del documento principale è obbligatorio
if (String.IsNullOrEmpty(rowData.MainOrdinal))
{
toReturn = false;
validationResult.Add("Il campo 'Ordinale documento principale' è obbligatirio");
}
// Il codice amministrazione è obbligatorio
if (String.IsNullOrEmpty(rowData.AdminCode))
{
toReturn = false;
validationResult.Add("Il campo 'Codice Amministrazione' è obbligatirio");
}
// La descrizione è obbligatoria
if (String.IsNullOrEmpty(rowData.Obj))
{
toReturn = false;
validationResult.Add("Il campo 'Descrizione' è obbligatorio");
}
// Impostazione della lista dei problemi
validationProblems = validationResult;
// Restituzione del risultato di validazione
return(toReturn);
}
/// <summary>
/// Funzione per la creazione dell'oggetto protocollo in entrata
/// </summary>
/// <param name="rowData">L'oggetto con le informazioni sul documento da creare</param>
/// <param name="registrySyd">Il system id del registo in cui protocollare</param>
/// <param name="rfSyd">Il system id dell'rf in cui protocollare</param>
/// <param name="administrationSyd">Il system id dell'amministrazione incui creare il documento</param>
/// <param name="isSmistamentoEnabled">True se, da configurazione, è abilitato lo smistamento</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo dell'utente che ha lanciato la procedura</param>
/// <returns>L'oggetto Protocollo con le informazioni sul protocollo in ingresso da creare</returns>
protected override Protocollo CreateProtocolObject(DocumentRowData rowData, string registrySyd, string rfSyd, string administrationSyd, bool isSmistamentoEnabled, InfoUtente userInfo, Ruolo role)
{
// Creazione dell'oggetto ProtocolloEntrata
ProtocolloEntrata inProto = new ProtocolloEntrata();
// Calcolo del mittente del protocollo
// Se è valorizzata la proprietà CorrDesc della rowData, significa che
// il corrispondente è di tipo occasionale
if (rowData.CorrDesc != null && rowData.CorrDesc.Count > 0)
{
// Creazione del corrispondente
inProto.mittente = new Corrispondente();
// Impostazione della descrizione del corrispondente
inProto.mittente.descrizione = rowData.CorrDesc[0];
// Impostazione dell'id amministrazione
inProto.mittente.idAmministrazione = administrationSyd;
// Impostazione del tipo corrispondente ad O
inProto.mittente.tipoCorrispondente = "O";
}
if (rowData.CorrCode != null && rowData.CorrCode.Count > 0)
{
// Altrimenti si procede con il caricamento delle informazioni sul
// corrispondente
inProto.mittente = ImportUtils.GetCorrispondenteByCode(
ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_IN,
rowData.CorrCode[0].Trim(),
role,
userInfo,
registrySyd,
rfSyd,
isSmistamentoEnabled,
TipoUtente.GLOBALE);
}
// Se non è stato ptrovato il corrispondente, eccezione
if (inProto.mittente == null)
{
throw new Exception("Impossibile recuperare le informazioni sul mittente del protocollo.");
}
// Restituzione dell'oggetto con le informazioni sul protocollo
return(inProto);
}
/// <summary>
/// Funzione per l'importazione di un documento RDE
/// </summary>
/// <param name="rowData">L'oggetto con i dati sul documento da importare</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <param name="serverPath">L'indirizzo della WA</param>
/// <param name="isSmistamentoEnabled">True se è abilito lo smistamento</param>
/// <param name="protoType">Il tipo di documento da creare</param>
/// <returns>Il riusltato dell'importazione</returns>
public static ImportResult ImportRDEDocument(
DocumentRowData rowData,
InfoUtente userInfo,
Ruolo role,
string serverPath,
ProtoType protoType)
{
// Instanziazione del web service
DocsPaWebService ws = new DocsPaWebService();
// Impostazione del timeout ad infinito
ws.Timeout = System.Threading.Timeout.Infinite;
// Lettura del valore di configurazione utilizzato per indicare
// se è obbligatoria la classificazione del documento
bool isClassificationRequired = false;
string valoreChiaveFasc = utils.InitConfigurationKeys.GetValue(UserManager.getInfoUtente().idAmministrazione, "FE_FASC_RAPIDA_REQUIRED");
if (string.IsNullOrEmpty(valoreChiaveFasc))
{
valoreChiaveFasc = "false";
}
Boolean.TryParse(
valoreChiaveFasc,
out isClassificationRequired);
try
{
// Chiamata del webservice per l'importazione RDE e restituzione
// della lista dei risultati
return(ws.ImportRDEDocument(
rowData,
userInfo,
role,
serverPath,
isClassificationRequired,
Utils.getAbilitazioneSmistamento() == "1",
false,
protoType));
}
catch (Exception e)
{
throw new Exception("Ricevuto errore dal servizio.");
}
}
/// <summary>
/// Funzione per l'importazione di un documento RDE
/// </summary>
/// <param name="rowData">L'oggetto con i dati sul documento da importare</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <param name="serverPath">L'indirizzo della WA</param>
/// <param name="isSmistamentoEnabled">True se è abilito lo smistamento</param>
/// <param name="protoType">Il tipo di documento da creare</param>
/// <returns>Il riusltato dell'importazione</returns>
public static ImportResult ImportRDEDocument(
DocumentRowData rowData,
InfoUtente userInfo,
Ruolo role,
string serverPath,
ProtoType protoType)
{
// Impostazione del timeout ad infinito
ws.Timeout = System.Threading.Timeout.Infinite;
// Lettura del valore di configurazione utilizzato per indicare
// se è obbligatoria la classificazione del documento
bool isClassificationRequired = false;
if (!string.IsNullOrEmpty(Utils.InitConfigurationKeys.GetValue(UserManager.GetInfoUser().idAmministrazione, DBKeys.FE_FASC_RAPIDA_REQUIRED.ToString())))
{
isClassificationRequired = bool.Parse(Utils.InitConfigurationKeys.GetValue(UserManager.GetInfoUser().idAmministrazione, DBKeys.FE_FASC_RAPIDA_REQUIRED.ToString()));
}
try
{
// Chiamata del webservice per l'importazione RDE e restituzione
// della lista dei risultati
return(ws.ImportRDEDocument(
rowData,
userInfo,
role,
serverPath,
isClassificationRequired,
false,
false,
protoType));
}
catch (Exception e)
{
throw new Exception("Ricevuto errore dal servizio.");
}
}
/// <summary>
/// Funzione per la validazione dei dati
/// </summary>
/// <param name="rowData">L'oggetto con i dati da validare</param>
/// <param name="isProfilationRequired">True se è richiesta la profilazione obbligatoria</param>
/// <param name="isRapidClassificationRequired">True se è richiesta la classificazione rapida obbligatoria</param>
/// <param name="validationProblems">Lista dei problemi verificatisi in fase di validazione dei dati</param>
/// <returns>True se la validazione passa</returns>
protected override bool CheckDataValidity(DocumentRowData rowData, bool isProfilationRequired, bool isRapidClassificationRequired, out List <string> validationProblems)
{
#region Dichiarazione variabili
// Il risultato della validazione
bool validationResult = true;
#endregion
// Creazione della lista dei problemi
validationProblems = new List <string>();
// L'ordinale è obbligatorio
if (String.IsNullOrEmpty(rowData.OrdinalNumber))
{
validationResult = false;
validationProblems.Add("Campo 'Ordinale' obbligatorio.");
}
// Il codice amministrazione è obbligatorio
if (String.IsNullOrEmpty(rowData.AdminCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice amministrazione' obbligatorio.");
}
// Il codice registro è obbligatorio
if (String.IsNullOrEmpty(rowData.RegCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice Registro' obbligatorio.");
}
// Se entrambi i campi 'Oggetto' e 'Codice Oggetto' non
// sono valorizzati, la validazione non passa
if (String.IsNullOrEmpty(rowData.ObjCode) &&
String.IsNullOrEmpty(rowData.Obj))
{
validationResult = false;
validationProblems.Add("Non risultano valorizzati nè il campo 'Codice Oggetto' nè il campo 'Oggetto'. Valorizzare uno dei due.");
}
// Se entrambi i campi 'Oggetto' e 'Codice oggetto' sono valorizzati, errore
if (!String.IsNullOrEmpty(rowData.ObjCode) &&
!String.IsNullOrEmpty(rowData.Obj))
{
validationResult = false;
validationProblems.Add("Risultano valorizzati entrambi i campi 'Codice Oggetto' e 'Oggetto'. Valorizzare solamente uno.");
}
// Se il campo 'Codice Fascicolo' del foglio excel è valorizzato, ed
// è valorizzata anche la profilazione del fascicolo, errore in quanto non è possibile
// valorizzarli entrambi
if (rowData.ProjectCodes != null && rowData.ProjectCodes.Length > 0 &&
(!String.IsNullOrEmpty(rowData.ProjectDescription) ||
!String.IsNullOrEmpty(rowData.FolderDescrition) ||
!String.IsNullOrEmpty(rowData.NodeCode) ||
!String.IsNullOrEmpty(rowData.ProjectTipology)))
{
validationResult = false;
validationProblems.Add("Risultano valorizzati sia i campi 'Codice Fascicolo' che i campi riguardanti la specifica del fascicolo. Non è possibile specificarli entambi.");
}
// Se è richiesta profilazione del documento obbligatoria
// ma non è valorizzato il campo 'Tipologia Documento', la validazione
// non deve passare
if (isProfilationRequired && String.IsNullOrEmpty(rowData.DocumentTipology))
{
validationResult = false;
validationProblems.Add("La profilazione del documento è obbligatoria ma non risulta valorizzato il campo 'Tipologia Documento'");
}
// Se è richiesta fascicolazione rapida obbligatoria ma non sono specificati
// dati in 'Codice Fascicolo' o nei campi dedicati al fascicolo
if (isRapidClassificationRequired &&
rowData.ProjectCodes == null &&
String.IsNullOrEmpty(rowData.ProjectDescription) &&
String.IsNullOrEmpty(rowData.FolderDescrition) &&
String.IsNullOrEmpty(rowData.NodeCode) &&
String.IsNullOrEmpty(rowData.ProjectTipology))
{
validationResult = false;
validationProblems.Add("La classificazione è obbligatoria ma non risultano valorizzati nè il campo 'Codice Fascicolo' nè i campi dedicati alla classificazione.");
}
// Retituzione del risultato di validazione
return(validationResult);
}
/// <summary>
/// Funzione per la creazione dell'oggetto protocollo in Ingresso
/// </summary>
/// <param name="rowData">L'oggetto con le informazioni sul documenti interno da creare</param>
/// <param name="registrySyd">Il system id del registro</param>
/// <param name="rfSyd">Il system id dell'RF</param>
/// <param name="administrationSyd">Il system id dell'amministrazione</param>
/// <param name="isSmistamentoEnabled">True se è abilitato lo smistamento</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <returns>L'oggetto con le informazioni sul protocollo da creare</returns>
protected override Protocollo CreateProtocolObject(DocumentRowData rowData, string registrySyd, string rfSyd, string administrationSyd, bool isSmistamentoEnabled, InfoUtente userInfo, Ruolo role)
{
// Creazione dell'oggetto ProtocolloInterno
ProtocolloInterno ownProto = new ProtocolloInterno();
// Il corrispondente da inserire
Corrispondente corr;
// Il codice corrispondente da analizzare
// Questo array dovrà contenere due elementi: Il codice corrispondente
// e la tipologia (M, D, CC)
string[] corrToAdd;
// Creazione lista destinatari e destinatari conoscenza
ownProto.destinatari = new ArrayList();
ownProto.destinatariConoscenza = new ArrayList();
// Per ogni codice corrispondente in CorrCode...
foreach (string corrDesc in rowData.CorrCode)
{
// Spezzettamento dei dati sul corrispondente
corrToAdd = corrDesc.Split('#');
// Se non ci sono più tre elementi, eccezione
// Tre elementi poiché il formato con cui è scritto il codice è
// <Codice>#D|CC#
if (corrToAdd.Length != 3)
{
throw new Exception(String.Format(
"Specifica corrispondente non valida: {0}",
corrDesc));
}
// A seconda del tipo di corrispondente bisogna intraprendere
// azioni differenti
switch (corrToAdd[1].ToUpper().Trim())
{
case "M": // Mittente del protocollo
// Reperimento del corrispondente
corr = ImportUtils.GetCorrispondenteByCode(
ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_INT_MITT,
corrToAdd[0].Trim(),
role,
userInfo,
registrySyd,
rfSyd,
isSmistamentoEnabled,
DocsPaVO.addressbook.TipoUtente.GLOBALE);
// Impostazione del mittente, se individuato
if (corr != null)
{
ownProto.mittente = corr;
}
break;
case "D": // Destinatario principale
// Reperimento del corrispondente
corr = ImportUtils.GetCorrispondenteByCode(
ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_INT_DEST,
corrToAdd[0].Trim(),
role,
userInfo,
registrySyd,
rfSyd,
isSmistamentoEnabled,
DocsPaVO.addressbook.TipoUtente.GLOBALE);
// Aggiunta del corrispondente alla lista dei destinatari, se individuato
if (corr != null)
{
ownProto.destinatari.Add(corr);
}
break;
case "CC": // Destinatario in copia
// Reperimento del corrispondente
corr = ImportUtils.GetCorrispondenteByCode(
ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_INT_DEST,
corrToAdd[0].Trim(),
role,
userInfo,
registrySyd,
rfSyd,
isSmistamentoEnabled,
DocsPaVO.addressbook.TipoUtente.GLOBALE);
// Aggiunta del corrispondente alla lista dei destinatari, se individuato
if (corr != null)
{
ownProto.destinatariConoscenza.Add(corr);
}
break;
}
}
// Aggiornamento di destinatari, mittenti e destinatari in conoscenza
ownProto.daAggiornareDestinatari = true;
ownProto.daAggiornareMittente = true;
ownProto.daAggiornareDestinatariConoscenza = true;
// Restituzione dell'oggetto con le informazioni sul protocollo
return(ownProto);
}
/// <summary>
/// Funzione per la lettura dei dati da una riga di foglio excel
/// </summary>
/// <param name="row">L'oggetto da cui prelevare i dati</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <returns>
/// L'oggetto con i dati estratti dalla riga del foglio excel
/// </returns>
protected override DocumentRowData ReadDataFromCurrentRow(OleDbDataReader row, InfoUtente userInfo, Ruolo role, bool isEnabledPregressi)
{
// L'oggetto da restituire
DocumentRowData toReturn = new DocumentRowData();
List <string> colonne = new List <string>();
for (int i = 0; i < row.FieldCount; i++)
{
colonne.Add(row.GetName(i));
}
// Prelevamento dell'ordinale
toReturn.OrdinalNumber = row["Ordinale"].ToString().Trim();
// Prelevamento del codice dell'amministrazione
toReturn.AdminCode = row["Codice Amministrazione"].ToString().Trim();
// Prelevamento del numero da assegnare al protocollo e della data di protocollo
if (isEnabledPregressi)
{
if (colonne.Contains("Numero di protocollo"))
{
toReturn.ProtocolNumber = row["Numero di protocollo"].ToString().Trim();
}
if (colonne.Contains("Data protocollo"))
{
if (String.IsNullOrEmpty(row["Data protocollo"].ToString()))
{
toReturn.ProtocolDate = DateTime.Now;
}
else
{
toReturn.ProtocolDate = DateTime.Parse(row["Data protocollo"].ToString());
}
}
if (colonne.Contains("Codice Ruolo Creatore"))
{
if (!String.IsNullOrEmpty(row["Codice Utente Creatore"].ToString()))
{
toReturn.CodiceUtenteCreatore = row["Codice Utente Creatore"].ToString().Trim();
}
}
if (colonne.Contains("Codice Ruolo Creatore"))
{
if (!String.IsNullOrEmpty(row["Codice Ruolo Creatore"].ToString()))
{
toReturn.CodiceRuoloCreatore = row["Codice Ruolo Creatore"].ToString().Trim();
}
}
}
else
{
if (colonne.Contains("Numero di protocollo") ||
colonne.Contains("Data protocollo") ||
colonne.Contains("Codice Utente Creatore") ||
colonne.Contains("Codice Ruolo Creatore")
)
{
throw new Exception("Ruolo non abilitato per questa importazione");
}
}
// Prelevamento del codice registro
toReturn.RegCode = row["Codice Registro"].ToString().Trim();
// Prelevamento del codice RF
toReturn.RFCode = row["Codice RF"].ToString().Trim();
// Prelevamento del codice oggetto
toReturn.ObjCode = row["Codice oggetto"].ToString().Trim();
// Prelevamento dell'oggetto
toReturn.Obj = row["Oggetto"].ToString().Trim();
// Prelevamento del codice corrispondente, se valorizzato
if (!String.IsNullOrEmpty(row["Codice corrispondenti"].ToString()))
{
toReturn.CorrCode = new List <string>(
row["Codice corrispondenti"].ToString().Trim().Split(';'));
}
// Prelevamento del pathname nel caso di stampa unione questa colonna non è presente e
// il valore di pathname viene settato nel blocco cath a stringa vuota
try
{
toReturn.Pathname = row["Pathname"].ToString().Trim();
}
catch (Exception e)
{
toReturn.Pathname = string.Empty;
}
// Prelevamento del valore che indica se il documento deve
// essere salvato nell'area di lavoro
toReturn.InWorkingArea = !String.IsNullOrEmpty(row["ADL"].ToString()) &&
row["ADL"].ToString().Trim().ToUpper() == "SI";
// Prelevamento delle note
if (!String.IsNullOrEmpty(row["Note"].ToString()))
{
// Creazione della nota
toReturn.Note = new InfoNota(row["Note"].ToString().Trim());
//Impostazione della visibilità Tutti
toReturn.Note.TipoVisibilita = TipiVisibilitaNotaEnum.Tutti;
// Creazione dell'oggetto utilizzato per memorizzare le informazioni
// sull'utente creatore
toReturn.Note.UtenteCreatore = new InfoUtenteCreatoreNota();
// Impostazione della descrizione del ruolo
toReturn.Note.UtenteCreatore.DescrizioneRuolo = role.descrizione;
// Impostazione della descrizione dell'utente
toReturn.Note.UtenteCreatore.DescrizioneUtente = userInfo.userId;
// Impostazione dell'id del ruolo
toReturn.Note.UtenteCreatore.IdRuolo = role.systemId;
// Impostazione dell'id dell'utente
toReturn.Note.UtenteCreatore.IdUtente = userInfo.userId;
// La nota deve essere inserita
toReturn.Note.DaInserire = true;
// Impostazione della data di creazione
toReturn.Note.DataCreazione = DateTime.Now;
}
// Prelevamento del codice del modello di trasmissione
toReturn.TransmissionModelCode = row["Codice modello trasmissione"].ToString().
Trim().Split(';');
// Prelevamento della descrizione della tipologia di documento
toReturn.DocumentTipology = row["Tipologia documento"].ToString().Trim().ToUpper();
// Prelevamento del codice fascicolo
if (!String.IsNullOrEmpty(row["Codice fascicolo"].ToString()))
{
toReturn.ProjectCodes = row["Codice fascicolo"].ToString().Trim().Split(';');
}
// Prelevamento della descrizione del fascicolo
toReturn.ProjectDescription = row["Descrizione fascicolo"].ToString().Trim();
// Prelevamento della descrizione del sottofascicolo
toReturn.FolderDescrition = row["Descrizione sottofascicolo"].ToString().Trim();
// Prelevamento della descrizione del titolario
toReturn.Titolario = row["Titolario"].ToString().Trim();
// Prelevamento del codice del nodo
toReturn.NodeCode = row["Codice Nodo"].ToString().Trim();
// Prelevamento della tipologia di fascicolo
toReturn.ProjectTipology = row["Tipologia fascicolo"].ToString().Trim().ToUpper();
//Prelevamento del valore che indica se il documento deve essere un predisposto
if (colonne.Contains("Predisposto"))
{
toReturn.Predisposto = !String.IsNullOrEmpty(row["Predisposto"].ToString()) &&
row["Predisposto"].ToString().Trim().ToUpper() == "SI";
}
// Restituzione dell'oggetto con i dati prelevati dalla riga
return(toReturn);
}
/// <summary>
/// Funzione per la validazione dei dati letti da un foglio excel
/// </summary>
/// <param name="rowData">L'oggetto con i dati da validare</param>
/// <param name="isProfilationRequired">True se è obbligatoria la profilazione del documento</param>
/// <param name="isRapidClassificationRequired">True se è richiesta la classificazione rapida</param>
/// <param name="validationProblems">La lista dei problemi rilevati in fase di verifica dati</param>
/// <returns>True se la validazione passa</returns>
protected override bool CheckDataValidity(DocumentRowData rowData, bool isProfilationRequired, bool isRapidClassificationRequired, out List <string> validationProblems)
{
#region Dichiarazione variabili
// Il risultato della validazione
bool validationResult = true;
// L'oggetto a cui richiedere le informaizoni sull'amministrazione
DocsPaDB.Query_DocsPAWS.Amministrazione administrationManager = null;
// Valore booleano che indica se è obbligatorio specificare l'RF
bool rfRequired = false;
// L'id dell'amministrazione
string administrationSyd = String.Empty;
// Valore booleano utilizzato per verificare se solo uno dei due campi
// Codice Corrispondenti e Corrispondenti è valorizzata
bool corrOk = true;
// Valore utilizzato per indicare se è stato trovato un destinatario
// principale
bool primCorrFound;
// Variabile utilizzata per contare il numero di mittenti specificati
int sendersNum;
#endregion
// Creazione della lista dei problemi
validationProblems = new List <string>();
// L'ordinale è obbligatorio
if (String.IsNullOrEmpty(rowData.OrdinalNumber))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Campo 'Numero protocollo emergenza.");
}
else
{
validationProblems.Add("Campo 'Ordinale' obbligatorio.");
}
}
// Il codice amministrazione è obbligatorio
if (String.IsNullOrEmpty(rowData.AdminCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice amministrazione' obbligatorio.");
}
// Il codice registro è obbligatorio
if (String.IsNullOrEmpty(rowData.RegCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice Registro' obbligatorio.");
}
// Il codice RF deve essere obbligatorio se richiesto dalla segnatura
// Creazione dell'oggetto a cui richiedere le informazioni sull'amministrazione
administrationManager = new DocsPaDB.Query_DocsPAWS.Amministrazione();
try
{
administrationSyd = ImportUtils.GetAdministrationId(rowData.AdminCode);
}
catch (Exception e)
{
validationResult = false;
validationProblems.Add(String.Format(
"Impossibile recuperare le informazioni sull'amministrazione {0}",
rowData.AdminCode));
}
// Se non è stato possibile ricavare l'id dell'amministrazione, problema
if (!String.IsNullOrEmpty(administrationSyd))
{
// Si procede con la verifica
// Verifica dell'obbligatorietà della specifica dell'RF
rfRequired = administrationManager.AmmGetListAmministrazioni().Where(
e => e.IDAmm == administrationSyd).FirstOrDefault().
Segnatura.Contains("COD_RF_PROT");
// Se l'RF è richiesto ma non è specificato, la validazione non passa
if (rfRequired && String.IsNullOrEmpty(rowData.RFCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice RF' obbligatorio in quanto richiesto dalla segnatura.");
}
}
// Se entrambi i campi 'Oggetto' e 'Codice Oggetto' non
// sono valorizzati, la validazione non passa
if (String.IsNullOrEmpty(rowData.ObjCode) &&
String.IsNullOrEmpty(rowData.Obj))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Il campo 'Oggetto' è obbligatorio.");
}
else
{
validationProblems.Add("Non risultano valorizzati nè il campo 'Codice Oggetto' nè il campo 'Oggetto'. Valorizzare uno dei due.");
}
}
// Se entrambi i campi 'Oggetto' e 'Codice oggetto' sono valorizzati, errore
if (!String.IsNullOrEmpty(rowData.ObjCode) &&
!String.IsNullOrEmpty(rowData.Obj))
{
validationResult = false;
validationProblems.Add("Risultano valorizzati entrambi i campi 'Codice Oggetto' e 'Oggetto'. Valorizzare solamente uno.");
}
primCorrFound = false;
sendersNum = 0;
// Se il campo 'Codice Corrispondenti' è valorizzato ma non contiene #D#,
// significa che non è stato specificato un destinatario principale e di
// conseguenza la validazione non passa.
// Se contine più di un #M#, significa che sono stati specificati più mittenti
// e di conseguenza la validazione non passa.
// Se il campo 'Codice Corrispondenti' è valorizzato...
if (rowData.CorrCode != null)
{
// Per ogni codice corrispondente contenuto nella lista...
foreach (string corrCode in rowData.CorrCode)
{
// ...se contiene #M#, si incrementa il contatore di mittenti
if (corrCode.ToUpper().Contains("#M#"))
{
sendersNum++;
}
// ...se contiene #D#, significa che esiste almeno un corrispondente
// principale
if (corrCode.ToUpper().Contains("#D#") &&
corrCode.Trim().Length > 3)
{
primCorrFound = true;
}
}
}
// Se la validazione dei campi corrispondenti è passata, si procede con
// la verifica della correttezza dei dati in essi contenuti
if (corrOk)
{
// Se non sono stati individuati mittenti, errore
if (sendersNum == 0)
{
validationResult = false;
validationProblems.Add(
"Il campo 'Codice Corrispondenti' non contiene codici per i mittenti. Specificarne uno.");
}
// Se sono stati trovati più mittenti, la validazione non passa
if (sendersNum > 1)
{
validationResult = false;
validationProblems.Add(String.Format(
"Il campo 'Codice Corrispondenti' contiene {0} mittenti. Specificarne solo uno.",
sendersNum));
}
// Se non è stato individuato alcun destinatario primario, errore
if (!primCorrFound)
{
validationResult = false;
validationProblems.Add("Nessun destinatario primario specificato nel campo 'Codice Corrispondenti'.");
}
}
// Se il campo 'Codice Fascicolo' del foglio excel è valorizzato, ed
// è valorizzata anche la profilazione del fascicolo, errore in quanto non è possibile
// valorizzarli entrambi
if (rowData.ProjectCodes != null && rowData.ProjectCodes.Length > 0 &&
(!String.IsNullOrEmpty(rowData.ProjectDescription) ||
!String.IsNullOrEmpty(rowData.FolderDescrition) ||
!String.IsNullOrEmpty(rowData.NodeCode) ||
!String.IsNullOrEmpty(rowData.ProjectTipology)))
{
validationResult = false;
validationProblems.Add("Risultano valorizzati sia i campi 'Codice Fascicolo' che i campi riguardanti la specifica del fascicolo. Non è possibile specificarli entambi.");
}
// Se è richiesta profilazione del documento obbligatoria
// ma non è valorizzato il campo 'Tipologia Documento', la validazione
// non deve passare
if (isProfilationRequired && String.IsNullOrEmpty(rowData.DocumentTipology) && !(rowData is RDEDocumentRowData))
{
validationResult = false;
validationProblems.Add("La profilazione del documento è obbligatoria ma non risulta valorizzato il campo 'Tipologia Documento'");
}
// Se è richiesta fascicolazione rapida obbligatoria ma non sono specificati
// dati in 'Codice Fascicolo' o nei campi dedicati al fascicolo
if (isRapidClassificationRequired &&
rowData.ProjectCodes == null &&
String.IsNullOrEmpty(rowData.ProjectDescription) &&
String.IsNullOrEmpty(rowData.FolderDescrition) &&
String.IsNullOrEmpty(rowData.NodeCode) &&
String.IsNullOrEmpty(rowData.ProjectTipology))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Campo 'Codice Classifica' obbligatorio.");
}
else
{
validationProblems.Add("La classificazione è obbligatoria ma non risultano valorizzati nè il campo 'Codice Fascicolo' nè i campi dedicati alla classificazione.");
}
}
// Se il campo Stringa protocollo emergenza non è valorizzato, non si può procedere
// (Solo nel caso di RDE)
if (rowData is RDEDocumentRowData && String.IsNullOrEmpty("Stringa protocollo emergenza"))
{
validationResult = false;
validationProblems.Add("Campo 'Stringa protocollo emergenza' obbligatorio.");
}
// Se il campo Data protocollo emergenza non è valorizzato, non si può procedere
// (Solo nel caso di RDE)
if (rowData is RDEDocumentRowData &&
String.IsNullOrEmpty(((RDEDocumentRowData)rowData).EmergencyProtocolDate))
{
validationResult = false;
validationProblems.Add("Campo 'Data protocollo emergenza' obbligatorio.");
}
// Se il campo Data protocollo emergenza non è valorizzato, non si può procedere
// (Solo nel caso di RDE)
if (rowData is RDEDocumentRowData &&
String.IsNullOrEmpty(((RDEDocumentRowData)rowData).EmergencyProtocolTime))
{
validationResult = false;
validationProblems.Add("Campo 'Ora protocollo emergenza' obbligatorio.");
}
if (rowData is RDEDocumentRowData)
{
RDEDocumentRowData converted = rowData as RDEDocumentRowData;
// Il campo Data protocollo emergenza deve essere minore della data di protocollazione, che
// si suppone uguale alla data odierna. visto che il protocolla in giallo è stata dismessa
// nel senso che non la usa più nessuno.
if (!String.IsNullOrEmpty(converted.EmergencyProtocolDate) &&
!String.IsNullOrEmpty(converted.EmergencyProtocolTime))
{
//l'excel è formattato un modo tale che la data e l'ora possono solo arrivare nel formato valido.
string dataEmerg = converted.EmergencyProtocolDate + " " + converted.EmergencyProtocolTime;
DateTime dataEmergOut;
if (isDate(dataEmerg))
{
dataEmergOut = DateTime.ParseExact(dataEmerg, formati, ci.DateTimeFormat, DateTimeStyles.AllowWhiteSpaces);
if (dataEmergOut > System.DateTime.Now)
{
validationResult = false;
validationProblems.Add("Campo 'Data protocollo emergenza' deve essere minore della data di protocollazione.");
}
}
else
{
validationResult = false;
validationProblems.Add("Il campo data o il campo ora emergenza non contiengo un formato valido.");
}
}
}
// Retituzione del risultato di validazione
return(validationResult);
}
/// <summary>
/// Funzione per l'importazione di un documento i cui dati sono descritti
/// all'interno di un oggetto DocumentRowData
/// </summary>
/// <param name="documentRowData">L'oggetto con i dati sul documento da creare</param>
/// <param name="userInfo">Le informaizoni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <param name="serverPath">L'indirizzo della WA</param>
/// <param name="isProfilationRequired">True se è richiesta la profilazione</param>
/// <param name="isRapidClassificationRequired">True se è richiesta la classificazione rapida</param>
/// <param name="sharedDirectoryPath">L'indirizzo della cartella sherata in cui è possibile reperire l'immagine da associare al documento</param>
/// <param name="isSmistamentoEnabled">True se è abilitato lo smistamento</param>
/// <param name="protoType">Il tipo di documento da creare</param>
/// <param name="resultsContainer"></param>
/// <param name="acquireDelegate">Il delegate per l'acquisizione</param>
/// <returns>Il risultato dell'importazione</returns>
public static ImportResult ImportAndAcquireDocument(
DocumentRowData documentRowData,
InfoUtente userInfo,
Ruolo role,
string serverPath,
bool isProfilationRequired,
bool isRapidClassificationRequired,
string ftpAddress,
bool isSmistamentoEnabled,
ProtoType protoType,
ref ResultsContainer resultsContainer,
String ftpUsername,
String ftpPassword,
bool isEnabledPregressi)
{
#region Dichiarazione variabili
// L'oggetto da restituire
ImportResult toReturn = null;
#endregion
switch (protoType)
{
case ProtoType.ATT:
if (resultsContainer != null)
{
toReturn = new Attachment().ImportDocument(
documentRowData,
userInfo,
role,
ftpAddress,
ref resultsContainer,
ftpUsername,
ftpPassword);
}
break;
case ProtoType.A:
case ProtoType.G:
case ProtoType.I:
case ProtoType.P:
// Si recupera l'oggetto responsabile dell'import
// e si esegue l'importazione
toReturn = GetDocumentManager(protoType).ImportDocument(
documentRowData,
userInfo,
role,
serverPath,
isProfilationRequired,
isRapidClassificationRequired,
ftpAddress,
protoType == ProtoType.G,
isSmistamentoEnabled,
protoType.ToString(),
ftpUsername,
ftpPassword,
isEnabledPregressi,
AcquireFileFromModel, true);
break;
}
// Restituzione del risultato
return(toReturn);
}
/// <summary>
/// Funzione per la vadazione dei dati contenuti nell'oggetto RowData
/// </summary>
/// <param name="rowData">L'oggetto con i dati da validare</param>
/// <param name="isProfilationRequired">True se, per configurazione, è richiesta la profilazione obbligatoria</param>
/// <param name="isRapidClassificationRequired">True se, per configurazione, è richiesta la classificazione rapida</param>
/// <param name="validationProblems">Questo parametro verrà impostato con la lista dei problemi riscontrati durante la procedura di validazione</param>
/// <returns>True se la procedura và a buon fine</returns>
protected override bool CheckDataValidity(DocumentRowData rowData, bool isProfilationRequired, bool isRapidClassificationRequired, out List <string> validationProblems)
{
#region Dichiarazione variabili
// Il risultato della validazione
bool validationResult = true;
// L'oggetto a cui richiedere le informaizoni sull'amministrazione
DocsPaDB.Query_DocsPAWS.Amministrazione administrationManager = null;
// Valore booleano che indica se è obbligatorio specificare l'RF
bool rfRequired = false;
// L'id dell'amministrazione
string administrationSyd = String.Empty;
#endregion
// Creazione della lista dei problemi
validationProblems = new List <string>();
// L'ordinale è obbligatorio
if (String.IsNullOrEmpty(rowData.OrdinalNumber))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Campo 'Numero protocollo emergenza' obbligatorios.");
}
else
{
validationProblems.Add("Campo 'Ordinale' obbligatorio.");
}
}
// Il codice amministrazione è obbligatorio
if (String.IsNullOrEmpty(rowData.AdminCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice amministrazione' obbligatorio.");
}
// Il codice registro è obbligatorio
if (String.IsNullOrEmpty(rowData.RegCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice Registro' obbligatorio.");
}
// Il codice RF deve essere obbligatorio se richiesto dalla segnatura
// Creazione dell'oggetto a cui richiedere le informazioni sull'amministrazione
administrationManager = new DocsPaDB.Query_DocsPAWS.Amministrazione();
try
{
administrationSyd = ImportUtils.GetAdministrationId(rowData.AdminCode);
}
catch (Exception e)
{
validationResult = false;
validationProblems.Add(String.Format(
"Impossibile recuperare le informazioni sull'amministrazione {0}",
rowData.AdminCode));
}
// Se non è stato possibile ricavare l'id dell'amministrazione, problema
if (!String.IsNullOrEmpty(administrationSyd))
{
// Si procede con la verifica
// Verifica dell'obbligatorietà della specifica dell'RF
rfRequired = administrationManager.AmmGetListAmministrazioni().Where(
e => e.IDAmm == administrationSyd).FirstOrDefault().
Segnatura.Contains("COD_RF_PROT");
// Se l'RF è richiesto ma non è specificato, la validazione non passa
if (rfRequired && String.IsNullOrEmpty(rowData.RFCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice RF' obbligatorio in quanto richiesto dalla segnatura.");
}
}
// Se entrambi i campi 'Oggetto' e 'Codice Oggetto' non
// sono valorizzati, la validazione non passa
if (String.IsNullOrEmpty(rowData.ObjCode) &&
String.IsNullOrEmpty(rowData.Obj))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Il campo 'Oggetto' è obbligatorio.");
}
else
{
validationProblems.Add("Non risultano valorizzati nè il campo 'Codice Oggetto' nè il campo 'Oggetto'. Valorizzare uno dei due.");
}
}
// Se entrambi i campi 'Oggetto' e 'Codice oggetto' sono valorizzati, errore
if (!String.IsNullOrEmpty(rowData.ObjCode) &&
!String.IsNullOrEmpty(rowData.Obj))
{
validationResult = false;
validationProblems.Add("Risultano valorizzati entrambi i campi 'Codice Oggetto' e 'Oggetto'. Valorizzare solamente uno.");
}
// Se entrambi i campi 'Codice Corrispondente' e 'Corrispondente' non
// sono valorizzati, la validazione non passa
if (rowData.CorrCode == null &&
rowData.CorrDesc == null)
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Non sono state trovate informazioni sui corrispondenti. Controllare i relativi campi.");
}
else
{
validationProblems.Add("Non risultano valorizzati nè il campo 'Codice Corrispondente' nè il campo 'Corrispondente'. Valorizzarne uno.");
}
}
// Se il campo 'Codice Fascicolo' del foglio excel è valorizzato, ed
// è valorizzata anche la profilazione del fascicolo, errore in quanto non è possibile
// valorizzarli entrambi
if (rowData.ProjectCodes != null && rowData.ProjectCodes.Length > 0 &&
(!String.IsNullOrEmpty(rowData.ProjectDescription) ||
!String.IsNullOrEmpty(rowData.FolderDescrition) ||
!String.IsNullOrEmpty(rowData.NodeCode) ||
!String.IsNullOrEmpty(rowData.ProjectTipology)))
{
validationResult = false;
validationProblems.Add("Risultano valorizzati sia i campi 'Codice Fascicolo' che i campi riguardanti la specifica del fascicolo. Non è possibile specificarli entambi.");
}
// Se è richiesta profilazione del documento obbligatoria
// ma non è valorizzato il campo 'Tipologia Documento', la validazione
// non deve passare
if (isProfilationRequired && String.IsNullOrEmpty(rowData.DocumentTipology) && !(rowData is RDEDocumentRowData))
{
validationResult = false;
validationProblems.Add("La profilazione del documento è obbligatoria ma non risulta valorizzato il campo 'Tipologia Documento'");
}
// Se è richiesta fascicolazione rapida obbligatoria ma non sono specificati
// dati in 'Codice Fascicolo' o nei campi dedicati al fascicolo
if (isRapidClassificationRequired &&
rowData.ProjectCodes == null &&
String.IsNullOrEmpty(rowData.ProjectDescription) &&
String.IsNullOrEmpty(rowData.FolderDescrition) &&
String.IsNullOrEmpty(rowData.NodeCode) &&
String.IsNullOrEmpty(rowData.ProjectTipology))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Campo 'Codice Classifica' obbligatorio.");
}
else
{
validationProblems.Add("La classificazione è obbligatoria ma non risultano valorizzati nè il campo 'Codice Fascicolo' nè i campi dedicati alla classificazione.");
}
}
// Se la riga è una riga di RDE, vengono effettuati ulteriori controlli
if (rowData is RDEDocumentRowData)
{
RDEDocumentRowData converted = rowData as RDEDocumentRowData;
// Campo Stringa protocollo emergenza obbligatorio
if (String.IsNullOrEmpty(converted.EmergencyProtocolSignature))
{
validationResult = false;
validationProblems.Add("Campo 'Stringa protocollo emergenza' obbligatorio.");
}
// Se il campo Data protocollo emergenza non è valorizzato, non si può procedere
if (String.IsNullOrEmpty(converted.EmergencyProtocolDate))
{
validationResult = false;
validationProblems.Add("Campo 'Data protocollo emergenza' obbligatorio.");
}
// Se il campo Data protocollo emergenza non è valorizzato, non si può procedere
if (String.IsNullOrEmpty(converted.EmergencyProtocolTime))
{
validationResult = false;
validationProblems.Add("Campo 'Ora protocollo emergenza' obbligatorio.");
}
// Il campo Data protocollo emergenza deve essere minore della data di protocollazione, che
// si suppone uguale alla data odierna. visto che il protocolla in giallo è stata dismessa
// nel senso che non la usa più nessuno.
if (!String.IsNullOrEmpty(converted.EmergencyProtocolDate) &&
!String.IsNullOrEmpty(converted.EmergencyProtocolTime))
{
//l'excel è formattato un modo tale che la data e l'ora possono solo arrivare nel formato valido.
string dataEmerg = converted.EmergencyProtocolDate + " " + converted.EmergencyProtocolTime;
DateTime dataEmergOut;
if (ImportUtils.IsDate(dataEmerg))
{
dataEmergOut = ImportUtils.ReadDate(dataEmerg);
if (dataEmergOut > System.DateTime.Now)
{
validationResult = false;
validationProblems.Add("Campo 'Data protocollo emergenza' deve essere minore della data di protocollazione.");
}
}
else
{
validationResult = false;
validationProblems.Add("Il campo data o il campo ora emergenza non sono espressi in un formato valido.");
}
}
// Se almeno uno fra i due campi "Data arrivo" e "Ora Arrivo", è valorizzato,
// viene controllato che antrambi lo siano.
if ((!String.IsNullOrEmpty(converted.ArrivalTime) && String.IsNullOrEmpty(converted.ArrivalDate)) ||
(!String.IsNullOrEmpty(converted.ArrivalDate) && String.IsNullOrEmpty(converted.ArrivalTime)))
{
validationResult = false;
validationProblems.Add("Solo uno dei due campi \"Data arrivo\" e \"Ora Arrivo\" risulta valorizzato. Valorizzarli entrambi o nessuno dei due.");
}
// La data di protocollo mittente deve essere minore della
// data attuale e minore della data di arrivo
if (!String.IsNullOrEmpty(converted.SenderProtocolDate) &&
DateTime.Parse(converted.SenderProtocolDate) > DateTime.Now)
{
validationProblems.Add("La data di protocollo mittente non può essere maggiore della data attuale.");
validationResult = false;
}
//controllo sulla validità del formato della data arrivo
// Se non è una data, errore
if (!string.IsNullOrEmpty(converted.ArrivalDate))
{
if (!ImportUtils.IsDate(converted.ArrivalDate))
{
validationProblems.Add("Il campo data o il campo ora arrivo non sono espressi in un formato valido.");
validationResult = false;
}
else
{
DateTime arrivalDate = ImportUtils.ReadDate(converted.ArrivalDate);
// La data di arrivo deve essere minore della
// data attuale
if (arrivalDate > DateTime.Now)
{
validationProblems.Add("La data di arrivo non può essere maggiore della data di protocollo.");
validationResult = false;
}
if (!String.IsNullOrEmpty(converted.SenderProtocolDate) &&
!String.IsNullOrEmpty(converted.ArrivalDate) &&
DateTime.Parse(converted.SenderProtocolDate) > arrivalDate)
{
validationResult = false;
validationProblems.Add("La data di protocollo mittente deve essere minore della data di arrivo.");
}
}
}
}
// Retituzione del risultato di validazione
return(validationResult);
}
/// <summary>
/// Funzione per l'importazione di un documento di emergenza a partire dai dati
/// descrittivi contenuti all'interno di uno specifico oggetto.
/// </summary>
/// <param name="rowData">L'oggetto con le informazioni sul documento da importare</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <param name="serverPath">L'indirizzo della WA</param>
/// <param name="isRapidClassificationRequired">True se è abilitata la classificazione rapida</param>
/// <param name="isSmistamentoEnabled">True se è abilitato lo smistamento</param>
/// <param name="sharedDirectoryPath">L'indirizzo della cartella scharata</param>
/// <param name="protoType">Il tipo di documento da creare</param>
/// <returns>Il risultato dell'importazione del documento</returns>
public static ImportResult ImportRDEDocument(
DocumentRowData rowData,
InfoUtente userInfo,
Ruolo role,
string serverPath,
bool isRapidClassificationRequired,
bool isSmistamentoEnabled,
string ftpAddress,
bool isProfilationRequired,
ImportDocumentsManager.ProtoType protoType,
String ftpUsername,
String ftpPassword,
bool isEnabledPregressi)
{
#region Dichiarazione variabili
// Possibilità da parte dell'utente di creare il documento della tipologia richiesta
bool canCreateDocuments;
// Il risultato dell'elaborazione
ImportResult toReturn;
// Il contenitore dei risultati
ResultsContainer resultContainer = new ResultsContainer();
#endregion
// Verifica della possibilità di creare documenti del tipo specificato
canCreateDocuments = CanCreateDocumentOfType(protoType, (Funzione[])role.funzioni.ToArray(typeof(Funzione)));
// Se con il ruolo corrente è possibile creare il documento della tipologi richiesta,
// si procede alla creazione
if (canCreateDocuments)
{
toReturn = ImportDocumentsManager.ImportDocument(
rowData,
userInfo,
role,
serverPath,
isProfilationRequired,
isRapidClassificationRequired,
ftpAddress,
isSmistamentoEnabled,
protoType,
ref resultContainer,
ftpUsername,
ftpPassword,
isEnabledPregressi);
}
else
{
// Altrimenti aggiunta di un result negativo
toReturn = new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.KO,
Message = "Utente non abilitato alla creazione di documenti di tipo " + protoType + "."
}
};
// Restituzione del risultato
return(toReturn);
}
/// <summary>
/// Funzione per l'acquisizione del file da associare ad un allegato
/// </summary>
/// <param name="path">Il path relativo del file da caricare</param>
/// <param name="administrationCode">Il codice dell'amministrazione</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="ftpAddress">L'indirizzo a cui è possibile recuperare le informazioni sul file</param>
/// <param name="attachment">L'allegato a cui associare il file</param>
protected void AcquireFile(string path, string administrationCode, InfoUtente userInfo, string ftpAddress, Allegato attachment, String ftpUsername, String ftpPassword, DocumentRowData rowData)
{
#region Dichiarazione Variabili
// Il contenuto del file
byte[] fileContent;
// L'oggetto fileRequest
FileRequest fileRequest;
// L'oggetto fileDocumento
FileDocumento fileDocumento;
#endregion
#region Lettura file documento
try
{
// Apertura, lettura e chiusura del file
//fileContent = ImportUtils.DownloadFileFromFTP(
// ftpAddress,
// String.Format("{0}/{1}/{2}",
// administrationCode,
// userInfo.userId,
// path),
// ftpUsername,
// ftpPassword);
// nuova versione, i file vengono presi in locale e caricati dagli utenti in locale nella procedura di import
fileContent = ImportUtils.DounloadFileFromUserTempFolder(rowData, userInfo, true);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
#endregion
#region Creazione dell'oggetto fileDocumento
// Creazione dell'oggetto fileDocumento
fileDocumento = new FileDocumento();
// Impostazione del nome del file
fileDocumento.name = Path.GetFileName(path);
// Impostazione del full name
fileDocumento.fullName = path;
// Impostazione del path
fileDocumento.path = Path.GetPathRoot(path);
// Impostazione della grandezza del file
fileDocumento.length = fileContent.Length;
// Impostazione del content del documento
fileDocumento.content = fileContent;
#endregion
#region Creazione dell'oggetto fileRequest
fileRequest = (FileRequest)attachment;
#endregion
#region Acquisizione del file
try
{
FileManager.putFile(fileRequest, fileDocumento, userInfo);
}
catch (Exception e)
{
// Aggiunta del problema alla lista dei problemi
throw new Exception("Errore durante l'upload del file.");
}
#endregion
}
/// <summary>
/// Funzione per la creazione dell'oggetto con le informazioni sul protocollo. In questo caso
/// questa funzione restituisce un risultato nullo in quanto il documento grigio non è un
/// protocollo
/// </summary>
/// <param name="rowData">L'oggetto con le informazioni sul documento da creare</param>
/// <param name="registrySyd">L'id del registro</param>
/// <param name="rfSyd">L'id dell'RF</param>
/// <param name="administrationSyd">L'id dell'amministrazione</param>
/// <param name="isSmistamentoEnabled">True se è abilitato lo smistamento</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo ocn cui è stata lanciata la procedura</param>
/// <returns>L'oggetto protocollo (null per i documenti grigi)</returns>
protected override Protocollo CreateProtocolObject(DocumentRowData rowData, string registrySyd, string rfSyd, string administrationSyd, bool isSmistamentoEnabled, InfoUtente userInfo, Ruolo role)
{
return(null);
}
/// <summary>
/// Funzione per l'importazione degli allegati
/// </summary>
/// <param name="dataReader">L'oggetto da cui leggere i dati</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <param name="ftpAddress">L'indirizzo della cartella condivisa in cui reperire il file da associare all'allegato</param>
/// <param name="resultContainer">L'oggetto con il report di importazione</param>
/// <returns>Il report relativo all0'importazione degli allegati</returns>
public List <ImportResult> ImportDocuments(
OleDbDataReader dataReader,
InfoUtente userInfo,
Ruolo role,
string ftpAddress,
ref ResultsContainer resultContainer,
String ftpUsername,
String ftpPassword)
{
#region Dichiarazione variabili
// Il report da restituire
List <ImportResult> toReturn = new List <ImportResult>();
// L'oggetto contente i dati sui documenti letti dalla riga del foglio excel
// in analisi
DocumentRowData rowData = null;
// Valore booleano utilizzato per indicare la
// validità dei dati
bool validParameters = false;
// Valore booleano utilizzato per indicare se
// ci sono stati problemi durante la lettura dei dati dalla
// riga del foglio excel
bool noErrorsReadingRowData = false;
// La lista dei problemi rilevati durante le fasi di
// creazione di un documento
List <string> creationProblems = null;
// Un oggetto utilizzato per contenere temporaneamente
// la riga di report per la creazione di un documento
ImportResult temp = null;
// Un valore intero utilizzato per contare gli allegati
// importati
int importedAttachments = 0;
// Un valore intero utilizzato per contare gli allegati
// non importati
int notImportedAttachments = 0;
// Le informazioni aggiuntive da riportare nella riga di report
// relativa ad un allegato creato.
string identificationData;
// Il report relativo al documento cui si vuole aggiungere l'allegato
ImportResult documentReport;
#endregion
// Se non ci sono documenti da importare, il report conterrà
// una sola riga con un messaggio informativo per l'utente
if (!dataReader.HasRows)
{
toReturn.Add(new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.OK,
Message = "Non sono stati rilevati allegati da importare."
});
}
// Finchè ci sono dati da leggere
while (dataReader.Read())
{
#region Inizializzazione variabili
// Reset del controllore di validità dati
validParameters = true;
// Reset del flag di errore in lettura dati
noErrorsReadingRowData = true;
// Creazione della lista dei problemi
creationProblems = new List <string>();
// Creazione del risultato dell'operazione di creazione
temp = new ImportResult();
// Inizializzazione dei dati identificativi del documento
// creato
identificationData = String.Empty;
#endregion
#region Prelevamento dei dati dalla riga attuale
try
{
// Lettura dei dati dalla riga attuale
rowData = this.ReadDataFromCurrentRow(dataReader, userInfo, role);
}
catch (Exception e)
{
// Aggiunta di un oggetto result con i dettagli sull'eccezione
toReturn.Add(new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.KO,
Message = e.Message,
Ordinal = rowData.OrdinalNumber
});
// Si sono verificati errori durante la lettura dei dati dalla riga attuale
noErrorsReadingRowData = false;
// Un allegato non è stato importato
notImportedAttachments++;
}
#endregion
#region Controllo validità campi obbligatori
validParameters = this.CheckDataValidity(rowData, out creationProblems);
// Aggiunta della lista degli errori alla lista dei dettagli
// del risultato attuale
temp.OtherInformation.AddRange(creationProblems);
#endregion
// Se gli eventuali dati profilati sono stati letti con successo
// e se la validazione è passata...
if (noErrorsReadingRowData && validParameters)
{
try
{
// Reperimento del report relativo al documento cui si desidera aggiungere
// l'allegato
documentReport = this.GetDocumentType(
rowData.MainOrdinal,
resultContainer);
// Se il documentReport è null -> tipologia non riconosciuta
if (documentReport == null)
{
// Impostazione del risultato a fallimento
temp.Outcome = ImportResult.OutcomeEnumeration.KO;
// Impostazione del messaggio
temp.Message = String.Format("Tipologia {0} non riconosciuta",
rowData.MainOrdinal);
// Un allegato non è stato importato
notImportedAttachments++;
}
else
{
// Altrimenti si procede all'importazione dell'allegato
CreateDocument(
rowData,
userInfo,
role,
out identificationData,
ftpAddress,
documentReport,
ftpUsername,
ftpPassword);
// Aggiunta dell'esito positivo
temp.Outcome = ImportResult.OutcomeEnumeration.OK;
// Aggiunta del messaggio
temp.Message = String.Format("Allegato aggiunto con successo. {0}",
identificationData);
// Un allegato è stato importato
importedAttachments++;
}
// Impostazione dell'ordinale
temp.Ordinal = rowData.OrdinalNumber;
// Aggiunta del risultato alla lista dei risultati
toReturn.Add(temp);
}
catch (Exception e)
{
// Viene creato un risultato negativo
toReturn.Add(new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.KO,
Message = e.Message,
Ordinal = rowData.OrdinalNumber
});
// Un allegato non è stato importato
notImportedAttachments++;
}
}
else
if (noErrorsReadingRowData)
{
// Altrimenti viene aggiunto alla lista dei risultati
// un nuovo risultato negativo e ne viene impostata la descrizione
toReturn.Add(new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.KO,
Message = "Alcuni parametri obbligatori non sono validi.",
OtherInformation = creationProblems,
Ordinal = rowData.OrdinalNumber
});
// Un allegato non è stato importato
notImportedAttachments++;
}
}
// Aggiunta di un'ultima riga contenente il totale degli allegati
// importati e non importati
toReturn.Add(new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.OK,
Message = String.Format("Allegati importati: {0}; Allegati non importati: {1}",
importedAttachments, notImportedAttachments)
});
// Restituzione del report sui risultati
return(toReturn);
}
/// <summary>
/// Funzione per l'importazione di un allegato i cui dati sono riportati all'interno di
/// un apposito oggetto
/// </summary>
/// <param name="documentRowData">L'oggetto con i dati sull'allegato da importare</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo dell'utente che ha lanciato la procedura</param>
/// <param name="ftpAddress">L'indirizzo della cartella sharata in cui recuperare il file da allegare al documento</param>
/// <returns>Il risultato dell'operaizone di importazione</returns>
public ImportResult ImportDocument(
DocumentRowData documentRowData,
InfoUtente userInfo,
Ruolo role,
string ftpAddress,
ref ResultsContainer resultContainer,
String ftpUsername,
String ftpPassword)
{
#region Dichiarazione variabili
// Il risultato da restituire
ImportResult toReturn = new ImportResult();
// Valore booleano utilizzato per indicare la
// validità dei dati
bool validParameters = false;
// Valore booleano utilizzato per indicare se
// ci sono stati problemi durante la lettura dei dati dalla
// riga del foglio excel
bool noErrorsReadingRowData = false;
// La lista dei problemi rilevati durante le fasi di
// creazione di un documento
List <string> creationProblems = null;
// Le informazioni aggiuntive da riportare nella riga di report
// relativa ad un allegato creato.
string identificationData;
// L'oggetto con le infomazioni sul documento a cui è necessario aggiungere
// l'allegato
ImportResult documentReport;
#endregion
// Se non è stato passato il documento da importare, viene restituito
// un messaggio informativo per l'utente
if (documentRowData == null)
{
toReturn = new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.OK,
Message = "Non sono stati rilevati allegati da importare."
}
}
;
// Se è stato passato l'oggetto da importare
if (documentRowData != null)
{
#region Inizializzazione variabili
// Reset del controllore di validità dati
validParameters = true;
// Reset del flag di errore in lettura dati
noErrorsReadingRowData = true;
// Creazione della lista dei problemi
creationProblems = new List <string>();
// Inizializzazione dei dati identificativi del documento
// creato
identificationData = String.Empty;
#endregion
#region Controllo validità campi obbligatori
validParameters = this.CheckDataValidity(documentRowData, out creationProblems);
// Aggiunta della lista degli errori alla lista dei dettagli
// del risultato
toReturn.OtherInformation.AddRange(creationProblems);
#endregion
// Se gli eventuali dati profilati sono stati letti con successo
// e se la validazione è passata...
if (noErrorsReadingRowData && validParameters)
{
try
{
// Reperimento del report relativo al documento cui si desidera aggiungere
// l'allegato
documentReport = this.GetDocumentType(
documentRowData.MainOrdinal,
resultContainer);
// Se il documentReport è null -> tipologia non riconosciuta
if (documentReport == null)
{
// Impostazione del risultato a fallimento
toReturn.Outcome = ImportResult.OutcomeEnumeration.KO;
// Impostazione del messaggio
toReturn.Message = String.Format("Tipologia {0} non riconosciuta",
documentRowData.MainOrdinal);
}
else
{
// Altrimenti si procede all'importazione dell'allegato
CreateDocument(
documentRowData,
userInfo,
role,
out identificationData,
ftpAddress,
documentReport,
ftpUsername,
ftpPassword);
// Aggiunta dell'esito positivo
toReturn.Outcome = ImportResult.OutcomeEnumeration.OK;
// Aggiunta del messaggio
toReturn.Message = String.Format("Allegato aggiunto con successo. {0}",
identificationData);
}
// Impostazione dell'ordinale
toReturn.Ordinal = documentRowData.OrdinalNumber;
}
catch (Exception e)
{
// Viene creato un risultato negativo
toReturn = new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.KO,
Message = e.Message,
Ordinal = documentRowData.OrdinalNumber
};
}
}
else
if (noErrorsReadingRowData)
{
// Altrimenti viene restituito un messaggio di avviso
toReturn = new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.KO,
Message = "Alcuni parametri obbligatori non sono validi.",
OtherInformation = creationProblems,
Ordinal = documentRowData.OrdinalNumber
};
}
}
// Restituzione del risultato
return(toReturn);
}
