public IHttpActionResult PostReajConvenioMed(ReajConvenioMed reajConvenioMed)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.ReajConvenioMed.Add(reajConvenioMed);

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateException)
            {
                if (ReajConvenioMedExists(reajConvenioMed.Ano, reajConvenioMed.ConvenioMedCod, reajConvenioMed.MesReajuste))
                {
                    return(Conflict());
                }
                else
                {
                    throw;
                }
            }

            return(CreatedAtRoute("DefaultApi", new { id = reajConvenioMed.Ano }, new ReajConvenioMedDTO(reajConvenioMed)));
        }
        public IHttpActionResult PutReajConvenioMed(int ano, int plano, int mes, ReajConvenioMed reajConvenioMed)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (ano != reajConvenioMed.Ano || plano != reajConvenioMed.ConvenioMedCod || mes != reajConvenioMed.MesReajuste)
            {
                return(BadRequest());
            }

            db.Entry(reajConvenioMed).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ReajConvenioMedExists(ano, plano, mes))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
        public IHttpActionResult GetReajConvenioMed(int ano, int plano, int mes)
        {
            ReajConvenioMed reajConvenioMed = db.ReajConvenioMed.Find(ano, plano, mes);

            if (reajConvenioMed == null)
            {
                return(NotFound());
            }

            return(Ok(new ReajConvenioMedDTO(reajConvenioMed)));
        }
 public ReajConvenioMedDTO(ReajConvenioMed r)
 {
     if (r == null)
     {
         return;
     }
     Ano                = r.Ano;
     ConvenioMedCod     = r.ConvenioMedCod;
     PercentualReajuste = r.PercentualReajuste;
     MesReajuste        = r.MesReajuste;
 }
        public IHttpActionResult DeleteReajConvenioMed(int ano, int plano, int mes)
        {
            ReajConvenioMed reajConvenioMed = db.ReajConvenioMed.Find(ano, plano, mes);

            if (reajConvenioMed == null)
            {
                return(NotFound());
            }

            ReajConvenioMedDTO r = new ReajConvenioMedDTO(reajConvenioMed);

            db.ReajConvenioMed.Remove(reajConvenioMed);
            db.SaveChanges();

            return(Ok(r));
        }
示例#6
0
        //O valor do Convênio Médico e do Convênio Odontológico será um valor aberto, na base.
        //As premissas serão somente para novas contratações
        public static IEnumerable <CalculoEventoBase> CalculaFuncionarioCiclo(Funcionario func, Ciclo ciclo)
        {
            Contexto db = new Contexto();

            List <CalculoEventoBase> lista = new List <CalculoEventoBase>();

            PAT pat = db.PAT.Find(func.CargaHoraria, func.SindicatoCod);

            if (pat == null)
            {
                throw new PATNaoCadastradaException();
            }
            Encargos encargos = db.Encargos.Find(func.EmpresaCod);

            if (encargos == null)
            {
                throw new EncargosNaoEncontradosException();
            }

            //db.Database.ExecuteSqlCommand("insert into CalculoEventoBase (CodEvento, MatriculaFuncionario, CodMesOrcamento, Valor) select CodEvento, MatriculaFuncionario, CodMesOrcamento, Valor from ValoresAbertosBase a inner join MesOrcamento b on a.CodMesOrcamento = b.Codigo where MatriculaFuncionario = {0} and b.CicloCod = {1}", func.Matricula, ciclo.Codigo);

            float baseEncargos = 0;
            float somaHEs, somaHNs;
            float salario = func.Salario, salarioBase = func.Salario;
            float valorConvMed = func.ValorConvMedico;
            float valorConvOdo = func.ValorConvOdontologico;
            float passe        = func.Filial.Cidade.VTPasse;
            float frete        = func.Filial.Cidade.VTFretadoValor;
            int   qtdaPasses   = db.CargaHoraria.Find(func.CargaHoraria).QtdaPassesDiario;

            foreach (MesOrcamento m in ciclo.MesesOrcamento)
            {
                int ano = m.Mes.Year, mes = m.Mes.Month;
                int qtdaDias = db.QtdaDias.Find(mes, func.CodEscalaTrabalho).Qtda;

                //Reajustes
                Reajuste        reajSal       = db.Reajuste.Find(ano, mes, func.SindicatoCod);
                ReajConvenioMed reajMed       = db.ReajConvenioMed.Find(ano, mes, func.ConvenioMedCod);
                ReajConvenioOdo reajOdo       = db.ReajConvenioOdo.Find(ano, func.CodConvenioOdo, mes);
                ReajVTFretado   reajVTFretado = db.ReajVTFretado.Find(ano, func.CidadeNome, mes);
                ReajVTPasse     reajVTPasse   = db.ReajVTPasse.Find(ano, func.CidadeNome, mes);

                if (reajSal != null)
                {
                    salarioBase *= (float)(reajSal.PercentualReajuste + 1);
                    if (salarioBase < reajSal.PisoSalarial)
                    {
                        salarioBase = reajSal.PisoSalarial;
                    }
                }

                if (reajMed != null)
                {
                    valorConvMed *= (float)(reajMed.PercentualReajuste + 1);
                }

                if (reajOdo != null)
                {
                    valorConvOdo *= (reajOdo.PercentualReajuste + 1);
                }

                if (reajVTFretado != null)
                {
                    frete *= (float)(reajVTFretado.PercentualReajuste + 1);
                }

                if (reajVTPasse != null)
                {
                    passe *= (float)(reajVTPasse.PercentualReajuste + 1);
                }

                //Horas Extras
                List <HEBase> hes = db.HEBase
                                    .Where(x => x.FuncionarioMatricula == func.Matricula && x.CodMesOrcamento == m.Codigo)
                                    .ToList();

                //Horas Noturnas
                List <AdNoturnoBase> hns = db.AdNoturnoBase
                                           .Where(x => x.FuncionarioMatricula == func.Matricula && x.CodMesOrcamento == m.Codigo)
                                           .ToList();

                FuncionarioFerias ferias = func.FuncionarioFerias.Where(x => x.CodMesOrcamento == m.Codigo).FirstOrDefault();

                if (ferias == null)
                {
                    salario = salarioBase;
                }
                else
                {
                    salario = salarioBase * (30 - ferias.QtdaDias) / 30;   //Encontra salário proporcional aos dias trabalhados
                }
                // ********************** SALÁRIOS E ADICIONAIS **********************
                CalculoEventoBase calculoSalario = new CalculoEventoBase
                {
                    CodEvento            = "SALARIO",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = salario
                };
                lista.Add(calculoSalario);

                CalculoEventoBase calculoPeric = new CalculoEventoBase {
                    Valor = 0
                };
                if (func.Periculosidade)
                {
                    calculoPeric.CodEvento            = "PERICUL";
                    calculoPeric.MatriculaFuncionario = func.Matricula;
                    calculoPeric.CodMesOrcamento      = m.Codigo;
                    calculoPeric.Valor = (float)(salario * 0.3);
                    lista.Add(calculoPeric);
                }

                CalculoEventoBase calculoAdCondutor = new CalculoEventoBase {
                    Valor = 0
                };
                if (func.AdCondutor)
                {
                    calculoAdCondutor.CodEvento            = "ADI-COND";
                    calculoAdCondutor.MatriculaFuncionario = func.Matricula;
                    calculoAdCondutor.CodMesOrcamento      = m.Codigo;
                    calculoAdCondutor.Valor = (float)(salario * 0.1);
                    lista.Add(calculoAdCondutor);
                }

                somaHEs = 0;
                hes.ForEach(x => {
                    somaHEs += salario / func.CargaHoraria * x.QtdaHoras * x.PercentualHoras / 100;

                    lista.Add(new CalculoEventoBase
                    {
                        CodEvento            = "HE-" + x.PercentualHoras.ToString(),
                        MatriculaFuncionario = func.Matricula,
                        CodMesOrcamento      = m.Codigo,
                        Valor = somaHEs
                    });
                });

                somaHNs = 0;
                hns.ForEach(x => {
                    somaHNs = salario / x.PercentualHoras / 100 / func.CargaHoraria * x.QtdaHoras;
                    lista.Add(new CalculoEventoBase
                    {
                        CodEvento            = "AD-N-" + x.PercentualHoras.ToString(),
                        MatriculaFuncionario = func.Matricula,
                        CodMesOrcamento      = m.Codigo,
                        Valor = somaHNs
                    });
                });


                //BASE DE ENCARGOS
                baseEncargos = calculoSalario.Valor + calculoPeric.Valor + calculoAdCondutor.Valor + somaHEs + somaHNs;


                // ********************** BENEFÍCIOS **********************
                float vtDescontado = 0;
                if (func.VTFretadoFlag)
                {
                    vtDescontado = frete - (float)(salarioBase * 0.6);
                    if (vtDescontado > 0)
                    {
                        lista.Add(new CalculoEventoBase
                        {
                            CodEvento            = "VT-FRETE",
                            MatriculaFuncionario = func.Matricula,
                            CodMesOrcamento      = m.Codigo,
                            Valor = vtDescontado
                        });
                    }
                }
                else
                {
                    vtDescontado = (passe * qtdaDias) - (float)(salarioBase * 0.6);
                    if (vtDescontado > 0)
                    {
                        lista.Add(new CalculoEventoBase
                        {
                            CodEvento            = "VT-PASSE",
                            MatriculaFuncionario = func.Matricula,
                            CodMesOrcamento      = m.Codigo,
                            Valor = vtDescontado
                        });
                    }
                }

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "PAT",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = pat.Valor * pat.Percentual
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "AUX-CRE",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = func.AuxCreche
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "PREV-PRI",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = func.PrevidenciaPrivada
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "CONV-MED",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = func.ValorConvMedico
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "CONV-ODO",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = func.ValorConvOdontologico
                });



                // ********************** ENCARGOS **********************
                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "INSS",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = baseEncargos * encargos.INSS
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "INCRA",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = baseEncargos * encargos.INCRA
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "SAL-EDU",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = baseEncargos * encargos.SalEducacao
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "SENAI",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = baseEncargos * encargos.Senai
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "SEBRAE",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = baseEncargos * encargos.Sebrae
                });

                lista.Add(new CalculoEventoBase
                {
                    CodEvento            = "SESI",
                    MatriculaFuncionario = func.Matricula,
                    CodMesOrcamento      = m.Codigo,
                    Valor = baseEncargos * encargos.SESI
                });
            }
            return(lista);
        }
        //Para cáculo de DSR, necessita-se da qtda de dias úteis e não úteis em cada mês.
        //Para isso, usa-se a tabela QtdaDias, que tem associada à ela uma escala de trabalho.
        //Foi criada a escala 1 (Dias úteis) e 2 (Dias não úteis) para esse cálculo
        public static IEnumerable <CalculoEventoContratacao> CalculaContratacaoCiclo(Contratacao cont, Ciclo ciclo)
        {
            Contexto db = new Contexto();

            if (cont == null || ciclo == null)
            {
                return(null);
            }

            List <CalculoEventoContratacao> lista = new List <CalculoEventoContratacao>();
            PAT            pat = db.PAT.Find(cont.CargaHoraria, cont.Filial.SindicatoCod);
            ConvenioMed    conveMed = null;
            ConvenioOdo    convOdo = null;
            Encargos       encargos = db.Encargos.Find(cont.EmpresaCod);
            EscalaTrabalho diasUteis = db.EscalaTrabalho.Find(1), diasNaoUteis = db.EscalaTrabalho.Find(2);

            float salario = 0, salarioBase = cont.Salario, valorConvMed = 0, valorDep = 0, valorConvOdo = 0;
            float valorPasse = db.Cidade.Find(cont.CidadeNome).VTPasse, valorPat = pat.Valor, peric = 0;
            float adCondutor = (float)(salarioBase * 0.1), vtDescontado = 0, somaHEs = 0, somaHNs = 0, baseEncargos = 0;
            int   qtdaPasses = db.CargaHoraria.Find(cont.CargaHoraria).QtdaPassesDiario;

            if (cont.ConvenioPlanoCod != null)
            {
                conveMed     = db.ConvenioMed.Find(cont.ConvenioPlanoCod);
                valorConvMed = (float)conveMed.Valor;
                valorDep     = (float)conveMed.ValorDependentes;
            }

            if (cont.ConvenioOdoCod != null)
            {
                convOdo      = db.ConvenioOdo.Find(cont.ConvenioOdoCod);
                valorConvOdo = convOdo.Valor;
            }

            foreach (MesOrcamento mes in ciclo.MesesOrcamento)
            {
                int numAno = mes.Mes.Year, numMes = mes.Mes.Month;
                int qtda     = db.ContratacaoMes.Find(cont.Codigo, mes.Codigo).Qtda;
                int qtdaDias = db.QtdaDias.Find(numMes, cont.CodEscala).Qtda;

                QtdaDias qtDiasObj     = db.QtdaDias.Find(numMes, diasUteis.Codigo);
                int      qtdaDiasUteis = qtDiasObj == null ? 22 : qtDiasObj.Qtda;
                qtDiasObj = db.QtdaDias.Find(numMes, diasNaoUteis.Codigo);
                int qtdaDiasNaoUteis = qtDiasObj == null ? 8 : qtDiasObj.Qtda;

                //Horas Extras
                List <HEContratacao> hes = db.HEContratacao
                                           .Where(x => x.ContratacaoCod == cont.Codigo && x.CodMesOrcamento == mes.Codigo)
                                           .ToList();

                //Horas Noturnas
                List <AdNoturnoContratacao> hns = db.AdNoturnoContratacao
                                                  .Where(x => x.CodContratacao == cont.Codigo && x.CodMesOrcamento == mes.Codigo)
                                                  .ToList();


                //**************** REAJUSTES ****************
                Reajuste reajSalario = db.Reajuste.Find(numAno, numMes, cont.Filial.SindicatoCod);
                if (reajSalario != null)
                {
                    salarioBase *= (float)(reajSalario.PercentualReajuste + 1);
                    peric        = (float)(salarioBase * 0.3);
                    adCondutor   = (float)(salarioBase * 0.1);
                    salario      = salarioBase;
                }

                if (conveMed != null)
                {
                    ReajConvenioMed reajConvMed = db.ReajConvenioMed.Find(numAno, numMes, cont.ConvenioPlanoCod);
                    if (reajConvMed != null)
                    {
                        valorConvMed *= (float)(reajConvMed.PercentualReajuste + 1);
                    }
                }

                if (convOdo != null)
                {
                    ReajConvenioOdo reajConvenioOdo = db.ReajConvenioOdo.Find(numAno, cont.ConvenioOdoCod, numMes);
                    if (reajConvenioOdo != null)
                    {
                        valorConvOdo *= (reajConvenioOdo.PercentualReajuste + 1);
                    }
                }

                ReajPAT reajPAT = db.ReajPAT.Find(numAno, numMes, cont.Filial.SindicatoCod);
                if (reajPAT != null)
                {
                    valorPat *= (reajPAT.PercentualReajuste + 1);
                }

                ReajVTPasse reajPasse = db.ReajVTPasse.Find(numAno, cont.CidadeNome, numMes);
                if (reajPasse != null)
                {
                    valorPasse *= (float)(reajPasse.PercentualReajuste + 1);
                }


                //****************** Cálculos ******************
                if (qtda > 0)
                {
                    //********************** SALÁRIOS E ADICIONAIS **********************
                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "SALARIO",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = salario
                    });


                    if (cont.Periculosidade)
                    {
                        lista.Add(new CalculoEventoContratacao
                        {
                            CodEvento       = "PERICUL",
                            CodContratacao  = cont.Codigo,
                            CodMesOrcamento = mes.Codigo,
                            Valor           = peric
                        });
                    }

                    if (cont.AdCondutor)
                    {
                        lista.Add(new CalculoEventoContratacao
                        {
                            CodEvento       = "ADI-COND",
                            CodContratacao  = cont.Codigo,
                            CodMesOrcamento = mes.Codigo,
                            Valor           = adCondutor
                        });
                    }

                    somaHEs = 0;
                    hes.ForEach(x => {
                        somaHEs += salario / cont.CargaHoraria * x.QtdaHoras * x.PercentualHoras / 100;

                        lista.Add(new CalculoEventoContratacao
                        {
                            CodEvento       = "HE-" + x.PercentualHoras.ToString(),
                            CodContratacao  = cont.Codigo,
                            CodMesOrcamento = mes.Codigo,
                            Valor           = somaHEs
                        });
                    });

                    somaHNs = 0;
                    hns.ForEach(x => {
                        somaHNs = salario / x.PercentualHoras / 100 / cont.CargaHoraria * x.QtdaHoras;
                        lista.Add(new CalculoEventoContratacao
                        {
                            CodEvento       = "AD-N-" + x.PercentualHoras.ToString(),
                            CodContratacao  = cont.Codigo,
                            CodMesOrcamento = mes.Codigo,
                            Valor           = somaHNs
                        });
                    });


                    //************************** BENEFÍCIOS **************************
                    vtDescontado = (valorPasse * qtdaDias) - (float)(salarioBase * 0.6);
                    if (vtDescontado > 0)
                    {
                        lista.Add(new CalculoEventoContratacao
                        {
                            CodEvento       = "VT-PASSE",
                            CodContratacao  = cont.Codigo,
                            CodMesOrcamento = mes.Codigo,
                            Valor           = vtDescontado
                        });
                    }

                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "PAT",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = valorPat * pat.Percentual
                    });

                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "CONV-MED",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = valorConvMed
                    });

                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "CONV-ODO",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = valorConvOdo
                    });


                    //************************** ENCARGOS **************************
                    baseEncargos = salario + (cont.Periculosidade ? peric : 0) + (cont.AdCondutor ? adCondutor : 0) + somaHEs + somaHNs;

                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "INSS",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = baseEncargos * encargos.INSS
                    });

                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "INCRA",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = baseEncargos * encargos.INCRA
                    });

                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "SAL-EDU",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = baseEncargos * encargos.SalEducacao
                    });

                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "SEBRAE",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = baseEncargos * encargos.Sebrae
                    });

                    lista.Add(new CalculoEventoContratacao
                    {
                        CodEvento       = "SESI",
                        CodContratacao  = cont.Codigo,
                        CodMesOrcamento = mes.Codigo,
                        Valor           = baseEncargos * encargos.SESI
                    });
                }
            }

            return(lista);
        }