public async Task Insert(UsuarioDTO usuario)
{
if (string.IsNullOrWhiteSpace(usuario.Nome))
{
AddError("Descricao", "Descricao deve ser informada.");
}
else
{
usuario.Nome = usuario.Nome.Trim();
if (usuario.Nome.Length < 5 || usuario.Nome.Length > 60)
{
AddError("Descricao", "A descricao deve conter entre 5 a 60 caracteres.");
}
}
CheckErros();
try
{
using (SSContext context = new SSContext())
{
context.Usuarios.Add(usuario);
await context.SaveChangesAsync();
}
}
catch (Exception ex)
{
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados, contate o administrador.");
}
}
private void SocketData(int source, int session, string method, byte[] param)
{
NetSprotoType.SocketData socketData = new NetSprotoType.SocketData(param);
long connectionId = socketData.connection;
byte[] tempParam = Convert.FromBase64String(socketData.buffer);
SkynetClusterRequest req = m_skynetPacketManager.UnpackSkynetRequest(tempParam);
if (req == null)
{
return;
}
NetProtocol instance = NetProtocol.GetInstance();
int tag = instance.GetTag("RPC");
RPCParam sprotoRequest = (RPCParam)instance.Protocol.GenRequest(tag, req.Data);
byte[] targetParam = Convert.FromBase64String(sprotoRequest.param);
if (req.Session > 0)
{
SSContext context = new SSContext();
context.IntegerDict["RemoteSession"] = req.Session;
context.LongDict["ConnectionId"] = connectionId;
Call(req.ServiceName, sprotoRequest.method, targetParam, context, TransferCallback);
}
else
{
Send(req.ServiceName, sprotoRequest.method, targetParam);
}
}
public async Task Insert(ProdutoDTO produto)
{
if (string.IsNullOrWhiteSpace(produto.Descricao))
{
base.AddError("Descricao", "Descrição deve ser informada.");
}
else
{
produto.Descricao = produto.Descricao.Trim();
if (produto.Descricao.Length < 5 || produto.Descricao.Length > 150)
{
base.AddError("Descricao", "Descrição deve ter entre 5 e 150 caracteres.");
}
}
if (produto.Preco <= 0)
{
base.AddError("Preco", "O preço não pode ser menor ou igual a zero.");
}
base.CheckErrors();
try
{
using (SSContext context = new SSContext())
{
context.Produtos.Add(produto);
await context.SaveChangesAsync();
}//context.Dispose();
}
catch (Exception ex)
{
throw new Exception("Erro no banco de dados.");
}
}
//add product
public List <Product> GetProducts()
{
using (var context = new SSContext())
{
return(context.Products.ToList());
}
}
public async Task Insert(CategoriaDTO categoria)
{
#region VALIDAÇÃO NOME
if (string.IsNullOrWhiteSpace(categoria.Nome))
{
base.AddError("A categoria deve ser informada.", "Categoria");
}
else
{
categoria.Nome = categoria.Nome.Trim();
if (categoria.Nome.Length < 5 || categoria.Nome.Length > 40)
{
base.AddError("O nome da categoria deve conter entre 5 e 40 caracteres.", "Categoria");
}
}
#endregion
base.CheckErrors();
#region VALIDAÇÃO ERROS
try
{
using (SSContext context = new SSContext())
{
context.Categoria.Add(categoria);
await context.SaveChangesAsync();
}
}
catch (Exception ex)
{
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados, contate do administrador.");
}
#endregion
}
public async Task <List <CategoriaDTO> > GetCategorias()
{
using (SSContext context = new SSContext())
{
return(await context.Categorias.ToListAsync());
}
}
public async Task Insert(UsuarioDTO usuario)
{
List <Error> errors = new List <Error>();
if (string.IsNullOrWhiteSpace(usuario.Nome))
{
base.AddError("Nome", "Nome deve ser informado");
}
else if (usuario.Nome.Length < 5 || usuario.Nome.Length > 50)
{
base.AddError("Nome", "O nome deve conter entre 5 e 50 caracteres");
}
//APÓS VALIDAR TODOS OS CAMPOS, VERIFIQUE SE POSSUIMOS ERROS
base.CheckErrors();
try
{
using (SSContext context = new SSContext())
{
context.Usuarios.Add(usuario);
await context.SaveChangesAsync();
}
}
catch (Exception ex)
{
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados, contate o admnistrador.");
}
}
private void RemoteResponseCallback(SSContext context, string method, byte[] param, RPCError error)
{
long connectionId = context.LongDict["ConnectionId"];
int remoteSession = context.IntegerDict["RemoteSession"];
int sourceSession = context.IntegerDict["SourceSession"];
int source = context.IntegerDict["Source"];
string sourceMethod = context.StringDict["Method"];
if (error == RPCError.OK)
{
DoResponse(source, sourceMethod, param, sourceSession);
}
else
{
DoError(source, sourceSession, error, "RemoteCall Error");
}
Dictionary <int, WaitForResponseRequest> waitForResponseDict = null;
bool isExist = m_conn2sessions.TryGetValue(connectionId, out waitForResponseDict);
if (isExist)
{
waitForResponseDict.Remove(remoteSession);
}
}
//edit categoroy
public Product GetProduct(int ID)
{
using (var context = new SSContext())
{
return(context.Products.Find(ID));
}
}
//edit categoroy
public Category GetCategory(int ID)
{
using (var context = new SSContext())
{
return(context.Categories.Find(ID));
}
}
//add category
public List <Category> GetCategories()
{
using (var context = new SSContext())
{
return(context.Categories.ToList());
}
}
public async Task <List <CategoriaDTO> > GetCategorias(int page, int size)
{
using (SSContext context = new SSContext())
{
return(await context.Categorias.Skip(page *size).Take(size).ToListAsync());
}
}
public async Task Insert(ClienteDTO cliente)
{
if (string.IsNullOrWhiteSpace(cliente.Nome))
{
AddError("Nome", "Nome deve ser informado.");
}
else if (cliente.Nome.Length < 5 || cliente.Nome.Length > 50)
{
AddError("Nome", "O nome deve conter entre 5 a 50 caracteres.");
}
//Após validar todos os campos, verifique se possuimos erros.
CheckErros();
try
{
using (SSContext context = new SSContext())
{
context.Clientes.Add(cliente);
await context.SaveChangesAsync();
}
}
catch (Exception ex)
{
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados, contate o administrador.");
}
}
//create
public void SaveCategory(Category category)
{
using (var context = new SSContext())
{
context.Categories.Add(category);
context.SaveChanges();
}
}
//create
public void SaveProduct(Product product)
{
using (var context = new SSContext())
{
context.Products.Add(product);
context.SaveChanges();
}
}
//update
public void UpdateProduct(Product product)
{
using (var context = new SSContext())
{
context.Entry(product).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
}
}
//update
public void UpdateCategory(Category category)
{
using (var context = new SSContext())
{
context.Entry(category).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
}
}
public void TimeoutCallback(SSContext context, long currentTime)
{
SkynetMessageSender_OnProcessRequest request = new SkynetMessageSender_OnProcessRequest();
request.request_count = 123456;
request.request_text = "hello skynet";
RemoteCall("testserver", ".test_send_skynet", "send_skynet", request.encode(), null, OnProcessResponse);
this.TestSendMsg();
}
//delete
public void DeleteCategory(Category category)
{
using (var context = new SSContext())
{
//var category = context.Categories.Find(ID);
context.Entry(category).State = System.Data.Entity.EntityState.Deleted;
//OR
//context.Categories.Remove(category);
context.SaveChanges();
}
}
//delete
public void DeleteProduct(Product product)
{
using (var context = new SSContext())
{
//product = context.Products.Find(ID);
context.Entry(product).State = System.Data.Entity.EntityState.Deleted;
//OR
context.Products.Remove(product);
context.SaveChanges();
}
}
private void SendRequestCallback(SSContext context, string method, byte[] param, RPCError error)
{
if (error == RPCError.OK)
{
BattleTaskConsumer_OnBattleRequestResponse response = new BattleTaskConsumer_OnBattleRequestResponse(param);
LoggerHelper.Info(m_serviceAddress, string.Format("TestSender <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Response"));
}
else
{
LoggerHelper.Info(m_serviceAddress, Encoding.ASCII.GetString(param));
}
}
private void RemoteRequest(int source, string method, NetSprotoType.ClusterClientRequest request, long connectionId, int session)
{
int tag = NetProtocol.GetInstance().GetTag("RPC");
RPCParam rpcParam = new RPCParam();
rpcParam.method = request.method;
rpcParam.param = request.param;
if (m_totalRemoteSession >= Int32.MaxValue)
{
m_totalRemoteSession = 0;
}
int remoteSession = ++m_totalRemoteSession;
List <byte[]> buffers = m_skynetPacketManager.PackSkynetRequest(request.remoteService, remoteSession, tag, rpcParam.encode());
SSContext rpcContext = new SSContext();
rpcContext.LongDict["ConnectionId"] = connectionId;
rpcContext.IntegerDict["RemoteSession"] = remoteSession;
rpcContext.IntegerDict["SourceSession"] = session;
rpcContext.IntegerDict["Source"] = source;
rpcContext.StringDict["Method"] = method;
RPCResponseContext rpcResponseCallback = new RPCResponseContext();
rpcResponseCallback.Callback = RemoteResponseCallback;
rpcResponseCallback.Context = rpcContext;
m_remoteResponseCallbacks.Add(remoteSession, rpcResponseCallback);
Dictionary <int, WaitForResponseRequest> waitResponseDict = null;
bool isExist = m_conn2sessions.TryGetValue(connectionId, out waitResponseDict);
if (!isExist)
{
waitResponseDict = new Dictionary <int, WaitForResponseRequest>();
m_conn2sessions.Add(connectionId, waitResponseDict);
}
WaitForResponseRequest waitForResponseRequest = new WaitForResponseRequest();
waitForResponseRequest.Session = session;
waitForResponseRequest.Source = source;
waitResponseDict.Add(remoteSession, waitForResponseRequest);
NetworkPacket networkPacket = new NetworkPacket();
networkPacket.ConnectionId = connectionId;
networkPacket.TcpObjectId = m_tcpObjectId;
networkPacket.Buffers = buffers;
networkPacket.Type = SocketMessageType.DATA;
NetworkPacketQueue.GetInstance().Push(networkPacket);
}
private void DoRequest(SSContext context, long currentTime)
{
TestServer_OnRequest request = new TestServer_OnRequest();
request.request_time = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
request.request_text = "hello my friend";
LoggerHelper.Info(m_serviceAddress, string.Format(">>>>>>>>>>>>>>>>Request Call Time:{0} info:{1}", request.request_time, request.request_text));
RemoteCall("testserver", "RPCTestServer", "OnRequest", request.encode(), null, DoRequestCallback);
LoggerHelper.Info(m_serviceAddress, string.Format(">>>>>>>>>>>>>>>>Request Send Time:{0} info:{1}", request.request_time, request.request_text));
RemoteSend("testserver", "RPCTestServer", "OnRequest", request.encode());
}
private void DoRequestCallback(SSContext context, string method, byte[] param, RPCError error)
{
if (error == RPCError.OK)
{
TestServer_OnRequestResponse response = new TestServer_OnRequestResponse(param);
LoggerHelper.Info(m_serviceAddress, string.Format("<<<<<<<<<<<<<<<<Response OK Time:{0} info:{1}", response.response_time, response.response_text));
Timeout(null, 10, DoRequest);
}
else
{
LoggerHelper.Info(m_serviceAddress, string.Format("<<<<<<<<<<<<<<<<Response Error code:{0} error text:{1}", (int)error, Encoding.ASCII.GetString(param)));
}
}
public async Task <List <ProdutoDTO> > GetData()
{
try
{
using (SSContext context = new SSContext())
{
return(await context.Produtos.ToListAsync());
}
}
catch (Exception ex)
{
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados, contate o administrador.");
}
}
public async Task <List <CategoriaDTO> > GetCategories(int page, int size)
{
try
{
using (SSContext context = new SSContext())
{
//List<ClienteDTO> clientes = context.Clientes.ToListAsync();
//return clientes;
return(await context.Categoria.ToListAsync());
}
}
catch (Exception ex)
{
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados, contate do administrador.");
}
}
//VOID????? CADÊ O RESPONSE??????
public async Task Insert(CategoriaDTO categoria)
{
if (string.IsNullOrWhiteSpace(categoria.Nome))
{
AddError("Nome", "O nome deve ser informado.");
}
else
{
categoria.Nome = categoria.Nome.Trim();
if (categoria.Nome.Length < 2 || categoria.Nome.Length > 70)
{
AddError("Nome", "Nome deve conter entre 2 e 70 caracteres.");
}
}
try
{
using (SSContext context = new SSContext())
{
//Irá no banco procurar se a categoria com este nome
//já foi cadastrado
CategoriaDTO categoriaJaCadastrada = await
context.Categorias.FirstOrDefaultAsync(c => c.Nome == categoria.Nome);
if (categoriaJaCadastrada != null)
{
//Se entrou aqui, categoria já cadastrada, lançar um erro!
//OU, NO MELHOR DOS CASOS, CRIAR UM RESPONSE.
throw new NecoException("Categoria já cadastrada!");
}
context.Categorias.Add(categoria);
await context.SaveChangesAsync();
}
}
catch (Exception ex)
{
if (ex is NecoException)
{
throw ex;
}
//TODO:
//Logar Erro em algum lugar
throw new Exception("Erro no banco de dados, contate o administrador.");
}
}
public async Task Insert(CategoriaDTO categoria)
{
if (string.IsNullOrWhiteSpace(categoria.Nome))
{
AddError("Nome", "Nome deve ser informado.");
}
else if (categoria.Nome.Length < 5 || categoria.Nome.Length > 50)
{
AddError("Nome", "O nome deve conter entre 5 a 50 caracteres.");
}
//Após validar todos os campos, verifique se possuimos erros.
CheckErros();
try
{
using (SSContext context = new SSContext())
{
//Irá no banco procurar se a categoria com este nome já foi cadastrada.
CategoriaDTO categoriaJaCadastrada = await context.Categorias.FirstOrDefaultAsync(c => c.Nome.Equals(categoria.Nome));
if (categoriaJaCadastrada != null)
{
//Se entrou aqui, categoria já cadastrada.
//Ou no melhor dos casos, criar um response.
throw new NecoException("Categoria já cadastrada!");
}
context.Categorias.Add(categoria);
await context.SaveChangesAsync();
}
}
catch (Exception ex)
{
if (ex is NecoException)
{
throw ex;
}
//TODO: Logar o erro em algum lugar.
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados, contate o administrador.");
}
}
private void OnBattleRequestCallback(SSContext context, string method, byte[] param, RPCError error)
{
int source = context.IntegerDict["source"];
int session = context.IntegerDict["session"];
if (error == RPCError.OK)
{
BattleTaskConsumer_OnBattleRequestResponse consumerResponse = new BattleTaskConsumer_OnBattleRequestResponse(param);
BattleTaskDispatcher_OnBattleRequestResponse dispatcherResponse = new BattleTaskDispatcher_OnBattleRequestResponse();
dispatcherResponse.method = "OnBattleRequest";
dispatcherResponse.param = consumerResponse.param;
DoResponse(source, dispatcherResponse.method, dispatcherResponse.encode(), session);
}
else
{
DoError(source, session, error, Encoding.ASCII.GetString(param));
}
}
private void TransferCallback(SSContext context, string method, byte[] param, RPCError error)
{
if (error == RPCError.OK)
{
int tag = NetProtocol.GetInstance().GetTag("RPC");
RPCParam rpcParam = new RPCParam();
rpcParam.method = method;
rpcParam.param = Convert.ToBase64String(param);
int remoteSession = context.IntegerDict["RemoteSession"];
long connectionId = context.LongDict["ConnectionId"];
List<byte[]> bufferList = m_skynetPacketManager.PackSkynetResponse(remoteSession, tag, rpcParam.encode());
NetworkPacket rpcMessage = new NetworkPacket();
rpcMessage.Type = SocketMessageType.DATA;
rpcMessage.TcpObjectId = m_tcpObjectId;
rpcMessage.Buffers = bufferList;
rpcMessage.ConnectionId = connectionId;
NetworkPacketQueue.GetInstance().Push(rpcMessage);
}
else
{
int remoteSession = context.IntegerDict["RemoteSession"];
long connectionId = context.LongDict["ConnectionId"];
List<byte[]> bufferList = m_skynetPacketManager.PackErrorResponse(remoteSession, Encoding.ASCII.GetString(param));
NetworkPacket rpcMessage = new NetworkPacket();
rpcMessage.Type = SocketMessageType.DATA;
rpcMessage.TcpObjectId = m_tcpObjectId;
rpcMessage.Buffers = bufferList;
rpcMessage.ConnectionId = connectionId;
NetworkPacketQueue.GetInstance().Push(rpcMessage);
LoggerHelper.Info(m_serviceAddress,
string.Format("Service:ClusterServer Method:TransferCallback errorCode:{0} errorText:{1}", (int)error, Encoding.ASCII.GetString(param)));
}
}