Пример #1
0
 public IList<FornitoreListaDTO> GetAllByAzienda()
 {
     try
     {
         _log.DebugFormat("Lettura fornitori per azienda");
         var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
         var db = new FornitoreDataContext(daoFactory.GetFornitoreDao().GetConnection().ConnectionString);
         _log.DebugFormat("Lettura fornitori per azienda - {0}", daoFactory.GetFornitoreDao().GetConnection().ConnectionString);
         
         return db.GetAll_Fornitori(_info.Azienda).ToList();
     }
     catch (Exception ex)
     {
         _log.ErrorFormat("Errore nel caricamento dei fornitori - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), _info.Azienda);
         throw;
     }
 }
Пример #2
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 };
        }
Пример #3
0
 public ContoDTO GetContoBancarioByEsercizio(int idEsercizio)
 {
     try
     {
         var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
         var pianoContiService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IPianoContiService>();
         var esercizio = daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
         var db = new FornitoreDataContext(daoFactory.GetFornitoreDao().GetConnection().ConnectionString);
         var fornitori = db.GetAll_Fornitori(_info.Azienda);
         return (from conto in esercizio.Conti where conto.Codice == pianoContiService.GetCodiceContoBancario() && string.IsNullOrEmpty(conto.Deleted) select setContoDto(conto, idEsercizio, false, fornitori, false)).FirstOrDefault();
     }
     catch (Exception ex)
     {
         _log.ErrorFormat("Errore nel caricamento del conto bancario - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
         throw;
     }
 }
Пример #4
0
        public FornitoreListaDTO[] GetFornitoriByCondominioId(int id)
        {
            try
            {
                var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
                var db = new FornitoreDataContext(daoFactory.GetFornitoreDao().GetConnection().ConnectionString);

                FornitoreListaDTO[] fornitori = (from fornitore in db.GetAll_FornitoriByCondominio(id)
                                                 select fornitore).ToArray<FornitoreListaDTO>();

                return fornitori;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nel caricamento dei fornitori - {0} - id:{1}", ex, Utility.GetMethodDescription(), id);
                throw;
            }

        }
Пример #5
0
        private IEnumerable<FornitoreListaDTO> getFornitori(int idAzienda)
        {
            if (_fornitori == null)
            {
                var db = new FornitoreDataContext(_daoFactory.GetFornitoreDao().GetConnection().ConnectionString);
                _fornitori = db.GetAll_Fornitori(idAzienda).ToList();                
            }

            return _fornitori;
        }