public List<RataSoggettoDTO> GetVersatoByEsercizio(EsercizioDTO esercizio, StabileDTO stabile, DateTime? dataLimite, bool soloDaSollecitare) { int? idStabile = null; if (stabile != null) idStabile = stabile.ID; var result = GetServiceClient().GetVersatoByEsercizio(esercizio.ID, idStabile, dataLimite, soloDaSollecitare, GetUserInfo()); CloseService(); return result; }
public override List<MillesimoDTO> GetMillesimiByConti(IList<int> idConti, StabileDTO stabile, GruppoStabileDTO scala) { int? idStabile = null; if (stabile != null) idStabile = stabile.ID; int? idScala = null; if (scala != null) idScala = scala.ID; var result = GetServiceClient().GetMillesimiByFilter(new MillesimiFilter { IdConti = new List<int>(idConti), CodiceStabile = idStabile, CodiceScala = idScala }, GetUserInfo()); CloseService(); return result; }
public StabileDTO[] GetAllByAzienda(int idAzienda) { try { var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); var lista = daoFactory.GetPalazzinaDao().GetByAzienda(idAzienda); var stabili = new StabileDTO[lista.Count]; int index = 0; foreach (Palazzina stabile in lista) { stabili[index] = setDto(stabile); index++; } return stabili; } catch (Exception ex) { _log.Error("Errore nel caricamento degli stabili: " + Library.Utility.GetMethodDescription(), ex); throw; } }
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 List<ConvocazioneAssembleaDTO> GetConvocatiPerAppello(StabileDTO stabile, GruppoStabileDTO scala) { return _assembleaService.GetConvocatiPerAppello(_assemblea, stabile, scala, _convocazione); }
public List<ConvocazioneAssembleaDTO> GetConvocatiPerAppello(StabileDTO stabile, GruppoStabileDTO scala) { //il filtro in locale non riesce ad operare con gli id...spero vada bene anche con le descrizioni return _appello.Where(item => ((stabile == null || item.Stabile == stabile.Descrizione) && (scala == null || item.GruppoStabile == scala.Descrizione))).ToList(); }
public List<ConvocazioneAssembleaDTO> GetConvocatiPerAppello(AssembleaDTO assemblea, StabileDTO stabile, GruppoStabileDTO scala, int convocazione) { int? idStabile = null; if (stabile != null) idStabile = stabile.ID; int? idScala = null; if (scala != null) idScala = scala.ID; List<ConvocazioneAssembleaDTO> result = base.GetServiceClient().GetConvocatiPerAppello(assemblea.ID, idStabile, idScala, convocazione, GetUserInfo()); base.CloseService(); return result; }
public List<MillesimoDTO> GetRiepilogoMillesimiByEsercizio(IList<int> contiSelezionati, IList<int> unitaSelezionate, StabileDTO stabile, GruppoStabileDTO scala, EsercizioDTO esercizio) { var millesimi = new List<MillesimoDTO>(); var service = new PianoContiWCFService(_fornitoreService, _soggettoService); var millesimiContiSelezionati = service.GetMillesimiByConti(contiSelezionati, stabile, scala); foreach (var conto in GetDaMillesimareByCondominio(esercizio)) { var conto1 = conto; var millesimiConto = from item in millesimiContiSelezionati where item.IdContoRiferimento == conto1.ID select item; millesimi.AddRange(millesimiConto); } return new List<MillesimoDTO> ( (from mill in millesimi where contiSelezionati.Contains(mill.IdContoRiferimento) && unitaSelezionate.Contains(mill.IdUnitaRiferimento) select mill).ToList() ); }
public virtual List<MillesimoDTO> GetMillesimiByConti(IList<int> idConti, StabileDTO stabile, GruppoStabileDTO scala) { throw new NotImplementedException("Implementare il metodo per il recupero del piano dei conti per esercizio"); }
public string IsAllowDeleteStabile(StabileDTO stabile) { var result = string.Empty; if (stabile.ID != 0) result = GetServiceClient().IsAllowDeleteStabile(stabile.ID, GetUserInfo()); CloseService(); return result; }
public StabileDTO[] GetPalazzinaByCondID(int idCondominio) { try { var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); var lista = daoFactory.GetCondominioDao().GetById(idCondominio, false).Palazzine; var palazzine = new StabileDTO[lista.Count]; var rep = new StabileRepository(_info, _windsorRepository); var index = 0; foreach (var item in lista) { palazzine[index] = rep.GetByDomainEntity(item); index++; } return palazzine; } catch (Exception ex) { _log.ErrorFormat("Errore nel caricamento degli Stabili - {0} - condominio:{1}", ex, Utility.GetMethodDescription(), idCondominio); throw; } }
public List<RiepilogoRataSoggettoDTO> GetRiepilogoVersamentiByEsercizioCondominio(CondominioDTO condominio, EsercizioDTO esercizio, StabileDTO stabile, GruppoStabileDTO scala, ReferenteDTO referente, DateTime? dataInizioRate, DateTime? dataFineRate, DateTime? dataVersamenti, bool groupBySoggetto, bool groupByPersona, bool groupByCondominio, bool grouByEsercizio, bool soloRitardi, decimal importoMinimo, bool sollecitaProprietarioConduzione) { int? idStabile = null; if (stabile != null) idStabile = stabile.ID; int? idScala = null; if (scala != null) idScala = scala.ID; int? idEsercizio = null; if (esercizio != null) idEsercizio = esercizio.ID; int? idCondominio = null; if (condominio != null) idCondominio = condominio.ID; int? idReferente = null; if (referente != null) idReferente = referente.ID; var result = GetServiceClient().GetRiepilogoVersamentiByEsercizioCondominio(idCondominio, idEsercizio, idStabile, idScala, idReferente, dataInizioRate, dataFineRate, dataVersamenti, groupBySoggetto, groupByPersona, groupByCondominio, grouByEsercizio, soloRitardi, importoMinimo, sollecitaProprietarioConduzione, GetUserInfo()); CloseService(); return result; }
private void sceltaCondominioCombo1SelectItem(object sender, DataSourceEventArgs<CondominioDTO> e) { Clear(); riepilogoRataSoggettoDTOBindingSource.Clear(); _condominio = e.BusinessEntity; _esercizio = null; esercizi.Value = null; if (_condominio != null) { loadEsercizi(); esercizi.Value = null; if (eserciziDTOBindingSource.Count == 1) esercizi.SelectedIndex = 0; } else esercizi.Clear(); _stabile = null; if (_condominio != null) { stabileDTOBindingSource.DataSource = getStrutturaCondominioService().GetStabiliByCondominio(_condominio); stabili.Value = null; if (stabileDTOBindingSource.Count == 1) stabili.SelectedIndex = 0; } else stabili.Clear(); }
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; }
private void stabiliValueChanged(object sender, EventArgs e) { if (stabili.SelectedItem != null) _stabile = (StabileDTO)stabili.SelectedItem.ListObject; }
public StabileDTO GetNewStabile(CondominioDTO condominio) { var stabile = new StabileDTO { GruppiStabile = new List<GruppoStabileDTO>(), IdCondominio = condominio.ID, MappaleCatastale = condominio.MappaleCatastale }; return stabile; }
public ResultRiepilogoRipartoDTO GetRiepilogoRiparto(int idEsercizio, StabileDTO stabile, GruppoStabileDTO scala, int? idRendiconto, TipoAccorpamentoRateEnum tipo) { var retryCount = 5; var success = false; int? idStabile = null; if (stabile != null) idStabile = stabile.ID; int? idScala = null; if (scala != null) idScala = scala.ID; ResultRiepilogoRipartoDTO result = new ResultRiepilogoRipartoDTO(); while (retryCount >= 0 && !success) { try { var info = GetUserInfo(); info.Tentativo = 6 - retryCount; result = GetServiceClient().GetRiepilogoRiparto(idEsercizio, idStabile, idScala, idRendiconto, tipo, GetUserInfo()); CloseService(); success = true; } catch (Exception ex) { _log.ErrorFormat("Errore nella lettura del riepilogo del riparto per piano rateale - TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", ex, (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, Login.Instance.CurrentLogin().Azienda); retryCount--; _log.InfoFormat("Esecuzione della funzione - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, Login.Instance.CurrentLogin().Azienda); } } return result; }
public bool DeleteStabile(StabileDTO stabile) { var result = GetServiceClient().DeleteStabile(stabile.ID, GetUserInfo()); CloseService(); return result; }
public int? ManageDomainEntity(StabileDTO dto) { try { var stabile = manageStabile(dto); if (stabile != null) return stabile.ID; return null; } catch (Exception ex) { _log.ErrorFormat("Errore nella gestione degli stabili - {0} - stabile:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID); throw; } }
public DataView GetRiepilogoMillesimiPivotByEsercizio(EsercizioDTO esercizio, StabileDTO stabile, GruppoStabileDTO gruppo) { return convertMillesimiToPivot(GetDaMillesimareByCondominio(esercizio), stabile, gruppo); }
private StabileDTO setDto(Palazzina item) { var dto = new StabileDTO { Descrizione = item.Descrizione, Ordine = item.Ordine, MappaleCatastale = item.MappaleCatastale, DescrizioneCondominio = item.CondominioRiferimento.DisplayName, DisplayName = item.DisplayName, ID = item.ID, IdCondominio = item.CondominioRiferimento.ID, Version = item.Version }; if (item.Indirizzo != null) { dto.Cap = item.Indirizzo.Cap; dto.Civico = item.Indirizzo.Civico; dto.Indirizzo = item.Indirizzo.Indirizzo; } int indexGruppi = 0; foreach (var gruppo in item.GruppiStabile) { var gruppoDto = _gruppoRep.GetByDomainEntity(gruppo); if (dto.GruppiStabile.Length == 0) dto.GruppiStabile = new GruppoStabileDTO[item.GruppiStabile.Count]; dto.GruppiStabile[indexGruppi] = gruppoDto; indexGruppi++; } // Lotto if (item.LottoRiferimento != null) { dto.IdLotto = item.LottoRiferimento.ID; dto.DescrizioneLotto = item.LottoRiferimento.Descrizione; } return dto; }
private DataView convertMillesimiToPivot(List<ContoDTO> conti, StabileDTO stabile, GruppoStabileDTO gruppo) { var tb = new DataTable("MillesimiPivot"); tb.Columns.Add("IdUnitaImmobiliare", typeof(int)); tb.Columns.Add("OrdineUnitaImmobiliare", typeof(int)); tb.Columns.Add("DescrizioneUnitaImmobiliare", typeof(string)); tb.Columns.Add("TipoUnitaImmobiliare", typeof(string)); tb.Columns.Add("InternoUnitaImmobiliare", typeof(string)); tb.Columns.Add("Stabile", typeof(string)); tb.Columns.Add("Scala", typeof(string)); tb.PrimaryKey = new[] { tb.Columns["IdUnitaImmobiliare"] }; var service = new PianoContiWCFService(_fornitoreService, _soggettoService); var idConti = new List<int>(conti.Count); idConti.AddRange(conti.Select(conto => conto.ID)); var millesimi = service.GetMillesimiByConti(idConti, stabile, gruppo); // ---------------------------------------------- // Aggiungo una colonna per ogni Conto // ---------------------------------------------- var contoColumns = new List<DataColumn>(conti.Count); foreach (var conto in conti.OrderBy(item => item.Ordine)) contoColumns = addColumnByConto(conto.ID, conto.Descrizione, tb, contoColumns); // ---------------------------------------------- // Riempio la tabella // ---------------------------------------------- foreach (var conto in conti) { var conto1 = conto; var millesimiSelezionati = from millesimo in millesimi where millesimo.IdContoRiferimento == conto1.ID && (gruppo == null || millesimo.IdGruppoRiferimento == gruppo.ID) && (stabile == null || millesimo.IdStabileRiferimento == stabile.ID) select millesimo; foreach (var millesimo in millesimiSelezionati) { var row = tb.Rows.Find(millesimo.IdUnitaRiferimento); if (row == null) { row = tb.NewRow(); row["IdUnitaImmobiliare"] = millesimo.IdUnitaRiferimento; row["OrdineUnitaImmobiliare"] = millesimo.Ordine; row["DescrizioneUnitaImmobiliare"] = millesimo.NominativoUnitaRiferimento; row["TipoUnitaImmobiliare"] = millesimo.TipoUnitaRiferimento; row["InternoUnitaImmobiliare"] = millesimo.InternoUnitaRiferimento; row["Stabile"] = millesimo.DescrizioneStabileRiferimento; row["Scala"] = millesimo.DescrizioneGruppoRiferimento; tb.Rows.Add(row); } var valore = millesimo.Valore ?? (object) DBNull.Value; row["Conto_" + conto.ID + "_" + conto.Descrizione] = valore; row["Ripartizione_" + conto.ID + "_" + conto.Descrizione] = millesimo.RipartizionePersonalizzata; } } return new DataView(tb, string.Empty, "OrdineUnitaImmobiliare", DataViewRowState.Added); }
private bool update(StabileDTO dto, out Palazzina item) { bool result; var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); try { item = daoFactory.GetPalazzinaDao().GetById(dto.ID, false); // Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia // Per ora non sono eseguiti controlli di concorrenza if (dto.Version == item.Version || true) { item.CondominioRiferimento = daoFactory.GetCondominioDao().GetById(dto.IdCondominio, false); item.Descrizione = dto.Descrizione; item.Ordine = dto.Ordine; item.MappaleCatastale = dto.MappaleCatastale; #region Indirizzo item.Indirizzo = new Address {Indirizzo = dto.Indirizzo, Civico = dto.Civico, Cap = dto.Cap}; if (item.CondominioRiferimento.Indirizzo != null) { if (item.Indirizzo.Comune != null) item.Indirizzo.Comune = item.CondominioRiferimento.Indirizzo.Comune; if (string.IsNullOrEmpty(item.Indirizzo.Indirizzo)) item.Indirizzo.Indirizzo = item.CondominioRiferimento.Indirizzo.Indirizzo; if (string.IsNullOrEmpty(item.Indirizzo.Cap)) item.Indirizzo.Cap = item.CondominioRiferimento.Indirizzo.Cap; if (string.IsNullOrEmpty(item.Indirizzo.Civico)) item.Indirizzo.Civico = item.CondominioRiferimento.Indirizzo.Civico; if (string.IsNullOrEmpty(item.Indirizzo.Localita)) item.Indirizzo.Localita = item.CondominioRiferimento.Indirizzo.Localita; if (item.Indirizzo.Nazione == null) item.Indirizzo.Nazione = item.CondominioRiferimento.Indirizzo.Nazione; } #endregion Indirizzo // ------------------------------------- // Lotto Riferimento // ------------------------------------- item.LottoRiferimento = null; if (dto.IdLotto > 0) item.LottoRiferimento = daoFactory.GetLottoDao().Find(dto.IdLotto, false); // ------------------------------------------------------ // Gruppi Stabile // ------------------------------------------------------ item.GruppiStabile.Clear(); foreach (var t in dto.GruppiStabile) { t.IdStabile = item.ID; var id = t.ID; if ((t.Stato == "U") || (t.Stato == "I")) { var manageDomainEntity = getGruppoStabileRepository().ManageDomainEntity(t); if (manageDomainEntity != null) id = (int)manageDomainEntity; } var gruppo = daoFactory.GetGruppoStabileDao().Find(id, false); if (gruppo != null) { item.GruppiStabile.Add(gruppo); gruppo.PalazzinaRiferimento = item; } } daoFactory.GetPalazzinaDao().Update(item); result = true; } else { // Eccezione: Sul db c'è qualche cosa di più nuovo. _log.ErrorFormat("Errore nel salvataggio dello stabile - id:{0} - il dato sul db è più recente di quello che si vuole salvare", dto.ID); result = false; } } catch (Exception ex) { _log.ErrorFormat("Errore nel salvataggio dello stabile - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID, ex); throw; } return result; }
public List<ConvocazioneAssembleaDTO> GetVotanti(AssembleaDTO assemblea, OrdineGiornoAssembleaDTO ordineGiorno, StabileDTO stabile, GruppoStabileDTO scala) { List<int> votanti = new List<int>(); if (scala != null) votanti.Add(scala.ID); else if (stabile != null) { foreach (GruppoStabileDTO gruppo in stabile.GruppiStabile) votanti.Add(gruppo.ID); } else votanti = null; List<ConvocazioneAssembleaDTO> result = base.GetServiceClient().GetVotantiAssemblea(assemblea.ID, ordineGiorno.ID, votanti, GetUserInfo()); base.CloseService(); return result; }
private bool insert(StabileDTO dto, out Palazzina item) { var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); item = null; try { var condominio = daoFactory.GetCondominioDao().Find(dto.IdCondominio, false); if (condominio != null) { item = dto.GruppiStabile.Length > 0 ? new Palazzina(condominio, dto.Descrizione, false) : new Palazzina(condominio, dto.Descrizione, true); item.Ordine = dto.Ordine; item.MappaleCatastale = dto.MappaleCatastale; #region Indirizzo item.Indirizzo = new Address { Indirizzo = dto.Indirizzo, Civico = dto.Civico, Cap = dto.Cap }; if (item.CondominioRiferimento.Indirizzo != null) { item.Indirizzo.Comune = item.CondominioRiferimento.Indirizzo.Comune; item.Indirizzo.Localita = item.CondominioRiferimento.Indirizzo.Localita; item.Indirizzo.Nazione = item.CondominioRiferimento.Indirizzo.Nazione; if (string.IsNullOrEmpty(item.Indirizzo.Cap)) item.Indirizzo.Cap = item.CondominioRiferimento.Indirizzo.Cap; if (string.IsNullOrEmpty(item.Indirizzo.Civico)) item.Indirizzo.Civico = item.CondominioRiferimento.Indirizzo.Civico; if (string.IsNullOrEmpty(item.Indirizzo.Indirizzo)) item.Indirizzo.Indirizzo = item.CondominioRiferimento.Indirizzo.Indirizzo; } #endregion Indirizzo daoFactory.GetPalazzinaDao().SaveOrUpdate(item); // ------------------------------------- // Lotto Riferimento // ------------------------------------- if (dto.IdLotto > 0) item.LottoRiferimento = daoFactory.GetLottoDao().GetById(dto.IdLotto, false); // ------------------------------------------------------ // Gruppi Stabile // ------------------------------------------------------ item.GruppiStabile.Clear(); foreach (GruppoStabileDTO t in dto.GruppiStabile) { t.IdStabile = item.ID; int id = t.ID; if ((t.Stato == "U") || (t.Stato == "I")) { var manageDomainEntity = getGruppoStabileRepository().ManageDomainEntity(t); if (manageDomainEntity != null) id = (int)manageDomainEntity; } var gruppo = daoFactory.GetGruppoStabileDao().GetById(id, false); item.GruppiStabile.Add(gruppo); gruppo.PalazzinaRiferimento = item; } } } catch (Exception ex) { _log.ErrorFormat("Errore nel salvataggio dello stabile - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID); throw; } return true; }
public List<ConvocazioneAssembleaDTO> GetVotantiPerVotazione(OrdineGiornoAssembleaDTO ordineGiorno, StabileDTO stabile, GruppoStabileDTO scala) { //capire come cavolo implemetare il filtro per stabile e scala... var oVotanti= _votanti[ordineGiorno.ID]; return oVotanti.Where(item => ((stabile == null || item.Stabile == stabile.Descrizione) && (scala == null || item.GruppoStabile == scala.Descrizione))).ToList(); }
private Palazzina manageStabile(StabileDTO stabileDto) { Palazzina palazzina = null; bool result; // Controllo sullo stato U, D, I switch (stabileDto.Stato.ToUpper()) { case "U": result = update(stabileDto, out palazzina); if (!result) throw new Exception("Il dato sul database è più recente di quello utilizzato"); break; case "I": result = insert(stabileDto, out palazzina); if (!result) throw new Exception("Impossibile scrivere sul database"); break; } return palazzina; }
public List<ConvocazioneAssembleaDTO> GetVotantiPerVotazione(OrdineGiornoAssembleaDTO ordineGiorno, StabileDTO stabile, GruppoStabileDTO scala) { return _assembleaService.GetVotantiPerVotazione(_assemblea, ordineGiorno, stabile, scala, _convocazione); }
public int? SetStabile(StabileDTO stabile, UserInfo userinfo) { var windsorRep = new WindsorConfigRepository(); try { windsorRep.BeginTransaction(userinfo); var rep = new StabileRepository(userinfo, windsorRep); var item = rep.ManageDomainEntity(stabile); windsorRep.Commit(); return item; } catch (Exception ex) { _log.ErrorFormat("Errore il salvataggio dello stabile - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), stabile.ID, userinfo.Azienda); windsorRep.Rollback(); throw; } }