public Lancamento CriarNovoLancamento(Lancamento lancamento, bool Atualizar = false)
{
if (lancamento == null)
{
lancamento = new Lancamento();
lancamento.LancamentoId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Lancamento> lancamentoRepository = new Repository <Lancamento>(context, unitOfWork);
ILancamentoService lancamentoService = new LancamentoService(lancamentoRepository);
if (!ExisteLancamento(lancamento.LancamentoId))
{
lancamento = lancamentoService.NovoLancamento(lancamento);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
lancamento = AtualizarLancamento(lancamento);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(lancamento);
}
return(lancamento);
}
public Fornecedor CriarNovoFornecedor(Fornecedor fornecedor, bool Atualizar = false)
{
if (fornecedor == null)
{
fornecedor = new Fornecedor();
fornecedor.FornecedorId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Fornecedor> fornecedorRepository = new Repository <Fornecedor>(context, unitOfWork);
IFornecedorService fornecedorService = new FornecedorService(fornecedorRepository);
if (!ExisteFornecedor(fornecedor.FornecedorId))
{
fornecedor = fornecedorService.NovoFornecedor(fornecedor);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
fornecedor = AtualizarFornecedor(fornecedor);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(fornecedor);
}
return(fornecedor);
}
//Genecico
public bool ExcluirUsuario(Usuario usuario)
{
bool ret = true;
if (usuario == null)
{
return(false);
}
if (usuario.UsuarioId == Guid.Empty)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Usuario> UsuarioRepository = new Repository <Usuario>(context, unitOfWork);
IUsuarioService UsuarioService = new UsuarioService(UsuarioRepository);
usuario.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
UsuarioService.Delete(usuario.UsuarioId);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaExclusao(usuario);
}
}
catch
{
ret = false;
}
return(ret);
}
//Generica
public Versao CriarNovaVersao(Versao versao, bool Atualizar = false)
{
if (versao == null)
{
versao = new Versao();
versao.VersaoId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Versao> versaoRepository = new Repository <Versao>(context, unitOfWork);
IVersaoService versaoService = new VersaoService(versaoRepository);
if (!ExisteVersao(versao.VersaoId))
{
versao = versaoService.NovaVersao(versao);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
versao = AtualizarVersao(versao);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
}
return(versao);
}
//Generica
public Usuario CriarNovoUsuario(Usuario usuario, bool Atualizar = false)
{
if (usuario == null)
{
usuario = new Usuario();
usuario.UsuarioId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Usuario> usuarioRepository = new Repository <Usuario>(context, unitOfWork);
IUsuarioService usuarioService = new UsuarioService(usuarioRepository);
if (!ExisteUsuario(usuario.UsuarioId))
{
usuario = usuarioService.NovoUsuario(usuario);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
usuario = AtualizarUsuario(usuario);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(usuario);
SolicitarAtivacao(usuario);
}
return(usuario);
}
//Genecico
public bool ExcluirRegra(Regra regra)
{
bool ret = true;
if (regra == null)
{
return(false);
}
if (regra.RegraId == Guid.Empty)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Regra> RegraRepository = new Repository <Regra>(context, unitOfWork);
IRegraService RegraService = new RegraService(RegraRepository);
regra.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
RegraService.Delete(regra.RegraId);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaExclusao(regra);
}
}
catch
{
ret = false;
}
return(ret);
}
public bool ExcluirLancamento(Lancamento lancamento)
{
bool ret = true;
if (lancamento == null)
{
return(false);
}
if (lancamento.LancamentoId == Guid.Empty)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Lancamento> lancamentoRepository = new Repository <Lancamento>(context, unitOfWork);
ILancamentoService lancamentoService = new LancamentoService(lancamentoRepository);
lancamento.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
lancamentoService.Delete(lancamento.LancamentoId);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaExclusao(lancamento);
}
}
catch
{
ret = false;
}
return(ret);
}
public AnoCalendario CriarNovoAnoCalendario(AnoCalendario anocalendario, bool Atualizar = false)
{
if (anocalendario == null)
{
anocalendario = new AnoCalendario();
anocalendario.Ano = 0;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <AnoCalendario> AnoCalendarioRepository = new Repository <AnoCalendario>(context, unitOfWork);
IAnoCalendarioService AnoCalendarioService = new AnoCalendarioService(AnoCalendarioRepository);
if (!ExisteAnoCalendario(anocalendario.Ano))
{
anocalendario = AnoCalendarioService.NovoAnoCalendario(anocalendario);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
anocalendario = AtualizarAnoCalendario(anocalendario);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(anocalendario);
}
return(anocalendario);
}
public TipoBloco CriarNovoTipoBloco(TipoBloco tipobloco, bool Atualizar = false)
{
if (tipobloco == null)
{
tipobloco = new TipoBloco();
tipobloco.TipoBlocoId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <TipoBloco> TipoBlocoRepository = new Repository <TipoBloco>(context, unitOfWork);
ITipoBlocoService TipoBlocoService = new TipoBlocoService(TipoBlocoRepository);
if (!ExisteTipoBloco(tipobloco.TipoBlocoId))
{
tipobloco = TipoBlocoService.NovoTipoBloco(tipobloco);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
tipobloco = AtualizarTipoBloco(tipobloco);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(tipobloco);
}
return(tipobloco);
}
public bool ExcluirTipoBloco(TipoBloco tipobloco)
{
bool ret = true;
if (tipobloco == null)
{
return(false);
}
if (tipobloco.TipoBlocoId == Guid.Empty)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <TipoBloco> TipoBlocoRepository = new Repository <TipoBloco>(context, unitOfWork);
ITipoBlocoService TipoBlocoService = new TipoBlocoService(TipoBlocoRepository);
tipobloco.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
TipoBlocoService.Delete(tipobloco.TipoBlocoId);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaExclusao(tipobloco);
}
}
catch
{
ret = false;
}
return(ret);
}
public Status CriarNovoStatus(Status status, bool Atualizar = false)
{
if (status == null)
{
status = new Status();
status.StatusId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Status> statusRepository = new Repository <Status>(context, unitOfWork);
IStatusService statusService = new StatusService(statusRepository);
if (!ExisteStatus(status.StatusId))
{
status = statusService.NovoStatus(status);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
status = AtualizarStatus(status);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(status);
}
return(status);
}
public bool ExcluirStatus(Status status)
{
bool ret = true;
if (status == null)
{
return(false);
}
if (status.StatusId == Guid.Empty)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Status> StatusRepository = new Repository <Status>(context, unitOfWork);
IStatusService StatusService = new StatusService(StatusRepository);
status.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
StatusService.Delete(status.StatusId);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaExclusao(status);
}
}
catch
{
ret = false;
}
return(ret);
}
//Genecico
public bool ExcluirVersao(Versao versao)
{
bool ret = true;
if (versao == null)
{
return(false);
}
if (versao.VersaoId == Guid.Empty)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Versao> VersaoRepository = new Repository <Versao>(context, unitOfWork);
IVersaoService VersaoService = new VersaoService(VersaoRepository);
versao.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
VersaoService.Delete(versao.VersaoId);
unitOfWork.SaveChanges();
}
}
catch
{
ret = false;
}
return(ret);
}
public Responsavel CriarNovoResponsavel(Responsavel responsavel, bool Atualizar = false)
{
if (responsavel == null)
{
responsavel = new Responsavel();
responsavel.ResponsavelId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Responsavel> ResponsavelRepository = new Repository <Responsavel>(context, unitOfWork);
IResponsavelService ResponsavelService = new ResponsavelService(ResponsavelRepository);
if (!ExisteResponsavel(responsavel.ResponsavelId))
{
responsavel = ResponsavelService.NovoResponsavel(responsavel);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
responsavel = AtualizarResponsavel(responsavel);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(responsavel);
}
return(responsavel);
}
public bool ExisteUsuarioRegra(Guid UsuarioId, Guid RegraId)
{
bool ret = false;
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <UsuarioRegra> usuarioregraRepository = new Repository <UsuarioRegra>(context, unitOfWork);
IUsuarioRegraService usuarioregraService = new UsuarioRegraService(usuarioregraRepository);
ret = (usuarioregraService.Query(p =>
p.UsuarioId == UsuarioId &&
p.RegraId == RegraId)
.Select()
.Count() > 0);
unitOfWork.Dispose();
}
}
catch
{
ret = false;
}
return(ret);
}
public bool ExcluirFornecedor(Fornecedor fornecedor)
{
bool ret = true;
if (fornecedor == null)
{
return(false);
}
if (fornecedor.FornecedorId == Guid.Empty)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Fornecedor> fornecedorRepository = new Repository <Fornecedor>(context, unitOfWork);
IFornecedorService fornecedorService = new FornecedorService(fornecedorRepository);
fornecedor.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
fornecedorService.Delete(fornecedor.FornecedorId);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaExclusao(fornecedor);
}
}
catch
{
ret = false;
}
return(ret);
}
//Generica
public UsuarioRegra CriarNovoUsuarioRegra(UsuarioRegra usuarioregra, bool Atualizar = false)
{
if (usuarioregra == null)
{
usuarioregra = new UsuarioRegra();
usuarioregra.UsuarioId = Guid.Empty;
usuarioregra.RegraId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <UsuarioRegra> usuarioregraRepository = new Repository <UsuarioRegra>(context, unitOfWork);
IUsuarioRegraService usuarioregraService = new UsuarioRegraService(usuarioregraRepository);
if (!ExisteUsuarioRegra(usuarioregra.UsuarioId, usuarioregra.RegraId))
{
usuarioregra = usuarioregraService.NovoUsuarioRegra(usuarioregra);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
usuarioregra = AtualizarUsuarioRegra(usuarioregra);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(usuarioregra);
}
return(usuarioregra);
}
//Generica
public Regra CriarNovaRegra(Regra regra, bool Atualizar = false)
{
if (regra == null)
{
regra = new Regra();
regra.RegraId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Regra> regraRepository = new Repository <Regra>(context, unitOfWork);
IRegraService regraService = new RegraService(regraRepository);
if (!ExisteRegra(regra.RegraId))
{
regra = regraService.NovaRegra(regra);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
regra = AtualizarRegra(regra);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(regra);
}
return(regra);
}
public UsuarioRegra CarregarUsuarioRegra(Guid UsuarioId, Guid RegraId)
{
UsuarioRegra ret = null;
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <UsuarioRegra> usuarioregraRepository = new Repository <UsuarioRegra>(context, unitOfWork);
IUsuarioRegraService usuarioregraService = new UsuarioRegraService(usuarioregraRepository);
var query = from item in usuarioregraService.Queryable()
where item.UsuarioId == UsuarioId &&
item.RegraId == RegraId
select item;
ret = query.SingleOrDefault <UsuarioRegra>();
unitOfWork.Dispose();
}
}
catch
{
ret = null;
}
return(ret);
}
public Bloco CriarNovoBloco(Bloco bloco, bool Atualizar = false)
{
if (bloco == null)
{
bloco = new Bloco();
bloco.BlocoId = Guid.Empty;
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Bloco> blocoRepository = new Repository <Bloco>(context, unitOfWork);
IBlocoService blocoService = new BlocoService(blocoRepository);
if (!ExisteBloco(bloco.BlocoId))
{
bloco = blocoService.NovoBloco(bloco);
unitOfWork.SaveChanges();
}
else if (Atualizar)
{
bloco = AtualizarBloco(bloco);
unitOfWork.SaveChanges();
}
unitOfWork.Dispose();
(new Execute()).Sistema.Versao.NovaVersaoParaCriacao(bloco);
}
return(bloco);
}
public bool ExcluirAnoCalendario(AnoCalendario anocalendario)
{
bool ret = true;
if (anocalendario == null)
{
return(false);
}
if (anocalendario.Ano == 0)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <AnoCalendario> AnoCalendarioRepository = new Repository <AnoCalendario>(context, unitOfWork);
IAnoCalendarioService AnoCalendarioService = new AnoCalendarioService(AnoCalendarioRepository);
anocalendario.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
AnoCalendarioService.Delete(anocalendario.Ano);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaExclusao(anocalendario);
}
}
catch
{
ret = false;
}
return(ret);
}
public Usuario CarregarUsuario(string LoginWindows)
{
Usuario ret = null;
try
{
ret = new Usuario();
using (PCFTIDataContext context = new PCFTIDataContext())
{
var usr = (from user in context.Usuario
.Include(p => p.UsuarioRegras)
.Include(p => p.UsuarioRegras.Select(t => t.Regra))
where user.LoginWindows.Equals(LoginWindows)
select user)
.SingleOrDefault <Usuario>();
ret = usr;
}
}
catch
{
ret = null;
}
return(ret);
}
// GET: Lancamento
public ActionResult Index()
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Fornecedor> fornecedorRepository = new Repository <Fornecedor>(context, unitOfWork);
IFornecedorService fornecedorService = new FornecedorService(fornecedorRepository);
var fornecedores = fornecedorService.ListarTodosOsFornecedores();
}
return(View());
}
public bool ExcluirUsuarioRegra(Usuario usuario)
{
bool ret = true;
if (usuario == null)
{
return(false);
}
if (usuario.UsuarioId == Guid.Empty)
{
return(false);
}
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <UsuarioRegra> usuarioregraRepository = new Repository <UsuarioRegra>(context, unitOfWork);
IUsuarioRegraService usuarioregraService = new UsuarioRegraService(usuarioregraRepository);
List <UsuarioRegra> usuarioregras = (from item in usuarioregraService.Queryable()
where item.UsuarioId == usuario.UsuarioId
select item)
.ToList <UsuarioRegra>();
Parallel.ForEach <UsuarioRegra>(usuarioregras, usuarioregra => {
usuarioregra.AlteradoPor = usuario.AlteradoPor;
usuarioregra.AlteradoEm = DateTime.Now;
usuarioregra.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Deleted;
usuarioregraService.Delete(usuarioregra);
(new Execute()).Sistema.Versao.NovaVersaoParaExclusao(usuarioregra);
});
unitOfWork.SaveChanges();
}
}
catch
{
ret = false;
}
return(ret);
}
//Generica
public Versao AtualizarVersao(Versao versao)
{
if (versao == null)
{
return(versao);
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Versao> versaoRepository = new Repository <Versao>(context, unitOfWork);
IVersaoService versaoService = new VersaoService(versaoRepository);
versao.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Modified;
versaoService.Update(versao);
unitOfWork.SaveChanges();
}
return(versao);
}
public static IEnumerable<Fornecedor> ListarTodosOsFornecedores()
{
IEnumerable<Fornecedor> ret = null;
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync<Fornecedor> fornecedorRepository = new Repository<Fornecedor>(context, unitOfWork);
IFornecedorService fornecedorService = new FornecedorService(fornecedorRepository);
ret = fornecedorService.ListarTodosOsFornecedores();
}
}
catch
{
}
return ret;
}
public static IEnumerable <Usuario> ListarTodosOsUsuarios()
{
IEnumerable <Usuario> ret = null;
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Usuario> usuarioRepository = new Repository <Usuario>(context, unitOfWork);
IUsuarioService usuarioService = new UsuarioService(usuarioRepository);
ret = usuarioService.ListarTodosOsUsuarios();
}
}
catch
{
}
return(ret);
}
public AnoCalendario AtualizarAnoCalendario(AnoCalendario anocalendario)
{
if (anocalendario == null)
{
return(anocalendario);
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <AnoCalendario> anocalendarioRepository = new Repository <AnoCalendario>(context, unitOfWork);
IAnoCalendarioService anocalendarioService = new AnoCalendarioService(anocalendarioRepository);
anocalendario.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Modified;
anocalendarioService.Update(anocalendario);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaEdicao(anocalendario);
}
return(anocalendario);
}
//Generica
public Regra AtualizarRegra(Regra regra)
{
if (regra == null)
{
return(regra);
}
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Regra> regraRepository = new Repository <Regra>(context, unitOfWork);
IRegraService regraService = new RegraService(regraRepository);
regra.ObjectState = INFRAESTRUTURA.TRANSVERSAL.Core.States.ObjectState.Modified;
regraService.Update(regra);
unitOfWork.SaveChanges();
(new Execute()).Sistema.Versao.NovaVersaoParaEdicao(regra);
}
return(regra);
}
public static IEnumerable <Versao> ListarTodosAsVersoes()
{
IEnumerable <Versao> ret = null;
try
{
using (IDataContextAsync context = new PCFTIDataContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <Versao> versaoRepository = new Repository <Versao>(context, unitOfWork);
IVersaoService versaoService = new VersaoService(versaoRepository);
ret = versaoService.ListarTodosAsVersoes();
}
}
catch
{
}
return(ret);
}
