public void ManageRistrutturazioniEdilizie(DatiDichiarazioneDTO datiDichiarazione)
{
byte[] data = GetServiceClient().CreateModuloRistrutturazioni(datiDichiarazione, GetUserInfo());
var docInfo = new DocumentInfo { Body = data, FileName = "_ModelloRistrutturazione37.pdf" };
_manageDocumentService.Open(docInfo, "Modello Ristrutturazione 37%", false, MergeFieldType.Default);
CloseService();
}
public Form GetForm(DocumentInfo document, string descrizione, MergeFieldType type)
{
_documentInfo = document;
_form = new PdfViewer { Text = descrizione };
_form.LoadDocument(document.Body);
return _form;
}
public void ManageRichiestaCodiceFiscale(int idCondominio, DateTime dataRichiesta, int? idReferente, int? idRappresentante, string codiceFiscale, TipoRichiestaEnum tipoRichiesta, DateTime? dataVariazioneDati, string allegati)
{
byte[] data = GetServiceClient().CreateModuloRichiestaCodiceFiscale(idCondominio, dataRichiesta, idReferente, idRappresentante, codiceFiscale, tipoRichiesta, dataVariazioneDati, allegati, GetUserInfo());
var docInfo = new DocumentInfo {Body = data, FileName = "_ModuloAA5.pdf"};
_manageDocumentService.Open(docInfo, "Modello richiesta Codice Fiscale", false, MergeFieldType.Default);
CloseService();
}
public Form GetForm(DocumentInfo document, string descrizione, MergeFieldType type)
{
var tipo = "rtf";
switch (document.FileExtension)
{
case ".doc":
tipo = "doc";
break;
case ".docx":
tipo = "docx";
break;
}
_documentInfo = document;
RichTextEditorForm form;
if (document.Body != null)
{
var stream = new MemoryStream(document.Body) { Position = 0 };
form = new RichTextEditorForm(stream, tipo, type) { Text = descrizione };
}
else
{
form = new RichTextEditorForm("rtf", type);
}
form.DocumentSave += formDocumentSave;
return form;
}
public FileCBIDTO Importa(byte[] bytes, long lenght, string nomeFile)
{
var doc = new DocumentInfo {Body = bytes, FileName = nomeFile, Length = lenght};
var result = GetServiceClient().ImportazioneFileCBI(doc, GetUserInfo());
CloseService();
return result;
}
public RisultatoInvioMessaggio(string codiceInvio, string codiceMessaggio, bool invioRiuscito, string messaggioInvio, DocumentInfo messaggio)
{
IdMessaggio = 0;
IdDelivery = 0;
CodiceInvio = codiceInvio;
CodiceMessaggio = codiceMessaggio;
InvioRiuscito = invioRiuscito;
MessaggioInvio = messaggioInvio;
Messaggio = messaggio;
}
public string GetIndirizziPoste(string nomeFile, IList<PersonaComunicazioneDTO> persone)
{
var result = GetServiceClient().GetIndirizziPoste(new List<PersonaComunicazioneDTO>(persone), GetUserInfo());
if (string.IsNullOrEmpty(result.Message))
{
var doc = new DocumentInfo {Body = result.FileBody, FileName = nomeFile};
_manageDocumentService.Open(doc, "Indirizzi per poste", false, MergeFieldType.Default);
}
CloseService();
return result.Message;
}
public void OpenFormDialog(DocumentInfo document, string descrizione, MergeFieldType type)
{
_documentInfo = document;
using (var form = new PdfViewer { Text = descrizione })
{
form.LoadDocument(document.Body);
form.ShowDialog();
form.Close();
form.Dispose();
}
Application.DoEvents();
}
public InviaLetteraConvocazioneUC(AssembleaDTO assemblea, CondominioDTO condominio)
{
InitializeComponent();
_assemblea = assemblea;
_condominio = condominio;
var mittenteLettera = getAziendaService().GetAzienda().MittenteEmailAzienda;
_parametriLettera = new ParametriStampaUnione
{
IdCondominio = _condominio.ID,
IdPersonaRichiedente = null, //occhio...controllare che cosa ci va qua...
DataAttiva = DateTime.Now,
ContattiDestinatario = string.Empty,
Identificativo = string.Empty,
IdAssemblea = _assemblea.ID,
Body = string.Empty,
ParametriAggiuntiviLettera = new ParametriAggiuntiviCompilazioneLettera
{
BodyFormat = "RTF",
TipiMessaggioConsentiti = new List<TipoMessaggio> {TipoMessaggio.Email, TipoMessaggio.Fax, TipoMessaggio.Lettera, TipoMessaggio.Manuale},
TipoLettera = TipoModelloLetteraEnum.Assemblea
}
};
var testoMessaggio = getTestoMessaggioUIService().GetControl(mittenteLettera, _parametriLettera, false, false, true);
getTestoMessaggioUIService().SetConfermaCaption("Invia");
getTestoMessaggioUIService().ConfirmCancel += letteraUC_OnConfirmCancel;
getTestoMessaggioUIService().TipoMessaggioChanged += letteraUC_OnTipoMessaggioChanged;
getTestoMessaggioUIService().SetAmbito(MergeFieldType.Assemblea);
splitContainer1.Panel2.Controls.Add(testoMessaggio);
testoMessaggio.Dock = DockStyle.Fill;
var oDoc = new DocumentInfo
{
FileExtension = "pdf",
FileName = "Convocazione assemblea",
BodyText = _assemblea.LetteraConvocazione
};
getTestoMessaggioUIService().GetDocumentiNew().Add(oDoc);
loadData();
// Tipo Assemblea
DataSourceHelper.PopulateCombo(cboTipoContatto, Conversione.EnumToList<TipoModalitaConvocazione>());
cboTipoContatto_ValueChanged(null,null);
}
private void btnConferma_Click(object sender, EventArgs e)
{
validationSummary1.Validate();
if (validationSummary1.IsValid)
{
var doc = new DocumentInfo
{
Body = Properties.Resources.SferaAssemblea,
FileName = $"{directoryToDownload.Text}/SferaAssemblea.zip",
FileExtension = ".zip"
};
getManageDocumentService().Save(doc);
ParentForm?.Close();
}
else
{
validationSummary1.ShowErrorSummary();
}
}
public void OpenFormDialog(DocumentInfo document, string descrizione, MergeFieldType type)
{
var tipo = "rtf";
switch (document.FileExtension)
{
case ".doc":
tipo = "doc";
break;
case ".docx":
tipo = "docx";
break;
}
_documentInfo = document;
if (document.Body != null)
{
var stream = new MemoryStream(document.Body) { Position = 0 };
using (var editor = new RichTextEditorForm(stream, tipo, type) { Text = descrizione })
{
editor.DocumentSave += formDocumentSave;
editor.ShowDialog();
editor.DocumentSave -= formDocumentSave;
editor.Close();
editor.Dispose();
}
Application.DoEvents();
}
else
{
using (var editor = new RichTextEditorForm("rtf", type))
{
editor.DocumentSave += formDocumentSave;
editor.ShowDialog();
editor.DocumentSave -= formDocumentSave;
editor.Close();
editor.Dispose();
}
Application.DoEvents();
}
}
public IList<DocumentInfo> Decompress(DocumentInfo file)
{
var result = new List<DocumentInfo>();
using (var zipFile = ZipFile.Read(new MemoryStream(file.Body)))
{
foreach (var entry in zipFile)
{
var zipMs = new MemoryStream();
entry.Extract(zipMs);
zipMs.Seek(0, SeekOrigin.Begin);
var fi = new FileInfo(entry.FileName);
var fileName = fi.Name;
if (fileName.EndsWith(fi.Extension))
fileName = fileName.Substring(0, fileName.Length - fi.Extension.Length);
result.Add(new DocumentInfo(zipMs.ToArray(), null, fileName, fi.Extension));
}
}
return result;
}
public string GetModuloPDF(CondominioDTO condominio, int anno, string nomeFile, FornitoreListaDTO fornitoreModello770, DateTime dataDichiarazione, int? numeroIscrizioneCaf, bool intermediarioDichiarazioneCondominio, bool enteDichiarante, PersonaDTO firmatarioDichiarazione, PersonaDTO intermediarioDichiarazione)
{
if(condominio != null)
{
int? idFornitore = null;
if (fornitoreModello770 != null)
idFornitore = fornitoreModello770.ID;
var result = GetServiceClient().GetModello770PDF(condominio.ID, anno, idFornitore, dataDichiarazione, numeroIscrizioneCaf, intermediarioDichiarazioneCondominio, enteDichiarante, firmatarioDichiarazione, intermediarioDichiarazione, GetUserInfo());
if (string.IsNullOrEmpty(result.Message))
{
var doc = new DocumentInfo { Body = result.FileBody, FileName = nomeFile };
_manageDocumentService.Open(doc, "Modello 770", false, MergeFieldType.Default);
}
CloseService();
return result.Message;
}
return "Non è stato scelto nessun condominio";
}
public void ManageDocumentoPratica(DocumentInfo docInfo, IManageDocumentService manageDocService)
{
manageDocService.Open(docInfo);
}
private bool isEditabile(DocumentInfo docInfo)
{
try
{
if (docInfo.FileExtension == ".rtf" || docInfo.FileExtension == ".doc" || docInfo.FileExtension == ".docx" || docInfo.FileExtension == ".htm" || docInfo.FileExtension == ".html")
return true;
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.ErrorFormat("Errore nel controllo se un documento è editabile - {0} - documento:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), docInfo.FileExtension, Login.Instance.CurrentLogin().Azienda);
return false;
}
return false;
}
public ResultPagamento(string message, DocumentInfo documentInfo, IList<ReportPagamentoDTO> pagamenti)
{
Message = message;
DocumentInfo = documentInfo;
Pagamenti = pagamenti;
}
public MemoryStream ConvertToPdf(DocumentInfo file)
{
var fileName = file.FileName;
var fileType = _fileTypeDetector.Detect(new MemoryStream(file.Body));
var streamToConvert = new MemoryStream(file.Body) {Position = 0};
var resultStream = new MemoryStream();
switch (fileType)
{
case EnumFileType.Word:
case EnumFileType.Word2007:
try
{
var word2007Doc = new Document(streamToConvert);
word2007Doc.Unprotect();
word2007Doc.Save(resultStream, WordSaveFormat.Pdf);
}
catch (FileNotFoundException e)
{
_log.ErrorFormat("Errore nella conversione di un file - {0} - fileName:{1}", e, Library.Utility.GetMethodDescription(), fileName);
}
break;
case EnumFileType.Excel:
case EnumFileType.Excel2007:
var cells = new Workbook(streamToConvert);
try
{
cells.Save(resultStream, CellsSaveFormat.Pdf);
}
catch (CellsException e)
{
_log.ErrorFormat("Errore nella conversione di un file - {0} - fileName:{1}", e, Library.Utility.GetMethodDescription(), fileName);
}
catch (FileNotFoundException e)
{
_log.ErrorFormat("Errore nella conversione di un file - FILE NON TROVATO - {0} - fileName:{1}", e, Library.Utility.GetMethodDescription(), fileName);
}
catch (Exception e)
{
// Here we have the workaround for "Unsupported sfnt version" exception.
if (resultStream.Length == 0)
cells.Save(resultStream, CellsSaveFormat.Pdf);
_log.ErrorFormat("Errore nella conversione di un file - WORKAROUND for 'Unsupported sfnt version' - {0} - fileName:{1}", e, Library.Utility.GetMethodDescription(), fileName);
}
break;
case EnumFileType.PowerPoint:
case EnumFileType.PowerPoint2007:
try
{
var slides = new Presentation(streamToConvert, new SlidesLoadOptions { LoadFormat = SlidesLoadFormat.Ppt });
slides.Save(resultStream, SlidesSaveFormat.Pdf);
}
catch (PptException e)
{
_log.ErrorFormat("Errore nella conversione di un file - {0} - fileName:{1}", e, Library.Utility.GetMethodDescription(), fileName);
}
catch (FileNotFoundException e)
{
_log.ErrorFormat("Errore nella conversione di un file - FILE NON TROVATO - {0} - fileName:{1}", e, Library.Utility.GetMethodDescription(), fileName);
}
break;
case EnumFileType.Pdf:
var pdf = new PdfFileInfo(streamToConvert);
var numberOfPage = pdf.NumberOfPages;
var pdfEditor = new PdfFileEditor();
pdfEditor.Extract(streamToConvert, 1, numberOfPage, resultStream);
break;
case EnumFileType.Png:
imageToPdf(streamToConvert, resultStream, ImageFileType.Png);
break;
case EnumFileType.Bmp:
imageToPdf(streamToConvert, resultStream, ImageFileType.Bmp);
break;
case EnumFileType.Jpg:
imageToPdf(streamToConvert, resultStream, ImageFileType.Jpeg);
//streamToConvert.CopyTo(resultStream);
break;
default:
_log.ErrorFormat("Unknown file type, conversion failed - {0} - fileName:{1}", Library.Utility.GetMethodDescription(), fileName);
break;
}
_log.InfoFormat("File converted successfully - {0} - fileName:{1}", Library.Utility.GetMethodDescription(), fileName);
resultStream.Position = 0;
return resultStream;
}
private void btnNewDocumentClick(object sender, EventArgs e)
{
try
{
var tipoDoc = string.Empty;
if (_contratto != null)
tipoDoc = "TipoDocumentoContratto";
else if (_condominio != null)
tipoDoc = "TipoDocumentoCondominio";
else if (_fornitore != null)
tipoDoc = "TipoDocumentoFornitore";
else if (_unitaImmobiliare != null)
tipoDoc = "TipoDocumentoUnitaImmobiliare";
var nuovoDocumento = new NuovoDocumento(tipoDoc);
if (nuovoDocumento.ShowDialog() == DialogResult.OK)
{
var file = new FileInfo(nuovoDocumento.DocumentFullPath);
// Generazione DTO relativo al documento selezionato
DocumentoDTO doc;
if (_contratto != null)
doc = getDocumentoService().GetNew(_contratto);
else if (_condominio != null)
doc = getDocumentoService().GetNew(_condominio);
else if (_fornitore != null)
doc = getDocumentoService().GetNew(_fornitore);
else if (_unitaImmobiliare != null)
doc = getDocumentoService().GetNew(_unitaImmobiliare);
else if (_attivita != null)
doc = getDocumentoService().GetNew(_attivita);
else
doc = new DocumentoDTO();
doc.DirectoryName = file.DirectoryName;
doc.DataCreazione = DateTime.Now;
doc.Tipo = nuovoDocumento.TipoDocumento;
doc.Descrizione = nuovoDocumento.DescrizioneDocumento;
doc.FileName = file.Name;
doc.FileExtension = file.Extension;
// Lettura File
var data = new byte[0];
try
{
var numBytes = file.Length;
var fStream = new FileStream(nuovoDocumento.DocumentFullPath, FileMode.Open, FileAccess.Read);
var br = new BinaryReader(fStream);
data = br.ReadBytes((int) numBytes);
br.Close();
fStream.Close();
}
catch (IOException ex)
{
CommonMessages.DisplayWarning(string.Format("Non è possibile allegare il file '{0}' perchè risulta aperto in un'applicazione", file.Name));
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'apertura di un documento - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
if (data.Length > 0)
{
var docInfo = new DocumentInfo { Body = data, FileName = file.Name, FileExtension = file.Extension };
// Salvataggio Documento ... solo se sono in update
if (_mode == ListMode.Update)
{
var form = new ExecuteLoadDataObjectAsync<DocumentMessages>("Il documento è in corso di salvataggio ....." + Environment.NewLine + "Si prega di attendere.");
Func<DocumentMessages> loadDati = () => saveDocument(doc, docInfo);
form.LoadData(loadDati);
form.ShowDialog();
if (_contratto != null)
{
if (form.DataSourceObject.Documento != null)
{
var docNew = form.DataSourceObject.Documento;
docNew.VisibileCondomino = nuovoDocumento.VisibileCondomino;
_contratto.Documenti.Add(docNew);
}
else
CommonMessages.DisplayWarning(string.Format("Si è verificato un errore nel salvataggio del documento.{0}{1}", Environment.NewLine, form.DataSourceObject.Message));
}
else if(!string.IsNullOrEmpty(form.DataSourceObject.Message))
CommonMessages.DisplayWarning(string.Format("Si è verificato un errore nel salvataggio del documento:{0}{1}", Environment.NewLine, form.DataSourceObject.Message));
else
LoadData(false);
form.Dispose();
}
else if (_mode == ListMode.Select)
{
doc.Body = docInfo.Body;
_documentiNuovi.Add(docInfo);
docInfo.BodyText = nuovoDocumento.DescrizioneDocumento;
doc.Stato = "NEW";
documentoBindingSource.Add(doc);
// Tutti i documenti nuovi devono essere selezionati
foreach (var row in lista.Rows)
{
var documento = row.ListObject as DocumentoDTO;
if (documento != null && documento.Stato == "NEW")
{
if (row.Cells.Exists("SelectColumn"))
row.Cells["SelectColumn"].Value = true;
}
}
if(lista.DisplayLayout.Bands[0].Columns.Exists("SelectColumn"))
lista.DisplayLayout.Bands[0].Columns["SelectColumn"].SortIndicator = SortIndicator.Descending;
}
}
}
lista.DataBind();
nuovoDocumento.Dispose();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'upload di un nuovo documento - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
}
private void btnConfermaClick(object sender, EventArgs e)
{
emissioneRateValidationSummary.Validate();
if (emissioneRateValidationSummary.IsValid)
{
var listaRate = (from row in listaRateSoggetti.Rows where row.IsDataRow && (bool) row.Cells["SelectColumn"].Value select (DettaglioEmissioneRateDTO) row.ListObject).ToList();
var form = new DownloadFileAsync<List<DettaglioEmissioneRateDTO>>();
Func<List<DettaglioEmissioneRateDTO>, byte[]> getFile = rate => getRateCondominiService().EmissioneRateDaRichiamare((int)contoCorrente.Value, rate, causale.Text, intestazoneAzienda.Text);
form.LoadData(listaRate, getFile);
form.ShowDialog();
var docInfo = new DocumentInfo();
if (form.FileBody != null)
{
docInfo.Body = form.FileBody;
docInfo.FileName = nomeFileCbi.Text;
getManageDocumentService().Open(docInfo, "File CBI", true, MergeFieldType.Default);
CommonMessages.DisplayComplete("Le rate sono state correttamente emesse.");
}
else
CommonMessages.DisplayComplete("Si sono verificati dei problemi nell'emissione delle rate.");
Visible = false;
setWizardHome();
form.Dispose();
}
else
emissioneRateValidationSummary.ShowErrorSummary();
}
public RisultatoInvioMessaggioAllegati(IList<RisultatoInvioMessaggio> risultatoInvio, IList<DocumentInfo> allegati, DocumentInfo messaggioGenerato)
{
RisultatoInvio = risultatoInvio;
Allegati = allegati;
MessaggioGenerato = messaggioGenerato;
}
public FileCBIDTO ImportaFile(DocumentInfo doc, int idAzienda, LogTransazione logTransazione)
{
var anomalie = new List<RisultatoElaborazioneCBI>();
FileCBI file;
var fileGiaCaricato = false;
StreamReader objReader = null;
try
{
byte[] b;
using (var streamDecompress = new MemoryStream())
{
using (var gZipStream = new GZipStream(new MemoryStream(doc.Body), CompressionMode.Decompress))
{
b = new byte[doc.Length];
while (true)
{
var n = gZipStream.Read(b, 0, b.Length);
if (n > 0)
streamDecompress.Write(b, 0, n);
else
break;
}
}
}
// ------------------------------------------------------
// Controlli
// ------------------------------------------------------
var checkSum = Utility.GetFileChecksum(b);
var fileEsistente = _daoFactory.GetFileCBIDao().GetByChecksum(checkSum);
if (fileEsistente != null)
{
anomalie.Add(new RisultatoElaborazioneCBI { Tipo="Generico", Anomalie = "<strong>Il file è già stato caricato.</strong>" });
file = fileEsistente;
fileGiaCaricato = true;
}
else
{
// ------------------------------------------------------
// Creo file
// ------------------------------------------------------
const string extension = ".cbi";
var fileName = string.Format("CBI_{0:s}_{1}{2}", DateTime.Now, idAzienda.ToString(CultureInfo.InvariantCulture).PadRight(5, '0'), extension);
_documentService.SaveDocument(b, fileName, extension, checkSum, idAzienda);
file = new FileCBI(checkSum, _daoFactory.GetAziendaDao().GetById(idAzienda, false), logTransazione);
// ------------------------------------------------------
// Leggo file
// ------------------------------------------------------
var fileInfo = _documentService.GetFileInfo(checkSum, idAzienda);
objReader = new StreamReader(fileInfo.FullName);
// ------------------------------------------------------
// Carico l'elenco dei fornitori
// ------------------------------------------------------
var db = new FornitoreDataContext(_daoFactory.GetFornitoreDao().GetConnection().ConnectionString);
_fornitori = db.GetAll_Fornitori(idAzienda).ToList();
// ------------------------------------------------------
// Carico l'elenco delle persone relative all'azienda
// ------------------------------------------------------
_personeAzienda = PreLoadedCollection.Instance.GetPersone(idAzienda);
// ------------------------------------------------------
// Carico tutti i movimenti bancari caricati per l'azienda
// ------------------------------------------------------
// Per ora nessun controllo per movimenti bancari duplicati bugid#4010
//var listaMovimentiBancari = _daoFactory.GetMovimentoBancarioDao().GetMovimentiCaricatiByAzienda(idAzienda);
var listaMovimentiBancari = new List<MovimentiBancariControlloDuplicatiDTO>();
// ------------------------------------------------------
// Carico l'elenco dei dati bancari dei condomini
// ------------------------------------------------------
var datiBancari = _daoFactory.GetDatiBancariCondominiDao().GetByAzienda(idAzienda);
var contiBancari = _daoFactory.GetContoDao().GetAllByAziendaCodice(idAzienda, _pianoContiService.GetCodiceContoBancario());
var contiVersamentoCondomini = _daoFactory.GetContoDao().GetAllByAziendaCodice(idAzienda, _pianoContiService.GetCodiceContoVersamentiCondomini());
var causaleVersamento = _daoFactory.GetCausaleContabileDao().GetByCodice("RR");
// ------------------------------------------------------
// Elaboro il contenuto
// ------------------------------------------------------
var sLine = string.Empty;
var index = 0;
while (sLine != null)
{
try
{
index++;
sLine = objReader.ReadLine();
if (sLine != null)
{
// Controllo la prima riga
if (index == 1)
{
var risultatoCheck = checkFile(sLine);
if (risultatoCheck != null)
anomalie.Add(risultatoCheck);
if(anomalie.Count > 0)
return new FileCBIDTO { ID = 0, Risultato = anomalie };
}
// Individuo un blocco che inizia con un codice riconosciuto e finisce con "EF"
var blocco = string.Empty;
while ((string.IsNullOrEmpty(sLine) || sLine.Length < 3 || sLine.Substring(0, 3) != " EF") && !objReader.EndOfStream)
{
if (sLine != null)
{
blocco += sLine;
sLine = objReader.ReadLine();
}
}
blocco += sLine;
if(!string.IsNullOrEmpty(blocco))
anomalie.AddRange(elaboraBlocco(blocco, file, index, datiBancari, contiBancari, contiVersamentoCondomini, listaMovimentiBancari, causaleVersamento, logTransazione));
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante l'elaborazione della riga - {0} - sLine:{1}", ex, Utility.GetMethodDescription(), sLine);
throw;
}
}
_daoFactory.GetFileCBIDao().SaveOrUpdate(file);
//foreach (var testataContabile in file.TestateContabili)
// _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testataContabile);
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante l'importazione del file CBI - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), idAzienda);
throw;
}
finally
{
if (objReader != null)
objReader.Close();
}
var risultato = (from ris in anomalie
where ris != null
select ris).ToList();
if (risultato.Count > 0)
{
var messaggioFormattatoWarning = formattaMessaggiWarning(risultato);
if (!string.IsNullOrEmpty(messaggioFormattatoWarning))
{
var warnMessage = messaggioFormattatoWarning;
if (warnMessage.Length > 3500)
warnMessage = warnMessage.Substring(0, 3500);
_log.WarnFormat("Importazione File CBI - Warning verificatisi:{0}", warnMessage);
}
string messaggioFormattatoAnomalie = formattaMessaggiAnomalie(risultato);
if (!string.IsNullOrEmpty(messaggioFormattatoAnomalie))
{
var warnMessage = messaggioFormattatoAnomalie;
if (warnMessage.Length > 3500)
warnMessage = warnMessage.Substring(0, 3500);
_log.WarnFormat("Importazione File CBI - Anomalie verificatisi:{0}", warnMessage);
}
if (!fileGiaCaricato)
{
file.Messaggi = messaggioFormattatoWarning;
file.Anomalie = messaggioFormattatoAnomalie;
}
if(risultato.Any(item => !string.IsNullOrEmpty(item.Fatal)))
_persistenceContext.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
}
return new FileCBIDTO { ID = file.ID, Risultato = risultato };
}
public DocumentInfo GetDocument(string id, int idAzienda, TipoDocumentoArchiviazione tipoDocumento)
{
byte[] bytes = null;
var fileName = string.Empty;
try
{
var fileInfo = GetFileInfo(id, idAzienda);
if (fileInfo != null)
{
var infile = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.Read);
bytes = new byte[infile.Length];
infile.Read(bytes, 0, bytes.Length);
fileName = fileInfo.FullName;
infile.Position = 0;
infile.Dispose();
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il recupero del documento - {0} id:{1}", ex, Utility.GetMethodDescription(), id);
throw;
}
var fileExtension = string.Empty;
var fileNameToOpen = string.Empty;
if (!string.IsNullOrEmpty(fileName))
{
var file = new FileInfo(fileName);
fileNameToOpen = file.Name;
}
var document = new DocumentInfo(bytes, id, fileNameToOpen, fileExtension);
document.FileExtension = GetFileExtension(document);
return document;
}
private DocumentMessages saveDocument(DocumentoDTO documento, DocumentInfo docInfo)
{
return getDocumentoService().Save(documento, docInfo);
}
public string GetFileExtension(DocumentInfo document)
{
try
{
if (document.Body != null)
{
var stream = new MemoryStream(document.Body);
var format = FileFormatUtil.DetectFileFormat(stream);
if (format != null && format.LoadFormat != LoadFormat.Unknown)
return string.Format(".{0}", format.LoadFormat).ToLower();
}
return document.FileExtension;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'indetificazione del tipo di documento - {0} - fileId:{1}", ex, Utility.GetMethodDescription(), document.FileId);
throw;
}
}
private DocumentMessages saveDocument(byte[] data, string fileName, string descrizione, bool visibileCondomino)
{
try
{
var extension = string.Empty;
var pos = fileName.LastIndexOf(".");
if (fileName.Length > pos)
extension = fileName.Substring(pos);
var documento = new DocumentoDTO
{
FileName = fileName,
FileExtension = extension,
Descrizione = descrizione,
Tipo = "F - " + _fascicolo.Descrizione,
VisibileCondomino = visibileCondomino,
IdCondominio = _fascicolo.IdCondominio.GetValueOrDefault(),
IdFascicoli = new List<int> { _fascicolo.ID }
};
var docInfo = new DocumentInfo { FileName = fileName, Body = data };
return getDocumentoService().Save(documento, docInfo);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del documento - {0} - file:{1} - descrizione:{2}", ex, Gipasoft.Library.Utility.GetMethodDescription(), fileName, descrizione);
throw;
}
}
public string GetFileExtension(DocumentInfo document)
{
return ".pdf";
}
void manageDocumentDocumentSave(object sender, DocumentSaveArgs e)
{
switch (_documentoDto.FileExtension)
{
case ".rtf":
_documentoDto.Body = e.DocumentoRtf;
break;
case ".doc":
_documentoDto.Body = e.DocumentoDoc;
break;
case ".docx":
_documentoDto.Body = e.DocumentoDocX;
break;
case ".html":
case ".htm":
_documentoDto.Body = e.DocumentoHtml;
break;
}
var documentInfo = new DocumentInfo
{
Body = _documentoDto.Body,
FileExtension = _documentoDto.FileExtension,
FileId = _documentoDto.Checksum,
FileName = _documentoDto.FileName
};
Save(_documentoDto, documentInfo);
}
public string GetFileExtension(DocumentInfo document)
{
throw new InvalidOperationException("Il metodo GetFileInfo è ammesso solo per FSDocumentService");
}
public Form GetForm(DocumentInfo document)
{
_documentInfo = document;
_form = new RichTextForm(null);
return _form;
}
public DocumentInfo GetDocument(string id, int idAzienda, TipoDocumentoArchiviazione tipoDocumento)
{
try
{
if (!string.IsNullOrEmpty(id))
{
string anno = string.Empty;
if (id.Contains(" - "))
anno = id.Split('-')[2].Trim();
else if(id.Length >= 13)
anno = id.Substring(10, 4);
id = id.Replace(" - ", "");
// ========================================================================================
// Recupero anno di riferimento --> ANNO SPEDIZIONE
// ========================================================================================
if (tipoDocumento == TipoDocumentoArchiviazione.FatturaPassiva)
{
var spesa = _spesaService.GetByIdentificativo(idAzienda, id);
if (spesa != null)
anno = spesa.AnnoArchiviazioneOttica.GetValueOrDefault().ToString();
else
{
var testataMovimento = _movimentiContabiliService.GetByIdentificativo(idAzienda, id);
if (testataMovimento != null)
anno = testataMovimento.AnnoArchiviazioneOttica.GetValueOrDefault().ToString();
}
}
var document = _documentService.GetDocument(id, idAzienda, tipoDocumento);
if (document.Body == null)
{
var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(idAzienda);
if (impostazioni != null &&
!string.IsNullOrEmpty(impostazioni.NomeApplicazioneArchiviazioneOttica) &&
!string.IsNullOrEmpty(impostazioni.UtenteArchiviazioneOttica) &&
!string.IsNullOrEmpty(impostazioni.PasswordArchiviazioneOttica) &&
!string.IsNullOrEmpty(impostazioni.IndiceContrattiArchiviazioneOttica))
{
_service = new ArchivaASP.ArchivaASP {Timeout = 60*60*10000};
long mRsaKeyLength = 0;
//=========================================================================
// OGGETTI PER CRITTOGRAFIA
//=========================================================================
// ----------------------------------------------------
// Richiesta della chiave pubblica al server
// ----------------------------------------------------
var sKey = "";
if (_service.GetKey(ref sKey, ref mRsaKeyLength) != 0)
{
_log.ErrorFormat("Errore dal web service archiva - CHIAVE PUBBLICA DAL SERVER - {0} - application:{1} - user:{2} - password:{3} - id:{4}", Library.Utility.GetMethodDescription(), impostazioni.NomeApplicazioneArchiviazioneOttica, impostazioni.UtenteArchiviazioneOttica, impostazioni.PasswordArchiviazioneOttica, id);
return new DocumentInfo(new byte[0], id, null, null);
}
// creo il servizio RSA per il server
_mRsaServer = new RSACryptoServiceProvider((int) mRsaKeyLength);
var serverKey = (ArchivaASP_KEY) ArchivaASP_SERIALIZER.DeserializeObject(sKey, typeof (ArchivaASP_KEY));
var serverParameters = new RSAParameters {Exponent = serverKey.Exp, Modulus = serverKey.Mod};
_mRsaServer.ImportParameters(serverParameters);
//=========================================================================
// LOGIN
//=========================================================================
// creo il servizio RSA per il client
_mRsaClient = new RSACryptoServiceProvider((int) mRsaKeyLength);
var rsaParam = _mRsaClient.ExportParameters(false);
_mUserKey = new ArchivaASP_KEY {Mod = rsaParam.Modulus, Exp = rsaParam.Exponent};
// creo la struttura dei parametri
_mUserSession = new ArchivaASP_LOGIN
{
SessionId = 0,
Application = impostazioni.NomeApplicazioneArchiviazioneOttica,
User = impostazioni.UtenteArchiviazioneOttica,
Password = impostazioni.PasswordArchiviazioneOttica
};
// creo una index list vuota
var indexList = new ArchivaASP_INDEXLIST();
// Crypto service
var crypto = new ArchivaASP_CRY();
// cripto la descrizione XML dei parametri
var abXmlUserSession = crypto.EncryptXML(_mUserSession, _mUserSession.GetType(), _mRsaServer);
// cripto la chiave del client XML dei parametri
var abXmlUserKey = crypto.EncryptXML(_mUserKey, _mUserKey.GetType(), _mRsaServer);
byte[] abXmlIndexList;
// effettuo il login
var lLoginError = _service.Login(ref abXmlUserSession, abXmlUserKey, out abXmlIndexList);
// decripto le info di login
if (lLoginError == 0)
{
_mUserSession = (ArchivaASP_LOGIN)crypto.DecryptXML(abXmlUserSession, typeof(ArchivaASP_LOGIN), _mRsaClient);
indexList = (ArchivaASP_INDEXLIST)crypto.DecryptXML(abXmlIndexList, typeof(ArchivaASP_INDEXLIST), _mRsaClient);
}
else
{
_log.ErrorFormat("Errore dal web service archiva - LOGIN ERROR - {0} - application:{1} - user:{2} - password:{3} - id:{4}", Library.Utility.GetMethodDescription(), impostazioni.NomeApplicazioneArchiviazioneOttica, impostazioni.UtenteArchiviazioneOttica, impostazioni.PasswordArchiviazioneOttica, id);
}
//=========================================================================
// ESECUZIONE DELLA RICERCA - I PARAMETRI DEVONO SELEZIONARE UN SOLO DOCUMENTO
//=========================================================================
// ---------------------------------------------------
// Parametri di Login - abXmlUserSession
// ---------------------------------------------------
// cripto la descrizione XML dei parametri
abXmlUserSession = crypto.EncryptXML(_mUserSession, typeof (ArchivaASP_LOGIN), _mRsaServer);
// ---------------------------------------------------
// Lista degli indice selezionati - abXmlIndexList
// ---------------------------------------------------
// cripto la index list XML dei parametri
indexList.Indexes.Clear();
if (tipoDocumento == TipoDocumentoArchiviazione.Contratto)
indexList.Indexes.Add(impostazioni.IndiceContrattiArchiviazioneOttica);
else
// TODO: Calcolare l'anno corretto
indexList.Indexes.Add(impostazioni.IndiceFattureArchiviazioneOttica + " " + anno);
abXmlIndexList = crypto.EncryptXML(indexList, typeof (ArchivaASP_INDEXLIST), _mRsaServer);
// ---------------------------------------------------
// Lista dei campi selezionati - abXmlFieldName
// ---------------------------------------------------
// campi da visualizzare
var fieldList = new ArchivaASP_FIELDLIST();
fieldList.Fields.Add("IDENTIFICATIVO UNIVOCO");
// cripto la lista dei campi fornibili XML dei parametri
var abXmlFieldName = crypto.EncryptXML(fieldList, typeof(ArchivaASP_FIELDLIST), _mRsaServer);
// ---------------------------------------------------
// Condizioni di ricerca - abXmlFieldCondition
// ---------------------------------------------------
// TODO: Impostare qui i parametri di ricerca
var parameters = "=(IDENTIFICATIVO UNIVOCO, $" + id + "$)";
// cripto la condizione XML dei parametri
var abXmlFieldCondition = crypto.EncryptXML(parameters, typeof (String), _mRsaServer);
// ----------------------------------------------------------------
// Esecuzione della ricerca ritorna direttamente il documento PDF
// ----------------------------------------------------------------
byte[] abDocumentBuffer;
var lSearchError = _service.SearchDocumentWithUniqueData(abXmlUserSession, abXmlIndexList, abXmlFieldCondition, abXmlFieldName, out abDocumentBuffer);
if (lSearchError != 0)
{
var sError = "";
_service.GetErrorDescription(lSearchError, ref sError);
_log.ErrorFormat("Errore dal web service archiva - LETTURA DOCUMENTO - {0} - codice:{1} - descrizione:{2} - id:{3}", Library.Utility.GetMethodDescription(), lSearchError, sError, id);
_service.Logout(ref abXmlUserSession);
return new DocumentInfo(new byte[0], id, sError, null);
}
document = new DocumentInfo(abDocumentBuffer, id, "Archiva", ".pdf");
_documentService.SaveDocument(document.Body, id + ".pdf", ".pdf", id, idAzienda);
// Logout dal servizio
_service.Logout(ref abXmlUserSession);
}
}
else
document.FileName = "Archiva";
return document;
}
return new DocumentInfo(new byte[0], id, null, null);
}
catch(OutOfMemoryException ex)
{
_log.ErrorFormat("Errore inaspettato nel metodo - OUT OF MEMORY - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), id);
return new DocumentInfo(new byte[0], id, "Il documento in questo momento non è disponibile di prega di riprovare più tardi", null);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel metodo - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), id);
throw;
}
}