public static TipoRubrica CriarTipoRubrica(int tipoRubricaId, string txNome, CsClasseRubrica csClasse, int tipoProjetoId)
{
var tipoRubrica = new TipoRubrica {
TipoRubricaId = tipoRubricaId, TxNome = txNome, CsClasse = csClasse, TipoProjetoId = tipoProjetoId
};
TipoRubricaDao.Instance.SalvarTipoRubrica(tipoRubrica);
return(tipoRubrica);
}
/// <summary>
/// Recupera Rúbricas de um Aditivo, filtrando por classe.
/// </summary>
/// <param name="aditivoId">Id do Aditivo a ter Rúbricas recuperadas.</param>
/// <param name="classe">Classe das Rúbricas a recuperar.</param>
/// <returns>Uma lista de DTOs de Rúbricas pertencentes ao Aditivo e à classe passada.</returns>
public List <RubricaDto> PesquisarRubricas(int aditivoId, CsClasseRubrica classe)
{
var rubricasDto = new List <RubricaDto>();
List <Rubrica> rubricas = RubricaDao.Instance.ConsultarRubricas(aditivoId, classe);
rubricasDto = DefinirRubricaDto(rubricas);
return(rubricasDto);
}
/// <summary>
/// Recupera detalhes de um mês de todas os Tipos de Rúbricas de uma Classe de Rúbricas.
/// </summary>
/// <param name="classeRubrica">Classe das Rúbricas.</param>
/// <param name="ano">ano.</param>
/// <param name="mes">mes.</param>
/// <returns>Lista de DTOs do detalhe do mês.</returns>
public List <CustoTipoRubricaDto> ListarCustosTiposRubricas(CsClasseRubrica classeRubrica, int ano, int mes)
{
List <TipoRubrica> tiposRubricas = TipoRubricaDao.Instance.ConsultarTiposRubricas(classeRubrica);
List <RubricaMes> rubricasMeses = RubricaMesDao.Instance.ConsultarRubricaMeses(classeRubrica, ano, mes);
List <CustoTipoRubricaDto> custosTiposRubricas = ListarCustosTipoRubricas(tiposRubricas, rubricasMeses);
ProcessarCustosTipoRubricas(custosTiposRubricas, ano, mes);
return(custosTiposRubricas);
}
/// <summary>
/// Consulta Tipos de Rúbricas usados em Rúbricas existentes pela Classe da Rúbrica.
/// </summary>
/// <param name="classeRubrica">Classe de Rúbrica a pesquisar.</param>
/// <param name="classeProjeto">Classe do Projeto a pesquisar. Padrao: CsClasseProjeto.Patrocinado</param>
/// <returns>Lista de Tipos de Rúbricas usados em Rúbricas existentes.</returns>
public List <TipoRubrica> ConsultarTiposRubricas(CsClasseRubrica classeRubrica,
CsClasseProjeto classeProjeto = CsClasseProjeto.Patrocinado)
{
List <TipoRubrica> tiposRubricas;
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
tiposRubricas = contexto.TiposRubrica
.Include(t => t.TipoProjeto)
.Include(t => t.TipoProjeto.ClasseProjeto)
.Where(t => t.CsClasse == classeRubrica && t.TipoProjeto.ClasseProjetoId == (int)classeProjeto)
.ToList();
}
return(tiposRubricas);
}
/// <summary>
/// Método para preencher os custos das rubricas administrativas
/// </summary>
/// <param name="classeRubrica">Classe do tipoRubrica</param>
/// <param name="ano">Ano</param>
/// <param name="mes">Mes</param>
/// <returns>CustoRubricasDto</returns>
public CustosRubricasDto DetalharCustosTipoRubrica(CsClasseRubrica classeRubrica, int ano, int mes)
{
List <CustoTipoRubricaDto> rubricaAdmDto = ListarCustosTiposRubricas(classeRubrica, ano, mes);
var custoRubrica = new CustosRubricasDto
{
TiposRubricas = rubricaAdmDto,
Total = new CustoValoresDto
{
OrcamentoAprovado = rubricaAdmDto.Sum(r => r.OrcamentoAprovado),
DespesaReal = rubricaAdmDto.Sum(r => r.DespesaReal),
SaldoDisponivel = rubricaAdmDto.Sum(r => r.SaldoDisponivel)
}
};
return(custoRubrica);
}
/// <summary>
/// Recupera detalhes de um mês de todas as Rúbricas de uma Classe de Rúbricas.
/// </summary>
/// <param name="classeRubrica">Classe de Rúbricas.</param>
/// <param name="ano">ano da rubrica a ser recuperado</param>
/// <param name="mes">mes da rubrica a ser recuperado</param>
/// <returns>Rubricas por mês</returns>
public List <RubricaMes> ConsultarRubricaMeses(CsClasseRubrica classeRubrica, int ano, int mes)
{
List <RubricaMes> rubricaMeses;
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
rubricaMeses = contexto.RubricaMeses
.Include(rm => rm.Rubrica)
.Include(rm => rm.Rubrica.TipoRubrica)
.Where(rm => rm.Rubrica.TipoRubrica.CsClasse == classeRubrica)
.Where(rm => rm.NbAno == ano)
.Where(rm => rm.CsMes == (CsMesDomain)mes)
.ToList();
}
return(rubricaMeses);
}
/// <summary>
/// Consulta Rubricas de um Aditivo por Classe de Rubrica.
/// </summary>
/// <param name="aditivoId">Id do Aditivo.</param>
/// <param name="classeRubrica">Classe de Rubrica.</param>
/// <returns>Lista de Rubricas recuperadas do Banco de Dados.</returns>
public List <Rubrica> ConsultarRubricas(int aditivoId, CsClasseRubrica classeRubrica)
{
List <Rubrica> rubricas;
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
rubricas = contexto.Rubricas
.MultiploInclude(
r => r.Filhos,
r => r.RubricaMeses,
r => r.Aditivo,
r => r.TipoRubrica
)
.Where(r => r.AditivoId == aditivoId)
.Where(r => (r.TipoRubrica.CsClasse & classeRubrica) > 0)
.ToList();
}
return(rubricas);
}
public ActionResult RubricaAditivoGet(int aditivoId, int?rubricaId = null,
CsClasseRubrica classe = CsClasseRubrica.Tudo)
{
bool userHasAccess = Roles.IsUserInRole(User.Identity.Name, classe.ToString());
bool isSuperUser = Roles.IsUserInRole(User.Identity.Name, "Sudo");
bool isGerenteDesenvolvimento = Roles.IsUserInRole(User.Identity.Name, "Desenvolvimento");
//Liberando acesso ao papel de Desenvolvimento às rubricas administrativas
if (isGerenteDesenvolvimento && classe.ToString() == "Administrativo")
{
userHasAccess = true;
}
if (isSuperUser)
{
userHasAccess = true;
}
if (userHasAccess && HttpContext.Request.AcceptTypes.Contains("application/json"))
{
if (rubricaId.HasValue)
{
RubricaDto rubrica = RubricaBo.Instance.PesquisarRubrica(rubricaId.Value);
return(Json(new { rubrica }, JsonRequestBehavior.AllowGet));
}
List <RubricaDto> rubricas;
if (classe == CsClasseRubrica.Tudo)
{
rubricas = RubricaBo.Instance.ListarRubricas(aditivoId);
}
else
{
rubricas = RubricaBo.Instance.PesquisarRubricas(aditivoId, classe);
}
return(Json(new { rubricas }, JsonRequestBehavior.AllowGet));
}
return(new EmptyResult());
}
