Beispiel #1
0
 private bool CamiaoValidoNaoCompleto(EncomendaFrita encomenda, PlanoFrito plano)
 {
     if (plano.CapacidadePaletes == plano.Ocupadas)
     {
         return(false);
     }
     return(CamiaoValido(encomenda, plano));
 }
Beispiel #2
0
        private bool isValidPlan(EncomendaFrita encomenda, PlanoFrito plano)
        {
            if (plano.Preco <= 0)
            {
                return(false);
            }
            if (plano.Ocupadas == plano.CapacidadePaletes)
            {
                return(false);
            }

            //Tem espaço para esta encomenda?
            if (plano.CapacidadePaletes - plano.Ocupadas < encomenda.Paletes)
            {
                return(false);
            }
            //Preciso e tenho congelados?
            if (!plano.Congelados && encomenda.Tipo == Tipo.Congelado)
            {
                return(false);
            }
            //Preciso e tenho Scos?
            if (!plano.Secos && encomenda.Tipo == Tipo.Seco)
            {
                return(false);
            }
            //Preciso e tenho frescos?
            if (!plano.Frescos &&
                encomenda.Tipo == Tipo.Frio)
            {
                return(false);
            }
            //Faço entregas para a zona do cliente?
            if (plano.Zona != encomenda.Encomenda.Cliente1.Zona && plano.Zona != encomenda.Encomenda.Cliente1.Opcao_zona_2 && plano.Zona != encomenda.Encomenda.Cliente1.Opcao_zona_3)
            {
                return(false);
            }
            //Camiao com ridelle
            if (!plano.Ridelle && encomenda.Ridelle)
            {
                return(false);
            }
            //Camiao com descarga manual
            if (!plano.EntradaSemAcesso && encomenda.SemAcesso)
            {
                return(false);
            }

            /*
             * if (plano.CapacidadePaletes == 15 && plano.Ocupadas < 12)
             *  return false;
             * if (plano.CapacidadePaletes == 8 && (plano.Ocupadas + encomenda.Paletes) < 6)
             *  return false;*/

            return(true);
        }
Beispiel #3
0
 internal double PriceWith(EncomendaFrita current)
 {
     this.Encomendas.Add(current);
     if (this.Encomendas != null && this.Encomendas.Count > 0)
     {
         int    extra = (this.Encomendas.GroupBy(x => x.Cliente).Count() - 1) * 50;
         double price = this.Preco / this.CapacidadePaletes * this.Ocupadas;
         this.Encomendas.Remove(current);
         if (price <= 0)
         {
             return(-1);
         }
         return(price + extra);
     }
     return(-1);
 }
Beispiel #4
0
        private bool CamiaoValido(EncomendaFrita encomenda, PlanoFrito plano)
        {
            if (plano.CapacidadePaletes == 5 && plano.Ocupadas < 3)
            {
                return(false);
            }
            if (plano.CapacidadePaletes == 11 && plano.Ocupadas < 8)
            {
                return(false);
            }
            if (plano.CapacidadePaletes == 18 && plano.Ocupadas < 12)
            {
                return(false);
            }
            if (plano.CapacidadePaletes == 32 && plano.Ocupadas < 21)
            {
                return(false);
            }

            if (!plano.Congelados &&
                encomenda.Tipo == Tipo.Congelado)
            {
                return(false);
            }
            //Preciso e tenho Scos?
            if (!plano.Secos &&
                encomenda.Tipo == Tipo.Seco)
            {
                return(false);
            }
            //Preciso e tenho frescos?
            if (!plano.Frescos &&
                encomenda.Tipo == Tipo.Frio)
            {
                return(false);
            }
            //Faço entregas para a zona do cliente?
            if (plano.Zona != encomenda.Encomenda.Cliente1.Zona &&
                plano.Zona != encomenda.Encomenda.Cliente1.Opcao_zona_2 &&
                plano.Zona != encomenda.Encomenda.Cliente1.Opcao_zona_3)
            {
                return(false);
            }


            return(true);
        }
Beispiel #5
0
        private PlanoFrito BestPlanFor(EncomendaFrita encomenda, List <PlanoFrito> plans)
        {
            var        alreadyUsed = plans.Where(x => x.Ocupadas > 0).ToList();
            var        minPrice    = double.MaxValue;
            PlanoFrito plan        = null;

            //Already used
            for (int i = 0; i < alreadyUsed.Count; i++)
            {
                var plano = alreadyUsed[i];
                if (!isValidPlan(encomenda, plano))
                {
                    continue;
                }
                if (minPrice > plano.Preco)
                {
                    minPrice = plano.Preco;
                    plan     = plano;
                }
            }

            if (plan != null)
            {
                return(plan);
            }
            //Pick from rest
            var notalreadyUsed = plans.Where(x => x.Ocupadas == 0).ToList();

            for (int i = 0; i < notalreadyUsed.Count; i++)
            {
                var plano = notalreadyUsed[i];
                if (!isValidPlan(encomenda, plano))
                {
                    continue;
                }
                if (minPrice > plano.Preco)
                {
                    minPrice = plano.Preco;
                    plan     = plano;
                }
            }
            return(plan);
        }
Beispiel #6
0
        private void Planify(EncomendaFrita current, IEnumerable <EncomendaFrita> encomendas, IEnumerable <PlanoFrito> plans)
        {
            PlanoCount++;
            double cachePrice = CalculatePrice(plans);

            if (cachePrice >= CurrentMinimum - threshold)
            {
                return;
            }
            var planos = plans.ToList();

            // Try all the plan
            for (int i = 0; i < planos.Count(); i++)
            {
                if (cachePrice >= CurrentMinimum - threshold)
                {
                    return;
                }
                var plan = planos[i];
                if (!isValidPlan(current, plan))
                {
                    continue;
                }
                //fast price check
                var planosClone = planos.Select(x => new PlanoFrito(x)).ToList();
                plan = planosClone[i];
                // Test this
                plan.Encomendas.Add(current);
                var price = CalculatePrice(planosClone);
                if (price >= CurrentMinimum - threshold)
                {
                    continue;
                }
                //test the rest of the setup
                Encomenda(encomendas, planosClone);
                // Null is impossible
            }
        }
Beispiel #7
0
        public List <PlanoFrito> Execute()
        {
            deleteDB();
            PlanoCount = 0;
            RecurCount = 0;
            Cache.Clear();
            context = new AMDModels();
            // context.Encomendas.Where( x => x.QtRollCong > 5 && x.Clientes.Distancias. )
            List <Models.PlanoSemanal> plano = context.PlanoSemanals.ToList();

            var plan = plano.Select(x => new PlanoFrito(x)).ToList();
            List <EncomendaFrita> regisotSemanal = new List <EncomendaFrita>();



            var encomendas = context.Encomendas.ToList();

            foreach (var enc in encomendas)
            {
                if (enc.Estado == "Arquivado")
                {
                    continue;
                }


                if (enc.QtRollCong > 0 || enc.QtPalCong > 0)
                {
                    var encoF = new EncomendaFrita();
                    encoF.Encomenda = enc;
                    encoF.Tipo      = Tipo.Congelado;
                    encoF.Semana    = encoF.Semana;
                    encoF.Paletes   = enc.TotalCongelados;
                    encoF.Rolli     = enc.QtRollCong ?? 0;
                    encoF.SemAcesso = enc.Manual ?? false;
                    if (enc.Ridelle != null)
                    {
                        encoF.Ridelle = enc.Ridelle.Value;
                    }
                    if (enc.Manual != null)
                    {
                        encoF.SemAcesso = enc.Manual.Value;
                    }
                    encoF.Cliente = enc.Cliente;
                    regisotSemanal.Add(encoF);
                    encoF.Peso = enc.Peso;
                }
                if (enc.QtRollSec > 0 || enc.QtPalSec > 0)
                {
                    var encoF = new EncomendaFrita();
                    encoF.Encomenda = enc;
                    encoF.Tipo      = Tipo.Seco;
                    encoF.Semana    = encoF.Semana;
                    encoF.Paletes   = enc.TotalSecos;
                    encoF.Rolli     = enc.QtRollSec ?? 0;
                    encoF.SemAcesso = enc.Manual ?? false;
                    if (enc.Ridelle != null)
                    {
                        encoF.Ridelle = enc.Ridelle.Value;
                    }
                    if (enc.Manual != null)
                    {
                        encoF.SemAcesso = enc.Manual.Value;
                    }
                    encoF.Cliente = enc.Cliente;
                    regisotSemanal.Add(encoF);
                    encoF.Peso = enc.Peso;
                }
                if (enc.QtRollFres > 0 || enc.QtPalFres > 0)
                {
                    var encoF = new EncomendaFrita();
                    encoF.Encomenda = enc;
                    encoF.Semana    = encoF.Semana;
                    encoF.Tipo      = Tipo.Frio;
                    encoF.Paletes   = enc.TotalFrios;
                    encoF.Rolli     = enc.QtRollFres ?? 0;
                    encoF.SemAcesso = enc.Manual ?? false;
                    if (enc.Ridelle != null)
                    {
                        encoF.Ridelle = enc.Ridelle.Value;
                    }
                    if (enc.Manual != null)
                    {
                        encoF.SemAcesso = enc.Manual.Value;
                    }
                    encoF.Cliente = enc.Cliente;
                    regisotSemanal.Add(encoF);
                    encoF.Peso = enc.Peso;
                }
            }



            //Algoritmo

            IEnumerable <PlanoFrito> ol = R(regisotSemanal, plan);
            //Recursive(regisotSemanal, plano, out ol);
            //var semana = 0;

            //var preçoMinimo = CalculatePrice(ol);

            // OK Simple s:P
            // Nos queremos os planos que nao têm nada primeiro
            //ver se existe algum que de para por encomendas

            var  master = ol.ToList();
            bool stop   = false;

            do
            {
                bool troca          = false;
                var  emptyPlans     = master.Where(x => x.Encomendas.Count == 0);
                var  withEncomendas = master.Where(x => x.Encomendas.Count > 0);
                foreach (var com in withEncomendas)
                {
                    foreach (var sem in emptyPlans.OrderBy(x => x.CapacidadePaletes))
                    {
                        //temos que ver se o plano é menor que o que temos
                        if (com.CapacidadePaletes <= sem.CapacidadePaletes || com.Ocupadas > sem.CapacidadePaletes)
                        {
                            continue; //Este nao tem espaço
                        }
                        bool valid = true;
                        // temos que verificar se este camiao consegue levar todas as nossas encomendas
                        foreach (var enc in com.Encomendas)
                        {
                            if (!isValidPlan(enc, sem))
                            {
                                //chapeu nao da, next
                                valid = false;
                                break;
                            }
                        }
                        if (!valid)
                        {
                            continue; // Next Pleaze not valid
                        }
                        // Este camiao é mais pequeno e consegue levar as nossas encomendas
                        // Toca a trocar
                        sem.Encomendas.AddRange(com.Encomendas);
                        com.Encomendas.Clear();
                        troca = true;
                        break;
                    }
                    if (troca) // Se tivermos trocado temos que correr de  novo porque isto alterou os camioes
                    {
                        break;
                    }
                }
                stop = !troca; // paramos se nao tiver havido troca
            } while (!stop);

            foreach (var planf in plan)
            {
                foreach (var encomendaF in planf.Encomendas)
                {
                    if (encomendaF.Estado == "Arquivado")
                    {
                        break;
                    }

                    try
                    {
                        // Your code...
                        // Could also be before try if you know the exception occurs in SaveChanges
                        // Aqui ta a encomenda frita
                        var context = new AMDModels();

                        String tipoEnc = "";

                        if ((int)encomendaF.Tipo == 0)
                        {
                            tipoEnc = "Congelados";
                        }

                        if ((int)encomendaF.Tipo == 1)
                        {
                            tipoEnc = "Frescos";
                        }

                        if ((int)encomendaF.Tipo == 2)
                        {
                            tipoEnc = "Secos";
                        }



                        /*
                         * string connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["AMD"].ConnectionString;
                         * SqlConnection con = new SqlConnection(connectionString);
                         *
                         * SqlCommand cmd = new SqlCommand("Select Nome from Clientes where Numero == @encomendaF.Cliente", con);
                         *
                         * con.Open();
                         * SqlDataAdapter adapt = new SqlDataAdapter(cmd);
                         * DataSet ds = new DataSet();
                         * adapt.Fill(ds);
                         * string nome = ds.Tables[0].Rows[0]["Item"].ToString();
                         * con.Close();
                         */

                        context.EncomendasFritas.Add(new EncomendasFrita()
                        {
                            Cliente   = encomendaF.Cliente,
                            Paletes   = encomendaF.Paletes,
                            Plano     = planf.PlanoSemanal.NumeroCarga,
                            Encomenda = encomendaF.Encomenda.CodEncomenda,
                            Ridelle   = encomendaF.Ridelle,
                            Rolli     = encomendaF.Rolli,
                            SemAcesso = encomendaF.SemAcesso,
                            Tipo      = tipoEnc,
                            Semana    = SemanaAtual(),
                            Peso      = encomendaF.Peso
                        });
                        context.SaveChanges();
                    }
                    catch (DbEntityValidationException e)
                    {
                        foreach (var eve in e.EntityValidationErrors)
                        {
                            Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                                              eve.Entry.Entity.GetType().Name, eve.Entry.State);
                            foreach (var ve in eve.ValidationErrors)
                            {
                                Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                                                  ve.PropertyName, ve.ErrorMessage);
                            }
                        }
                        throw;
                    }
                    context.SaveChanges();
                }
            }


            //Este e o novo preço minimo,
            //TODO:: Ou muito me engano ou estas a calcular mal os preços, o que esta certo e que ele de facto faz o que é rpeciso, escolhe os camioes mais pequenos ;)
            var preçoMinimo2 = CalculatePrice(master);

            try
            {
                var re = ol.Where(x => x.Encomendas != null);
                MessageBox.Show("Preço Minimo = " + preçoMinimo2);
                return(ol.Where(x => x.Ocupadas > 0).ToList());
            }
            catch (Exception ex)
            {
                MessageBox.Show("Não é possivel efectuar carga");
                return(null);
            }
            //var age = a.First().Transportador;
        }