Example #1
0
        public void IncluirVoto(Entidade.Voto lVoto)
        {
            using (SqlConnection con = new SqlConnection(connectionString))
            {
                StringBuilder sqlQuery = new StringBuilder();
                sqlQuery.Append("INSERT INTO Voto (");
                sqlQuery.Append("   CodigoFilme");
                sqlQuery.Append("  ,CodigoEmocao");
                sqlQuery.Append("  ,Valor");
                sqlQuery.Append("  ,Data");
                sqlQuery.Append(" ) VALUES ( ");
                sqlQuery.Append("   @CodigoFilme");
                sqlQuery.Append("  ,@CodigoEmocao");
                sqlQuery.Append("  ,@Valor");
                sqlQuery.Append("  ,@Data");
                sqlQuery.Append(") ");

                con.Open();
                using (SqlCommand command = new SqlCommand(sqlQuery.ToString(), con))
                {
                    command.Parameters.Add(new SqlParameter("@CodigoFilme", lVoto.CodigoFilme));
                    command.Parameters.Add(new SqlParameter("@CodigoEmocao", lVoto.CodigoEmocao));
                    command.Parameters.Add(new SqlParameter("@Valor", lVoto.Valor));
                    command.Parameters.Add(new SqlParameter("@Data", lVoto.Data));
                    command.ExecuteNonQuery();
                }
                con.Close();
            }
        }
Example #2
0
        public void IncluirFilme(Entidade.Filme lFilme)
        {
            using (SqlConnection con = new SqlConnection(connectionString))
            {
                StringBuilder sqlQuery = new StringBuilder();
                sqlQuery.Append("INSERT INTO Filme (");
                sqlQuery.Append("   Codigo");
                sqlQuery.Append("  ,Nome");
                sqlQuery.Append("  ,Capa");
                sqlQuery.Append(" ) VALUES ( ");
                sqlQuery.Append("   @Codigo");
                sqlQuery.Append("  ,@Nome");
                sqlQuery.Append("  ,@Capa");
                sqlQuery.Append(") ");

                con.Open();
                using (SqlCommand command = new SqlCommand(sqlQuery.ToString(), con))
                {
                    command.Parameters.Add(new SqlParameter("@Codigo", lFilme.Codigo));
                    command.Parameters.Add(new SqlParameter("@Nome", lFilme.Nome));
                    command.Parameters.Add(new SqlParameter("@Capa", lFilme.Capa));
                    command.ExecuteNonQuery();
                }
                con.Close();
            }
        }
Example #3
0
        public static void IncluirVoto(Entidade.Voto lVoto){
            //Incluir filme caso nao exista no banco
            if (!NG.Filme.ExisteFilme(lVoto.Filme))
                NG.Filme.IncluirFilme(lVoto.Filme);

            DB.Voto dbVoto = new DB.Voto();
            dbVoto.IncluirVoto(lVoto);
        }
Example #4
0
 public Voto(Entidade.Filme lFilme = null, Entidade.Emocao lEmocao = null, int? lValor = null)
 {
     if (lFilme != null && lEmocao != null && lValor != null)
     {
         CodigoFilme = lFilme.Codigo;
         Filme = lFilme;
         CodigoEmocao = lEmocao.Codigo;
         Emocao = lEmocao;
         Valor = (int)lValor;
         Data = DateTime.Now;
     }
 }
Example #5
0
 public static bool ExisteFilme(Entidade.Filme lFilme)
 {
     DB.Filme dbFilme = new DB.Filme();
     if (dbFilme.ObterFilme(lFilme.Codigo) == null)
     {
         //Nao Existe Filme
         return false;
     }
     else
     {
         //Existe Filme
         return true;
     }
 }
        public void AdicionarOuEditarCliente(Entidade.Cliente cliente)
        {
            cliente.ChecarCliente();

            if (cliente.ID == 0)
            {
                _cliRep.Adicionar(cliente);
                if (cliente.Foto.Binario.Length == 0)
                    cliente.Foto = null;
            }
            else
                _cliRep.Atualizar(cliente);

            _cliRep.Salvar();
        }
Example #7
0
 public bool Incluir(Entidade.Grupo ObjGrupo)
 {
     using (ISession session = NHibernateHelper.OpenSession())
         using (ITransaction transaction = session.BeginTransaction())
         {
             try
             {
                 session.Save(ObjGrupo);
                 transaction.Commit();
             }
             catch (Exception ex)
             {
                 throw new Exception(ex.Message.ToString());
             }
         }
     return true;
 }
Example #8
0
        public void IncluirEmocao(Entidade.Emocao lEmocao)
        {
            using (SqlConnection con = new SqlConnection(connectionString))
            {
                StringBuilder sqlQuery = new StringBuilder();
                sqlQuery.Append("INSERT INTO Emocao (");
                sqlQuery.Append("   Codigo");
                sqlQuery.Append("  ,Descricao");
                sqlQuery.Append(" ) VALUES ( ");
                sqlQuery.Append("   @Codigo");
                sqlQuery.Append("  ,@Descricao");
                sqlQuery.Append(") ");

                con.Open();
                using (SqlCommand command = new SqlCommand(sqlQuery.ToString(), con))
                {
                    command.Parameters.Add(new SqlParameter("@Codigo", lEmocao.Codigo));
                    command.Parameters.Add(new SqlParameter("@Descricao", lEmocao.Descricao));
                    command.ExecuteNonQuery();
                }
                con.Close();
            }
        }
Example #9
0
 public Guid Inserir(Entidade categoria)
 {
     throw new NotImplementedException();
 }
Example #10
0
 public FrmLancamento(Entidade _entidade)
 {
     InitializeComponent();
     entidade = _entidade;
 }
 public void Remover(Entidade obj)
 {
     contexto.RS_Entidade.Remove(obj);
     contexto.SaveChanges();
 }
 public void Adicionar(Entidade obj)
 {
     contexto.RS_Entidade.Add(obj);
     contexto.SaveChanges();
 }
Example #13
0
 public FrmRelatorios(Entidade _entidade)
 {
     InitializeComponent();
     entidade = _entidade;
 }
 public void QuandoSalvoNoBancoComNome(string nomeArquivo)
 {
     var entidade = new Entidade { Id = 1, NomeArquivo = nomeArquivo, Arquivo = arquivo };
     collection.Save(entidade);
 }
 protected virtual void PersistirEntidade(Entidade entidade)
 {
     PersistirEntidades(new[] { entidade });
 }
Example #16
0
        public static string btnLogin_Click(string txtLogin, string txtSenha, string ddlEstabelecimento, string w, string h)
        {
            Login    paglogin        = new Login();
            Usuario  usuario         = new Usuario();
            Entidade entidade        = new Entidade();
            Entidade estabelecimento = new Entidade();
            Comanda  comanda         = new Comanda();

            usuario.Login        = txtLogin;
            usuario.Senha        = txtSenha;
            estabelecimento.Nome = ddlEstabelecimento;

            int width  = Convert.ToInt32(w);
            int height = Convert.ToInt32(h);

            var result = paglogin.repUsuario.Select_Usuario(usuario);

            if (result != null)
            {
                foreach (DataRow item in result.Rows)
                {
                    usuario.id_Usuario = Convert.ToInt32(item["id_Usuario"]);
                    usuario.ic_Ativo   = Convert.ToByte(item["ic_Ativo"]);
                    usuario.id_Tipo    = Convert.ToInt32(item["id_Tipo"]);
                    usuario.Senha      = item["Senha"].ToString();
                    entidade.Nome      = item["Nome"].ToString();
                }
                var senha = paglogin.criptografia.Criptografar(txtSenha.ToUpper());

                if (usuario != null)
                {
                    if (usuario.Senha == senha && usuario.ic_Ativo == 1)
                    {
                        entidade.CNPJ_CPF = paglogin.bancoTools.retornaCampo("CNPJ_CPF", "Entidade", "join Usuario on Usuario.id_Entidade = Entidade.id_Entidade", "Usuario.Login = '******' and Usuario.Senha = '" + senha + "'");
                        paglogin.repEntidade.Select_Entidade(entidade);
                        HttpContext.Current.Session["Objentidade"] = entidade;
                        HttpContext.Current.Session["Objusuario"]  = usuario;

                        if (usuario.id_Tipo == 1)
                        {
                            if (width < 490)
                            {
                                estabelecimento.id_Entidade = paglogin.bancoTools.retornaId("Entidade", "Nome", "'" + estabelecimento.Nome + "'", "id_Entidade");
                                HttpContext.Current.Session["Objestabelecimento"] = estabelecimento;
                                //var verificaComanda = paglogin.bancoTools.checa_existe("Comanda", "id_Entidade", entidade.id_Entidade + " and and ic_Status = 1");
                                var verificaComanda = paglogin.bancoTools.checa_existe("Comanda as C join Mesa as M on M.id_Mesa = C.id_Mesa ", "C.id_Entidade", entidade.id_Entidade + " and M.id_Entidade = " + estabelecimento.id_Entidade + " and C.ic_Status = 1");
                                if (verificaComanda.Rows.Count > 0)
                                {
                                    foreach (DataRow item in verificaComanda.Rows)
                                    {
                                        comanda.id_Comanda  = Convert.ToInt32(item["id_Comanda"]);
                                        comanda.id_Entidade = Convert.ToInt32(item["id_Entidade"]);
                                        comanda.id_Mesa     = Convert.ToInt32(item["id_Mesa"]);
                                        comanda.nm_Comanda  = item["nm_Comanda"].ToString();
                                        comanda.ic_Status   = Convert.ToByte(item["ic_Status"]);
                                        comanda.DataHora    = Convert.ToDateTime(item["DataHora"]);
                                    }
                                    HttpContext.Current.Session["Objcomanda"] = comanda;
                                }
                                return("cliente");
                            }
                            else
                            {
                                return("Acessivel apenas em dispositivos mobile!");
                            }
                        }
                        else if (usuario.id_Tipo == 2)
                        {
                            if (width > 490)
                            {
                                if (entidade.Nome == ddlEstabelecimento)
                                {
                                    return("empresa");
                                }
                                else
                                {
                                    return("Senha ou entidade errada.");
                                }
                            }
                            else
                            {
                                return("Acessivel somente em PCs");
                            }
                        }
                        else if (usuario.id_Tipo == 3)
                        {
                            if (width > 490)
                            {
                                return("cozinha");
                            }
                            else
                            {
                                return("Acessivel somente em PCs");
                            }
                        }
                    }
                    else
                    {
                        return("Usuário ou senha inválida.");
                    }
                }
            }
            else
            {
                return("Usuário nao cadastrado.");
            }
            return("");
        }
        // GET: ParticiparCampanha
        public ActionResult Index()
        {
            //conexoes com o banco
            VinculoAfinidadeDao  vinculoafinidadedao  = new VinculoAfinidadeDao();
            ParticipaCampanhaDao participacampanhadao = new ParticipaCampanhaDao();

            //Instanciando as listas
            IList <Campanha> campanhasdisponiveis   = new List <Campanha>();
            IList <Campanha> campanhasparticipantes = new List <Campanha>();

            //verifica se é entidade ou voluntario para preenche as campanhas participantes e disponiveis
            if (Session["Entidade"] != null)
            {
                Entidade          entidadesessao = (Entidade)Session["Entidade"];
                IList <Afinidade> afinidades     = vinculoafinidadedao.BuscaAfinidadesporEntidade(entidadesessao);
                IList <Campanha>  campanhas      = vinculoafinidadedao.BuscaCampanhaporAfinidades(afinidades);

                foreach (var campanha in campanhas)
                {
                    //Verifica se participa ou nao da campanha para preencher a lista correspondente
                    if (participacampanhadao.ParticipodaCampanha(campanha, entidadesessao))
                    {
                        campanhasparticipantes.Add(campanha);
                    }
                    else
                    {
                        campanhasdisponiveis.Add(campanha);
                    }
                }
            }
            else if (Session["Voluntario"] != null)
            {
                Voluntario        voluntariosessao = (Voluntario)Session["Voluntario"];
                IList <Afinidade> afinidades       = vinculoafinidadedao.BuscaAfinidadesporVoluntario(voluntariosessao);
                IList <Campanha>  campanhas        = vinculoafinidadedao.BuscaCampanhaporAfinidades(afinidades);

                foreach (var campanha in campanhas)
                {
                    //Verifica se participa ou nao da campanha para preencher a lista correspondente
                    if (participacampanhadao.ParticipodaCampanha(campanha, voluntariosessao))
                    {
                        campanhasparticipantes.Add(campanha);
                    }
                    else
                    {
                        campanhasdisponiveis.Add(campanha);
                    }
                }
            }


            if (campanhasdisponiveis.Count() > 0)
            {
                ViewBag.CampanhasDisponiveis = campanhasdisponiveis;
            }

            if (campanhasparticipantes.Count > 0)
            {
                ViewBag.CampanhasParticipantes = campanhasparticipantes;
            }


            return(View());
        }
Example #18
0
 public GeradorDAO(SistemaEntidade sistema, ProjetoEntidade projeto, Entidade entidade, List <EntidadeConsulta> consultas)
 {
     Sistema   = sistema;
     Entidade  = entidade;
     Consultas = consultas;
 }
Example #19
0
        public void CarregarDadosRME(int pRegistroManutencaoID)
        {
            using (UnitOfWork oUnitOfWork = new UnitOfWork())
            {
                RegistroManutencao _RegistroManutencao = oUnitOfWork.RegistroManutencaoREP.BuscarPorID(pRegistroManutencaoID);
                if (_RegistroManutencao == null)
                {
                    Utils.Notificar(ntfGeral, "Registro de Manutenção de Equipamento não encontrado", Enums.TipoNotificacao.Alerta);
                    return;
                }

                Equipamento _Equipamento = oUnitOfWork.EquipamentoREP.BuscarPorID(_RegistroManutencao.EquipamentoID);

                txtEquipamento.Text    = _Equipamento.NumeroSerie;
                txtEquipamento.Visible = true;
                ddlEquipamento.Visible = false;
                rfvEquipamento.Enabled = false;

                CarregarDadosEquipamento(oUnitOfWork, _Equipamento);

                ddlManutencaoTipo.Enabled = false;

                ddlManutencaoTipo.SelectedValue = _RegistroManutencao.ManutencaoTipoID.ToString();

                AlterarTipoManutencao(_RegistroManutencao.ManutencaoTipoID);

                RegistroManutencaoArquivo _registroManutencaoArquivo = oUnitOfWork.RegistroManutencaoArquivoREP.BuscarPorID(_RegistroManutencao.RegistroManutencaoID);

                if (_registroManutencaoArquivo != null)
                {
                    string caminhoArquivo = Server.MapPath(_registroManutencaoArquivo.ArquivoUrl);
                    if (File.Exists(caminhoArquivo))
                    {
                        btnCalibracaoUpload.ImageUrl = _registroManutencaoArquivo.ArquivoUrl;
                        btnCalibracaoUpload.Visible  = true;
                    }
                }

                ddlStatus.SelectedValue = _RegistroManutencao.ManutencaoStatusID.ToString();

                lblIdentificador.Text          = string.Format("{0:0000}", _RegistroManutencao.RegistroManutencaoID);
                txtDataRealizacao.SelectedDate = _RegistroManutencao.DataRealizacao;
                txtDataRealizacao.Enabled      = false;

                Entidade oExecutor = oUnitOfWork.EntidadeREP.BuscarPorID(_RegistroManutencao.ExecutorID);
                ddlExecutor.Items.Add(new RadComboBoxItem(oExecutor.Nome, oExecutor.EntidadeID.ToString()));
                ddlExecutor.SelectedValue = oExecutor.EntidadeID.ToString();

                Entidade oAprovador = oUnitOfWork.EntidadeREP.BuscarPorID(_RegistroManutencao.AprovadorID);
                ddlAprovador.Items.Add(new RadComboBoxItem(oAprovador.Nome, oAprovador.EntidadeID.ToString()));
                ddlAprovador.SelectedValue = oAprovador.EntidadeID.ToString();

                txtRelatorioTecnico.Text = _RegistroManutencao.RelatorioDescricao;
                txtDefeito.Text          = _RegistroManutencao.DefeitoDescricao;

                if (ddlStatus.SelectedItem.Text == "Finalizado")
                {
                    AlterarControlesFinalizacao();
                }
            }
        }
Example #20
0
 public abstract Resultado ValidaEntidade(Entidade entidade);
Example #21
0
 /// <summary>
 /// Calcula a distância entre dos pontos usando teorema de pitágoras.
 /// </summary>
 /// <param name="ent1">Primeira entidade de comparação.</param>
 /// <param name="ent2">Segunda entidade de comparação.</param>
 /// <returns>Distância resultante entre os dois pontos.</returns>
 public static double DistanciaPontos(Entidade ent1, Entidade ent2)
 {
     return(Math.Sqrt((Math.Pow((ent2.Coordenadas.X - ent1.Coordenadas.X), 2) + Math.Pow((ent2.Coordenadas.Y - ent1.Coordenadas.Y), 2))));
 }
Example #22
0
 public GeradorProxy(SistemaEntidade sistema, Entidade entidade)
 {
     Sistema  = sistema;
     Entidade = entidade;
 }
Example #23
0
        public static Dados.Entidades.Usuario ToUsuario(this Entidade ent)
        {
            Usuario user = (Usuario)ent;

            return(user);
        }
 public UsuarioRepositorio()
 {
     Entidade.Add(new Usuario("admin", "admin"));
 }
Example #25
0
 internal static Produto ToProduto(this Entidade prod)
 {
     return((Produto)prod);
 }
Example #26
0
        public bool Enviar(Entidade entidade_novo, DataTable retorno)
        {
            BancoTools banco = new BancoTools();

            if (retorno.Rows.Count > 0)
            {
                Entidade entidade_antigo = new Entidade();

                foreach (DataRow row in retorno.Rows)
                {
                    entidade_antigo.id_Entidade = Convert.ToInt32(row["id_Entidade"]);
                    entidade_antigo.id_Tipo     = Convert.ToInt32(row["id_Tipo"]);
                    entidade_antigo.Logradouro  = row["Logradouro"].ToString();
                    entidade_antigo.Nome        = row["Nome"].ToString();
                    entidade_antigo.Numero      = row["Numero"].ToString();
                    entidade_antigo.Pais        = row["Pais"].ToString();
                    entidade_antigo.RazaoSocial = row["RazaoSocial"].ToString();
                    entidade_antigo.Telefone    = Convert.ToInt64(row["Telefone"]);
                    entidade_antigo.Estado      = row["Estado"].ToString();
                    entidade_antigo.Email       = row["Email"].ToString();
                    entidade_antigo.Complemento = row["Complemento"].ToString();
                    entidade_antigo.CNPJ_CPF    = row["CNPJ_CPF"].ToString();
                    entidade_antigo.Cidade      = row["Cidade"].ToString();
                    entidade_antigo.CEP         = row["CEP"].ToString();
                    entidade_antigo.Bairro      = row["Bairro"].ToString();
                }

                dynamic[,] resultado = banco.compara_objetos(entidade_novo, entidade_antigo);
                string tabela = "Entidade";
                if (resultado[0, 0] == true)
                {
                    var query = banco.monta_update(resultado[0, 1], tabela, resultado[0, 2]);
                    banco.ExecuteNonQuery(query);
                }
                return(false);
            }
            else
            {
                var query = "insert into Entidade values (@Tipo,'@Nome','@RazaoSocial','@CNPJCPF',@Telefone," +
                            "'@Cidade','@Estado','@Pais','@Logradouro','@Bairro'," +
                            "'@Complemento','@Numero','@CEP','@Email')";

                query = query.Replace("@Tipo", entidade_novo.id_Tipo.ToString())
                        .Replace("@Nome", entidade_novo.Nome)
                        .Replace("@RazaoSocial", entidade_novo.RazaoSocial)
                        .Replace("@CNPJCPF", entidade_novo.CNPJ_CPF)
                        .Replace("@Telefone", entidade_novo.Telefone.ToString())
                        .Replace("@Cidade", entidade_novo.Cidade)
                        .Replace("@Estado", entidade_novo.Estado)
                        .Replace("@Pais", entidade_novo.Pais)
                        .Replace("@Logradouro", entidade_novo.Logradouro)
                        .Replace("@Bairro", entidade_novo.Bairro.ToString())
                        .Replace("@Complemento", entidade_novo.Complemento.ToString())
                        .Replace("@Numero", entidade_novo.Numero)
                        .Replace("@CEP", entidade_novo.CEP)
                        .Replace("@Email", entidade_novo.Email);

                try
                {
                    banco.ExecuteNonQuery(query);
                    return(true);
                }
                catch (Exception)
                {
                    return(false);
                }
            }
        }
Example #27
0
 //Método para fazer login
 private void btnLogin_Click_1(object sender, EventArgs e)
 {
     if ((txtUsuario.Text == "adm") && (txtSenha.Text == "12345"))
     {
         //Instanciando e mostrando a tela
         frmAdm admtela = new frmAdm()
         {
             telaprincipal = this
         };
         this.Hide();
         admtela.Show();
     }
     else
     {
         try
         {
             //Verificando o preenchimento do campo USUÁRIO
             if (txtUsuario.Text == "")
             {
                 MessageBox.Show("Preencha o campo Usuário!");
                 txtUsuario.Focus();
                 lblMensagem.Text = null;
                 return;
             }
             //Verificando o preenchimento do campo SENHA
             if (txtSenha.Text == "")
             {
                 MessageBox.Show("Preencha o campo Senha!");
                 txtSenha.Focus();
                 lblMensagem.Text = null;
                 return;
             }
             //Instanciando classes
             Entidade obj  = new Entidade();
             BD       cont = new BD();
             //Atribuiu o campo ao objeto
             obj.Usuario = txtUsuario.Text;
             obj.Senha   = txtSenha.Text;
             //Atribuição do método ao objeto
             obj = new BD().Login(obj);
             //Verificação da existência do usuário
             if (obj.Usuario == null)
             {
                 lblMensagem.Text      = "Usuário ou/e senha incorretos!";
                 lblMensagem.ForeColor = Color.Red;
                 //Limpando os campos
                 txtUsuario.Clear();
                 txtSenha.Clear();
                 txtUsuario.Focus();
                 return;
             }
             else
             {
                 //Instanciando a classe
                 var aux = new frmPerfilCliente(txtUsuario.Text);
                 //Limpando campos e fazendo o focus
                 txtUsuario.Clear(); txtUsuario.Focus();
                 txtSenha.Clear();
                 this.Hide();
                 aux.Show();
             }
         }
         catch (Exception ex)
         {
             MessageBox.Show("Erro ao logar: " + ex.Message);
         }
     }
 }
 public void Atualizar(Entidade obj)
 {
     contexto.RS_Entidade.Update(obj);
     contexto.SaveChanges();
 }
Example #29
0
        /// <summary>
        /// metodo localiza a variavel Output Global e seus filhos diretos
        /// </summary>
        /// <param name="entidade"></param>
        /// <returns></returns>
        public void SegmentarEntidade(Entidade entidade)
        {
            VariavelBLL        oVariavel             = new VariavelBLL();
            EntidadeBLL        oEntidade             = new EntidadeBLL();
            RegraLogicaBLL     oRegraLogica          = new RegraLogicaBLL();
            Variavel           dadosVariavelLista    = new Variavel();
            Segmento           dadosSeguimento       = new Segmento();
            RegraLogica        dadosRegraLogica      = new RegraLogica();
            List <RegraLogica> dadosRegraLogicaLista = new List <RegraLogica>();

            //retorna a variavel OutputGlobal
            dadosVariavelLista = oVariavel.ListarOutputGlobal(entidade.Variavel);
            //retorna lista de filhos do OutputGlobal
            //dadosVariavelLista = oVariavel.ListarRelacao(dadosVariavelLista);

            //retorna Critérios das variaveis recursivamente
            for (int i = 0; i < dadosVariavelLista.VariavelFilho.Count; i++)
            {
                //Variavel com Tipo de dado Importado
                if (dadosVariavelLista.VariavelFilho[i].TipoDadoVariavel.IDTipoDadoVariavel == 1)
                {
                    entidade.Variavel.IDVariavel = dadosVariavelLista.VariavelFilho[i].IDVariavel;
                    entidade = oEntidade.ListarVariavel(entidade);
                    if (entidade.Variavel.Criterio.IDCriterio != 0)
                    {
                        dadosVariavelLista.VariavelFilho[i].Criterio.IDCriterio = entidade.Variavel.Criterio.IDCriterio;
                    }
                    else
                    {
                        dadosVariavelLista.VariavelFilho[i].Criterio.Valor = entidade.Variavel.Criterio.Valor;
                    }
                }
                //Variavel com Tipo de dado Deduzido ou Calculo
                else
                {
                    //Recursivamente Procura Filhos e seus criterios
                    dadosVariavelLista.VariavelFilho[i].Criterio = RetornaCriterio(dadosVariavelLista.VariavelFilho[i], entidade);
                }
            }

            dadosRegraLogica.Variavel = entidade.Variavel;
            //carrega todas as regras logicas do OutputGlobal
            dadosRegraLogicaLista = oRegraLogica.ListarPorVariavel(dadosRegraLogica);

            //percorre a lista de regra logica até encontrar a regra válida
            for (int i = 0; i < dadosRegraLogicaLista.Count; i++)
            {
                for (int j = 0; j < dadosVariavelLista.VariavelFilho.Count; j++)
                {
                    dadosVariavelLista.VariavelFilho[j].RegraLogica.IdRegraLogica = dadosRegraLogicaLista[i].IdRegraLogica;
                    //testa Variaveis para encontrar a regra lógica válida
                    dadosVariavelLista.VariavelFilho[j].RegraLogica = oRegraLogica.ValidarVariavel(dadosVariavelLista.VariavelFilho[j]);
                    //Regra Lógica falsa interrompe o laço
                    if (dadosVariavelLista.VariavelFilho[j].RegraLogica.Valido == false)
                    {
                        break;
                    }

                    //Regra lógica válida prepara o critério para retorno
                    else if (j + 1 == dadosVariavelLista.VariavelFilho.Count)
                    {
                        //Consome a Regra Logica
                        entidade.Segmento.RegraLogica.IdRegraLogica = dadosRegraLogicaLista[i].IdRegraLogica;
                        //Retorna Segmento basiado na Regra Logica
                        entidade.Segmento = ListarRegraLogica(entidade.Segmento);
                        //Cadastra a Entidade em um Segmento
                        NovaEntidade(entidade.Segmento);
                        //Incrementa o tamanho do mercado de um segmento
                        ControleTamanhoMercado(entidade.Segmento);
                        return;
                    }
                }
            }
        }
Example #30
0
        private void SalvarDadosBasicosEntidade()
        {
            using (UnitOfWork oUnitOfWork = new UnitOfWork())
            {
                try
                {
                    Entidade _entidade;

                    // Inserção
                    if (string.IsNullOrEmpty(Request["EntidadeID"]))
                    {
                        _entidade                  = new Entidade();
                        _entidade.Rowguid          = SequentialGuid.NewGuid();
                        _entidade.DataCriacao      = DateTime.Now;
                        _entidade.UsuarioCriadorID = int.Parse(Session["ssnLoggedUserID"].ToString());
                        _entidade.Inativo          = chkIsInativo.Checked;

                        _entidade.EntidadeTipoID = int.Parse(ddlTipoEntidade.SelectedValue);
                        if (rbtPessoaFisica.Checked)
                        {
                            _entidade.CPF        = txtCPF.Text;
                            _entidade.CNPJ       = null;
                            _entidade.TipoPessoa = rbtPessoaFisica.Value;
                            _entidade.Nome       = txtNome.Text.Trim();
                            _entidade.Apelido    = txtApelido.Text.Trim();
                        }
                        else
                        {
                            _entidade.CNPJ       = txtCNPJ.Text;
                            _entidade.CPF        = null;
                            _entidade.TipoPessoa = rbtPessoaJuridica.Value;
                            _entidade.Nome       = txtRazaoSocial.Text.Trim();
                            _entidade.Apelido    = txtFantasia.Text.Trim();
                        }
                        _entidade.DataNascimento       = txtDataNascimento.SelectedDate;
                        _entidade.DataModificacao      = DateTime.Now;
                        _entidade.UsuarioModificadorID = int.Parse(Session["ssnLoggedUserID"].ToString());
                        _entidade.Observacao           = txtObservacao.Text;

                        oUnitOfWork.EntidadeREP.Adicionar(_entidade);
                    }
                    // Atualização
                    else
                    {
                        _entidade                = oUnitOfWork.EntidadeREP.BuscarPorID(int.Parse(Request["entidadeID"]));
                        _entidade.Inativo        = chkIsInativo.Checked;
                        _entidade.EntidadeTipoID = int.Parse(ddlTipoEntidade.SelectedValue);
                        if (rbtPessoaFisica.Checked)
                        {
                            _entidade.CPF        = txtCPF.Text;
                            _entidade.CNPJ       = null;
                            _entidade.TipoPessoa = rbtPessoaFisica.Value;
                            _entidade.Nome       = txtNome.Text.Trim();
                            _entidade.Apelido    = txtApelido.Text.Trim();
                        }
                        else
                        {
                            _entidade.CNPJ       = txtCNPJ.Text;
                            _entidade.CPF        = null;
                            _entidade.TipoPessoa = rbtPessoaJuridica.Value;
                            _entidade.Nome       = txtRazaoSocial.Text.Trim();
                            _entidade.Apelido    = txtFantasia.Text.Trim();
                        }
                        _entidade.DataNascimento       = txtDataNascimento.SelectedDate;
                        _entidade.DataModificacao      = DateTime.Now;
                        _entidade.UsuarioModificadorID = int.Parse(Session["ssnLoggedUserID"].ToString());
                        _entidade.Observacao           = txtObservacao.Text;

                        oUnitOfWork.EntidadeREP.Atualizar(_entidade);
                    }

                    oUnitOfWork.Save();

                    if (string.IsNullOrEmpty(Request["EntidadeID"])) // TODO: Alterar os métodos de manutenção de relacionamentos de entidade
                    {
                        if (_entidade.EntidadeTipoID <= 1)
                        {
                            //_entidade.EntidadesRelacaoFilho.Add(oUnitOfWork.EntidadeREP.BuscarPorID(int.Parse(Session["ssnLoggedUserID"].ToString())));
                            //oUnitOfWork.Save();
                            oUnitOfWork.EntidadeREP.InserirRelacao(_entidade.EntidadeID, int.Parse(Session["ssnLoggedUserID"].ToString()));
                            oUnitOfWork.EntidadeREP.InserirUsuario(_entidade.EntidadeID, Utils.RemoveSpecialCharacters(_entidade.Apelido.Trim()).ToLower() + "usr", Utils.RemoveSpecialCharacters(_entidade.Apelido.Trim()).ToLower() + "psw");
                            oUnitOfWork.EntidadeREP.InserirUsuarioPerfil(_entidade.EntidadeID, 2);
                        }
                        else
                        {
                            //_entidade.EntidadesRelacaoFilho.Add(oUnitOfWork.EntidadeREP.BuscarPorID(int.Parse(Session["ssnLoggedUserID"].ToString())));
                            //oUnitOfWork.Save();
                            oUnitOfWork.EntidadeREP.InserirRelacao(int.Parse(Session["ssnLoggedUserID"].ToString()), _entidade.EntidadeID);
                            oUnitOfWork.EntidadeREP.InserirUsuario(_entidade.EntidadeID, Utils.RemoveSpecialCharacters(_entidade.Apelido.Trim()).ToLower() + "usr", Utils.RemoveSpecialCharacters(_entidade.Apelido.Trim()).ToLower() + "psw");

                            if (_entidade.EntidadeTipoID == 2)
                            {
                                oUnitOfWork.EntidadeREP.InserirUsuarioPerfil(_entidade.EntidadeID, 2);
                            }
                            else
                            {
                                oUnitOfWork.EntidadeREP.InserirUsuarioPerfil(_entidade.EntidadeID, 3);
                            }
                        }
                    }

                    Utils.Notificar(ntfGeral, "Entidade salva.", Enums.TipoNotificacao.Informacao);
                    // Para o caso de inserção
                    if (string.IsNullOrEmpty(Request["entidadeID"]))
                    {
                        Response.Redirect(string.Format("EntidadeCad.aspx?entidadeID={0}&isNew=true", _entidade.EntidadeID.ToString()));
                    }
                }
                catch (Exception ex)
                {
                    Utils.Notificar(ntfGeral, "Falha ao tentar salvar a entidade.", Enums.TipoNotificacao.Erro);
                    Log.Trace(ex, true);
                }
            }
        }
Example #31
0
        public void Save_Click(object sender, EventArgs e)
        {
            //Editar entidade
            if (Request.QueryString["EntidadeID"] != null)
            {
                int      id       = Int32.Parse(Request.QueryString["EntidadeID"]);
                Entidade entidade = GetEntidades().Where(ent => ent.entidade_id == id).First();
                entidade.nome    = TextBoxNome.Text;
                entidade.email   = TextBoxEmail.Text;
                entidade.morada  = TextBoxMorada.Text;
                entidade.tema_id = Convert.ToInt32(listaTemas.SelectedItem.Value);
                if (Estado.SelectedValue.Equals("yes"))
                {
                    entidade.estado = true;
                }
                else
                {
                    entidade.estado = false;
                }

                UpdateEntidade(entidade);

                //Editar o estado dos conteudos
                if (EstadoConteudo.SelectedValue.Equals("yes") || EstadoConteudo.SelectedValue.Equals("no"))
                {
                    int      cont_id = Convert.ToInt32(listaTemas.SelectedItem.Value);
                    Conteudo cont    = GetConteudos(entidade.email).Where(p => p.conteudo_id == cont_id).First();
                    if (EstadoConteudo.SelectedValue.Equals("yes"))
                    {
                        cont.estado = true;
                    }
                    if (EstadoConteudo.SelectedValue.Equals("no"))
                    {
                        cont.estado = false;
                    }

                    UpdateConteudo(cont);
                }
                Response.Redirect("Entidades");
            }

            //Registar nova Entidade
            else
            {
                Entidade ent = new Entidade();
                ent.nome    = TextBoxNome.Text;
                ent.email   = TextBoxEmail.Text;
                ent.morada  = TextBoxMorada.Text;
                ent.tema_id = Convert.ToInt32(listaTemas.SelectedItem.Value);
                if (Estado.SelectedValue.Equals("yes"))
                {
                    ent.estado = true;
                }
                else
                {
                    ent.estado = false;
                }

                NewEntidade(ent);

                //Atribuiçao do ROLE de administrador a esta entidade
                Models.ApplicationDbContext context = new ApplicationDbContext();
                IdentityResult IdRoleResult;
                IdentityResult IdUserResult;

                var roleStore = new RoleStore <IdentityRole>(context);

                var roleMgr = new RoleManager <IdentityRole>(roleStore);

                if (!roleMgr.RoleExists("Admin"))
                {
                    IdRoleResult = roleMgr.Create(new IdentityRole {
                        Name = "Admin"
                    });
                }

                var userMgr = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
                var appUser = new ApplicationUser
                {
                    UserName = TextBoxEmail.Text,
                    Email    = TextBoxEmail.Text
                };
                IdUserResult = userMgr.Create(appUser, "Pa$$word1");

                if (!userMgr.IsInRole(userMgr.FindByEmail(TextBoxEmail.Text).Id, "Admin"))
                {
                    IdUserResult = userMgr.AddToRole(userMgr.FindByEmail(TextBoxEmail.Text).Id, "Admin");
                }

                Response.Redirect("Entidades");
            }
        }
Example #32
0
 public static void IncluirFilme(Entidade.Filme lFilme)
 {
     DB.Filme dbFilme = new DB.Filme();
     dbFilme.IncluirFilme(lFilme);
 }
Example #33
0
 public override Resultado ValidaEntidade(Entidade entidade)
 {
     Login = (Login)entidade;
     Resultado.MensagemSucesso.Append("Validado com sucesso.");
     return(Resultado);
 }
Example #34
0
 public Guid Alterar(Entidade categoria)
 {
     throw new NotImplementedException();
 }
Example #35
0
 public Animal(string identificacao, Entidade entidade) : this(identificacao, entidade.RetornarNome(), entidade.RetornarIdade(), entidade.RetornarSexo())
 {
 }
Example #36
0
        public string TrataConteudoInternoValidation(Entidade entidade, string texto, eTipoValidacao tipoValidacao)
        {
            var propriedades = entidade.PropriedadesAValidar().ToList();

            if (!propriedades.Any())
            {
                return(texto
                       .Replace("{{property}}", "")
                       .Replace("{{validations}}", ""));
            }

            var sbConstrutor = new StringBuilder();
            var sbCorpo      = new StringBuilder();

            if (tipoValidacao == eTipoValidacao.Alterar)
            {
                sbConstrutor.Append("\n" + TabbedString(3));
            }

            for (int i = 0; i < propriedades.Count; i++)
            {
                var    propriedade              = propriedades[i];
                var    ultimoItem               = i == propriedades.Count - 1;
                var    finalDaLinha             = ultimoItem ? string.Empty : "\n" + TabbedString(3);
                string nomePropriedadeValidacao = RetornarNomePropriedadeValidacao(propriedade);

                sbConstrutor.Append($"Validate{propriedade.Nome}();{finalDaLinha}");

                sbCorpo
                .Append($"\n\n{TabbedString(2)}")
                .Append($"protected void Validate{propriedade.Nome}()\n{TabbedString(2)}{{")
                .Append($"\n{TabbedString(3)}RuleFor(r => r.{nomePropriedadeValidacao})");

                var  espacamento = TabbedString(4);
                bool tipoString  = propriedade.Tipo == eTipoPropriedade.String;

                if (!propriedade.Nullable)
                {
                    sbCorpo.Append($"\n{espacamento}.NotEmpty()");
                    sbCorpo.Append($"\n{espacamento}.WithMessage(string.Format(Mensagens.Obrigatorio, \"{nomePropriedadeValidacao}\"))");
                }

                if (propriedade.Min == 0 && propriedade.Max > 0)
                {
                    var validacao         = tipoString ? "MaximumLength" : "LessThanOrEqualTo";
                    var mensagemValidacao = tipoString ? "TamanhoMaximo" : "ValorMaximo";
                    sbCorpo.Append($"\n{espacamento}.{validacao}({propriedade.Max})");
                    sbCorpo.Append($"\n{espacamento}.WithMessage(string.Format(Mensagens.{mensagemValidacao}, \"{propriedade.Nome}\", \"{propriedade.Max}\"))");
                }

                if (propriedade.Min > 0 && propriedade.Max > 0)
                {
                    var validacao         = tipoString ? "Length" : "InclusiveBetween";
                    var mensagemValidacao = tipoString ? "IntervaloCaracteres" : "ValorEntre";
                    sbCorpo.Append($"\n{espacamento}.{validacao}({propriedade.Min}, {propriedade.Max})");
                    sbCorpo.Append($"\n{espacamento}.WithMessage(string.Format(Mensagens.{mensagemValidacao}, \"{propriedade.Nome}\", \"{propriedade.Min}\", \"{propriedade.Max}\"))");
                }

                if (!string.IsNullOrEmpty(propriedade.ExpressaoRegular))
                {
                    sbCorpo.Append($"\n{espacamento}.Matches(\"{propriedade.ExpressaoRegular}\")");
                    sbCorpo.Append($"\n{TabbedString(3)}.WithMessage(\"Digite sua mensagem\")");
                }

                sbCorpo.Append($";\n{TabbedString(2)}}}");
            }

            var textoTratado = texto.Replace("{{property}}", sbConstrutor.ToString());

            return(textoTratado.Replace("{{validations}}", sbCorpo.ToString()));
        }
        //Método para cadstrar usuario
        private void btnCadastroExercicio_Click_1(object sender, EventArgs e)
        {
            //Instanciando classes
            Entidade objTabela = new Entidade();
            BD       cont      = new BD();

            //Condicional que determina que para que o cadastro seja efetuado, todos os campos devem ser preenchidos
            if ((txtNomeCadastro.Text != "") && (txtIdadeCadastro.Text != "") && (txtPesoCadastro.Text != "") &&
                (txtAlturaCadastro.Text != "") && (txtTelefoneCadastro.Text != "") && (txtLogin.Text != "") &&
                (txtSenha.Text != "") && (txtEmailCadastro.Text != "") && ((rbtPerderPeso.Checked) || (rbtGanharMassa.Checked)))
            {
                try
                {
                    //Os atributos recebem o que for inserido no campo
                    objTabela.Nome     = txtNomeCadastro.Text;
                    objTabela.Idade    = int.Parse(txtIdadeCadastro.Text);
                    objTabela.Peso     = double.Parse(txtPesoCadastro.Text);
                    objTabela.Altura   = double.Parse(txtAlturaCadastro.Text);
                    objTabela.Telefone = txtTelefoneCadastro.Text;
                    objTabela.Usuario  = txtLogin.Text;
                    objTabela.Senha    = txtSenha.Text;
                    objTabela.Email    = txtEmailCadastro.Text;
                    //Condição de preenchimento da meta de peso
                    if (rbtPerderPeso.Checked)
                    {
                        objTabela.MetaPeso = "Perder peso";
                    }
                    if (rbtGanharMassa.Checked)
                    {
                        objTabela.MetaPeso = "Ganhar massa";
                    }
                    //Conferindo se existe outro usuário com o mesmo nome
                    //Verificando o resultado do método
                    if (cont.ExistUsu(objTabela) == 0)
                    {
                        MessageBox.Show("Nome de usuário indisponível.\n\nTente outro nome.");
                        txtLogin.Clear();
                        txtLogin.Focus();
                    }
                    else
                    {
                        //Método para inserir usuário
                        int x = cont.InserirUsuario(objTabela);

                        //Verificando se o usuário foi inserido com sucesso
                        if (x > 0)
                        {
                            MessageBox.Show("Usuário: " + txtNomeCadastro.Text + ", inserido com sucesso.");
                            //Assim que o usuário executar o cadastro volta para a tela de login
                            frmLogin tela = new frmLogin();
                            tela.Show();
                            Close();
                        }
                        else
                        {
                            MessageBox.Show("Usuário não inserido.");
                        }
                    }
                }
                //Se houver erro na execução a mensagem de erro é exibida
                catch (Exception ex)
                {
                    MessageBox.Show("Ocorreu um erro: " + ex.Message);
                }
            }
            //Se houver algum campo não preenchido esta mensagem aparece
            else
            {
                MessageBox.Show("Preencha todos os campos!");
            }
        }
Example #38
0
 public void Salvar(Entidade entidade)
 {
     eventos.Salvar(entidade.Id, entidade.Eventos, entidade.Versao);
 }
 private static int ObterProximoId(Entidade entidade)
 {
     return(new Entidades.Pedido().ObterEntidadeId(Database.Select(Entidade.Pedido)[^ 1]));
Example #40
0
 public void Adicionar(Entidade entidade)
 {
     ///3 - ADICIONAR A ENTIDADE (DO SEU TEMA) NA COLEÇÃO EM MEMÓRIA
 }
 public void InsertOrUpdate(Entidade entidade){