private static void AtualizarEstadoDoObjeto(IEntidade estado) { if (estado != null) { estado.EstadoEntidade = EstadosEntidade.NaoModificado; } }
protected override string CanDeleteRecord(IEntidade entidade) { if (db.Clientes.Any(x => x.CidadeId == entidade.Codigo)) { return("Registro não pode ser excluído pois existe um cliente vinculado a cidade"); } return(string.Empty); }
private void AlterarEntidade(IEntidade entidadeAAlterar) { entidadeAAlterar = (IEntidade)LerDadosEntidade(); if (TipoEntidade == EnumTipoEntidade.Cliente) { LerDadosCliente((Cliente)entidadeAAlterar); } }
public static SqlConstrutor <Tipo> iniciar(String tabela, String apelido = null) { Type tipo = typeof(Tipo); ConstructorInfo constructorInfo = tipo.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[0], null); IEntidade instancia = (IEntidade)constructorInfo.Invoke(null); return(new SqlConstrutor <Tipo>(instancia, tabela, apelido)); }
protected SqlConstrutor(IEntidade entidade, String tabela, String apelido = null) { this.entidade = entidade; tabelaPrincipal = tabela; apelidoPrincipal = String.IsNullOrEmpty(apelido) ? entidade.GetType().Name : apelido; listaJoins = new List <Uniao>(); Mapeamento = MapeamentoUtils.obterMapeamento(entidade, apelidoPrincipal); }
private IEntidade DesmontarHeader(IEntidade tela, String msg) { foreach (Entidade.Layout.Campo campo in Entidade.Layout.Mapa.Header.Campos) { ((Entidade.Header)tela).GetType().GetProperty(campo.Propriedade).SetValue(tela, DesmontarCampo(campo.TipoDados, msg.Substring(pos, campo.Tamanho), campo.Formato), null); pos += campo.Tamanho; } pos += 5; return(tela); }
public virtual int GetHashCode(IEntidade obj) { Logger.Instancia.Warn(this, "GetHashCode(entidade)", "Verificando..."); if (!(obj != null || obj is IEntidade || obj.Id == 0L)) { throw new NotImplementedException(); } else { return(obj.Id.GetHashCode()); } }
private String MontarHeader(IEntidade tela) { String header = ""; Type t = tela.GetType(); foreach (Entidade.Layout.Campo campo in Entidade.Layout.Mapa.Header.Campos) { header += MontarCampo(campo.TipoDados, (Object)t.GetProperty(campo.Propriedade).GetValue(tela, null), campo.Tamanho, campo.Formato); } return(header); }
/// <summary> /// Verifica se a entidade ja existe na lista informada /// </summary> /// <param name="entidade"></param> /// <param name="lista"></param> /// <returns></returns> private bool VerificaIdentityPeriodicos(IEntidade entidade, Lista <IPeriodico> lista) { bool retorno = false; while (lista.ContemProximo()) { if (((IEntidade)lista.Proximo()).Id.Equals(entidade.Id)) { retorno = true; } } return(retorno); }
protected virtual ActionResult FindAndReturnEntity(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } IEntidade entidade = db.Set <T>().Find(id); if (entidade == null) { return(HttpNotFound()); } return(View(entidade)); }
public virtual bool Equals(IEntidade x, IEntidade y) { Logger.Instancia.Warn(this, "Equals(entidade,entidade)", "Verificando..."); if (x == null && y == null) { return(false); } if (x is IEntidade && y is IEntidade) { return(((IEntidade)x).Id == ((IEntidade)y).Id); } return(x.Equals(y)); }
private String MontarMensagem(IEntidade tela, Entidade.Layout.Acao layoutAcao) { String msg = ""; Type t = tela.GetType(); foreach (Entidade.Layout.Campo campo in layoutAcao.Campos) { msg += MontarCampo(campo.TipoDados, (Object)t.GetProperty(campo.Propriedade).GetValue(tela, null), campo.Tamanho, campo.Formato); } msg = msg.Length.ToString().PadLeft(5, '0') + msg; return(msg); }
public bool Equals(IEntidade <Guid> other) { if (other == null) { return(false); } if (IsTransient) { return(ReferenceEquals(this, other)); } return(other.ID == ID);// && other.GetType() == GetType(); }
internal IEntidade LerMensagem(IEntidade entidade, String chaveAcao, String msg) { Entidade.Layout.Acao layoutAcao; pos = 0; layoutAcao = Buscar(entidade.GetType().Name, chaveAcao, Tipo.Retorno); if (layoutAcao != null) { entidade = DesmontarHeader(entidade, msg); entidade = DesmontarMensagem(entidade, layoutAcao, msg); } return(entidade); }
public ActionResult DeleteConfirmed(int id) { IEntidade entidade = db.Set <T>().Find(id); var errorOnDelete = CanDeleteRecord(entidade); if (string.IsNullOrWhiteSpace(errorOnDelete)) { db.Entry(entidade).State = EntityState.Deleted; db.SaveChanges(); MessageHelper.DisplaySuccessMessage(this, $"Registro {typeof(T).Name} excluído com sucesso", MessageType.Success); return(RedirectToAction("Index")); } MessageHelper.DisplaySuccessMessage(this, errorOnDelete, MessageType.Error); return(View(entidade)); }
protected Dictionary <String, DbParameter> criarParamatros(IEntidade entidade) { Type tipo = entidade.GetType(); Dictionary <String, DbParameter> param = new Dictionary <String, DbParameter>(); Dictionary <String, Type> tipos = entidade.obterTiposMapeado(); foreach (String k in tipos.Keys) { PropertyInfo p = tipo.GetProperty(k, new Type[] { }); if (p == null || p.GetCustomAttributes(typeof(Transiente), true).Length > 0) { continue; } if (p.GetValue(entidade, null) == null) { param.Add(k, ad.criaParametro(k, ConverteUtils.converteParaDbType(tipos[k]), DBNull.Value)); } else if (tipos[k].IsEnum) { param.Add(k, ad.criaParametro(k, DbType.Int32, (int)p.GetValue(entidade, null))); } else if (tipos[k].IsSubclassOf(typeof(AbstractEntidade))) {//Se for uma entidade: 1-obtem seu mapeamento de chaves, 2-Pega a primeira chave e passa para o mapeamento IEntidade tmp = (IEntidade)p.GetValue(entidade); Dictionary <string, Type> chv = tmp.obterTiposMapeadoChave(); String priChv = chv.Keys.First(); param.Add(k, ad.criaParametro(k, ConverteUtils.converteParaDbType(chv[priChv]), tmp[priChv])); } else if (tipos[k] == typeof(TimeSpan)) { TimeSpan ts = (TimeSpan)p.GetValue(entidade, null); //DateTime data = new DateTime(1981, 1, 30, ts.Hours, ts.Minutes, ts.Seconds); param.Add(k, ad.criaParametro(k, ConverteUtils.converteParaDbType(tipos[k]), ts)); } else { param.Add(k, ad.criaParametro(k, ConverteUtils.converteParaDbType(tipos[k]), p.GetValue(entidade, null))); } } return(param); }
internal String GerarMensagem(IEntidade entidade, String chaveAcao) { Entidade.Layout.Acao layoutAcao; String msg = ""; layoutAcao = Buscar(entidade.GetType().Name, chaveAcao, Tipo.Envio); if (layoutAcao != null) { ((Entidade.Header)entidade).Programa = layoutAcao.Programa; ((Entidade.Header)entidade).RegistrosPorPagina = layoutAcao.RegistrosPorPagina; msg = MontarHeader(entidade); msg += MontarMensagem(entidade, layoutAcao); } return(msg); }
public Uniao(SqlConstrutor <Tipo> construtor, String nome, Type tipo, String tabela, String apelido = null) { sqlConstrutor = construtor; Nome = nome; Tipo = tipo; Tabela = tabela; Apelido = apelido ?? tabela; ConstructorInfo constructorInfo = Tipo.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[0], null); instancia = (IEntidade)constructorInfo.Invoke(null); mapear = sqlConstrutor.entidade.GetType().GetProperty(nome).obterAtributo <Mapear>(true);//.GetRuntimeProperty(nome).GetCustomAttribute<Mapear>(); if (mapear == null) { throw new Exception(String.Format("Propriedade {0} da entidade {1} não possui a assinatura Mapear.", Nome, sqlConstrutor.entidade.GetType().FullName)); } Mapeamento = MapeamentoUtils.obterMapeamento(instancia, Apelido); }
/// <summary> /// Compara duas entidades e indica se ambas são iguais. /// </summary> /// <param name="entidade">Entidade para comparar com a entidade atual.</param> /// <returns>Verdadeiro se ambas as entidades forem iguais; caso contrário, falso.</returns> public override sealed bool Equals(IEntidade entidade) { return(Equals(entidade as Parcela)); }
public bool Equals(IEntidade other) { return this.Id.Equals(other.Id); }
public virtual int CompareTo(IEntidade other) { return this.Id.CompareTo(other.Id); }
public EntidadeAlteradaBD(IEntidade entidade) { IdEntidade = entidade.Id; TipoClr = entidade.GetType().Name; }
/// <summary> /// Compara a instância atual com outro objeto do mesmo tipo e retorna um número inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição na ordem de classificação como o outro objeto. /// </summary> /// <param name="entidade">Objeto para comparar com a instância atual.</param> /// <returns> /// Um valor que indica a ordem relativa dos objetos que estão sendo comparados. /// </returns> public override sealed int CompareTo(IEntidade entidade) { var operacao = entidade as Operacao; return(((operacao == null) || operacao.Id < Id) ? 1 : Equals(operacao) ? 0 : -1); }
/// <summary> /// Compara duas entidades e indica se ambas são iguais. /// </summary> /// <param name="entidade">Entidade para comparar com a entidade atual.</param> /// <returns>Verdadeiro se ambas as entidades forem iguais; caso contrário, falso.</returns> public abstract bool Equals(IEntidade entidade);
/// <summary> /// Compara a instância atual com outro objeto do mesmo tipo e retorna um número inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição na ordem de classificação como o outro objeto. /// </summary> /// <param name="entidade">Objeto para comparar com a instância atual.</param> /// <returns> /// Um valor que indica a ordem relativa dos objetos que estão sendo comparados. /// </returns> public override sealed int CompareTo(IEntidade entidade) { var parcela = entidade as IParcela; return(((parcela == null) || parcela.DataDeVencimento < DataDeVencimento) ? 1 : Equals(parcela) ? 0 : -1); }
protected virtual string CanDeleteRecord(IEntidade entidade) { return(string.Empty); }
public static ISqlConstrutor iniciar(IEntidade entidade, String tabela, String apelido = null) { return(new SqlConstrutor <Tipo>(entidade, tabela, apelido)); }
/// <summary> /// Compara a instância atual com outro objeto do mesmo tipo e retorna um número inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição na ordem de classificação como o outro objeto. /// </summary> /// <param name="entidade">Objeto para comparar com a instância atual.</param> /// <returns> /// Um valor que indica a ordem relativa dos objetos que estão sendo comparados. /// </returns> public abstract int CompareTo(IEntidade entidade);
/// <summary> /// Compara duas entidades e indica se ambas são iguais. /// </summary> /// <param name="entidade">Entidade para comparar com a entidade atual.</param> /// <returns>Verdadeiro se ambas as entidades forem iguais; caso contrário, falso.</returns> public override sealed bool Equals(IEntidade entidade) { return(Equals(entidade as Operacao)); }