Пример #1
0
        public void ImportarValores(int ano, Enum.OrcamentodaUnidade.Trimestres trimestre, string pathTemp)
        {
            var lista = RepositoryService.MetadaUnidade.ListarMetas(ano);

            foreach (var metaUnidade in lista)
            {
                int?status = RepositoryService.MetadaUnidade.Retrieve(metaUnidade.ID.Value, "statuscode").StatusCode;

                if (status.HasValue && status.Value != (int)Enum.MetaUnidade.StatusMetaUnidade.ImportarPlanilhaMeta)
                {
                    ImportarValores(metaUnidade, pathTemp, trimestre);
                }
            }
        }
        public void ImportarValores(int ano, Enum.OrcamentodaUnidade.Trimestres trimestre, string pathTemp)
        {
            var lista = RepositoryService.MetadaUnidade.ListarMetas(ano);

            foreach (var metaUnidade in lista)
            {
                int?status = RepositoryService.MetadaUnidade.Retrieve(metaUnidade.ID.Value, "itbc_razodostatusmetasupervisor").RazaodoStatusMetaSupervisor;

                if (status.HasValue && status.Value != (int)Enum.MetaUnidade.RazaodoStatusMetaSupervisor.ImportandoPlanilhaMetaSupervisor)
                {
                    ImportarValores(metaUnidade, pathTemp, trimestre);
                }
            }
        }
Пример #3
0
        public static Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes[] ListarMeses(Enum.OrcamentodaUnidade.Trimestres trimestre)
        {
            switch (trimestre)
            {
            case Enum.OrcamentodaUnidade.Trimestres.Trimestre1:
                return(new Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes[]
                {
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Janeiro,
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Fevereiro,
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Marco
                });


            case Enum.OrcamentodaUnidade.Trimestres.Trimestre2:
                return(new Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes[]
                {
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Abril,
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Maio,
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Junho
                });


            case Enum.OrcamentodaUnidade.Trimestres.Trimestre3:
                return(new Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes[]
                {
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Julho,
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Agosto,
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Setembro
                });


            case Enum.OrcamentodaUnidade.Trimestres.Trimestre4:
                return(new Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes[]
                {
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Outubro,
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Novembro,
                    Enum.OrcamentodaUnidadeDetalhadoporProduto.Mes.Dezembro
                });

            default:
                throw new ArgumentException("(CRM) Opção de trimestre inválida! Valor: " + trimestre);
            }
        }
Пример #4
0
        private List <string> AtualizarValoresPotencialProdutoMes(MetadaUnidade metaUnidade, int quantidadePorLote, Enum.OrcamentodaUnidade.Trimestres trimeste)
        {
            var listaPotencialProduto = RepositoryService.MetadaUnidadeporProduto.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, trimeste);

            var listaError  = new List <string>();
            var listaCreate = new List <MetaDetalhadadaUnidadeporProduto>();
            var listaUpdate = new List <MetaDetalhadadaUnidadeporProduto>();

            foreach (var mes in Helper.ListarMeses(trimeste))
            {
                var listaTodos      = RepositoryService.MetadaUnidadeporProdutoMes.ListarValoresPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, mes);
                var listaExistentes = RepositoryService.MetadaUnidadeporProdutoMes.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, mes);

                foreach (var item in listaTodos)
                {
                    var itemExistente = listaExistentes.Find(x => x.Produto.Id == item.Produto.Id);

                    if (itemExistente == null)
                    {
                        var potencialProduto = listaPotencialProduto.Find(x => x.Produto.Id == item.Produto.Id);


                        item.Nome           = string.Format("{0} - {1} - {2}", metaUnidade.UnidadedeNegocios.Name, Helper.ConvertToInt(mes), item.Produto.Name).Truncate(100);
                        item.MetadoProduto  = new Lookup(potencialProduto.ID.Value, potencialProduto.Nome, SDKore.Crm.Util.Utility.GetEntityName(potencialProduto));
                        item.Trimestre      = (int)trimeste;
                        item.UnidadeNegocio = metaUnidade.UnidadedeNegocios;
                        item.RazaoStatus    = (int)Domain.Enum.MetaUnidadeporProdutoMes.StatusCode.Ativa;

                        listaCreate.Add(item);
                    }
                    else
                    {
                        item.ID = itemExistente.ID;
                        listaUpdate.Add(item);
                    }
                }
            }

            // Update em lote
            for (int i = 0; i < listaUpdate.Count; i += quantidadePorLote)
            {
                var retorno = RepositoryService.MetadaUnidadeDetalhadaProduto.Update(listaUpdate.Skip(i).Take(quantidadePorLote).ToList());

                foreach (var item in retorno)
                {
                    listaError.Add(item.Key + " - " + item.Value);
                }
            }

            // Create em lote
            for (int i = 0; i < listaCreate.Count; i += quantidadePorLote)
            {
                var listaEmLote = listaCreate.Skip(i).Take(quantidadePorLote).ToList();

                DomainExecuteMultiple retorno = RepositoryService.MetadaUnidadeDetalhadaProduto.Create(listaEmLote);

                if (retorno.IsFaulted)
                {
                    for (int x = 0; x < retorno.List.Length; x++)
                    {
                        var item = retorno.List[x];

                        listaError.Add("Create - " + item.Message);
                    }
                }
            }

            return(listaError);
        }
        private Dictionary <Guid, string> AtualizarValoresPotencialProduto(MetadaUnidade metaUnidade, int quantidadePorLote, Enum.OrcamentodaUnidade.Trimestres trimeste)
        {
            var listaTodos               = RepositoryService.PotencialdoSupervisorporProduto.ListarValoresPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, trimeste);
            var listaExistentes          = RepositoryService.PotencialdoSupervisorporProduto.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, trimeste);
            var listaPotencialSubfamilia = RepositoryService.PotencialdoSupervisorporSubfamilia.ListarPorUnidadeNegocio(metaUnidade.UnidadedeNegocios.Id, metaUnidade.Ano.Value, trimeste);

            var listaError  = new Dictionary <Guid, string>();
            var listaCreate = new List <PotencialdoSupervisorporProduto>();
            var listaUpdate = new List <PotencialdoSupervisorporProduto>();

            foreach (var item in listaTodos)
            {
                var itemExistente = listaExistentes.Find(x => x.Trimestre.Value == item.Trimestre.Value &&
                                                         x.Produto.Id == item.Produto.Id &&
                                                         x.Supervisor.Id == item.Supervisor.Id);


                if (itemExistente == null)
                {
                    var potencialSubfamilia = listaPotencialSubfamilia.Find(x => x.SubfamiliadeProduto.Id == item.Subfamilia.Id &&
                                                                            x.Supervisor.Id == item.Supervisor.Id);


                    item.UnidadeNegocio = metaUnidade.UnidadedeNegocios;
                    item.Nome           = string.Format("{0} - {1}", metaUnidade.UnidadedeNegocios.Name, item.Produto.Name);
                    item.PotencialdoSupervisorPorProduto = new Lookup(potencialSubfamilia.ID.Value, potencialSubfamilia.Nome, SDKore.Crm.Util.Utility.GetEntityName(potencialSubfamilia));
                    item.RazaoStatus = (int)Domain.Enum.PotencialdoSupervisorporProduto.StatusCode.Ativa;

                    listaCreate.Add(item);
                }
                else
                {
                    item.ID = itemExistente.ID;
                    listaUpdate.Add(item);
                }
            }

            // Update em lote
            for (int i = 0; i < listaUpdate.Count; i += quantidadePorLote)
            {
                var retorno = RepositoryService.PotencialdoSupervisorporProduto.Update(listaUpdate.Skip(i).Take(quantidadePorLote).ToList());

                foreach (var item in retorno)
                {
                    listaError.Add(item.Key, item.Value);
                }
            }

            // Create em lote
            for (int i = 0; i < listaCreate.Count; i += quantidadePorLote)
            {
                var listaEmLote = listaCreate.Skip(i).Take(quantidadePorLote).ToList();

                DomainExecuteMultiple retorno = RepositoryService.PotencialdoSupervisorporProduto.Create(listaEmLote);

                if (retorno.IsFaulted)
                {
                    for (int x = 0; x < retorno.List.Length; x++)
                    {
                        var item = retorno.List[x];

                        listaError.Add(Guid.Empty, item.Message);
                    }
                }
            }

            return(listaError);
        }