public async Task <ActionResult> LoginUser([FromBody] Authentication auth)
{
TokenMessage msg = new TokenMessage();
try
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage res = await client.PostAsJsonAsync(new Uri("http://localhost:49939/api/Gateway/data"), auth);
if (res.IsSuccessStatusCode)
{
var Response = res.Content.ReadAsStringAsync().Result;
msg = Newtonsoft.Json.JsonConvert.DeserializeObject <TokenMessage>(Response);
HttpContext.Response.Cookies["access_token"].Value = msg.AccessToken;
HttpContext.Response.Cookies["refresh_token"].Value = msg.RefreshToken;
}
else
{
var Response = res.Content.ReadAsStringAsync().Result;
var str = Newtonsoft.Json.JsonConvert.DeserializeObject <string>(Response);
return(View("SorryPage", (object)str));
}
}
}
catch
{
string str = "Now system is unavailable";
return(View("SorryPage", (object)str));
}
return(View("Description"));
}
public async Task <IHttpActionResult> PostAccessToken([FromBody] AuthCodeModel codeModel)
{
Code code = new Code();
try
{
code = await db.Codes.FirstOrDefaultAsync(x => x.AccessCode == codeModel.Code);
}
catch
{
return(Unauthorized());
}
if (code == null)
{
return(Unauthorized());
}
if (code.Timeofrelease <= DateTime.Now)
{
return(Unauthorized());
}
Owner owner = new Owner();
try
{
owner = await db.Owners.FirstOrDefaultAsync(x => x.RedirectURI == codeModel.RedirectURI);
}
catch
{
return(Unauthorized());
}
Token token = new Token();
try
{
token = await db.Tokens.FirstOrDefaultAsync(x => x.AccessCodeId == code.Id);
}
catch
{
return(Unauthorized());
}
if (token == null)
{
return(Unauthorized());
}
TokenMessage msg = new TokenMessage();
msg.AccessToken = token.AccessToken;
msg.RefreshToken = token.RefreshToken;
msg.TokenType = "Bearer";
return(Ok <TokenMessage>(msg));
}
public async Task <JsonResult> PaypalSetup(string cartId, decimal cartTotal, string carrier = null)
{
// this is the first part of a paypal transaction, which sends a request from P4M to Realex
// when this returns we redirect the consumer to PP in a popup window
var result = new TokenMessage();
try
{
// validate that the cart total from the widget is correct to prevent cart tampering in the browser
cartTotal = Math.Round(cartTotal, 2);
var localCart = ShoppingCart.GetCart(HttpContext);
localCart.CalcTax();
//decimal cartTot = Convert.ToDecimal(cartTotal);
if (cartTotal != localCart.Total)
{
localCart.EmptyCart();
HttpContext.Session[ShoppingCart.CartSessionKey] = null;
throw new Exception("Your cart is invalid and has been cleared. We're sorry for any inconvenience. Please keep shopping");
}
var orderId = await CreateLocalOrderAsync(localCart);
var token = Request.Cookies["p4mToken"].Value;
_httpClient.SetBearerToken(token);
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var purchaseMessage = new PostPurchaseMessage {
CartId = cartId, OrderId = orderId.ToString(), Carrier = carrier
};
var content = new ObjectContent <PostPurchaseMessage>(purchaseMessage, new JsonMediaTypeFormatter());
var apiResult = await _httpClient.PostAsync(_p4mConsts.BaseApiAddress + "paypalSetup", content);
//var apiResult = await _httpClient.GetAsync(string.Format("{0}paypalSetup/{1}", _urls.BaseApiAddress, cartId));
//apiResult.EnsureSuccessStatusCode();
var messageString = await apiResult.Content.ReadAsStringAsync();
var setupResult = JsonConvert.DeserializeObject <TokenMessage>(messageString);
if (!setupResult.Success)
{
if (setupResult.Error.Contains("has already been processed!"))
{
ShoppingCart.GetCart(this).EmptyCart();
HttpContext.Session[ShoppingCart.CartSessionKey] = null;
}
throw new Exception(setupResult.Error);
}
result.Token = setupResult.Token;
}
catch (Exception e)
{
result.Error = e.Message;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Send a message to specified target a registration token.
/// </summary>
/// <param name="isTest">If true, won't send the message to target. It'll just validate it.</param>
/// <param name="message"></param>
/// <returns>If successful, the response body contains an instance of T(MassageBase).</returns>
public async Task <TokenMessage> SendMessage(bool isTest, TokenMessage message)
{
var result = await _fcmApi.SendHttpRequestToTokenAsync(_projectId, new SendRequestBody <TokenMessage>
{
ValidateOnly = isTest,
Message = message
});
message.Name = result.Name;
return(message);
}
public async Task <int> Insert(string sender, string receiver, TokenMessage tokenMessage)
{
var p = PendingTokenMessage.Create(sender, receiver, tokenMessage);
if (p == null)
{
return(-1);
}
var insertedRows = await _database.InsertAsync(p);
return(insertedRows == 1 ? p.ID : -1);
}
public ActionResult Validate([FromBody] TokenMessage token)
{
try
{
parseToken(token.Token);
return(Ok());
}
catch
{
return(Unauthorized());
}
}
public TokenMessage addNewToken(string token_card, string customer_id)
{
ENDPOINT = Constants.url_add_new_token;
PARAMETER = body.getBodyAddNewToken(token_card, customer_id);
string content = _request.Execute(
ENDPOINT,
"POST",
_auxiliars.ConvertToBase64(_PUBLIC_KEY),
PARAMETER);
TokenMessage customer = JsonConvert.DeserializeObject <TokenMessage>(content);
return(customer);
}
public override void OnClientSceneChanged(NetworkConnection conn)
{
if (SceneManager.GetActiveScene().name.StartsWith("Lobby"))
{
if (!string.IsNullOrEmpty(token))
{
//Enviamos mensaje de token
TokenMessage msg = new TokenMessage();
msg.Token = token;
NetworkClient.Send <TokenMessage>(msg);
}
}
base.OnClientSceneChanged(conn);
}
public ActionResult <TokenMessage> Renew([FromBody] TokenMessage token)
{
try
{
var username = parseToken(token.Token);
return(Ok(new TokenMessage
{
Token = generateNewToken(username),
}));
}
catch
{
return(Unauthorized());
}
}
public async Task <JsonResult> GetNewShippingToken()
{
var result = new TokenMessage();
try
{
var resp = await GetGFSTokenAsync();
result.Token = resp.AccessToken;
result.Expires = DateTime.UtcNow.AddSeconds(resp.ExpiresIn).ToString("yyyy-MM-ddThh:mm:ssZ");
}
catch (Exception e)
{
result.Error = e.Message;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public HttpResponseMessage Post(UserDTO user)
{
AuthModel auth = new AuthModel();
HttpResponseMessage responseMessage;
string response = auth.Authenticate(user.Username, user.Password);
if (response != null)
{
string role = auth.GetRole(user.Username);
TokenMessage msg = new TokenMessage(response, role);
responseMessage = Request.CreateResponse(HttpStatusCode.OK, msg);
}
else
{
ErrorMessage msg = new ErrorMessage("Invalid username or password");
responseMessage = Request.CreateResponse(HttpStatusCode.Forbidden, msg);
}
return(responseMessage);
}
public async Task <ActionResult> GenCodes(string code, string state)
{
TokenMessage msg = new TokenMessage();
AuthCodeModel codeModel = new AuthCodeModel();
codeModel.Code = code;
codeModel.RedirectURI = "http://localhost:53722/";
codeModel.GrantType = "code";
codeModel.ClientId = 1;
try
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage res = await client.PostAsJsonAsync(new Uri("http://localhost:49939/api/Gateway/code"), codeModel);
if (res.IsSuccessStatusCode)
{
var Response = res.Content.ReadAsStringAsync().Result;
msg = Newtonsoft.Json.JsonConvert.DeserializeObject <TokenMessage>(Response);
HttpContext.Response.Cookies["access_token"].Value = msg.AccessToken;
HttpContext.Response.Cookies["refresh_token"].Value = msg.RefreshToken;
}
else
{
var Response = res.Content.ReadAsStringAsync().Result;
var str = Newtonsoft.Json.JsonConvert.DeserializeObject <string>(Response);
return(View("SorryPage", (object)str));
}
}
}
catch
{
string str = "Now system is unavailable";
return(View("SorryPage", (object)str));
}
return(View("Description"));
}
public static PendingTokenMessage Create(string sender, string receiver, TokenMessage tokenMessage)
{
if (WalletAddress.Decode58Check(sender) == null)
{
throw new ArgumentException("invalid address", nameof(sender));
}
if (WalletAddress.Decode58Check(receiver) == null)
{
throw new ArgumentException("invalid address", nameof(receiver));
}
if (tokenMessage == null)
{
throw new ArgumentNullException(nameof(tokenMessage));
}
return(new PendingTokenMessage
{
Sender = sender,
Receiver = receiver,
Data = JsonConvert.SerializeObject(tokenMessage)
});
}
/// <summary>
/// Primire username si parola de la client
/// </summary>
/// <param name="user">obiect care contine username si parola</param>
/// <returns>token</returns>
public HttpResponseMessage Post(UserDTO user)
{
var auth = new AuthModel();
HttpResponseMessage responseMessage;
var response = auth.Authenticate(user.Username, user.Password);
if (response != null)
{
// Username si parola valide
var role = auth.GetRole(user.Username);
var msg = new TokenMessage(response, role);
responseMessage = Request.CreateResponse(HttpStatusCode.OK, msg);
}
else
{
//invalid username and password
var msg = new JSendMessage("fail", "Invalid username or password");
responseMessage = Request.CreateResponse(HttpStatusCode.Forbidden, msg);
}
return(responseMessage);
}
public HttpResponseMessage Post(UserDTO user)
{
HttpResponseMessage responseMessage;
string response = auth.Authenticate(user.Email, user.Password);
//string response = "123";
if (response != null)
{
// Username si parola valide
string role = users.GetUserRole(user.Email);
//string role = "admin";
TokenMessage msg = new TokenMessage(response, role);
responseMessage = Request.CreateResponse(HttpStatusCode.OK, msg);
}
else
{
//invalid username and password
JSendMessage msg = new JSendMessage("fail", "Invalid username or password");
responseMessage = Request.CreateResponse(HttpStatusCode.Forbidden, msg);
}
return(responseMessage);
}
private IEnumerator OnServerTokenMessageCoroutine(NetworkConnection conn, TokenMessage msg)
{
if (tokens.Contains(msg.Token)) // Si el token coincide con uno que nos hayan pasado
{
if (modoServidor == ServidorPartida)
{
ChangeUIMessage uimsg = new ChangeUIMessage(UI_Prepartida);
conn.Send <ChangeUIMessage>(uimsg);
KeyValuePair <string, NetworkConnection> dupla = new KeyValuePair <string, NetworkConnection>(msg.Token, conn);
tokenConnection.Add(dupla);
// Esto lo hago aquí porque es individual para cada uno
// if (rondaAJugar == maxRondas) // Si toca el combate final
// {
// int i = 0;
// while (!clasificacionActualizada && i < intentosConexion)
// {
// ++i;
// yield return new WaitForSeconds(tiempoEsperaConexion);
// }
// if (!clasificacionActualizada)
// {
// print("Agotado tiempo de espera, mensaje de clasificación no recibido");
// }
// else
// {
// int index = clasificacionOrdenada.FindIndex(p => p.Key == msg.Token);
// if (index >= 2) // Si no entra en la final
// {
// GameEndedMessage result = new GameEndedMessage();
// result.Puesto = index;
// conn.Send<GameEndedMessage>(result);
// }
// }
// }
// if(clasificacionActualizada)
// {
// clasificacionOrdenada = managerClasification.GetClasificacionOrdenada();
// List<string> tokensOrdenados = new List<string>();
// List<int[]> resultados = new List<int[]>();
// foreach (var kvp in clasificacionOrdenada)
// {
// tokensOrdenados.Add(kvp.Key);
// resultados.Add(kvp.Value);
// }
// TablaClasificacionMessage result = new TablaClasificacionMessage();
// result.Tokens = tokensOrdenados;
// result.Resultados = resultados;
// conn.Send<TablaClasificacionMessage>(result);
// print("Mandamos mensaje de tablaclasificacion");
// }
/*
* ¿POR QUÉ HAGO ESTO?
*
* " O sea, me da igual que estén todos, no tengo que actualizarlos a todos a la vez.
* Si tengo la clasificación actualizada, puedo mandársela a cada uno cuando venga y ya está.
*
* Si me espero a todos, es "peor" porque va a haber un momento en el que tenga la clasificación toh mal. "
*
* MAL - Los primeros que lleguen no van a tener la clasificacion bien, se quedan en prepartida, necesito
* hacerlo de esta forma para asegurarme que les llega a todos.
*
* Curiosidad: Lo de antes funcionaba porque en el while de maxrondas==rondaajugar no habia un ++i
* así que esperaba para siempre en todos los clientes, por lo que siempre llegaba bien.
*/
serverPlayers++;
print("OnServerTokenMessage: serverPlayers: " + serverPlayers + " --- MaxPlayers: " + maxPlayers);
if (serverPlayers == maxPlayers) // Si estamos todos los jugadores
{
int i = 0;
while (!clasificacionActualizada && i < intentosConexion) // Esperar a la clasificacion es mejor que esperar a los jugadores
{
++i;
yield return(new WaitForSeconds(tiempoEsperaConexion));
}
if (!clasificacionActualizada)
{
print("Agotado tiempo de espera, mensaje de clasificación no recibido");
rondaAJugar--; // ¿Repetir la ronda?
}
clasificacionOrdenada = managerClasification.GetClasificacionOrdenada();
TablaClasificacionMessage clasificacionMessage = new TablaClasificacionMessage();
List <string> tokensOrdenados = new List <string>();
List <int[]> resultados = new List <int[]>();
foreach (var kvp in clasificacionOrdenada)
{
tokensOrdenados.Add(kvp.Key);
resultados.Add(kvp.Value);
}
clasificacionMessage.Tokens = tokensOrdenados;
clasificacionMessage.Resultados = resultados;
if (rondaAJugar == maxRondas) // Toca la final
{
foreach (var tk in tokens)
{
int index = clasificacionOrdenada.FindIndex(p => p.Key == tk);
if (index >= 2) // Si no entra en la final
{
GameEndedMessage result = new GameEndedMessage();
result.Puesto = index;
NetworkConnection connection = tokenConnection.Find(p => p.Key == tk).Value;
connection.Send <GameEndedMessage>(result);
}
else if (index >= 0) //Entra en la final
{
NetworkConnection connection = tokenConnection.Find(p => p.Key == tk).Value;
connection.Send <TablaClasificacionMessage>(clasificacionMessage);
}
else
{
print("Usuario no encontrado");
}
}
}
else if (rondaAJugar > maxRondas) // Si estamos todos y ya no toca nada más, pasamos mensaje a los de la final
{
GameEndedMessage gameEndedMessage = new GameEndedMessage();
for (i = 0; i < maxPlayers; ++i) // maxPlayers es el maxPlayers original dividido por 2
{
gameEndedMessage.Puesto = i;
string tk = clasificacionOrdenada[i].Key;
NetworkConnection connection = tokenConnection.Find(p => p.Key == tk).Value;
connection.Send <GameEndedMessage>(gameEndedMessage);
}
partidaFinalizada = true; // Oficialmente hemos acabado la partida
}
else
{
NetworkServer.SendToAll <TablaClasificacionMessage>(clasificacionMessage);
print("Se envía mensaje de tabla de clasificación");
}
}
}
else if (modoServidor == ServidorCombate)
{
KeyValuePair <string, NetworkConnection> dupla = new KeyValuePair <string, NetworkConnection>(msg.Token, conn);
tokenConnection.Add(dupla);
CombatUsersMessage cumsg = new CombatUsersMessage();
cumsg.Users = users;
conn.Send <CombatUsersMessage>(cumsg);
}
}
else // Si no es correcto, conn.Disconnect()
{
print("Token no encontrado");
conn.Disconnect();
}
}
/****************************************************************************/
/************** FUNCIONES PARA MENSAJES EN SERVIDOR ***************/
/****************************************************************************/
private void OnServerTokenMessageHandler(NetworkConnection conn, TokenMessage msg)
{
print("Recibido TokenMessage: (" + msg.Token + ")");
StartCoroutine(OnServerTokenMessageCoroutine(conn, msg));
}
public async Task <ActionResult> DrawStatistic()
{
int i = 0;
StatisticInformation Information = new StatisticInformation();
try
{
using (HttpClient test = new HttpClient())
{
bool flag = false;
while (!flag)
{
test.DefaultRequestHeaders.Clear();
test.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
test.DefaultRequestHeaders.Add("Authorization", "Bearer " + HttpContext.Request.Cookies["access_token"].Value);
HttpResponseMessage res = await test.GetAsync("http://localhost:49939/api/gateway/GetStatistic");
if (res.IsSuccessStatusCode)
{
var Response = res.Content.ReadAsStringAsync().Result;
Information = Newtonsoft.Json.JsonConvert.DeserializeObject <StatisticInformation>(Response);
flag = true;
}
else
{
var EmpResponse = res.Content.ReadAsStringAsync().Result;
string str = Newtonsoft.Json.JsonConvert.DeserializeObject <string>(EmpResponse);
if (str != null)
{
return(View("SorryPage", (object)str));
}
if ((res.StatusCode == System.Net.HttpStatusCode.Unauthorized) && (i == 0))
{
test.DefaultRequestHeaders.Clear();
test.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
TokenMessage Message = new TokenMessage();
RefreshToken Refresh = new RefreshToken();
Refresh.Token = HttpContext.Request.Cookies["refresh_token"].Value;
res = await test.PostAsJsonAsync("http://localhost:49939/api/gateway/refresh", Refresh);
if (res.IsSuccessStatusCode)
{
var Response2 = res.Content.ReadAsStringAsync().Result;
Message = Newtonsoft.Json.JsonConvert.DeserializeObject <TokenMessage>(Response2);
HttpContext.Request.Cookies["access_token"].Value = Message.AccessToken;
HttpContext.Request.Cookies["refresh_token"].Value = Message.RefreshToken;
HttpContext.Response.Cookies["access_token"].Value = Message.AccessToken;
HttpContext.Response.Cookies["refresh_token"].Value = Message.RefreshToken;
i++;
}
else
{
return(View("SorryPage", (object)"Ошибка обновления токена. Пожалуйста повторите позже"));
}
}
return(View("SorryPage", (object)str));
}
}
}
}
catch
{
string str = "Now system is unavailable";
return(View("SorryPage", (object)str));
}
return(View(Information));
}
public async Task <IHttpActionResult> PostRefresh([FromBody] RefreshToken key)
{
Token token = new Token();
try
{
token = await db.Tokens.FirstOrDefaultAsync(x => x.RefreshToken == key.Token);
}
catch
{
return(Unauthorized());
}
if (token == null)
{
return(Unauthorized());
}
if (token.TimeOfReleaseRefreshToken <= DateTime.Now)
{
return(Unauthorized());
}
token.TimeOfReleaseAccessToken = token.TimeOfReleaseAccessToken.Value.AddYears(-1);
token.TimeOfReleaseRefreshToken = token.TimeOfReleaseRefreshToken.Value.AddYears(-1);
db.Entry(token).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (Exception ex)
{
return(InternalServerError());
}
User TMP = new User();
try
{
TMP = await db.Users.FindAsync(token.UserId);
}
catch
{
return(Unauthorized());
}
if (TMP == null)
{
return(Unauthorized());
}
string source1 = DateTime.Now.ToString() + "|" + TMP.UserName + "|" + TMP.UserRole;
string source2 = DateTime.Now.ToString() + "|" + TMP.UserName + "|" + TMP.UserRole;
string Tokenstr = HashPassword(source1);
string Refreshstr = HashPassword(source2);
Token TempToken = new Token();
TempToken.AccessToken = Tokenstr;
TempToken.RefreshToken = Refreshstr;
TempToken.TimeOfReleaseAccessToken = DateTime.Now.AddMinutes(5);
TempToken.TimeOfReleaseRefreshToken = DateTime.Now.AddMinutes(10);
TempToken.UserId = TMP.Id;
TempToken.AccessCodeId = 2;
db.Tokens.Add(TempToken);
try
{
await db.SaveChangesAsync();
}
catch (Exception ex)
{
return(InternalServerError());
}
TokenMessage msg = new TokenMessage();
msg.AccessToken = TempToken.AccessToken;
msg.RefreshToken = TempToken.RefreshToken;
msg.TokenType = "Bearer";
return(Ok <TokenMessage>(msg));
}
public async Task <int> AddAsync(string sender, string receiver, TokenMessage tokenMessage)
{
return(await _database.PendingTokenMessages.Insert(sender, receiver, tokenMessage));
}
public object LoginAndRrgister([FromBody] JObject obj)
{
string appid = "wx4a873d58da246519";
string secret = "65f3c061efbc76fe6a93a9c26c0fc9ef";
byte[] bs = Encoding.ASCII.GetBytes(obj["Code"].ToString()); //参数转化为ascii码
HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create("https://api.weixin.qq.com/sns/oauth2/access_token?appid=" + appid + "&secret=" + secret + "&code=" + obj["Code"].ToString() + "&grant_type=authorization_code"); //创建请求
req.Method = "POST"; //确定传值的方式，此处为post方式传值
req.ContentType = "application/x-www-form-urlencoded";
req.ContentLength = bs.Length;
using (Stream reqStream = req.GetRequestStream())
{
reqStream.Write(bs, 0, bs.Length);
}
using (WebResponse wr = req.GetResponse())
{
//在这里对接收到的页面内容进行处理(第一次 通过code查openid 和 access_token)
//坑 这里需要把流数据解析出来再放到字符串
string codeVal = new StreamReader(wr.GetResponseStream()).ReadToEnd(); //解析出来再放到字符串
TokenMessage jsonData = JsonConvert.DeserializeObject <TokenMessage>(codeVal); //反序列化成json
TokenMessage tsave = new TokenMessage(); //实例化一个接收两个参数的类
tsave.openid = jsonData.openid; //赋值接收到的值
tsave.access_token = jsonData.access_token; //赋值接收到的值
if (string.IsNullOrEmpty(tsave.openid) || string.IsNullOrEmpty(tsave.access_token)) //如果请求失败
{
return(code.SystemError("微信Code第一步验证出问题了,有可能code过期，需要前端重新访问获取code的地址"));
}
//再次请求api
HttpWebRequest req2 = (HttpWebRequest)HttpWebRequest.Create("https://api.weixin.qq.com/sns/userinfo?access_token=" + tsave.access_token + "&openid=" + tsave.openid + "&lang=zh_CN");
req2.Method = "GET";
using (WebResponse wr2 = req2.GetResponse())
{
string codeVal2 = new StreamReader(wr2.GetResponseStream()).ReadToEnd(); //解析出来再放到字符串
if (string.IsNullOrEmpty(codeVal2)) //如果请求失败
{
return(code.SystemError("code第二步骤验证出问题了"));
}
//序列化成json
TokenMessage jsonval = JsonConvert.DeserializeObject <TokenMessage>(codeVal2);
var cc = jk.User_JK.Where(a => a.OpenID == jsonData.openid).FirstOrDefault();
if (cc == null) //如果没有注册
{
User_JK res = new User_JK();
res.OpenID = jsonval.openid;
res.WeChatName = jsonval.nickname; //微信名字
res.HeadImg = jsonval.headimgurl;
res.IsChou = false;
jk.User_JK.Add(res);
jk.SaveChanges();
return(code.SussessV("201", "新用户注册成功", res));
}
else //如果注册了
{
return(code.Sussess("登录成功", cc));
}
}
}
}
