public static void F_INTERFACE_COMMAND(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null)
return;
byte CommandId = packet.GetUint8();
switch (CommandId)
{
case 1: // ????
{
} break;
case 2: // Resurrect Button
{
cclient.Plr.PreRespawnPlayer();
Log.Success("Interface Command", "Respawn Player");
} break;
case 10: // Talisman Fuse
{
} break;
};
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = client as LobbyClient;
UInt32 WorldUid = packet.GetUint32Reversed();
string Name = packet.GetParsedString();
PacketOut Out = new PacketOut((UInt32)Opcodes.ANS_CHARACTER_NAME_CHECK);
if (Databases.CharacterTable.Count(c => c.Name == Name) == 0)
{
cclient.Pending = new CharacterEntry();
cclient.Pending.Index = Databases.CharacterTable.GenerateIndex();
cclient.Pending.AccountIndex = cclient.Account.Index;
cclient.Pending.Name = Name;
cclient.Pending.World = (int)WorldUid;
cclient.Pending.Rank = 1;
cclient.Pending.Money = 0;
cclient.Pending.Threat = 1;
cclient.Pending.Playtime = 0;
cclient.Pending.Clan = "APB-EMU";
cclient.Pending.IsOnline = 0;
cclient.Pending.DistrictID = 0;
cclient.Pending.DistrictType = 0;
cclient.Pending.LFG = 0;
cclient.Pending.IsGroupPublic = 0;
cclient.Pending.GroupInvite = 0;
cclient.Pending.GroupStatus = 0;
Out.WriteUInt32Reverse((uint)ResponseCodes.RC_SUCCESS);
}
else
{
cclient.Pending = default(CharacterEntry);
Out.WriteUInt32Reverse((uint)ResponseCodes.RC_CHARACTER_NAME_CHECK_IN_USE);
}
cclient.Send(Out);
return 0;
}
public static void F_FLIGHT(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
UInt16 TargetOID = packet.GetUint16();
UInt16 State = packet.GetUint16();
Log.Info("F_FLIGHT", "TargetOid = " + TargetOID + ",State=" + State);
if (State == 20) // Flight Master
{
Object Obj = cclient.Plr.Zone.GetObject(TargetOID);
if (Obj == null || !Obj.IsCreature())
{
Log.Error("F_FLIGHT", "Invalid Creature OID : " + TargetOID);
return;
}
UInt16 FlyID = packet.GetUint16();
List<Zone_Taxi> Taxis = WorldMgr.GetTaxis(cclient.Plr);
if (Taxis.Count <= FlyID - 1)
return;
if (!cclient.Plr.RemoveMoney(Taxis[FlyID - 1].Info.Price))
{
cclient.Plr.SendLocalizeString("", GameData.Localized_text.TEXT_MERCHANT_INSUFFICIENT_MONEY_TO_BUY);
return;
}
cclient.Plr.Teleport(Taxis[FlyID - 1].ZoneID, Taxis[FlyID - 1].WorldX, Taxis[FlyID - 1].WorldY, Taxis[FlyID - 1].WorldZ, Taxis[FlyID - 1].WorldO);
}
}
static public void F_USE_ITEM(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.IsPlaying())
return;
Player Plr = cclient.Plr;
ushort slot = packet.GetUint16();
Item item = Plr.ItmInterface.GetItemInSlot(slot);
if (Plr.Level < item.Info.MinRank)
{
Plr.SendLocalizeString("", GameData.Localized_text.TEST_ITEM_PLAYER_LEVEL_TOO_LOW);
return;
}
else if (Plr.Rank < item.Info.MinRenown)
{
Plr.SendLocalizeString("", GameData.Localized_text.TEST_ITEM_PLAYER_RENOWN_TOO_LOW);
return;
}
if (item.Info.Type == 31 && item.Info.ScriptName == "HealthPotion") // Potion
{
Plr.DealHeal(Plr, (uint)item.Info.MinRank * 100);
Plr.ItmInterface.DeleteItem(slot, 1, true);
}
}
static public void CL_CHECK(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
uint Version = packet.GetUint32();
Log.Debug("CL_CHECK", "Launcher Version : " + Version);
PacketOut Out = new PacketOut((byte)Opcodes.LCR_CHECK);
if (Version != Program.Version)
{
Out.WriteByte((byte)CheckResult.LAUNCHER_VERSION); // Version incorrect + message
Out.WriteString(Program.Message);
client.SendPacket(Out);
cclient.Disconnect();
return;
}
byte File = packet.GetUint8();
UInt64 Len = 0;
if (File >= 1)
Len = packet.GetUint64();
if ((long)Len != Program.Info.Length)
{
Out.WriteByte((byte)CheckResult.LAUNCHER_FILE);
Out.WriteString(Program.StrInfo);
}
else
Out.WriteByte((byte)CheckResult.LAUNCHER_OK);
cclient.SendPacket(Out);
}
public static void F_BAG_INFO(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.IsPlaying())
return;
byte Type = packet.GetUint8();
Player Plr = cclient.Plr;
switch (Type)
{
case 3: // Toggle Pvp
Plr.CbtInterface.TogglePvp();
break;
case 16: // Buy more bag space
byte Price = packet.GetUint8();
if (!Plr.ItmInterface.HasMaxBag())
{
if (Plr.HaveMoney(Plr.ItmInterface.GetBagPrice()))
{
if (Plr.RemoveMoney(Plr.ItmInterface.GetBagPrice()))
{
++Plr.ItmInterface.BagBuy;
Plr.ItmInterface.SendMaxInventory(Plr);
}
}
}
break;
}
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
WorldClient cclient = (WorldClient)client;
UInt32 code = packet.GetUint32();
cclient.Send(new ANS_DISTRICT_RESERVE(code, packet.GetUint32(), cclient.Character.LFG, cclient));
return 0;
}
static public void CMSG_VerifyProtocolReq(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
PacketOut Out = new PacketOut((byte)Opcodes.SMSG_VerifyProtocolReply);
byte[] IV_HASH1 = { 0x01, 0x53, 0x21, 0x4d, 0x4a, 0x04, 0x27, 0xb7, 0xb4, 0x59, 0x0f, 0x3e, 0xa7, 0x9d, 0x29, 0xe9 };
byte[] IV_HASH2 = { 0x49, 0x18, 0xa1, 0x2a, 0x64, 0xe1, 0xda, 0xbd, 0x84, 0xd9, 0xf4, 0x8a, 0x8b, 0x3c, 0x27, 0x20 };
ByteString iv1 = ByteString.CopyFrom(IV_HASH1);
ByteString iv2 = ByteString.CopyFrom(IV_HASH2);
VerifyProtocolReply.Builder verify = VerifyProtocolReply.CreateBuilder();
verify.SetResultCode(VerifyProtocolReply.Types.ResultCode.RES_SUCCESS);
verify.SetIv1(ByteString.CopyFrom(IV_HASH1));
verify.SetIv2(ByteString.CopyFrom(IV_HASH2));
Out.Write(verify.Build().ToByteArray());
cclient.SendTCPCuted(Out);
}
public static void F_INTERACT(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null || !cclient.Plr.IsInWorld())
return;
Log.Dump("F_INTERACT", packet.ToArray(), 0, packet.ToArray().Length);
InteractMenu Menu = new InteractMenu();
Menu.Unk = packet.GetUint16();
Menu.Oid = packet.GetUint16();
Menu.Menu = packet.GetUint16();
Menu.Page = packet.GetUint8();
Menu.Num = packet.GetUint8();
Menu.SellCount = packet.GetUint16();
Menu.Count = packet.GetUint16();
Object Obj = cclient.Plr.Region.GetObject(Menu.Oid);
if (Obj == null)
return;
if (Obj.GetDistanceTo(cclient.Plr) > 20)
{
Log.Error("F_INTERACT", "Distance = " + Obj.GetDistanceTo(cclient.Plr));
return;
}
Obj.SendInteract(cclient.Plr, Menu);
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = (LobbyClient)client;
Byte slotId = packet.GetUint8();
Character character = cclient.Characters.Get(slotId);
if (character == null) Log.Error(cclient.Account.Email, "Wrong slot specified!");
World.World info = null;
lock (Program.worldListener.Worlds)
{
Program.worldListener.Worlds.TryGetValue(character.WorldId, out info);
}
PacketOut Out = new PacketOut((UInt32)Opcodes.ANS_WORLD_ENTER);
if (info == null) Out.WriteUInt32Reverse(1);
else
{
info.Send(new AccountEnter(cclient.Account.Id, character.Id, cclient.SessionId));
Out.WriteUInt32Reverse((uint)ResponseCodes.RC_SUCCESS);
Out.WriteByte(info.IP1);
Out.WriteByte(info.IP2);
Out.WriteByte(info.IP3);
Out.WriteByte(info.IP4);
Out.WriteUInt16Reverse((UInt16)info.Port);
Out.WriteInt64Reverse(TCPManager.GetTimeStamp());
}
cclient.Send(Out);
return 0;
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = (LobbyClient)client;
Byte slotId = packet.GetUint8();
CharacterEntry character = Databases.CharacterTable.SingleOrDefault(c => c.AccountIndex == cclient.Account.Index && c.Slot == slotId);
if (character.Index < 1) Log.Error(cclient.Account.Username, "Wrong slot specified!");
World.World info = null;
lock (Program.worldListener.Worlds)
{
Program.worldListener.Worlds.TryGetValue((uint)character.World, out info);
}
PacketOut Out = new PacketOut((UInt32)Opcodes.ANS_WORLD_ENTER);
if (info == null) Out.WriteUInt32Reverse(1);
else
{
info.Send(new AccountEnter((uint)cclient.Account.Index, (uint)character.Index, cclient.SessionId));
Out.WriteUInt32Reverse((uint)ResponseCodes.RC_SUCCESS);
Out.WriteByte(info.IP1);
Out.WriteByte(info.IP2);
Out.WriteByte(info.IP3);
Out.WriteByte(info.IP4);
Out.WriteUInt16Reverse((UInt16)info.Port);
Out.WriteInt64Reverse(TCPManager.GetTimeStamp());
}
cclient.Send(Out);
return 0;
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = client as LobbyClient;
byte[] clientModulus = new byte[64];
for (int i = 0; i < 64; ++i) clientModulus[i] = packet.GetUint8();
cclient.clientModulus = new FrameWork.NetWork.Crypto.BigInteger(1, clientModulus);
UInt16 unk = packet.GetUint16();
byte[] Proof = new byte[20];
for (int i = 0; i < 20; ++i) Proof[i] = packet.GetUint8();
cclient.Proof = Proof;
if (IsBanned(cclient))
{
ANS_LOGIN_FAILED.Send(cclient, (int)ResponseCodes.RC_LOGIN_ACCOUNT_BLOCKED);
cclient.Disconnect();
}
else
{
if (IsValid(cclient))
{
ANS_LOGIN_SUCCES.Send(cclient);
cclient.ECrypt = new TCP.Encryption(cclient.SessionId);
ANS_CHARACTER_INFO.Send(cclient);
}
else
{
ANS_LOGIN_FAILED.Send(cclient, (int)ResponseCodes.RC_LOGIN_INVALID_ACCOUNT);
cclient.Disconnect();
}
}
return 0;
}
public static void HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = (LobbyClient)client;
UInt32 WorldUid = packet.GetUint32R();
string Name = packet.GetUnicodeString();
PacketOut Out = new PacketOut((UInt32)Opcodes.ANS_CHARACTER_NAME_CHECK);
if (CheckName(Name) == 0)
{
cclient.CreateChar = new DBCharacter();
cclient.CreateChar.AcctId = cclient.Account.Id;
cclient.CreateChar.Name = Name;
if (cclient.Account.WorldId != WorldUid)
Program.CharMgr.SetAccountWorld(cclient.Account.Id, (int)WorldUid);
Out.WriteUInt32(0);
}
else
{
cclient.CreateChar = null;
Out.WriteUInt32(1);
}
cclient.SendTCP(Out);
}
public static void HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = client as LobbyClient;
byte freeslot = Program.CharMgr.GetFreeSlot(cclient.Account.Id);
if (freeslot == 0 || cclient.CreateChar == null)
ANS_CHARACTER_CREATE.Send(cclient);
else
{
cclient.CreateChar.SlotId = freeslot;
cclient.CreateChar.Faction = packet.GetUint8();
cclient.CreateChar.Gender = packet.GetUint8();
cclient.CreateChar.Version = (int)packet.GetUint32R();
cclient.CreateChar.Seconds = (int)packet.GetUint32R();
byte[] Custom = new byte[packet.Length - packet.Position];
packet.Read(Custom, 0, Custom.Length);
cclient.CreateChar.Custom = BitConverter.ToString(Custom);
Program.CharMgr.CreateCharacter(cclient.CreateChar);
ANS_CHARACTER_CREATE.Send(cclient);
}
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = client as LobbyClient;
byte slotId = packet.GetUint8();
Character Info = cclient.Characters.Get(slotId);
MySqlCommand cmd = new MySqlCommand("DELETE FROM `clientstatus` WHERE `name` = @name", Connection.Instance);
try
{
cmd.Prepare();
cmd.Parameters.AddWithValue("@name", Info.Name);
cmd.ExecuteNonQuery();
}
catch (MySqlException) { }
finally { cmd.Dispose(); }
PacketOut Out = new PacketOut((UInt32)Opcodes.ANS_CHARACTER_INFO);
if (Info == null) Out.WriteUInt32Reverse((uint)ResponseCodes.RC_FAILED);
else
{
Out.WriteUInt32Reverse((uint)ResponseCodes.RC_SUCCESS);
Out.WriteByte(Info.Slot);
Out.WriteByte(Info.Gender);
Out.WriteUInt32Reverse(Info.Playtime);
Out.WriteUInt32Reverse(Info.Rank);
Out.WriteByte(Info.Threat);
Out.WriteUInt32Reverse(Info.Money);
Out.WriteParsedString("APB-EMU", 60);
byte[] Custom = Info.getCustom();
Out.Write(Custom, 0, Custom.Length);
}
cclient.Send(Out);
return 0;
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
WorldClient cclient = (WorldClient)client;
PacketOut Out = new PacketOut((UInt32)Opcodes.LFG);
if (cclient.LFG == 0)
{
MySqlCommand cmd = new MySqlCommand("UPDATE `clientstatus` SET `lfg` = 1 WHERE `name` = @name", WorldServer.Database.Connection.Instance);
try
{
cmd.Prepare();
cmd.Parameters.AddWithValue("@name", cclient.Name);
cmd.ExecuteNonQuery();
}
catch (MySqlException e) { FrameWork.Logger.Log.Error("MySQL", e.ToString()); }
finally { cmd.Dispose(); }
cclient.LFG = 1;
Out.WriteByte(1);
}
else if (cclient.LFG == 1)
{
MySqlCommand cmd = new MySqlCommand("UPDATE `clientstatus` SET `lfg` = 0 WHERE `name` = @name", WorldServer.Database.Connection.Instance);
try
{
cmd.Prepare();
cmd.Parameters.AddWithValue("@name", cclient.Name);
cmd.ExecuteNonQuery();
}
catch (MySqlException e) { FrameWork.Logger.Log.Error("MySQL", e.ToString()); }
finally { cmd.Dispose(); }
cclient.LFG = 0;
Out.WriteByte(0);
}
cclient.Send(Out);
return 0;
}
public static void F_TRADE_STATUS(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.IsPlaying())
return;
cclient.Plr.ItmInterface.HandleTrade(packet);
}
static public void F_SWITCH_ATTACK_MODE(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.HasPlayer())
return;
cclient.Plr.CbtInterface.Attacking = true;
}
/// <summary>
/// Returns the information for a given Eloqua account.
/// </summary>
/// <param name="site">
/// The site for accessing Eloqua services, this is tipically the company name. This is the same used to access
/// Eloqua website.
/// </param>
/// <param name="user">The username. This is the same used to access Eloqua website.</param>
/// <param name="password">The password of the account. This is the same used to access Eloqua website.</param>
/// <returns>The information for the given account. It is directly retrieved from Eloqua.</returns>
public static async Task<AccountInfo> GetAccountInfoAsync(string site, string user, string password)
{
var client = new BaseClient(site, user, password, BulkUrl.Login);
IRestResponse<AccountInfo> responseAccountInfo =
await client.ExecuteTaskAsync<AccountInfo>(new RestRequest("id", Method.GET));
return responseAccountInfo.Data;
}
public static void HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = client as LobbyClient;
Program.CharMgr.DeleteCharacter(cclient.Account.Id, packet.GetUint8());
PacketOut Out = new PacketOut((UInt32)Opcodes.ANS_CHARACTER_DELETE);
Out.WriteUInt32R(0);
cclient.SendTCP(Out);
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = client as LobbyClient;
cclient.Characters.Delete(packet.GetUint8());
PacketOut Out = new PacketOut((UInt32)Opcodes.ANS_CHARACTER_DELETE);
Out.WriteUInt32Reverse((uint)ResponseCodes.RC_SUCCESS);
cclient.Send(Out);
return 0;
}
/// <summary>
/// Executes the handlers for a specified request type.
/// </summary>
/// <param name="key">The request type.</param>
/// <param name="client">Client on which to execute handler; provided in event delegate.</param>
/// <param name="e">Desired event arguments.</param>
public void ExecuteHandler(short key, BaseClient client, RequestReceivedEventArgs e)
{
ClientEventHandler<RequestReceivedEventArgs> value;
if (TryGetValue(key, out value))
{
value.Invoke(client, e);
}
}
public static void F_INTERRUPT(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null)
return;
cclient.Plr.AbtInterface.StopCast();
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
WorldClient cclient = (WorldClient)client;
UInt32 whisperuid = packet.GetUint32Reversed();
String charname = packet.GetParsedString();
String message = packet.GetParsedString();
(client as WorldClient).Send(new ANS_CHAT_WHISPER(cclient, whisperuid, charname, message));
//cclient.Send(new CHAT_WHISPER(cclient.CharacterId, 1, message));
return 0;
}
public static void HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = client as LobbyClient;
packet.Skip(24);
string Email = packet.GetUnicodeString().ToUpper();
Log.Notice("ASK_LOGIN", "Authentification de : " + Email);
SendLoginResult(cclient, Email,Program.CharMgr.LoadAccount(Email));
}
static public void CMSG_GetAcctPropListReq(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
PacketOut Out = new PacketOut((byte)Opcodes.SMSG_GetAcctPropListReply);
byte[] val = { 0x08, 0x00 };
Out.Write(val);
cclient.SendTCPCuted(Out);
}
public static void Init(string apiKey)
{
if (string.IsNullOrEmpty(apiKey))
{
Log.WriteWarn("Error Reporter", "API key is empty, errors will not be sent to Bugsnag.");
return;
}
Client = new BaseClient(apiKey);
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
LobbyClient cclient = (LobbyClient)client;
byte FileId = packet.GetUint8();
PacketOut Out = new PacketOut((UInt32)Opcodes.ANS_CONFIGFILE_LOAD);
Out.WriteInt32Reverse((int)ResponseCodes.RC_SUCCESS);
Out.WriteByte(FileId);
byte[] Result = ZlibMgr.Compress(Program.FileMgr.GetFileByte((int)cclient.Account.Id, FileId, true, "", ""));
cclient.Send(Out);
return 0;
}
static public void F_TEXT(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null)
return;
byte Unk = packet.GetUint8();
string Text = packet.GetString((int)(packet.Length - packet.Position));
CommandMgr.HandleText(cclient.Plr, Text);
}
static public void F_SOCIAL_NETWORK(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.IsPlaying() || !cclient.Plr.IsInWorld())
return;
Player Plr = cclient.Plr;
byte Type = packet.GetUint8();
switch (Type)
{
case 11: // Inspection
{
Player Target = Plr.CbtInterface.GetTarget(GameData.TargetTypes.TARGETTYPES_TARGET_ALLY) as Player;
if (Target == null)
Plr.SendLocalizeString("", GameData.Localized_text.TEXT_SN_LISTS_ERR_PLAYER_NOT_FOUND);
else
Target.ItmInterface.SendInspect(Plr);
}
break;
case 8:
{
packet.Skip(1);
byte NameSize = packet.GetUint8();
packet.Skip(1);
string Name = packet.GetString(NameSize);
byte GuildSize = packet.GetUint8();
packet.Skip(1);
string GuildName = packet.GetString(GuildSize);
packet.Skip(1);
UInt16 Career = packet.GetUint16();
packet.Skip(4);
UInt16 ZoneId = packet.GetUint16();
while (ZoneId > 256)
ZoneId -= 256;
while (packet.GetUint8() != 0xFF) ;
packet.Skip(2 + (ZoneId == 255 ? 0 : 1));
byte MinLevel = packet.GetUint8();
byte MaxLevel = packet.GetUint8();
Plr.SocInterface.SendPlayers(Player.GetPlayers(Name, GuildName, Career, ZoneId, MinLevel, MaxLevel));
} break;
}
}
public async Task logCreatedNewAuth0Client(BaseClient requestingClient, string createdAuth0AccountEmail)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.CREATED_NEW_AUTH0_CLIENT_CATEGORY), $"{requestingClient.nickname} requested to make a client an Auth0 account for the email: {createdAuth0AccountEmail}"));
await saveLogs();
}
public virtual async Task Validate(BaseClient client, CancellationToken cancellationToken)
{
var authGrantTypes = _responseTypeHandlers.Select(r => r.GrantType);
var supportedGrantTypes = _grantTypeHandlers.Select(g => g.GrantType).Union(authGrantTypes).Distinct();
var notSupportedGrantTypes = client.GrantTypes.Where(gt => !supportedGrantTypes.Any(sgt => sgt == gt));
if (notSupportedGrantTypes.Any())
{
throw new OAuthException(ErrorCodes.INVALID_CLIENT_METADATA, string.Format(ErrorMessages.UNSUPPORTED_GRANT_TYPES, string.Join(",", notSupportedGrantTypes)));
}
if (!string.IsNullOrWhiteSpace(client.TokenEndPointAuthMethod) && !_oauthClientAuthenticationHandlers.Any(o => o.AuthMethod == client.TokenEndPointAuthMethod))
{
throw new OAuthException(ErrorCodes.INVALID_CLIENT_METADATA, string.Format(ErrorMessages.UNKNOWN_AUTH_METHOD, client.TokenEndPointAuthMethod));
}
var supportedResponseTypeHandlers = _responseTypeHandlers.Where(r => client.GrantTypes.Contains(r.GrantType));
if (supportedResponseTypeHandlers.Any())
{
var supportedResponseTypes = supportedResponseTypeHandlers.Select(s => s.ResponseType);
var unSupportedResponseTypes = client.ResponseTypes.Where(r => !supportedResponseTypes.Contains(r));
if (unSupportedResponseTypes.Any())
{
throw new OAuthException(ErrorCodes.INVALID_CLIENT_METADATA, string.Format(ErrorMessages.BAD_RESPONSE_TYPES, string.Join(",", unSupportedResponseTypes)));
}
}
foreach (var kvp in supportedResponseTypeHandlers.GroupBy(k => k.GrantType))
{
if (!kvp.Any(k => client.ResponseTypes.Contains(k.ResponseType)))
{
throw new OAuthException(ErrorCodes.INVALID_CLIENT_METADATA, string.Format(ErrorMessages.MISSING_RESPONSE_TYPE, kvp.Key));
}
}
if (supportedResponseTypeHandlers.Any())
{
if (client.RedirectionUrls == null || !client.RedirectionUrls.Any())
{
throw new OAuthException(ErrorCodes.INVALID_CLIENT_METADATA, string.Format(ErrorMessages.MISSING_PARAMETER, OAuthClientParameters.RedirectUris));
}
foreach (var redirectUrl in client.RedirectionUrls)
{
CheckRedirectUrl(client, redirectUrl);
}
}
var scopes = client.AllowedScopes.Select(_ => _.Name);
var existingScopes = (await _oauthScopeRepository.FindOAuthScopesByNames(scopes, cancellationToken));
var existingScopeNames = existingScopes.Select(s => s.Name);
var unsupportedScopes = scopes.Except(existingScopeNames);
if (unsupportedScopes.Any())
{
throw new OAuthException(ErrorCodes.INVALID_CLIENT_METADATA, string.Format(ErrorMessages.UNSUPPORTED_SCOPES, string.Join(",", unsupportedScopes)));
}
client.AllowedScopes = existingScopes;
CheckUri(client.JwksUri, ErrorMessages.BAD_JWKS_URI);
CheckUris(client.ClientUris, ErrorMessages.BAD_CLIENT_URI);
CheckUris(client.LogoUris, ErrorMessages.BAD_LOGO_URI);
CheckUris(client.TosUris, ErrorMessages.BAD_TOS_URI);
CheckUris(client.PolicyUris, ErrorMessages.BAD_POLICY_URI);
CheckSignature(client.TokenSignedResponseAlg, ErrorMessages.UNSUPPORTED_TOKEN_SIGNED_RESPONSE_ALG);
CheckEncryption(client.TokenEncryptedResponseAlg, client.TokenEncryptedResponseEnc, ErrorMessages.UNSUPPORTED_TOKEN_ENCRYPTED_RESPONSE_ALG, ErrorMessages.UNSUPPORTED_TOKEN_ENCRYPTED_RESPONSE_ENC, OAuthClientParameters.TokenEncryptedResponseAlg);
if (!string.IsNullOrWhiteSpace(client.JwksUri) && client.JsonWebKeys != null)
{
throw new OAuthException(ErrorCodes.INVALID_CLIENT_METADATA, ErrorMessages.DUPLICATE_JWKS);
}
}
public async Task logGetProfile(BaseClient requestingClient, Profile returnedProfile)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.GET_PROFILE_CATEGORY), requestingClient.nickname + " made a request to get a profile object for: " + returnedProfile.nickname));
await saveLogs();
}
public async Task logModifiedClientStatus(BaseClient requestingClient, Client affectedClientWithNewStatus, Status oldStatus)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.MODIFIED_CLIENT_STATUS_CATEGORY), $"{requestingClient.nickname} requested to modify {affectedClientWithNewStatus.nickname}'s status from '{oldStatus.statusDescription}' to '{affectedClientWithNewStatus.clientStatus.statusDescription}'"));
await saveLogs();
}
public async Task logDeletedClient(BaseClient requestingClient, BaseClient deletedClient)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.DELETED_CLIENT_CATEGORY), $"{requestingClient.nickname} requested to delete {deletedClient.nickname} and all related entities"));
await saveLogs();
}
public async Task logDeletedTag(BaseClient requestingClient, Logic.Objects.Tag deletedTag)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.DELETED_TAG_CATEGORY), $"{requestingClient.nickname} requested to delete the {deletedTag.tagName} tag"));
await saveLogs();
}
public async Task logError(BaseClient requestingClient, string category)
{
Category errorCategory = await getCategoryByName(LoggingConstants.MODIFIED_ANSWER_CATEGORY);
string logMessage = $"{requestingClient.nickname}'s request failed. ";
#region post
if (errorCategory.categoryName == LoggingConstants.CREATED_ASSIGNMENT_CATEGORY)
{
logMessage += "There was an error posting new assignments";
}
if (errorCategory.categoryName == LoggingConstants.CREATED_NEW_MESSAGE_CATEGORY)
{
logMessage += "There was an error creating a new message";
}
if (errorCategory.categoryName == LoggingConstants.CREATED_NEW_CLIENT_CATEGORY)
{
logMessage += "There was an error creating a new client object";
}
if (errorCategory.categoryName == LoggingConstants.CREATED_NEW_AUTH0_CLIENT_CATEGORY)
{
logMessage += "There was an error creating a new Auth0 account for a client";
}
if (errorCategory.categoryName == LoggingConstants.CREATED_NEW_TAG_CATEGORY)
{
logMessage += "There was an error creating a new tag";
}
if (errorCategory.categoryName == LoggingConstants.CREATED_NEW_CLIENT_TAG_RELATIONSHIPS_CATEGORY)
{
logMessage += "There was an error adding a tag to a client";
}
#endregion
#region get
if (errorCategory.categoryName == LoggingConstants.GET_ALL_CLIENT_CATEGORY)
{
logMessage += "There was an error getting all clients";
}
if (errorCategory.categoryName == LoggingConstants.GET_PROFILE_CATEGORY)
{
logMessage += "There was an error retrieving a profile";
}
if (errorCategory.categoryName == LoggingConstants.GET_SPECIFIC_CLIENT_CATEGORY)
{
logMessage += "There was an error getting the client data";
}
if (errorCategory.categoryName == LoggingConstants.GET_SPECIFIC_HISTORY_CATEGORY)
{
logMessage += "There was an error getting the history object";
}
if (errorCategory.categoryName == LoggingConstants.GET_ALL_HISTORY_CATEGORY)
{
logMessage += "There was an error getting all of the history objects";
}
#endregion
#region put
if (errorCategory.categoryName == LoggingConstants.MODIFIED_ANSWER_CATEGORY)
{
logMessage += "There was an error changing the answer";
}
if (errorCategory.categoryName == LoggingConstants.MODIFIED_ASSIGNMENT_STATUS_CATEGORY)
{
logMessage += "There was an error modifying the assignment's status";
}
if (errorCategory.categoryName == LoggingConstants.MODIFIED_CLIENT_CATEGORY)
{
logMessage += "There was an error modifying a client";
}
if (errorCategory.categoryName == LoggingConstants.MODIFIED_PROFILE_CATEGORY)
{
logMessage += "There was an error modifying the profile";
}
if (errorCategory.categoryName == LoggingConstants.MODIFIED_MESSAGE_READ_STATUS_CATEGORY)
{
logMessage += "There was an error modifying the read status of a message";
}
if (errorCategory.categoryName == LoggingConstants.MODIFIED_CLIENT_STATUS_CATEGORY)
{
logMessage += "There was an error modifying a client's status";
}
#endregion
#region delete
if (errorCategory.categoryName == LoggingConstants.DELETED_CLIENT_CATEGORY)
{
logMessage += "There was an error deleting a client and all the related entities";
}
if (errorCategory.categoryName == LoggingConstants.DELETED_ASSIGNMENT_CATEGORY)
{
logMessage += "There was an error deleting an assignment from a client's list";
}
if (errorCategory.categoryName == LoggingConstants.DELETED_TAG_CATEGORY)
{
logMessage += "There was an error deleting a tag";
}
#endregion
await repository.CreateNewLogEntry(makeLogTemplateObject(errorCategory, logMessage));
await saveLogs();
}
public async Task logCreatedNewTag(BaseClient requestingClient, Logic.Objects.Tag newTag)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.CREATED_NEW_TAG_CATEGORY), $"{requestingClient.nickname} requested to make a new tag: {newTag.tagName}"));
await saveLogs();
}
public Task <bool> Delete(BaseClient data, CancellationToken cancellationToken)
{
_clients.Remove(_clients.First(c => c.ClientId == data.ClientId));
return(Task.FromResult(true));
}
/// <summary>
/// Inits the repo, gpg etc
/// </summary>
public frmMain()
{
InitializeComponent();
var bugsnag = new BaseClient("23814316a6ecfe8ff344b6a467f07171");
EnableTray = false;
// Getting actual version
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string version = fvi.FileVersion;
cfg["version"] = version.Remove(5, 2);
this.Text = "Pass4Win " + Strings.Version + " " + cfg["version"];
// checking for update this an async operation
LatestPass4WinRelease();
// Do we have a valid password store and settings
try
{
if (cfg["PassDirectory"] == "")
{
// this will fail, I know ugly hack
}
}
catch
{
cfg["FirstRun"] = true;
frmConfig Config = new frmConfig();
var dialogResult = Config.ShowDialog();
}
//checking git status
if (!LibGit2Sharp.Repository.IsValid(cfg["PassDirectory"]))
{
// Remote or generate a new one
if (cfg["UseGitRemote"] == true)
{
// check if server is alive
if (IsGITAlive(cfg["UseGitRemote"]) || IsHTTPSAlive(cfg["UseGitRemote"]))
{
// clone the repo and catch any error
try
{
string clonedRepoPath = LibGit2Sharp.Repository.Clone(cfg["GitRemote"], cfg["PassDirectory"], new CloneOptions()
{
CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials
{
Username = cfg["GitUser"],
Password = DecryptConfig(cfg["GitPass"], "pass4win")
}
});
}
catch
{
MessageBox.Show(Strings.Error_connection, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
toolStripOffline.Visible = true;
}
}
else
{
MessageBox.Show(Strings.Error_git_unreachable, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
toolStripOffline.Visible = true;
}
}
else
{
// creating new Git
var repo = LibGit2Sharp.Repository.Init(cfg["PassDirectory"], false);
toolStripOffline.Visible = true;
}
}
else
{
// Do we do remote or not
CheckOnline(true);
}
// Making sure core.autocrlf = true
using (var repo = new LibGit2Sharp.Repository(cfg["PassDirectory"]))
{
repo.Config.Set("core.autocrlf", true);
}
// Init GPG if needed
string gpgfile = cfg["PassDirectory"];
gpgfile += "\\.gpg-id";
// Check if we need to init the directory
if (!File.Exists(gpgfile))
{
Directory.CreateDirectory(Path.GetDirectoryName(gpgfile));
KeySelect newKeySelect = new KeySelect();
if (newKeySelect.ShowDialog() == DialogResult.OK)
{
using (StreamWriter w = new StreamWriter(gpgfile))
{
w.Write(newKeySelect.gpgkey);
}
using (var repo = new LibGit2Sharp.Repository(cfg["PassDirectory"]))
{
repo.Stage(gpgfile);
repo.Commit("gpgid added", new LibGit2Sharp.Signature("pass4win", "pass4win", System.DateTimeOffset.Now), new LibGit2Sharp.Signature("pass4win", "pass4win", System.DateTimeOffset.Now));
}
}
else
{
newKeySelect.Close();
MessageBox.Show(Strings.Error_nokey, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
System.Environment.Exit(1);
}
}
// Setting the exe location for the GPG Dll
GpgInterface.ExePath = cfg["GPGEXE"];
// Setting up datagrid
dt.Columns.Add("colPath", typeof(string));
dt.Columns.Add("colText", typeof(string));
treeDt.Columns.Add("colPath", typeof(string));
treeDt.Columns.Add("colText", typeof(string));
ListDirectory(new DirectoryInfo(cfg["PassDirectory"]), "");
fillDirectoryTree(dirTreeView, cfg["PassDirectory"]);
dataPass.DataSource = dt.DefaultView;
dataPass.Columns[0].Visible = false;
EnableTray = true;
}
static public void F_PLAYER_STATE2(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null || !cclient.Plr.IsInWorld())
{
return;
}
Player Plr = cclient.Plr;
long Pos = packet.Position;
PacketOut Out = new PacketOut((byte)Opcodes.F_PLAYER_STATE2);
Out.Write(packet.ToArray(), (int)packet.Position, (int)packet.Size);
Out.WriteByte(0);
Plr.DispatchPacket(Out, false);
packet.Position = Pos;
UInt16 Key = packet.GetUint16();
byte Type = packet.GetUint8();
byte MoveingState = packet.GetUint8();
byte CombatByte = packet.GetUint8();
byte Strafe = packet.GetUint8();
UInt16 Heading = packet.GetUint16R();
UInt16 X = packet.GetUint16R();
UInt16 Y = packet.GetUint16R();
byte Unk1 = packet.GetUint8();
UInt16 Z = packet.GetUint16R();
byte zmod = packet.GetUint8();
//Log.Success("zMod ",""+zmod);
// zmod is somewhat strange what i found out so far
// z mod is 255 while standing
// z mod is 0 while running and z is below 65535
// z mod is 1 while running and z is above 65535
// z mod can be 113 / 97 / 115 / 99 while running and z is below 65535 and enemy in target
// z mod is 99 / 100 / 116 while running and z is above 65535 and enemy in target
// z mod is 4 while running in water
// z mod is 68 while swimming in water
// z mod is ticking with 255 7 times then 68 while standing in deep water
// z mod is 12 while running in water (that should lower your health / kill you and reduce movement speed)
// z mod is ticking with 255 7 times then 12 while standing in lava
if (packet.Size < 10)
{
return;
}
int z_temp = Z;
Heading /= 8;
X /= 2;
Y /= 2;
// z update if z is higher then 65535
if (zmod != 0 && zmod != 97 && zmod != 113 && zmod != 99 && zmod != 115)
{
z_temp += 65535;
}
if (Type != (byte)MovementTypes.NotMoving)
{
Plr.IsMoving = true;
}
else
{
Plr.IsMoving = false;
}
//Log.Success("Movement Before ", X + "," + Y + "," + Z);
if (CombatByte >= 50 && CombatByte < 0x92 || CombatByte == 0xDF)
{
if (Plr.LastCX != 0 && Plr.LastCY != 0)
{
if (Plr.LastCX > 12288 && X < 4096)
{
Plr.SetOffset((ushort)(Plr.XOffset + 1), Plr.YOffset);
}
else if (X > 12288 && Plr.LastCX < 4096)
{
Plr.SetOffset((ushort)(Plr.XOffset - 1), Plr.YOffset);
}
if (Plr.LastCY > 24576 && Y < 8192)
{
Plr.SetOffset(Plr.XOffset, (ushort)(Plr.YOffset + 1));
}
else if (Y > 24576 && Plr.LastCY < 8192)
{
Plr.SetOffset(Plr.XOffset, (ushort)(Plr.YOffset - 1));
}
}
Plr.LastCX = X;
Plr.LastCY = Y;
X = Plr.Zone.CalculCombat(X, Plr.XOffset, true);
Y = Plr.Zone.CalculCombat(Y, Plr.YOffset, false);
Heading /= 2;
z_temp /= 16;
// combat offset z
if (Plr._ZoneMgr.ZoneId == 161 || Plr._ZoneMgr.ZoneId == 162)
{
z_temp += 12288;
}
else
{
z_temp += 4096;
}
}
else
{
if (Plr.LastX != 0 && Plr.LastY != 0)
{
if (Plr.LastX > 24576 && X < 4096)
{
Plr.SetOffset((ushort)(Plr.XOffset + 1), Plr.YOffset);
}
else if (Plr.LastX < 4096 && X > 24576)
{
Plr.SetOffset((ushort)(Plr.XOffset - 1), Plr.YOffset);
}
if (Plr.LastY > 24576 && Y < 4096)
{
Plr.SetOffset(Plr.XOffset, (ushort)(Plr.YOffset + 1));
}
else if (Plr.LastY < 4096 && Y > 24576)
{
Plr.SetOffset(Plr.XOffset, (ushort)(Plr.YOffset - 1));
}
}
Plr.LastX = X;
Plr.LastY = Y;
X = Plr.Zone.CalculPin(X, Plr.XOffset, true);
Y = Plr.Zone.CalculPin(Y, Plr.YOffset, false);
z_temp /= 4;
}
// if (Plr.IsInWorld() && Plr.Zone.ZoneId == 161)
// Z += 16384;
//Log.Success("Movement after", "X=" + X + ",Y=" + Y + ",Z=" + Z + ",ztemp = " + z_temp + "," + Type + "," + Unk1 + "," + CombatByte);
Plr.SetPosition(X, Y, (ushort)z_temp, Heading);
}
public SearchMembersClient(BaseClient baseClient)
{
_baseClient = baseClient;
}
public static void F_UI_MOD(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
//Log.Dump("F_UI_MOD", packet, true);
}
public override void HandleMcpeDisconnect(McpeDisconnect message)
{
Log.Info($"Received disconnect: {message.message}");
BaseClient.ShowDisconnect(message.message, false);
base.HandleMcpeDisconnect(message);
}
public async Task logCreatedNewClient(BaseClient requestingClient, Client newClient)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.CREATED_NEW_CLIENT_CATEGORY), $"{requestingClient.nickname} requested to make a new client object with email: {newClient.email}"));
await saveLogs();
}
public async Task logGetSpecificClient(BaseClient requestingClient, BaseClient requestedClient)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.GET_SPECIFIC_CLIENT_CATEGORY), requestingClient.nickname + " made a request to retrieve the client information for " + requestedClient.nickname));
await saveLogs();
}
public override void HandleMcpeAvailableCommands(McpeAvailableCommands message)
{
BaseClient.LoadCommands(message.CommandSet);
//UnhandledPackage(message);
}
public async Task <List <MessageHistory> > GetAllChatHistories(BaseClient subjectClient)
{
List <Message.Data.Entities.Client> contextClients = await santaContext.Clients.Include(c => c.ClientStatus).Where(c => c.ClientStatus.StatusDescription != Constants.AWAITING_STATUS && c.ClientStatus.StatusDescription != Constants.DENIED_STATUS).ToListAsync();
/* Assignment history query */
/*
* Xref is not null
* Event type is the type of event attatched to the xref
* Assignment status is attached to xref
* Subject client is the meta passed in the method
* Conversation client is the sender client (The agent)
* Assignment sender is the sender client (The agent)
* Assignment reciever client is the reciever client (The actual assignment client)
*
* Subject and reciever messages are new lists for loading times since histories are lazy loaded in the app
*
*/
List <MessageHistory> listLogicAssignmentMessageHistory = await santaContext.ClientRelationXrefs
.Select(xref => new MessageHistory()
{
relationXrefID = xref.ClientRelationXrefId,
eventType = new Event()
{
eventTypeID = xref.EventType.EventTypeId,
eventDescription = xref.EventType.EventDescription,
active = xref.EventType.IsActive,
removable = xref.EventType.ClientRelationXrefs.Count == 0 && xref.EventType.Surveys.Count == 0,
immutable = xref.EventType.EventDescription == Constants.CARD_EXCHANGE_EVENT || xref.EventType.EventDescription == Constants.GIFT_EXCHANGE_EVENT
},
assignmentStatus = Mapper.MapAssignmentStatus(xref.AssignmentStatus),
subjectClient = Mapper.MapClientChatMeta(subjectClient),
conversationClient = Mapper.MapClientChatMeta(xref.SenderClient),
assignmentRecieverClient = Mapper.MapClientChatMeta(xref.RecipientClient),
assignmentSenderClient = Mapper.MapClientChatMeta(xref.SenderClient),
subjectMessages = new List <ChatMessage>(),
recieverMessages = new List <ChatMessage>(),
unreadCount = xref.ChatMessages
.Where(m => !m.FromAdmin && m.IsMessageRead == false)
.Count()
}).ToListAsync();
/* General history query */
/*
* All clients where the status of the client is approved or completed (Awaiting and denied have no chat history)
*
* Xref is null
* Event type does not exist
* Assignment status does not exist
* Subject client is the meta passed in the method
* Conversation client is the client object in the context
* Assingment sender/reciever clients do not exist
*
* Subject and reciever messages are new lists for loading times since histories are lazy loaded in the app
*/
List <MessageHistory> logicGeneralChatHistories = await santaContext.Clients.Where(c => c.ClientStatus.StatusDescription == Constants.APPROVED_STATUS || c.ClientStatus.StatusDescription == Constants.COMPLETED_STATUS)
.Select(client => new MessageHistory()
{
relationXrefID = null,
eventType = new Event(),
assignmentStatus = new AssignmentStatus(),
subjectClient = Mapper.MapClientChatMeta(subjectClient),
conversationClient = Mapper.MapClientChatMeta(client),
assignmentRecieverClient = new ClientChatMeta(),
assignmentSenderClient = new ClientChatMeta(),
subjectMessages = new List <ChatMessage>(),
recieverMessages = new List <ChatMessage>(),
unreadCount = client.ChatMessageMessageSenderClients
.Where(m => m.ClientRelationXrefId == null && !m.MessageSenderClient.IsAdmin && m.IsMessageRead == false)
.Count()
}).ToListAsync();
List <MessageHistory> totalHistories = listLogicAssignmentMessageHistory.Concat(logicGeneralChatHistories).ToList();
return(totalHistories.OrderByDescending(h => h.eventType.eventDescription).ThenBy(h => h.conversationClient.clientNickname).ToList());
}
public async Task logDeletedAssignment(BaseClient requestingClient, BaseClient affectedClient, RelationshipMeta deletedAssignment)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.DELETED_ASSIGNMENT_CATEGORY), $"{requestingClient.nickname} requested to remove {deletedAssignment.relationshipClient.clientNickname} from {affectedClient.nickname}'s assignment list"));
await saveLogs();
}
public async Task PostAsyncReturnsBatchResponseContent()
{
using (HttpResponseMessage responseMessage = new HttpResponseMessage(HttpStatusCode.OK))
using (TestHttpMessageHandler testHttpMessageHandler = new TestHttpMessageHandler())
{
/* Arrange */
// 1. create a mock response
string requestUrl = "https://localhost/";
string responseJSON = "{\"responses\":"
+ "[{"
+ "\"id\": \"1\","
+ "\"status\":200,"
+ "\"headers\":{\"Cache-Control\":\"no-cache\",\"OData-Version\":\"4.0\",\"Content-Type\":\"application/json;odata.metadata=minimal;odata.streaming=true;IEEE754Compatible=false;charset=utf-8\"},"
+ "\"body\":{\"@odata.context\":\"https://graph.microsoft.com/v1.0/$metadata#users/$entity\",\"displayName\":\"MOD Administrator\",\"jobTitle\":null,\"id\":\"9f4fe8ea-7e6e-486e-b8f4-VkHdanfIomf\"}"
+ "},"
+ "{"
+ "\"id\": \"2\","
+ "\"status\":409,"
+ "\"headers\" : {\"Cache-Control\":\"no-cache\"},"
+ "\"body\":{\"error\": {\"code\": \"20117\",\"message\": \"An item with this name already exists in this location.\",\"innerError\":{\"request-id\": \"nothing1b13-45cd-new-92be873c5781\",\"date\": \"2019-03-22T23:17:50\"}}}"
+ "}]}";
HttpContent content = new StringContent(responseJSON);
responseMessage.Content = content;
// 2. Map the response
testHttpMessageHandler.AddResponseMapping(requestUrl, responseMessage);
// 3. Create a batch request object to be tested
MockCustomHttpProvider customHttpProvider = new MockCustomHttpProvider(testHttpMessageHandler);
BaseClient client = new BaseClient(requestUrl, authenticationProvider.Object, customHttpProvider);
BatchRequest batchRequest = new BatchRequest(requestUrl, client);
// 4. Create batch request content to be sent out
// 4.1 Create HttpRequestMessages for the content
HttpRequestMessage httpRequestMessage1 = new HttpRequestMessage(HttpMethod.Get, "https://graph.microsoft.com/v1.0/me/");
HttpRequestMessage httpRequestMessage2 = new HttpRequestMessage(HttpMethod.Post, "https://graph.microsoft.com/v1.0/me/onenote/notebooks");
// 4.2 Create batch request steps with request ids.
BatchRequestStep requestStep1 = new BatchRequestStep("1", httpRequestMessage1);
BatchRequestStep requestStep2 = new BatchRequestStep("2", httpRequestMessage2, new List <string> {
"1"
});
// 4.3 Add batch request steps to BatchRequestContent.
BatchRequestContent batchRequestContent = new BatchRequestContent(requestStep1, requestStep2);
/* Act */
BatchResponseContent returnedResponse = await batchRequest.PostAsync(batchRequestContent);
HttpResponseMessage firstResponse = await returnedResponse.GetResponseByIdAsync("1");
HttpResponseMessage secondResponse = await returnedResponse.GetResponseByIdAsync("2");
/* Assert */
// validate the first response
Assert.NotNull(firstResponse);
Assert.Equal(HttpStatusCode.OK, firstResponse.StatusCode);
Assert.True(firstResponse.Headers.CacheControl.NoCache);
Assert.NotNull(firstResponse.Content);
// validate the second response
Assert.NotNull(secondResponse);
Assert.Equal(HttpStatusCode.Conflict, secondResponse.StatusCode);
Assert.True(secondResponse.Headers.CacheControl.NoCache);
Assert.NotNull(secondResponse.Content);
}
}
public override void HandleMcpeRequestChunkRadius(McpeRequestChunkRadius message)
{
BaseClient.RequestChunkRadius(Client.ChunkRadius);
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
SendDistrictEnter((WorldClient)client);
return(0);
}
public async Task logModifiedClient(BaseClient requestingClient, Client modifiedClient)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.GET_ALL_HISTORY_CATEGORY), $"{requestingClient.nickname} modified a client's data for {modifiedClient.nickname}"));
await saveLogs();
}
protected virtual T Get(string id, Dictionary <string, object> urlParams = null)
{
var result = BaseClient.Get(this.GetResourceUri(id) + Utils.BuildUrlParams(urlParams));
return(Utils.Deserialize <T>(result));
}
public static void F_COMMAND_CONTROLLED(BaseClient client, PacketIn packet)
{
GameClient cclient = (GameClient)client;
if (cclient.Plr?.CrrInterface == null)
{
return;
}
IPetCareerInterface petInterface = cclient.Plr.CrrInterface as IPetCareerInterface;
Pet myPet = petInterface?.myPet;
if (myPet == null)
{
return;
}
ushort abilityid = packet.GetUint16();
PetCommand command = (PetCommand)packet.GetUint8();
switch (command)
{
case PetCommand.Stay:
if (cclient.Plr.IsMounted)
{
return;
}
myPet.MvtInterface.StopMove();
myPet.FollowMode = 1;
myPet.IsHeeling = false;
myPet.AiInterface.Debugger?.SendClientMessage("[MR]: Holding position by request.");
myPet.SendPetUpdate();
break; // stay
case PetCommand.Follow:
if (cclient.Plr.IsMounted)
{
return;
}
myPet.AiInterface.ProcessCombatEnd();
if (myPet.StsInterface.Speed == 0)
{
break;
}
myPet.MvtInterface.ScaleSpeed(myPet.SpeedMult);
myPet.MvtInterface.Recall(cclient.Plr);
myPet.FollowMode = 2;
myPet.AiInterface.Debugger?.SendClientMessage("[MR]: Heeling by request.");
myPet.SendPetUpdate();
break; // heel
case PetCommand.Passive:
myPet.AiInterface.SetBrain(new PassiveBrain(myPet));
petInterface.AIMode = 3;
myPet.AIMode = 3;
myPet.AiInterface.Debugger?.SendClientMessage("[MR]: Passive state.");
break; // mode Passive
case PetCommand.Defensive:
myPet.AiInterface.SetBrain(new GuardBrain(myPet));
petInterface.AIMode = 4;
myPet.AIMode = 4;
myPet.AiInterface.Debugger?.SendClientMessage("[MR]: Defensive state.");
break; // mode Defensive
case PetCommand.Aggressive:
myPet.AiInterface.SetBrain(new AggressiveBrain(myPet));
petInterface.AIMode = 5;
myPet.AIMode = 5;
myPet.AiInterface.Debugger?.SendClientMessage("[MR]: Aggressive state.");
break; // mode Aggressive
case PetCommand.Attack:
long now = TCPManager.GetTimeStampMS();
if (cclient.Plr.IsMounted || now <= myPet.AttackReuseTimer + COMMAND_ATTACK_REUSE)
{
return;
}
myPet.AttackReuseTimer = now;
Unit target = cclient.Plr.CbtInterface.GetTarget(TargetTypes.TARGETTYPES_TARGET_ENEMY);
if (target == null || !CombatInterface.CanAttack(myPet, target))
{
return;
}
if (!cclient.Plr.LOSHit(target))
{
return;
}
myPet.AiInterface.Debugger?.SendClientMessage("[MR]: Attacking by request.");
myPet.IsHeeling = false;
myPet.FollowMode = 0;
myPet.Owner.CbtInterface.RefreshCombatTimer();
myPet.AiInterface.ProcessCombatStart(target);
myPet.SendPetUpdate();
break; //attack
case PetCommand.Release:
myPet.Destroy();
break;
case PetCommand.AbilityCast:
if (cclient.Plr.IsMounted)
{
return;
}
foreach (NPCAbility pa in myPet.AbtInterface.NPCAbilities)
{
if (pa.Entry == abilityid)
{
if (pa.Range > 0)
{
Unit abTarget = myPet.CbtInterface.GetCurrentTarget();
if (abTarget == null || !myPet.LOSHit(abTarget))
{
return;
}
}
myPet.AbtInterface.StartCast(myPet, abilityid, 1);
break;
}
}
break;
case PetCommand.Autocast:
if (cclient.Plr.IsMounted)
{
return;
}
foreach (NPCAbility pa in myPet.AbtInterface.NPCAbilities)
{
if (pa.Entry != abilityid)
{
continue;
}
pa.AutoUse = !pa.AutoUse;
myPet.SendPetUpdate();
break;
}
break;
}
}
public async Task logCreatedNewClientTagRelationships(BaseClient requestingClient, BaseClient targetClient)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.CREATED_NEW_CLIENT_TAG_RELATIONSHIPS_CATEGORY), $"{requestingClient.nickname} requested to add tags to {targetClient.nickname}"));
await saveLogs();
}
public async Task <MessageHistory> GetChatHistoryByXrefIDAndSubjectIDAsync(Guid clientRelationXrefID, BaseClient subjectClient)
{
MessageHistory logicHistory = new MessageHistory();
Message.Data.Entities.ClientRelationXref contextRelationship = await santaContext.ClientRelationXrefs
.Include(r => r.EventType)
.Include(r => r.SenderClient)
.Include(r => r.RecipientClient)
.Include(r => r.AssignmentStatus)
.Include(r => r.ChatMessages)
.ThenInclude(cm => cm.MessageReceiverClient)
.Include(r => r.ChatMessages)
.ThenInclude(cm => cm.MessageSenderClient)
.Where(x => x.ClientRelationXrefId == clientRelationXrefID)
.AsNoTracking()
.FirstOrDefaultAsync();
return(Mapper.MapHistoryInformation(contextRelationship, subjectClient, false));
}
public async Task <MessageHistory> GetGeneralChatHistoryBySubjectIDAsync(Client conversationClient, BaseClient subjectClient)
{
MessageHistory logicHistory = new MessageHistory();
List <Message.Data.Entities.ChatMessage> contextListMessages = await santaContext.ChatMessages
.Where(m => m.ClientRelationXrefId == null && (m.MessageSenderClientId == conversationClient.clientID || m.MessageReceiverClientId == conversationClient.clientID))
.Include(s => s.MessageSenderClient)
.Include(r => r.MessageReceiverClient)
.AsNoTracking()
.OrderBy(dt => dt.DateTimeSent)
.ToListAsync();
return(Mapper.MapHistoryInformation(conversationClient, contextListMessages, subjectClient));
}
public async Task logGetAllClients(BaseClient requestingClient)
{
await repository.CreateNewLogEntry(makeLogTemplateObject(await getCategoryByName(LoggingConstants.GET_ALL_CLIENT_CATEGORY), requestingClient.nickname + " made a request to retrieve a list of all clients"));
await saveLogs();
}
public void KickClient(string command, string[] args)
{
if (args.Length <= 0)
{
IGConsole.Instance.println("Usage: type \"help\"", false);
return;
}
if (ulong.TryParse(args[0], out ulong Id))
{
if (socketObj.ConnectedClients.ContainsKey(Id))
{
socketObj.ConnectedClients[Id].SendPacket(new ConnectionPacket(false, 0, false, false));
socketObj.ConnectedClients[Id].RootDispose();
}
else
{
IGConsole.Instance.println("invalid ID", false);
}
}
else
{
switch (args[0])
{
case "all":
foreach (var item in socketObj.ConnectedClients)
{
item.Value.SendPacket(new ConnectionPacket(false, 0, false, false));
item.Value.RootDispose();
}
break;
case "index":
if (args.Length <= 1)
{
IGConsole.Instance.println("Usage: type \"help\"", false);
return;
}
if (int.TryParse(args[1], out int index))
{
int i = 0;
BaseClient baseClient = null;
foreach (var item in socketObj.ConnectedClients)
{
if (i == index)
{
baseClient = item.Value;
}
i++;
}
if (baseClient != null)
{
baseClient.SendPacket(new ConnectionPacket(false, 0, false, false));
baseClient.RootDispose();
}
else
{
IGConsole.Instance.println("invalid index", false);
}
}
else
{
IGConsole.Instance.println("invalid parameter", false);
}
break;
default:
IGConsole.Instance.println("invalid parameter", false);
break;
}
}
}