public ActionResult Create(MensagemModel mensagenModel)
{
if (ModelState.IsValid)
{
string msgAntiga = mensagenModel.Mensagem;
//AesCryptoServiceProvider
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.BlockSize = 128;
aes.KeySize = 256;
aes.IV = Encoding.UTF8.GetBytes(AesIV256BD);
aes.Key = Encoding.UTF8.GetBytes(AesKey256BD);
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
// Convertendo String para byte Arrey
byte[] src = Encoding.Unicode.GetBytes(mensagenModel.Mensagem);
//Encriptação
using (ICryptoTransform encrypt = aes.CreateEncryptor())
{
byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length);
mensagenModel.Mensagem = Convert.ToBase64String(dest);
}
string msg = mensagenModel.Mensagem;
db.Mensagens.Add(mensagenModel);
db.SaveChanges();
return(RedirectToAction(nameof(Create), new { @msg = msg, @msgAntiga = msgAntiga }));
}
return(RedirectToAction(nameof(Create)));
}
public MensagemNoConsoleComandoEEnvia(MensagemModel mensagem, string input, IClientWebSocketSend clientWebSocketSendMessage, ClientWebSocket client)
{
this._mensagem = mensagem;
this._input = input;
this._clientWebSocketSendMessage = clientWebSocketSendMessage;
this._client = client;
}
private void ReceiveCallback(IAsyncResult AR)
{
try
{
int received = clientSocket.EndReceive(AR);
if (received == 0)
{
return;
}
byte[] recBuf = new byte[received];
Array.Copy(buffer, recBuf, received);
MensagemModel mensagem = new MensagemModel(recBuf);
_verifyAcaoMensagem(mensagem);
clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceiveCallback, null);
}
catch (SocketException ex)
{
_callError(ex.Message);
}
catch (ObjectDisposedException ex)
{
_callError(ex.Message);
}
}
public async Task <IActionResult> Delete(int idUsuario, int idEndereco)
{
var cliente = await _context.Clientes.FindAsync(idUsuario);
var endereco = cliente.Enderecos.FirstOrDefault(e => e.IdEndereco == idEndereco);
if (endereco != null)
{
cliente.Enderecos.Remove(endereco);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço excluído com sucesso.");
if (endereco.Selecionado && cliente.Enderecos.Count() > 0)
{
cliente.Enderecos.FirstOrDefault().Selecionado = true;
await _context.SaveChangesAsync();
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir o endereço.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não encontrado.", TipoMensagem.Erro);
}
return(RedirectToAction("Index", new { cid = idUsuario }));
}
public void DesconectAllClients()
{
MensagemModel message = new MensagemModel(AcaoMensagemEnum.TerminarTransmissao, string.Empty);
byte[] buffer = message.ToByteArray();
_sendForAll(buffer);
}
private void ReceiveCallback(IAsyncResult AR)
{
try
{
Socket current = (Socket)AR.AsyncState;
int received = current.EndReceive(AR);
if (received == 0)
{
return;
}
MensagemModel mensagem = new MensagemModel(buffer);
_verifyAcaoMensagem(mensagem, current);
current.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceiveCallback, current);
}
catch (SocketException ex)
{
_mensagemServidor.ShowErrorDialog(ex.Message);
}
catch (ObjectDisposedException ex)
{
_mensagemServidor.ShowErrorDialog(ex.Message);
}
}
public async Task <IActionResult> Delete(int?cid, int?eid)
{
if (!cid.HasValue)
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
if (!eid.HasValue)
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", new { cid = cid }));
}
var cliente = await _context.Clientes.FindAsync(cid);
var endereco = cliente.Enderecos.FirstOrDefault(e => e.IdEndereco == eid);
if (endereco == null)
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", new { cid = cid }));
}
ViewBag.Cliente = cliente;
return(View(endereco));
}
public void SendToClients(string text)
{
MensagemModel message = new MensagemModel(AcaoMensagemEnum.EnviarTexto, text);
byte[] buffer = message.ToByteArray();
_sendForAll(buffer);
}
private async Task Receiving(ClientWebSocket client)
{
var buffer = new byte[1024 * 4];
while (true)
{
var result = await client.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Text)
{
string input = (Encoding.UTF8.GetString(buffer, 0, result.Count));
MensagemModel mensagem = Newtonsoft.Json.JsonConvert.DeserializeObject <MensagemModel>(input);
if (mensagem.TipoMensagem == Models.Enum.TipoMensagemEnum.MensagemConectado ||
mensagem.TipoMensagem == Models.Enum.TipoMensagemEnum.MensagemRegistro)
{
_controladorDeMensagemNoConsole.EscreverMensagemNoConsole(new MensagemNoConsoleConectadoOuRegistro(mensagem));
}
else if (mensagem.TipoMensagem == Models.Enum.TipoMensagemEnum.MensagemComando)
{
_controladorDeMensagemNoConsole.EscreverMensagemNoConsole(new MensagemNoConsoleComandoEEnvia(mensagem, input, this._clientWebSocketSendMessage, client));
}
}
else if (result.MessageType == WebSocketMessageType.Close)
{
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
break;
}
}
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
var produto = await _context.Produtos.FindAsync(id);
//delete image from wwwroot/image
var imagePath = Path.Combine(_hostEnvironment.WebRootPath, "image", produto.ImageName);
if (System.IO.File.Exists(imagePath))
{
System.IO.File.Exists(imagePath);
}
if (produto != null)
{
_context.Produtos.Remove(produto);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Produto excluído com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir o produto.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Produto não encontrado.", TipoMensagem.Erro);
}
return(RedirectToAction(nameof(Index)));
}
public void SendDesconectRequest()
{
MensagemModel message = new MensagemModel(AcaoMensagemEnum.Desconectar, string.Empty);
byte[] buffer = message.ToByteArray();
clientSocket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, SendCallback, null);
}
public IActionResult Update(string id, [FromBody] Contato alterar)
{
string mensagem = String.Empty;
var msg = new MensagemModel();
if (alterar == null)
{
msg.Mensagem = "Nenhuma informação foi passado no objeto!";
msg.Status = false;
return BadRequest(msg);
}
if (String.IsNullOrEmpty(id))
{
msg.Mensagem = "O id do contato não foi informado!";
msg.Status = false;
return BadRequest(msg);
}
else
{
int valor = 0;
if(Int32.TryParse(id, out valor))
{
if(valor != alterar.idContato)
{
msg.Mensagem = "O id informado não confere com o id do contato!";
msg.Status = false;
return BadRequest(msg);
}
if (valor == 0)
{
msg.Mensagem = "O id do contato não foi informado!";
msg.Status = false;
return BadRequest(msg);
}
}
}
if (!negocio.updateContato(alterar, out mensagem))
{
msg.Mensagem = mensagem;
msg.Status = false;
return BadRequest(msg);
}
var contatosAtualizados = negocio.getContato().ToList();
msg.Contatos = contatosAtualizados;
msg.Mensagem = mensagem;
msg.Status = true;
return Ok(msg);
}
public IActionResult Create( [FromBody] Contato novo)
{
string mensagem = String.Empty;
var msg = new MensagemModel();
if (novo == null)
{
msg.Mensagem = "Nenhuma informação foi passado no objeto!";
msg.Status = false;
return BadRequest(msg);
}
if(!negocio.addContato(novo, out mensagem))
{
msg.Mensagem = mensagem;
msg.Status = false;
return BadRequest(msg);
}
var contatosAtualizados = negocio.getContato().ToList();
msg.Contatos = contatosAtualizados;
msg.Mensagem = mensagem;
msg.Status = true;
return Ok(msg);
}
public async Task <IActionResult> Index(int?cid)
{
if (cid.HasValue)
{
var cliente = await _context.Clientes.FindAsync(cid);
if (cliente != null)
{
var pedidos = await _context.Pedidos
.Where(p => p.IdCliente == cid)
.OrderByDescending(x => x.IdPedido)
.AsNoTracking().ToListAsync();
ViewBag.Cliente = cliente;
return(View(pedidos));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado",
TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não informado",
TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
public async Task <IActionResult> Create(int?ped, int?prod)
{
if (ped.HasValue)
{
if (_context.Pedidos.Any(p => p.IdPedido == ped))
{
var produtos = _context.Produtos
.OrderBy(x => x.Nome)
.Select(p => new { p.IdProduto, NomePreco = $"{p.Nome} ({p.Valor:C})" })
.AsNoTracking().ToList();
var produtosSelectList = new SelectList(produtos, "IdProduto", "NomePreco");
ViewBag.Produtos = produtosSelectList;
if (prod.HasValue && ItemPedidoExiste(ped.Value, prod.Value))
{
var itemPedido = await _context.ItensPedidos
.Include(i => i.Produto)
.FirstOrDefaultAsync(i => i.IdPedido == ped && i.IdProduto == prod);
return(View(itemPedido));
}
else
{
return(View(new ItemPedidoModel()
{
IdPedido = ped.Value, ValorUnitario = 0, Quantidade = 1
}));
}
}
TempData["mensagem"] = MensagemModel.Serializar("Pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
TempData["mensagem"] = MensagemModel.Serializar("Pedido não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
public async Task <IActionResult> Delete(int idPedido, int idProduto)
{
var itemPedido = await _context.ItensPedidos.FindAsync(idPedido, idProduto);
if (itemPedido != null)
{
_context.ItensPedidos.Remove(itemPedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido excluído com sucesso.");
var pedido = await _context.Pedidos.FindAsync(itemPedido.IdPedido);
pedido.ValorTotal = _context.ItensPedidos
.Where(i => i.IdPedido == itemPedido.IdPedido)
.Sum(i => i.ValorUnitario * i.Quantidade);
await _context.SaveChangesAsync();
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir o item de pedido.", TipoMensagem.Erro);
}
return(RedirectToAction("Index", new { ped = idPedido }));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", new { ped = idPedido }));
}
}
private async Task RunWebSockets()
{
RegistroModel registro = new RegistroModel();
registro = _services_registro.RegistrarInformacoesMaquina();
var client = new ClientWebSocket();
await client.ConnectAsync(new Uri($"ws://{endereco}:{porta}/ws"), CancellationToken.None);
MensagemModel mensagem = new MensagemModel(registro);
await _clientWebSocketSendMessage.Send(client, mensagem.ToString());
Console.WriteLine(">> Connected!");
var sending = Task.Run(async() =>
{
string line;
while ((line = Console.ReadLine()) != null && line != String.Empty)
{
var bytes = Encoding.UTF8.GetBytes(line);
await client.SendAsync(new ArraySegment <byte>(bytes), WebSocketMessageType.Text, true, CancellationToken.None);
}
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
});
var receiving = Receiving(client);
await Task.WhenAll(sending, receiving);
}
public List <RegistroModel> getAllRegistros()
{
List <RegistroModel> registros = new List <RegistroModel>();
try
{
FirebaseResponse response = client.Get(PATH_FIREBASE);
if (!response.Body.Equals("null"))
{
string[] stringArrayJson = formatarStringParaArrayStringJson(response.Body);
foreach (string json in stringArrayJson)
{
registros.Add(JsonConvert.DeserializeObject <RegistroModel>(json));
}
}
else
{
registros = null;
}
}
catch (Exception e)
{
MensagemModel mensagem = new MensagemModel("Erro ao recuperar todos registros", "Não foi possível recuperar os registros, possivelmente devido à problemas de conexão com a internet, tente novamente mais tarde.");
LogModel log = new LogModel(mensagem.Titulo, e.Message, e.StackTrace, DateTime.Now);
LogController.logarErro(log);
MessageBox.Show(mensagem.Corpo, mensagem.Titulo, MessageBoxButtons.OK);
registros = null;
}
return(registros);
}
public void SendToServer(string text)
{
MensagemModel message = new MensagemModel(AcaoMensagemEnum.EnviarTexto, text);
byte[] buffer = message.ToByteArray();
clientSocket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, SendCallback, null);
}
public async Task <IActionResult> Create(int?cid)
{
if (cid.HasValue)
{
var cliente = await _context.Clientes.FindAsync(cid);
if (cliente != null)
{
_context.Entry(cliente).Collection(c => c.Pedidos).Load();
PedidoModel pedido = null;
if (_context.Pedidos.Any(p => p.IdCliente == cid && !p.DataPedido.HasValue))
{
pedido = await _context.Pedidos
.FirstOrDefaultAsync(p => p.IdCliente == cid && !p.DataPedido.HasValue);
}
else
{
pedido = new PedidoModel {
IdCliente = cid.Value, ValorTotal = 0
};
cliente.Pedidos.Add(pedido);
await _context.SaveChangesAsync();
}
return(RedirectToAction("Index", "ItemPedido", new { ped = pedido.IdPedido }));
}
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
TempData["mensagem"] = MensagemModel.Serializar("Cliente não informado", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
public async Task <IActionResult> Create([FromForm] ItemPedidoModel itemPedido)
{
if (ModelState.IsValid)
{
if (itemPedido.IdPedido > 0)
{
var produto = await _context.Produtos.FindAsync(itemPedido.IdProduto);
itemPedido.ValorUnitario = produto.Valor;
if (ItemPedidoExiste(itemPedido.IdPedido, itemPedido.IdProduto))
{
_context.ItensPedidos.Update(itemPedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido alterado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao alterar item de pedido.", TipoMensagem.Erro);
}
}
else
{
_context.ItensPedidos.Add(itemPedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido cadastrado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao cadastrar item de pedido.", TipoMensagem.Erro);
}
}
var pedido = await _context.Pedidos.FindAsync(itemPedido.IdPedido);
pedido.ValorTotal = _context.ItensPedidos
.Where(i => i.IdPedido == itemPedido.IdPedido)
.Sum(i => i.ValorUnitario * i.Quantidade);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", new { ped = itemPedido.IdPedido }));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
else
{
var produtos = _context.Produtos
.OrderBy(x => x.Nome)
.Select(p => new { p.IdProduto, NomePreco = $"{p.Nome} ({p.Valor:C})" })
.AsNoTracking().ToList();
var produtosSelectList = new SelectList(produtos, "IdProduto", "NomePreco");
ViewBag.Produtos = produtosSelectList;
return(View(itemPedido));
}
}
public override async Task ReceiveAsync(WebSocket socket, WebSocketReceiveResult result, byte[] buffer)
{
var socketId = WebSocketConnectionManager.GetId(socket);
var input = Encoding.UTF8.GetString(buffer, 0, result.Count);
MensagemModel mensagem = Newtonsoft.Json.JsonConvert.DeserializeObject <MensagemModel>(input);
await SendMessageToAllAsync(mensagem.ToString());
}
public async Task <IActionResult> Create(int?id, [FromForm] ProdutoModel produto)
{
string wwwwRootPath = _hostEnvironment.WebRootPath;
string fileName = Path.GetFileNameWithoutExtension(produto.ImageFile.FileName);
string extension = Path.GetExtension(produto.ImageFile.FileName);
produto.ImageName = fileName = fileName + DateTime.Now.ToString("yymmssfff") + extension;
string path = Path.Combine(wwwwRootPath + "/Image/", fileName);
using (var fileStream = new FileStream(path, FileMode.Create))
if (ModelState.IsValid)
{
// upload save image to wwwroot/image
{
await produto.ImageFile.CopyToAsync(fileStream);
}
if (id.HasValue)
{
if (ProdutoExiste(id.Value))
{
_context.Produtos.Update(produto);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Produto alterado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao alterar produto.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Produto não encontrado.", TipoMensagem.Erro);
}
}
else
{
_context.Produtos.Add(produto);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Produto cadastrado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao cadastrar produto.", TipoMensagem.Erro);
}
}
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(produto));
}
}
public List <MensagemModel> GetConversa(int idmensagem, String email, String senha)
{
Conexao bd = new Conexao();
try
{
bd.conectar();
#region CommandText
bd.cmd.CommandText =
" " +
" SELECT " +
" DataDeEnvio, " +
" tblDoador.Nome, " +
" tblFuncionario.Nome, " +
" Texto, " +
" Lida " +
" FROM tblMensagem " +
" LEFT JOIN tblDoador " +
" ON tblMensagem.fk_IdDoador = tblDoador.IdDoador " +
" LEFT JOIN tblFuncionario " +
" ON tblMensagem.fk_IdFuncionario = tblFuncionario.IdFuncionario " +
" WHERE tblMensagem.fk_Cnpj LIKE (SELECT fk_Cnpj FROM tblMensagem WHERE IdMensagem = @idmensagem) AND " +
" tblMensagem.fk_IdDoador = (SELECT IdDoador FROM tblDoador WHERE Email LIKE @email AND Senha LIKE @senha) " +
"";
bd.cmd.Parameters.AddWithValue("@idmensagem", idmensagem);
bd.cmd.Parameters.AddWithValue("@email", email);
bd.cmd.Parameters.AddWithValue("@senha", senha);
#endregion
bd.dr = bd.cmd.ExecuteReader();
List <MensagemModel> retorno = new List <MensagemModel>();
if (bd.dr.HasRows)
{
while (bd.dr.Read())
{
MensagemModel mensagem = new MensagemModel();
mensagem.Data = bd.dr[0].ToString();
mensagem.Doador = bd.dr[1].ToString();
mensagem.Funcionario = bd.dr[2].ToString();
mensagem.Texto = bd.dr[3].ToString();
mensagem.Lida = (bd.dr[4].ToString().Equals("True"));
retorno.Add(mensagem);
}
}
bd.cmd.Parameters.Clear();
bd.fechaConexao();
return(retorno);
}
catch (System.Data.SqlClient.SqlException)
{
bd.fechaConexao();
return(null);
}
}
private void _verifyAcaoMensagem(MensagemModel message, Socket requestSocket)
{
if (message.Acao == AcaoMensagemEnum.EnviarTexto)
{
_mensagemServidor.ShowMessageByTcp(message.Text);
}
else if (message.Acao == AcaoMensagemEnum.Desconectar)
{
_removeSocket(requestSocket);
}
}
private void _verifyAcaoMensagem(MensagemModel message)
{
if (message.Acao == AcaoMensagemEnum.EnviarTexto)
{
_mensagemClienteView.ShowMessageByTcp(message.Text);
}
else if (message.Acao == AcaoMensagemEnum.TerminarTransmissao)
{
_mensagemClienteView.Desconectar();
}
}
public IActionResult GetAll(int page = 0, int size = 10)
{
var resultado = negocio.getContato().OrderBy(i => i.idContato).Skip(page).Take(size).ToList();
var msg = new MensagemModel();
if (resultado.Count() == 0)
{
msg.Mensagem = "Nenhum dado retornado!";
return NotFound(msg);
}
return new ObjectResult(resultado);
}
public override async Task OnConnected(WebSocket socket)
{
await base.OnConnected(socket);
var socketId = WebSocketConnectionManager.GetId(socket);
MensagemModel mensagem = new MensagemModel();
mensagem.TipoMensagem = Models.Enum.TipoMensagemEnum.MensagemConectado;
mensagem.data = $"{socketId} is now connected";
await SendMessageToAllAsync(mensagem.ToString());
}
public IActionResult GetById(string id)
{
var item = negocio.getContatoId(id);
var msg = new MensagemModel();
if (item.idContato == 0)
{
msg.Mensagem ="Nenhum dado retornado!" ;
return NotFound(msg);
}
return new ObjectResult(item);
}
// GET: Usuario
public ActionResult Index() //Testando as informações do usuario pegadas no BD
{
try
{
int iduser = ((Usuario)Session["usuario"]).IdPessoa;
int quant;
if (Request.QueryString.Keys.Count > 0)
{
quant = int.Parse(Request.QueryString[0]);
if (quant != 10 && quant != 25 && quant != 50 && quant != 999)
{
ViewBag.ErroQuant = true;
quant = 10;
}
}
else
{
quant = 10;
}
using (UsuarioModel model = new UsuarioModel())
{
ViewBag.ReadU = model.ReadU(iduser);
}
using (UsuarioModel model = new UsuarioModel())
{//Pega informações do usuario que logou e manda paraa view
ViewBag.GetAgeUser = model.GetAgeUser(iduser);
}
using (GrupoModel model = new GrupoModel())
{
ViewBag.ReadGrupo = model.ReadGrupo(iduser); //Retorna os grupos em que o usuario está participando
}
using (GrupoModel model = new GrupoModel())
{
ViewBag.QuantGruposParticipa = model.QuantGruposParticipa(iduser); //Retorna o count de grupos em que o usuario participa
}
using (MensagemModel model = new MensagemModel())
{
ViewBag.ReadMensagemIndex = model.ReadMensagemIndex(iduser, quant); //Exibe no feed as mensagens dos grupos em que o usuario participa TODO: ainda nao sei se mostra de todos que estão no grupo
}
using (MensagemModel model = new MensagemModel())
{
ViewBag.QuantMsgUser = model.QuantMsgUser(iduser);
}
return(View());
}
catch (Exception ex)
{
Console.WriteLine("{0} Exception caught", ex);
return(RedirectToAction("Erro404", "Error"));
}
}
