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));
}