public static Player Find(string playerName)
{
if (string.IsNullOrWhiteSpace(playerName))
{
return(null);
}
var player = Player.FindOnline(playerName);
if (player != null)
{
return(player);
}
try
{
using (var context = DbInterface.CreatePlayerContext())
{
return(QueryPlayerByName(context, playerName));
}
}
catch (Exception ex)
{
Log.Error(ex);
return(null);
}
}
protected override void HandleTarget(ServerContext context, ParserResult result, Client target)
{
if (target?.Entity == null)
{
Console.WriteLine($@" {Strings.Player.offline}");
return;
}
if (target.Name == null)
{
Console.WriteLine($@" {Strings.Account.notfound}");
return;
}
var power = result.Find(Power);
DbInterface.SetPlayerPower(target.Name, power.AsUserRights());
PacketSender.SendEntityDataToProximity(target.Entity);
PacketSender.SendGlobalMsg(
power != Access.None
? Strings.Player.admin.ToString(target.Entity.Name)
: Strings.Player.deadmin.ToString(target.Entity.Name)
);
Console.WriteLine($@" {Strings.Commandoutput.powerchanged.ToString(target.Entity.Name)}");
}
public static bool PlayerExists(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return(false);
}
var player = FindOnline(name);
if (player != null)
{
return(true);
}
try
{
using (var context = DbInterface.CreatePlayerContext())
{
return(AnyPlayerByName(context, name));
}
}
catch (Exception ex)
{
Log.Error(ex);
return(false);
}
}
public static void RemoveFriendship(Guid id, Guid otherId)
{
if (id == Guid.Empty || otherId == Guid.Empty)
{
return;
}
//No passing in custom contexts here.. they may already have this user in the change tracker and things just get weird.
//The cost of making a new context is almost nil.
try
{
using (var context = DbInterface.CreatePlayerContext(readOnly: false))
{
var friendship = context.Player_Friends.Where(f => f.Owner.Id == id && f.Target.Id == otherId).FirstOrDefault();
if (friendship != null)
{
context.Entry(friendship).State = EntityState.Deleted;
}
var otherFriendship = context.Player_Friends.Where(f => f.Owner.Id == otherId && f.Target.Id == id).FirstOrDefault();
if (otherFriendship != null)
{
context.Entry(otherFriendship).State = EntityState.Deleted;
}
context.SaveChanges();
}
}
catch (Exception ex)
{
Log.Error(ex, $"Failed to remove friendship between {id} and {otherId}.");
//ServerContext.DispatchUnhandledException(new Exception("Failed to save user, shutting down to prevent rollbacks!"), true);
}
}
/// <summary>
/// Augmenter ou diminuer tous les prix
/// </summary>
/// <param name="pourcentage"></param>
public static void ModifierPrix(String pourcentage)
{
DataTable dt;
sErreurs err = new sErreurs("", "");
String mysql;
try
{
/*
* Code SQL de création de la procédure stockée :
*
* CREATE PROCEDURE `modifier_prix` ( IN `pourcentage` INT )
* COMMENT 'Augmenter ou diminuer les prix d''un pourcentage.' NOT DETERMINISTIC MODIFIES SQL DATA SQL SECURITY DEFINER
* BEGIN
* UPDATE articles SET prix_art = prix_art * ( 1 + pourcentage /100 );
* END
*
*/
// appel de la procédure stockée
mysql = "CALL modifier_prix(" + pourcentage + ");";
dt = DbInterface.Lecture(mysql, err);
}
catch (MonException erreur)
{
throw erreur;
}
}
private static bool PostContextSetup()
{
if (Context == null)
{
throw new ArgumentNullException(nameof(Context));
}
if (!DbInterface.InitDatabase(Context))
{
Console.ReadKey();
return(false);
}
Console.WriteLine();
Console.WriteLine(Strings.Commandoutput.playercount.ToString(DbInterface.RegisteredPlayers));
Console.WriteLine(Strings.Commandoutput.gametime.ToString(Time.GetTime().ToString("F")));
Time.Update();
PacketSender.CacheGameDataPacket();
return(true);
}
/// <summary>
/// Loads a guild and it's members from the database
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static Guild LoadGuild(Guid id)
{
if (!Guilds.TryGetValue(id, out Guild found))
{
using (var context = DbInterface.CreatePlayerContext())
{
var guild = context.Guilds.Where(g => g.Id == id).Include(g => g.Bank).FirstOrDefault();
if (guild != null)
{
//Load Members
var members = context.Players.Where(p => p.DbGuild.Id == id).ToDictionary(t => t.Id, t => new Tuple <Guid, string, int, int, Guid, Guid>(t.Id, t.Name, t.GuildRank, t.Level, t.ClassId, t.MapId));
foreach (var member in members)
{
var gmember = new GuildMember(member.Value.Item1, member.Value.Item2, member.Value.Item3, member.Value.Item4, ClassBase.GetName(member.Value.Item5), MapBase.GetName(member.Value.Item6));
guild.Members.AddOrUpdate(member.Key, gmember, (key, oldValue) => gmember);
}
SlotHelper.ValidateSlots(guild.Bank, guild.BankSlotsCount);
guild.Bank = guild.Bank.OrderBy(bankSlot => bankSlot?.Slot).ToList();
Guilds.AddOrUpdate(id, guild, (key, oldValue) => guild);
return(guild);
}
}
}
else
{
return(found);
}
return(null);
}
/// <summary>
/// Récupérer la liste des articles
/// </summary>
/// <param name="tri">champ de tri</param>
/// <param name="ordre">sens du tri</param>
/// <returns>lste d'articles</returns>
public List <Article> getLesArticles(String tri = "NO_ARTICLE", String ordre = "ASC")
{
DataTable dt;
sErreurs err = new sErreurs("", "");
//MySqlConnection cnx = Connexion.getInstance().getConnexion();
String mysql = "SELECT NO_ARTICLE, LIB_ARTICLE, QTE_DISPO, VILLE_ART, PRIX_ART, INTERROMPU ";
mysql += "FROM ARTICLES ";
mysql += "ORDER BY " + tri + " " + ordre;
try
{
dt = DbInterface.Lecture(mysql, err);
List <Article> mesArt = new List <Article>();
foreach (DataRow dataRow in dt.Rows)
{
Article unart = new Article();
unart.no_article = dataRow[0].ToString();
unart.lib_article = dataRow[1].ToString();
unart.qte_dispo = dataRow[2].ToString();
unart.ville_art = dataRow[3].ToString();
unart.prix_art = dataRow[4].ToString();
unart.interrompu = dataRow[5].ToString();
mesArt.Add(unart);
}
return(mesArt);
}
catch (MonException erreur)
{
throw erreur;
}
}
public static string FindMuteReason(
[NotNull] User user,
string ip,
[CanBeNull] PlayerContext playerContext = null
)
{
lock (DbInterface.GetPlayerContextLock())
{
var context = DbInterface.GetPlayerContext();
if (context == null)
{
return(null);
}
if (user.Mute == null)
{
user.IpMute = Find(ip);
}
var mute = user.Mute;
var expired = mute?.IsExpired ?? true;
if (expired && mute != null)
{
Remove(mute);
user.IpMute = null;
user.UserMute = null;
}
return(expired
? null
: Strings.Account.mutestatus.ToString(mute.StartTime, mute.Muter, mute.EndTime, mute.Reason));
}
}
public void OnGet()
{
if (PostId == null)
{
Status = "";
StatusColor = "black";
return;
}
try
{
var prj = DbInterface.GetPostById(Convert.ToInt32(PostId));
PostName = prj.Name;
PostAnnouncement = prj.Announcement;
PostBody = prj.Body;
PostType = prj.Type.ToString();
var users = DbInterface.GetUsersRelatedToPostById(Convert.ToInt32(PostId));
RelationTypes = string.Empty;
foreach (var entry in users)
{
RelationTypes += entry.userData.Id + ": " + (int)entry.postRelation + '\n';
}
Status = "Loaded";
StatusColor = "green";
}
catch (Exception e)
{
StatusColor = "red";
Status = "Error: " + e.Message;
new InternalException(e);
}
}
public object ItemsGive(LookupKey lookupKey, [FromBody] ItemInfo itemInfo)
{
if (lookupKey.IsInvalid)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest, lookupKey.IsIdInvalid ? @"Invalid player id." : @"Invalid player name."
));
}
if (ItemBase.Get(itemInfo.ItemId) == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, @"Invalid item id."));
}
if (itemInfo.Quantity < 1)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest, "Cannot give 0, or a negative amount of an item."
));
}
var(client, player) = Player.Fetch(lookupKey);
if (player == null)
{
return(Request.CreateErrorResponse(
HttpStatusCode.NotFound,
lookupKey.HasId
? $@"No player with id '{lookupKey.Id}'."
: $@"No player with name '{lookupKey.Name}'."
));
}
if (!player.TryGiveItem(itemInfo.ItemId, itemInfo.Quantity, ItemHandling.Normal, itemInfo.BankOverflow, true))
{
return(Request.CreateErrorResponse(
HttpStatusCode.InternalServerError,
$@"Failed to give player {itemInfo.Quantity} of '{itemInfo.ItemId}'."
));
}
using (var context = DbInterface.CreatePlayerContext(false))
{
context.Update(player);
context.SaveChanges();
}
var quantityBank = player.CountItems(itemInfo.ItemId, false, true);
var quantityInventory = player.CountItems(itemInfo.ItemId, true, false);
return(new
{
id = itemInfo.ItemId,
quantity = new
{
total = quantityBank + quantityInventory,
bank = quantityBank,
inventory = quantityInventory
}
});
}
public object PlayerLevelSet(LookupKey lookupKey, [FromBody] LevelChange change)
{
if (lookupKey.IsInvalid)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest, lookupKey.IsIdInvalid ? @"Invalid player id." : @"Invalid player name."
));
}
var(client, player) = Player.Fetch(lookupKey);
if (player != null)
{
player.SetLevel(change.Level, true);
if (player.Online)
{
PacketSender.SendEntityDataToProximity(player);
}
using (var context = DbInterface.CreatePlayerContext(false))
{
context.Update(player);
context.SaveChanges();
}
return(player);
}
return(Request.CreateErrorResponse(
HttpStatusCode.NotFound,
lookupKey.HasId ? $@"No player with id '{lookupKey.Id}'." : $@"No player with name '{lookupKey.Name}'."
));
}
private void CalculateBounds( MapInstance map, int x, int y )
{
var maps = new Stack<Tuple<MapInstance, int, int>>();
maps.Push( new Tuple<MapInstance, int, int>( map, x, y ) );
while( maps.Count > 0 )
{
var curMap = maps.Pop();
map = curMap.Item1;
x = curMap.Item2;
y = curMap.Item3;
if( HasMap( map.Id ) || DbInterface.GridsContain( map.Id ) )
{
continue;
}
MyMaps.Add( map.Id );
map.MapGridX = x;
map.MapGridY = y;
if( x < mTopLeft.X )
{
mTopLeft.X = x;
}
if( y < mTopLeft.Y )
{
mTopLeft.Y = y;
}
if( x > mBotRight.X )
{
mBotRight.X = x;
}
if( y > mBotRight.Y )
{
mBotRight.Y = y;
}
if( MapInstance.Lookup.Keys.Contains( map.Up ) && MapInstance.Get( map.Up ).Down == map.Id )
{
maps.Push( new Tuple<MapInstance, int, int>( MapInstance.Get( map.Up ), x, y - 1 ) );
}
if( MapInstance.Lookup.Keys.Contains( map.Down ) && MapInstance.Get( map.Down ).Up == map.Id )
{
maps.Push( new Tuple<MapInstance, int, int>( MapInstance.Get( map.Down ), x, y + 1 ) );
}
if( MapInstance.Lookup.Keys.Contains( map.Left ) && MapInstance.Get( map.Left ).Right == map.Id )
{
maps.Push( new Tuple<MapInstance, int, int>( MapInstance.Get( map.Left ), x - 1, y ) );
}
if( MapInstance.Lookup.Keys.Contains( map.Right ) && MapInstance.Get( map.Right ).Left == map.Id )
{
maps.Push( new Tuple<MapInstance, int, int>( MapInstance.Get( map.Right ), x + 1, y ) );
}
}
}
public static RefreshToken Find(Guid id)
{
lock (DbInterface.GetPlayerContextLock())
{
return(DbInterface.GetPlayerContext()?.RefreshTokens?.Find(id));
}
}
/// <summary>
/// Joins a player into the guild.
/// </summary>
/// <param name="player">The player to join into the guild.</param>
/// <param name="rank">Integer index of the rank to give this new member.</param>
/// <param name="initiator">The player who initiated this change (null if done by the api or some other method).</param>
public void AddMember(Player player, int rank, Player initiator = null)
{
if (player != null && !Members.Any(m => m.Key == player.Id))
{
using (var context = DbInterface.CreatePlayerContext(readOnly: false))
{
var dbPlayer = context.Players.FirstOrDefault(p => p.Id == player.Id);
if (dbPlayer != null)
{
dbPlayer.DbGuild = this;
dbPlayer.GuildRank = rank;
dbPlayer.GuildJoinDate = DateTime.UtcNow;
context.ChangeTracker.DetectChanges();
DetachGuildFromDbContext(context, this);
context.SaveChanges();
player.Guild = this;
player.GuildRank = rank;
player.GuildJoinDate = DateTime.UtcNow;
var member = new GuildMember(player.Id, player.Name, player.GuildRank, player.Level, player.ClassName, player.MapName);
Members.AddOrUpdate(player.Id, member, (key, oldValue) => member);
// Send our new guild list to everyone that's online.
UpdateMemberList();
// Send our entity data to nearby players.
PacketSender.SendEntityDataToProximity(Player.FindOnline(player.Id));
LogActivity(Id, player, initiator, GuildActivityType.Joined);
}
}
}
}
public static bool Remove(Guid userId, bool expired = true)
{
try
{
using (var context = DbInterface.CreatePlayerContext(readOnly: false))
{
var bans = context.Bans.Where(e => e.UserId == userId && (!expired || Expired(e))).ToList();
if ((bans?.Count ?? 0) == 0)
{
return(true);
}
foreach (var ban in bans)
{
context.Entry(ban).State = EntityState.Deleted;
}
context.SaveChanges();
}
return(true);
}
catch (Exception ex)
{
Log.Error(ex, "Failed to remove bans for user with id " + userId);
//ServerContext.DispatchUnhandledException(new Exception("Failed to save user, shutting down to prevent rollbacks!"), true);
}
return(false);
}
/// <summary>
/// Removes all guilds in which only have 1 member that haven't been online in the configured number of days
/// </summary>
public static void WipeStaleGuilds()
{
if (Options.Instance.Guild.DeleteStaleGuildsAfterDays > 0)
{
using (var context = DbInterface.CreatePlayerContext(readOnly: false))
{
foreach (var guild in context.Guilds)
{
var memberCount = context.Players.Where(p => p.DbGuild.Id == guild.Id).Count();
if (memberCount == 0)
{
context.Entry(guild).State = EntityState.Deleted;
LogActivity(guild.Id, null, null, GuildActivityType.Disbanded, "Stale");
}
else if (context.Players.Where(p => p.DbGuild.Id == guild.Id).Count() == 1)
{
var lastOnline = context.Players.FirstOrDefault(p => p.DbGuild.Id == guild.Id).LastOnline;
if (lastOnline != null && DateTime.UtcNow - lastOnline > TimeSpan.FromDays(Options.Instance.Guild.DeleteStaleGuildsAfterDays))
{
context.Entry(guild).State = EntityState.Deleted;
LogActivity(guild.Id, null, null, GuildActivityType.Disbanded, "Stale");
}
}
}
context.SaveChanges();
}
}
}
/// <summary>
/// Modifier les informations de l'article courant dans la base de données
/// </summary>
public void modifierArticle()
{
DataTable dt;
sErreurs err = new sErreurs("", "");
String mysql;
try
{
// actualiser les infoamtions dans la base
mysql = "UPDATE ARTICLES SET LIB_ARTICLE = '";
mysql += this.lib_article;
mysql += "', QTE_DISPO = '";
mysql += this.qte_dispo;
mysql += "', VILLE_ART = '";
mysql += this.ville_art;
mysql += "', PRIX_ART = '";
mysql += this.prix_art;
mysql += "', INTERROMPU = '";
mysql += this.interrompu;
mysql += "' WHERE NO_ARTICLE = '" + this.no_article + "';";
dt = DbInterface.Lecture(mysql, err);
}
catch (MonException erreur)
{
throw erreur;
}
}
public object UserChangeEmailById(Guid userId, [FromBody] AdminChange authorizedChange)
{
var email = authorizedChange.New;
if (string.IsNullOrWhiteSpace(email))
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, $@"Malformed email address '{email}'."));
}
if (!FieldChecking.IsWellformedEmailAddress(email, Strings.Regex.email))
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, $@"Malformed email address '{email}'."));
}
var user = Database.PlayerData.User.Find(userId);
if (user == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $@"No user with id '{userId}'."));
}
if (DbInterface.EmailInUse(email))
{
return(Request.CreateErrorResponse(HttpStatusCode.Conflict, @"Email address already in use."));
}
user.Email = email;
DbInterface.SavePlayerDatabaseAsync();
return(user);
}
public static RefreshToken FindForTicket([CanBeNull] Guid ticketId)
{
if (ticketId == Guid.Empty)
{
return(null);
}
lock (DbInterface.GetPlayerContextLock())
{
if (DbInterface.GetPlayerContext()?.RefreshTokens == null)
{
return(null);
}
var playerContext = DbInterface.GetPlayerContext();
var refreshToken = playerContext?.RefreshTokens?.Where(queryToken => queryToken.TicketId == ticketId)
.FirstOrDefault();
if (refreshToken == null || DateTime.UtcNow < refreshToken.Expires)
{
return(refreshToken);
}
else
{
Remove(refreshToken, true);
}
}
return(null);
}
public object UserChangePassword(Guid userId, [FromBody] AuthorizedChange authorizedChange)
{
if (!authorizedChange.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, @"Invalid payload"));
}
var user = Database.PlayerData.User.Find(userId);
if (user == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $@"No user with name '{userId}'."));
}
if (!user.TryChangePassword(
authorizedChange.Authorization.ToUpper().Trim(), authorizedChange.New.ToUpper().Trim()
))
{
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, @"Invalid credentials."));
}
DbInterface.SavePlayerDatabaseAsync();
return("Password updated.");
}
internal override CCR Execute(List <string> args, PersonDb db)
{
if (args.Count < 2)
{
return(CCR.INVALIDPARAM);
}
Error result = DbInterface.ChangePlayer(args[0], db, args[1], args.Count > 2 ? args[2] : "");
StringBuilder outMessage = new StringBuilder();
switch (result)
{
case Error.OK:
outMessage.Append("Player changed successfully!");
break;
case Error.SAVEERROR:
outMessage.Append("Player could not be saved to the Database!");
break;
case Error.NOTFOUND:
outMessage.Append("Could not find a player with the given UID!");
break;
case Error.UNKNOWN:
default:
outMessage.Append("An Unknown Error Occured!");
break;
}
Console.WriteLine(outMessage.ToString());
return(CCR.OK);
}
private void PopulateMessageNames(List <ChatHistory> messages)
{
var userIds = messages.Where(m => m.UserId != Guid.Empty).GroupBy(m => m.UserId).Select(m => m.First().UserId).ToList();
var playerIds = messages.Where(m => m.PlayerId != Guid.Empty).GroupBy(m => m.PlayerId).Select(m => m.First().PlayerId).ToList();
var targetIds = messages.Where(m => m.TargetId != Guid.Empty && m.MessageType == ChatMessageType.PM).GroupBy(m => m.TargetId).Select(m => m.First().TargetId).ToList();
var playerSet = new HashSet <Guid>(playerIds);
playerSet.UnionWith(targetIds);
using (var db = DbInterface.CreatePlayerContext(true))
{
var users = db.Users.Where(u => userIds.Contains(u.Id)).Select(u => new KeyValuePair <Guid, string>(u.Id, u.Name)).ToDictionary(p => p.Key, p => p.Value);
var players = db.Players.Where(p => playerSet.Contains(p.Id)).Select(p => new KeyValuePair <Guid, string>(p.Id, p.Name)).ToDictionary(p => p.Key, p => p.Value);
foreach (var msg in messages)
{
if (users.ContainsKey(msg.UserId))
{
msg.Username = users[msg.UserId];
}
if (players.ContainsKey(msg.PlayerId))
{
msg.PlayerName = players[msg.PlayerId];
}
if (players.ContainsKey(msg.TargetId))
{
msg.TargetName = players[msg.TargetId];
}
}
}
}
public void AddFriend(Player friend)
{
if (friend == null || friend == this)
{
return;
}
if (CachedFriends.ContainsKey(friend.Id))
{
return;
}
//No passing in custom contexts here.. they may already have this user in the change tracker and things just get weird.
//The cost of making a new context is almost nil.
try
{
CachedFriends.Add(friend.Id, friend.Name);
using (var context = DbInterface.CreatePlayerContext(readOnly: false))
{
var friendship = new Database.PlayerData.Players.Friend(this, friend);
context.Entry(friendship).State = EntityState.Added;
context.SaveChanges();
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to add friend " + friend.Name + " to " + Name + "'s friends list.");
//ServerContext.DispatchUnhandledException(new Exception("Failed to save user, shutting down to prevent rollbacks!"), true);
}
}
private void PopulateGuildActivityNames(List <GuildHistory> guildActivity)
{
var userIds = guildActivity.Where(m => m.UserId != Guid.Empty).GroupBy(m => m.UserId).Select(m => m.First().UserId).ToList();
var playerIds = guildActivity.Where(m => m.PlayerId != Guid.Empty).GroupBy(m => m.PlayerId).Select(m => m.First().PlayerId).ToList();
var targetIds = guildActivity.Where(m => m.InitiatorId != Guid.Empty).GroupBy(m => m.InitiatorId).Select(m => m.First().InitiatorId).ToList();
var playerSet = new HashSet <Guid>(playerIds);
playerSet.UnionWith(targetIds);
using (var db = DbInterface.CreatePlayerContext(true))
{
var users = db.Users.Where(u => userIds.Contains(u.Id)).Select(u => new KeyValuePair <Guid, string>(u.Id, u.Name)).ToDictionary(p => p.Key, p => p.Value);
var players = db.Players.Where(p => playerSet.Contains(p.Id)).Select(p => new KeyValuePair <Guid, string>(p.Id, p.Name)).ToDictionary(p => p.Key, p => p.Value);
foreach (var msg in guildActivity)
{
if (users.ContainsKey(msg.UserId))
{
msg.Username = users[msg.UserId];
}
if (players.ContainsKey(msg.PlayerId))
{
msg.PlayerName = players[msg.PlayerId];
}
if (players.ContainsKey(msg.InitiatorId))
{
msg.InitiatorName = players[msg.InitiatorId];
}
}
}
}
public static Player Find(Guid playerId)
{
if (playerId == Guid.Empty)
{
return(null);
}
var player = Player.FindOnline(playerId);
if (player != null)
{
return(player);
}
try
{
using (var context = DbInterface.CreatePlayerContext())
{
return(QueryPlayerById(context, playerId));
}
}
catch (Exception ex)
{
Log.Error(ex);
return(null);
}
}
//BanAction
public static void ProcessAction(Client client, Player player, BanAction action)
{
var target = DbInterface.GetPlayer(action.Name);
if (target != null)
{
if (string.IsNullOrEmpty(Ban.CheckBan(target.User, "")))
{
if (action.BanIp == true)
{
Ban.Add(
target.User, action.DurationDays, action.Reason, player.Name, target.Client?.GetIp() ?? ""
);
}
else
{
Ban.Add(target.User, action.DurationDays, action.Reason, player.Name, "");
}
target.Client?.Disconnect();
PacketSender.SendChatMsg(player, Strings.Account.banned.ToString(target.Name), Color.Red);
}
else
{
PacketSender.SendChatMsg(player, Strings.Account.alreadybanned.ToString(target.Name), Color.Red);
}
}
else
{
PacketSender.SendChatMsg(player, Strings.Player.offline);
}
}
public static Ban Find(Guid userId)
{
lock (DbInterface.GetPlayerContextLock())
{
return(ByUser(DbInterface.GetPlayerContext(), userId)?.FirstOrDefault());
}
}
//MuteAction
public static void ProcessAction(Client client, Player player, MuteAction action)
{
var target = DbInterface.GetPlayer(action.Name);
if (target != null)
{
if (string.IsNullOrEmpty(Mute.FindMuteReason(target.UserId, "")))
{
if (action.BanIp == true)
{
Mute.Add(
target.User, action.DurationDays, action.Reason, player.Name, target.Client?.GetIp() ?? ""
);
}
else
{
Mute.Add(target.User, action.DurationDays, action.Reason, player.Name, "");
}
PacketSender.SendChatMsg(player, Strings.Account.muted.ToString(target.Name), Color.Red);
}
else
{
PacketSender.SendChatMsg(player, Strings.Account.alreadymuted.ToString(target.Name), Color.Red);
}
}
else
{
PacketSender.SendChatMsg(player, Strings.Player.offline);
}
}
/// <summary>
/// The fraud detector class is
/// </summary>
public FraudDetector()
{
// TODO: Add constructor logic here
// get the time to sleep between failed file open operations
m_FraudDetectInterval = 1000*Convert.ToInt32(System.Configuration.ConfigurationManager.AppSettings["FraudCheckIntervalInSecs"]);
// get the event log name
m_eventLogName = System.Configuration.ConfigurationManager.AppSettings["EventLogname"];
// get the event log name
m_emailList = System.Configuration.ConfigurationManager.AppSettings["ToEmailList"];
// get the SMTP Server
m_smtpserver = System.Configuration.ConfigurationManager.AppSettings["SMTPServer"];
// get the CDR delay interval
m_cdrdelay = Convert.ToDouble(System.Configuration.ConfigurationManager.AppSettings["CDRDelayIntervalInMins"]);
// get the CDR delay interval
m_internationalCallLimit = Convert.ToInt16( System.Configuration.ConfigurationManager.AppSettings["InternationalCallLimit"]);
// get the CDR delay interval
m_CallLimit = Convert.ToInt16(System.Configuration.ConfigurationManager.AppSettings["TotalCallLimit"]);
// db interface
db = new DbInterface();
}
public List <Commande> getLesCommandes(String tris, String ordres)
{
DataTable dt;
String mysql = "SELECT NO_COMMAND, NO_VENDEUR, NO_CLIENT, DATE_CDE, FACTURE " +
"FROM COMMANDES " + "ORDER BY " + tris + " " + ordres;
sErreurs er = new sErreurs("Erreur sur lecture des commandes", "Commande.getLesCommandes()");
try
{
dt = DbInterface.Lecture(mysql, er);
List <Commande> mesCdes = new List <Commande>();
foreach (DataRow dataRow in dt.Rows)
{
Vendeur unvd = new Vendeur();
unvd.NoVendeur = dataRow[1].ToString();
Clientel uncli = new Clientel();
uncli.NoCl = dataRow[2].ToString();
Commande unecde = new Commande(dataRow[0].ToString(),
((DateTime)dataRow[3]),
dataRow[4].ToString(),
unvd,
uncli);
mesCdes.Add(unecde);
}
return(mesCdes);
}
catch (MonException erreur)
{
throw erreur;
}
}
