public DataTable RealizarLogin()
{
DataTable dt = null;
try
{
con.Conectar();
string query = "SELECT * FROM funcionario WHERE emailFuncionario = '" + Email + "' AND senhaFuncionario = '" + Senha + "' ";
dt = con.RetDataTable(query);
if (dt.Rows.Count > 0)
{
Nome = dt.Rows[0]["nomeFuncionario"].ToString();
CodFuncionario = int.Parse(dt.Rows[0]["codFuncionario"].ToString());
int codTipo = int.Parse(dt.Rows[0]["tipoFuncionario"].ToString());
TipoFuncionario = (TipoFuncionario)codTipo;
}
else
{
MessageBox.Show("Email ou Senha inválido.");
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
finally
{
con.Desconectar();
}
return(dt);
}
public SmellFuncionario(TipoFuncionario tipo, double salario, string cpf)
{
_tipo = tipo;
_salario = salario;
_cpf = cpf;
Console.WriteLine("Criar Funcionário!!!");
}
private Funcionario()
{
//partial loading NH
_nome = "NH";
_nif = "123456789";
_tipoFuncionario = new TipoFuncionario(1, "Something");
}
/// <summary>
/// Monta a treeview com os módulos, já marcando o que o funcionário tem acesso
/// </summary>
protected void MontaTreeView(int idLoja, int id, Funcionario funcionario, TipoFuncionario tipoFunc)
{
// Quantidade de treeviews por linha
var qtdTrvPorLinha = 4;
// Recupera os menus do sistema
var menus = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Glass.Global.Negocios.IMenuFluxo>().ObterMenusPorConfig(idLoja);
// Recupera as funções do sistema
var funcoes = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Glass.Global.Negocios.IFuncaoFluxo>().ObterFuncoes().ToList();
var table = new Table();
table.ID = string.Format("table_{0}", id);
var tr = new TableRow();
// Para cada módulo do sistema, monta uma treeview com os menus
foreach (var menu in menus.Where(f => f.IdMenuPai.GetValueOrDefault() == 0))
{
// Cria a treeview com o nome do módulo
var trv = new TreeView();
trv.ID = string.Format("trv_{0}_{1}", menu.IdMenu, id);
trv.EnableViewState = false;
trv.NodeStyle.CssClass = "treeNode";
trv.RootNodeStyle.CssClass = "rootNode";
trv.LeafNodeStyle.CssClass = "leafNode";
trv.Attributes.Add("onclick", "OnTreeClick(event)");
// Monta a treeview
trv.Nodes.Add(PreencheNo(funcionario, tipoFunc, menus.ToList(), funcoes, menu));
// Adiciona controle em um td
if (trv.Nodes.Count > 0)
{
var td = new TableCell();
td.Style.Add("vertical-align", "top");
td.Controls.Add(trv);
tr.Cells.Add(td);
// Insere uma nova linha a cada qtdTrvPorLinha treeviews
if (tr.Cells.Count % qtdTrvPorLinha == 0)
{
table.Rows.Add(tr);
tr = new TableRow();
}
}
}
// Insere a última linha na tabela (caso não tenha completado as quatros td's para ser inserida no foreach acima)
if (tr.Cells.Count % qtdTrvPorLinha > 0)
{
table.Controls.Add(tr);
}
// Adiciona controles na tela
divMenu.Controls.Add(table);
}
public void VerificarCargos()
{
var lista = contexto;
var tipofuncionarios = new List <TipoFuncionario>();
if (!contexto.TipoFuncionarios.Any(arg => arg.DescricaoFuncionario == "PROFESSOR"))
{
var tipofuncionario = new TipoFuncionario();
tipofuncionario.DescricaoFuncionario = "PROFESSOR";
tipofuncionarios.Add(tipofuncionario);
}
if (!contexto.TipoFuncionarios.Any(arg => arg.DescricaoFuncionario == "SECRETARIO"))
{
var tipofuncionario = new TipoFuncionario();
tipofuncionario.DescricaoFuncionario = "SECRETARIO";
tipofuncionarios.Add(tipofuncionario);
}
if (!contexto.TipoFuncionarios.Any(arg => arg.DescricaoFuncionario == "DIRETOR"))
{
var tipofuncionario = new TipoFuncionario();
tipofuncionario.DescricaoFuncionario = "DIRETOR";
tipofuncionarios.Add(tipofuncionario);
}
}
public bool ValidarVeterinario(TipoFuncionario tipoFuncionario)
{
if (tipoFuncionario != TipoFuncionario.Veterinario)
{
return(false);
}
return(true);
}
public void Mapeamento_tipo_funcionario_correto()
{
var tipoFuncionario = new TipoFuncionario(100, "Teste");
new GestorTransacoesTestes().ExecutaTransacao((sess, tran) => {
new PersistenceSpecification <TipoFuncionario>(sess)
.VerifyTheMappings(tipoFuncionario);
Assert.True(true);
});
}
public ActionResult Editar(TipoFuncionario tipoFuncionario)
{
if (ModelState.IsValid)
{
_banco.Entry(tipoFuncionario).State = EntityState.Modified;
_banco.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoFuncionario));
}
public ActionResult Adicionar(TipoFuncionario novoTipoFuncionario)
{
if (ModelState.IsValid)
{
_banco.TipoFuncionarios.Add(novoTipoFuncionario);
_banco.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(novoTipoFuncionario));
}//fim adicionar
private Funcionario(TipoFuncionario tipo, string nome, decimal salario)
{
this.tipo = tipo;
this.nome = nome;
this.salario = salario;
LancarRegistrosNoBancoDeDados();
GerarDocumentosFiscais();
EnviarEmailDeBoasVindas();
}
/// <summary>
/// Inicia uma nova instância da classe <see cref="ListaDto"/>.
/// </summary>
/// <param name="tipoFuncionario">A entidade de tipos de funcionário.</param>
internal ListaDto(TipoFuncionario tipoFuncionario)
{
this.Id = tipoFuncionario.IdTipoFuncionario;
this.Descricao = tipoFuncionario.Descricao;
this.Permissoes = new PermissoesDto
{
Excluir = tipoFuncionario.TipoSistema,
LogAlteracoes = LogAlteracaoDAO.Instance.TemRegistro(Glass.Data.Model.LogAlteracao.TabelaAlteracao.TipoFuncionario, (uint)this.Id, null),
};
}
public void Modifica(ModificaDadosGeraisFuncionario comando)
{
Contract.Requires(comando != null);
if (comando.Version != _versao)
{
throw new InvalidOperationException(Msg.Objeto_modificado_por_outro_utilizador);
}
_nome = comando.Nome;
_nif = comando.Nif;
_tipoFuncionario = comando.TipoFuncionario;
}
public void Mapeamento_funcionario_correto()
{
var tipoFuncionario = new TipoFuncionario(100, "Teste");
var funcionario = Funcionario.CriaNovo(new CriaFuncionario("Luis", "123456789", tipoFuncionario, new[] { Contacto.CriaTelefone("123456789") }));
new GestorTransacoesTestes().ExecutaTransacao((sess, tran) => {
sess.Save(tipoFuncionario);
sess.Flush();
new PersistenceSpecification <Funcionario>(sess)
.VerifyTheMappings(funcionario);
Assert.True(true);
});
}
/// <summary>
/// Inicia uma nova instância da classe <see cref="ConverterCadastroAtualizacaoParaTipoFuncionario"/>.
/// </summary>
/// <param name="cadastro">O DTO de cadastro, enviado para o endpoint.</param>
/// <param name="atual">O tipo de funcionário atual (opcional), para que sejam aproveitados os valores, se necessário.</param>
public ConverterCadastroAtualizacaoParaTipoFuncionario(
CadastroAtualizacaoDto cadastro,
TipoFuncionario atual = null)
{
this.cadastro = cadastro;
this.tipoFuncionario = new Lazy <TipoFuncionario>(() =>
{
var destino = atual ?? new TipoFuncionario();
this.ConverterDtoParaModelo(destino);
return(destino);
});
}
protected Funcionario(CriaFuncionario comando)
{
Contract.Requires(comando != null);
Contract.Ensures(!string.IsNullOrEmpty(_nome));
Contract.Ensures(!string.IsNullOrEmpty(_nif));
Contract.Ensures(_tipoFuncionario != null);
Contract.Ensures(_contactos != null);
_nome = comando.Nome;
_nif = comando.Nif;
_tipoFuncionario = comando.TipoFuncionario;
_contactos = new List <Contacto>(comando.Contactos ?? Enumerable.Empty <Contacto>());
_versao = comando.Versao;
}
public static Funcionario CriarFuncionario(TipoFuncionario tipo, string nome, decimal salario)
{
switch (tipo)
{
case TipoFuncionario.Engenheiro:
return(new Engenheiro(nome, salario));
case TipoFuncionario.Vendedor:
return(new Vendedor(nome, salario));
case TipoFuncionario.Gerente:
return(new Gerente(nome, salario));
default:
throw new ArgumentException("Tipo de funcionário inválido");
}
}
public Financeiro CriarFuncionarioF(TipoFuncionario tipo)
{
switch (tipo)
{
case TipoFuncionario.Auxiliar:
return(new Financeiro(new AuxiliarFactory()));
case TipoFuncionario.Designer:
return(new Financeiro(new DesignerFactory()));
case TipoFuncionario.Diretor:
return(new Financeiro(new DiretorFactory()));
default:
throw new InvalidEnumArgumentException();
}
}
public Funcionario(DateTime dataCadastro, DateTime dataNascimento, string nome, string rg,
string telefone, string email, string senha, string endereco, string cidade, string estado,
string pais, TipoFuncionario tipoFuncionario)
{
DataCadastro = dataCadastro;
DataNascimento = dataNascimento;
Nome = nome;
Rg = rg;
Telefone = telefone;
Email = email;
Senha = senha;
Endereco = endereco;
Cidade = cidade;
Estado = estado;
Pais = pais;
TipoFuncionario = tipoFuncionario;
}
/// <summary>
/// Retorna uma lista de funcinários de acordo com o tipo passado
/// </summary>
/// <returns></returns>
public static List <SelectListItem> RetornarListaFuncionarios(TipoFuncionario tipo)
{
RequisicaoObterListaDto requisicaoDto = new RequisicaoObterListaDto()
{
CampoOrdem = "NOME",
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario,
NaoPaginarPesquisa = true,
};
if (tipo != TipoFuncionario.NaoIdentificado)
{
requisicaoDto.ListaFiltros.Add("TIPO", ((int)tipo).ToString());
}
requisicaoDto.ListaFiltros.Add("INATIVO", "false");
FuncionarioBll funcionarioBll = new FuncionarioBll(false);
RetornoObterListaDto <FuncionarioDto> retornoDto = new RetornoObterListaDto <FuncionarioDto>();
if (!funcionarioBll.ObterListaFiltrada(requisicaoDto, ref retornoDto))
{
return(null);
}
List <SelectListItem> listaRetorno = new List <SelectListItem>();
listaRetorno.Add(new SelectListItem()
{
Value = "null",
Text = "Todos"
});
foreach (var func in retornoDto.ListaEntidades)
{
listaRetorno.Add(new SelectListItem()
{
Value = func.Id.ToString(),
Text = func.Nome
});
}
return(listaRetorno);
}
public void Testa_mapemento_funcionar()
{
new AuxiliarTransacao().ExecutaTransacao((sess, tran) => {
var tipo = new TipoFuncionario {
Id = 100, Descricao = "teste"
};
sess.Save(tipo);
var func = new Funcionario {
Contactos = new[] { new Contacto {
TipoContacto = TipoContacto.Email, Valor = "*****@*****.**"
} },
Nif = "123456789",
Nome = "Luis",
TipoFuncionario = tipo
};
new PersistenceSpecification <Funcionario>(sess)
.VerifyTheMappings(func);
});
}
/// <summary>
/// Preenche um nó da treeview
/// </summary>
/// <param name="nodePai"></param>
/// <param name="funcionario"></param>
/// <param name="menusModulo"></param>
/// <param name="funcoes"></param>
/// <param name="menu"></param>
private TreeNode PreencheNo(Funcionario funcionario, TipoFuncionario tipoFunc, List <Glass.Global.Negocios.Entidades.Menu> menusModulo, List <FuncaoMenu> funcoes, Glass.Global.Negocios.Entidades.Menu menu)
{
var node = new TreeNode(menu.Nome);
node.Value = string.Format("m|{0}", menu.IdMenu.ToString());
node.SelectAction = TreeNodeSelectAction.Expand;
node.Expanded = false;
CriaFuncoes(ref node, funcionario, tipoFunc, funcoes, menu);
// Cria os filhos deste menu
CriaItensTreeView(ref node, funcionario, tipoFunc, menu, menusModulo, funcoes);
if (UserInfo.GetUserInfo.IsAdministrador)
{
node.ImageUrl = "~/Images/Menu.png";
node.ShowCheckBox = funcionario == null || funcionario.TipoFuncionario.IdTipoFuncionario != (int)Data.Helper.Utils.TipoFuncionario.MarcadorProducao;
// Verifica se o usuário possui acesso à este menu
if (funcionario != null)
{
node.Checked = funcionario.ConfigsMenuFunc.Any(f => f.IdMenu == menu.IdMenu);
}
else
{
node.Checked = tipoFunc.ConfigsMenuTipoFunc.Any(f => f.IdMenu == menu.IdMenu);
}
}
else
{
// Verifica se o funcionário/tipo possui acesso à esta função
if (funcionario != null)
{
node.ImageUrl += funcionario.ConfigsMenuFunc.Any(f => f.IdMenu == menu.IdMenu) ? "~/Images/validacao.gif" : "";
}
else
{
node.ImageUrl += tipoFunc.ConfigsMenuTipoFunc.Any(f => f.IdMenu == menu.IdMenu) ? "~/Images/validacao.gif" : "";
}
}
return(node);
}
internal CriaFuncionario(string nome, string nif, TipoFuncionario tipoFuncionario, IEnumerable <Contacto> contactos, int versao)
{
Contract.Requires(!string.IsNullOrEmpty(nome), Msg.String_nao_pode_ser_nula);
Contract.Requires(!string.IsNullOrEmpty(nif), Msg.String_nao_pode_ser_nula);
Contract.Requires(tipoFuncionario != null, Msg.Tipo_funcionario_tem_de_ser_definido);
Contract.Requires(versao >= 0, Msg.Numero_superior_0);
Contract.Ensures(!string.IsNullOrEmpty(_nome), Msg.String_nao_pode_ser_nula);
Contract.Ensures(!string.IsNullOrEmpty(_nif), Msg.String_nao_pode_ser_nula);
Contract.Ensures(_tipoFuncionario != null, Msg.Tipo_funcionario_tem_de_ser_definido);
Contract.Ensures(_versao >= 0, Msg.Numero_superior_0);
if (!VerificadorNif.NifValido(nif))
{
throw new InvalidOperationException(Msg.Nif_invalido);
}
_nome = nome;
_nif = nif;
_tipoFuncionario = tipoFuncionario;
_contactos = contactos;
_versao = versao;
}
/// <summary>
/// Adiciona as funções que este menu possui como filhas do mesmo
/// </summary>
/// <param name="node"></param>
/// <param name="funcionario"></param>
/// <param name="tipoFunc"></param>
/// <param name="funcoes"></param>
/// <param name="menu"></param>
private void CriaFuncoes(ref TreeNode node, Funcionario funcionario, TipoFuncionario tipoFunc, List <FuncaoMenu> funcoes, Glass.Global.Negocios.Entidades.Menu menu)
{
var funcoesMenu = funcoes.Where(f => f.IdMenu == menu.IdMenu);
foreach (var funcao in funcoesMenu)
{
var nodeFuncao = new TreeNode(funcao.Descricao);
nodeFuncao.Value = string.Format("f|{0}", funcao.IdFuncaoMenu.ToString());
nodeFuncao.SelectAction = TreeNodeSelectAction.None;
if (UserInfo.GetUserInfo.IsAdministrador)
{
nodeFuncao.ShowCheckBox = true;
nodeFuncao.ImageUrl = "~/Images/gear.gif";
// Verifica se o funcionário/tipo possui acesso à esta função
if (funcionario != null)
{
nodeFuncao.Checked = funcionario.ConfigsFuncaoFunc.Any(f => f.IdFuncaoMenu == funcao.IdFuncaoMenu);
}
else
{
nodeFuncao.Checked = tipoFunc.ConfigsFuncaoTipoFunc.Any(f => f.IdFuncaoMenu == funcao.IdFuncaoMenu);
}
}
else
{
// Verifica se o funcionário/tipo possui acesso à esta função
if (funcionario != null)
{
nodeFuncao.ImageUrl += funcionario.ConfigsFuncaoFunc.Any(f => f.IdFuncaoMenu == funcao.IdFuncaoMenu) ? "~/Images/validacao.gif" : "";
}
else
{
nodeFuncao.ImageUrl += tipoFunc.ConfigsFuncaoTipoFunc.Any(f => f.IdFuncaoMenu == funcao.IdFuncaoMenu) ? "~/Images/validacao.gif" : "";
}
}
node.ChildNodes.Add(nodeFuncao);
}
}
public void Mapeamento_funcionario_correto()
{
var tipoFuncionario = new TipoFuncionario(100, "Teste");
var funcionario = new FuncionarioDto {
Id = 1,
Contactos = new List <Contacto> {
Contacto.CriaExtensao("1234")
},
Nif = "123456789",
Nome = "Luis",
TipoFuncionario = tipoFuncionario
};
new GestorTransacoesTestes().ExecutaTransacao((sess, tran) => {
sess.Save(tipoFuncionario);
sess.Flush();
new PersistenceSpecification <FuncionarioDto>(sess)
.VerifyTheMappings(funcionario);
Assert.True(true);
});
}
//_____________________________________________
public void SetTipoFuncionario(TipoFuncionario TipoFuncionario)
{
try
{
this.TipoFuncionario = (TipoFuncionario)SecureValidationsFuncionario.ValidationsTipoFuncionario(Convert.ToInt32(TipoFuncionario));
}
catch (FormatException ex)
{
throw new FormatException(nameof(ex.Message));
}
catch (InvalidCastException ex)
{
throw new InvalidCastException(nameof(ex.Message));
}
catch (OverflowException ex)
{
throw new OverflowException(nameof(ex.Message));
}
catch (Exception ex)
{
throw new Exception(nameof(ex.Message));
}
}
public Funcionario(TipoFuncionario tipo, string nome, decimal salario)
{
this.tipo = tipo;
this.nome = nome;
this.salario = salario;
LancarRegistrosNoBancoDeDados();
GerarDocumentosFiscais();
EnviarEmailDeBoasVindas();
switch (tipo)
{
case TipoFuncionario.Vendedor:
GerarRegistroDeComissao();
break;
case TipoFuncionario.Gerente:
GerarRegistroDeBonus();
break;
default:
break;
}
}
public ModificaDadosGeraisFuncionario(int id, int version, string nome, string nif, TipoFuncionario tipoFuncionario)
{
Contract.Requires(id > 0);
Contract.Requires(version > 0);
Contract.Requires(!string.IsNullOrEmpty(nome));
Contract.Requires(!string.IsNullOrEmpty(nif));
Contract.Requires(tipoFuncionario != null);
Contract.Ensures(_id > 0);
Contract.Ensures(_version > 0);
Contract.Ensures(!string.IsNullOrEmpty(_nome));
Contract.Ensures(!string.IsNullOrEmpty(_nif));
Contract.Ensures(_tipoFuncionario != null);
if (!VerificadorNif.NifValido(nif))
{
throw new InvalidOperationException(Msg.Nif_invalido);
}
_id = id;
_version = version;
_nome = nome;
_nif = nif;
_tipoFuncionario = tipoFuncionario;
}
private void ConverterDtoParaModelo(TipoFuncionario destino)
{
destino.Descricao = this.cadastro.ObterValorNormalizado(c => c.Descricao, destino.Descricao);
}
public ActionResult Editar(long id)
{
TipoFuncionario tipofuncionario = _banco.TipoFuncionarios.Find(id);
return(View(tipofuncionario));
}
public Funcionario(int id, TipoFuncionario tipoFuncionario, Usuario usuario)
{
Id = id;
TipoFuncionario = tipoFuncionario;
Usuario = usuario;
}
