public System.Threading.Tasks.Task <KeepAliveResponse> KeepAliveAsync(skidata.com.tdi.common.v1.data.AuthenticationHeader AuthenticationHeader)
{
KeepAliveRequest inValue = new KeepAliveRequest();
inValue.AuthenticationHeader = AuthenticationHeader;
return(((CarAccessTransactionEventInterface)(this)).KeepAliveAsync(inValue));
}
public ActionResult KeepAlive(KeepAliveRequest request)
{
_logger.LogTrace($"{Request.HttpContext.Connection.RemoteIpAddress}: POST {Request.Host}{Request.Path}");
_authHandler.CheckToken(request.Token);
_serverManager.KeepAlive(request);
return(Ok());
//Todo adjust return
}
public static void HandleClientKeepAliveRequest(Session session, KeepAliveRequest keepAlive)
{
session.Send(0u, 0u, new KeepAliveResponse
{
Check = keepAlive.Check,
Timestamp = (uint)DateTimeOffset.Now.ToUnixTimeSeconds()
});
}
public bool KeepAlive(skidata.com.tdi.common.v1.data.AuthenticationHeader AuthenticationHeader)
{
KeepAliveRequest inValue = new KeepAliveRequest();
inValue.AuthenticationHeader = AuthenticationHeader;
KeepAliveResponse retVal = ((CarAccessTransactionEventInterface)(this)).KeepAlive(inValue);
return(retVal.KeepAliveSignal);
}
public static IRequest Serilize(byte[] rawRequest)
{
IRequest request;
if (rawRequest.Length < 1)
{
return(null);
}
switch ((QRPacketType)rawRequest[0])
{
case QRPacketType.AvaliableCheck:
request = new AvaliableRequest(rawRequest);
break;
//verify challenge to check game server is real or fake;
//after verify we can add game server to server list
case QRPacketType.Challenge:
request = new ChallengeRequest(rawRequest);
break;
case QRPacketType.HeartBeat:
request = new HeartBeatRequest(rawRequest);
break;
case QRPacketType.KeepAlive:
request = new KeepAliveRequest(rawRequest);
break;
case QRPacketType.EchoResponse:
request = new QRRequestBase(rawRequest);
break;
case QRPacketType.ClientMessageACK:
request = new QRRequestBase(rawRequest);
break;
default:
LogWriter.UnknownDataRecieved(rawRequest);
request = null;
break;
}
if (request == null)
{
return(null);
}
if (!(bool)request.Parse())
{
LogWriter.ToLog(LogEventLevel.Error, ErrorMessage.GetErrorMessage(QRErrorCode.Parse));
return(null);
}
return(request);
}
private void Dialog_RequestReceived(Object sender, MessageReceivedEventArgs <KeepAliveRequest> e)
{
KeepAliveRequest request = e.Message;
this.OnMessageReceived(request,
() =>
{
this.Dialog.SendResponse(new KeepAliveResponse(request));
});
}
public override Task <KeepAliveReply> KeepAlive(KeepAliveRequest request, ServerCallContext context)
{
var keepAliveReply = new KeepAliveReply()
{
Status = new MediaContract.Status()
{
Code = 200,
Msg = "KeepAlive Successful!"
}
};
return(Task.FromResult(keepAliveReply));
}
public void KeepAlive(KeepAliveRequest request)
{
lock (TranscoderCache)
{
var cacheObject = TranscoderCache.FirstOrDefault(item =>
item.TranscodedVideoUri == request.TranscodedVideoUri);
if (cacheObject != null)
{
cacheObject.KeepAliveTimeStamp = DateTime.Now;
}
//TODO: Response to Client? Keepalive Invalid, Video stopped to transcode
}
}
public HttpResponseMessage KeepAlive(KeepAliveRequest request)
{
var result = new KeepAliveResult();
try
{
result = service.KeepAlive(request);
}
catch (Exception e)
{
result.ErrorMessage = e.Message;
result.Success = false;
return(Request.CreateResponse(HttpStatusCode.InternalServerError, result));
}
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public override Task <KeepAliveReply> KeepAlive(KeepAliveRequest request, ServerCallContext context)
{
foreach (Dictionary <string, DateTime> dict in _sipServiceDirector.VideoSessionAlive)
{
if (dict.ContainsKey(request.Gbid + "," + request.Hdr.Sessionid))
{
dict[request.Gbid + "," + request.Hdr.Sessionid] = DateTime.Now;
}
}
var keepAliveReply = new KeepAliveReply()
{
Status = new Status()
{
Code = 200,
Msg = "KeepAlive Successful!"
}
};
return(Task.FromResult(keepAliveReply));
}
public KeepAliveResponse KeepAlive(KeepAliveRequest request)
{
KeepAliveResponse response = new KeepAliveResponse();
AuthToken authToken = null;
try
{
Common.Helpers.ValidationHelper.ValidateRequiredField(request.AuthToken, "Auth Token");
if (!UserController.ValidateSession(request.AuthToken, out authToken))
{
throw new AuthenticationException("Authentication failed.");
}
var newAuthToken = UserController.KeepSessionAlive(authToken);
response.NewAuthToken = UserController.CreateSessionCookie(newAuthToken);
response.ExpirySeconds = (int)Settings.Default.SessionExpiryInterval.TotalSeconds;
}
catch (AuthenticationException ex)
{
throw new WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.Unauthorized);
}
catch (Common.Exceptions.ValidationException ex)
{
throw new WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.Unauthorized);
}
catch (Exception ex)
{
ExceptionHelper.Log(ex, authToken == null ? null : authToken.Username);
throw new WebFaultException <string>("An unknown error has occurred.", System.Net.HttpStatusCode.InternalServerError);
}
return(response);
}
System.Threading.Tasks.Task <KeepAliveResponse> CarAccessTransactionEventInterface.KeepAliveAsync(KeepAliveRequest request)
{
return(base.Channel.KeepAliveAsync(request));
}
internal void Handle(KeepAliveRequest input) {
Reply(new KeepAliveResponse());
}
KeepAliveResponse CarAccessTransactionEventInterface.KeepAlive(KeepAliveRequest request)
{
return(base.Channel.KeepAlive(request));
}
public KeepAliveResult KeepAlive(KeepAliveRequest request)
{
var result = new KeepAliveResult();
try
{
Room room = null;
Hand hand = null;
Round round = null;
#region Set Room, Hand and Round
if (GameCenter.RoomsByID.ContainsKey(request.Room))
{
room = GameCenter.RoomsByID[request.Room];
}
else
{
throw new RoomNotFoundException("Can't find room in game center");
}
if (room.CurrentHand != null)
{
hand = room.CurrentHand;
if (hand.CurrentRound != null)
{
round = hand.CurrentRound;
}
}
#endregion
#region Room's info
#region Players info by table location
//get room's players location in table
//get all current active player's states at the table
//get all players bets in the current round
result.TableLocationOfActivePlayers = new int[10];
result.PlayersStates = new string[10];
result.PlayersBets = new double[10];
for (int i = 0; i < 10; i++)
{
Chair chair = null;
foreach (Chair c in room.Chairs)
{
if (c.Index == i)
{
chair = c;
break;
}
}
if (chair == null)
{
throw new WrongIOException("Chair not found");
}
if (room.TableLocationOfActivePlayers.ContainsKey(chair))
{
Player player = room.TableLocationOfActivePlayers[chair];
result.TableLocationOfActivePlayers[i] = player.GetHashCode();
result.PlayersStates[i] = player.CurrentState.ToString();
if (hand != null && round != null)
{
result.PlayersBets[i] = room.CurrentHand.CurrentRound.LiveBets[player];
}
}
else
{
result.PlayersStates[i] = Player.State.Passive.ToString();
result.PlayersBets[i] = -1;
}
}
#endregion
result.IsTableFull = room.IsTableFull;
#endregion
#region Hand's info
//get player's and table's cards
if (hand != null)
{
result.PlayersAndTableCards = new int[52];
foreach (Player p in hand.ActivePlayers)
{
if (p.PrivateCards[0] != null && p.PrivateCards[1] != null)
{
result.PlayersAndTableCards[p.PrivateCards[0].Index] = p.GetHashCode();
result.PlayersAndTableCards[p.PrivateCards[1].Index] = p.GetHashCode();
}
}
for (int i = 0; i < hand.CommunityCards.Length; i++)
{
if (hand.CommunityCards[i] == null)
{
break;
}
result.PlayersAndTableCards[hand.CommunityCards[i].Index] = (-1) * (i + 1);
}
result.DealerId = hand.Dealer.GetHashCode();
}
#endregion
#region Round's info
if (round != null)
{
result.CurrentPlayerID = round.CurrentPlayer.GetHashCode();
//get pot's values and amount to claim
result.PotsValues = new List <double>();
result.PotsAmountToClaim = new List <double>();
if (round.CurrentPot == null)
{
throw new WrongIOException("Round's pot is somehow null...");
}
Pot potIter = round.CurrentPot;
while (potIter.BasePot != null)
{
potIter = potIter.BasePot;
}
while (potIter != null)
{
result.PotsValues.Add(potIter.Value);
result.PotsAmountToClaim.Add(potIter.AmountToClaim);
potIter = potIter.PartialPot;
}
//Note: Result.PlayersBets info is in Room's info (above)
result.TotalRaise = round.TotalRaise;
result.LastRaise = round.LastRaise;
}
#endregion
//Player's info
if (room.ActivePlayersByID.ContainsKey(request.PlayerID))
{
result.PlayerWallet = room.ActivePlayersByID[request.PlayerID].Wallet.AmountOfMoney;
}
result.Success = true;
}
catch (RoomNotFoundException e)
{
result.Success = false;
result.ErrorMessage = e.Message;
}
catch (WrongIOException e)
{
result.Success = false;
result.ErrorMessage = e.Message;
}
return(result);
}
public KeepAliveHandler(ISession session, IRequest request) : base(session, request)
{
_request = (KeepAliveRequest)request;
}
internal void Handle(KeepAliveRequest request) {
_handle(request);
}
public override Task<KeepAliveResponse> KeepAlive(KeepAliveRequest request, ServerCallContext context)
{
// Store interaction time
this._lastInteractionTime = DateTime.Now;
KeepAliveResponse response = new KeepAliveResponse
{
};
return Task.FromResult(response);
}
private Task ConnectionChecker(SocketBase socket)
{
KeepAliveRequest keepAliveRequest = socket as KeepAliveRequest ?? throw new ArgumentNullException(nameof(socket));
return(_lobbyManager.UpdatePlayerStatus(keepAliveRequest.Name));
}
