Exemplo n.º 1
0
        public LottoDTO[] GetAllByAzienda(int idAzienda)
        {
            try
            {
                var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
                var lista = daoFactory.GetLottoDao().GetByAzienda(idAzienda);
                var lotti = new LottoDTO[lista.Count];

                int index = 0;
                foreach (var lotto in lista)
                {
                    lotti[index] = setDto(lotto);
                    index++;
                }

                return lotti;
            }
            catch (Exception ex)
            {
                
                _log.Error("Errore nel caricamento dei lotti: " + Library.Utility.GetMethodDescription(), ex);
                throw;
            }
        }
Exemplo n.º 2
0
        private bool insert(LottoDTO dto, out Lotto item)
        {
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);

            try
            {
                Condominio condominioRiferimento = null;

                // -------------------------------------
                // Condominio Riferimento
                // -------------------------------------
                if (dto.IdCondominio > 0)
                    condominioRiferimento = daoFactory.GetCondominioDao().Find(dto.IdCondominio, false);

                if (condominioRiferimento != null)
                {
                    item = new Lotto(condominioRiferimento, dto.Descrizione) { PartitaIva = dto.PartitaIva };
                    daoFactory.GetLottoDao().SaveOrUpdate(item);
                }
                else
                {
                    _log.ErrorFormat("Tentativo di salvare un lotto senza specificare il condominio - {0} - azienda:{1}", Utility.GetMethodDescription(), _info.Azienda);
                    item = null;
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'inserimento del lotto - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), dto.ID, _info.Azienda);
                throw;
            }

            return true;
        }
Exemplo n.º 3
0
        private Lotto manage(LottoDTO dto)
        {
            Lotto item = null;
            bool result;

            // Controllo sullo stato U, D, I
            switch (dto.Stato.ToUpper())
            {
                case "U":
                    result = update(dto, out item);

                    if (!result)
                        throw new Exception("Il dato sul database è più recente di quello utilizzato");
                    break;
                case "I":
                    result = insert(dto, out item);

                    if (!result)
                        throw new Exception("Impossibile scrivere sul database");
                    break;
            }
            return item;
        }
Exemplo n.º 4
0
        private static LottoDTO setDto(Lotto item)
        {
            var dto = new LottoDTO
            {
                IdCondominio = item.CondominioRiferimento.ID,
                DescrizioneCondominio = item.CondominioRiferimento.Descrizione,
                Descrizione = item.Descrizione,
                PartitaIva = item.PartitaIva,
                ID = item.ID,
                Version = item.Version
            };

            return dto;
        }
Exemplo n.º 5
0
        private bool update(LottoDTO dto, out Lotto item)
        {
            bool result = false;
            item = null;
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);

            try
            {
                item = daoFactory.GetLottoDao().GetById(dto.ID, false);

                // Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
                if (dto.Version == item.Version)
                {
                    item.Descrizione = dto.Descrizione;
                    item.PartitaIva = dto.PartitaIva;

                    // -------------------------------------
                    // Condominio Riferimento
                    // -------------------------------------
                    if (dto.IdCondominio > 0)
                        item.CondominioRiferimento = daoFactory.GetCondominioDao().GetById(dto.IdCondominio, false);

                    daoFactory.GetLottoDao().Update(item);

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

            return result;
        }
Exemplo n.º 6
0
        public LottoDTO[] GetLottiByCondominioID(int idCondominio)
        {
            try
            {
                var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
                var condominio = daoFactory.GetCondominioDao().Find(idCondominio, false);
                if (condominio != null)
                {
                    var lista = condominio.Lotti;
                    var lotti = new LottoDTO[lista.Count];

                    var index = 0;
                    foreach (var lotto in lista)
                    {
                        lotti[index] = setDto(lotto);
                        index++;
                    }

                    return lotti;
                }

                return new LottoDTO[0];
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nella gestione dei lotti - {0} - condominio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idCondominio, _info.Azienda);
                throw;
            }
        }
Exemplo n.º 7
0
 public int? ManageDomainEntity(LottoDTO dto)
 {
     try
     {
         var item = manage(dto);
         if(item != null)
             return item.ID;
         return null;
     }
     catch (Exception ex)
     {
         _log.ErrorFormat("Errore nella gestione dei lotti - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), dto.ID, _info.Azienda);
         throw;
     }
 }
 public bool DeleteLotto(LottoDTO lotto)
 {
     var result = GetServiceClient().DeleteLotto(lotto.ID, GetUserInfo());
     CloseService();
     return result;
 }
        public string IsAllowDeleteLotto(LottoDTO lotto)
        {
            var result = string.Empty;
            if (lotto.ID != 0)
                result = GetServiceClient().IsAllowDeleteLotto(lotto.ID, GetUserInfo());

            CloseService();
            return result;
        }
Exemplo n.º 10
0
        public DataTable AddDataLettura(ContatoreDTO contatore, CondominioDTO condominio, DataTable tb, DateTime data, LottoDTO lotto, StabileDTO stabile, GruppoStabileDTO scala)
        {
            var dateColumn = new List<DataColumn>();

            int? idLotto = null;
            if(lotto != null)
                idLotto = lotto.ID;

            int? idStabile = null;
            if(stabile != null)
                idStabile = stabile.ID;

            int? idScala = null;
            if(scala != null)
                idScala = scala.ID;

            // Se non sono presenti righe devo caricare tutte le righe per le unità immobiliari presenti
            if (tb.Rows.Count == 0)
            {
                IList<LetturaContatoreDTO> lettureNew = GetServiceClient().GetNewLettura(contatore.ID, data, condominio.ID, idLotto, idStabile, idScala, GetUserInfo());

                foreach (var lettura in lettureNew)
                {
                    var row = tb.NewRow();
                    row["IdUnitaImmobiliare"] = lettura.IdUnitaImmobiliare;
                    row["InternoUnitaImmobiliare"] = lettura.InternoUnitaImmobiliare;
                    row["DescrizioneUnitaImmobiliare"] = lettura.DescrizioneUnitaImmobiliare;
                    row["OrdineUnitaImmobiliare"] = lettura.OrdineUnitaImmobiliare;
                    row["TipoUnitaImmobiliare"] = lettura.TipoUnitaImmobiliare;
                    row["Lotto"] = lettura.Lotto;
                    row["Stabile"] = lettura.Stabile;
                    row["Scala"] = lettura.Scala;

                    // Data
                    dateColumn = addColumnByData(data, tb, dateColumn);
                    if(lettura.Valore != null)
                        row["Data_" + data.ToShortDateString()] = lettura.Valore;
                    else
                        row["Data_" + data.ToShortDateString()] = DBNull.Value;

                    tb.Rows.Add(row);
                }
            }
            else
            {
                dateColumn.AddRange(tb.Columns.Cast<DataColumn>().Where(column => column.ColumnName.StartsWith("Data_")));

                addColumnByData(data, tb, dateColumn);

                foreach (DataRow row in tb.Rows)
                    row["Data_" + data.ToShortDateString()] = DBNull.Value;
            }
            CloseService();

            return tb;
        }
Exemplo n.º 11
0
        public DataTable GetLetturePivotByEsercizio(EsercizioDTO esercizio, ContatoreDTO contatore, LottoDTO lotto, StabileDTO stabile, GruppoStabileDTO scala)
        {
            int? idLotto = null;
            if (lotto != null)
                idLotto = lotto.ID;

            int? idStabile = null;
            if (stabile != null)
                idStabile = stabile.ID;

            int? idScala = null;
            if (scala != null)
                idScala = scala.ID;

            var letture = GetServiceClient().GetLettureContatoriByEsercizio(esercizio.ID, esercizio.IdCondominio, contatore.ID, idLotto, idStabile, idScala, GetUserInfo());

            var tb = new DataTable("LettureContatori");
            tb.Columns.Add("IdUnitaImmobiliare", typeof(int));
            tb.Columns.Add("InternoUnitaImmobiliare", typeof(string));
            tb.Columns.Add("DescrizioneUnitaImmobiliare", typeof(string));
            tb.Columns.Add("OrdineUnitaImmobiliare", typeof(int));
            tb.Columns.Add("TipoUnitaImmobiliare", typeof(string));
            tb.Columns.Add("Lotto", typeof(string));
            tb.Columns.Add("Stabile", typeof(string));
            tb.Columns.Add("Scala", typeof(string));
            tb.PrimaryKey = new[] { tb.Columns["IdUnitaImmobiliare"] };

            // ----------------------------------------------
            // Aggiungo una colonna per ogni Data
            // ----------------------------------------------
            var dateColumn = new List<DataColumn>();
            if (letture.Count > 0)
            {
                var idExampleUnita = letture[0].IdUnitaImmobiliare;
                var listaLettureExample = from item in letture
                                          where item != null && item.IdUnitaImmobiliare == idExampleUnita
                                          orderby item.Data
                                          select item;
                dateColumn = new List<DataColumn>(listaLettureExample.Count());
                dateColumn = listaLettureExample.Aggregate(dateColumn, (current, letturaExample) => addColumnByData(letturaExample.Data, tb, current));
            }

            // ----------------------------------------------
            // Riempio la tabella
            // ----------------------------------------------
            foreach (var lettura in letture.OrderBy(item => item.OrdineUnitaImmobiliare))
            {
                var row = tb.Rows.Find(lettura.IdUnitaImmobiliare);
                if (row == null)
                {
                    row = tb.NewRow();
                    row["IdUnitaImmobiliare"] = lettura.IdUnitaImmobiliare;
                    row["InternoUnitaImmobiliare"] = lettura.InternoUnitaImmobiliare;
                    row["DescrizioneUnitaImmobiliare"] = lettura.DescrizioneUnitaImmobiliare;
                    row["OrdineUnitaImmobiliare"] = lettura.OrdineUnitaImmobiliare;
                    row["TipoUnitaImmobiliare"] = lettura.TipoUnitaImmobiliare;
                    row["Lotto"] = lettura.Lotto;
                    row["Stabile"] = lettura.Stabile;
                    row["Scala"] = lettura.Scala;
                    tb.Rows.Add(row);
                }
                if (!tb.Columns.Contains("Data_" + lettura.Data.ToShortDateString()))
                    dateColumn = addColumnByData(lettura.Data, tb, dateColumn);

                if (lettura.Valore != null)
                    row["Data_" + lettura.Data.ToShortDateString()] = lettura.Valore;
                else
                    row["Data_" + lettura.Data.ToShortDateString()] = DBNull.Value;
            }

            CloseService();

            return tb;
        }
Exemplo n.º 12
0
		public int? SetLotto(LottoDTO lotto, UserInfo userinfo)
		{
			var windsorRep = new WindsorConfigRepository();
			try
			{
				windsorRep.BeginTransaction(userinfo);
                var repo = new LottoRepository(userinfo, windsorRep);
                var item = repo.ManageDomainEntity(lotto);
				windsorRep.Commit();
				return item;
			}
			catch (Exception ex)
			{
				_log.ErrorFormat("Errore nel salvataggio del lotto - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), lotto.ID, userinfo.Azienda);
				windsorRep.Rollback();
				throw;
			}
		}