Ejemplo n.º 1
0
        public IHttpActionResult GetByEmpresaID(int empresaID)
        {
            try
            {
                var propriedades = _repository.GetByEmpresaID(empresaID).ToList();

                return(Ok(propriedades));
            }
            catch (System.Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Ejemplo n.º 2
0
        public IHttpActionResult Post([FromBody] Empresa empresa)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(BadRequest(ModelState));
                }

                _repository.Insert(empresa);

                if (empresa.CopiarDe != 0)
                {
                    var deParaPropriedade   = new Dictionary <int, int>();
                    var deParaGrupo         = new Dictionary <int, int>();
                    var deParaContaContabil = new Dictionary <int, int>();
                    var deParaCentroCusto   = new Dictionary <int, int>();
                    var deParaEspecie       = new Dictionary <int, int>();

                    if (empresa.CopiarEntidades.Contains("propriedade"))
                    {
                        var propriedadeBase = _propriedadeRepository.GetByEmpresaID(empresa.CopiarDe);

                        foreach (var pb in propriedadeBase)
                        {
                            var propriedadeNova = new Propriedade()
                            {
                                EmpresaID = empresa.ID,
                                Nome      = pb.Nome,
                                Fixa      = pb.Fixa
                            };

                            _propriedadeRepository.Insert(propriedadeNova);

                            deParaPropriedade.Add(pb.ID, propriedadeNova.ID);

                            if (pb.Fixa)
                            {
                                foreach (var pbValor in pb.Valores)
                                {
                                    _propriedadeValorRepository.Insert(new PropriedadeValor()
                                    {
                                        PropriedadeID = propriedadeNova.ID,
                                        Valor         = pbValor.Valor
                                    });
                                }
                            }
                        }
                    }

                    if (empresa.CopiarEntidades.Contains("contaContabil"))
                    {
                        var contaContabilBase = _contaContabilRepository.GetByEmpresaID(empresa.CopiarDe).OrderBy(x => x.CodigoInterno);

                        foreach (var ccb in contaContabilBase)
                        {
                            var contaContabilNova = new ContaContabil()
                            {
                                Codigo        = ccb.Codigo,
                                CodigoInterno = ccb.CodigoInterno,
                                EmpresaID     = empresa.ID,
                                Nome          = ccb.Nome,
                                NomeAbreviado = ccb.NomeAbreviado,
                                PaiID         = ccb.PaiID == null ? null : (int?)deParaContaContabil.Where(x => x.Key == ccb.PaiID).Single().Value
                            };

                            _contaContabilRepository.Insert(contaContabilNova);

                            deParaContaContabil.Add(ccb.ID, contaContabilNova.ID);
                        }
                    }

                    if (empresa.CopiarEntidades.Contains("grupo"))
                    {
                        var grupoBase = _grupoRepository.GetByEmpresaID(empresa.CopiarDe);

                        foreach (var gb in grupoBase)
                        {
                            var grupoNovo = new Grupo()
                            {
                                Codigo          = gb.Codigo,
                                ContaContabilID = gb.ContaContabilID == null ? null : deParaContaContabil.Count == 0 ? null : (int?)deParaContaContabil.Where(x => x.Key == gb.ContaContabilID).Single().Value,
                                EmpresaID       = empresa.ID,
                                Nome            = gb.Nome
                            };

                            _grupoRepository.Insert(grupoNovo);

                            deParaGrupo.Add(gb.ID, grupoNovo.ID);
                        }

                        if (empresa.CopiarEntidades.Contains("especie"))
                        {
                            var especieBase = _especieRepository.GetByEmpresaID(empresa.CopiarDe);

                            foreach (var eb in especieBase)
                            {
                                var especieNova = new Especie()
                                {
                                    Codigo  = eb.Codigo,
                                    GrupoID = deParaGrupo.Where(x => x.Key == eb.GrupoID).Single().Value,
                                    Nome    = eb.Nome
                                };

                                _especieRepository.Insert(especieNova);

                                deParaEspecie.Add(eb.ID, especieNova.ID);
                            }

                            if (deParaPropriedade.Count > 0)
                            {
                                var especiePropriedadeBase = _especiePropriedadeRepository.GetByEmpresaID(empresa.CopiarDe);

                                foreach (var epb in especiePropriedadeBase)
                                {
                                    var especiePropriedadeNova = new EspeciePropriedade()
                                    {
                                        EspecieID     = deParaEspecie.Where(x => x.Key == epb.EspecieID).Single().Value,
                                        PropriedadeID = deParaPropriedade.Where(x => x.Key == epb.PropriedadeID).Single().Value
                                    };

                                    _especiePropriedadeRepository.Insert(especiePropriedadeNova);
                                }
                            }
                        }
                    }

                    if (empresa.CopiarEntidades.Contains("centroCusto"))
                    {
                        var centroCustoBase = _centroCustoRepository.GetByEmpresaID(empresa.CopiarDe).OrderBy(x => x.CodigoInterno);

                        foreach (var ccb in centroCustoBase)
                        {
                            var centroCustoNovo = new CentroCusto()
                            {
                                Codigo        = ccb.Codigo,
                                CodigoInterno = ccb.CodigoInterno,
                                EmpresaID     = empresa.ID,
                                Nome          = ccb.Nome,
                                PaiID         = ccb.PaiID == null ? null : (int?)deParaCentroCusto.Where(x => x.Key == ccb.PaiID).Single().Value
                            };

                            _centroCustoRepository.Insert(centroCustoNovo);

                            deParaCentroCusto.Add(ccb.ID, centroCustoNovo.ID);
                        }
                    }
                }

                return(Ok(empresa));
            }
            catch (System.Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Ejemplo n.º 3
0
        public IHttpActionResult CargaInicial(int inventarioID)
        {
            try
            {
                var inventario = _repository.GetByID(inventarioID);

                var empresa = _empresaRepository.GetByID(inventario.EmpresaID);

                var grupos = _grupoRepository.GetByEmpresaID(inventario.EmpresaID);

                var especies = _especieRepository.GetByEmpresaID(inventario.EmpresaID);

                var propriedades = _propriedadeRepository.GetByEmpresaID(inventario.EmpresaID);

                var especiePropriedades = _especiePropriedadeRepository.GetByEmpresaID(inventario.EmpresaID);

                var responsaveis = _responsavelRepository.GetByEmpresaID(inventario.EmpresaID);

                var centrosCusto = _centroCustoRepository.GetByEmpresaID(inventario.EmpresaID);

                var contasContabeis = _contaContabilRepository.GetByEmpresaID(inventario.EmpresaID);

                var filiais = _filialDbRepository.GetByEmpresaID(inventario.EmpresaID);

                var locais = _localDbRepository.GetByEmpresaID(inventario.EmpresaID);

                var configs = _configRepository.GetByInventarioID(inventario.ID);

                var itens = _itemRepository.GetByEmpresaID(inventario.EmpresaID);

                var itemEstados = _itemEstadoRepository.GetAll();

                object carga = new
                {
                    itemEstado = itemEstados.Count == 0 ? null : itemEstados.Select(ie => new
                    {
                        ie.ID,
                        ie.Nome
                    }),

                    empresa = new
                    {
                        empresa.CNPJ,
                        empresa.DataCadastroFormatada,
                        empresa.ID,
                        empresa.NomeFantasia,
                        empresa.RazaoSocial,

                        grupos = grupos.Count == 0 ? null : grupos.Select(g => new
                        {
                            g.Codigo,
                            g.ContaContabilID,
                            g.DataCadastroFormatada,
                            g.ID,
                            g.Nome
                        }),

                        especies = especies.Count == 0 ? null : especies.Select(e => new
                        {
                            e.Codigo,
                            e.DataCadastroFormatada,
                            e.GrupoID,
                            e.ID,
                            e.Nome,
                            propriedades = especiePropriedades.Where(ep => ep.EspecieID == e.ID).Select(ep => new
                            {
                                ep.DataCadastroFormatada,
                                ep.EspecieID,
                                ep.PropriedadeID
                            })
                        }),

                        propriedades = propriedades.Count == 0 ? null : propriedades.Select(p => new
                        {
                            p.Codigo,
                            p.DataCadastroFormatada,
                            p.Fixa,
                            p.ID,
                            p.Nome
                        }),

                        responsaveis = responsaveis.Count == 0 ? null : responsaveis.Select(r => new
                        {
                            r.Cargo,
                            r.DataCadastroFormatada,
                            r.ID,
                            r.Matricula,
                            r.Nome,
                            r.UsuarioID
                        }),

                        centrosCusto = centrosCusto.Count == 0 ? null : centrosCusto.Select(cc => new
                        {
                            cc.Codigo,
                            cc.CodigoInterno,
                            cc.DataCadastroFormatada,
                            cc.ID,
                            cc.Nome,
                            cc.Nivel,
                            cc.PaiID,
                            cc.ResponsavelID
                        }),

                        contasContabeis = contasContabeis.Count == 0 ? null : contasContabeis.Select(cco => new
                        {
                            cco.Codigo,
                            cco.CodigoInterno,
                            cco.DataCadastroFormatada,
                            cco.ID,
                            cco.Nivel,
                            cco.Nome,
                            cco.NomeAbreviado,
                            cco.PaiID
                        })
                    },

                    inventario = new
                    {
                        inventario.ID,
                        inventario.Codigo,
                        inventario.Nome,
                        inventario.StatusID,

                        filiais = filiais.Count == 0 ? null : filiais.Select(f => new
                        {
                            f.ID,
                            f.Codigo,
                            f.CNPJ,
                            f.Nome
                        }),

                        locais = locais.Count == 0 ? null : locais.Select(l => new
                        {
                            l.CentroCustoID,
                            l.Codigo,
                            l.CodigoInterno,
                            l.DataCadastroFormatada,
                            l.FilialID,
                            l.ID,
                            l.Nivel,
                            l.Nome,
                            l.PaiID,
                            l.ResponsavelID
                        }),

                        itens = itens.Count == 0 ? null : itens.Select(i => new
                        {
                            i.Codigo,
                            i.CodigoAnterior,
                            i.CodigoPM,
                            i.DadosPM,
                            i.DataCadastroFormatada,
                            i.EspecieID,
                            i.Local.FilialID,
                            i.ID,
                            i.ImagemUrl,
                            i.Imagens,
                            i.Incorporacao,
                            i.IncorporacaoAnterior,
                            i.ItemEstadoID,
                            i.Latitude,
                            i.LocalID,
                            i.LocalPM,
                            i.Longitude,
                            i.Marca,
                            i.Modelo,
                            i.Nome,
                            i.NumeroSerie,
                            i.Observacao,
                            i.ResponsavelID,
                            i.StatusID,
                            i.StatusNome,
                            i.Tag
                        }),

                        configs = configs.Select(c => new
                        {
                            c.EntidadeCampo.NomeCampo,
                            c.Visivel,
                            c.Obrigatorio
                        })
                    }
                };

                return(Ok(carga));
            }
            catch (System.Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }