public void ForeachShouldIterateOverAllAddedValues()
        {
            var addedValues = new HashSet <int>();
            var hashedset   = new HashedSet <int>();

            SampleNames.ToList().ForEach(n =>
            {
                hashedset.Add(n.Length);
                addedValues.Add(n.Length);
            });

            hashedset.ToList().ForEach(v => Assert.IsTrue(addedValues.Contains(v)));
        }
        public void UnionShouldProduceSetContainingElementsFromBothSets()
        {
            var numbers = new List <int>()
            {
                1, 2, 3, 4, 5, 6, 7
            };
            var hashedset = new HashedSet <int>();

            SampleNames.ToList().ForEach(n => hashedset.Add(n.Length));

            var result = hashedset.UnionWith(numbers);

            numbers.ForEach(x => Assert.IsTrue(result.Contains(x)));

            hashedset.ToList().ForEach(x => Assert.IsTrue(result.Contains(x)));
        }
Example #3
0
        public BindingList<RichiedentePraticaDTO> GetAllSoggettiFornitori(CondominioDTO condominio)
        {
            IList<RichiedentePraticaDTO> fornitoriPreferiti = (from fornitore in _fornitoreService.GetPreferitiByCondominio(condominio.ID)
                                                               select new RichiedentePraticaDTO() 
                                                               {
                                                                   Id = fornitore.ID,
                                                                   DisplayNominativo = fornitore.PersonaRiferimento.DisplayName,
                                                                   IdCondominio = condominio.ID,
                                                                   IdPersona = fornitore.PersonaRiferimento.ID,
                                                                   Tipo = "Fornitore"
                                                               }).ToList();

            IList<RichiedentePraticaDTO> soggetti = (from soggetto in _soggettoService.GetByCondominio(condominio)
                                                     select new RichiedentePraticaDTO()
                                                     {
                                                         Id = soggetto.ID,
                                                         DisplayNominativo = soggetto.DisplayNominativo,
                                                         DescrizioneUnitaImmobiliare = soggetto.DescrizioneUnitaImmobiliare,
                                                         IdCondominio = condominio.ID,
                                                         IdPersona = soggetto.IdPersona,
                                                         IdUnitaImmobiliare = soggetto.IdUnitaImmobiliare,
                                                         OrdineUnitaImmobiliare = soggetto.OrdineUnitaImmobiliare,
                                                         Tipo = soggetto.Tipo.ToString()
                                                     }).ToList();

            ISet<RichiedentePraticaDTO> richiedenti = new HashedSet<RichiedentePraticaDTO>(soggetti);
            richiedenti.AddAll(fornitoriPreferiti);

            return new BindingList<RichiedentePraticaDTO>(richiedenti.ToList());
        }
Example #4
0
        public BindingList<RichiedentePraticaDTO> GetSoggettiAttiviByCondominio(CondominioDTO condominio, IFornitoreService fornitoreService, IReferenteService referenteService, IPersonaService personaService)
        {
            BindingList<FornitoreDTO> fornitoriCompleti = fornitoreService.GetFornitoriCompletiByCondominio(condominio);
            BindingList<PersonaListaDTO> listaPersone = personaService.GetAll();

            IList<RichiedentePraticaDTO> fornitori = (from fornitore in fornitoriCompleti
                                                      select new RichiedentePraticaDTO() 
                                                      {
                                                          Id = fornitore.ID,
                                                          DisplayNominativo = fornitore.DisplayNominativo,
                                                          IdCondominio = condominio.ID,
                                                          IdPersona = fornitore.PersonaRiferimento.ID,
                                                          Tipo = fornitore.DescrizioneTipoFornitore
                                                      }).ToList();

            IList<RichiedentePraticaDTO> referenti = (from referente in referenteService.GetAllEffettivi()
                                                      join persona in listaPersone
                                                      on referente.PersonaId equals persona.ID
                                                      select new RichiedentePraticaDTO() 
                                                      {
                                                          Id = referente.ID,
                                                          DisplayNominativo = referente.NominativoPersona,
                                                          IdCondominio = condominio.ID,
                                                          IdPersona = referente.PersonaId,
                                                          Tipo = "Referente"
                                                      }).ToList();

            ISet<RichiedentePraticaDTO> soggetti = new HashedSet<RichiedentePraticaDTO>(referenti);
            soggetti.AddAll(fornitori);

            return new BindingList<RichiedentePraticaDTO>(soggetti.ToList());
        }
        private IList<UnitaImmobiliare> getUnitaByConto(ContiModelloRegistrazioneContabile dettaglioModello)
        {
            Iesi.Collections.Generic.ISet<UnitaImmobiliare> listaUnita = new HashedSet<UnitaImmobiliare>();
            if (dettaglioModello.Unita.Count > 0)
            {
                foreach (var dettaglioRiparto in dettaglioModello.Unita)
                {
                    if (dettaglioRiparto.LottoRiferimento != null)
                        listaUnita.AddAll(dettaglioRiparto.LottoRiferimento.GetUnitaImmobiliari());
                    else if (dettaglioRiparto.PalazzinaRiferimento != null)
                        listaUnita.AddAll(dettaglioRiparto.PalazzinaRiferimento.GetUnitaImmobiliari());
                    else if (dettaglioRiparto.GruppoStabileRiferimento != null)
                        listaUnita.AddAll(dettaglioRiparto.GruppoStabileRiferimento.UnitaImmobiliari);
                    else if (dettaglioRiparto.UnitaRiferimento != null)
                        listaUnita.Add(dettaglioRiparto.UnitaRiferimento);
                    else
                        listaUnita.AddAll(dettaglioModello.Modello.CondominioRiferimento.GetUnitaImmobiliari());
                }
            }
            else
                listaUnita.AddAll(dettaglioModello.Modello.CondominioRiferimento.GetUnitaImmobiliari());

            return listaUnita.ToList();
        }
        public IList<UnitaImmobiliare> GetUnitaContoModello(MovimentoContabile movimento, int index)
        {
            try
            {
                Iesi.Collections.Generic.ISet<UnitaImmobiliare> listaUnita = new HashedSet<UnitaImmobiliare>();
                if (movimento.Spesa != null)
                {
                    if (movimento.Spesa.Utenza.ModelloRegistrazione.Conti.Count > index)
                    {
                        var dettaglioModello = movimento.Spesa.Utenza.ModelloRegistrazione.Conti.ToList()[index];
                        listaUnita.AddAll(getUnitaByConto(dettaglioModello));
                    }
                    else
                        listaUnita.AddAll(movimento.Testata.EsercizioRiferimento.CondominioRiferimento.GetUnitaImmobiliari());
                }

                return listaUnita.ToList();
            }
            catch (Exception ex)
            {
                
                _log.Error("Errore nella lettura delle unità - " + Library.Utility.GetMethodDescription() + " - movimento:" + movimento.ID + " - index:" + index, ex);
                throw;
            }
        }
        public IList<UnitaImmobiliare> GetUnitaModello(ModelloRegistrazioneContabile modello)
        {
            Iesi.Collections.Generic.ISet<UnitaImmobiliare> listaUnita = new HashedSet<UnitaImmobiliare>();
            foreach (var dettaglioModello in modello.Conti)
                listaUnita.AddAll(getUnitaByConto(dettaglioModello));

            return listaUnita.ToList();
        }