public void ValidandoAcessoaUmaHomePage()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
this.Usuario.Tipo = EnumAutenticacao.TipodeUsuario.Usuario;
this.Usuario.Login = "******";
this.Usuario.Senha = "bnkGt/s/jhxjZsCRAFDllQ=="; // testes
UsuarioController.Manter(this.Usuario, colecao);
this.Ambiente.Titulo = "Portal (Homologação)";
this.Ambiente.Habilitado = Valor.Ativo;
this.Ambiente.Restrito = Valor.Ativo;
AcessoController.Manter(this.Ambiente, "usuario.testes", colecao);
colecao.Persistir();
this.Mapeamento.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
this.Mapeamento.IdAcesso = this.Ambiente.ID;
this.Mapeamento.UrlMapID = PAGINA_ID;
this.Mapeamento.Principal = Valor.Ativo;
AcessoController.Manter(this.Mapeamento, "usuario.testes", null);
bool isHomePage = HomePageFacade.IsTrue(PAGINA_ID);
Assert.IsTrue(isHomePage, "Não foi possível localizar a associação com o cenário HOME.");
try { UsuarioCorrenteFacade.Desconectar(); }
catch { /* Prevenção */ }
}
public void CriandoeExcluindoPermissaoParaUmGrupo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
Swarm.Core.Library.Seguranca.Grupo objGrupo = GrupoController.Create();
objGrupo.Descricao = "Grupo de teste #1";
GrupoController.Manter(objGrupo, this.Usuario.Login, colecao);
GrupoUsuario objGrupoUsuario = GrupoUsuarioController.Create();
objGrupoUsuario.Usuario = this.Usuario;
objGrupoUsuario.Grupo = objGrupo;
GrupoUsuarioController.Manter(objGrupoUsuario, this.Usuario.Login, colecao);
Permissao objPermissao = PermissaoController.Create();
objPermissao.Grupo = objGrupoUsuario;
objPermissao.GUID = this.Ambiente.GUID;
PermissaoController.Manter(objPermissao, this.Usuario.Login, colecao);
PermissaoController.Excluir(objPermissao, colecao);
GrupoUsuarioController.Excluir(objGrupoUsuario, colecao);
GrupoController.Excluir(objGrupo, colecao);
colecao.Persistir();
Assert.IsTrue(Checar.MenorouIgual(objPermissao.ID));
}
public void CriandoeExcluindoPermissaoParaUmGrupo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
Swarm.Core.Library.Seguranca.Grupo objGrupo = GrupoController.Create();
objGrupo.Descricao = "Grupo de teste #1";
GrupoController.Manter(objGrupo, this.Usuario.Login, colecao);
GrupoUsuario objGrupoUsuario = GrupoUsuarioController.Create();
objGrupoUsuario.Usuario = this.Usuario;
objGrupoUsuario.Grupo = objGrupo;
GrupoUsuarioController.Manter(objGrupoUsuario, this.Usuario.Login, colecao);
Permissao objPermissao = PermissaoController.Create();
objPermissao.Grupo = objGrupoUsuario;
objPermissao.GUID = this.Ambiente.GUID;
PermissaoController.Manter(objPermissao, this.Usuario.Login, colecao);
PermissaoController.Excluir(objPermissao, colecao);
GrupoUsuarioController.Excluir(objGrupoUsuario, colecao);
GrupoController.Excluir(objGrupo, colecao);
colecao.Persistir();
Assert.IsTrue(Checar.MenorouIgual(objPermissao.ID));
}
public void CriandoUmaLigacao()
{
try
{
ColecaoPersistencia colecaoPersistencia = new ColecaoPersistencia();
this.Usuario.Tipo = EnumAutenticacao.TipodeUsuario.Usuario;
this.Usuario.Login = "******";
this.Usuario.Senha = "bnkGt/s/jhxjZsCRAFDllQ=="; // testes
UsuarioController.Manter(this.Usuario, colecaoPersistencia);
this.Grupo.Descricao = "Grupo #1 (Homologação)";
GrupoController.Manter(this.Grupo, this.Usuario.Login, colecaoPersistencia);
this.Ligacao.Usuario = this.Usuario;
this.Ligacao.Grupo = this.Grupo;
GrupoUsuarioController.Manter(this.Ligacao, this.Usuario.Login, colecaoPersistencia);
colecaoPersistencia.Persistir();
Assert.That(Checar.MaiorQue(this.Usuario.GetGrupos().Count), "Não há grupos associados ao usuário 'usuario.teste'");
Assert.That(Checar.MaiorQue(this.Grupo.GetUsuarios().Count), "Não há usuários associados ao grupo 'Grupo #1 (Homologação)'");
}
catch (Exception erro) { Assert.That(Valor.Inativo, erro.Message); }
}
public void CriandoCenariodeAcessoAnonimo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Administrativo (Homologação)";
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.Ambiente = this.AmbienteEnvolvido;
AcessoController.Manter(objSuperGrupo, "usuario.teste", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Segurança (Homologação)";
objGrupo.Habilitado = Valor.Ativo;
objGrupo.SuperGrupo = objSuperGrupo;
AcessoController.Manter(objGrupo, "usuario.teste", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Manutenção de Usuários (Homologação)";
objFuncionalidade.Habilitado = Valor.Ativo;
objFuncionalidade.Grupo = objGrupo;
AcessoController.Manter(objFuncionalidade, "usuario.teste", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
Assert.IsTrue(Checar.MaiorQue(this.AmbienteEnvolvido.ID));
}
public void CriandoCenariodeAcessoAnonimo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Administrativo (Homologação)";
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.Ambiente = this.AmbienteEnvolvido;
AcessoController.Manter(objSuperGrupo, "usuario.teste", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Segurança (Homologação)";
objGrupo.Habilitado = Valor.Ativo;
objGrupo.SuperGrupo = objSuperGrupo;
AcessoController.Manter(objGrupo, "usuario.teste", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Manutenção de Usuários (Homologação)";
objFuncionalidade.Habilitado = Valor.Ativo;
objFuncionalidade.Grupo = objGrupo;
AcessoController.Manter(objFuncionalidade, "usuario.teste", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
Assert.IsTrue(Checar.MaiorQue(this.AmbienteEnvolvido.ID));
}
public void PermitirMultiplosItensMapeadosQuandoFuncionalidade()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objFuncionalidadeMAP = new AcessoMap();
objFuncionalidadeMAP.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP.UrlMapID = Valor.Um;
objFuncionalidadeMAP.Principal = Valor.Ativo;
AcessoController.Manter(objFuncionalidadeMAP, "usuario.teste", colecao);
AcessoMap objFuncionalidadeMAP_2 = new AcessoMap();
objFuncionalidadeMAP_2.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP_2.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP_2.UrlMapID = Valor.Dois;
objFuncionalidadeMAP_2.Principal = Valor.Inativo;
AcessoController.Manter(objFuncionalidadeMAP_2, "usuario.teste", colecao);
AcessoController.Excluir(objFuncionalidadeMAP, colecao);
AcessoController.Excluir(objFuncionalidadeMAP_2, colecao);
colecao.Persistir();
Assert.IsFalse(Checar.MaiorQue(objFuncionalidadeMAP.ID), "O registro 1 deveria ter sido removido.");
Assert.IsFalse(Checar.MaiorQue(objFuncionalidadeMAP_2.ID), "O registro 2 deveria ter sido removido.");
}
public void ValidandoAcessoaUmaHomePage()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
this.Usuario.Tipo = EnumAutenticacao.TipodeUsuario.Usuario;
this.Usuario.Login = "******";
this.Usuario.Senha = "bnkGt/s/jhxjZsCRAFDllQ=="; // testes
UsuarioController.Manter(this.Usuario, colecao);
this.Ambiente.Titulo = "Portal (Homologação)";
this.Ambiente.Habilitado = Valor.Ativo;
this.Ambiente.Restrito = Valor.Ativo;
AcessoController.Manter(this.Ambiente, "usuario.testes", colecao);
colecao.Persistir();
this.Mapeamento.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
this.Mapeamento.IdAcesso = this.Ambiente.ID;
this.Mapeamento.UrlMapID = PAGINA_ID;
this.Mapeamento.Principal = Valor.Ativo;
AcessoController.Manter(this.Mapeamento, "usuario.testes", null);
bool isHomePage = HomePageFacade.IsTrue(PAGINA_ID);
Assert.IsTrue(isHomePage, "Não foi possível localizar a associação com o cenário HOME.");
try { UsuarioCorrenteFacade.Desconectar(); }
catch { /* Prevenção */ }
}
/// <summary>
/// Este método irá atualizar o avatar do usuário corrente (logado). Usado apenas na troca de Avatar.
/// </summary>
public static void AtualizarAvatarUsuarioLogado(string avatar, ColecaoPersistencia colecao)
{
if (!string.IsNullOrEmpty(avatar))
{
ObjUsuario usuario = UsuarioCorrenteSingleton.Istance.Usuario;
usuario.Avatar = avatar;
colecao.AdicionarItem(usuario, Persistence.Enumeradores.EnumTipoTransacao.Alterar);
}
}
public ModeloObjetoBase(string tabela, string chavePrimaria)
{
this._tabela = tabela;
this._chavePrimaria = chavePrimaria;
this.ItemsPersistencia = new ListaItemsPersistencia(this._tabela, this._chavePrimaria);
this._tipoPersistencia = EnumTipoPersistencia.Normal;
this._colecao = null;
}
public bool Create(string loginUsuario, string loginConta, string senhaConta)
{
try
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
ControladorShardAccount.Manter(0, loginUsuario, loginConta, senhaConta, string.Empty, string.Empty, false, false, colecao);
colecao.Persistir();
return true;
}
catch { return false; /*Conta já existe*/ }
}
public bool Create(string loginUsuario, string loginConta, string senhaConta)
{
try
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
ControladorShardAccount.Manter(0, loginUsuario, loginConta, senhaConta, string.Empty, string.Empty, false, false, colecao);
colecao.Persistir();
return(true);
}
catch { return(false); /*Conta já existe*/ }
}
public void InicializarObjetosEnvolvidos()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
this.Usuario = UsuarioController.Create();
this.Usuario.Tipo = EnumAutenticacao.TipodeUsuario.Usuario;
this.Usuario.Login = "******";
this.Usuario.Senha = "bnkGt/s/jhxjZsCRAFDllQ=="; // testes
UsuarioController.Manter(this.Usuario, colecao);
this.Ambiente = new Ambiente();
this.Ambiente.Titulo = "Portal (Homologação)";
this.Ambiente.Habilitado = Valor.Ativo;
this.Ambiente.Restrito = Valor.Ativo;
AcessoController.Manter(this.Ambiente, "usuario.testes", colecao);
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Aninhamento Padrão - Nível 1 (Homologação)";
objSuperGrupo.Ambiente = this.Ambiente;
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objSuperGrupo, "usuario.testes", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Aninhamento Padrão - Nível 2 (Homologação)";
objGrupo.SuperGrupo = objSuperGrupo;
objGrupo.Habilitado = Valor.Ativo;
objGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objGrupo, "usuario.testes", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
this.Funcionalidade = new Funcionalidade();
this.Funcionalidade.Titulo = "Validação de Página Mapeada (Homologação)";
this.Funcionalidade.Grupo = objGrupo;
this.Funcionalidade.Habilitado = Valor.Ativo;
AcessoController.Manter(this.Funcionalidade, "usuario.testes", colecao);
colecao.Persistir();
this.Mapeamento = new AcessoMap();
this.Mapeamento.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
this.Mapeamento.IdAcesso = this.Funcionalidade.ID;
this.Mapeamento.UrlMapID = PAGINA_ID;
this.Mapeamento.Principal = Valor.Ativo;
AcessoController.Manter(this.Mapeamento, "usuario.testes", null);
this.Permissao = PermissaoController.Create();
try { UsuarioCorrenteFacade.Desconectar(); }
catch { /* Prevenção */ }
}
public bool Delete(string login)
{
try
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
ControladorUsuario.Excluir(login, colecao);
colecao.Persistir();
return(true);
}
catch { return(false); /*Não foi possível remover o usuário*/ }
}
public bool Delete(string login)
{
try
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
ControladorUsuario.Excluir(login, colecao);
colecao.Persistir();
return true;
}
catch { return false; /*Não foi possível remover o usuário*/ }
}
public bool Delete(string loginConta)
{
try
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
int id = ControladorShardAccount.GetAccount(loginConta).ID;
ControladorShardAccount.Excluir(id, colecao);
colecao.Persistir();
return true;
}
catch { return false; /*Não foi possível remover a conta*/ }
}
public bool Delete(string loginConta)
{
try
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
int id = ControladorShardAccount.GetAccount(loginConta).ID;
ControladorShardAccount.Excluir(id, colecao);
colecao.Persistir();
return(true);
}
catch { return(false); /*Não foi possível remover a conta*/ }
}
public void InicializarObjetosEnvolvidos()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
this.Usuario = UsuarioController.Create();
this.Usuario.Tipo = EnumAutenticacao.TipodeUsuario.Usuario;
this.Usuario.Login = "******";
this.Usuario.Senha = "bnkGt/s/jhxjZsCRAFDllQ=="; // testes
UsuarioController.Manter(this.Usuario, colecao);
this.Ambiente = new Ambiente();
this.Ambiente.Titulo = "Portal (Homologação)";
this.Ambiente.Habilitado = Valor.Ativo;
this.Ambiente.Restrito = Valor.Ativo;
AcessoController.Manter(this.Ambiente, "usuario.testes", colecao);
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Aninhamento Padrão - Nível 1 (Homologação)";
objSuperGrupo.Ambiente = this.Ambiente;
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objSuperGrupo, "usuario.testes", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Aninhamento Padrão - Nível 2 (Homologação)";
objGrupo.SuperGrupo = objSuperGrupo;
objGrupo.Habilitado = Valor.Ativo;
objGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objGrupo, "usuario.testes", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
this.Funcionalidade = new Funcionalidade();
this.Funcionalidade.Titulo = "Validação de Página Mapeada (Homologação)";
this.Funcionalidade.Grupo = objGrupo;
this.Funcionalidade.Habilitado = Valor.Ativo;
AcessoController.Manter(this.Funcionalidade, "usuario.testes", colecao);
colecao.Persistir();
this.Mapeamento = new AcessoMap();
this.Mapeamento.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
this.Mapeamento.IdAcesso = this.Funcionalidade.ID;
this.Mapeamento.UrlMapID = PAGINA_ID;
this.Mapeamento.Principal = Valor.Ativo;
AcessoController.Manter(this.Mapeamento, "usuario.testes", null);
this.Permissao = PermissaoController.Create();
try { UsuarioCorrenteFacade.Desconectar(); }
catch { /* Prevenção */ }
}
public static void Manter(int id, int idUsuario, string nome, string email, char sexo, DateTime dataNascimento, ColecaoPersistencia colecao)
{
ObjPessoa pessoa = new ObjPessoa();
if (id > 0)
pessoa.Materializar(id);
bool existeAlteracoes = false;
if (!pessoa.Usuario.ID.Equals(idUsuario))
{
pessoa.Usuario.ID = idUsuario;
existeAlteracoes = true;
}
if (!pessoa.Nome.Equals(nome))
{
pessoa.Nome = nome;
existeAlteracoes = true;
}
if (!pessoa.Email.Equals(email))
{
pessoa.Email = email;
existeAlteracoes = true;
}
if (!pessoa.Sexo.Equals(sexo))
{
pessoa.Sexo = sexo;
existeAlteracoes = true;
}
if (!pessoa.DataNascimento.Equals(dataNascimento))
{
pessoa.DataNascimento = dataNascimento;
existeAlteracoes = true;
}
if (existeAlteracoes)
{
if (pessoa.ID > 0)
colecao.AdicionarItem(pessoa, Persistence.Enumeradores.EnumTipoTransacao.Alterar);
else
{
ObjUsuario usuario = new ObjUsuario(idUsuario);
pessoa.Usuario = usuario;
colecao.AdicionarItem(pessoa, Persistence.Enumeradores.EnumTipoTransacao.Incluir);
}
}
}
public void CriandoeExcluindoPermissaoParaUmUsuario()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
Permissao objPermissao = PermissaoController.Create();
objPermissao.Usuario = this.Usuario;
objPermissao.GUID = this.Ambiente.GUID;
PermissaoController.Manter(objPermissao, this.Usuario.Login, colecao);
PermissaoController.Excluir(objPermissao, colecao);
colecao.Persistir();
Assert.IsTrue(Checar.MenorouIgual(objPermissao.ID));
}
public void CriandoeExcluindoPermissaoParaUmUsuario()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
Permissao objPermissao = PermissaoController.Create();
objPermissao.Usuario = this.Usuario;
objPermissao.GUID = this.Ambiente.GUID;
PermissaoController.Manter(objPermissao, this.Usuario.Login, colecao);
PermissaoController.Excluir(objPermissao, colecao);
colecao.Persistir();
Assert.IsTrue(Checar.MenorouIgual(objPermissao.ID));
}
// Com controle de Transação
public bool Inserir(ColecaoPersistencia colecao)
{
int cColunas = 0;
int cValores = 0;
StringBuilder sql = new StringBuilder();
sql.AppendFormat("INSERT INTO {0}\n", this._tabela);
sql.AppendLine("(");
foreach (OItemPersistencia item in this._listaItems)
{
cColunas++;
sql.AppendFormat("{0}{1}\n", item.Nome, Outros.InserirVirgula(cColunas, this._listaItems.Count));
}
sql.AppendLine(")");
sql.AppendLine("VALUES");
sql.AppendLine("(");
foreach (OItemPersistencia item in this._listaItems)
{
cValores++;
if (item.Nome.Equals(this._chavePrimaria) || item.Valor == null)
{
sql.AppendFormat("NULL{0}\n", Outros.InserirVirgula(cValores, this._listaItems.Count));
}
else if (Outros.Comparar(item.Tipo, typeof(string)) || Outros.Comparar(item.Tipo, typeof(char)))
{
sql.AppendFormat("'{0}'{1}\n", SqlUtils.PrevencaoInternaSqlInjection(item.Valor), Outros.InserirVirgula(cValores, this._listaItems.Count));
}
else if (Outros.Comparar(item.Tipo, typeof(DateTime)))
{
DateTime dataHora = Conversoes.DataHora(item.Valor);
sql.AppendFormat("'{0}'{1}\n", dataHora.ToString("yyyy-MM-dd HH:mm:ss"), Outros.InserirVirgula(cValores, this._listaItems.Count));
}
else
{
sql.AppendFormat("{0}{1}\n", SqlUtils.PrevencaoInternaSqlInjection(item.Valor), Outros.InserirVirgula(cValores, this._listaItems.Count));
}
}
sql.AppendLine(")");
if (colecao == null)
{
return(this._mysql.Inserir(sql));
}
else
{
return(this._mysql.Inserir(sql, colecao));
}
}
public void ValidandoAcessoaUmaPaginaAnonima()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
this.Ambiente.Titulo = "Páginas Anônimas (Homologação)";
this.Ambiente.Habilitado = Valor.Ativo;
this.Ambiente.Restrito = Valor.Ativo;
this.Ambiente.CodigoInterno = EnumAcesso.CodigoInterno_Ambiente.Anonimo;
AcessoController.Manter(this.Ambiente, "usuario.testes", colecao);
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Aninhamento Padrão - Nível 1 (Homologação)";
objSuperGrupo.Ambiente = this.Ambiente;
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objSuperGrupo, "usuario.testes", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Aninhamento Padrão - Nível 2 (Homologação)";
objGrupo.SuperGrupo = objSuperGrupo;
objGrupo.Habilitado = Valor.Ativo;
objGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objGrupo, "usuario.testes", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Validação de Página (Homologação)";
objFuncionalidade.Grupo = objGrupo;
objFuncionalidade.Habilitado = Valor.Ativo;
AcessoController.Manter(objFuncionalidade, "usuario.testes", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
int paginaID = Valor.Dois; // Página DEFAULT (Fins de teste)
this.Mapeamento.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
this.Mapeamento.IdAcesso = objFuncionalidade.ID;
this.Mapeamento.UrlMapID = paginaID; // Página DEFAULT (Fins de teste)
this.Mapeamento.Principal = Valor.Ativo;
AcessoController.Manter(this.Mapeamento, "usuario.testes", null);
bool isAnonymousPage = AnonymousPageFacade.IsTrue(paginaID);
Assert.IsTrue(isAnonymousPage, "Não foi possível localizar a associação com o cenário ANONIMO.");
}
public void ValidarMapeamentos()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objAmbienteMAP = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = this.AmbienteEnvolvido.ID;
objAmbienteMAP.UrlMapID = Valor.Um;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP, "usuario.teste", colecao);
AcessoController.Excluir(objAmbienteMAP, colecao);
colecao.Persistir();
Assert.That(Checar.MenorouIgual(objAmbienteMAP.ID), "Não foi possível concluir a operação de criação e exclusão de mapeamento.");
}
public bool Remover(ColecaoPersistencia colecao)
{
StringBuilder sql = new StringBuilder();
sql.AppendFormat("DELETE FROM {0}\n", this._tabela);
this.FecharPorIdTabela(sql);
if (colecao == null)
{
return(this._mysql.Remover(sql));
}
else
{
return(this._mysql.Remover(sql, colecao));
}
}
public void ValidandoAcessoaUmaPaginaAnonima()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
this.Ambiente.Titulo = "Páginas Anônimas (Homologação)";
this.Ambiente.Habilitado = Valor.Ativo;
this.Ambiente.Restrito = Valor.Ativo;
this.Ambiente.CodigoInterno = EnumAcesso.CodigoInterno_Ambiente.Anonimo;
AcessoController.Manter(this.Ambiente, "usuario.testes", colecao);
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Aninhamento Padrão - Nível 1 (Homologação)";
objSuperGrupo.Ambiente = this.Ambiente;
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objSuperGrupo, "usuario.testes", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Aninhamento Padrão - Nível 2 (Homologação)";
objGrupo.SuperGrupo = objSuperGrupo;
objGrupo.Habilitado = Valor.Ativo;
objGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objGrupo, "usuario.testes", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Validação de Página (Homologação)";
objFuncionalidade.Grupo = objGrupo;
objFuncionalidade.Habilitado = Valor.Ativo;
AcessoController.Manter(objFuncionalidade, "usuario.testes", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
int paginaID = Valor.Dois; // Página DEFAULT (Fins de teste)
this.Mapeamento.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
this.Mapeamento.IdAcesso = objFuncionalidade.ID;
this.Mapeamento.UrlMapID = paginaID; // Página DEFAULT (Fins de teste)
this.Mapeamento.Principal = Valor.Ativo;
AcessoController.Manter(this.Mapeamento, "usuario.testes", null);
bool isAnonymousPage = AnonymousPageFacade.IsTrue(paginaID);
Assert.IsTrue(isAnonymousPage, "Não foi possível localizar a associação com o cenário ANONIMO.");
}
public bool Alterar(ColecaoPersistencia colecao)
{
int cItems = 0;
StringBuilder sql = new StringBuilder();
sql.AppendFormat("UPDATE {0}\n", this._tabela);
sql.AppendLine("SET");
foreach (OItemPersistencia item in this._listaItems)
{
cItems++;
if (item.Nome.Equals(this._chavePrimaria))
{
continue;
}
if (item.Valor == null)
{
sql.AppendFormat("{0} = NULL{1}\n", item.Nome, Outros.InserirVirgula(cItems, this._listaItems.Count));
}
else if (Outros.Comparar(item.Tipo, typeof(string)))
{
sql.AppendFormat("{0} = '{1}'{2}\n", item.Nome, SqlUtils.PrevencaoInternaSqlInjection(item.Valor), Outros.InserirVirgula(cItems, this._listaItems.Count));
}
else if (Outros.Comparar(item.Tipo, typeof(DateTime)))
{
DateTime dataHora = Conversoes.DataHora(item.Valor);
sql.AppendFormat("{0} = '{1}'{2}\n", item.Nome, dataHora.ToString("yyyy-MM-dd HH:mm:ss"), Outros.InserirVirgula(cItems, this._listaItems.Count));
}
else
{
sql.AppendFormat("{0} = {1}{2}\n", item.Nome, SqlUtils.PrevencaoInternaSqlInjection(item.Valor), Outros.InserirVirgula(cItems, this._listaItems.Count));
}
}
this.FecharPorIdTabela(sql);
if (colecao == null)
{
return(this._mysql.Alterar(sql));
}
else
{
return(this._mysql.Alterar(sql, colecao));
}
}
public void CriandoeExcluindoumUsuario()
{
try
{
ColecaoPersistencia colecaoPersistencia = new ColecaoPersistencia();
this.Usuario.Tipo = EnumAutenticacao.TipodeUsuario.Usuario;
this.Usuario.Login = "******";
this.Usuario.Senha = "bnkGt/s/jhxjZsCRAFDllQ=="; // testes
this.Usuario.Avatar = Valor.Vazio;
UsuarioController.Manter(this.Usuario, colecaoPersistencia);
colecaoPersistencia.Persistir();
Assert.IsTrue(Valor.Ativo);
}
catch (Exception erro) { Assert.That(Valor.Inativo, erro.Message); }
}
public void CriandoeExcluindoumGrupo()
{
try
{
ColecaoPersistencia colecaoPersistencia = new ColecaoPersistencia();
this.Grupo.Descricao = "Grupo #1 (Homologação)";
GrupoController.Manter(this.Grupo, "usuario.teste", colecaoPersistencia);
colecaoPersistencia.Persistir();
Assert.IsTrue(Valor.Ativo);
}
catch (Exception erro)
{
Assert.That(Valor.Inativo, erro.Message);
}
}
public void CriandoeExcluindoumUsuario()
{
try
{
ColecaoPersistencia colecaoPersistencia = new ColecaoPersistencia();
this.Usuario.Tipo = EnumAutenticacao.TipodeUsuario.Usuario;
this.Usuario.Login = "******";
this.Usuario.Senha = "bnkGt/s/jhxjZsCRAFDllQ=="; // testes
this.Usuario.Avatar = Valor.Vazio;
UsuarioController.Manter(this.Usuario, colecaoPersistencia);
colecaoPersistencia.Persistir();
Assert.IsTrue(Valor.Ativo);
}
catch (Exception erro) { Assert.That(Valor.Inativo, erro.Message); }
}
public static void Manter(int id, string login, string senha, TipoUsuario tipo, string avatar, ColecaoPersistencia colecao)
{
ObjUsuario usuario = new ObjUsuario();
if (id > 0)
usuario.Materializar(id);
bool existeAlteracoes = false;
if (!String.IsNullOrEmpty(login) && !usuario.Login.Equals(login))
{
usuario.Login = login;
existeAlteracoes = true;
}
Criptografia.Criptografia criptografia = new CriptografiaMD5();
string senhaCriptografada = criptografia.Criptografar(senha);
if (!String.IsNullOrEmpty(senha) && !usuario.Senha.Equals(senhaCriptografada))
{
usuario.Senha = senhaCriptografada;
existeAlteracoes = true;
}
if (!usuario.Tipo.Equals(tipo))
{
usuario.Tipo = tipo;
existeAlteracoes = true;
}
if (!String.IsNullOrEmpty(avatar) && !usuario.Avatar.Equals(avatar))
{
usuario.Avatar = avatar;
existeAlteracoes = true;
}
if (existeAlteracoes)
{
if (usuario.ID > 0)
colecao.AdicionarItem(usuario, Persistence.Enumeradores.EnumTipoTransacao.Alterar);
else
colecao.AdicionarItem(usuario, Persistence.Enumeradores.EnumTipoTransacao.Incluir);
}
}
public bool Create(string login, string senha, string nome, string email, char sexo, DateTime dataNascimento)
{
try
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
/*Criando Usuário*/
ControladorUsuario.Manter(0, login, senha, TipoUsuario.Usuario, string.Empty, colecao);
colecao.Persistir();
/*Criando Pessoa*/
colecao.Limpar();
int idUsuario = ControladorUsuario.GetUsuarioPorLogin(login).ID;
ControladorPessoa.Manter(0, idUsuario, nome, email, sexo, dataNascimento, colecao);
colecao.Persistir();
return(true);
}
catch { return(false); /*Usuário já existe no sistema*/ }
}
public bool Create(string login, string senha, string nome, string email, char sexo, DateTime dataNascimento)
{
try
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
/*Criando Usuário*/
ControladorUsuario.Manter(0, login, senha, TipoUsuario.Usuario, string.Empty, colecao);
colecao.Persistir();
/*Criando Pessoa*/
colecao.Limpar();
int idUsuario = ControladorUsuario.GetUsuarioPorLogin(login).ID;
ControladorPessoa.Manter(0, idUsuario, nome, email, sexo, dataNascimento, colecao);
colecao.Persistir();
return true;
}
catch { return false; /*Usuário já existe no sistema*/ }
}
public void NaoPodeHaverDoisItensMapeadosComoPrincipaisQuandoFuncionalidadeMesmoSendoDistintos()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objFuncionalidadeMAP = new AcessoMap();
objFuncionalidadeMAP.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP.UrlMapID = Valor.Um;
objFuncionalidadeMAP.Principal = Valor.Ativo;
AcessoController.Manter(objFuncionalidadeMAP, "usuario.teste", colecao);
AcessoMap objFuncionalidadeMAP_2 = new AcessoMap();
objFuncionalidadeMAP_2.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP_2.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP_2.UrlMapID = Valor.Dois;
objFuncionalidadeMAP_2.Principal = Valor.Ativo; // *ERRO*
AcessoController.Manter(objFuncionalidadeMAP_2, "usuario.teste", colecao);
colecao.Persistir();
}
protected void btnRegister_Click(object sender, EventArgs e)
{
try
{
this.ValidateViewItems();
// First, create User
ColecaoPersistencia colecao = new ColecaoPersistencia();
ControladorUsuario.Manter(int.MinValue, this.Login, this.Password, Security.Usuario.Enumeradores.TipoUsuario.Usuario, string.Empty, colecao);
colecao.Persistir();
// Now, create User Person
colecao.Limpar();
int idUsuario = ControladorUsuario.GetUsuarioPorLogin(this.Login).ID;
ControladorPessoa.Manter(int.MinValue, idUsuario, this.Name, this.Email, this.Sex, this.BirthDate, colecao);
colecao.Persistir();
Mensagens.MostrarAlerta(this, "Your account has been created successfully.");
this.btnRegister.Enabled = false;
}
catch (Exception error) { Mensagens.MostrarAlerta(this, error.Message); }
}
protected void btnRegister_Click(object sender, EventArgs e)
{
try
{
this.ValidateViewItems();
// First, create User
ColecaoPersistencia colecao = new ColecaoPersistencia();
ControladorUsuario.Manter(int.MinValue, this.Login, this.Password, Security.Usuario.Enumeradores.TipoUsuario.Usuario, string.Empty, colecao);
colecao.Persistir();
// Now, create User Person
colecao.Limpar();
int idUsuario = ControladorUsuario.GetUsuarioPorLogin(this.Login).ID;
ControladorPessoa.Manter(int.MinValue, idUsuario, this.Name, this.Email, this.Sex, this.BirthDate, colecao);
colecao.Persistir();
Mensagens.MostrarAlerta(this, "Your account has been created successfully.");
this.btnRegister.Enabled = false;
}
catch (Exception error) { Mensagens.MostrarAlerta(this, error.Message); }
}
// Com controle de Transação
public bool Inserir(ColecaoPersistencia colecao)
{
int cColunas = 0;
int cValores = 0;
StringBuilder sql = new StringBuilder();
sql.AppendFormat("INSERT INTO {0}\n", this._tabela);
sql.AppendLine("(");
foreach (OItemPersistencia item in this._listaItems)
{
cColunas++;
sql.AppendFormat("{0}{1}\n", item.Nome, Outros.InserirVirgula(cColunas, this._listaItems.Count));
}
sql.AppendLine(")");
sql.AppendLine("VALUES");
sql.AppendLine("(");
foreach (OItemPersistencia item in this._listaItems)
{
cValores++;
if (item.Nome.Equals(this._chavePrimaria) || item.Valor == null)
sql.AppendFormat("NULL{0}\n", Outros.InserirVirgula(cValores, this._listaItems.Count));
else if (Outros.Comparar(item.Tipo, typeof(string)) || Outros.Comparar(item.Tipo, typeof(char)))
sql.AppendFormat("'{0}'{1}\n", SqlUtils.PrevencaoInternaSqlInjection(item.Valor), Outros.InserirVirgula(cValores, this._listaItems.Count));
else if (Outros.Comparar(item.Tipo, typeof(DateTime)))
{
DateTime dataHora = Conversoes.DataHora(item.Valor);
sql.AppendFormat("'{0}'{1}\n", dataHora.ToString("yyyy-MM-dd HH:mm:ss"), Outros.InserirVirgula(cValores, this._listaItems.Count));
}
else
sql.AppendFormat("{0}{1}\n", SqlUtils.PrevencaoInternaSqlInjection(item.Valor), Outros.InserirVirgula(cValores, this._listaItems.Count));
}
sql.AppendLine(")");
if (colecao == null)
return this._mysql.Inserir(sql);
else
return this._mysql.Inserir(sql, colecao);
}
public void NaoPermitirMaisDeUmItemMapeadoNoMesmoAmbiente()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objAmbienteMAP = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = Valor.Um; // DEFAULT (ID Ambiente)
objAmbienteMAP.UrlMapID = Valor.Um;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP, "usuario.teste", colecao);
AcessoMap objAmbienteMAP_DUPLICADO = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = Valor.Um; // DEFAULT (ID Ambiente)
objAmbienteMAP.UrlMapID = Valor.Dois;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP_DUPLICADO, "usuario.teste", colecao); // *ERRO*
colecao.Persistir();
Assert.IsFalse(Checar.MaiorQue(objAmbienteMAP_DUPLICADO.ID), "Não deveria permitir a duplicação de ligações quando Ambiente.");
}
private bool ManipulandoDadosNaBase(StringBuilder querySql, ColecaoPersistencia colecao)
{
// retorna true em caso de sucesso.
bool executou = false;
MySqlCommand comandoSql = null;
try
{
// recuperando instancia de MySqlCommand
comandoSql = colecao.TransacaoAtiva.Conexao.CreateCommand();
// Definindo conexao e transacao para MySqlCommand
comandoSql.Connection = colecao.TransacaoAtiva.Conexao;
comandoSql.Transaction = colecao.TransacaoAtiva.Transacao;
// Definindo query para comandoSql
comandoSql.CommandText = querySql.ToString();
// executando query
executou = comandoSql.ExecuteNonQuery() > 0;
}
catch (Exception ex)
{
throw new Exception("Uma exceção do tipo " + ex.GetType() + " foi encontrado enquanto a query estava sendo processada.");
}
finally
{
if (comandoSql != null)
{
comandoSql.Dispose();
}
}
return(executou);
}
internal bool Remover(StringBuilder querySql, ColecaoPersistencia colecao)
{
return ManipulandoDadosNaBase(querySql, colecao);
}
private bool ManipulandoDadosNaBase(StringBuilder querySql, ColecaoPersistencia colecao)
{
// retorna true em caso de sucesso.
bool executou = false;
MySqlCommand comandoSql = null;
try
{
// recuperando instancia de MySqlCommand
comandoSql = colecao.TransacaoAtiva.Conexao.CreateCommand();
// Definindo conexao e transacao para MySqlCommand
comandoSql.Connection = colecao.TransacaoAtiva.Conexao;
comandoSql.Transaction = colecao.TransacaoAtiva.Transacao;
// Definindo query para comandoSql
comandoSql.CommandText = querySql.ToString();
// executando query
executou = comandoSql.ExecuteNonQuery() > 0;
}
catch (Exception ex)
{
throw new Exception("Uma exceção do tipo " + ex.GetType() + " foi encontrado enquanto a query estava sendo processada.");
}
finally
{
if (comandoSql != null)
comandoSql.Dispose();
}
return executou;
}
public static void Excluir(string login, ColecaoPersistencia colecao)
{
ObjUsuario usuario = ControladorUsuario.GetUsuarioPorLogin(login);
colecao.AdicionarItem(usuario, Persistence.Enumeradores.EnumTipoTransacao.Remover);
}
/// <summary>
/// Alterar senha usuário corrente (logado).
/// </summary>
public static void AtualizarSenhaUsuarioLogado(string senhaAtual, string novaSenha, ColecaoPersistencia colecao)
{
if ((!string.IsNullOrEmpty(senhaAtual) && string.IsNullOrEmpty(novaSenha)) ||
(!string.IsNullOrEmpty(novaSenha) && string.IsNullOrEmpty(senhaAtual)))
{
throw new Usuario.Excessoes.AlterarSenhaDadosIncompletosException("Não foi possível Alterar a senha, dados incompletos.");
}
if (!string.IsNullOrEmpty(senhaAtual) && !string.IsNullOrEmpty(novaSenha))
{
ObjUsuario usuario = UsuarioCorrenteSingleton.Istance.Usuario;
Criptografia.Criptografia criptografia = new CriptografiaMD5();
senhaAtual = criptografia.Criptografar(senhaAtual);
if (senhaAtual.Equals(usuario.Senha))
{
novaSenha = criptografia.Criptografar(novaSenha);
usuario.Senha = novaSenha;
colecao.AdicionarItem(usuario, Persistence.Enumeradores.EnumTipoTransacao.Alterar);
}
else
{
throw new Usuario.Excessoes.SenhaInvalidaException("A senha informada não confere.");
}
}
}
public void ValidarMapeamentos()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objAmbienteMAP = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = this.AmbienteEnvolvido.ID;
objAmbienteMAP.UrlMapID = Valor.Um;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP, "usuario.teste", colecao);
AcessoController.Excluir(objAmbienteMAP, colecao);
colecao.Persistir();
Assert.That(Checar.MenorouIgual(objAmbienteMAP.ID), "Não foi possível concluir a operação de criação e exclusão de mapeamento.");
}
/// <summary>
/// Alterar senha usuário corrente (logado).
/// </summary>
public static void AtualizarSenhaUsuarioLogado(string senhaAtual, string novaSenha, ColecaoPersistencia colecao)
{
if ((!string.IsNullOrEmpty(senhaAtual) && string.IsNullOrEmpty(novaSenha)) ||
(!string.IsNullOrEmpty(novaSenha) && string.IsNullOrEmpty(senhaAtual)))
throw new Usuario.Excessoes.AlterarSenhaDadosIncompletosException("Não foi possível Alterar a senha, dados incompletos.");
if (!string.IsNullOrEmpty(senhaAtual) && !string.IsNullOrEmpty(novaSenha))
{
ObjUsuario usuario = UsuarioCorrenteSingleton.Istance.Usuario;
Criptografia.Criptografia criptografia = new CriptografiaMD5();
senhaAtual = criptografia.Criptografar(senhaAtual);
if (senhaAtual.Equals(usuario.Senha))
{
novaSenha = criptografia.Criptografar(novaSenha);
usuario.Senha = novaSenha;
colecao.AdicionarItem(usuario, Persistence.Enumeradores.EnumTipoTransacao.Alterar);
}
else
throw new Usuario.Excessoes.SenhaInvalidaException("A senha informada não confere.");
}
}
internal bool Remover(StringBuilder querySql, ColecaoPersistencia colecao)
{
return(ManipulandoDadosNaBase(querySql, colecao));
}
/// <summary>
/// Inclusion of registry does not believe the collection of persistence.
/// </summary>
public static void Manter(int id, string loginUsuario, string login, string senha, string CPF, string RG, bool doador, bool ativo, ColecaoPersistencia colecao)
{
ObjShardAccount shardAccount = new ObjShardAccount();
if (id > 0)
{
shardAccount.Materializar(id);
}
bool existeAlteracao = false;
if (!shardAccount.Login.Equals(login))
{
shardAccount.Login = login;
existeAlteracao = true;
}
if (!shardAccount.Senha.Equals(senha))
{
shardAccount.Senha = senha;
existeAlteracao = true;
}
if (!shardAccount.CPF.Equals(CPF))
{
shardAccount.CPF = CPF;
existeAlteracao = true;
}
if (!shardAccount.RG.Equals(RG))
{
shardAccount.RG = RG;
existeAlteracao = true;
}
if (!shardAccount.Doador.Equals(doador))
{
shardAccount.Doador = doador;
existeAlteracao = true;
}
if (!shardAccount.Ativo.Equals(ativo))
{
shardAccount.Ativo = ativo;
existeAlteracao = true;
}
if (existeAlteracao)
{
ObjPessoa pessoa = ControladorPessoa.GetPessoa(loginUsuario);
shardAccount.NomeCompleto = pessoa.Nome;
shardAccount.DataNascimento = pessoa.DataNascimento;
shardAccount.Sexo = pessoa.Sexo;
shardAccount.Email = pessoa.Email;
shardAccount.DataCriacaoConta = DateTime.Now;
if (shardAccount.ID > 0)
{
colecao.AdicionarItem(shardAccount, Persistence.Enumeradores.EnumTipoTransacao.Alterar);
}
else
{
shardAccount.Ativo = false;
bool inserted = shardAccount.Incluir();
if (inserted)
{
ControladorUsuarioConta.LinkingWebAccountToShardAccount(pessoa.Usuario.ID, shardAccount.Login);
}
}
}
}
public bool Alterar(ColecaoPersistencia colecao)
{
int cItems = 0;
StringBuilder sql = new StringBuilder();
sql.AppendFormat("UPDATE {0}\n", this._tabela);
sql.AppendLine("SET");
foreach (OItemPersistencia item in this._listaItems)
{
cItems++;
if (item.Nome.Equals(this._chavePrimaria))
continue;
if (item.Valor == null)
sql.AppendFormat("{0} = NULL{1}\n", item.Nome, Outros.InserirVirgula(cItems, this._listaItems.Count));
else if (Outros.Comparar(item.Tipo, typeof(string)))
sql.AppendFormat("{0} = '{1}'{2}\n", item.Nome, SqlUtils.PrevencaoInternaSqlInjection(item.Valor), Outros.InserirVirgula(cItems, this._listaItems.Count));
else if (Outros.Comparar(item.Tipo, typeof(DateTime)))
{
DateTime dataHora = Conversoes.DataHora(item.Valor);
sql.AppendFormat("{0} = '{1}'{2}\n", item.Nome, dataHora.ToString("yyyy-MM-dd HH:mm:ss"), Outros.InserirVirgula(cItems, this._listaItems.Count));
}
else
sql.AppendFormat("{0} = {1}{2}\n", item.Nome, SqlUtils.PrevencaoInternaSqlInjection(item.Valor), Outros.InserirVirgula(cItems, this._listaItems.Count));
}
this.FecharPorIdTabela(sql);
if (colecao == null)
return this._mysql.Alterar(sql);
else
return this._mysql.Alterar(sql, colecao);
}
public void NaoPermitirMaisDeUmItemMapeadoNoMesmoAmbiente()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objAmbienteMAP = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = Valor.Um; // DEFAULT (ID Ambiente)
objAmbienteMAP.UrlMapID = Valor.Um;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP, "usuario.teste", colecao);
AcessoMap objAmbienteMAP_DUPLICADO = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = Valor.Um; // DEFAULT (ID Ambiente)
objAmbienteMAP.UrlMapID = Valor.Dois;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP_DUPLICADO, "usuario.teste", colecao); // *ERRO*
colecao.Persistir();
Assert.IsFalse(Checar.MaiorQue(objAmbienteMAP_DUPLICADO.ID), "Não deveria permitir a duplicação de ligações quando Ambiente.");
}
public void NaoPodeHaverDoisItensMapeadosComoPrincipaisQuandoFuncionalidadeMesmoSendoDistintos()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objFuncionalidadeMAP = new AcessoMap();
objFuncionalidadeMAP.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP.UrlMapID = Valor.Um;
objFuncionalidadeMAP.Principal = Valor.Ativo;
AcessoController.Manter(objFuncionalidadeMAP, "usuario.teste", colecao);
AcessoMap objFuncionalidadeMAP_2 = new AcessoMap();
objFuncionalidadeMAP_2.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP_2.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP_2.UrlMapID = Valor.Dois;
objFuncionalidadeMAP_2.Principal = Valor.Ativo; // *ERRO*
AcessoController.Manter(objFuncionalidadeMAP_2, "usuario.teste", colecao);
colecao.Persistir();
}
public bool Remover(ColecaoPersistencia colecao)
{
StringBuilder sql = new StringBuilder();
sql.AppendFormat("DELETE FROM {0}\n", this._tabela);
this.FecharPorIdTabela(sql);
if (colecao == null)
return this._mysql.Remover(sql);
else
return this._mysql.Remover(sql, colecao);
}
public void PermitirMultiplosItensMapeadosQuandoFuncionalidade()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objFuncionalidadeMAP = new AcessoMap();
objFuncionalidadeMAP.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP.UrlMapID = Valor.Um;
objFuncionalidadeMAP.Principal = Valor.Ativo;
AcessoController.Manter(objFuncionalidadeMAP, "usuario.teste", colecao);
AcessoMap objFuncionalidadeMAP_2 = new AcessoMap();
objFuncionalidadeMAP_2.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP_2.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP_2.UrlMapID = Valor.Dois;
objFuncionalidadeMAP_2.Principal = Valor.Inativo;
AcessoController.Manter(objFuncionalidadeMAP_2, "usuario.teste", colecao);
AcessoController.Excluir(objFuncionalidadeMAP, colecao);
AcessoController.Excluir(objFuncionalidadeMAP_2, colecao);
colecao.Persistir();
Assert.IsFalse(Checar.MaiorQue(objFuncionalidadeMAP.ID), "O registro 1 deveria ter sido removido.");
Assert.IsFalse(Checar.MaiorQue(objFuncionalidadeMAP_2.ID), "O registro 2 deveria ter sido removido.");
}
/// <summary>
/// Inclusion of registry does not believe the collection of persistence.
/// </summary>
public static void Manter(int id, string loginUsuario, string login, string senha, string CPF, string RG, bool doador, bool ativo, ColecaoPersistencia colecao)
{
ObjShardAccount shardAccount = new ObjShardAccount();
if (id > 0)
shardAccount.Materializar(id);
bool existeAlteracao = false;
if (!shardAccount.Login.Equals(login))
{
shardAccount.Login = login;
existeAlteracao = true;
}
if (!shardAccount.Senha.Equals(senha))
{
shardAccount.Senha = senha;
existeAlteracao = true;
}
if (!shardAccount.CPF.Equals(CPF))
{
shardAccount.CPF = CPF;
existeAlteracao = true;
}
if (!shardAccount.RG.Equals(RG))
{
shardAccount.RG = RG;
existeAlteracao = true;
}
if (!shardAccount.Doador.Equals(doador))
{
shardAccount.Doador = doador;
existeAlteracao = true;
}
if (!shardAccount.Ativo.Equals(ativo))
{
shardAccount.Ativo = ativo;
existeAlteracao = true;
}
if (existeAlteracao)
{
ObjPessoa pessoa = ControladorPessoa.GetPessoa(loginUsuario);
shardAccount.NomeCompleto = pessoa.Nome;
shardAccount.DataNascimento = pessoa.DataNascimento;
shardAccount.Sexo = pessoa.Sexo;
shardAccount.Email = pessoa.Email;
shardAccount.DataCriacaoConta = DateTime.Now;
if (shardAccount.ID > 0)
colecao.AdicionarItem(shardAccount, Persistence.Enumeradores.EnumTipoTransacao.Alterar);
else
{
shardAccount.Ativo = false;
bool inserted = shardAccount.Incluir();
if (inserted) ControladorUsuarioConta.LinkingWebAccountToShardAccount(pessoa.Usuario.ID, shardAccount.Login);
}
}
}
public static void Excluir(string login, ColecaoPersistencia colecao)
{
ObjUsuario usuario = ControladorUsuario.GetUsuarioPorLogin(login);
colecao.AdicionarItem(usuario, Persistence.Enumeradores.EnumTipoTransacao.Remover);
}
public static void Excluir(int id, ColecaoPersistencia colecao)
{
ObjShardAccount account = new ObjShardAccount(id);
colecao.AdicionarItem(account, Persistence.Enumeradores.EnumTipoTransacao.Remover);
}
/// <summary>
/// Este método irá atualizar o avatar do usuário corrente (logado). Usado apenas na troca de Avatar.
/// </summary>
public static void AtualizarAvatarUsuarioLogado(string avatar, ColecaoPersistencia colecao)
{
if (!string.IsNullOrEmpty(avatar))
{
ObjUsuario usuario = UsuarioCorrenteSingleton.Istance.Usuario;
usuario.Avatar = avatar;
colecao.AdicionarItem(usuario, Persistence.Enumeradores.EnumTipoTransacao.Alterar);
}
}
public static void Excluir(int id, ColecaoPersistencia colecao)
{
ObjShardAccount account = new ObjShardAccount(id);
colecao.AdicionarItem(account, Persistence.Enumeradores.EnumTipoTransacao.Remover);
}
/// <summary>
/// Por padrão o tipo de persistência é Normal. Executando este método você irá utilizar persistência com coleção.
/// </summary>
public void DefinirTipoPersistencia(ColecaoPersistencia colecao)
{
this._colecao = colecao;
this._tipoPersistencia = EnumTipoPersistencia.Colecao;
}
