public void PreencherUfsCategoria(CategoriaConteudo categoria)
{
foreach (ListItem item in chkUF.Items)
{
item.Selected = categoria.ListaCategoriaConteudoUF.Any(c => c.UF.ID == int.Parse(item.Value));
}
}
public override bool Equals(object obj)
{
CategoriaConteudoTags objeto = obj as CategoriaConteudoTags;
return(objeto == null ? false : CategoriaConteudo.Equals(objeto.CategoriaConteudo) &&
Tag.Equals(objeto.Tag));
}
public IList <StatusMatricula> ObterStatusMatriculaPorCategoriaConteudo(CategoriaConteudo categoriaConteudo)
{
if (categoriaConteudo == null)
{
return(ObterTodos());
}
if (categoriaConteudo.PossuiFiltroCategorias)
{
return
(repositorio.session.Query <StatusMatricula>()
.Where(
s =>
s.ListaCategoriaConteudo.Any(c => c.ID == categoriaConteudo.ID))
.OrderBy(s => s.Nome)
.ToList());
}
if (categoriaConteudo.CategoriaConteudoPai != null)
{
return(ObterStatusMatriculaPorCategoriaConteudo(categoriaConteudo.CategoriaConteudoPai));
}
return(ObterTodos());
}
private void PreencherHierarquia(CategoriaConteudo pai, TreeNode nodePai, bool radio, bool postback, IList <int> selecionados, Uf uf = null)
{
nodePai.Value = pai.ID.ToString();
nodePai.Text = pai.Nome;
if (radio)
{
AlterarNodeParaRadio(pai, nodePai, postback, selecionados);
}
if (selecionados != null)
{
nodePai.Checked = selecionados.Any(x => x == pai.ID);
}
nodePai.SelectAction = TreeNodeSelectAction.None;
if (selecionados != null)
{
nodePai.Checked = selecionados.Any(x => x == pai.ID);
}
// Nacionaliza ou não a lista de filhos.
var listaFilhos = uf == null
? pai.ListaCategoriaConteudoFilhos
: pai.ListaCategoriaConteudoFilhos.Where(
c => c.ListaCategoriaConteudoUF.Any(u => u.UF.ID == uf.ID));
foreach (var filho in listaFilhos)
{
var nodeFilho = new TreeNode
{
Value = filho.ID.ToString(),
Text = filho.Nome
};
if (selecionados != null)
{
nodeFilho.Checked = selecionados.Any(x => x == filho.ID);
}
if (radio)
{
AlterarNodeParaRadio(filho, nodeFilho, postback, selecionados);
}
if (selecionados != null)
{
nodeFilho.Checked = selecionados.Any(x => x == filho.ID);
}
PreencherHierarquia(filho, nodeFilho, radio, postback, selecionados, uf);
nodeFilho.SelectAction = TreeNodeSelectAction.None;
nodePai.ChildNodes.Add(nodeFilho);
}
}
private void AlterarNodeParaRadio(CategoriaConteudo categoria, TreeNode node, bool postback, IList <int> selecionados)
{
node.ShowCheckBox = false;
node.Text = "<input " + (postback ? "class='mostrarload'" : "") + " type='radio' name='" + trvCategorias.ClientID + "_rbCategoriaConteudo' value ='" +
categoria.ID + "' " +
(selecionados != null && selecionados.Any(x => x == categoria.ID) ? "checked='checked'" : "") +
"/>" + categoria.Nome;
}
/// <summary>
/// Obtém a maior categoria pai que possua filtro de Satus ou a própria categoria, caso não possua pai.
/// </summary>
/// <param name="categoriaConteudo"></param>
/// <returns></returns>
public CategoriaConteudo ObterMaiorCategoriaComFiltroCategoria(CategoriaConteudo categoriaConteudo)
{
var pais = ObterPais(categoriaConteudo);
// Como foi implementado, a primeira categoria da lista ObterPais() sempre será o maior pai.
var maiorPai = pais.FirstOrDefault(x => x.PossuiFiltroCategorias);
return(maiorPai ?? categoriaConteudo);
}
public bool IsFormacaoDeFormadores(CategoriaConteudo categoria)
{
int id;
if (int.TryParse(new ManterConfiguracaoSistema().ObterConfiguracaoSistemaPorID((int)enumConfiguracaoSistema.IdFormacaoDeFormadores).Registro, out id))
{
return(ObterCategoriaConteudoPorID(id).ObterFilhos().Select(x => x.ID).Contains(categoria.ID));
}
throw new AcademicoException("ID da Formação de Formadores não informada nas configurações do sistema");
}
public bool AlterouCategoria(int idSolucaoEducacional, CategoriaConteudo novaCategoria)
{
var solucao = repositorio.session.Query <SolucaoEducacional>().First(s => s.ID == idSolucaoEducacional);
if (solucao.CategoriaConteudo == null)
{
return(novaCategoria != null);
}
return(novaCategoria == null || solucao.CategoriaConteudo.ID != novaCategoria.ID);
}
public IQueryable <Questionario> ObterQuestionariosAbandono(CategoriaConteudo categoria = null)
{
var query = repositorio.session.Query <Questionario>()
.Where(x => x.TipoQuestionario.ID == (int)enumTipoQuestionario.Abandono);
if (categoria != null)
{
query = query.Where(x => x.ListaCategoriaConteudo.Select(c => c.ID).Contains(categoria.ID));
}
return(query);
}
public IList <CategoriaConteudo> ObterCategoriaConteudoPorFiltro(CategoriaConteudo pCategoriaConteudo)
{
IList <CategoriaConteudo> listaCategoriaConteudo = null;
try
{
listaCategoriaConteudo = bmCategoriaConteudo.ObterPorFiltro(pCategoriaConteudo);
}
catch (Exception ex)
{
ErroUtil.Instancia.TratarErro(ex);
}
return(listaCategoriaConteudo);
}
public CategoriaConteudo ObterCategoriaConteudoPorID(int pId)
{
CategoriaConteudo CategoriaConteudo = null;
try
{
CategoriaConteudo = bmCategoriaConteudo.ObterPorID(pId);
}
catch (Exception ex)
{
ErroUtil.Instancia.TratarErro(ex);
}
return(CategoriaConteudo);
}
private void ValidarCategoriaConteudoInformada(CategoriaConteudo pCategoriaConteudo)
{
ValidarInstancia(pCategoriaConteudo);
if (string.IsNullOrWhiteSpace(pCategoriaConteudo.Nome))
{
throw new AcademicoException("Nome. Campo Obrigatório");
}
if (pCategoriaConteudo.PossuiFiltroCategorias &&
(pCategoriaConteudo.ListaStatusMatricula == null || !pCategoriaConteudo.ListaStatusMatricula.Any()))
{
throw new AcademicoException(
"Pelo menos 1 status precisa ser informado caso a opção \"Possui Status relacionados?\" esteja selecionada.");
}
}
private IList <CategoriaConteudo> ObterPais(CategoriaConteudo categoriaConteudo)
{
var retorno = new List <CategoriaConteudo>();
if (categoriaConteudo.CategoriaConteudoPai != null)
{
retorno.AddRange(ObterPais(categoriaConteudo.CategoriaConteudoPai));
retorno.Add(categoriaConteudo);
}
else
{
retorno.Add(categoriaConteudo);
}
return(retorno.Distinct().ToList());
}
public IList <CategoriaConteudo> ObterPorFiltro(CategoriaConteudo pCategoriaConteudo)
{
var query = repositorio.session.Query <CategoriaConteudo>();
if (pCategoriaConteudo != null)
{
if (!string.IsNullOrWhiteSpace(pCategoriaConteudo.Nome))
{
query = query.Where(x => x.Nome.Contains(pCategoriaConteudo.Nome));
}
}
return(query.Select(x => new CategoriaConteudo()
{
ID = x.ID, Nome = x.Nome
}).ToList <CategoriaConteudo>());
}
public void AtualizarSiglaSubCategorias(CategoriaConteudo pCategoriaConteudo)
{
if (pCategoriaConteudo.CategoriaConteudoPai != null)
{
return;
}
if (!pCategoriaConteudo.ListaCategoriaConteudoFilhos.Any())
{
return;
}
foreach (var item in pCategoriaConteudo.ListaCategoriaConteudoFilhos)
{
item.Sigla = pCategoriaConteudo.Sigla;
AlterarCategoriaConteudo(item);
}
}
public void Incluir(CategoriaConteudo pCategoriaConteudo)
{
ValidarCategoriaConteudoInformada(pCategoriaConteudo);
//Verifica se a solução educacional já existe
bool existeRegistroCadastrado = false;// this.VerificarExistenciaDaSolucaoEducacional(pCategoriaConteudo.Nome);
if (existeRegistroCadastrado)
{
throw new AcademicoException(string.Format("A Categoria {0} já existe",
pCategoriaConteudo.Nome));
}
//pCategoriaConteudo.DataAlteracao = DateTime.Now;
repositorio.Salvar(pCategoriaConteudo);
}
static string CategoriaPai(CategoriaConteudo categoria)
{
if (categoria == null)
{
return("");
}
if (categoria.CategoriaConteudoPai == null)
{
return(categoria.Nome);
}
var ca = categoria.CategoriaConteudoPai;
var resultado = categoria.Nome;
while (ca != null)
{
resultado = ca.Nome;
ca = ca.CategoriaConteudoPai;
}
return(resultado);
}
public int?ObterProximoCodigoSequencial(CategoriaConteudo categoria)
{
if (categoria == null)
{
return(null);
}
var max = repositorio.session.Query <SolucaoEducacional>()
.Where(x => x.CategoriaConteudo.ID == categoria.ID)
.Max(x => x.Sequencia);
if (max.HasValue)
{
return(max.Value + 1);
}
else
{
return(1);
}
}
public void Excluir(CategoriaConteudo pCategoriaConteudo)
{
var termoAceite = new BMTermoAceite().ObterPorCategoriaConteudo(pCategoriaConteudo.ID);
if (termoAceite != null)
{
throw new AcademicoException("Exclusão de registro negada. Existe um termo de aceite vinculado a categoria conteúdo.");
}
if (this.ValidarDependencias(pCategoriaConteudo))
{
throw new AcademicoException("Exclusão de registro negada. Existem Registros Dependentes desta Categoria de Solução Educacional.");
}
if (pCategoriaConteudo.TermoAceiteCategoriaCounteudo != null)
{
new BMTermoAceite().ExcluirTermoAceiteCategoriaConteudo(pCategoriaConteudo.TermoAceiteCategoriaCounteudo.ID);
}
repositorio.Excluir(pCategoriaConteudo);
}
public void AlterarCategoriaConteudo(CategoriaConteudo pCategoriaConteudo)
{
try
{
base.PreencherInformacoesDeAuditoria(pCategoriaConteudo);
bmCategoriaConteudo.Alterar(pCategoriaConteudo);
AtualizarSiglaSubCategorias(pCategoriaConteudo);
}
catch (AlertException ex)
{
throw ex;
}
catch (AcademicoException ex)
{
throw ex;
}
catch (Exception ex)
{
ErroUtil.Instancia.TratarErro(ex);
}
}
public void ExcluirCategoriaConteudo(int IdCategoriaConteudo)
{
try
{
CategoriaConteudo CategoriaConteudo = null;
if (IdCategoriaConteudo > 0)
{
CategoriaConteudo = bmCategoriaConteudo.ObterPorID(IdCategoriaConteudo);
}
bmCategoriaConteudo.Excluir(CategoriaConteudo);
}
catch (AcademicoException ex)
{
throw ex;
}
catch (Exception ex)
{
ErroUtil.Instancia.TratarErro(ex);
}
}
protected override bool ValidarDependencias(object pCategoriaConteudo)
{
CategoriaConteudo CategoriaConteudo = (CategoriaConteudo)pCategoriaConteudo;
return(CategoriaConteudo.ListaSolucaoEducacional != null && CategoriaConteudo.ListaSolucaoEducacional.Count > 0);
}
private string PrepararEntradaDeDadosParaOServicoDrupal(CategoriaConteudo registro)
{
IList <CategoriaConteudoPermissao> ListaSolucaoEducacionalPermissao = registro.ListaPermissao;
IList <CategoriaConteudoTags> ListaSolucaoEducacionalTags = registro.ListaTags;
StringBuilder sbTodasTaxonomias = new StringBuilder();
StringBuilder sbTaxonomiaListaUF = new StringBuilder();
StringBuilder sbTaxonomiaListaPerfil = new StringBuilder();
StringBuilder sbTaxonomiaListaNivelOcupacional = new StringBuilder();
StringBuilder sbTaxonomiaListaTag = new StringBuilder();
sbTaxonomiaListaUF.Append("ListaUF,");
sbTaxonomiaListaPerfil.Append(";ListaPerfil,");
sbTaxonomiaListaNivelOcupacional.Append(";ListaNivelOcupacional,");
sbTaxonomiaListaTag.Append(";ListaTag,");
bool temUf = false;
bool temPerfil = false;
bool temTag = false;
bool temNivelOcupacional = false;
/* Percorre a Lista de Soluções Educacionais para acrescentar estas Soluções Educacionais à lista de
* taxonomias */
foreach (CategoriaConteudoPermissao itemPermissao in ListaSolucaoEducacionalPermissao)
{
if (itemPermissao.Uf != null && itemPermissao.Uf.ID > 0)
{
sbTaxonomiaListaUF.Append(string.Concat(itemPermissao.Uf.ID, ","));
temUf = true;
}
else if (itemPermissao.Perfil != null && itemPermissao.Perfil.ID > 0)
{
sbTaxonomiaListaPerfil.Append(string.Concat(itemPermissao.Perfil.ID, ","));
temPerfil = true;
}
else if (itemPermissao.NivelOcupacional != null && itemPermissao.NivelOcupacional.ID > 0)
{
sbTaxonomiaListaNivelOcupacional.Append(string.Concat(itemPermissao.NivelOcupacional.ID, ","));
temNivelOcupacional = true;
}
}
if (temUf)
{
string taxonomiaListaUF = sbTaxonomiaListaUF.ToString();
if (taxonomiaListaUF.EndsWith(","))
{
taxonomiaListaUF = taxonomiaListaUF.Remove(taxonomiaListaUF.Length - 1, 1);
}
sbTodasTaxonomias.Append(taxonomiaListaUF);
}
if (temPerfil)
{
string taxonomiaListaPerfil = sbTaxonomiaListaPerfil.ToString();
if (taxonomiaListaPerfil.EndsWith(","))
{
taxonomiaListaPerfil = taxonomiaListaPerfil.Remove(taxonomiaListaPerfil.Length - 1, 1);
}
//Adiciona a lista de perfis, à lista de taxonomias
sbTodasTaxonomias.Append(taxonomiaListaPerfil);
}
if (temNivelOcupacional)
{
string taxonomiaListaNivelOcupacional = sbTaxonomiaListaNivelOcupacional.ToString();
if (taxonomiaListaNivelOcupacional.EndsWith(","))
{
taxonomiaListaNivelOcupacional = taxonomiaListaNivelOcupacional.Remove(taxonomiaListaNivelOcupacional.Length - 1, 1);
}
//Adiciona a lista de perfis, à lista de taxonomias
sbTodasTaxonomias.Append(taxonomiaListaNivelOcupacional);
}
/* Percorre a Lista de Tags para acrescentar estas tags à lista de
* taxonomias (stringBuilder sbTodasTaxonomias) */
foreach (CategoriaConteudoTags itemTag in ListaSolucaoEducacionalTags)
{
if (itemTag.Tag != null && itemTag.Tag.ID > 0)
{
sbTaxonomiaListaTag.Append(string.Concat(itemTag.Tag.ID, ","));
temTag = true;
}
}
if (temTag)
{
string taxonomiaListaTags = sbTaxonomiaListaTag.ToString();
if (taxonomiaListaTags.EndsWith(","))
{
taxonomiaListaTags = taxonomiaListaTags.Remove(taxonomiaListaTags.Length - 1, 1);
}
//Adiciona a lista de perfis, à lista de taxonomias
sbTodasTaxonomias.Append(taxonomiaListaTags);
}
return(sbTodasTaxonomias.ToString());
}
public bool AlterouCategoria(int solucaoEducacionalId, CategoriaConteudo novaCategoria)
{
return(bmSolucaoEducacional.AlterouCategoria(solucaoEducacionalId, novaCategoria));
}
public void AtualizaNodeDrupal(CategoriaConteudo registro, string url)
{
try
{
if (!(registro.IdNode > 0))
{
return;
}
string sbTodasTaxonomias = this.PrepararEntradaDeDadosParaOServicoDrupal(registro);
int idNodePai = 0;
if (registro.CategoriaConteudoPai != null && registro.CategoriaConteudoPai.ID > 0 && !registro.CategoriaConteudoPai.IdNode.HasValue)
{
throw new AlertException("Dados salvaos no banco de dados. Não foi possível enviar os dados para o Portal. Favor publicar a categoria pai primeiro");
}
if (registro.CategoriaConteudoPai != null && registro.CategoriaConteudoPai.IdNode.HasValue)
{
idNodePai = registro.CategoriaConteudoPai.IdNode.Value;
}
bool ativo = true;
string linkParaImagem = string.Empty;
//if (registro.Imagem != null && registro..ID > 0)
//{
// ConfiguracaoSistema caminhoParaDiretorioDeUpload = ConfiguracaoSistemaUtil.ObterInformacoes(enumConfiguracaoSistema.EnderecoSGUS);
// linkParaImagem = CommonHelper.ObterLinkParaArquivoDeImagem(caminhoParaDiretorioDeUpload.Registro, registro.Imagem.ID);
//}
var postParameters = new Dictionary <string, string> {
{ "login", ConfiguracaoSistemaUtil.ObterInformacoes(enumConfiguracaoSistema.UsuarioSOAPPortal).Registro },
{ "senha", ConfiguracaoSistemaUtil.ObterInformacoes(enumConfiguracaoSistema.SenhaSOAPPortal).Registro },
{ "id_solucao_educacional", string.Empty },
{ "titulo", registro.Nome },
{ "corpo", registro.Apresentacao },
{ "lista_taxs", sbTodasTaxonomias },
{ "status", ativo.ToString() },
{ "node_id", registro.IdNode.ToString() },
{ "parent_id", idNodePai.ToString() },
{ "imagem", linkParaImagem }
};
var result = JsonUtil.GetJson <DTOJsonResultNodeId>(url, "POST", postParameters);
/*cursos_soap_updateRequest c = new cursos_soap_updateRequest(
* ConfiguracaoSistemaUtil.ObterInformacoes(enumConfiguracaoSistema.UsuarioSOAPPortal).Registro ,
* ConfiguracaoSistemaUtil.ObterInformacoes(enumConfiguracaoSistema.SenhaSOAPPortal).Registro,
* string.Empty,
* registro.Nome,
* registro.Apresentacao,
* sbTodasTaxonomias,
* ativo.ToString(),
* registro.IdNode.ToString(),
* idNodePai.ToString(),
* linkParaImagem,
* registro.CargaHoraria);
*
* soap_server_port_type s = new soap_server_port_typeClient();
* cursos_soap_updateResponse cursosSoapCreateResponse = s.cursos_soap_update(c);*/
int nodeRetorno = int.Parse(result.status);
if (nodeRetorno != registro.IdNode)
{
CategoriaConteudo categoriaConteudo = new BMCategoriaConteudo().ObterPorID(registro.ID);
categoriaConteudo.IdNode = int.Parse(result.status);
new BMCategoriaConteudo().Alterar(categoriaConteudo);
}
}
catch (AlertException ex)
{
throw ex;
}
catch (Exception)
{
throw new AlertException("Dados salvos no banco de dados. Erro ao sincronizar com o Portal");
}
}
public int?ObterProximoCodigoSequencial(CategoriaConteudo categoria)
{
return(bmSolucaoEducacional.ObterProximoCodigoSequencial(categoria));
}
public IList <StatusMatricula> ObterStatusMatriculaPorCategoriaConteudo(CategoriaConteudo categoriaConteudo)
{
return(_bmStatusMatricula.ObterStatusMatriculaPorCategoriaConteudo(categoriaConteudo));
}
public void Alterar(CategoriaConteudo pCategoriaConteudo)
{
ValidarCategoriaConteudoInformada(pCategoriaConteudo);
repositorio.Salvar(pCategoriaConteudo);
}
public IQueryable <Questionario> ObterQuestionariosCancelamento(CategoriaConteudo categoria = null)
{
return(bmQuestionario.ObterQuestionariosCancelamento(categoria));
}
public IQueryable <Questionario> ObterQuestionariosAbandono(CategoriaConteudo categoria = null)
{
return(bmQuestionario.ObterQuestionariosAbandono(categoria));
}
