コード例 #1
0
ファイル: MillesimoRepository.cs プロジェクト: gipasoft/Sfera
 public MillesimoDTO GetByDomainEntity(Millesimo item)
 {
     try
     {
         return setDto(item);
     }
     catch (Exception ex)
     {
         _log.Error("Errore nel caricamento dei millesimi: " + Library.Utility.GetMethodDescription() + " - id:" + item.ID, ex);
         throw;
     }
 }
コード例 #2
0
ファイル: Millesimo.cs プロジェクト: gipasoft/Sfera
 public virtual IUpdatableBusinessEntity Copy()
 {
     var millesimo = new Millesimo(ContoRiferimento, null);
     return millesimo;
 }
コード例 #3
0
        public void SetUp()
        {
            _azienda = new Azienda("PROVA", "Azienda di prova") {ID=1};
            _aziendaDestinazione = new Azienda("DEST", "Azienda di destinazione") { ID = 2 };
            _condominio = new Condominio("Condominio ABC", 31, 12, 2015, _azienda)
            {
                ID = 1,
                Codice = "COND01",
                CodiceCUC = "CUC123456",
                CodiceSIA = "SIA12",
                AnnoInizio = 2015,
                CodiceFiscale = "012365477859",
                CodiceCalcoloTariffaAcqua = "TAR01"
            };
            _condominio.Palazzine.Clear();

            _esercizio = new EsercizioDTO
            {
                Descrizione = "Primo Esercizio",
                DataApertura = new DateTime(2016, 6, 1),
                DataChiusura = new DateTime(2017, 5, 31)
            };

            _banca01 = new DatiBancariCondomini("12345", "12345", "123456789012", "A", _condominio) {Iban = "IT02L1234512345123456789012" };
            _banca02 = new DatiBancariCondomini("03268", "10001", "100000000000", "A", _condominio) { Iban = "IT11X03268100001100000000000" };

            _stabile01 = new Palazzina(_condominio, "Stabile 01") {ID=1};
            _stabile01.GruppiStabile.Clear();
            _condominio.Palazzine.Add(_stabile01);

            var comune = new Comune("A944", "Bologna", new Provincia("BO", new Regione("Emilia Romagna")));

            _gruppoStabile01 = new GruppoStabile(_stabile01, "Scala 01") { ID = 1, Ordine = 1, Note = "Note per Scala01", Indirizzo = new Address { Cap = "40131", Civico = "SCA/1", Indirizzo = "Via Scala01", Localita = "Scaletta01", Comune = comune } };
            _gruppoStabile02 = new GruppoStabile(_stabile01, "Scala 02") { ID = 2, Ordine = 2, Note = "Note per Scala02", Indirizzo = new Address { Cap = "40132", Civico = "SCA/2", Indirizzo = "Via Scala02", Localita = "Scaletta02", Comune = comune } };

            _condominio.Indirizzo = new Address
            {
                Indirizzo = "via dei Fiori",
                Cap = "40100",
                Civico = "23",
                Localita = "Pioppa",
                Comune = comune
            };

            var listaTipoUnitaImmobiliare = new List<TipoUnitaImmobiliare>
            {
                new TipoUnitaImmobiliare("Tipo01") {ID = 1},
                new TipoUnitaImmobiliare("Tipo02") {ID = 2}
            };

            var fornitore = new Fornitore(new Persona(TipoPersonaEnum.Giuridica, "Franco", "Livoresi", _azienda.ID, true) {PartitaIva = "01867511204"}, _azienda.ID) {ID =1};
            var fornitore01 = new Fornitore(new Persona(TipoPersonaEnum.Giuridica, "Luigi", "Majorana", _azienda.ID, true) { PartitaIva = "01230460394" }, _azienda.ID) {ID = 2};
            var agenziaAssicurativa = new AgenziaAssicurativa(new Persona(TipoPersonaEnum.Giuridica, "", "Agenzia Bologna", _azienda.ID, true) { PartitaIva = "03211600402" }, fornitore01, "Agenzia BO", _azienda.ID) {ID = 3};
            var tipoContratto = new TipoContratto("Pulizia Scale") {ID=1};
            var tipoContrattoAssicurativo = new TipoContratto("Assicurazione") {ID=2};

            _unitaImmobiliare01 = new UnitaImmobiliare(_gruppoStabile01, listaTipoUnitaImmobiliare[0]) { ID = 1, Descrizione = "Unità 01", Ordine = 1};
            _unitaImmobiliare02 = new UnitaImmobiliare(_gruppoStabile01, new TipoUnitaImmobiliare("Tipo02")) { ID = 2, Descrizione = "Unità 02", Ordine = 2 }; 
            _unitaImmobiliare03 = new UnitaImmobiliare(_gruppoStabile02, listaTipoUnitaImmobiliare[1]) { ID = 3, Descrizione = "Unità 03", Ordine = null }; 
            _unitaImmobiliare04 = new UnitaImmobiliare(_gruppoStabile02, new TipoUnitaImmobiliare("Tipo NEW")) { ID = 4, Descrizione = "Unità 04", Ordine = 4 };

            _unitaImmobiliare01.CondizioniSicurezzaImpianto = new SicurezzaImpianto
            {
                Norma = true,
                Note = "Note01"
            };

            _unitaImmobiliareImpiantistica01 = new UnitaImmobiliareImpiantistica(_unitaImmobiliare01, "TipoImpianto01", true) { ID = 1, Descrizione = "Impianto 01"};
            _unitaImmobiliareImpiantistica02 = new UnitaImmobiliareImpiantistica(_unitaImmobiliare01, "TipoImpianto02", false) {ID = 2, Descrizione = "Impianto 02"};

            _persona01 = new Persona(TipoPersonaEnum.Fisica, "Mario", "Rossi", _azienda.ID, false)
            {
                ID = 1,
                ComuneNascita = comune,
                IndirizzoResidenza =
                    new Address
                    {
                        Indirizzo = "via residenza01",
                        Cap = "40101",
                        Civico = "1",
                        Comune = comune,
                        Localita = "Pioppa 01"
                    },
                Domicilio =
                    new Address
                    {
                        Indirizzo = "via domicilio01",
                        Cap = "40101",
                        Civico = "1",
                        Comune = comune,
                        Localita = "Pioppa 01"
                    },
                Recapito =
                    new Address
                    {
                        Indirizzo = "via recapito01",
                        Cap = "40101",
                        Civico = "1",
                        Comune = comune,
                        Localita = "Pioppa 01"
                    }
            };

            _proprietario01 = new Proprietario(_unitaImmobiliare01, _persona01) {ID = 1, Descrizione = "Mario Rossi", VersamentoMav = true, Consigliere = true, Principale = true};

            _persona02 = new Persona(TipoPersonaEnum.Giuridica, "Giulio", "Verdi", _azienda.ID, false)
            {
                ID = 2,
                ComuneNascita = comune,
                IndirizzoResidenza =
                    new Address
                    {
                        Indirizzo = "via residenza02",
                        Cap = "40102",
                        Civico = "2",
                        Comune = comune,
                        Localita = "Pioppa 02"
                    },
                Domicilio =
                    new Address
                    {
                        Indirizzo = "via domicilio02",
                        Cap = "40102",
                        Civico = "2",
                        Comune = comune,
                        Localita = "Pioppa 02"
                    },
                Recapito =
                    new Address
                    {
                        Indirizzo = "via recapito02",
                        Cap = "40102",
                        Civico = "2",
                        Comune = comune,
                        Localita = "Pioppa 02"
                    }
            };
            _proprietario02 = new Proprietario(_unitaImmobiliare02, _persona02) {ID = 2, Descrizione = "Giulio Verdi", DataInizio = new DateTime(2015, 1, 1)};

            _persona03 = new Persona(TipoPersonaEnum.Fisica, "Franco", "Bianchi", _azienda.ID, false)
            {
                ID = 3,
                IndirizzoResidenza =
                    new Address
                    {
                        Indirizzo = "via residenza03",
                        Cap = "40103",
                        Civico = "3",
                        Comune = comune,
                        Localita = "Pioppa 03"
                    },
                Domicilio =
                    new Address
                    {
                        Indirizzo = "via domicilio03",
                        Cap = "40103",
                        Civico = "3",
                        Comune = comune,
                        Localita = "Pioppa 03"
                    }
            };
            _persona01.Recapito = new Address { Indirizzo = "via recapito03", Cap = "40103", Civico = "3", Comune = comune, Localita = "Pioppa 03" };
            _proprietario03 = new Proprietario(_unitaImmobiliare03, _persona03) {ID = 3, Descrizione = "Franco Bianchi"};

            _proprietario04 = new Proprietario(_unitaImmobiliare04, _persona01)
            {
                ID = 4,
                SoggettoPrincipale = _proprietario01
            };

            _persona04 = new Persona(TipoPersonaEnum.Fisica, "Primo", "Conduttore", _azienda.ID, false)
            {
                ID = 4,
                IndirizzoResidenza =
                    new Address
                    {
                        Indirizzo = "via residenza04",
                        Cap = "40104",
                        Civico = "4",
                        Comune = comune,
                        Localita = "Pioppa 04"
                    },
                Domicilio =
                    new Address
                    {
                        Indirizzo = "via domicilio04",
                        Cap = "40104",
                        Civico = "4",
                        Comune = comune,
                        Localita = "Pioppa 04"
                    },
                Recapito =
                    new Address
                    {
                        Indirizzo = "via recapito04",
                        Cap = "40104",
                        Civico = "4",
                        Comune = comune,
                        Localita = "Pioppa 04"
                    }
            };
            _conduttore01 = new Conduttore(_unitaImmobiliare01, _persona04) {ID = 5, Descrizione = "Primo Conduttore"};

            _persona05 = new Persona(TipoPersonaEnum.Fisica, "Secondo", "Conduttore", _azienda.ID, false)
            {
                ID = 5,
                IndirizzoResidenza =
                    new Address
                    {
                        Indirizzo = "via residenza05",
                        Cap = "40105",
                        Civico = "5",
                        Comune = comune,
                        Localita = "Pioppa 05"
                    },
                Domicilio =
                    new Address
                    {
                        Indirizzo = "via domicilio05",
                        Cap = "40105",
                        Civico = "5",
                        Comune = comune,
                        Localita = "Pioppa 05"
                    },
                Recapito =
                    new Address
                    {
                        Indirizzo = "via recapito05",
                        Cap = "40105",
                        Civico = "5",
                        Comune = comune,
                        Localita = "Pioppa 05"
                    }
            };
            _conduttore02 = new Conduttore(_unitaImmobiliare02, _persona05) {ID = 6, Descrizione = "Secondo Conduttore"};

            _contatto01 = new Email("[email protected]", true, _persona01) { ID = 1, Descrizione = "mail principale persona 01"};
            _contatto02 = new Email("[email protected]", false, _persona01) { ID = 2, Descrizione = "mail secondaria persona 01" };
            _contatto03 = new Cellulare("1234567890", true, _persona01) { ID = 3, Descrizione = "cellulare principale persona 01" };
            _contatto04 = new Fax("9876543210", false, _persona02) { ID = 4, Descrizione = "fax persona 02" };
            _contatto05 = new Telefono("1357924680", true, _persona03) { ID = 5, Descrizione = "telefono persona 03" }; 
            _contatto06 = new EmailCertificata("[email protected]", true, _persona01) { ID = 6, Descrizione = "mail certificata persona 01" };
            _contatto07 = new SitoInternet("www.bianchi.it", false, _persona03) { ID = 7, Descrizione = "sito internet persona03" };
            _contatto08 = new Telefono("3333333333", false, _persona04) { ID = 8, Descrizione = "telefono persona 04" };
            _contatto09 = new Cellulare("9999999999", true, _persona05) { ID = 9, Descrizione = "cellulare persona 05" };
            _contatto10 = new Email("[email protected]", false, _persona05) { ID=10 };

            _condominio.PersoneDaNonSollecitare.Add(new PersonaDaNonSollecitare(_persona01, _condominio) { Motivo = "persona01 non paga" });
            _condominio.PersoneDaNonSollecitare.Add(new PersonaDaNonSollecitare(_persona03, _condominio) { Motivo = "persona02 è simpatica" });

            // Contratto Appalto
            _documentocontrattoAppalto01 = new Documento(201, "Appalto", true, _azienda) { ID = 1, CondominioRiferimento = _condominio, Checksum = "CHK001", FileName = "appalto01", FileExtension = "pdf", Descrizione = "Appalto001" };
            _documentocontrattoAppalto02 = new Documento(202, "Appalto", true, _azienda) { ID = 2, CondominioRiferimento = _condominio, Checksum = "CHK002", FileName = "appalto02", FileExtension = "pdf", Descrizione = "Appalto002" };

            _contrattoAppalto = new ContrattoAppalto(tipoContratto, _condominio, fornitore)
            {
                ID = 1,
                NumeroContratto = "CONTRA001",
                Scadenza = new DateTime(2016, 12, 31),
                Descrizione = "Contratto di Appalto di prova",
                Note = "Nota per contratto appalto",
                Documenti = { _documentocontrattoAppalto01, _documentocontrattoAppalto02 }
            };

            _documentocontrattoAppalto01.ContrattoRiferimento = _contrattoAppalto;
            _documentocontrattoAppalto02.ContrattoRiferimento = _contrattoAppalto;

            // Contratto Assicurativo
            _documentocontrattoAssicurativo01 = new Documento(203, "Assicurativo01", true, _azienda) { ID = 3, CondominioRiferimento = _condominio, Checksum = "CHK003", FileName = "assicurazione01", FileExtension = "pdf", Descrizione = "Assicurazione001" };
            _documentocontrattoAssicurativo02 = new Documento(204, "Assicurativo02", true, _azienda) { ID = 4, CondominioRiferimento = _condominio, Checksum = "CHK004", FileName = "assicurazione02", FileExtension = "pdf", Descrizione = "Assicurazione002" };

            _contrattoAssicurativo = new AssicurazioneContratto(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
            {
                ID = 2,
                FornitoreAttuale = agenziaAssicurativa,
                NumeroContratto = "CONTR_ASS_001",
                Scadenza = new DateTime(2016, 12, 31),
                Descrizione = "Contratto Assicurativo di prova",
                Note = "Nota per contratto assicurativo",
                Documenti = { _documentocontrattoAssicurativo01, _documentocontrattoAssicurativo02 }
            };

            _contrattoAssicurativoGlobale = new GlobaleAssicurazione(new DateTime(2016, 11, 30),
                new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
            {
                ID = 3,
                FornitoreAttuale = agenziaAssicurativa,
                NumeroContratto = "CONTR_GLOB_001",
                Scadenza = new DateTime(2016, 12, 31),
                ImportoLimiteCoseRCT = 50000,
                ImportoMassimaleSinistroRCT = 60000,
                ImportoUnicoRCT = 70000,
                ImportoPremio = 80000,
                Descrizione = "Contratto Globale di prova",
                Note = "Nota per contratto globale",
                FranchigiaDanniAcqua = 90000,
                FranchigiaRicercaGuasto = 100000,
                ValoreRicostruzioneNuovo = 110000,
                DanniAcqua = true,
                RicercaGuasto = true
            };

            _contrattoAssicurativoIncendio = new IncendioAssicurazione(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
            {
                ID = 4,
                FornitoreAttuale = agenziaAssicurativa,
                NumeroContratto = "CONTR_INC_001",
                ImportoLimiteCoseRCT = 150000,
                ImportoMassimaleSinistroRCT = 160000,
                ImportoUnicoRCT = 170000,
                ImportoPremio = 180000,
                FranchigiaDanniAcqua = 120000,
                FranchigiaRicercaGuasto = 130000,
                ValoreRicostruzioneNuovo = 140000,
                DanniAcqua = true,
                RicercaGuasto = false,
                Scadenza = new DateTime(2016, 12, 31),
                Descrizione = "Contratto Incendio di prova",
                Note = "Nota per contratto incendio"
            };

            _contrattoAssicurativoFurto = new FurtoAssicurazione(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
            {
                ID = 5,
                FornitoreAttuale = agenziaAssicurativa,
                NumeroContratto = "CONTR_FURTO_001",
                Scadenza = new DateTime(2016, 12, 31),
                Descrizione = "Contratto Furto di prova",
                Note = "Nota per contratto furto"
            };

            _contrattoAssicurativoInfortuni = new InfortuniAssicurazione(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
            {
                ID = 6,
                FornitoreAttuale = agenziaAssicurativa,
                NumeroContratto = "CONTR_INFORTUNI_001",
                Scadenza = new DateTime(2016, 12, 31),
                Descrizione = "Contratto Infortuni di prova",
                Note = "Nota per contratto infortuni"
            };

            _contrattoAssicurativoResponsabilitaCivile = new ResponsabilitaCivileAssicurazione(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
            {
                ID = 7,
                FornitoreAttuale = agenziaAssicurativa,
                NumeroContratto = "CONTR_RESPCIV_001",
                Scadenza = new DateTime(2016, 12, 31),
                Descrizione = "Contratto Responsabilità civile di prova",
                Note = "Nota per contratto responsabilità civile"
            };

            _condominio.ContrattiAssicurativi.Add(_contrattoAssicurativo);
            _condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoGlobale);
            _condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoIncendio);
            _condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoFurto);
            _condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoInfortuni);
            _condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoResponsabilitaCivile);

            _contrattoAssicurativo.CondominioRiferimento = _condominio;
            _contrattoAssicurativoGlobale.CondominioRiferimento = _condominio;
            _contrattoAssicurativoIncendio.CondominioRiferimento = _condominio;
            _contrattoAssicurativoFurto.CondominioRiferimento = _condominio;
            _contrattoAssicurativoInfortuni.CondominioRiferimento = _condominio;
            _contrattoAssicurativoResponsabilitaCivile.CondominioRiferimento = _condominio;

            _documentocontrattoAssicurativo01.ContrattoRiferimento = _contrattoAssicurativo;
            _documentocontrattoAssicurativo02.ContrattoRiferimento = _contrattoAssicurativo;
            
            // Conti / Millesimi
            _conto01 = new Conto(_condominio, TipoContoEconomicoEnum.Economico, TipoPeriodoCompetenzaContabile.Esercizio, "SPESE GENERALI PROPRIETA'", true, true, false) {DescrizioneBilancio = "SPE GEN", Codice = "001", ID = 1};
            _conto02 = new Conto(_condominio, TipoContoEconomicoEnum.Economico, TipoPeriodoCompetenzaContabile.Riscaldamento, "SPESE RISCALDAMENTO", true, true, false) { DescrizioneBilancio = "SPE RIS", Codice = "002",  ID = 2 };

            _sottoconto01 = new SottoConto(_conto01, "SPESE SCALA 01") { Codice = "001.001", ID = 1 };
            _sottoconto02 = new SottoConto(_conto01, "SPESE SCALA 02") { Codice = "001.002", ID = 2 };
            _sottoconto03 = new SottoConto(_conto02, "SPESE ABITAZIONI") { Codice = "002.001", ID = 3 };
            _sottoconto04 = new SottoConto(_conto02, "SPESE GARAGE") { Codice = "002.002", ID = 4 };

            _millesimo01 = new Millesimo(_conto01, _unitaImmobiliare01) { ID = 1, Valore = 100 };
            _millesimo02 = new Millesimo(_conto01, _unitaImmobiliare02) { ID = 2, Valore = 200 };
            _millesimo03 = new Millesimo(_conto02, _unitaImmobiliare01) { ID = 3, Valore = 300 };
            _millesimo04 = new Millesimo(_conto02, _unitaImmobiliare02) { ID = 4, Valore = 400 };

            _fascicoloImmobiliare = new FascicoloImmobiliare("Prova Fascicolo", "PRO", "01") {ID=1};
            _fascicoloCondominio = new FascicoloCondominio(_fascicoloImmobiliare, _condominio) { ID =1, Necessario = true, Presente = false };
            _fascicoloCondominio.Documenti.Add(_documentocontrattoAppalto01);
            _fascicoloCondominio.Documenti.Add(_documentocontrattoAssicurativo02);
            _documentocontrattoAppalto01.Fascicoli.Add(_fascicoloCondominio);
            _documentocontrattoAssicurativo02.Fascicoli.Add(_fascicoloCondominio);

            // Stub per IDaoFactory
            _daoFactory = MockRepository.GenerateStub<IDaoFactory>();

            // Stub per azienda
            var aziendaDao = MockRepository.GenerateStub<IAziendaDao>();
            aziendaDao.Stub(x => x.Find(2, false)).Return(_aziendaDestinazione);
            _daoFactory.Stub(x => x.GetAziendaDao()).Return(aziendaDao);

            // Stub per tipo unità immobiliare
            var tipoUnitaImmobiliareDao = MockRepository.GenerateStub<ITipoUnitaImmobiliareDao>();
            tipoUnitaImmobiliareDao.Stub(x => x.GetByAzienda(Arg<int>.Is.Anything)).Return(listaTipoUnitaImmobiliare);
            _daoFactory.Stub(x => x.GetTipoUnitaImmobiliareDao()).Return(tipoUnitaImmobiliareDao);

            // Stub per fornitore
            var fornitoreDao = MockRepository.GenerateStub<IFornitoreDao>();
            fornitoreDao.Stub(x => x.Find(1, false)).Return(fornitore);
            fornitoreDao.Stub(x => x.Find(2, false)).Return(fornitore01);
            fornitoreDao.Stub(x => x.GetByPartitaIva("01867511204", _aziendaDestinazione.ID)).Return(fornitore);
            fornitoreDao.Stub(x => x.GetByPartitaIva("01230460394", _aziendaDestinazione.ID)).Return(fornitore01);
            fornitoreDao.Stub(x => x.GetByPartitaIva("03211600402", _aziendaDestinazione.ID)).Return(agenziaAssicurativa);
            _daoFactory.Stub(x => x.GetFornitoreDao()).Return(fornitoreDao);

            // Stub per tipo contratto
            var tipoContrattoDao = MockRepository.GenerateStub<ITipoContrattoDao>();
            tipoContrattoDao.Stub(x => x.GetByDescrizione("Pulizia Scale", _aziendaDestinazione.ID)).Return(tipoContratto);
            tipoContrattoDao.Stub(x => x.GetByDescrizione("Assicurazione", _aziendaDestinazione.ID)).Return(tipoContrattoAssicurativo);
            _daoFactory.Stub(x => x.GetTipoContrattoDao()).Return(tipoContrattoDao);

            // Stub per Comune
            var comuneDao = MockRepository.GenerateStub<IComuneDao>();
            comuneDao.Stub(x => x.Find(comune.Codice, false)).Return(comune);
            comuneDao.Stub(x => x.Find(null, false)).Throw(new NullReferenceException("Id non può essere null"));
            _daoFactory.Stub(x => x.GetComuneDao()).Return(comuneDao);
            
            // Stub per fascicolo immobiliare
            _fascicoloImmobiliareDao = MockRepository.GenerateStub<IFascicoloImmobiliareDao>();
            _fascicoloImmobiliareDao.Stub(x => x.GetByAzienda(_aziendaDestinazione.ID)).Return(new List<FascicoloImmobiliare> { _fascicoloImmobiliare });
            _daoFactory.Stub(x => x.GetFascicoloImmobiliareDao()).Return(_fascicoloImmobiliareDao);

            _documentService = MockRepository.GenerateStub<IDocumentService>();
            _exportCsvCondominiService = new ExportCsvCondominiService();
            _importCsvCondominiService = new ImportCsvCondominiService(_daoFactory, _documentService);
        }
コード例 #4
0
        private string loadCondominio(string codiceCondominio, Azienda azienda, OleDbConnection conn)
        {
            string message = string.Empty;

            // ===========================================================================================================
            //  Lettura Tabelle
            // ===========================================================================================================

            // ----------------------------------------------------------------------------------
            //  Condomini
            // ----------------------------------------------------------------------------------
            var condominioAdapter = new OleDbDataAdapter("SELECT * FROM TabCondomìni WHERE TabCondomìni.Codice = '" + codiceCondominio + "'", conn);

            var dsCondomini = new DataSet("Condomini");
            condominioAdapter.Fill(dsCondomini, "TabCondomìni");

            if (dsCondomini.Tables["TabCondomìni"].Rows.Count > 0)
            {
                var rowCondominio = dsCondomini.Tables["TabCondomìni"].Rows[0];

                var esercizioAdapter = new OleDbDataAdapter("SELECT * FROM TabEsercizi WHERE idCondominio = " + rowCondominio["id"] + " AND TabEsercizi.Attivo = True AND TabEsercizi.Straordinario = False AND (TabEsercizi.Nome LIKE 'ORDINARIO%' OR TabEsercizi.Nome LIKE '0RDINARIO%') ORDER BY DataF DESC", conn);
                esercizioAdapter.Fill(dsCondomini, "TabEsercizi");

                if (dsCondomini.Tables["TabEsercizi"].Rows.Count > 0)
                {
                    var rowEsercizio = dsCondomini.Tables["TabEsercizi"].Rows[0];

                    var dataInizioEsercizio = (DateTime)rowEsercizio["DataI"];
                    var dataFineEsercizio = (DateTime)rowEsercizio["DataF"];

                    Condominio condominio = _daoFactory.GetCondominioDao().GetByCodice(codiceCondominio.PadLeft(3, '0'), azienda.ID);
                    if (condominio == null)
                    {
                        condominio = new Condominio(rowCondominio["Nome"].ToString(), dataFineEsercizio.Day, dataFineEsercizio.Month, dataFineEsercizio.Year + 1, azienda) {Codice = codiceCondominio.PadLeft(3, '0')};
                        _daoFactory.GetCondominioDao().SaveOrUpdate(condominio);
                        addDefault(condominio);
                    }
                    else
                    {
                        // ======================================================================================
                        // Eliminazione vecchi dati
                        // ======================================================================================
                        foreach (UnitaImmobiliare unita in _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(condominio.ID))
                        {
                            foreach (Millesimo mill in unita.Millesimi)
                            {
                                mill.UnitaRiferimento = null;
                                mill.ContoRiferimento = null;
                            }
                            unita.Millesimi.Clear();
                            unita.GruppoStabileRiferimento.UnitaImmobiliari.Remove(unita);
                            _daoFactory.GetUnitaImmobiliareDao().Delete(unita);
                        }

                        foreach (Palazzina stabileDelete in condominio.Palazzine)
                        {
                            foreach (GruppoStabile gruppo in stabileDelete.GruppiStabile)
                                gruppo.PalazzinaRiferimento = null;
                            stabileDelete.CondominioRiferimento = null;
                        }
                        condominio.Palazzine.Clear();

                        var stabileFirst = new Palazzina(condominio, "Stabile A");
                        _daoFactory.GetPalazzinaDao().SaveOrUpdate(stabileFirst);

                        // Dati Bancari
                        foreach (DatiBancariCondomini banca in condominio.DatiBancari)
                        {
                            foreach (MovimentoBancario mov in banca.MovimentiBancari)
                            {
                                mov.Condominio = null;
                                mov.Banca = null;
                                mov.Fornitore = null;
                                mov.Esercizio = null;
                                mov.File = null;
                            }

                            banca.CondominioRiferimento = null;
                        }
                        condominio.DatiBancari.Clear();

                        // Piano Conti
                        foreach (Conto contoDelete in condominio.Conti)
                        {
                            contoDelete.CondominioRiferimento = null;
                            contoDelete.Millesimi.Clear();
                        }
                        condominio.Conti.Clear();

                        // Modelli Ripartizione
                        foreach (ModelloRegistrazioneContabile modello in condominio.ModelliRegistrazioneContabile)
                            modello.CondominioRiferimento = null;
                        condominio.ModelliRegistrazioneContabile.Clear();

                        // Esercizi
                        foreach (Esercizio esercizioDelete in condominio.Esercizi)
                        {
                            esercizioDelete.AnnoGestionale.Esercizi.Remove(esercizioDelete);
                            _daoFactory.GetEsercizioDao().Delete(esercizioDelete);
                        }
                        condominio.Esercizi.Clear();

                        // Anno Gestionale
                        foreach (AnnoGestionale anno in condominio.AnniGestionali)
                            _daoFactory.GetAnnoGestionaleDao().Delete(anno);
                        condominio.AnniGestionali.Clear();
                        // ======================================================================================

                        condominio.Descrizione = rowCondominio["Nome"].ToString();

                        // ======================================================================================
                        //  Default del condominio
                        // ======================================================================================

                        // Conti comuni del Piano dei conti
                        IList<PianoConti> conti = _daoFactory.GetPianoContiDao().GetByAzienda(azienda.ID);
                        foreach (PianoConti pianoConto in conti)
                        {
                            if(pianoConto.IsRequired)
                                pianoConto.ConvertToConto(condominio);
                        }

                        // Nuovo esercizio
                        DateTime inizioEsercizioOld = dataInizioEsercizio;
                        DateTime fineEsercizioOld = dataFineEsercizio;
                        var annoNew = new AnnoGestionale(condominio, inizioEsercizioOld.AddYears(1).Year, fineEsercizioOld.AddYears(1).Year);
                        _daoFactory.GetAnnoGestionaleDao().SaveOrUpdate(annoNew);
                        var esercizioNew = new Esercizio(condominio, inizioEsercizioOld.AddYears(1), fineEsercizioOld.AddYears(1), annoNew, Sfera.Enums.GestioneEsercizioEnum.Ordinario);
                        _daoFactory.GetEsercizioDao().SaveOrUpdate(esercizioNew);
                    }

                    condominio.CodiceImportazione = rowCondominio["id"].ToString().Trim();

                    if (rowCondominio["Note"] != DBNull.Value && !string.IsNullOrEmpty(rowCondominio["Note"].ToString()))
                        condominio.Note = rowCondominio["Note"].ToString();

                    if (rowCondominio["CF"] != DBNull.Value && !string.IsNullOrEmpty(rowCondominio["CF"].ToString()))
                        condominio.CodiceFiscale = rowCondominio["CF"].ToString().Trim();

                    // ----------------------------
                    // Banche
                    // ----------------------------
                    var bancheCondominiAdapter = new OleDbDataAdapter("SELECT * FROM TabBanche INNER JOIN TabBanche_Condomìni ON TabBanche.id = TabBanche_Condomìni.idBanca WHERE TabBanche_Condomìni.idCondominio = " + rowCondominio["id"], conn);
                    bancheCondominiAdapter.Fill(dsCondomini, "Banche");

                    foreach (DataRow rowBanca in dsCondomini.Tables["Banche"].Rows)
                    {
                        try
                        {
                            if (rowBanca["TabBanche_Condomìni.Attivo"] != DBNull.Value && (bool)rowBanca["TabBanche_Condomìni.Attivo"])
                            {
                                DatiBancariCondomini datiBancari = null;
                                if (rowBanca["CodSiaOrdinante"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["CodSiaOrdinante"].ToString()))
                                    condominio.CodiceSIA = rowBanca["CodSiaOrdinante"].ToString().Trim();

                                if (rowBanca["IBAN"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["IBAN"].ToString()))
                                {
                                    datiBancari = new DatiBancariCondomini(rowBanca["IBAN"].ToString().Trim().Replace(" ", ""), condominio);
                                    condominio.DatiBancari.Add(datiBancari);
                                    _daoFactory.GetDatiBancariCondominiDao().SaveOrUpdate(datiBancari);
                                }
                                else if (rowBanca["Abi"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["Abi"].ToString()) && rowBanca["Cab"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["Cab"].ToString()) && rowBanca["CC"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["CC"].ToString()))
                                {
                                    var coor = new CoordinateBancarie
                                    {
                                        Abi = rowBanca["Abi"].ToString().Trim().PadLeft(5, '0'),
                                        Cab = rowBanca["Cab"].ToString().Trim().PadLeft(5, '0'),
                                        ContoCorrente = rowBanca["CC"].ToString().Trim().PadLeft(12, '0')
                                    };

                                    datiBancari = new DatiBancariCondomini(coor.CalcolaIBAN(), condominio);
                                    condominio.DatiBancari.Add(datiBancari);
                                    _daoFactory.GetDatiBancariCondominiDao().SaveOrUpdate(datiBancari);
                                }
                                if (datiBancari != null && rowBanca["Predefinito"] != DBNull.Value)
                                {
                                    datiBancari.Principale = (bool)rowBanca["Predefinito"];
                                    datiBancari.CodiceImportazione = rowBanca["TabBanche_Condomìni.id"].ToString().Trim();
                                }
                                if (datiBancari != null)
                                    datiBancari.Note = rowBanca["NomeCC"].ToString().Trim();
                            }
                        }
                        catch (Exception ex)
                        {
                            
                            _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Banche) - banca:" + rowBanca["id"], ex);
                            throw;
                        }
                    }

                    // Se ho una sola coordinata bancaria questa è la principale
                    if (condominio.DatiBancari.Count == 1)
                        Library.IesiGenericCollections<DatiBancariCondomini>.GetByIndex(condominio.DatiBancari, 0).Principale = true;

                    // ----------------------------
                    // Stabili/Scale
                    // ----------------------------
                    var stabiliScaleAdapter = new OleDbDataAdapter("SELECT DISTINCT TabIndirizzi.*, TabEdifici.*, TabIndirizzi_Condomìni.idCondominio, TabCodComune.Nome " +
                        "FROM TabEdifici INNER JOIN " +
                        "((TabCodComune INNER JOIN " +
                        "(TabIndirizzi INNER JOIN " +
                        "TabIndirizzi_Condomìni ON TabIndirizzi.id = TabIndirizzi_Condomìni.idIndirizzo) ON TabCodComune.id = TabIndirizzi.idComune) INNER JOIN TabLocali ON TabIndirizzi_Condomìni.id = TabLocali.idIndirizzoCondominio) ON TabEdifici.id = TabLocali.idEdificio " +
                        "WHERE TabIndirizzi_Condomìni.idCondominio = " + rowCondominio["id"] + " " +
                        "ORDER BY TabIndirizzi_Condomìni.idCondominio, TabIndirizzi.id", conn);
                    stabiliScaleAdapter.Fill(dsCondomini, "StabiliScale");

                    int numeroUnitaImmobiliari = 0;
                    bool first = true;
                    var stabile = Library.IesiGenericCollections<Palazzina>.GetByIndex(condominio.Palazzine, 0);
                    var descrizioneStabile = string.Empty;
                    Address indirizzoStabile = null;

                    IList<NameValueDTO<int, string>> listaPersone = _daoFactory.GetPersonaDao().GetByQueryDTO<NameValueDTO<int, string>>("SELECT new NameValueDTOIntString(PERS.ID, PERS.CodiceImportazione) FROM Persona PERS WHERE PERS.AziendaID = :azienda", new[] { new QueryParam("azienda", azienda.ID) });
                    foreach (DataRow rowStabile in dsCondomini.Tables["StabiliScale"].Rows)
                    {
                        try
                        {
                            GruppoStabile newScala;
                            if (first)
                            {
                                newScala = Library.IesiGenericCollections<GruppoStabile>.GetByIndex(stabile.GruppiStabile, 0);
                                newScala.Descrizione = rowStabile["TabEdifici.Nome"].ToString();
                            }
                            else
                            {
                                newScala = new GruppoStabile(stabile, rowStabile["TabEdifici.Nome"].ToString());
                                _daoFactory.GetGruppoStabileDao().SaveOrUpdate(newScala);
                            }

                            newScala.Descrizione = rowStabile["TabEdifici.Nome"].ToString();
                            newScala.Indirizzo = getIndirizzo(rowStabile);
                            
                            newScala.CodiceImportazione = rowStabile["TabEdifici.id"].ToString().Trim();
                            newScala.Note = rowStabile["TabEdifici.Note"].ToString().Trim() + Environment.NewLine + rowStabile["TabIndirizzi.Note"].ToString().Trim();

                            descrizioneStabile += rowStabile["TabIndirizzi.Nome"].ToString().Trim() + " ";
                            if (indirizzoStabile == null)
                                indirizzoStabile = (Address)newScala.Indirizzo.Clone();

                            // Unità Immobiliari
                            message += loadUnitaImmobiliari((int)rowEsercizio["id"], newScala, (int)rowStabile["TabEdifici.id"], dataInizioEsercizio, listaPersone, conn);
                            numeroUnitaImmobiliari += newScala.UnitaImmobiliari.Count;

                            first = false;
                        }
                        catch (Exception ex)
                        {
                            
                            _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Scale) - indirizzo:" + rowStabile["TabIndirizzi.id"], ex);
                            throw;
                        }
                    }
                    stabile.Descrizione = descrizioneStabile.Trim();
                    stabile.Indirizzo = indirizzoStabile;

                    if (stabile.Indirizzo != null) condominio.Indirizzo = 
                        (Address)stabile.Indirizzo.Clone();
                    condominio.NumeroUnitaImmobiliari = numeroUnitaImmobiliari;

                    // ===================================
                    //  Piano dei conti
                    // ===================================
                    var pianoContiAdapter = new OleDbDataAdapter("SELECT TabCapitoli.*, TabEsercizi.idCondominio " +
                        "FROM TabEsercizi INNER JOIN TabCapitoli ON TabEsercizi.id = TabCapitoli.idEsercizio " +
                        "WHERE TabEsercizi.Attivo = true AND TabEsercizi.Straordinario = false AND TabEsercizi.id = " + rowEsercizio["id"] + " " +
                        "ORDER BY TabCapitoli.Codice", conn);
                    pianoContiAdapter.Fill(dsCondomini, "PianoConti");

                    var loadedConti = new List<Conto>();
                    DataTable tbPianoConti = dsCondomini.Tables["PianoConti"];
                    int ordineConto = 0;
                    foreach (DataRow row in tbPianoConti.Rows)
                    {
                        try
                        {
                            var conto = new Conto(condominio, Sfera.Enums.TipoContoEconomicoEnum.Economico, Sfera.Enums.TipoPeriodoCompetenzaContabile.Esercizio, row["Nome"].ToString(), true, true, false);
                            _daoFactory.GetContoDao().SaveOrUpdate(conto);

                            string codice = row["Codice"].ToString().Trim();
                            if (!string.IsNullOrEmpty(codice))
                            {
                                conto.Codice = codice.Length > 2 ? codice.Substring(0, 2).PadLeft(3, '0') : codice.PadLeft(3, '0');
                            }

                            conto.PresenteBilancio = true;
                            conto.CodiceImportazione = row["id"].ToString();
                            ordineConto++;
                            conto.Ordine = ordineConto;
                            loadedConti.Add(conto);

                            dsCondomini = new DataSet();
                            var sottoContiAdapter = new OleDbDataAdapter("SELECT * FROM TabSottoCapitoli WHERE TabSottoCapitoli.idCapitolo = " + row["id"], conn);
                            sottoContiAdapter.Fill(dsCondomini, "SottoConti");
                            var ordineSottoConto = 0;
                            foreach (DataRow rowSottoConto in dsCondomini.Tables["SottoConti"].Rows)
                            {
                                try
                                {
                                    var sottoConto = new SottoConto(conto, rowSottoConto["Nome"].ToString()) {CodiceImportazione = rowSottoConto["id"].ToString()};
                                    ordineSottoConto++;
                                    sottoConto.Codice = conto.Codice + "." + ordineSottoConto.ToString().PadLeft(3, '0');
                                    _daoFactory.GetSottoContoDao().SaveOrUpdate(sottoConto);
                                }
                                catch (Exception ex)
                                {
                                    
                                    _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Sotto Conti) - sottoconto:" + rowSottoConto["id"], ex);
                                    throw;
                                }

                            }
                        }
                        catch (Exception ex)
                        {
                            
                            _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Piano dei conti) - conto:" + row["id"], ex);
                            throw;
                        }
                    }

                    // ===================================
                    //  Millesimi
                    // ===================================
                    try
                    {
                        var unitaCondominio = _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(condominio.ID);
                        foreach (Conto conto in loadedConti)
                        {
                            try
                            {
                                dsCondomini = new DataSet();
                                var millesimiAdapter = new OleDbDataAdapter("SELECT * " +
                                    "FROM (TabMillesimi INNER JOIN TabMillesimiLocali ON TabMillesimi.id = TabMillesimiLocali.idTabMillesimi) INNER JOIN TabCapitoli ON TabMillesimi.id = TabCapitoli.idTabMillesimi " +
                                    "WHERE TabMillesimi.idEsercizio = " + rowEsercizio["id"].ToString().Trim() + " AND TabCapitoli.id = " + conto.CodiceImportazione.Trim() + ";", conn);
                                millesimiAdapter.Fill(dsCondomini, "Millesimi");

                                foreach (DataRow rowMillesimo in dsCondomini.Tables["Millesimi"].Rows)
                                {
                                    try
                                    {
                                        if ((float)rowMillesimo["PercProp"] > 0)
                                        {
                                            //string hql = "FROM UnitaImmobiliare UNI WHERE UNI.CodiceImportazione = :codice";
                                            //IList<UnitaImmobiliare> listaUnita = _daoFactory.GetUnitaImmobiliareDao().GetByQuery(hql, new QueryParam[] { new QueryParam("codice", rowMillesimo["idLocale"].ToString().Trim()) });
                                            IList<UnitaImmobiliare> listaUnita = (from item in unitaCondominio
                                                                                  where item.CodiceImportazione == rowMillesimo["idLocale"].ToString().Trim()
                                                                                  select item).ToList();
                                            if (listaUnita.Count > 0)
                                            {
                                                var newMillesimo = new Millesimo(conto, listaUnita[0])
                                                {
                                                    Valore = Convert.ToDecimal((float) rowMillesimo["Mill"]),
                                                    CodiceImportazione = rowMillesimo["TabMillesimiLocali.id"].ToString().Trim()
                                                };
                                                _daoFactory.GetMillesimoDao().SaveOrUpdate(newMillesimo);

                                                if (listaUnita[0].GetConduttorePrincipale(dataInizioEsercizio) != null)
                                                {
                                                    var percentualeProp = Convert.ToDecimal((float)rowMillesimo["PercProp"]) / 100m;
                                                    new SoggettoCondominioRipartizione(conto, listaUnita[0].GetProprietarioPrincipale(dataInizioEsercizio), percentualeProp);
                                                    new SoggettoCondominioRipartizione(conto, listaUnita[0].GetConduttorePrincipale(dataInizioEsercizio), 1 - percentualeProp);
                                                }
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        
                                        _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Millesimi) - millesimo:" + rowMillesimo["TabMillesimiLocali.id"].ToString().Trim(), ex);
                                        throw;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                
                                _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Millesimi) - conto:" + conto.CodiceImportazione, ex);
                                throw;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        
                        _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Millesimi) - condominio:" + codiceCondominio, ex);
                        throw;
                    }

                    // ===================================
                    //  Regole di ripartizione
                    // ===================================
                    try
                    {
                        var regoleAdapter = new OleDbDataAdapter("SELECT TabRegoleRipartizione.Nome, TabRegoleRipartizione.Note, TabRegoleRipartizione.idEsercizio, TabDettagliRegoleRipartizione.* " +
                            "FROM TabRegoleRipartizione INNER JOIN TabDettagliRegoleRipartizione ON TabRegoleRipartizione.id = TabDettagliRegoleRipartizione.idRegola " +
                            "WHERE TabRegoleRipartizione.idEsercizio = " + rowEsercizio["id"].ToString().Trim() + ";", conn);
                        regoleAdapter.Fill(dsCondomini, "Regole");

                        int lastIdModello = 0;
                        ModelloRegistrazioneContabile lastModello = null;
                        foreach (DataRow rowRegola in dsCondomini.Tables["Regole"].Rows)
                        {
                            try
                            {
                                var hql = "FROM Conto C WHERE C.CodiceImportazione = :codice";
                                var listaConti = _daoFactory.GetContoDao().GetByQuery(hql, new[] { new QueryParam("codice", rowRegola["idCapitolo"].ToString().Trim()) });
                                if (listaConti.Count > 0)
                                {
                                    var hqlSottoConto = "FROM SottoConto S WHERE S.CodiceImportazione = :codice";
                                    var listaSottoConti = _daoFactory.GetSottoContoDao().GetByQuery(hqlSottoConto, new[] { new QueryParam("codice", rowRegola["idSottoCapitolo"].ToString().Trim()) });
                                    if (listaSottoConti.Count > 0)
                                    {
                                        if ((int)rowRegola["idRegola"] != lastIdModello)
                                        {
                                            var modello = new ModelloRegistrazioneContabile(condominio, rowRegola["Nome"].ToString(), null)
                                            {
                                                CodiceImportazione = rowRegola["idRegola"].ToString().Trim()
                                            };
                                            lastIdModello = (int)rowRegola["idRegola"];
                                            lastModello = modello;
                                            _daoFactory.GetModelloRegistrazioneContabileDao().SaveOrUpdate(modello);
                                        }
                                        var contoModello = new ContiModelloRegistrazioneContabile(lastModello, listaConti[0], listaSottoConti[0], Convert.ToDecimal((float)rowRegola["Perc"])/100m, null) {CodiceImportazione = rowRegola["id"].ToString().Trim()};
                                        _daoFactory.GetContiModelloRegistrazioneContabileDao().SaveOrUpdate(contoModello);
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                
                                _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Regole Ripartizione) - regola:" + rowRegola["idRegola"].ToString().Trim(), ex);
                                throw;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        
                        _log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Regole Ripartizione)", ex);
                        throw;
                    }
                }
                else
                {
                    message = "Non è stato trovato alcun esercizio Ordinario importabile per il condominio: " + codiceCondominio + " - " + rowCondominio["Nome"];
                    
                    _log.Error(message + " - " + Library.Utility.GetMethodDescription());
                }
            }
            else
            {
                message = "Non è stato trovato il condominio: " + codiceCondominio;
                
                _log.Error(message + " - " + Library.Utility.GetMethodDescription());
            }

            return message;
        }
コード例 #5
0
ファイル: MillesimoRepository.cs プロジェクト: gipasoft/Sfera
        private bool insert(MillesimoDTO dto, out Millesimo item)
        {
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);

            try
            {
                item = new Millesimo(daoFactory.GetContoDao().GetById(dto.IdContoRiferimento, false), daoFactory.GetUnitaImmobiliareDao().GetById(dto.IdUnitaRiferimento, false)) {Valore = dto.Valore};
                daoFactory.GetMillesimoDao().SaveOrUpdate(item);
            }
            catch (Exception ex)
            {
                _log.Error("Errore nell'inserimento dei millesimi:" + Library.Utility.GetMethodDescription() + " - id:" + dto.ID, ex);
                throw;
            }

            return true;
        }
コード例 #6
0
ファイル: MillesimoRepository.cs プロジェクト: gipasoft/Sfera
        private bool update(MillesimoDTO dto, out Millesimo item)
        {
            var result = false;
            item = null;
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);

            try
            {
                item = daoFactory.GetMillesimoDao().Find(dto.ID, false);
                if(item != null)
                {
                    // Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
                    if (dto.Version == item.Version)
                    {
                        item.Valore = dto.Valore;
                        item.ContoRiferimento = daoFactory.GetContoDao().GetById(dto.IdContoRiferimento, false);
                        item.UnitaRiferimento = daoFactory.GetUnitaImmobiliareDao().GetById(dto.IdUnitaRiferimento, false);

                        result = true;
                    }
                    else
                    {
                        // Eccezione: Sul db c'è qualche cosa di più nuovo.
                        _log.Error("Errore nel salvataggio dei millesimi: id:" + dto.ID + " - il dato sul db è più recente di quello che si vuole salvare");
                    }
                }
                else
                    result = true;
            }
            catch (Exception ex)
            {
                _log.Error("Errore nel salvataggio dei millesimi: " + Library.Utility.GetMethodDescription() + " - id:" + dto.ID, ex);
                throw;
            }

            return result;
        }
コード例 #7
0
ファイル: MillesimoRepository.cs プロジェクト: gipasoft/Sfera
        private MillesimoDTO setDto(Millesimo item)
        {
            var dto = new MillesimoDTO {ID = item.ID, Valore = item.Valore};

            if (item.ContoRiferimento != null)
            {
                dto.IdContoRiferimento = item.ContoRiferimento.ID;
                dto.DescrizioneContoRiferimento = item.ContoRiferimento.Descrizione;
                dto.OrdineConto = item.ContoRiferimento.Ordine;
                dto.CodiceConto = item.ContoRiferimento.Codice;
            }

            if (item.UnitaRiferimento != null)
            {
                dto.IdUnitaRiferimento = item.UnitaRiferimento.ID;
                dto.InternoUnitaRiferimento = item.UnitaRiferimento.InternoCompleto;
                dto.TipoUnitaRiferimento = item.UnitaRiferimento.TipoUnitaImmobiliare.Descrizione;
                dto.NominativoUnitaRiferimento = item.UnitaRiferimento.Descrizione;
                dto.OrdineGruppoRiferimento = item.UnitaRiferimento.GruppoStabileRiferimento.Ordine;
                dto.OrdineStabileRiferimento = item.UnitaRiferimento.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine;
                if (item.UnitaRiferimento.Ordine != null)
                    dto.Ordine = item.UnitaRiferimento.Ordine.Value;
            }

            dto.Version = item.Version;

            return dto;
        }
コード例 #8
0
ファイル: MillesimoRepository.cs プロジェクト: gipasoft/Sfera
 public int Insert(int idConto, int idUnitaImmobiliare, decimal valore)
 {
     try
     {
         if (valore > 0)
         {
             var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
             var mill = new Millesimo(daoFactory.GetContoDao().GetById(idConto, false), daoFactory.GetUnitaImmobiliareDao().GetById(idUnitaImmobiliare, false)) {Valore = valore};
             daoFactory.GetMillesimoDao().SaveOrUpdate(mill);
             return mill.Version + 1;
         }
         return -1;
     }
     catch (Exception ex)
     {
         _log.Error("Errore nel salvataggio dei millesimi: " + Library.Utility.GetMethodDescription() + " - idConto:" + idConto + " - idUnitaImmobiliare:" + idUnitaImmobiliare + " - valore:" + valore, ex);
         throw;
     }
 }