Пример #1
0
 public OptimizationFactory(
     GestoreProfili gestoreProfili,
     UnitOfWork uow)
 {
     m_GestoreProfili = gestoreProfili;
     m_UnitOfWork     = uow;
 }
Пример #2
0
        public void Init(UnitOfWork session, List <Ingresso> elencoIngressi, GestoreProfili gestore, Percorso percorso)
        {
            m_GestoreProfili = gestore;

            m_GestoreTitoliSingoliGruppi = new GestoreTitoli(session);
            m_GestoreTitoliSingoliGruppi.ReBuildElencoTitoli(percorso, false, this.treeListSingolo);
            m_GestoreTitoliSingoliGruppi.ApplyElencoTitoli(m_GestoreProfili, this.treeListSingolo, false);

            m_GestoreTitoliScuole = new GestoreTitoli(session);
            m_GestoreTitoliScuole.ReBuildElencoTitoli(percorso, true, this.treeListScuola);
            m_GestoreTitoliScuole.ApplyElencoTitoli(m_GestoreProfili, this.treeListScuola, true);

            this.checkEditScuola.Checked = (m_GestoreProfili.TotalePersoneScuole() > 0);

            checkEditScuola_CheckedChanged(null, null);

            this.spinEditNumero.Value = m_GestoreProfili.TotalePersone();
            if (this.spinEditNumero.Value == 0)
            {
                this.spinEditNumero.Value = 1;
            }

            this.spinEditNumeroS.Value = m_GestoreProfili.TotalePersoneScuole();

            SetupAlbero();

            AggiornaTotale();
        }
Пример #3
0
        private void CercaIlPercorsoMigliore(GestoreProfili gestore, List <Ingresso> dafare)
        {
            // cerca il percorso migliore
            List <SoluzioneIngressiItem> nuovoPercorso = new List <SoluzioneIngressiItem>();

            foreach (ProfiloCliente item in gestore.ElencoProfili)
            {
                item.ElencoSoluzioni.CancellaContenuto();

                Tentativo(item, nuovoPercorso, 0, -1, dafare);

                item.TrovaSoluzionePreferita();
            }
        }
Пример #4
0
        internal void Init(UnitOfWork unitOfWork, GestoreProfili gestoreProfili)
        {
            //_Profilo = profilo;
            _GestoreProfili = gestoreProfili;
            _UnitOfWork     = unitOfWork;

            if (_GestoreProfili.ElencoCodiciSconto.Count > 0)
            {
                _CodiceSconto = _GestoreProfili.ElencoCodiciSconto[0];
            }
            else
            {
                _CodiceSconto = null;
            }

            UpdateInfo();
        }
Пример #5
0
        public void CalcolaSoluzioneKernel(List <Ingresso> dafare)
        {
            // tutte le varianti per i SINGOLI
            XPCollection <Variante> varianti = new XPCollection <Variante>(m_UnitOfWork);

            //varianti.Criteria = new BinaryOperator("TipologiaTre", TipologiaTreEnum.Standard, BinaryOperatorType.Equal);
            varianti.Sorting = new SortingCollection(varianti,
                                                     new SortProperty[] { new SortProperty("Biglietto.Percorso.Ingressi.Count", DevExpress.Xpo.DB.SortingDirection.Descending) });

            m_TutteLeVarianti = new List <Variante>();
            foreach (Variante item in varianti)
            {
                if (item.Biglietto.ComprendeData(DateTime.Now) && item.ComprendeData(DateTime.Now) &&
                    item.PrezzoAttuale != null && item.VenditaAbilitata)
                {
                    if (item.TipologiaTre == EnumTipologiaTre.CardMyFE && !item.MyFeComune())
                    {
                        continue;
                    }

                    m_TutteLeVarianti.Add(item);
                }
            }

            CercaIlPercorsoMigliore(m_GestoreProfili, dafare);

            // VERIFICA SE CONVIENE IL GRUPPO
            // verifica con un profilo unico, senza titoli per riduzione
            m_GestoreProfiloUnico = new GestoreProfili(m_GestoreProfili.TipologiaMyFe);
            ProfiloCliente nuovoProfilo = new ProfiloCliente();

            nuovoProfilo.ElencoTitoli     = new List <Titolo>();
            nuovoProfilo.NumeroPersone    = m_GestoreProfili.TotalePersone();
            nuovoProfilo.Scuola           = false;
            nuovoProfilo.OttimizzaCalcolo = true;

            m_GestoreProfiloUnico.ElencoProfili.Add(nuovoProfilo);
            List <Ingresso> nuovoDafare = new List <Ingresso>(dafare);

            CercaIlPercorsoMigliore(m_GestoreProfiloUnico, nuovoDafare);
        }
        public void Init(UnitOfWork session, List <Ingresso> percorso, ProfiloCliente profilo, GestoreProfili gestore)
        {
            m_Profilo        = profilo;
            m_GestoreProfili = gestore;

            m_GestoreTitoliSingoliGruppi = new GestoreTitoli(session);
            m_GestoreTitoliSingoliGruppi.ReBuildElencoTitoli(percorso, false, this.treeListSingolo);
            m_GestoreTitoliSingoliGruppi.ApplyElencoTitoli(m_Profilo.ElencoTitoli, this.treeListSingolo);

            m_GestoreTitoliScuole = new GestoreTitoli(session);
            m_GestoreTitoliScuole.ReBuildElencoTitoli(percorso, true, this.treeListScuola);
            m_GestoreTitoliScuole.ApplyElencoTitoli(m_Profilo.ElencoTitoli, this.treeListScuola);

            this.spinEditNumero.Value       = m_Profilo.NumeroPersone;
            this.simpleButtonDelete.Enabled = m_GestoreProfili.ElencoProfili.Contains(m_Profilo);

            this.checkEditScuola.Checked = m_Profilo.Scuola;
            checkEditScuola_CheckedChanged(null, null);

            SetupAlbero();
        }
Пример #7
0
        internal int ApplyElencoTitoli(GestoreProfili gestoreProfili, TreeList albero, bool scuola)
        {
            int num = 0;

            List <ProfiloCliente> elenco = new List <ProfiloCliente>();

            foreach (TreeListNode item in albero.Nodes)
            {
                if (item.HasChildren)
                {
                    num += ApplyElencoTitoli(gestoreProfili, item, albero, elenco, scuola);
                }
                else
                {
                    Titolo titolo = item.Tag as Titolo;
                    foreach (ProfiloCliente profilo in gestoreProfili.ElencoProfili)
                    {
                        if (profilo.Scuola != scuola)
                        {
                            continue;
                        }

                        if ((titolo != null && profilo.ElencoTitoli.Contains(titolo)) ||
                            (titolo == null && profilo.ElencoTitoli.Count == 0))
                        {
                            if (!elenco.Contains(profilo))
                            {
                                item.SetValue(albero.Columns[3], profilo.NumeroPersone);
                                elenco.Add(profilo);
                                num++;
                            }
                        }
                    }
                }
            }

            return(num);
        }
Пример #8
0
        public List <Suggerimento> Suggerimenti(List <Ingresso> dafare)
        {
            List <Suggerimento> suggerimenti = new List <Suggerimento>();

            if (dafare.Count == 0 || m_GestoreProfili.ElencoProfili.Count == 0)
            {
                return(suggerimenti);
            }

            if (dafare.Count >= 5)
            {
                return(suggerimenti);
            }

            // assumo di avere una soluzione valida
            decimal gestoreProfiliTotaleImporto = m_GestoreProfili.TotaleImporto();
            decimal sogliaMax = gestoreProfiliTotaleImporto * 1.20m;
            decimal sogliaMin = gestoreProfiliTotaleImporto * 0.7m;

            if (gestoreProfiliTotaleImporto == 0)
            {
                return(suggerimenti);
            }

            // clona m_GestoreProfili
            GestoreProfili nuovoGestore = new GestoreProfili(m_GestoreProfili.TipologiaMyFe);

            foreach (ProfiloCliente item in m_GestoreProfili.ElencoProfili)
            {
                ProfiloCliente nuovoProfilo = new ProfiloCliente();
                nuovoProfilo.ElencoTitoli     = item.ElencoTitoli;
                nuovoProfilo.NumeroPersone    = item.NumeroPersone;
                nuovoProfilo.Scuola           = item.Scuola;
                nuovoProfilo.OttimizzaCalcolo = true;

                nuovoGestore.ElencoProfili.Add(nuovoProfilo);
            }

            // calcola suggerimenti
            XPCollection <Ingresso> ingressi = new XPCollection <Ingresso>(m_UnitOfWork);

            for (int indicePrimo = 0; indicePrimo < ingressi.Count; indicePrimo++)
            {
                Ingresso ingressoPrimo = ingressi[indicePrimo];

                if (ingressoPrimo.Tipologia != EnumTipologiaIngresso.Museo)
                {
                    continue;
                }

                if (!dafare.Contains(ingressoPrimo))
                {
                    List <Ingresso> nuovoDafare = new List <Ingresso>(dafare);
                    nuovoDafare.Add(ingressoPrimo);

                    CercaIlPercorsoMigliore(nuovoGestore, nuovoDafare);

                    decimal nuovoGestoreTotaleImporto = nuovoGestore.TotaleImporto();
                    if (nuovoGestoreTotaleImporto <= sogliaMax && nuovoGestoreTotaleImporto > sogliaMin)
                    {
                        Suggerimento sugg = new Suggerimento();
                        sugg.Importo        = nuovoGestoreTotaleImporto - gestoreProfiliTotaleImporto;
                        sugg.DescrizioneUno = ingressoPrimo.Descrizione;
                        sugg.DescrizioneDue = string.Empty;
                        sugg.IngressoUno    = ingressoPrimo;
                        sugg.IngressoDue    = null;

                        suggerimenti.Add(sugg);
                    }

                    if (nuovoDafare.Count <= 3)
                    {
                        // provo ad aggiungerne un altro
                        for (int indiceSecondo = indicePrimo + 1; indiceSecondo < ingressi.Count; indiceSecondo++)
                        {
                            Ingresso ingressoSecondo = ingressi[indiceSecondo];

                            if (ingressoSecondo.Tipologia != EnumTipologiaIngresso.Museo)
                            {
                                continue;
                            }

                            if (!dafare.Contains(ingressoSecondo))
                            {
                                List <Ingresso> nuovoDafareSecondo = new List <Ingresso>(nuovoDafare);
                                nuovoDafareSecondo.Add(ingressoSecondo);

                                // aggiungo due ingressi

                                CercaIlPercorsoMigliore(nuovoGestore, nuovoDafareSecondo);

                                nuovoGestoreTotaleImporto = nuovoGestore.TotaleImporto();
                                if (nuovoGestoreTotaleImporto <= sogliaMax && nuovoGestoreTotaleImporto > sogliaMin)
                                {
                                    Suggerimento sugg = new Suggerimento();
                                    sugg.Importo        = nuovoGestoreTotaleImporto - gestoreProfiliTotaleImporto;
                                    sugg.DescrizioneUno = ingressoPrimo.Descrizione;
                                    sugg.DescrizioneDue = ingressoSecondo.Descrizione;
                                    sugg.IngressoUno    = ingressoPrimo;
                                    sugg.IngressoDue    = ingressoSecondo;

                                    suggerimenti.Add(sugg);
                                }
                            }
                        }
                    }
                }
            }

            return(suggerimenti);
        }