public void HandleMessage(AcceptExchangeRequest message)
{
//the other player accepted our request, send data to him
DataMessageBuilder builder = new DataMessageBuilder(message.senderPlayerId);
builder.SetGoalFields(Player.game.Fields.Cast<Common.Schema.Field>().Where(f => f is Common.Schema.GoalField).Cast<Common.Schema.GoalField>());
builder.SetTaskFields(Player.game.Fields.Cast<Common.Schema.Field>().Where(f => f is TaskField).Cast<TaskField>());
builder.SetPieces(Player.game.Pieces);
builder.SetPlayerLocation(Player.game.Location);
var data = builder.GetXml();
Player.Send(data);
//do not call play, we call play already when we get our data
}
public async Task HandleMessage(AuthorizeKnowledgeExchange message, Socket handler)
{
if (!ValidateMessage(message))
{
return;
}
var playerFrom = Players.Where(p => p.Guid == message.playerGuid).Single();
var playerTo = Players.Where(p => p.Id == message.withPlayerId).SingleOrDefault();
await Task.Delay((int)GameMasterClient.Settings.ActionCosts.KnowledgeExchangeDelay);
if (playerTo == null)
{
var permanentReject = new RejectKnowledgeExchange()
{
permanent = true,
playerId = playerFrom.Id
};
GameMasterClient.Connection.SendFromClient(handler, XmlMessageConverter.ToXml(permanentReject));
return;
}
if (playerTo.OpenExchangeRequests.Contains(playerFrom.Id))
{
var accept = new AcceptExchangeRequest()
{
playerId = playerTo.Id,
senderPlayerId = playerFrom.Id
};
playerTo.OpenExchangeRequests.Remove(playerFrom.Id);
GameMasterClient.Connection.SendFromClient(handler, XmlMessageConverter.ToXml(accept));
return;
}
var response = new KnowledgeExchangeRequest()
{
playerId = playerTo.Id,
senderPlayerId = playerFrom.Id
};
playerFrom.OpenExchangeRequests.Add(playerTo.Id);
GameMasterClient.Connection.SendFromClient(handler, XmlMessageConverter.ToXml(response));
}
/// <summary>
/// Accept an exchange request.
/// <param name="apiKey">Your apiKey.</param>
/// <param name="apiSecret">Your apiSecretKey.</param>
/// <param name="address"/>The address that funds the source amount.</parm>
/// <param name="privateKey">The privateKey of the sending address.</param>
/// </summary>
/// <returns></returns>
public async Task <Result <bool, ErrorResponse> > AcceptExchangeRequestAsync(
string apiKey,
string apiSecret,
string address,
string privateKey,
AcceptExchangeRequest exchangeRequest)
{
#region
IEnumerable <ValidationResult> validation = exchangeRequest.Validate();
if (validation.Any())
{
foreach (var item in validation)
{
throw new ArgumentNullException(item.ErrorMessage);
}
}
if (string.IsNullOrWhiteSpace(address))
{
throw new ArgumentNullException(address);
}
else if (string.IsNullOrWhiteSpace(privateKey))
{
throw new ArgumentNullException(nameof(privateKey));
}
#endregion
string token = getAuthToken(apiKey, apiSecret);
var result = new Result <bool, ErrorResponse>();
string requestUri = $"{mEnv.BaseUrl}/v1/ExchangeRequests/{exchangeRequest.ID}";
string reserveTxnSinatrue = null;
string executeTxnSignature = null;
string reclaimTxnSignature = null;
BigInteger nonce = BigInteger.Parse(GluwaService.GetNonceString());
if (exchangeRequest.Conversion.Value.IsSourceCurrencyBtc())
{
BtcTxnSignature txnSignature = await getBtcTxnSignaturesAsync(
exchangeRequest.Conversion.Value.ToSourceCurrency(),
address,
exchangeRequest.SourceAmount,
exchangeRequest.Fee,
exchangeRequest.DestinationAddress,
exchangeRequest.ReservedFundsAddress,
exchangeRequest.ReservedFundsRedeemScript,
privateKey);
reserveTxnSinatrue = txnSignature.ReserveTxnSignature;
executeTxnSignature = txnSignature.ExecuteTxnSignature;
reclaimTxnSignature = txnSignature.ReclaimTxnSignature;
}
else
{
BigInteger convertExpiryBlockNumber = BigInteger.Parse(exchangeRequest.ExpiryBlockNumber.ToString());
reserveTxnSinatrue = getGluwacoinReserveTxnSignature(
exchangeRequest.Conversion.Value.ToSourceCurrency(),
address,
exchangeRequest.SourceAmount,
exchangeRequest.Fee,
exchangeRequest.DestinationAddress,
exchangeRequest.Executor,
nonce,
convertExpiryBlockNumber,
privateKey);
}
PatchExchangeRequest bodyParams = new PatchExchangeRequest()
{
SendingAddress = address,
ReserveTxnSignature = reserveTxnSinatrue,
Nonce = nonce.ToString(),
ExecuteTxnSignature = executeTxnSignature,
ReclaimTxnSignature = reclaimTxnSignature
};
string json = bodyParams.ToJson();
StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
HttpRequestMessage request = new HttpRequestMessage
{
Method = new HttpMethod("PATCH"),
RequestUri = new Uri(requestUri),
Content = content
};
try
{
using (HttpClient httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add(AUTHORIZATION, $"{BASIC} {token}");
using (HttpResponseMessage response = await httpClient.SendAsync(request))
{
if (response.IsSuccessStatusCode)
{
result.IsSuccess = true;
result.Data = true;
return(result);
}
string contentString = await response.Content.ReadAsStringAsync();
result.Error = ResponseHandler.GetError(response.StatusCode, requestUri, contentString);
}
}
}
catch (HttpRequestException)
{
result.IsSuccess = false;
result.Error = ResponseHandler.GetExceptionError();
}
return(result);
}
