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;
}
}
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;
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
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;
}
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;
}
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;
}
}
