public FUTRequestBase(FUTAccount account, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod loginMethod)
{
FUTAccount = account;
RequestPerMinuteManager = rpmManager;
RequestPerMinuteManagerSearch = rpmManagerSearch;
CurrentLoginMethod = loginMethod;
}
public LoginWebRequest(FUTAccount account, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_mailClient = MailClientFactory.Create(account.EMail, account.EMailPassword);
FUTAccount.FUTPlatform = new FUTPlatform();
FUTAccount.FUTPlatform.SKU = Constants.SKUWeb;
}
public static CookieContainer GetCookieContainer(FUTAccount account, bool web = true)
{
lock (_lockObject)
{
var cString = web ? "web" : "mobile";
var filename = Path.GetFullPath(_path + $"\\cookies\\{account.EMail.ToLower().Replace(".", "")}_{cString}.dat");
if (!File.Exists(filename))
{
return(new CookieContainer());
}
Directory.CreateDirectory(Path.GetFullPath(_path + "\\cookies\\"));
try
{
using (Stream stream = File.Open(filename, FileMode.Open))
{
BinaryFormatter formatter = new BinaryFormatter();
return((CookieContainer)formatter.Deserialize(stream));
}
}
catch (Exception e)
{
return(new CookieContainer());
}
}
}
public static void AddFUTAccount(FUTAccount account)
{
lock (_accountsLock)
{
using (var context = new FUTAccountsDatabase())
{
context.FUTAccounts.Add(account);
context.SaveChanges();
}
}
}
public static void DeleteCookieContainer(FUTAccount account, bool web = true)
{
lock (_lockObject)
{
var cString = web ? "web" : "mobile";
var filename = Path.GetFullPath(_path + $"\\cookies\\{account.EMail.ToLower().Replace(".", "")}_{cString}.dat");
Directory.CreateDirectory(Path.GetFullPath(_path + "\\cookies\\"));
if (File.Exists(filename))
{
try
{
File.Delete(filename);
}
catch (Exception e)
{
}
}
}
}
public FUTRequestFactory(FUTAccount account)
{
FUTAccount = account;
_httpClient = new HttpClientEx();
_httpClient.AddCommonHeaders();
_cookies = new CookieContainer();
//load cookies from db
//var futCookies = FUTAccountsDatabase.GetFUTCookiesByFUTAccount(FUTAccount);
//if (futCookies != null)
//{
// if(!string.IsNullOrEmpty(futCookies.FutWeb))
// {
// _cookies = futCookies.FutWeb.DeserializeCookieContainer();
// }
//}
_httpClient.ClientHandler.CookieContainer = _cookies;
RequestPerMinuteManager = new RequestPerMinuteManager();
RequestPerMinuteManagerSearch = new RequestPerMinuteManager(true);
RequestCounter = 0;
}
public static void UpdateCoinsByFUTAccount(FUTAccount account, int coins)
{
using (var context = new FUTLogsDatabase())
{
var lastSession = context.FUTCoins.FirstOrDefault(x => x.EMail.ToLower() == account.EMail.ToLower());
if (lastSession != null)
{
lastSession.Coins = coins;
}
else
{
var coinsNew = new FUTCoins
{
EMail = account.EMail,
Coins = coins
};
context.FUTCoins.Add(coinsNew);
}
context.SaveChanges();
}
}
public static void SaveCookieContainer(FUTAccount account, CookieContainer cookies, bool web = true)
{
lock (_lockObject)
{
var cString = web ? "web" : "mobile";
var filename = Path.GetFullPath(_path + $"\\cookies\\{account.EMail.ToLower().Replace(".", "")}_{cString}.dat");
Directory.CreateDirectory(Path.GetFullPath(_path + "\\cookies\\"));
DeleteCookieContainer(account, web);
using (Stream stream = File.Create(filename))
{
try
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, cookies);
}
catch (Exception e)
{
}
}
}
}
public RemoveItemsFromWatchlistRequest(FUTAccount account, List <string> tradeIDs, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_tradeIDs = tradeIDs;
}
public IOSLoginRequest(FUTAccount account, FUTSession session, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, session, rpmManager, rpmManagerSearch, login)
{
_mailClient = MailClientFactory.Create(account.EMail, account.EMailPassword);
}
public SolveCaptchaRequest(FUTAccount account, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login, string captchaResult) : base(account, rpmManager, rpmManagerSearch, login)
{
_captchaResult = captchaResult;
}
public BuyTradeRequest(FUTAccount account, long tradeID, long price, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_price = price;
_tradeID = tradeID;
}
public OfferItemOnTransferMarketRequest(FUTAccount account, OfferItemModel item, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_item = item;
}
public UserHistoricalRequest(FUTAccount account, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
}
public MuleManager()
{
this.RequiresAuthentication();
this.RequiresClaims(delegate(Claim claim)
{
var beingAs = GetRoleFromClaim(claim.Value);
return(beingAs == WebAccessRole.Administrator || beingAs == WebAccessRole.Owner);
});
Get("/mulemanager", args =>
{
var model = new MuleManagerModel();
model.Clients = Fifa.Managers.MuleManager.GetMuleClients();
return(View["MuleManager", model]);
});
Post("/mulemanager", args =>
{
var body = new StreamReader(Request.Body).ReadToEnd();
var parameters = HttpUtility.ParseQueryString(body);
if (parameters["importMulingsessions"] != null)
{
try
{
var data = parameters["importData"];
var lines = data.Split("\r\n".ToCharArray());
foreach (var line in lines)
{
if (line.Trim() == "" || !line.Contains(";"))
{
continue;
}
var accountData = line.Split(';');
if (accountData.Count() != 8)
{
continue;
}
var futAccount = new FUTAccount
{
EMail = accountData[0],
Password = accountData[1],
EMailPassword = accountData[2],
SecurityAnswer = accountData[3],
BackupCode1 = accountData[4],
};
var muleClient = new MuleClient(futAccount)
{
MuleVolume = int.Parse(accountData[5]),
MinimumCoinsOnAccount = int.Parse(accountData[6])
};
Fifa.Managers.MuleManager.AddMuleClient(muleClient);
}
return(Response.AsRedirect("/mulemanager"));
}
catch (Exception e)
{
return(Response.AsRedirect("/mulemanager"));
}
}
if (parameters["addMulingsession"] != null)
{
var futAccount = new FUTAccount
{
EMail = parameters["accountEMail"],
EMailPassword = parameters["accountEMailPassword"],
Password = parameters["accountPassword"],
BackupCode1 = parameters["accountBackupCode"],
SecurityAnswer = parameters["accountSecurityanswer"]
};
var muleClient = new MuleClient(futAccount)
{
MuleVolume = int.Parse(parameters["muleVolume"]),
MinimumCoinsOnAccount = int.Parse(parameters["minimumCoinsOnAccount"])
};
Fifa.Managers.MuleManager.AddMuleClient(muleClient);
return(Response.AsRedirect("/mulemanager"));
}
return(Response.AsRedirect("/mulemanager"));
});
Post("/removemulesession", args =>
{
var body = new StreamReader(Request.Body).ReadToEnd();
var parameters = HttpUtility.ParseQueryString(body);
var email = parameters["email"];
var client = Fifa.Managers.MuleManager.GetMuleClientByEMail(email);
if (client == null)
{
return(Response.AsRedirect("/mulemanager"));
}
if (!client.Muling)
{
Fifa.Managers.MuleManager.RemoveMuleClient(email);
}
return(Response.AsRedirect("/mulemanager"));
});
}
public NotAssignedRequest(FUTAccount account, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
}
public PriceLimitsRequest(FUTAccount account, long assetID, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_assetID = assetID;
}
public SetNewUserRequest(FUTAccount account, RequestPerMinuteManager rpmManager,
RequestPerMinuteManager rpmManagerSearch, LoginMethod login, UserHistoricalResponse hist)
: base(account, rpmManager, rpmManagerSearch, login)
{
_hist = hist;
}
public UserMassInfoRequest(FUTAccount account, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod loginMethod) : base(account, rpmManager, rpmManagerSearch, loginMethod)
{
}
public async Task <LoginResponse> PerformRequestAsync()
{
try
{
var resp = new LoginResponse();
if (_mailClient == null && String.IsNullOrEmpty(FUTAccount.BackupCode1) && String.IsNullOrEmpty(FUTAccount.BackupCode2) && String.IsNullOrEmpty(FUTAccount.BackupCode3) && String.IsNullOrEmpty(FUTAccount.GoogleAuthCode))
{
resp.Code = FUTErrorCode.UnknownEMailProvider;
resp.Message = "Unknown EMailprovider";
return(resp);
}
HttpClient.RemoveRequestHeader(NonStandardHttpHeaders.PhishingToken);
HttpClient.RemoveRequestHeader(NonStandardHttpHeaders.SessionId);
UpdateStatistic("Loading Cookies and Enviromentvariables...");
HttpClient.SetCookieContainer(CookieManager.GetCookieContainer(FUTAccount, false));
UpdateStatistic("Grabbing Loginpage...");
var loggedIn = await GetLoginPageAsync().ConfigureAwait(false);
var loggedInString = await loggedIn.Content.ReadAsStringAsync().ConfigureAwait(false);
if (!loggedIn.RequestMessage.RequestUri.AbsoluteUri.Contains("companion/auth.html"))
{
await Task.Delay(2000).ConfigureAwait(false);
UpdateStatistic("Loging in to Origin...");
loggedIn = await LoginAsync(loggedIn.RequestMessage.RequestUri.AbsoluteUri).ConfigureAwait(false);
loggedInString = await loggedIn.Content.ReadAsStringAsync().ConfigureAwait(false);
}
var codeSentTimestamp = DateTime.Now.Subtract(new TimeSpan(0, 2, 0));
if (loggedInString.Contains("var redirectUri = 'https://signin.ea.com:443/p/web2/login?execution="))
{
var redirect = Regex.Match(loggedInString, "'(.*?)';").Groups[1].Value;
var red2 = Regex.Match(loggedInString, "redirectUri \\+ \"(.*?)\";").Groups[1].Value;
loggedIn = await HttpClient.GetAsync(redirect + red2).ConfigureAwait(false);
loggedInString = await loggedIn.Content.ReadAsStringAsync().ConfigureAwait(false);
}
if (loggedInString.Contains("general-error") && !loggedInString.Contains("panel-profile-upgrade"))
{
resp.Code = Models.FUTErrorCode.WrongLoginData;
return(resp);
}
if (loggedInString.Contains("panel-forewordMessage") && loggedInString.Contains("btn-continue"))
{
UpdateStatistic("Accepting TFACreation...");
loggedIn = await AcceptTwoFactorAsync(loggedIn.RequestMessage.RequestUri.AbsoluteUri);
loggedInString = await loggedIn.Content.ReadAsStringAsync().ConfigureAwait(false);
}
if (loggedInString.Contains("btnTFACreate") && loggedInString.Contains("tfa_type") && loggedInString.Contains("EMAIL"))
{
UpdateStatistic("Create EMail TFA...");
loggedIn = await CreateEMailTwoFactorAsync(loggedIn.RequestMessage.RequestUri.AbsoluteUri);
loggedInString = await loggedIn.Content.ReadAsStringAsync().ConfigureAwait(false);
}
if (loggedInString.Contains("tfa-login-link") && loggedInString.Contains("btnSendCode"))
{
if (!String.IsNullOrEmpty(FUTAccount.GoogleAuthCode))
{
loggedIn = await SelectGoogleAuthenticatorAsync(loggedIn.RequestMessage.RequestUri.AbsoluteUri).ConfigureAwait(false);
loggedInString = await loggedIn.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
loggedIn = await SelectEMailTwoFactorAsync(loggedIn.RequestMessage.RequestUri.AbsoluteUri).ConfigureAwait(false);
loggedInString = await loggedIn.Content.ReadAsStringAsync().ConfigureAwait(false);
}
}
var twoFactorCode = "";
if (loggedInString.Contains("oneTimeCode"))
{
if (!String.IsNullOrEmpty(FUTAccount.BackupCode1))
{
twoFactorCode = FUTAccount.BackupCode1;
FUTAccount.BackupCode1 = "";
FUTAccount.SaveChanges();
}
else if (!String.IsNullOrEmpty(FUTAccount.BackupCode2))
{
twoFactorCode = FUTAccount.BackupCode2;
FUTAccount.BackupCode2 = "";
FUTAccount.SaveChanges();
}
else if (!String.IsNullOrEmpty(FUTAccount.BackupCode2))
{
twoFactorCode = FUTAccount.BackupCode2;
FUTAccount.BackupCode3 = "";
FUTAccount.SaveChanges();
}
else if (!string.IsNullOrEmpty(FUTAccount.GoogleAuthCode))
{
twoFactorCode = QuickEAAuthenticator.GenerateAuthCode(FUTAccount.GoogleAuthCode);
}
else
{
var resendUri = loggedIn.RequestMessage.RequestUri.AbsoluteUri + "&_eventId=resend";
var resendUri2 = "https://signin.ea.com" + loggedInString.GetRegexBetween(" < a id=\"resend_code_link\" href=\"", "\"");
UpdateStatistic("Waiting for TwoFactor Code...");
twoFactorCode = await WaitForTwoFactorCode(codeSentTimestamp, resendUri).ConfigureAwait(false);
}
if (twoFactorCode == "WrongUserPassword")
{
resp.Code = Models.FUTErrorCode.WrongEMailPassword;
return(resp);
}
if (twoFactorCode == "GMXBlocked")
{
resp.Code = Models.FUTErrorCode.GMXBlocked;
return(resp);
}
if (twoFactorCode.StartsWith("EXC"))
{
resp.Code = Models.FUTErrorCode.TwoFactorFailed;
resp.Message = twoFactorCode.Remove(0, 3);
return(resp);
}
if (twoFactorCode == "000000" || twoFactorCode == "")
{
resp.Code = Models.FUTErrorCode.TwoFactorFailed;
resp.Message = "Couldn't get twoFactorCode";
return(resp);
}
await Task.Delay(2000).ConfigureAwait(false);
loggedIn = await FillInTwoFactorAsync(loggedIn.RequestMessage.RequestUri.AbsoluteUri, twoFactorCode).ConfigureAwait(false);
loggedInString = await loggedIn.Content.ReadAsStringAsync().ConfigureAwait(false);
}
if (loggedInString.Contains("Eingegebener Code nicht korrekt"))
{
resp.Code = FUTErrorCode.WrongEMailCode;
resp.Message = "Wrong email code!";
return(resp);
}
if (!loggedIn.RequestMessage.RequestUri.AbsoluteUri.Contains("auth.html"))
{
resp.Code = Models.FUTErrorCode.NoRedirectToWebApp;
resp.Message = "No redirect to mobile-app";
return(resp);
}
UpdateStatistic("Grabbing EASW ID...");
var authCode = loggedIn.RequestMessage.RequestUri.Query.Remove(0, 6);
var tmpBearer = await GetBearerAuthCodeAsync(authCode);
var bearer = Regex.Match(tmpBearer, "\"access_token\" : \"(.*?)\",").Groups[1].Value;
var easw = await GetEaswAsync(bearer);
var easwID = easw.pid.pidId.ToString();
if (string.IsNullOrEmpty(easwID))
{
CookieManager.DeleteCookieContainer(FUTAccount, false);
resp.Code = Models.FUTErrorCode.NoEaswID;
resp.Message = "No easwID";
return(resp);
}
resp.NucleusID = easwID;
HttpClient.AddRequestHeader(NonStandardHttpHeaders.NucleusId, easwID);
HttpClient.AddRequestHeader(NonStandardHttpHeaders.EmbedError, "true");
UpdateStatistic("Grabbing Shards...");
var shards = await IsServerOnline();
if (!shards)
{
resp.Code = Models.FUTErrorCode.ServerMaintenance;;
resp.Message = "Server offline";
return(resp);
}
HttpClient.AddRequestHeader(NonStandardHttpHeaders.SessionId, "");
UpdateStatistic("Grabbing UserAccounts...");
var userAccounts = await BruteforcePlatformAsync().ConfigureAwait(false);
if (userAccounts == null || userAccounts.userAccountInfo == null || userAccounts.userAccountInfo.personas == null || userAccounts.userAccountInfo.personas.FirstOrDefault() == null)
{
resp.Code = Models.FUTErrorCode.NoUserAccounts;
resp.Message = "No userAccounts";
return(resp);
}
var nucleusName = userAccounts.userAccountInfo.personas.FirstOrDefault().personaName;
var personaID = userAccounts.userAccountInfo.personas.FirstOrDefault().personaId.ToString();
resp.NucleusName = nucleusName;
resp.PersonaID = personaID;
authCode = await GetAuthCodeAsync(bearer);
authCode = Regex.Match(authCode, "{\"code\":\"(.*?)\"}").Groups[1].Value;
if (string.IsNullOrEmpty(authCode))
{
resp.Code = Models.FUTErrorCode.NoSessionID;
resp.Message = "No authCode";
return(resp);
}
UpdateStatistic("Authing on Utas...");
var authed = await AuthAsync(authCode, personaID).ConfigureAwait(false);
if (authed == null || string.IsNullOrEmpty(authed.sid))
{
resp.Code = Models.FUTErrorCode.NoSessionID;
resp.Message = "No sid";
return(resp);
}
resp.SessionID = authed.sid;
HttpClient.AddRequestHeader(NonStandardHttpHeaders.SessionId, authed.sid);
await Task.Delay(3000).ConfigureAwait(false);
UpdateStatistic("Grabbing SecurityQuestion...");
var question = await QuestionAsync().ConfigureAwait(false);
if (question.Code == FUTErrorCode.CaptchaTriggered || question.Code == FUTErrorCode.CaptchaTriggered2)
{
var futproxy = FUTAccount.GetFUTProxy();
var solver = new CaptchaSolver(futproxy);
var result = await solver.DoAntiCaptcha();
if (result.errorId == 0)
{
await SolveCaptchaAsync(result.solution.token);
question = await QuestionAsync().ConfigureAwait(false);
}
else
{
resp.Code = Models.FUTErrorCode.CaptchaException;
resp.Message = "Captcha failed! " + result.errorDescription;
return(resp);
}
}
if (!string.IsNullOrEmpty(question.token))
{
HttpClient.AddRequestHeader(NonStandardHttpHeaders.PhishingToken, question.token);
resp.PhishingToken = question.token;
HttpClient.RemoveRequestHeader(NonStandardHttpHeaders.NucleusId);
HttpClient.RemoveRequestHeader(NonStandardHttpHeaders.Route);
CollectAllCookies();
return(resp);
}
UpdateStatistic("Validating SecurityQuestion...");
var validate = await ValidateAsync().ConfigureAwait(false);
if (string.IsNullOrEmpty(validate?.token))
{
if (validate.code == "461")
{
resp.Code = Models.FUTErrorCode.WrongSecurityAnswer;
resp.Message = "Wrong SecurityAnswer";
return(resp);
}
resp.Code = Models.FUTErrorCode.NoPhishingToken;
resp.Message = "No phishingtoken";
return(resp);
}
//await QuestionAsync().ConfigureAwait(false);
UpdateStatistic("Login success...");
HttpClient.AddRequestHeader(NonStandardHttpHeaders.PhishingToken, validate.token);
resp.PhishingToken = validate.token;
HttpClient.RemoveRequestHeader(NonStandardHttpHeaders.Route);
CollectAllCookies();
return(resp);
}
catch (Exception e)
{
var resp = new LoginResponse();
resp.Message = e.ToString();
resp.Code = FUTErrorCode.BadRequest;
return(resp);
}
}
public MoveItemToTradepileRequest(FUTAccount account, long itemID, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_itemID = itemID;
}
public TransferMarketRequest(FUTAccount account, FUTSearchParameter item, bool isMuling, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_item = item;
_muling = isMuling;
}
public RemoveItemFromTradepileRequest(FUTAccount account, long tradeID, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_tradeID = tradeID;
}
public CreditsRequest(FUTAccount account, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
}
public AccountManager()
{
this.RequiresAuthentication();
Get("/accountmanager", args =>
{
var mod = new AccountManagerModel();
var accounts = FUTAccountsDatabase.GetFUTAccounts();
mod.Accounts = accounts;
return(View["AccountManager", mod]);
});
Post("/accountmanager", args =>
{
var body = new StreamReader(Request.Body).ReadToEnd();
body = HttpUtility.UrlDecode(body);
var parameters = HttpUtility.ParseQueryString(body);
var accounts = parameters["accounts"].Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
foreach (var accString in accounts)
{
if (accString.Split(';').Count() < 5)
{
continue;
}
var email = accString.Split(';')[0];
var password = accString.Split(';')[1];
var securityAnswer = accString.Split(';')[2];
var appAuth = accString.Split(';')[3];
var emailPassword = accString.Split(';')[4];
if (FUTAccountsDatabase.GetFUTAccountByEMail(email) == null)
{
var futAccount = new FUTAccount();
futAccount.EMail = email;
futAccount.Password = password;
futAccount.SecurityAnswer = securityAnswer;
futAccount.GoogleAuthCode = appAuth;
futAccount.EMailPassword = emailPassword;
futAccount.FUTPlatform = new FUTPlatform();
FUTAccountsDatabase.AddFUTAccount(futAccount);
Fifa.Managers.BotManager.AddBot(email);
}
}
return(Response.AsRedirect("/accountmanager"));
});
Post("/deleteaccountarray", args =>
{
var body = new StreamReader(Request.Body).ReadToEnd();
body = HttpUtility.UrlDecode(body);
var parameters = HttpUtility.ParseQueryString(body);
var accounts = parameters["account"].Split(',');
foreach (var acc in accounts)
{
FUTAccountsDatabase.RemoveFUTAccountByEMail(acc);
Fifa.Managers.BotManager.RemoveBot(acc);
}
return("true");
});
Post("/deleteaccount", args =>
{
var body = new StreamReader(Request.Body).ReadToEnd();
body = HttpUtility.UrlDecode(body);
var parameters = HttpUtility.ParseQueryString(body);
var acc = parameters["account"];
FUTAccountsDatabase.RemoveFUTAccountByEMail(acc);
Fifa.Managers.BotManager.RemoveBot(acc);
return("true");
});
}
public DiscardItemRequest(FUTAccount account, long item, bool isMuling, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod login) : base(account, rpmManager, rpmManagerSearch, login)
{
_item = item;
_muling = isMuling;
}
public DeleteActiveMessageRequest(FUTAccount account, int id, RequestPerMinuteManager rpmManager, RequestPerMinuteManager rpmManagerSearch, LoginMethod loginMethod) : base(account, rpmManager, rpmManagerSearch, loginMethod)
{
_id = id;
}
