public void TestUpdateDataPayload()
{
List <Property> _prop = new List <Property>();
List <DataResponse> _data = new List <DataResponse>();
TestCreateDataPayload();
_data = DataPayload.Get();
_prop.Add(new Property {
key = "width", value = "200px"
});
DataResponse updateRecord = new DataResponse()
{
Id = "Hello",
Name = "Hello.png",
User = "",
Created_on = DateTime.Now.ToString(),
Edited_on = DateTime.Now.ToString(),
Extension = ".png",
MimeType = "application/image",
Size = 111,
Type = "IMAGE",
Url = "http://localhost/uploads/data/Hello.png",
FilePath = "",
Properties = _prop
};
DataResponse updated = DataPayload.Update(updateRecord);
Assert.NotEqual(_data[0].Properties, updateRecord.Properties);
}
public void PostgreSQLProviderInsert()
{
DataProviderBase provider = new PostgreSQLDataProvider(new ConnectionParams()
{
Database = "Zenith",
Password = "******",
Port = 5432,
Server = "localhost",
Username = "******",
OpenImmidiately = false
});
provider.Open();
User user = new User()
{
Username = "******",
AccessToken = "",
EmailAddress = "*****@*****.**",
Id = 23,
IsValid = true
};
DataPayload<User> payload = new DataPayload<User>()
{
Entity = user,
Identifier = null
};
DataResult result = provider.Execute(Operation.Insert, payload);
Assert.IsNotNull(result);
provider.Close();
Assert.IsFalse(provider.IsOpen);
}
protected override void HandleResponse(Packet packet, GProtocolSendType type)
{
try
{
var dataPayload = new DataPayload(packet.Payload);
RealTimeEventHandlers.NewMessageReceived?.Invoke(this, new MessageReceiveEvent
{
MessageInfo = new MessageInfo
{
MessageType = MessageType.Public,
SendType = type,
ClientReceiveTime = packet.ClientReceiveTime
},
Message = new Message
{
Data = dataPayload.Payload,
ReceiverId = dataPayload.ReceiverId,
SenderId = dataPayload.SenderId
}
});
}
catch (Exception e)
{
e.LogException <PublicMessageResponseHandler>(DebugLocation.RealTime, "HandleResponse");
}
}
public void TestReadDataPayload()
{
List <DataResponse> _data = new List <DataResponse>();
_data = DataPayload.Get();
//Console.WriteLine(_data);
Assert.NotNull(_data);
}
void PlatformCut(DataPayload data)
{
var package = data.AsDataPackage();
package.RequestedOperation = DataPackageOperation.Move;
Clipboard.SetContent(package);
Clipboard.Flush();
}
private static Packet DoAction(DataPayload payload)
{
var dataPayload = new DataPayload(receiverId: payload.ReceiverId, payload: payload.Payload);
return(new Packet(RealTimeHandler.PlayerHash, RealTimeConst.ActionPrivateMessage,
GProtocolSendType.Reliable,
dataPayload.Serialize()));
}
private async Task Client_MessageCreateReceived(object sender, DataPayload <Gracie.Models.Message> messageCreatePayload, CancellationToken cancellationToken)
{
//logger.Log(LogLevel.Information, messageCreatePayload.Data.Content);
if (ulong.TryParse(messageCreatePayload.Data.Content, out var result))
{
await SendVoiceServerUpdate(messageCreatePayload.Data.GuildId.Value, result, cancellationToken);
}
var content = Convert.ToUInt64(messageCreatePayload.Data.Content);
}
private static Packet DoAction(DataPayload payload)
{
return(new Packet(TurnBasedHandler.PlayerHash, TurnBasedConst.OnVote,
JsonConvert.SerializeObject(payload,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Ignore
})));
}
public Result Load()
{
var dataPayload = new DataPayload();
_contentItems = dataPayload.ContentItems.ToList();
_sessions = dataPayload.Sessions.ToList();
_contentItemTypes = dataPayload.ContentItemTypes.ToList();
return(Result.Ok());
}
public async Task ShouldReceive200AndValueOnIncrementRequestCount()
{
var client = new HttpClient();
var url = string.Concat(_address, "/api/values/5");
var result = await client.GetAsync(url);
var wwwAuthenticate = result.Headers.WwwAuthenticate.First();
Assert.AreEqual(HttpStatusCode.Unauthorized, result.StatusCode);
StringAssert.Equals(wwwAuthenticate.Scheme, "AuthAPI");
var responsePayload = new ResponsePayload(wwwAuthenticate.Parameter);
var requestPayload = new RequestPayload
{
ClientId = "TestAPI",
Identifier = responsePayload.Identifier,
RequestCount = string.Format("{0:D8}", int.Parse(responsePayload.RequestCount) + 1),
UserName = "******"
};
var dataPayload = new DataPayload
{
ClientId = "TestAPI",
Method = "GET",
Password = "******",
RequestBodyBase64 = string.Empty,
RequestURI = "/api/values/5",
UserName = "******"
};
var authHeader = new AuthHeader
{
Data = dataPayload,
Request = requestPayload
};
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("AuthAPI", authHeader.ToAuthorizationHeader("QiU6bSt3anE2OURfX3IsKlVZen05K1tBLW5AQ1x1d0xIXVZwaGE7Zj83QTc0ZXthVy9aWV9UZ0tUcnRUVEQ6d2JxTEhGOi9fMitBfiNZOS5NXHlyJzNnNSl1VzxNQExkQXtHJEQ+fWElMkMhWUJhLT8kbUFeQERWa310J2N+NkQ="));
result = await client.GetAsync(url);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(await result.Content.ReadAsAsync <string>(), "value");
authHeader.Request.RequestCount = string.Format("{0:D8}", int.Parse(authHeader.Request.RequestCount) + 1);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("AuthAPI", authHeader.ToAuthorizationHeader("QiU6bSt3anE2OURfX3IsKlVZen05K1tBLW5AQ1x1d0xIXVZwaGE7Zj83QTc0ZXthVy9aWV9UZ0tUcnRUVEQ6d2JxTEhGOi9fMitBfiNZOS5NXHlyJzNnNSl1VzxNQExkQXtHJEQ+fWElMkMhWUJhLT8kbUFeQERWa310J2N+NkQ="));
result = await client.GetAsync(url);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
}
protected override void HandleResponse(Packet packet, GProtocolSendType type)
{
try
{
var dataPayload = new DataPayload(packet.Payload);
var shotsFromBuffer = GsSerializer.Object.GetSnapShotsFromBuffer(dataPayload.Payload);
GsSerializer.OnNewSnapShotReceived?.Invoke(this, shotsFromBuffer);
}
catch (Exception e)
{
e.LogException <SnapShotResponseHandler>(DebugLocation.RealTime, "HandleResponse");
}
}
private Task HelloRecievedSetupHeartbeat(object sender, DataPayload <Hello> payload, CancellationToken cancellationToken)
{
var heartbeat = Task.Run(async delegate
{
while (true)
{
await Task.Delay(payload.Data.HeartbeatInterval);
await SendHeartbeat(cancellationToken);
}
});
return(Task.CompletedTask);
}
public async Task ShouldReceive200OnPost()
{
var client = new HttpClient();
var valuesModel = new ValuesModel
{
Id = 1,
Name = "oi"
};
var url = string.Concat(_address, "/api/values");
var result = await client.PostAsJsonAsync <ValuesModel>(url, valuesModel);
var wwwAuthenticate = result.Headers.WwwAuthenticate.First();
Assert.AreEqual(HttpStatusCode.Unauthorized, result.StatusCode);
StringAssert.Equals(wwwAuthenticate.Scheme, "AuthAPI");
var responsePayload = new ResponsePayload(wwwAuthenticate.Parameter);
var requestPayload = new RequestPayload
{
ClientId = "TestAPI",
Identifier = responsePayload.Identifier,
RequestCount = string.Format("{0:D8}", int.Parse(responsePayload.RequestCount) + 1),
UserName = "******"
};
var json = JsonConvert.SerializeObject(valuesModel);
var dataPayload = new DataPayload
{
ClientId = "TestAPI",
Method = "POST",
Password = "******",
RequestBodyBase64 = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(valuesModel))),
RequestURI = "/api/values",
UserName = "******"
};
var authHeader = new AuthHeader
{
Data = dataPayload,
Request = requestPayload
};
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("AuthAPI", authHeader.ToAuthorizationHeader("QiU6bSt3anE2OURfX3IsKlVZen05K1tBLW5AQ1x1d0xIXVZwaGE7Zj83QTc0ZXthVy9aWV9UZ0tUcnRUVEQ6d2JxTEhGOi9fMitBfiNZOS5NXHlyJzNnNSl1VzxNQExkQXtHJEQ+fWElMkMhWUJhLT8kbUFeQERWa310J2N+NkQ="));
result = result = await client.PostAsJsonAsync <ValuesModel>(url, valuesModel);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
}
public void TestDeleteDataPayload()
{
List <DataResponse> _model = new List <DataResponse>();
TestCreateDataPayload();
_model = DataPayload.Get();
Assert.NotNull(_model);
//
bool isDeleted = DataPayload.Delete("HelloData");
Assert.True(isDeleted);
//
_model = DataPayload.Get();
Assert.True(_model.Count == 0);
}
private async Task HelloRecievedSendIdentify(object sender, DataPayload <Hello> payload, CancellationToken cancellationToken)
{
logger.LogInformation("Hello Recieved");
await SendHeartbeat(cancellationToken);
var sendPayload = new GatewayDataPayload <Identify>
{
Data = new Identify
{
GuildSubscriptions = false,
Intents = Intent.GuildMessages | Intent.DirectMessages | Intent.GuildVoiceStates,
Token = Configuration["discordtoken"]
},
GatewayOpcode = Opcode.Identify
};
await client.SendPayload(sendPayload, MaxSendPayload, cancellationToken);
}
protected override void HandleResponse(Packet packet, GProtocolSendType type)
{
try
{
var dataPayload = new DataPayload(packet.Payload);
GsSerializer.OnNewEventHandler?.Invoke(this,
new EventData
{
Caller = dataPayload.ExtraData,
Data = dataPayload.Payload,
SenderId = dataPayload.SenderId,
ReceiverId = dataPayload.ReceiverId
});
}
catch (Exception e)
{
e.LogException <NewEventResponseHandler>(DebugLocation.RealTime, "HandleResponse");
}
}
protected override void HandleResponse(Packet packet, GProtocolSendType type)
{
var dataPayload = new DataPayload(packet.Payload);
RealTimeEventHandlers.NewMessageReceived?.Invoke(this, new MessageReceiveEvent
{
MessageInfo = new MessageInfo
{
MessageType = MessageType.Private,
SendType = type,
ClientReceiveTime = packet.ClientReceiveTime
},
Message = new Message
{
Data = dataPayload.Payload,
ReceiverId = dataPayload.ReceiverId,
SenderId = dataPayload.SenderId
}
});
}
public ModelController(IHostingEnvironment environment, IConfiguration configuration, ILogger <ModelController> log, IPyNNServiceClient srv, IPyZMEServiceClient _zmeClient, IZSModelPredictionClient _zsClient, IPyTensorServiceClient tbClientInstance)
{
_environment = environment ?? throw new ArgumentNullException(nameof(environment));
this.Configuration = configuration;
this.nnclient = srv;
this.Logger = log;
this.zmeClient = _zmeClient;
this.zsClient = _zsClient;
this.tbClient = tbClientInstance;
try
{
responseData = ModelPayload.Get();
dataResponseData = DataPayload.Get();
}
catch (Exception ex)
{
//ILogger
string error = ex.Message;
}
}
internal static void AddToQueue(DataPayload dataPayload)
{
try
{
var payload = dataPayload.Serialize();
if (GsSerializer.Object.GetSendQueueBufferSize(_sendQueue) + payload.Length <=
RealTimeConst.MaxPacketBeforeSize &&
_sendQueue.Count <= MaxQueueSize)
{
_sendQueue?.Enqueue(payload);
}
else
{
DebugUtil.LogError(typeof(ObserverCompacterUtil), DebugLocation.RealTime, "AddToQueue",
new GameServiceException("Send Queue is Full"));
}
}
catch (Exception e)
{
e.LogException(typeof(ObserverCompacterUtil), DebugLocation.RealTime, "AddToQueue");
}
}
protected override void HandleResponse(Packet packet, GProtocolSendType type)
{
try
{
var(ownerId, payloads) = GsSerializer.Object.GetObserver(packet.Payload);
while (payloads.Count > 0)
{
var dataPayload = new DataPayload(payloads.Dequeue());
GsSerializer.OnNewEventHandler?.Invoke(this,
new EventData
{
Caller = dataPayload.ExtraData,
Data = dataPayload.Payload,
SenderId = ownerId
});
}
}
catch (Exception e)
{
e.LogException <ObserverResponseHandler>(DebugLocation.RealTime, "HandleResponse");
}
}
public void TestCreateDataPayload()
{
List <Property> _prop = new List <Property>();
DataResponse newRecord = new DataResponse()
{
Id = "HelloData",
Name = "Hello.png",
User = "",
Created_on = DateTime.Now.ToString(),
Edited_on = DateTime.Now.ToString(),
Extension = ".png",
MimeType = "application/image",
Size = 111,
Type = "IMAGE",
Url = "http://localhost/uploads/data/Hello.png",
FilePath = "",
Properties = _prop
};
DataResponse createdRecord = DataPayload.Create(newRecord);
Assert.Equal(newRecord, createdRecord);
}
private static Func<byte[], int, bool, bool> GetSender(SharedNetworkInfo sharedInfo, SendStats stats = null)
{
List<byte> datablock = new List<byte>();
byte[] tempBuffer = new byte[1024 * 1024];
return (byte[] data, int size, bool flush) =>
{
int totalSize = datablock.Count + size;
int blockSize = 1024 * 1024;
int remainder = size;
int offset = 0;
while (totalSize > blockSize)
{
datablock.CopyTo(0, tempBuffer, 0, datablock.Count);
int nextBlockSize = blockSize - datablock.Count;
if (nextBlockSize > remainder)
nextBlockSize = remainder;
Array.Copy(data, offset, tempBuffer, datablock.Count, nextBlockSize);
offset += nextBlockSize;
datablock.Clear();
totalSize -= blockSize;
remainder -= nextBlockSize;
DataPayload dataPack = new DataPayload() { Data = tempBuffer, EndOfStream = false };
Utilities.SendEncrypted<DataPayload>(sharedInfo, dataPack);
var reply = ProtoBuf.Serializer.DeserializeWithLengthPrefix<NetCommand>(sharedInfo.Stream, ProtoBuf.PrefixStyle.Fixed32);
if (reply.Type != NetCommandType.DataReceived)
return false;
if (stats != null)
{
stats.BytesSent += dataPack.Data.Length;
}
}
if (remainder > 0)
{
for (int i = offset; i < size; i++)
datablock.Add(data[i]);
}
if (flush)
{
DataPayload dataPack = new DataPayload() { Data = datablock.ToArray(), EndOfStream = true };
Utilities.SendEncrypted<DataPayload>(sharedInfo, dataPack);
var reply = ProtoBuf.Serializer.DeserializeWithLengthPrefix<NetCommand>(sharedInfo.Stream, ProtoBuf.PrefixStyle.Fixed32);
if (reply.Type != NetCommandType.DataReceived)
return false;
if (stats != null)
{
stats.BytesSent += dataPack.Data.Length;
}
}
return true;
};
}
public void SQLServerInsert()
{
DataProviderBase provider = new SQLServerDataProvider(new ConnectionParams()
{
ConnectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=Test;Integrated Security=SSPI;AttachDBFilename=D:\Programming\DB\Test.mdf"
});
provider.Open();
User user = new User()
{
Username = "******",
AccessToken = "",
EmailAddress = "*****@*****.**",
Id = 23,
IsValid = true
};
DataPayload<User> payload = new DataPayload<User>()
{
Entity = user,
Identifier = null
};
DataResult result = provider.Execute(Operation.Insert, payload);
}
public async Task <IActionResult> PostSqlAsync()
{
DataResponse newRecord = new DataResponse();
string reqBody = "";
string reqSql = "";
string dirFullpath = $"{DirectoryHelper.GetDataDirectoryPath()}";
string newFile = "DataHub_" + DateTime.Now.Ticks.ToString() + ".csv";
string _filePath = Path.Combine(dirFullpath, newFile);
long fileSize = 0L;
List <string> resultRows = new List <string>();
StringBuilder csvBuilder = new StringBuilder();
List <Property> _props = new List <Property>();
int numberOfColumns = 0;
//
using (var reader = new StreamReader(Request.Body))
{
reqBody = reader.ReadToEnd().ToString();
}
JObject jsonBody = JObject.Parse(reqBody);
reqSql = jsonBody["sql"].ToString();
#region ODBC
string zmodId = ZSSettingPayload.GetUserNameOrEmail(HttpContext);
var settings = ZSSettingPayload.GetDataHubInfo(zmodId);
string cnn = $"Driver={settings.Item5};ConnectionType=Direct;HOST={settings.Item1};PORT={settings.Item4};AuthenticationType=Plain;UID={settings.Item2};PWD={settings.Item3};SSL={settings.Item6}";
Console.WriteLine($"DATAHUB >>>>>>>>>>>>>>>>>>>>> { cnn }");
//using (OdbcConnection connection = new OdbcConnection("Driver=Dremio Connector;ConnectionType=Direct;HOST=dremio-demo.westeurope.cloudapp.azure.com;PORT=31010;AuthenticationType=Plain;UID=demo;PWD=iug2019#riga"))
using (OdbcConnection connection = new OdbcConnection(cnn))
{
try
{
connection.Open();
Console.WriteLine("DATAHUB CONNECTION ESTABLISHED...");
OdbcCommand DbCommand = connection.CreateCommand();
Console.WriteLine(reqSql);
DbCommand.CommandText = reqSql;
List <string> columns = new List <string>();
OdbcDataReader reader = DbCommand.ExecuteReader();
numberOfColumns = reader.FieldCount;
//add header column name
for (int i = 0; i < reader.FieldCount; i++)
{
columns.Add(reader.GetName(i));
csvBuilder.Append(reader.GetName(i));
if (i < reader.FieldCount - 1)
{
csvBuilder.Append(",");
}
}
resultRows.Add(csvBuilder.ToString());
csvBuilder.Clear();
//
//add rows
while (reader.Read())
{
csvBuilder.Clear();
for (int i = 0; i < reader.FieldCount; i++)
{
if (!reader.IsDBNull(i))
{
csvBuilder.Append(reader[i]);
}
else
{
csvBuilder.Append("No Data");
}
if (i < reader.FieldCount - 1)
{
csvBuilder.Append(",");
}
}
resultRows.Add(csvBuilder.ToString());
}
using (StreamWriter writer = new StreamWriter(_filePath))
{
foreach (var line in resultRows)
{
writer.WriteLine(line);
}
writer.Flush();
fileSize = writer.BaseStream.Length;
}
string _url = DirectoryHelper.GetDataUrl(newFile);
await Task.FromResult(0);
//
string type = "CSV";
//get properties row and column count
int[] csvProps = CsvHelper.GetCsvRowColumnCount(dirFullpath + @"/" + newFile);
_props.Add(new Property {
key = "Number of rows", value = resultRows.Count().ToString()
});
_props.Add(new Property {
key = "Number of columns", value = numberOfColumns.ToString()
});
newRecord = new DataResponse()
{
Created_on = DateTime.Now.ToString(),
Edited_on = DateTime.Now.ToString(),
Extension = "CSV",
FilePath = _filePath,
Id = newFile,
MimeType = "text/csv",
Name = newFile.Replace(".CSV", ""),
Properties = _props,
Size = fileSize,
Type = type,
Url = _url,
DateCreated = DateTime.Now
};
DataPayload.Create(newRecord);
}
catch (Exception e)
{
// return error message
Console.WriteLine("DataHub ERROR:>>>>" + e.Message);
//cleanup the file created
}
}
#endregion
//
return(Json(newRecord));
}
public void Written(Endpoint endpoint, DataPayload payload, TimeSpan elapsed)
{
GetTcpWrite().Success(elapsed, payload.Buffer.Length);
GetApiRequests().Success(payload.ApiKey, elapsed);
}
public void RavenDBProviderInsert()
{
DataProviderBase provider = new RavenDBDataProvider(new ConnectionParams()
{
Database = "Zenith",
Port = 8080,
Url = "http://localhost",
OpenImmidiately = false
});
provider.Open();
User user = new User()
{
Username = "******",
AccessToken = "",
EmailAddress = "*****@*****.**",
Id = 23,
IsValid = true
};
DataPayload<User> payload = new DataPayload<User>()
{
Entity = user,
Identifier = null
};
DataResult result = provider.Execute(Operation.Insert, payload);
Assert.IsNotNull(result);
provider.Close();
Assert.IsFalse(provider.IsOpen);
}
private Task Client_ReadyReceived(object sender, DataPayload <Ready> readyPayload, CancellationToken cancellationToken)
{
logger.LogInformation("Ready Recieved");
return(Task.CompletedTask);
}
private Task Client_TypingStartReceived1(object sender, DataPayload <TypingStart> typingStartEventPayload, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public void WriteFailed(Endpoint endpoint, DataPayload payload, TimeSpan elapsed, Exception exception)
{
GetTcpWrite().Failure(elapsed);
GetApiRequests().Failure(payload.ApiKey, elapsed);
}
public void Share(DataPayload data)
{
PlatformShare(data);
}
public void Cut(DataPayload data)
{
PlatformCut(data);
}
public void Copy(DataPayload data)
{
PlatformCopy(data);
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
try
{
if (_authHeader != null)
{
_authHeader.Request.RequestCount = string.Format("{0:D8}", int.Parse(_authHeader.Request.RequestCount) + 1);
_authHeader.Data = new DataPayload
{
ClientId = AuthAPIConfiguration.Instance.ClientId,
Method = request.Method.Method,
Password = _password,
RequestBodyBase64 = request.Content != null?Convert.ToBase64String(await request.Content.ReadAsByteArrayAsync()) : string.Empty,
RequestURI = request.RequestUri.PathAndQuery,
UserName = _userName
};
request.Headers
.Authorization = new AuthenticationHeaderValue(AuthAPIConfiguration.Instance.ClientId,
_authHeader.ToAuthorizationHeader(AuthAPIConfiguration.Instance.ClientSecret));
}
return(await base.SendAsync(request, cancellationToken)
.ContinueWith(async task =>
{
var response = task.Result;
if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
var wwwAuthenticate = response.Headers.WwwAuthenticate.FirstOrDefault();
if (wwwAuthenticate != null && wwwAuthenticate.Scheme.Equals("AuthAPI"))
{
var responsePayload = new ResponsePayload(wwwAuthenticate.Parameter);
var requestPayload = new RequestPayload
{
ClientId = AuthAPIConfiguration.Instance.ClientId,
Identifier = responsePayload.Identifier,
RequestCount = string.Format("{0:D8}", int.Parse(responsePayload.RequestCount) + 1),
UserName = _userName
};
var dataPayload = new DataPayload
{
ClientId = AuthAPIConfiguration.Instance.ClientId,
Method = request.Method.Method,
Password = _password,
RequestBodyBase64 = request.Content != null ? Convert.ToBase64String(await request.Content.ReadAsByteArrayAsync()) : string.Empty,
RequestURI = request.RequestUri.PathAndQuery,
UserName = _userName
};
var authHeader = new AuthHeader
{
Data = dataPayload,
Request = requestPayload
};
_tempAuthHeader = authHeader;
request.Headers.Authorization = new AuthenticationHeaderValue("AuthAPI", _tempAuthHeader.ToAuthorizationHeader(AuthAPIConfiguration.Instance.ClientSecret));
response = await ReplayRequest(request, cancellationToken);
if (response.IsSuccessStatusCode)
{
_authHeader = _tempAuthHeader;
}
}
}
else if (response.IsSuccessStatusCode)
{
if (_tempAuthHeader != null)
{
_authHeader = _tempAuthHeader;
}
}
return response;
}).Unwrap());
}
catch (Exception)
{
throw;
}
}
private static Packet DoAction(DataPayload payload)
{
return(new Packet(RealTimeHandler.PlayerHash, RealTimeConst.ActionEvent, GProtocolSendType.Reliable,
payload.Serialize()));
}
