public CharacterDTO LoadBySlot(long accountId, byte slot)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
CharacterDTO dto = new CharacterDTO();
if (Mapper.Mappers.CharacterMapper.ToCharacterDTO(context.Character.AsNoTracking().SingleOrDefault(c => c.AccountId.Equals(accountId) && c.Slot.Equals(slot) && c.State.Equals((byte)CharacterState.Active)), dto))
{
return(dto);
}
}
}
catch (Exception e)
{
// for now we shall ban the user that has 2 characters per slot and ask him to
// explain what he did to make it happen. might also be saving issue.
Logger.Error($"There should be only 1 character per slot, AccountId: {accountId} Slot: {slot}", e);
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
PenaltyLogDTO penalty = new PenaltyLogDTO()
{
AccountId = accountId, DateStart = DateTime.UtcNow, DateEnd = DateTime.UtcNow.AddYears(15), Penalty = PenaltyType.Banned, Reason = $"OpenBuster: Multiple characters in slot:{slot} recognized", AdminName = "OpenBuster"
};
PenaltyLog penaltyLog = new PenaltyLog();
if (Mapper.Mappers.PenaltyLogMapper.ToPenaltyLog(penalty, penaltyLog))
{
context.PenaltyLog.Add(penaltyLog);
context.SaveChanges();
}
}
}
return(null);
}
internal static void BanMethod(this ClientSession session, string characterName, int duration, string reason)
{
CharacterDTO character = DAOFactory.CharacterDAO.LoadByName(characterName);
if (character != null)
{
ServerManager.Instance.Kick(characterName);
PenaltyLogDTO log = new PenaltyLogDTO
{
AccountId = character.AccountId,
Reason = reason,
Penalty = PenaltyType.Banned,
DateStart = DateTime.UtcNow,
DateEnd = duration == 0 ? DateTime.UtcNow.AddYears(15) : DateTime.UtcNow.AddDays(duration),
AdminName = session.Character.Name
};
Character.InsertOrUpdatePenalty(log);
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("DONE"), 10));
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("USER_NOT_FOUND"),
10));
}
}
public SaveResult InsertOrUpdate(ref PenaltyLogDTO log)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
int id = log.PenaltyLogId;
PenaltyLog entity = context.PenaltyLog.FirstOrDefault(c => c.PenaltyLogId.Equals(id));
if (entity == null)
{
log = insert(log, context);
return(SaveResult.Inserted);
}
log = update(entity, log, context);
return(SaveResult.Updated);
}
}
catch (Exception e)
{
Logger.Error(string.Format(Language.Instance.GetMessageFromKey("UPDATE_PENALTYLOG_ERROR"), log.PenaltyLogId, e.Message), e);
return(SaveResult.Error);
}
}
internal static void MuteMethod(this ClientSession session, string characterName, string reason, int duration)
{
CharacterDTO characterToMute = DAOFactory.CharacterDAO.LoadByName(characterName);
if (characterToMute != null)
{
ClientSession targetSession = ServerManager.Instance.GetSessionByCharacterName(characterName);
if (targetSession?.Character.IsMuted() == false)
{
targetSession.SendPacket(UserInterfaceHelper.GenerateInfo(
string.Format(Language.Instance.GetMessageFromKey("MUTED_PLURAL"), reason, duration)));
}
PenaltyLogDTO log = new PenaltyLogDTO
{
AccountId = characterToMute.AccountId,
Reason = reason,
Penalty = PenaltyType.Muted,
DateStart = DateTime.UtcNow,
DateEnd = DateTime.UtcNow.AddMinutes(duration),
AdminName = session.Character.Name
};
Character.InsertOrUpdatePenalty(log);
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("DONE"), 10));
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("USER_NOT_FOUND"),
10));
}
}
public PenaltyLogDTO Insert(PenaltyLogDTO penaltylog)
{
using (var context = DataAccessHelper.CreateContext())
{
PenaltyLog entity = _mapper.Map <PenaltyLog>(penaltylog);
context.PenaltyLog.Add(entity);
context.SaveChanges();
return(_mapper.Map <PenaltyLogDTO>(penaltylog));
}
}
public void UseZonesSkill(string packet)
{
PenaltyLogDTO penalty = Session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (Session.Character.IsMuted())
{
if (Session.Character.Gender == GenderType.Female)
{
Session.SendPacket("cancel 0 0");
Session.CurrentMap?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 12));
}
else
{
Session.SendPacket("cancel 0 0");
Session.CurrentMap?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 12));
}
}
else
{
if (Session.Character.LastTransform.AddSeconds(3) > DateTime.Now)
{
Session.SendPacket("cancel 0 0");
Session.SendPacket(Session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("CANT_ATTACK"), 0));
return;
}
if (Session.Character.IsVehicled)
{
Session.SendPacket("cancel 0 0");
return;
}
Logger.Debug(packet, Session.SessionId);
if (Session.Character.CanFight)
{
string[] packetsplit = packet.Split(' ');
if (packetsplit.Length > 4)
{
if (Session.Character.Hp > 0)
{
int CastingId;
short x = -1;
short y = -1;
if (!int.TryParse(packetsplit[2], out CastingId) || !short.TryParse(packetsplit[3], out x) || !short.TryParse(packetsplit[4], out y))
{
return;
}
ZoneHit(CastingId, x, y);
}
}
}
}
}
/// <summary>
/// mtlist
/// </summary>
/// <param name="packet"></param>
public void MultiTargetListHit(MultiTargetListPacket mutliTargetListPacket)
{
PenaltyLogDTO penalty = Session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (Session.Character.IsMuted())
{
Session.SendPacket("cancel 0 0");
Session.CurrentMap?.Broadcast(Session.Character.Gender == GenderType.Female ? Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1) :
Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 12));
return;
}
if ((DateTime.Now - Session.Character.LastTransform).TotalSeconds < 3)
{
Session.SendPacket("cancel 0 0");
Session.SendPacket(Session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("CANT_ATTACKNOW"), 0));
return;
}
if (Session.Character.IsVehicled)
{
Session.SendPacket("cancel 0 0");
return;
}
Logger.Debug(mutliTargetListPacket.ToString(), Session.SessionId);
if (mutliTargetListPacket != null && mutliTargetListPacket.TargetsAmount > 0 && mutliTargetListPacket.TargetsAmount == mutliTargetListPacket.Targets.Count())
{
foreach (MultiTargetListSubPacket subpacket in mutliTargetListPacket.Targets)
{
List <CharacterSkill> skills = Session.Character.UseSp ? Session.Character.SkillsSp.GetAllItems() : Session.Character.Skills.GetAllItems();
if (skills != null)
{
CharacterSkill ski = skills.FirstOrDefault(s => s.Skill.CastId == subpacket.SkillCastId - 1);
if (ski.CanBeUsed())
{
MapMonster mon = Session.CurrentMap.GetMonster(subpacket.TargetId);
if (mon != null && mon.IsInRange(Session.Character.MapX, Session.Character.MapY, ski.Skill.Range) && ski != null && mon.CurrentHp > 0)
{
Session.Character.LastSkillUse = DateTime.Now;
mon.HitQueue.Enqueue(new GameObject.Networking.HitRequest(TargetHitType.SpecialZoneHit, Session, ski.Skill));
}
Observable.Timer(TimeSpan.FromMilliseconds(ski.Skill.CastTime * 100))
.Subscribe(
o =>
{
Session.SendPacket($"sr {subpacket.SkillCastId - 1}");
}
);
}
}
}
}
}
private static PenaltyLogDTO update(PenaltyLog entity, PenaltyLogDTO penaltylog, OpenNosContext context)
{
if (entity != null)
{
Mapper.Mappers.PenaltyLogMapper.ToPenaltyLog(penaltylog, entity);
context.SaveChanges();
}
if (Mapper.Mappers.PenaltyLogMapper.ToPenaltyLogDTO(entity, penaltylog))
{
return(penaltylog);
}
return(null);
}
private static PenaltyLogDTO insert(PenaltyLogDTO penaltylog, OpenNosContext context)
{
PenaltyLog entity = new PenaltyLog();
Mapper.Mappers.PenaltyLogMapper.ToPenaltyLog(penaltylog, entity);
context.PenaltyLog.Add(entity);
context.SaveChanges();
if (Mapper.Mappers.PenaltyLogMapper.ToPenaltyLogDTO(entity, penaltylog))
{
return(penaltylog);
}
return(null);
}
public IEnumerable <PenaltyLogDTO> LoadAll()
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List <PenaltyLogDTO> result = new List <PenaltyLogDTO>();
foreach (PenaltyLog entity in context.PenaltyLog)
{
PenaltyLogDTO dto = new PenaltyLogDTO();
Mapper.Mappers.PenaltyLogMapper.ToPenaltyLogDTO(entity, dto);
result.Add(dto);
}
return(result);
}
}
public IEnumerable <PenaltyLogDTO> LoadByAccount(long accountId)
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List <PenaltyLogDTO> result = new List <PenaltyLogDTO>();
foreach (PenaltyLog PenaltyLog in context.PenaltyLog.Where(s => s.AccountId.Equals(accountId)))
{
PenaltyLogDTO dto = new PenaltyLogDTO();
Mapper.Mappers.PenaltyLogMapper.ToPenaltyLogDTO(PenaltyLog, dto);
result.Add(dto);
}
return(result);
}
}
public static bool ToPenaltyLogDTO(PenaltyLog input, PenaltyLogDTO output)
{
if (input == null)
{
return(false);
}
output.AccountId = input.AccountId;
output.AdminName = input.AdminName;
output.DateEnd = input.DateEnd;
output.DateStart = input.DateStart;
output.Penalty = input.Penalty;
output.PenaltyLogId = input.PenaltyLogId;
output.Reason = input.Reason;
return(true);
}
private void ExecuteHandler(ClientSession session)
{
if (_isParsed)
{
Logger.LogUserEvent("GMCOMMAND", session.GenerateIdentity(),
$"[BlockFExp]CharacterName: {CharacterName} Reason: {Reason} Until: {DateTime.UtcNow.AddMinutes(Duration)}");
if (Duration == 0)
{
Duration = 60;
}
CharacterDTO character = DAOFactory.CharacterDAO.LoadByName(CharacterName);
if (character != null)
{
ClientSession targetSession =
ServerManager.Instance.Sessions.FirstOrDefault(s =>
s.Character?.Name == CharacterName);
targetSession?.SendPacket(Duration == 1
? UserInterfaceHelper.GenerateInfo(
string.Format(Language.Instance.GetMessageFromKey("MUTED_SINGULAR"),
Reason))
: UserInterfaceHelper.GenerateInfo(string.Format(
Language.Instance.GetMessageFromKey("MUTED_PLURAL"), Reason,
Duration)));
PenaltyLogDTO log = new PenaltyLogDTO
{
AccountId = character.AccountId,
Reason = Reason,
Penalty = PenaltyType.BlockFExp,
DateStart = DateTime.UtcNow,
DateEnd = DateTime.UtcNow.AddMinutes(Duration),
AdminName = session.Character.Name
};
Character.InsertOrUpdatePenalty(log);
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("DONE"), 10));
}
else
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("USER_NOT_FOUND"), 10));
}
}
else
{
session.SendPacket(session.Character.GenerateSay(ReturnHelp(), 10));
}
}
public IEnumerable <PenaltyLogDTO> LoadByIp(string ip)
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
string cleanIp = ip.Replace("tcp://", "");
cleanIp = cleanIp.Substring(0, cleanIp.LastIndexOf(":") > 0 ? cleanIp.LastIndexOf(":") : cleanIp.Length);
List <PenaltyLogDTO> result = new List <PenaltyLogDTO>();
foreach (PenaltyLog PenaltyLog in context.PenaltyLog.Where(s => s.IP.Contains(cleanIp)))
{
PenaltyLogDTO dto = new PenaltyLogDTO();
Mapper.Mappers.PenaltyLogMapper.ToPenaltyLogDTO(PenaltyLog, dto);
result.Add(dto);
}
return(result);
}
}
/// <summary>
/// suctl packet
/// </summary>
/// <param name="suctlPacket"></param>
public void Attack(SuctlPacket suctlPacket)
{
PenaltyLogDTO penalty = Session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (Session.Character.IsMuted() && penalty != null)
{
if (Session.Character.Gender == GenderType.Female)
{
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
else
{
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = Session.Character.Mates.FirstOrDefault(x => x.MateTransportId == suctlPacket.MateTransportId);
if (attacker == null)
{
return;
}
if (attacker.IsSitting)
{
return;
}
IEnumerable <NpcMonsterSkill> mateSkills = attacker.IsUsingSp ? attacker.SpSkills.ToList() : attacker.Monster.Skills;
if (mateSkills != null)
{
NpcMonsterSkill ski = mateSkills.FirstOrDefault(s => s?.Skill?.CastId == suctlPacket.CastId);
switch (suctlPacket.TargetType)
{
case UserType.Monster:
if (attacker.Hp > 0)
{
MapMonster target = Session?.CurrentMapInstance?.GetMonster(suctlPacket.TargetId);
AttackMonster(attacker, ski, target);
}
return;
}
}
}
public PenaltyLogDTO Insert(PenaltyLogDTO penaltylog)
{
try
{
using (var context = DataAccessHelper.CreateContext())
{
PenaltyLog entity = _mapper.Map <PenaltyLog>(penaltylog);
context.PenaltyLog.Add(entity);
context.SaveChanges();
return(_mapper.Map <PenaltyLogDTO>(penaltylog));
}
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
public void AddPenalty(long accountId, PenaltyType penaltyType, DateTime dateEnd, string reason)
{
if (!MSManager.Instance.AuthentificatedAdmins.ContainsKey(CurrentClient.ClientId) || MSManager.Instance.AuthentificatedAdmins[CurrentClient.ClientId].Authority != AuthorityType.GameMaster)
{
return;
}
PenaltyLogDTO penalty = new PenaltyLogDTO()
{
AccountId = accountId,
Penalty = penaltyType,
DateStart = DateTime.Now,
DateEnd = dateEnd,
Reason = reason,
AdminName = MSManager.Instance.AuthentificatedAdmins[CurrentClient.ClientId].Name
};
DAOFactory.PenaltyLogDAO.InsertOrUpdate(ref penalty);
}
/// <summary>
/// suctl packet
/// </summary>
/// <param name="suctlPacket"></param>
public void Attack(SuctlPacket suctlPacket)
{
PenaltyLogDTO penalty = Session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (Session.Character.IsMuted() && penalty != null)
{
if (Session.Character.Gender == GenderType.Female)
{
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
else
{
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = Session.Character.Mates.First(x => x.MateTransportId == suctlPacket.MateTransportId);
switch (suctlPacket.TargetType)
{
case UserType.Monster:
/*if (attacker.Hp > 0)
* {
* MapMonster target = Session?.CurrentMapInstance?.GetMonster(suctlPacket.TargetId);
* NpcMonsterSkill skill = attacker.Monster.Skills.FirstOrDefault(x => x.NpcMonsterSkillId == suctlPacket.CastId);
* AttackMonster(attacker, skill, target);
* }*/
return;
case UserType.Npc:
return;
case UserType.Player:
return;
case UserType.Object:
return;
default:
return;
}
}
/// <summary>
/// u_as
/// </summary>
/// <param name="useAOESkillPacket"></param>
public void UseZonesSkill(UseAOESkillPacket useAOESkillPacket)
{
PenaltyLogDTO penalty = Session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (Session.Character.IsMuted())
{
if (Session.Character.Gender == GenderType.Female)
{
Session.SendPacket("cancel 0 0");
Session.CurrentMap?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 12));
}
else
{
Session.SendPacket("cancel 0 0");
Session.CurrentMap?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 12));
}
}
else
{
if (Session.Character.LastTransform.AddSeconds(3) > DateTime.Now)
{
Session.SendPacket("cancel 0 0");
Session.SendPacket(Session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("CANT_ATTACK"), 0));
return;
}
if (Session.Character.IsVehicled)
{
Session.SendPacket("cancel 0 0");
return;
}
Logger.Debug(useAOESkillPacket.ToString(), Session.SessionId);
if (Session.Character.CanFight && useAOESkillPacket != null)
{
if (Session.Character.Hp > 0)
{
ZoneHit(useAOESkillPacket.CastId, useAOESkillPacket.MapX, useAOESkillPacket.MapY);
}
}
}
}
private void ExecuteHandler(ClientSession session)
{
if (_isParsed)
{
Logger.LogUserEvent("GMCOMMAND", session.GenerateIdentity(),
$"[BanAccount]AccountId: {AccountId} Reason: {Reason} Until: {(Duration == 0 ? DateTime.UtcNow.AddYears(15) : DateTime.UtcNow.AddDays(Duration))}");
AccountDTO acc = DAOFactory.AccountDAO.LoadById(AccountId);
if (acc != null)
{
foreach (CharacterDTO dto in DAOFactory.CharacterDAO.LoadByAccount(AccountId))
{
try
{
ServerManager.Instance.Kick(dto.Name);
}
catch (Exception ex)
{
Logger.LogEventError("BanAccount", "Kicking account failed.", ex);
}
}
PenaltyLogDTO log = new PenaltyLogDTO
{
AccountId = AccountId,
Reason = Reason,
Penalty = PenaltyType.Banned,
DateStart = DateTime.UtcNow,
DateEnd = Duration == 0 ? DateTime.UtcNow.AddYears(15) : DateTime.UtcNow.AddDays(Duration),
AdminName = session.Character.Name
};
Character.InsertOrUpdatePenalty(log);
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("DONE"), 10));
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("USER_NOT_FOUND"),
10));
}
}
else
{
session.SendPacket(session.Character.GenerateSay(ReturnHelp(), 10));
}
}
private void ExecuteHandler(ClientSession session)
{
if (_isParsed)
{
Logger.LogUserEvent("GMCOMMAND", session.GenerateIdentity(),
$"[Unmute]CharacterName: {CharacterName}");
CharacterDTO chara = DAOFactory.CharacterDAO.LoadByName(CharacterName);
if (chara != null)
{
if (ServerManager.Instance.PenaltyLogs.Any(s =>
s.AccountId == chara.AccountId && s.Penalty == (byte)PenaltyType.Muted &&
s.DateEnd > DateTime.UtcNow))
{
PenaltyLogDTO log = ServerManager.Instance.PenaltyLogs.Find(s =>
s.AccountId == chara.AccountId && s.Penalty == (byte)PenaltyType.Muted &&
s.DateEnd > DateTime.UtcNow);
if (log != null)
{
log.DateEnd = DateTime.UtcNow.AddSeconds(-1);
Character.InsertOrUpdatePenalty(log);
}
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("DONE"),
10));
}
else
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("USER_NOT_MUTED"), 10));
}
}
else
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("USER_NOT_FOUND"), 10));
}
}
else
{
session.SendPacket(session.Character.GenerateSay(ReturnHelp(), 10));
}
}
public void Update(PenaltyLogDTO penaltylog)
{
try
{
using (var context = DataAccessHelper.CreateContext())
{
PenaltyLog result = context.PenaltyLog.FirstOrDefault(c => c.AccountId == penaltylog.AccountId && c.PenaltyLogId == penaltylog.PenaltyLogId);
if (result != null)
{
penaltylog.PenaltyLogId = result.PenaltyLogId;
_mapper.Map(penaltylog, result);
context.SaveChanges();
}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
public PenaltyLogDTO LoadById(int penaltyLogId)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
PenaltyLogDTO dto = new PenaltyLogDTO();
if (Mapper.Mappers.PenaltyLogMapper.ToPenaltyLogDTO(context.PenaltyLog.FirstOrDefault(s => s.PenaltyLogId.Equals(penaltyLogId)), dto))
{
return(dto);
}
return(null);
}
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
/// <summary>
/// u_s
/// </summary>
/// <param name="useSkillPacket"></param>
public void UseSkill(UseSkillPacket useSkillPacket)
{
if (Session.Character.CanFight && useSkillPacket != null)
{
PenaltyLogDTO penalty = Session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (Session.Character.IsMuted())
{
if (Session.Character.Gender == GenderType.Female)
{
Session.SendPacket("cancel 0 0");
Session.CurrentMap?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 12));
}
else
{
Session.SendPacket("cancel 0 0");
Session.CurrentMap?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
Session.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 12));
}
return;
}
Logger.Debug(useSkillPacket.ToString(), Session.SessionId);
if (useSkillPacket.MapX.HasValue && useSkillPacket.MapY.HasValue)
{
Session.Character.MapX = useSkillPacket.MapX.Value;
Session.Character.MapY = useSkillPacket.MapY.Value;
}
if (Session.Character.IsSitting)
{
Session.Character.Rest();
}
if (Session.Character.IsVehicled || Session.Character.InvisibleGm)
{
Session.SendPacket("cancel 0 0");
return;
}
switch (useSkillPacket.UserType)
{
case UserType.Monster:
if (Session.Character.Hp > 0)
{
TargetHit(useSkillPacket.CastId, useSkillPacket.MapMonsterId);
}
break;
case UserType.Player:
if (Session.Character.Hp > 0 && useSkillPacket.MapMonsterId == Session.Character.CharacterId)
{
TargetHit(useSkillPacket.CastId, useSkillPacket.MapMonsterId);
}
else
{
Session.SendPacket("cancel 2 0");
}
break;
default:
Session.SendPacket("cancel 2 0");
return;
}
}
}
internal static void SendStats(this ClientSession session, CharacterDTO characterDto)
{
session.SendPacket(session.Character.GenerateSay("----- CHARACTER -----", 13));
session.SendPacket(session.Character.GenerateSay($"Name: {characterDto.Name}", 13));
session.SendPacket(session.Character.GenerateSay($"Id: {characterDto.CharacterId}", 13));
session.SendPacket(session.Character.GenerateSay($"State: {characterDto.State}", 13));
session.SendPacket(session.Character.GenerateSay($"Gender: {characterDto.Gender}", 13));
session.SendPacket(session.Character.GenerateSay($"Class: {characterDto.Class}", 13));
session.SendPacket(session.Character.GenerateSay($"Level: {characterDto.Level}", 13));
session.SendPacket(session.Character.GenerateSay($"JobLevel: {characterDto.JobLevel}", 13));
session.SendPacket(session.Character.GenerateSay($"HeroLevel: {characterDto.HeroLevel}", 13));
session.SendPacket(session.Character.GenerateSay($"Gold: {characterDto.Gold}", 13));
session.SendPacket(session.Character.GenerateSay($"Bio: {characterDto.Biography}", 13));
session.SendPacket(session.Character.GenerateSay($"MapId: {characterDto.MapId}", 13));
session.SendPacket(session.Character.GenerateSay($"MapX: {characterDto.MapX}", 13));
session.SendPacket(session.Character.GenerateSay($"MapY: {characterDto.MapY}", 13));
session.SendPacket(session.Character.GenerateSay($"Reputation: {characterDto.Reputation}", 13));
session.SendPacket(session.Character.GenerateSay($"Dignity: {characterDto.Dignity}", 13));
session.SendPacket(session.Character.GenerateSay($"Rage: {characterDto.RagePoint}", 13));
session.SendPacket(session.Character.GenerateSay($"Compliment: {characterDto.Compliment}", 13));
session.SendPacket(session.Character.GenerateSay(
$"Fraction: {(characterDto.Faction == FactionType.Demon ? Language.Instance.GetMessageFromKey("DEMON") : Language.Instance.GetMessageFromKey("ANGEL"))}",
13));
session.SendPacket(session.Character.GenerateSay("----- --------- -----", 13));
AccountDTO account = DAOFactory.AccountDAO.LoadById(characterDto.AccountId);
if (account != null)
{
session.SendPacket(session.Character.GenerateSay("----- ACCOUNT -----", 13));
session.SendPacket(session.Character.GenerateSay($"Id: {account.AccountId}", 13));
session.SendPacket(session.Character.GenerateSay($"Name: {account.Name}", 13));
session.SendPacket(session.Character.GenerateSay($"Authority: {account.Authority}", 13));
session.SendPacket(session.Character.GenerateSay($"RegistrationIP: {account.RegistrationIP}", 13));
session.SendPacket(session.Character.GenerateSay($"Email: {account.Email}", 13));
session.SendPacket(session.Character.GenerateSay("----- ------- -----", 13));
IEnumerable <PenaltyLogDTO> penaltyLogs = ServerManager.Instance.PenaltyLogs
.Where(s => s.AccountId == account.AccountId).ToList();
PenaltyLogDTO penalty = penaltyLogs.LastOrDefault(s => s.DateEnd > DateTime.UtcNow);
session.SendPacket(session.Character.GenerateSay("----- PENALTY -----", 13));
if (penalty != null)
{
session.SendPacket(session.Character.GenerateSay($"Type: {penalty.Penalty}", 13));
session.SendPacket(session.Character.GenerateSay($"AdminName: {penalty.AdminName}", 13));
session.SendPacket(session.Character.GenerateSay($"Reason: {penalty.Reason}", 13));
session.SendPacket(session.Character.GenerateSay($"DateStart: {penalty.DateStart}", 13));
session.SendPacket(session.Character.GenerateSay($"DateEnd: {penalty.DateEnd}", 13));
}
session.SendPacket(
session.Character.GenerateSay($"Bans: {penaltyLogs.Count(s => s.Penalty == PenaltyType.Banned)}",
13));
session.SendPacket(
session.Character.GenerateSay($"Mutes: {penaltyLogs.Count(s => s.Penalty == PenaltyType.Muted)}",
13));
session.SendPacket(
session.Character.GenerateSay(
$"Warnings: {penaltyLogs.Count(s => s.Penalty == PenaltyType.Warning)}", 13));
session.SendPacket(session.Character.GenerateSay("----- ------- -----", 13));
}
session.SendPacket(session.Character.GenerateSay("----- SESSION -----", 13));
foreach (long[] connection in CommunicationServiceClient.Instance.RetrieveOnlineCharacters(characterDto
.CharacterId))
{
if (connection != null)
{
CharacterDTO character = DAOFactory.CharacterDAO.LoadById(connection[0]);
if (character != null)
{
session.SendPacket(session.Character.GenerateSay($"Character Name: {character.Name}", 13));
session.SendPacket(session.Character.GenerateSay($"ChannelId: {connection[1]}", 13));
session.SendPacket(session.Character.GenerateSay("-----", 13));
}
}
}
session.SendPacket(session.Character.GenerateSay("----- ------------ -----", 13));
}
private void ExecuteHandler(ClientSession session)
{
string BuildServersPacket(string username, int sessionId, bool ignoreUserName)
{
string channelPacket = CommunicationServiceClient.Instance.RetrieveRegisteredWorldServers(username, sessionId, ignoreUserName);
if (channelPacket?.Contains(':') != true)
{
// no need for this as in release the debug is ignored eitherway
//if (ServerManager.Instance.IsDebugMode)
Logger.Debug("Could not retrieve Worldserver groups. Please make sure they've already been registered.");
// find a new way to display this message
//Session.SendPacket($"fail {Language.Instance.GetMessageFromKey("NO_WORLDSERVERS")}");
session.SendPacket($"fail {Language.Instance.GetMessageFromKey("IDERROR")}");
}
return(channelPacket);
}
UserDTO user = new UserDTO
{
Name = Name,
Password = ConfigurationManager.AppSettings["UseOldCrypto"] == "true" ? CryptographyBase.Sha512(LoginCryptography.GetPassword(Password)).ToUpper() : Password
};
AccountDTO loadedAccount = DAOFactory.AccountDAO.LoadByName(user.Name);
if (loadedAccount?.Password.ToUpper().Equals(user.Password) == true)
{
string ipAddress = session.IpAddress;
DAOFactory.AccountDAO.WriteGeneralLog(loadedAccount.AccountId, ipAddress, null, GeneralLogType.Connection, "LoginServer");
//check if the account is connected
if (!CommunicationServiceClient.Instance.IsAccountConnected(loadedAccount.AccountId))
{
AuthorityType type = loadedAccount.Authority;
PenaltyLogDTO penalty = DAOFactory.PenaltyLogDAO.LoadByAccount(loadedAccount.AccountId).FirstOrDefault(s => s.DateEnd > DateTime.UtcNow && s.Penalty == PenaltyType.Banned);
if (penalty != null)
{
// find a new way to display date of ban
session.SendPacket($"fail {string.Format(Language.Instance.GetMessageFromKey("BANNED"), penalty.Reason, penalty.DateEnd.ToString("yyyy-MM-dd-HH:mm"))}");;
}
else
{
switch (type)
{
case AuthorityType.Unconfirmed:
{
session.SendPacket($"fail {Language.Instance.GetMessageFromKey("NOTVALIDATE")}");
}
break;
case AuthorityType.Banned:
{
session.SendPacket($"fail {string.Format(Language.Instance.GetMessageFromKey("BANNED"), penalty.Reason, penalty.DateEnd.ToString("yyyy-MM-dd-HH:mm"))}");;
}
break;
case AuthorityType.Closed:
{
session.SendPacket($"fail {Language.Instance.GetMessageFromKey("IDERROR")}");
}
break;
default:
{
if (loadedAccount.Authority == AuthorityType.User || loadedAccount.Authority == AuthorityType.BitchNiggerFaggot)
{
MaintenanceLogDTO maintenanceLog = DAOFactory.MaintenanceLogDAO.LoadFirst();
if (maintenanceLog != null)
{
// find a new way to display date and reason of maintenance
session.SendPacket($"fail {string.Format(Language.Instance.GetMessageFromKey("MAINTENANCE"), maintenanceLog.DateEnd, maintenanceLog.Reason)}");
return;
}
}
int newSessionId = SessionFactory.Instance.GenerateSessionId();
Logger.Debug(string.Format(Language.Instance.GetMessageFromKey("CONNECTION"), user.Name, newSessionId));
try
{
ipAddress = ipAddress.Substring(6, ipAddress.LastIndexOf(':') - 6);
CommunicationServiceClient.Instance.RegisterAccountLogin(loadedAccount.AccountId, newSessionId, ipAddress);
}
catch (Exception ex)
{
Logger.Error("General Error SessionId: " + newSessionId, ex);
}
string[] clientData = ClientData.Split('.');
bool ignoreUserName = clientData.Length < 3 ? false : short.TryParse(clientData[3], out short clientVersion) && (clientVersion < 3075 || ConfigurationManager.AppSettings["UseOldCrypto"] == "true");
session.SendPacket(BuildServersPacket(user.Name, newSessionId, ignoreUserName));
}
break;
}
}
}
else
{
session.SendPacket($"fail {Language.Instance.GetMessageFromKey("ALREADY_CONNECTED")}");
}
}
else
{
session.SendPacket($"fail {Language.Instance.GetMessageFromKey("IDERROR")}");
}
}
public void VerifyLogin(string packet)
{
string[] packetsplit = packet.Split(' ');
UserDTO user = new UserDTO()
{
Name = packetsplit[2], Password = packetsplit[3]
};
// closed
bool flag = true;
if (flag)
{
// TODO: implement check for maintenances
bool maintenanceCheck = true;
if (maintenanceCheck)
{
AccountDTO loadedAccount = DAOFactory.AccountDAO.LoadByName(user.Name);
if (loadedAccount != null && loadedAccount.Password.ToUpper().Equals(user.Password))
{
DAOFactory.AccountDAO.WriteGeneralLog(loadedAccount.AccountId, _session.IpAddress, null, "Connection", "LoginServer");
if (!ServiceFactory.Instance.CommunicationService.AccountIsConnected(loadedAccount.Name))
{
AuthorityType type = loadedAccount.Authority;
PenaltyLogDTO penalty = DAOFactory.PenaltyLogDAO.LoadByAccount(loadedAccount.AccountId).FirstOrDefault(s => s.DateEnd > DateTime.Now && s.Penalty == PenaltyType.Banned);
if (penalty != null)
{
_session.SendPacket($"fail {String.Format(Language.Instance.GetMessageFromKey("BANNED"), penalty.Reason, (penalty.DateEnd).ToString("yyyy-MM-dd-HH:mm"))}");
}
else
{
switch (type)
{
case AuthorityType.Unknown:
{
_session.SendPacket($"fail {Language.Instance.GetMessageFromKey("NOTVALIDATE")}");
}
break;
default:
{
int newSessionId = SessionFactory.Instance.GenerateSessionId();
DAOFactory.AccountDAO.UpdateLastSessionAndIp(user.Name, newSessionId, _session.IpAddress);
Logger.Log.DebugFormat(Language.Instance.GetMessageFromKey("CONNECTION"), user.Name, newSessionId);
// inform communication service about new player from login server
try
{
ServiceFactory.Instance.CommunicationService.RegisterAccountLogin(user.Name, newSessionId);
}
catch (Exception ex)
{
Logger.Log.Error("General Error SessionId: " + newSessionId, ex);
}
_session.SendPacket(BuildServersPacket(newSessionId));
}
break;
}
}
}
else
{
_session.SendPacket($"fail {String.Format(Language.Instance.GetMessageFromKey("ALREADY_CONNECTED"))}");
}
}
else
{
_session.SendPacket($"fail {String.Format(Language.Instance.GetMessageFromKey("IDERROR"))}");
}
}
else
{
_session.SendPacket($"fail {String.Format(Language.Instance.GetMessageFromKey("MAINTENANCE"))}"); // add estimated time of maintenance/end of maintenance
}
}
else
{
_session.SendPacket($"fail {String.Format(Language.Instance.GetMessageFromKey("CLIENT_DISCONNECTED"))}");
}
}
public void LoadCharacters(string packet)
{
string[] loginPacketParts = packet.Split(' ');
// Load account by given SessionId
bool isCrossServerLogin = false;
if (Session.Account == null)
{
bool hasRegisteredAccountLogin = true;
AccountDTO account = null;
if (loginPacketParts.Length > 4)
{
if (loginPacketParts.Length > 7 && loginPacketParts[4] == "DAC" && loginPacketParts[8] == "CrossServerAuthenticate")
{
isCrossServerLogin = true;
account = DaoFactory.AccountDao.LoadByName(loginPacketParts[5]);
}
else
{
account = DaoFactory.AccountDao.LoadByName(loginPacketParts[4]);
}
}
try
{
if (account != null)
{
hasRegisteredAccountLogin = isCrossServerLogin
? CommunicationServiceClient.Instance.IsCrossServerLoginPermitted(account.AccountId, Session.SessionId)
: CommunicationServiceClient.Instance.IsLoginPermitted(account.AccountId, Session.SessionId);
}
}
catch (Exception ex)
{
Logger.Log.Error("MS Communication Failed.", ex);
Session.Disconnect();
return;
}
if (loginPacketParts.Length > 4 && hasRegisteredAccountLogin)
{
if (account != null)
{
if (account.Password.ToLower().Equals(EncryptionBase.Sha512(loginPacketParts[6])) || isCrossServerLogin)
{
PenaltyLogDTO penalty = DaoFactory.PenaltyLogDao.LoadByAccount(account.AccountId).FirstOrDefault(s => s.DateEnd > DateTime.Now && s.Penalty == PenaltyType.Banned);
if (penalty != null)
{
Session.SendPacket($"fail {string.Format(Language.Instance.GetMessageFromKey("BANNED"), penalty.Reason, penalty.DateEnd.ToString("yyyy-MM-dd-HH:mm"))}");
Logger.Log.Info($"[LOG] {account.Name} connected from {Session.IpAddress} while being banned");
Session.Disconnect();
return;
}
// TODO MAINTENANCE MODE
if (ServerManager.Instance.Sessions.Count() >= ServerManager.Instance.AccountLimit)
{
if (account.Authority < AuthorityType.Moderator)
{
Session.Disconnect();
return;
}
}
Account accountobject = new Account
{
AccountId = account.AccountId,
Name = account.Name,
Password = account.Password.ToLower(),
Authority = account.Authority,
BankMoney = account.BankMoney,
Money = account.Money
};
accountobject.Initialize();
Session.InitializeAccount(accountobject, isCrossServerLogin);
}
else
{
Logger.Log.ErrorFormat($"Client {Session.ClientId} forced Disconnection, invalid Password or SessionId.");
Session.Disconnect();
return;
}
}
else
{
Logger.Log.ErrorFormat($"Client {Session.ClientId} forced Disconnection, invalid AccountName.");
Session.Disconnect();
return;
}
}
else
{
Logger.Log.ErrorFormat($"Client {Session.ClientId} forced Disconnection, login has not been registered or Account is already logged in.");
Session.Disconnect();
return;
}
}
// TODO: Wrap Database access up to GO
if (Session.Account == null)
{
return;
}
if (isCrossServerLogin)
{
if (byte.TryParse(loginPacketParts[6], out byte slot))
{
SelectCharacter(new SelectPacket {
Slot = slot
});
}
}
else
{
IEnumerable <CharacterDTO> characters = DaoFactory.CharacterDao.LoadByAccount(Session.Account.AccountId);
Logger.Log.InfoFormat(Language.Instance.GetMessageFromKey("ACCOUNT_ARRIVED"), Session.Account.Name);
// load characterlist packet for each character in CharacterDTO
Session.SendPacket("clist_start 0");
foreach (CharacterDTO character in characters)
{
IEnumerable <ItemInstanceDTO> inventory = DaoFactory.IteminstanceDao.LoadByType(character.CharacterId, InventoryType.Wear);
WearableInstance[] equipment = new WearableInstance[16];
foreach (ItemInstanceDTO equipmentEntry in inventory)
{
// explicit load of iteminstance
WearableInstance currentInstance = equipmentEntry as WearableInstance;
equipment[(short)currentInstance.Item.EquipmentSlot] = currentInstance;
}
string petlist = string.Empty;
List <MateDTO> mates = DaoFactory.MateDao.LoadByCharacterId(character.CharacterId).ToList();
for (int i = 0; i < 26; i++)
{
//0.2105.1102.319.0.632.0.333.0.318.0.317.0.9.-1.-1.-1.-1.-1.-1.-1.-1.-1.-1.-1.-1
petlist += $"{(i != 0 ? "." : "")}{(mates.Count > i ? $"{mates.ElementAt(i).Skin}.{mates.ElementAt(i).NpcMonsterVNum}" : "-1")}";
}
// 1 1 before long string of -1.-1 = act completion
Session.SendPacket($"clist {character.Slot} {character.Name} 0 {(byte) character.Gender} {(byte) character.HairStyle} {(byte) character.HairColor} 0 {(byte) character.Class} {character.Level} {character.HeroLevel} {equipment[(byte) EquipmentType.Hat]?.ItemVNum ?? -1}.{equipment[(byte) EquipmentType.Armor]?.ItemVNum ?? -1}.{equipment[(byte) EquipmentType.WeaponSkin]?.ItemVNum ?? (equipment[(byte) EquipmentType.MainWeapon]?.ItemVNum ?? -1)}.{equipment[(byte) EquipmentType.SecondaryWeapon]?.ItemVNum ?? -1}.{equipment[(byte) EquipmentType.Mask]?.ItemVNum ?? -1}.{equipment[(byte) EquipmentType.Fairy]?.ItemVNum ?? -1}.{equipment[(byte) EquipmentType.CostumeSuit]?.ItemVNum ?? -1}.{equipment[(byte) EquipmentType.CostumeHat]?.ItemVNum ?? -1} {character.JobLevel} 1 1 {petlist} {(equipment[(byte) EquipmentType.Hat] != null && equipment[(byte) EquipmentType.Hat].Item.IsColored ? equipment[(byte) EquipmentType.Hat].Design : 0)} 0");
}
Session.SendPacket("clist_end");
}
}
public void VerifyLogin(string packet)
{
// TODO: implement check for maintenances
string[] packetsplit = packet.Split(' ');
UserDTO user = new UserDTO {
Name = packetsplit[2], Password = ConfigurationManager.AppSettings["UseOldCrypto"] == "true" ? EncryptionBase.Sha512(LoginEncryption.GetPassword(packetsplit[3])).ToUpper() : packetsplit[3]
};
AccountDTO loadedAccount = DAOFactory.AccountDAO.LoadByName(user.Name);
if (loadedAccount != null && loadedAccount.Password.ToUpper().Equals(user.Password))
{
DAOFactory.AccountDAO.WriteGeneralLog(loadedAccount.AccountId, _session.IpAddress, null, "Connection", "LoginServer");
//check if the account is connected
if (!ServerCommunicationClient.Instance.HubProxy.Invoke <bool>("AccountIsConnected", loadedAccount.Name).Result)
{
AuthorityType type = loadedAccount.Authority;
PenaltyLogDTO penalty = DAOFactory.PenaltyLogDAO.LoadByAccount(loadedAccount.AccountId).FirstOrDefault(s => s.DateEnd > DateTime.Now && s.Penalty == PenaltyType.Banned);
if (penalty != null)
{
_session.SendPacket($"fail {string.Format(Language.Instance.GetMessageFromKey("BANNED"), penalty.Reason, penalty.DateEnd.ToString("yyyy-MM-dd-HH:mm"))}");
}
else
{
switch (type)
{
case AuthorityType.Unconfirmed:
{
_session.SendPacket($"fail {Language.Instance.GetMessageFromKey("NOTVALIDATE")}");
}
break;
default:
{
int newSessionId = SessionFactory.Instance.GenerateSessionId();
DAOFactory.AccountDAO.UpdateLastSessionAndIp(user.Name, newSessionId, _session.IpAddress);
Logger.Log.DebugFormat(Language.Instance.GetMessageFromKey("CONNECTION"), user.Name, newSessionId);
// inform communication service about new player from login server
try
{
ServerCommunicationClient.Instance.HubProxy.Invoke("RegisterAccountLogin", user.Name, newSessionId);
}
catch (Exception ex)
{
Logger.Log.Error("General Error SessionId: " + newSessionId, ex);
}
_session.SendPacket(BuildServersPacket(user.Name, newSessionId));
}
break;
}
}
}
else
{
_session.SendPacket($"fail {string.Format(Language.Instance.GetMessageFromKey("ALREADY_CONNECTED"))}");
}
}
else
{
_session.SendPacket($"fail {string.Format(Language.Instance.GetMessageFromKey("IDERROR"))}");
}
}
/// <summary>
/// login packet
/// </summary>
/// <param name="loginPacket"></param>
public void VerifyLogin(LoginPacket loginPacket)
{
if (loginPacket == null)
{
return;
}
UserDTO user = new UserDTO
{
Name = loginPacket.Name,
Password = ConfigurationManager.AppSettings["UseOldCrypto"] == "true" ? EncryptionBase.Sha512(LoginEncryption.GetPassword(loginPacket.Password)).ToUpper() : loginPacket.Password
};
AccountDTO loadedAccount = DaoFactory.AccountDao.LoadByName(user.Name);
if (loadedAccount != null && loadedAccount.Password.ToUpper().Equals(user.Password))
{
DaoFactory.AccountDao.WriteGeneralLog(loadedAccount.AccountId, _session.IpAddress, null, GeneralLogType.Connection, "LoginServer");
//check if the account is connected
if (!CommunicationServiceClient.Instance.IsAccountConnected(loadedAccount.AccountId))
{
AuthorityType type = loadedAccount.Authority;
PenaltyLogDTO penalty = DaoFactory.PenaltyLogDao.LoadByAccount(loadedAccount.AccountId).FirstOrDefault(s => s.DateEnd > DateTime.Now && s.Penalty == PenaltyType.Banned);
if (penalty != null)
{
_session.SendPacket($"failc 7");
}
else
{
switch (type)
{
// TODO TO ENUM
case AuthorityType.Unconfirmed:
{
_session.SendPacket($"failc {(byte)LoginFailType.CantConnect}");
}
break;
case AuthorityType.Banned:
{
_session.SendPacket($"failc {(byte)LoginFailType.Banned}");
}
break;
case AuthorityType.Closed:
{
_session.SendPacket($"failc {(byte)LoginFailType.CantConnect}");
}
break;
default:
{
int newSessionId = SessionFactory.Instance.GenerateSessionId();
Logger.Log.DebugFormat(Language.Instance.GetMessageFromKey("CONNECTION"), user.Name, newSessionId);
if (CommunicationServiceClient.Instance.GetMaintenanceState() && _session.Account.Authority <= AuthorityType.GameMaster)
{
_session.SendPacket("failc 2");
return;
}
try
{
CommunicationServiceClient.Instance.RegisterAccountLogin(loadedAccount.AccountId, newSessionId, loadedAccount.Name);
}
catch (Exception ex)
{
Logger.Log.Error("General Error SessionId: " + newSessionId, ex);
}
_session.SendPacket(BuildServersPacket(loadedAccount.AccountId, newSessionId));
}
break;
}
}
}
else
{
_session.SendPacket($"failc {(byte)LoginFailType.AlreadyConnected}");
}
}
else
{
_session.SendPacket($"failc {(byte)LoginFailType.AccountOrPasswordWrong}");
}
}
