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();
 }
Exemplo n.º 2
0
 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();
 }
Exemplo n.º 4
0
        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; 
        }
Exemplo n.º 6
0
        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;
        }
Exemplo n.º 7
0
        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;
        }
Exemplo n.º 8
0
        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();
        }
Exemplo n.º 9
0
        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);
        }
Exemplo n.º 10
0
 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();
     }
 }
Exemplo n.º 11
0
        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();
            }
        }
Exemplo n.º 12
0
        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";
        }
Exemplo n.º 14
0
 public void ManageDocumentoPratica(DocumentInfo docInfo, IManageDocumentService manageDocService)
 {
     manageDocService.Open(docInfo);
 }
Exemplo n.º 15
0
        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;
        }
Exemplo n.º 16
0
 public ResultPagamento(string message, DocumentInfo documentInfo, IList<ReportPagamentoDTO> pagamenti)
 {
     Message = message;
     DocumentInfo = documentInfo;
     Pagamenti = pagamenti;
 }
Exemplo n.º 17
0
        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;
        }
Exemplo n.º 18
0
        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;
            }
        }
Exemplo n.º 19
0
        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();

        }
Exemplo n.º 20
0
 public RisultatoInvioMessaggioAllegati(IList<RisultatoInvioMessaggio> risultatoInvio, IList<DocumentInfo> allegati, DocumentInfo messaggioGenerato)
 {
     RisultatoInvio = risultatoInvio;
     Allegati = allegati;
     MessaggioGenerato = messaggioGenerato;
 }
Exemplo n.º 21
0
        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 };
        }
Exemplo n.º 22
0
        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;
        }
Exemplo n.º 23
0
 private DocumentMessages saveDocument(DocumentoDTO documento, DocumentInfo docInfo)
 {
     return getDocumentoService().Save(documento, docInfo);
 }
Exemplo n.º 24
0
        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;
            }
        }
Exemplo n.º 25
0
        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;
            }
        }
Exemplo n.º 26
0
 public string GetFileExtension(DocumentInfo document)
 {
     return ".pdf";
 }
Exemplo n.º 27
0
        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);
        }
Exemplo n.º 28
0
 public string GetFileExtension(DocumentInfo document)
 {
     throw new InvalidOperationException("Il metodo GetFileInfo è ammesso solo per FSDocumentService");
 }
Exemplo n.º 29
0
 public Form GetForm(DocumentInfo document)
 {
     _documentInfo = document;
     _form = new RichTextForm(null);
     return _form;
 }
Exemplo n.º 30
0
        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;
            }
        }