public async Task <JsonResult> PesquisarJson(String termo)
{
db.Configuration.ProxyCreationEnabled = false;
db.Configuration.LazyLoadingEnabled = false;
if (String.IsNullOrEmpty(termo))
{
return(Json(null, JsonRequestBehavior.AllowGet));
}
if (!await RedisCacheClient.ExistsAsync("Agencias"))
{
var agenciasBancarias = await db.AgenciasBancarias
// .Where(a => a.Nome.Contains(termo) || termo.Contains(a.CodigoCompensacao.ToString()))
.ToListAsync();
await RedisCacheClient.AddAsync("Agencias", agenciasBancarias, new TimeSpan(0, 3, 0));
}
termo = termo.ToUpper();
var lista = await RedisCacheClient.GetAsync <List <AgenciaBancaria> >("Agencias");
return(Json(lista
.Where(a => a.Nome.Contains(termo) || termo.Contains(a.CodigoCompensacao.ToString())), JsonRequestBehavior.AllowGet));
// return Json(agenciasBancarias, JsonRequestBehavior.AllowGet);
}
// GET: Categorias
public async Task <ActionResult> Index(int?page)
{
if (!await RedisCacheClient.ExistsAsync("Categoria"))
{
await RedisCacheClient.AddAsync("Categoria", "", new TimeSpan(0, 3, 0));
var categoriaDB = await db.Categorias.ToListAsync();
foreach (var item in categoriaDB)
{
await RedisCacheClient.AddAsync("Categoria:" + item.CategoriaId.ToString(), item, new TimeSpan(0, 3, 0));
}
}
var categorias = (await RedisCacheClient.SearchKeysAsync("Categoria:*"))
.Select(p => RedisCacheClient.Get <Categoria>(p)).OrderBy(x => x.CategoriaId).ToList() ??
await db.Categorias.OrderBy(x => x.CategoriaId).ToListAsync();
var pageNumber = page ?? 1;
var paginacao = await categorias.ToPagedListAsync(pageNumber, 25);
ViewBag.PageCategorias = paginacao;
return(View());
}
// GET: Veiculos
public async Task <ActionResult> Index(int?page)
{
if (!await RedisCacheClient.ExistsAsync("Veiculos"))
{
await RedisCacheClient.AddAsync("Veiculo", "", new TimeSpan(0, 3, 0));
var veiculosDB = await db.Veiculos.ToListAsync();
foreach (var item in veiculosDB)
{
await RedisCacheClient.AddAsync("Veiculo:" + item.VeiculoId.ToString(), item, new TimeSpan(0, 3, 0));
}
}
var veiculos = (await RedisCacheClient.SearchKeysAsync("Veiculo:*"))
.Select(p => RedisCacheClient.Get <Veiculo>(p)).OrderBy(x => x.VeiculoId).ToList() ??
await db.Veiculos.OrderBy(x => x.VeiculoId).ToListAsync();
var pageNumber = page ?? 1;
var paginacao = await veiculos.ToPagedListAsync(pageNumber, 25);
ViewBag.PageVeiculos = paginacao;
return(View());
}
public override async Task <string> EnqueueAsync(T data)
{
string id = Guid.NewGuid().ToString("N");
_logger.Debug("Queue {_queueName} enqueue item: {id}", _queueName, id);
if (!await OnEnqueuingAsync(data).AnyContext())
{
_logger.Trace("Aborting enqueue item: {id}", id);
return(null);
}
bool success = await _cache.AddAsync(GetPayloadKey(id), data, _payloadTtl).AnyContext();
if (!success)
{
throw new InvalidOperationException("Attempt to set payload failed.");
}
await Database.ListLeftPushAsync(QueueListName, id).AnyContext();
await _cache.SetAsync(GetEnqueuedTimeKey(id), DateTime.UtcNow.Ticks, _payloadTtl).AnyContext();
// This should pulse the monitor.
await _subscriber.PublishAsync(GetTopicName(), id).AnyContext();
Interlocked.Increment(ref _enqueuedCount);
var entry = new QueueEntry <T>(id, data, this, DateTime.UtcNow, 0);
await OnEnqueuedAsync(entry).AnyContext();
_logger.Trace("Enqueue done");
return(id);
}
protected override async Task <string> EnqueueImplAsync(T data, QueueEntryOptions options)
{
string id = Guid.NewGuid().ToString("N");
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Queue {Name} enqueue item: {EntryId}", _options.Name, id);
}
bool isTraceLogLevelEnabled = _logger.IsEnabled(LogLevel.Trace);
if (!await OnEnqueuingAsync(data, options).AnyContext())
{
if (isTraceLogLevelEnabled)
{
_logger.LogTrace("Aborting enqueue item: {EntryId}", id);
}
return(null);
}
var now = SystemClock.UtcNow;
var envelope = new RedisPayloadEnvelope <T> {
Properties = options.Properties,
CorrelationId = options.CorrelationId,
Value = data
};
bool success = await Run.WithRetriesAsync(() => _cache.AddAsync(GetPayloadKey(id), envelope, _payloadTimeToLive), logger : _logger).AnyContext();
if (!success)
{
throw new InvalidOperationException("Attempt to set payload failed.");
}
await Run.WithRetriesAsync(() => Task.WhenAll(
_cache.SetAsync(GetEnqueuedTimeKey(id), now.Ticks, _payloadTimeToLive),
Database.ListLeftPushAsync(_queueListName, id)
), logger : _logger).AnyContext();
try {
_autoResetEvent.Set();
await Run.WithRetriesAsync(() => _subscriber.PublishAsync(GetTopicName(), id), logger : _logger).AnyContext();
} catch (Exception ex) {
if (isTraceLogLevelEnabled)
{
_logger.LogTrace(ex, "Error publishing topic message");
}
}
Interlocked.Increment(ref _enqueuedCount);
var entry = new QueueEntry <T>(id, null, data, this, now, 0);
await OnEnqueuedAsync(entry).AnyContext();
if (isTraceLogLevelEnabled)
{
_logger.LogTrace("Enqueue done");
}
return(id);
}
public async Task <string> StoreAsync(AuthenticationTicket ticket)
{
var key = Guid.NewGuid().ToString("N");
await _client.AddAsync(key, ticket.Serialize(), GetExpiration(ticket));
return(key);
}
public async Task <ActionResult> Create([Bind(Include = "CategoriaId,Nome")] Categoria categoria)
{
if (ModelState.IsValid)
{
db.Categorias.Add(categoria);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("Categoria:" + categoria.CategoriaId, categoria, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(categoria));
}
public async Task <ActionResult> Create([Bind(Include = "ContatoId,Nome,Email")] Contato contato)
{
if (ModelState.IsValid)
{
db.Contatos.Add(contato);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("Contato:" + contato.ContatoId, contato, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(contato));
}
public async Task <ActionResult> Create([Bind(Include = "VeiculoId,Carro,Marca,Ano,Placa")] Veiculo veiculo)
{
if (ModelState.IsValid)
{
db.Veiculos.Add(veiculo);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("Veiculo:" + veiculo.VeiculoId, veiculo, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(veiculo));
}
public async Task <ActionResult> Create([Bind(Include = "EmpresaId,RazaoSocial,NomeFantasia,Cnpj")] Empresa empresa)
{
if (ModelState.IsValid)
{
db.Empresas.Add(empresa);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("Empresa:" + empresa.EmpresaId, empresa, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(empresa));
}
public async Task <ActionResult> Create([Bind(Include = "BancoId,Nome,Numero")] Banco banco)
{
if (ModelState.IsValid)
{
db.Bancos.Add(banco);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("Banco:" + banco.BancoId, banco, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(banco));
}
public async Task <ActionResult> Create([Bind(Include = "FuncionarioId,Nome,Cargo,DataNascimento")] Funcionario funcionario)
{
if (ModelState.IsValid)
{
db.Funcionarios.Add(funcionario);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("Funcionario:" + funcionario.FuncionarioId, funcionario, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(funcionario));
}
public async Task <ActionResult> Create([Bind(Include = "CompromissoId,Titulo,DataHora,Local,Observacoes")] Compromisso compromisso)
{
if (ModelState.IsValid)
{
db.Compromissos.Add(compromisso);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("Compromisso:" + compromisso.CompromissoId, compromisso, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(compromisso));
}
public async Task <ActionResult> Create([Bind(Include = "ProdutoId,CategoriaId,Nome,Preco")] Produto produto)
{
if (ModelState.IsValid)
{
db.Produtos.Add(produto);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("Produto:" + produto.ProdutoId, produto, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
ViewBag.CategoriaId = new SelectList(db.Categorias, "CategoriaId", "Nome", produto.CategoriaId);
return(View(produto));
}
public async Task <ActionResult> BuscarCompromisso(string compromisso)
{
if (String.IsNullOrEmpty(compromisso))
{
return(Json(null, JsonRequestBehavior.AllowGet));
}
if (!await RedisCacheClient.ExistsAsync("Compromissos"))
{
var compromissoDB = await db.Compromissos.ToListAsync();
await RedisCacheClient.AddAsync("Compromissos", compromissoDB, new TimeSpan(0, 3, 0));
}
var lista = await RedisCacheClient.GetAsync <List <Compromisso> >("Compromissos");
return(Json(lista
.Where(a => a.Titulo.Contains(compromisso)), JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> Create([Bind(Include = "AgenciaBancariaId,BancoId,CodigoCompensacao,Nome")] AgenciaBancaria agenciaBancaria)
{
if (ModelState.IsValid)
{
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
db.AgenciasBancarias.Add(agenciaBancaria);
await db.SaveChangesAsync();
await RedisCacheClient.AddAsync("AgenciaBancaria:" + agenciaBancaria.AgenciaBancariaId, agenciaBancaria, new TimeSpan(0, 5, 0));
scope.Complete();
}
return(RedirectToAction("Index"));
}
ViewBag.BancoId = new SelectList(db.Bancos, "BancoId", "Nome", agenciaBancaria.BancoId);
return(View(agenciaBancaria));
}
