Exemple #1
0
        //Listagem das Folhas de Horas consoante o estado
        public JsonResult GetListComprasByEstado([FromBody] Compras ML)
        {
            UserAccessesViewModel UPerm = DBUserAccesses.GetByUserAreaFunctionality(User.Identity.Name, Enumerations.Features.MercadoLocal);

            if (UPerm != null && UPerm.Read.Value)
            {
                ViewBag.UPermissions = UPerm;

                List <ComprasViewModel> result = new List <ComprasViewModel>();
                if (ML.Estado == 0)
                {
                    result = DBCompras.GetAll();
                }
                else
                {
                    result = DBCompras.GetAllByEstado((int)ML.Estado);
                }

                if (result != null)
                {
                    List <NAVProjectsViewModel>  AllProjects = DBNAV2017Projects.GetAll(_config.NAVDatabaseName, _config.NAVCompanyName, "");
                    List <LinhasRequisição>      AllLines    = DBRequestLine.GetAll();
                    List <NAVSupplierViewModels> AllSupliers = DBNAV2017Supplier.GetAll(_config.NAVDatabaseName, _config.NAVCompanyName, "");

                    result.ForEach(Compras =>
                    {
                        Compras.RegiaoMercadoLocalTexto = Compras.RegiaoMercadoLocal == null ? "" : EnumerablesFixed.LocalMarketRegions.Where(y => y.Id == Compras.RegiaoMercadoLocal).FirstOrDefault().Value;
                        Compras.CodigoProdutoTexto      = Compras.CodigoProduto == null ? "" : Compras.CodigoProduto;
                        Compras.EstadoTexto             = Compras.Estado == null ? "" : EnumerablesFixed.ComprasEstado.Where(y => y.Id == Compras.Estado).FirstOrDefault().Value;

                        if (!string.IsNullOrEmpty(Compras.NoFornecedor))
                        {
                            Compras.NoFornecedorTexto = Compras.NoFornecedor == null ? "" : Compras.NoFornecedor + " - " + AllSupliers.Where(x => x.No_ == Compras.NoFornecedor).FirstOrDefault() != null ? AllSupliers.Where(x => x.No_ == Compras.NoFornecedor).FirstOrDefault().Name : "";
                        }

                        if (!string.IsNullOrEmpty(Compras.NoRequisicao) && Compras.NoLinhaRequisicao != null)
                        {
                            Compras.RecusadoComprasTexto = AllLines.Where(x => x.NºRequisição == Compras.NoRequisicao && x.NºLinha == Compras.NoLinhaRequisicao).FirstOrDefault() != null ? AllLines.Where(x => x.NºRequisição == Compras.NoRequisicao && x.NºLinha == Compras.NoLinhaRequisicao).FirstOrDefault().RecusadoCompras == true ? "Sim" : "Não" : "";
                        }

                        if (!string.IsNullOrEmpty(Compras.NoProjeto))
                        {
                            Compras.NoProjetoTexto = AllProjects.Where(x => x.No == Compras.NoProjeto).FirstOrDefault() != null ? AllProjects.Where(x => x.No == Compras.NoProjeto).FirstOrDefault().Description : "";
                        }
                    });
                }

                return(Json(result.OrderByDescending(x => x.ID)));
            }

            return(Json(null));
        }
Exemple #2
0
        public RequisitionViewModel CreateMarketConsultFor(RequisitionViewModel requisition)
        {
            try
            {
                //Verificar se pode criar uma consulta de mercado
                if (requisition.Lines.Where(p => p.CreateMarketSearch == true).Where(p => string.IsNullOrEmpty(p.QueryCreatedMarketNo)).Count() <= 0)
                {
                    requisition.eReasonCode = -1;
                    requisition.eMessage    = "Consulta ao Mercado não pode ser criada! As linhas devem estar marcadas com 'Criar Consulta Mercado' e não ter 'Nº de Consulta Mercado Criada'";
                    return(requisition);
                }

                //Criar nova Consulta Mercado - Obtenção do novo NumConsultaMercado e incrementar Numerações
                ConsultaMercado consultaMercado = DBConsultaMercado.Create(changedByUserName);

                //Ir Buscar o Nº Mecanográfico do utilizado
                ConfigUtilizadores UC = DBUserConfigurations.GetById(changedByUserName);

                //Actualizar o registo com os dados possiveis
                consultaMercado.CodProjecto               = requisition.ProjectNo == "" ? null : requisition.ProjectNo;
                consultaMercado.Descricao                 = "Consulta Mercado - " + requisition.RequisitionNo;
                consultaMercado.CodRegiao                 = requisition.RegionCode;
                consultaMercado.CodAreaFuncional          = requisition.FunctionalAreaCode;
                consultaMercado.CodCentroResponsabilidade = requisition.CenterResponsibilityCode;
                consultaMercado.DataPedidoCotacao         = DateTime.Now;
                consultaMercado.CodLocalizacao            = requisition.LocalCode;
                consultaMercado.Destino = 0;
                consultaMercado.Estado  = 0;
                consultaMercado.UtilizadorRequisicao = requisition.CreateUser;
                consultaMercado.Fase                   = 0;
                consultaMercado.Modalidade             = 0;
                consultaMercado.PedidoCotacaoCriadoEm  = DateTime.Now;
                consultaMercado.PedidoCotacaoCriadoPor = changedByUserName;
                consultaMercado.NumRequisicao          = requisition.RequisitionNo;
                consultaMercado.Urgente                = requisition.Urgent;
                consultaMercado.CodComprador           = !string.IsNullOrEmpty(UC.EmployeeNo) ? UC.EmployeeNo : null;

                consultaMercado = DBConsultaMercado.Update(consultaMercado);

                //Para cada linha da requisição
                foreach (RequisitionLineViewModel requisitionLine in requisition.Lines.Where(p => p.CreateMarketSearch == true).Where(p => p.QueryCreatedMarketNo == null))
                {
                    decimal _qty            = requisitionLine.QuantityToRequire != null ? requisitionLine.QuantityToRequire.Value : 0;
                    decimal _custo          = requisitionLine.UnitCost != null ? requisitionLine.UnitCost.Value : 0;
                    decimal _custoTotalPrev = Math.Round(_qty * _custo * 100) / 100;

                    DateTime?_dataEntrega;

                    try
                    {
                        _dataEntrega = DateTime.Parse(requisitionLine.ExpectedReceivingDate);
                    }
                    catch
                    {
                        _dataEntrega = null;
                    }

                    //Inserir Linhas na tabela "Linhas_Consulta_Mercado"
                    LinhasConsultaMercado linhasConsultaMercado = new LinhasConsultaMercado()
                    {
                        NumConsultaMercado        = consultaMercado.NumConsultaMercado,
                        CodProduto                = requisitionLine.Code,
                        Descricao                 = requisitionLine.Description,
                        Descricao2                = requisitionLine.Description2,
                        NumProjecto               = requisitionLine.ProjectNo,
                        CodRegiao                 = requisitionLine.RegionCode,
                        CodAreaFuncional          = requisitionLine.FunctionalAreaCode,
                        CodCentroResponsabilidade = requisitionLine.CenterResponsibilityCode,
                        CodLocalizacao            = requisitionLine.LocalCode,
                        Quantidade                = requisitionLine.QuantityToRequire,
                        CustoUnitarioPrevisto     = requisitionLine.UnitCost,
                        CustoTotalPrevisto        = _custoTotalPrev,
                        CodUnidadeMedida          = requisitionLine.UnitMeasureCode,
                        DataEntregaPrevista       = _dataEntrega,
                        NumRequisicao             = requisition.RequisitionNo,
                        LinhaRequisicao           = requisitionLine.LineNo,
                        CriadoEm  = DateTime.Now,
                        CriadoPor = changedByUserName
                    };
                    linhasConsultaMercado = DBConsultaMercado.Create(linhasConsultaMercado);


                    //Verificar se tem Fornecedor identificado
                    if (requisitionLine.SupplierNo != null)
                    {
                        //Verificar se na tabela "Seleccao_Entidades" já temos este Fornecedor para esta Consulta Mercado
                        SeleccaoEntidades seleccaoEntidades = DBConsultaMercado.GetSeleccaoEntidadesPorNumConsultaFornecedor(consultaMercado.NumConsultaMercado, requisitionLine.SupplierNo);

                        if (seleccaoEntidades == null)
                        {
                            seleccaoEntidades = new SeleccaoEntidades()
                            {
                                NumConsultaMercado = consultaMercado.NumConsultaMercado,
                                CodFornecedor      = requisitionLine.SupplierNo,
                                NomeFornecedor     = !string.IsNullOrEmpty(requisitionLine.SupplierNo) ? DBNAV2017Supplier.GetAll(_config.NAVDatabaseName, _config.NAVCompanyName, requisitionLine.SupplierNo).FirstOrDefault().Name : "",
                                Selecionado        = true,
                                Preferencial       = true
                            };

                            seleccaoEntidades = DBConsultaMercado.Create(seleccaoEntidades);
                        }
                    }

                    requisitionLine.QueryCreatedMarketNo = consultaMercado.NumConsultaMercado;

                    DBRequestLine.Update(DBRequestLine.ParseToDB(requisitionLine));
                }

                requisition.MarketInquiryNo = consultaMercado.NumConsultaMercado;

                Requisição requisição = DBRequest.ParseToDB(requisition);
                DBRequest.Update(requisição);
                requisition = DBRequest.ParseToViewModel(requisição);

                requisition.eReasonCode = 1;
                requisition.eMessage    = "Consulta ao Mercado " + consultaMercado.NumConsultaMercado + " criada com sucesso";
            }
            catch (Exception ex)
            {
                requisition.eReasonCode = -1;
                requisition.eMessage    = ex.Message;
            }

            return(requisition);
        }
Exemple #3
0
        public RequisitionViewModel ValidateRequisition(RequisitionViewModel requisition)
        {
            requisition.eReasonCode = 99;
            requisition.eMessage    = "Ocorreu um erro na Validação da Requisição.";

            try
            {
                if (requisition != null)
                {
                    if (requisition.State == RequisitionStates.Approved)
                    {
                        if (requisition.Lines != null && requisition.Lines.Count > 0)
                        {
                            var linesToValidate = requisition.Lines
                                                  .Where(x => x.QuantityRequired != null && x.QuantityRequired.HasValue && x.QuantityRequired.Value > 0)
                                                  .ToList();

                            if (linesToValidate != null && linesToValidate.Count > 0)
                            {
                                linesToValidate.ForEach(item =>
                                {
                                    item.QuantityToProvide = item.QuantityRequired; // QuantidadeADisponibilizar = QuantidadeRequerida
                                    item.UpdateUser        = this.changedByUserName;
                                    item.UpdateDateTime    = DateTime.Now;

                                    if (DBRequestLine.Update(item.ParseToDB()) == null)
                                    {
                                        requisition.eReasonCode = 2;
                                        requisition.eMessage    = "Ocorreu um erro ao atualizar as linhas na Validação da Requisição.";
                                    }
                                });

                                if (requisition.eReasonCode == 99)
                                {
                                    requisition.State = RequisitionStates.Validated;
                                    requisition.ResponsibleValidation = this.changedByUserName;
                                    requisition.ValidationDate        = DateTime.Now;
                                    requisition.UpdateUser            = this.changedByUserName;

                                    var updatedReq = DBRequest.UpdateHeaderAndLines(requisition.ParseToDB(), true);
                                    if (updatedReq != null)
                                    {
                                        requisition             = updatedReq.ParseToViewModel();
                                        requisition.eReasonCode = 1;
                                        requisition.eMessage    = "Requisição validada com sucesso.";
                                    }
                                    else
                                    {
                                        requisition.eReasonCode = 3;
                                        requisition.eMessage    = "Ocorreu um erro ao validar a requisição.";
                                    }
                                }
                            }
                            else
                            {
                                requisition.eReasonCode = 4;
                                requisition.eMessage    = "Não existem linhas com Qt. Requerida superior a zero.";
                            }
                        }
                        else
                        {
                            requisition.eReasonCode = 5;
                            requisition.eMessage    = "Não existem linhas para validar na Requisição.";
                        }
                    }
                    else
                    {
                        requisition.eReasonCode = 6;
                        requisition.eMessage    = "A Requisição não está no estado Aprovado.";
                    }
                }
                else
                {
                    requisition = new RequisitionViewModel()
                    {
                        eReasonCode = 7,
                        eMessage    = "Erro na obtenção da Requisição.",
                    };
                }
            }
            catch
            {
                requisition.eReasonCode = 99;
                requisition.eMessage    = "Ocorreu um erro na Validação da Requisição.";
            };

            return(requisition);
        }
Exemple #4
0
        public RequisitionViewModel SendPrePurchaseFor(RequisitionViewModel requisition)
        {
            if (requisition != null && requisition.Lines != null && requisition.Lines.Count > 0 && requisition.State == RequisitionStates.Validated)
            {
                //use for later database update
                var requisitionLines = requisition.Lines
                                       .Where(x =>
                                              x.SendPrePurchase.Value == true && //Enviar Pré Compra
                                              (x.SubmitPrePurchase == null || x.SubmitPrePurchase.Value == false)) //Enviado Pré Compra
                                       .ToList();

                var prePurchOrderLines = requisitionLines
                                         .Select(line => new PrePurchOrderLineViewModel()
                {
                    RequisitionNo            = line.RequestNo,
                    RequisitionLineNo        = line.LineNo,
                    ProductCode              = line.Code,
                    ProductDescription       = line.Description,
                    UnitOfMeasureCode        = line.UnitMeasureCode,
                    LocationCode             = line.LocalCode,
                    QuantityAvailable        = line.QuantityAvailable,
                    UnitCost                 = line.UnitCost,
                    ProjectNo                = line.ProjectNo,
                    RegionCode               = line.RegionCode,
                    FunctionalAreaCode       = line.FunctionalAreaCode,
                    CenterResponsibilityCode = line.CenterResponsibilityCode,
                    CreateUser               = this.changedByUserName,
                    SupplierNo               = line.SupplierNo,
                })
                                         .ToList();

                if (prePurchOrderLines.Count() > 0)
                {
                    bool success = false;
                    try
                    {
                        //Update Requisition Lines
                        requisitionLines.ForEach(line =>
                        {
                            line.SubmitPrePurchase = true;
                            line.UpdateUser        = this.changedByUserName;
                        });

                        var createdLines = DBPrePurchOrderLines.CreateAndUpdateReqLines(prePurchOrderLines.ParseToDB(), requisitionLines.ParseToDB());
                        if (createdLines != null)
                        {
                            var updatedLines = DBRequestLine.GetByRequisitionId(requisition.RequisitionNo);
                            if (updatedLines != null)
                            {
                                requisition.Lines = updatedLines.ParseToViewModel();
                            }
                            success = true;
                        }
                    }
                    catch { }

                    if (success)
                    {
                        requisition.eReasonCode = 1;
                        requisition.eMessage    = "Pré-Compra enviada com sucesso";
                    }
                    else
                    {
                        requisition.eReasonCode = 2;
                        requisition.eMessage    = "Ocorreu um erro ao enviar a Pré-Compra.";
                    }
                }
                else
                {
                    requisition.eReasonCode = 2;
                    requisition.eMessage    = " Não existem linhas para enviar.";
                }
            }
            else
            {
                requisition.eReasonCode = 2;
                requisition.eMessage    = " O estado da requisição e / ou linhas não cumprem os requisitos.";
            }
            return(requisition);
        }
Exemple #5
0
        public RequisitionViewModel CreatePurchaseOrderFor(RequisitionViewModel requisition)
        {
            if (requisition != null && requisition.Lines != null && requisition.Lines.Count > 0)
            {
                if (string.IsNullOrEmpty(requisition.ReceivedDate))
                {
                    requisition.eReasonCode = 4;
                    requisition.eMessage    = "É obrigatório o preenchimento do campo Data Receção no Geral.";
                    return(requisition);
                }

                //use for database update later
                var requisitionLines = requisition.Lines;

                requisitionLines.RemoveAll(x => x.CriarNotaEncomenda == null || x.CriarNotaEncomenda == false);
                requisitionLines.RemoveAll(x => x.CreatedOrderNo != "" && x.CreatedOrderNo != null);
                //FIM

                if (requisitionLines.Any(x => string.IsNullOrEmpty(x.SupplierNo) || !x.UnitCost.HasValue || x.UnitCost.Value == 0))
                {
                    throw new Exception("É obrigatório o preenchimento do fornecedor e do custo unitário nas linhas");
                }


                List <PurchOrderDTO> purchOrders = new List <PurchOrderDTO>();
                List <DBNAV2017SupplierProductRef.SuppliersProductsRefs> supplierProductRef = new List <DBNAV2017SupplierProductRef.SuppliersProductsRefs>();

                try
                {
                    purchOrders = requisitionLines.GroupBy(x =>
                                                           x.SupplierNo,
                                                           x => x,
                                                           (key, items) => new PurchOrderDTO
                    {
                        SupplierId               = key,
                        RequisitionId            = requisition.RequisitionNo,
                        CenterResponsibilityCode = requisition.CenterResponsibilityCode,
                        FunctionalAreaCode       = requisition.FunctionalAreaCode,
                        RegionCode               = requisition.RegionCode,
                        LocalMarketRegion        = requisition.LocalMarketRegion,
                        InAdvance          = requisition.InAdvance.HasValue ? requisition.InAdvance.Value : false,
                        PricesIncludingVAT = requisition.PricesIncludingVAT.HasValue ? requisition.PricesIncludingVAT.Value : false,
                        LocationCode       = requisition.LocalCode,
                        Purchaser_Code     = requisition.NumeroMecanografico,


                        Lines = items.Select(line => new PurchOrderLineDTO()
                        {
                            LineId                   = line.LineNo,
                            Type                     = line.Type,
                            Code                     = line.Code,
                            Description              = line.Description,
                            Description2             = line.Description2,
                            ProjectNo                = line.ProjectNo,
                            QuantityRequired         = line.QuantityRequired,
                            UnitCost                 = line.UnitCost,
                            LocationCode             = line.LocalCode,
                            OpenOrderNo              = line.OpenOrderNo,
                            OpenOrderLineNo          = line.OpenOrderLineNo,
                            CenterResponsibilityCode = line.CenterResponsibilityCode,
                            FunctionalAreaCode       = line.FunctionalAreaCode,
                            RegionCode               = line.RegionCode,
                            UnitMeasureCode          = line.UnitMeasureCode,
                            VATBusinessPostingGroup  = line.VATBusinessPostingGroup,
                            VATProductPostingGroup   = line.VATProductPostingGroup,
                            DiscountPercentage       = line.DiscountPercentage.HasValue ? line.DiscountPercentage.Value : 0,
                        })
                                .ToList()
                    })
                                  .ToList();

                    supplierProductRef = DBNAV2017SupplierProductRef.GetSuplierProductRefsForRequisition(_config.NAVDatabaseName, _config.NAVCompanyName, requisition.RequisitionNo);
                }
                catch
                {
                    throw new Exception("Ocorreu um erro ao agrupar as linhas.");
                }

                if (purchOrders.Count() > 0)
                {
                    purchOrders.ForEach(purchOrder =>
                    {
                        try
                        {
                            purchOrder.Lines.ForEach(line =>
                                                     line.SupplierProductCode = supplierProductRef
                                                                                .Where(x => x.ProductId == line.Code &&
                                                                                       x.SupplierNo == purchOrder.SupplierId &&
                                                                                       x.UnitOfMeasureCode == line.UnitMeasureCode)
                                                                                .FirstOrDefault()
                                                                                ?.SupplierProductId
                                                     );

                            //Novo código que adiciona + linhas mas só para requisições do tipo nutrição
                            if (requisition.RequestNutrition == true)
                            {
                                string codFornecedor = purchOrder.SupplierId;
                                List <ConfigLinhasEncFornecedor> LinhasEncFornecedor = DBConfigLinhasEncFornecedor.GetAll().Where(x => x.VendorNo == codFornecedor).ToList();

                                if (LinhasEncFornecedor != null && LinhasEncFornecedor.Count > 0)
                                {
                                    foreach (ConfigLinhasEncFornecedor linha in LinhasEncFornecedor)
                                    {
                                        string ProjectNo                = string.Empty;
                                        string RegionCode               = string.Empty;
                                        string FunctionalAreaCode       = string.Empty;
                                        string CenterResponsibilityCode = string.Empty;
                                        string ArmazemCompraDireta      = string.Empty;

                                        Configuração Config = DBConfigurations.GetById(1);
                                        if (Config != null)
                                        {
                                            ArmazemCompraDireta = Config.ArmazemCompraDireta;
                                        }

                                        UnidadesProdutivas UnidProd = DBProductivityUnits.GetAll().Where(x => x.NºCliente == codFornecedor).FirstOrDefault();
                                        if (UnidProd != null)
                                        {
                                            ProjectNo = UnidProd.ProjetoMatSubsidiárias;
                                        }

                                        if (!string.IsNullOrEmpty(ProjectNo))
                                        {
                                            NAVProjectsViewModel Project = DBNAV2017Projects.GetAll(_config.NAVDatabaseName, _config.NAVCompanyName, ProjectNo).FirstOrDefault();
                                            if (Project != null)
                                            {
                                                RegionCode               = Project.RegionCode;
                                                FunctionalAreaCode       = Project.AreaCode;
                                                CenterResponsibilityCode = Project.CenterResponsibilityCode;
                                            }
                                        }

                                        PurchOrderLineDTO purchOrderLine = new PurchOrderLineDTO()
                                        {
                                            LineId                   = null,
                                            Type                     = 2, //PRODUTO
                                            Code                     = linha.No,
                                            Description              = linha.Description,
                                            Description2             = linha.Description2,
                                            ProjectNo                = ProjectNo,
                                            QuantityRequired         = linha.Quantity,
                                            UnitCost                 = linha.Valor,
                                            LocationCode             = ArmazemCompraDireta,
                                            OpenOrderNo              = "",   //line.OpenOrderNo,
                                            OpenOrderLineNo          = null, //line.OpenOrderLineNo,
                                            CenterResponsibilityCode = CenterResponsibilityCode,
                                            FunctionalAreaCode       = FunctionalAreaCode,
                                            RegionCode               = RegionCode,
                                            UnitMeasureCode          = linha.UnitOfMeasure,
                                            VATBusinessPostingGroup  = "", //line.VATBusinessPostingGroup,
                                            VATProductPostingGroup   = "", //line.VATProductPostingGroup,
                                            DiscountPercentage       = 0   //line.DiscountPercentage.HasValue ? line.DiscountPercentage.Value : 0,
                                        };
                                        purchOrder.Lines.Add(purchOrderLine);
                                    }
                                }
                            }

                            //var result = CreateNAVPurchaseOrderFor(purchOrder, Convert.ToDateTime(requisition.ReceivedDate), requisition.Comments);
                            var result = CreateNAVPurchaseOrderFor(purchOrder, Convert.ToDateTime(requisition.ReceivedDate));
                            if (result.CompletedSuccessfully)
                            {
                                //Update req
                                requisition.OrderNo = result.ResultValue;

                                //Update Requisition Lines
                                requisition.Lines.ForEach(line =>
                                {
                                    if (line.SupplierNo == purchOrder.SupplierId)
                                    {
                                        line.CreatedOrderNo = result.ResultValue;
                                        line.UpdateUser     = this.changedByUserName;
                                    }
                                });
                                //Commit to DB
                                var updatedReq = DBRequest.Update(requisition.ParseToDB(), true);
                                //bool linesUpdated = DBRequestLine.Update(requisition.Lines.ParseToDB());
                                //if (linesUpdated)
                                if (updatedReq != null)
                                {
                                    requisition.eMessages.Add(new TraceInformation(TraceType.Success, "Criada encomenda para o fornecedor núm. " + purchOrder.SupplierId + "; "));
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            requisition.eMessages.Add(new TraceInformation(TraceType.Error, "Ocorreu um erro ao criar encomenda para o fornecedor núm. " + purchOrder.SupplierId + ": " + ex.Message));
                            //requisition.eMessages.Add(new TraceInformation(TraceType.Exception, purchOrder.SupplierId + " " + ex.Message));
                        }
                    });

                    if (requisition.eMessages.Any(x => x.Type == TraceType.Success))
                    {
                        //Refresh lines - Get from db
                        var updatedLines = DBRequestLine.GetByRequisitionId(requisition.RequisitionNo);
                        if (updatedLines != null)
                        {
                            requisition.Lines = updatedLines.ParseToViewModel();
                        }
                    }

                    if (requisition.eMessages.Any(x => x.Type == TraceType.Error))
                    {
                        requisition.eReasonCode = 2;
                        requisition.eMessage    = "Ocorram erros ao criar encomenda de compra.";
                    }
                    else
                    {
                        requisition.eReasonCode = 1;
                        requisition.eMessage    = "Encomenda de compra criada com sucesso.";
                    }
                }
                else
                {
                    requisition.eReasonCode = 3;
                    requisition.eMessage    = "Não existem linhas que cumpram os requisitos de criação de encomenda.";
                }
            }
            return(requisition);
        }
Exemple #6
0
        public RequisitionViewModel ValidateLocalMarketFor(RequisitionViewModel requisition)
        {
            if (requisition != null && requisition.Lines != null && requisition.Lines.Count > 0 && requisition.State == RequisitionStates.Approved)
            {
                //use for database update later
                var requisitionLines = requisition.Lines
                                       .Where(x =>
                                              x.LocalMarket != null &&
                                              x.PurchaseValidated != null &&
                                              x.QuantityRequired != null &&
                                              x.LocalMarket.Value &&
                                              !x.PurchaseValidated.Value &&
                                              x.QuantityRequired.Value > 0)
                                       .ToList();

                List <PurchOrderDTO> purchOrders = new List <PurchOrderDTO>();

                try
                {
                    purchOrders = requisitionLines.GroupBy(x =>
                                                           x.SupplierNo,
                                                           x => x,
                                                           (key, items) => new PurchOrderDTO
                    {
                        SupplierId               = key,
                        RequisitionId            = requisition.RequisitionNo,
                        CenterResponsibilityCode = requisition.CenterResponsibilityCode,
                        FunctionalAreaCode       = requisition.FunctionalAreaCode,
                        RegionCode               = requisition.RegionCode,
                        LocalMarketRegion        = requisition.LocalMarketRegion,
                        InAdvance          = requisition.InAdvance.HasValue ? requisition.InAdvance.Value : false,
                        PricesIncludingVAT = requisition.PricesIncludingVAT.HasValue ? requisition.PricesIncludingVAT.Value : false,
                        Purchaser_Code     = requisition.NumeroMecanografico,

                        Lines = items.Select(line => new PurchOrderLineDTO()
                        {
                            LineId                   = line.LineNo.Value,
                            Type                     = line.Type,
                            Code                     = line.Code,
                            Description              = line.Description,
                            ProjectNo                = line.ProjectNo,
                            QuantityRequired         = line.QuantityRequired,
                            UnitCost                 = line.UnitCost,
                            LocationCode             = line.LocalCode,
                            OpenOrderNo              = line.OpenOrderNo,
                            OpenOrderLineNo          = line.OpenOrderLineNo,
                            CenterResponsibilityCode = line.CenterResponsibilityCode,
                            FunctionalAreaCode       = line.FunctionalAreaCode,
                            RegionCode               = line.RegionCode,
                            UnitMeasureCode          = line.UnitMeasureCode,
                            VATBusinessPostingGroup  = line.VATBusinessPostingGroup,
                            VATProductPostingGroup   = line.VATProductPostingGroup,
                            DiscountPercentage       = line.DiscountPercentage.HasValue ? line.DiscountPercentage.Value : 0,
                        })
                                .ToList()
                    })
                                  .ToList();
                }
                catch
                {
                    throw new Exception("Ocorreu um erro ao agrupar as linhas.");
                }

                if (purchOrders.Count() > 0)
                {
                    purchOrders.ForEach(purchOrder =>
                    {
                        try
                        {
                            var result = CreateNAVPurchaseOrderFor(purchOrder, Convert.ToDateTime(requisition.ReceivedDate));
                            if (result.CompletedSuccessfully)
                            {
                                //Update Requisition Lines
                                requisitionLines.ForEach(line =>
                                                         line.CreatedOrderNo = result.ResultValue);

                                bool linesUpdated = DBRequestLine.Update(requisitionLines.ParseToDB());
                                if (linesUpdated)
                                {
                                    requisition.eMessages.Add(new TraceInformation(TraceType.Success, "Criada encomenda para o fornecedor núm. " + purchOrder.SupplierId + "; "));
                                }
                            }
                        }
                        catch
                        {
                            requisition.eMessages.Add(new TraceInformation(TraceType.Error, "Ocorreu um erro ao criar encomenda para o fornecedor núm. " + purchOrder.SupplierId + "; "));
                        }
                    });

                    if (requisition.eMessages.Any(x => x.Type == TraceType.Success))
                    {
                        //Refresh lines - Get from db
                        var updatedLines = DBRequestLine.GetByRequisitionId(requisition.RequisitionNo);
                        if (updatedLines != null)
                        {
                            requisition.Lines = updatedLines.ParseToViewModel();
                        }
                    }

                    if (requisition.eMessages.Any(x => x.Type == TraceType.Error))
                    {
                        requisition.eReasonCode = 2;
                        requisition.eMessage    = "Ocorram erros ao validar o mercado local.";
                    }
                    else
                    {
                        requisition.eReasonCode = 1;
                        requisition.eMessage    = "Mercado local validado com sucesso.";
                    }
                }
                else
                {
                    requisition.eReasonCode = 3;
                    requisition.eMessage    = "Não existem linhas que cumpram os requisitos de validação.";
                }
            }
            else
            {
                requisition.eReasonCode = 3;
                requisition.eMessage    = "O estado da requisição e / ou linhas não cumprem os requisitos de validação.";
            }
            return(requisition);
        }
Exemple #7
0
        public JsonResult AprovadoToRecusar([FromBody] JObject requestParams)
        {
            ErrorHandler result = new ErrorHandler
            {
                eReasonCode = 0,
                eMessage    = "Os Registos foram atualizados com sucesso."
            };

            try
            {
                string rejectionComments = requestParams["rejectReason"].ToString();

                List <ComprasViewModel> Mercados = new List <ComprasViewModel>();
                int count = 0;
                if (requestParams["mercados"].Count() > 0)
                {
                    for (count = 0; count < requestParams["mercados"].Count(); count++)
                    {
                        ComprasViewModel Mercado = new ComprasViewModel
                        {
                            ID                  = (int)requestParams["mercados"][count]["id"],
                            CodigoProduto       = (string)requestParams["mercados"][count]["codigoProduto"],
                            Descricao           = (string)requestParams["mercados"][count]["descricao"],
                            Descricao2          = (string)requestParams["mercados"][count]["descricao2"],
                            CodigoUnidadeMedida = (string)requestParams["mercados"][count]["codigoUnidadeMedida"],
                            Quantidade          = (decimal)requestParams["mercados"][count]["quantidade"],
                            NoRequisicao        = (string)requestParams["mercados"][count]["noRequisicao"],
                            NoLinhaRequisicao   = (int)requestParams["mercados"][count]["noLinhaRequisicao"],
                            Urgente             = string.IsNullOrEmpty(Convert.ToString(requestParams["mercados"][count]["urgente"])) ? false : (bool)requestParams["mercados"][count]["urgente"],
                            RegiaoMercadoLocal  = (string)requestParams["mercados"][count]["regiaoMercadoLocal"],
                            Estado              = (int)requestParams["mercados"][count]["estado"],
                            DataCriacao         = string.IsNullOrEmpty(Convert.ToString(requestParams["mercados"][count]["dataCriacao"])) ? Convert.ToDateTime("1753/01/01") : (DateTime)requestParams["mercados"][count]["dataCriacao"],
                            UtilizadorCriacao   = (string)requestParams["mercados"][count]["utilizadorCriacao"],
                            Responsaveis        = (string)requestParams["mercados"][count]["responsaveis"],
                            NoProjeto           = (string)requestParams["mercados"][count]["noProjeto"],
                            NoFornecedor        = (string)requestParams["mercados"][count]["noFornecedor"],
                            NoEncomenda         = (string)requestParams["mercados"][count]["noEncomenda"],
                            DataEncomenda       = string.IsNullOrEmpty(Convert.ToString(requestParams["mercados"][count]["dataEncomenda"])) ? Convert.ToDateTime("1753/01/01") : (DateTime)requestParams["mercados"][count]["dataEncomenda"],
                            NoConsultaMercado   = (string)requestParams["mercados"][count]["noConsultaMercado"],
                            DataConsultaMercado = string.IsNullOrEmpty(Convert.ToString(requestParams["mercados"][count]["dataConsultaMercado"])) ? Convert.ToDateTime("1753/01/01") : (DateTime)requestParams["mercados"][count]["dataConsultaMercado"],
                            DataValidacao       = string.IsNullOrEmpty(Convert.ToString(requestParams["mercados"][count]["dataValidacao"])) ? Convert.ToDateTime("1753/01/01") : (DateTime)requestParams["mercados"][count]["dataValidacao"],
                            UtilizadorValidacao = (string)requestParams["mercados"][count]["utilizadorValidacao"],
                            DataRecusa          = string.IsNullOrEmpty(Convert.ToString(requestParams["mercados"][count]["dataRecusa"])) ? Convert.ToDateTime("1753/01/01") : (DateTime)requestParams["mercados"][count]["dataRecusa"],
                            UtilizadorRecusa    = (string)requestParams["mercados"][count]["utilizadorRecusa"],
                            DataTratado         = string.IsNullOrEmpty(Convert.ToString(requestParams["mercados"][count]["dataTratado"])) ? Convert.ToDateTime("1753/01/01") : (DateTime)requestParams["mercados"][count]["dataTratado"],
                            UtilizadorTratado   = (string)requestParams["mercados"][count]["utilizadorTratado"],
                            Recusada            = string.IsNullOrEmpty(Convert.ToString(requestParams["mercados"][count]["recusada"])) ? false : (bool)requestParams["mercados"][count]["recusada"]
                        };
                        Mercados.Add(Mercado);
                    }
                }

                if (Mercados != null && Mercados.Count() > 0)
                {
                    UserAccessesViewModel UPerm = DBUserAccesses.GetByUserAreaFunctionality(User.Identity.Name, Enumerations.Features.MercadoLocal);
                    if (UPerm.Update == true)
                    {
                        Mercados.ForEach(MercadoVM =>
                        {
                            if (MercadoVM.Responsaveis.ToLower().Contains(User.Identity.Name.ToLower()))
                            {
                                Compras Mercado = DBCompras.ParseToCompras(MercadoVM);

                                Mercado.Estado           = 3; //RECUSADO
                                Mercado.DataRecusa       = DateTime.Now;
                                Mercado.UtilizadorRecusa = User.Identity.Name;

                                if (DBCompras.Update(Mercado) == null)
                                {
                                    result.eReasonCode = 6;
                                    result.eMessage    = "Ocorreu um erro ao atualizar o registo.";
                                }

                                string NoRequisicao   = Mercado.NoRequisicao;
                                int NoLinhaRequisicao = (int)Mercado.NoLinhaRequisicao;

                                LinhasRequisição LinhaRequisicao = DBRequestLine.GetByRequisicaoNoAndLineNo(NoRequisicao, NoLinhaRequisicao);
                                if (LinhaRequisicao != null)
                                {
                                    LinhaRequisicao.RecusadoCompras       = true;
                                    LinhaRequisicao.MotivoRecusaMercLocal = MercadoVM.RecusadaTexto;
                                    LinhaRequisicao.DataRecusaMercLocal   = DateTime.Now;
                                    LinhaRequisicao.MercadoLocal          = false;
                                    LinhaRequisicao.DataMercadoLocal      = null;

                                    if (DBRequestLine.Update(LinhaRequisicao) == null)
                                    {
                                        result.eReasonCode = 5;
                                        result.eMessage    = "Ocorreu um erro ao atualizar a Linha de Requisição.";
                                    }
                                }
                                else
                                {
                                    result.eReasonCode = 4;
                                    result.eMessage    = "Não foi possivel ler a Linha de Requisição.";
                                }
                            }
                            else
                            {
                                result.eReasonCode = 3;
                                result.eMessage    = "O seu id não está no campo Responsáveis, logo não pode alterar o registo.";
                            }
                        });
                    }
                    else
                    {
                        result.eReasonCode = 2;
                        result.eMessage    = "Não tem permissões para alterar o registo do mercado Local.";
                    }
                }
                else
                {
                    result.eReasonCode = 1;
                    result.eMessage    = "Não foi possivel ler o registo do Mercado Local.";
                }

                return(Json(result));
            }
            catch (Exception ex)
            {
                result.eReasonCode = 99;
                result.eMessage    = "Ocorreu um erro.";
            }
            return(Json(null));
        }
Exemple #8
0
        public JsonResult AprovadoToValidar([FromBody] List <Compras> Mercados)
        {
            ErrorHandler result = new ErrorHandler
            {
                eReasonCode = 0,
                eMessage    = "Os Registos foram atualizados com sucesso."
            };

            try
            {
                if (Mercados != null && Mercados.Count() > 0)
                {
                    UserAccessesViewModel UPerm = DBUserAccesses.GetByUserAreaFunctionality(User.Identity.Name, Enumerations.Features.MercadoLocal);
                    if (UPerm.Update == true)
                    {
                        Mercados.ForEach(Mercado =>
                        {
                            if (Mercado.Responsaveis.ToLower().Contains(User.Identity.Name.ToLower()))
                            {
                                Mercado.Estado              = 2; //VALIDADO
                                Mercado.DataValidacao       = DateTime.Now;
                                Mercado.UtilizadorValidacao = User.Identity.Name;

                                if (DBCompras.Update(Mercado) == null)
                                {
                                    result.eReasonCode = 6;
                                    result.eMessage    = "Ocorreu um erro ao atualizar o registo.";
                                }

                                string NoRequisicao   = Mercado.NoRequisicao;
                                int NoLinhaRequisicao = (int)Mercado.NoLinhaRequisicao;

                                LinhasRequisição LinhaRequisicao = DBRequestLine.GetByRequisicaoNoAndLineNo(NoRequisicao, NoLinhaRequisicao);
                                if (LinhaRequisicao != null)
                                {
                                    LinhaRequisicao.ValidadoCompras = true;

                                    if (DBRequestLine.Update(LinhaRequisicao) == null)
                                    {
                                        result.eReasonCode = 5;
                                        result.eMessage    = "Ocorreu um erro ao atualizar a Linha de Requisição.";
                                    }
                                }
                                else
                                {
                                    result.eReasonCode = 4;
                                    result.eMessage    = "Não foi possivel ler a Linha de Requisição.";
                                }
                            }
                            else
                            {
                                result.eReasonCode = 3;
                                result.eMessage    = "O seu id não está no campo Responsáveis, logo não pode alterar o registo.";
                            }
                        });
                    }
                    else
                    {
                        result.eReasonCode = 2;
                        result.eMessage    = "Não tem permissões para alterar o registo do mercado Local.";
                    }
                }
                else
                {
                    result.eReasonCode = 1;
                    result.eMessage    = "Não foi possivel ler o registo do Mercado Local.";
                }

                return(Json(result));
            }
            catch (Exception ex)
            {
                result.eReasonCode = 99;
                result.eMessage    = "Ocorreu um erro.";
            }
            return(Json(null));
        }
Exemple #9
0
        public JsonResult CriarEncomendaCabimento([FromBody] List <LinhasPreEncomendaView> item)
        {
            //if (item != null)
            //{
            //    try
            //    {
            //        RequisitionService serv = new RequisitionService(configws, HttpContext.User.Identity.Name);
            //        item = serv.CreatePurchaseOrderFor(item);


            //    }
            //    catch (Exception ex)
            //    {
            //        item.eReasonCode = 2;
            //        item.eMessage = "Ocorreu um erro ao criar encomenda de compra (" + ex.Message + ")";
            //    }
            //}
            //else
            //{
            //    item = new LinhasPreEncomendaView()
            //    {
            //        eReasonCode = 3,
            //        eMessage = "Não é possivel criar encomenda de compra. A requisição não pode ser nula."
            //    };
            //}
            //return Json(item);



            /*
             * 1º - filtrar os itens que chegam aqui, ficando apenas com os que são:
             *  --> Documento a Criar = Encomenda (1)
             *  --> Criar Documento = true
             *  --> Nº Encomenda Aberto = ''
             *  --> Nº Linha Encomenda Aberto = ''
             * 2º - Criar Encomenda
             * 3º - As linhas da Requisição devem ficar marcadas  com o Nº da Encomenda criada (cada item tem um Nº Linha Requisição)
             * 4º - Colocar as linhas com Tratadas = 1
             */

            ErrorHandler resultado = new ErrorHandler
            {
                eReasonCode = 1,
                eMessage    = "Criada Encomenda com sucesso."
            };

            if (item != null)
            {
                try
                {
                    List <LinhasPreEncomendaView> list = item.Where(it => it.DocumentoACriar == 1).Where(it => it.CriarDocumento == true).Where(it => it.NumEncomendaAberto == string.Empty).Where(it => !it.NumLinhaEncomendaAberto.HasValue).ToList();

                    List <PurchOrderDTO> purchOrders = new List <PurchOrderDTO>();

                    try
                    {
                        if (list != null && list.Count() > 0)
                        {
                            purchOrders = list.GroupBy(x =>
                                                       x.NumFornecedor,
                                                       x => x,
                                                       (key, items) => new PurchOrderDTO
                            {
                                SupplierId               = key,
                                RequisitionId            = list.Where(f => f.NumFornecedor == key).FirstOrDefault().NumRequisicao,
                                CenterResponsibilityCode = list.Where(f => f.NumFornecedor == key).FirstOrDefault().CodigoCentroResponsabilidade,
                                FunctionalAreaCode       = list.Where(f => f.NumFornecedor == key).FirstOrDefault().CodigoAreaFuncional,
                                RegionCode               = list.Where(f => f.NumFornecedor == key).FirstOrDefault().CodigoRegiao,
                                LocalMarketRegion        = list.Where(f => f.NumFornecedor == key).FirstOrDefault().CodigoLocalizacao,
                                Lines = items.Select(line => new PurchOrderLineDTO()
                                {
                                    LineId                   = line.NumLinhaPreEncomenda,
                                    Type                     = null,
                                    Code                     = line.CodigoProduto,
                                    Description              = line.DescricaoProduto,
                                    ProjectNo                = line.NumProjeto,
                                    QuantityRequired         = line.QuantidadeDisponibilizada,
                                    UnitCost                 = line.CustoUnitario,
                                    LocationCode             = line.CodigoLocalizacao,
                                    OpenOrderNo              = line.NumEncomendaAberto,
                                    OpenOrderLineNo          = line.NumLinhaEncomendaAberto,
                                    CenterResponsibilityCode = line.CodigoCentroResponsabilidade,
                                    FunctionalAreaCode       = line.CodigoAreaFuncional,
                                    RegionCode               = line.CodigoRegiao,
                                    UnitMeasureCode          = line.CodigoUnidadeMedida,
                                    VATBusinessPostingGroup  = string.Empty,
                                    VATProductPostingGroup   = string.Empty,
                                }).ToList()
                            }).ToList();
                        }
                    }
                    catch
                    {
                        throw new Exception("Ocorreu um erro ao agrupar as linhas.");
                    }

                    if (purchOrders != null && purchOrders.Count() > 0)
                    {
                        purchOrders.ForEach(purchOrder =>
                        {
                            RequisitionViewModel requisition = DBRequest.GetById(purchOrder.RequisitionId).ParseToViewModel();

                            try
                            {
                                //purchOrder.Purchaser_Code = User.Identity.Name;
                                purchOrder.Purchaser_Code = string.IsNullOrEmpty(DBUserConfigurations.GetById(User.Identity.Name).EmployeeNo) ? "" : DBUserConfigurations.GetById(User.Identity.Name).EmployeeNo;

                                var result = CreateNAVPurchaseOrderFor(purchOrder, Convert.ToDateTime(requisition.ReceivedDate));
                                if (result.CompletedSuccessfully)
                                {
                                    foreach (PurchOrderLineDTO Linha in purchOrder.Lines)
                                    {
                                        LinhasPreEncomenda LinhaPre = DBEncomendas.GetLinhasPreEncomenda((int)Linha.LineId);

                                        if (LinhaPre != null)
                                        {
                                            string ReqNo   = LinhaPre.NºRequisição;
                                            int ReqNoLinha = (int)LinhaPre.NºLinhaRequisição;

                                            Requisição Req = DBRequest.GetById(ReqNo);
                                            if (Req != null)
                                            {
                                                Req.NºEncomenda           = result.ResultValue;
                                                Req.UtilizadorModificação = User.Identity.Name;
                                                Req.DataHoraModificação   = DateTime.Now;
                                                if (DBRequest.Update(Req) != null)
                                                {
                                                    LinhasRequisição ReqLinha = DBRequestLine.GetByRequisicaoNoAndLineNo(ReqNo, ReqNoLinha);
                                                    if (ReqLinha != null)
                                                    {
                                                        ReqLinha.NºEncomendaCriada     = result.ResultValue;
                                                        ReqLinha.UtilizadorModificação = User.Identity.Name;
                                                        ReqLinha.DataHoraModificação   = DateTime.Now;
                                                        DBRequestLine.Update(ReqLinha);
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    foreach (LinhasPreEncomendaView Linha in list)
                                    {
                                        if (Linha.NumFornecedor == purchOrder.SupplierId)
                                        {
                                            Linha.NumPreEncomenda       = result.ResultValue;
                                            Linha.DocumentoACriar       = null;
                                            Linha.CriarDocumento        = false;
                                            Linha.Tratada               = true;
                                            Linha.UtilizadorModificacao = User.Identity.Name;
                                            Linha.DataHoraModificacao   = DateTime.Now;
                                            DBEncomendas.Update(DBEncomendas.CastLinhasPreEncomendaToDB(Linha));
                                        }
                                    }

                                    resultado.eMessages.Add(new TraceInformation(TraceType.Success, "Criada encomenda para o fornecedor núm. " + purchOrder.SupplierId + "; "));

                                    //Update req
                                    //requisition.OrderNo = result.ResultValue;

                                    //Update Requisition Lines
                                    //requisition.Lines.Where(x => x.LineNo == purchOrder.OpenOrderLineNo).ToList().ForEach(line =>
                                    //{
                                    //    line.CreatedOrderNo = result.ResultValue;
                                    //    line.UpdateUser = User.Identity.Name;
                                    //    line.UpdateDateTime = DateTime.Now;
                                    //});
                                    //Commit to DB
                                    //var updatedReq = DBRequest.Update(requisition.ParseToDB(), true);



                                    //bool linesUpdated = DBRequestLine.Update(requisition.Lines.ParseToDB());
                                    //if (linesUpdated)
                                    //if (updatedReq != null)
                                    //{
                                    //    resultado.eMessages.Add(new TraceInformation(TraceType.Success, "Criada encomenda para o fornecedor núm. " + purchOrder.SupplierId + "; "));
                                    //}
                                }
                            }
                            catch (Exception ex)
                            {
                                resultado.eMessages.Add(new TraceInformation(TraceType.Error, "Ocorreu um erro ao criar encomenda para o fornecedor núm. " + purchOrder.SupplierId + "; "));
                                resultado.eMessages.Add(new TraceInformation(TraceType.Exception, purchOrder.SupplierId + " " + ex.Message));
                            }

                            if (resultado.eMessages.Any(x => x.Type == TraceType.Error))
                            {
                                resultado.eReasonCode = 2;
                                //resultado.eMessage = "Ocorreram erros ao criar encomenda de compra.";

                                resultado.eMessage = "Ocorreram erros ao criar encomenda de compra." + Environment.NewLine + resultado.eMessages[resultado.eMessages.Count() - 1].Message;
                            }
                            else
                            {
                                resultado.eReasonCode = 1;
                                resultado.eMessage    = "Encomenda de compra criada com sucesso.";
                            }
                        });
                    }
                    else
                    {
                        resultado.eReasonCode = 3;
                        resultado.eMessage    = "Não existem linhas que cumpram os requisitos de validação do mercado local.";
                    }
                }
                catch (Exception ex)
                {
                    resultado.eReasonCode = -1;
                    resultado.eMessage    = "Erro desconhecido.";
                }
            }

            return(Json(resultado));
        }