public SaveResult InsertOrUpdate(ref RespawnDTO respawn)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
long characterId = respawn.CharacterId;
long respawnMapTypeId = respawn.RespawnMapTypeId;
Respawn entity = context.Respawn.FirstOrDefault(c => c.RespawnMapTypeId.Equals(respawnMapTypeId) && c.CharacterId.Equals(characterId));
if (entity == null)
{
respawn = Insert(respawn, context);
return(SaveResult.Inserted);
}
respawn.RespawnId = entity.RespawnId;
respawn = Update(entity, respawn, context);
return(SaveResult.Updated);
}
}
catch (Exception e)
{
Logger.Error(e);
return(SaveResult.Error);
}
}
public SaveResult InsertOrUpdate(ref RespawnDTO respawn)
{
try
{
using (var context = DataAccessHelper.CreateContext())
{
long CharacterId = respawn.CharacterId;
short RespawnType = respawn.RespawnType;
Respawn entity = context.Respawn.FirstOrDefault(c => c.RespawnType.Equals(RespawnType) && c.CharacterId.Equals(CharacterId));
if (entity == null)
{
respawn = Insert(respawn, context);
return(SaveResult.Inserted);
}
else
{
respawn.RespawnId = entity.RespawnId;
respawn = Update(entity, respawn, context);
return(SaveResult.Updated);
}
}
}
catch (Exception e)
{
Logger.Error(e);
return(SaveResult.Error);
}
}
private RespawnDTO Update(Respawn entity, RespawnDTO respawn, OpenNosContext context)
{
if (entity != null)
{
_mapper.Map(respawn, entity);
context.SaveChanges();
}
return(_mapper.Map <RespawnDTO>(entity));
}
private void ExecuteHandler(ClientSession session)
{
if (_isParsed)
{
if (session.Character.StaticBonusList.All(s => s.StaticBonusType != StaticBonusType.MultipleReturns))
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RETURNPOINT_NOT_PERMITTED"),
10));
return;
}
if (session.Character.MapInstance.MapInstanceType != MapInstanceType.BaseMapInstance)
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("CANT_USE_THAT"), 10));
return;
}
if (ReturnPointId < 1 || ReturnPointId > 5)
{
return;
}
if (session.HasCurrentMapInstance &&
session.CurrentMapInstance.Map.MapTypes.Any(s => s.MapTypeId == (short)MapTypeEnum.Act4))
{
RespawnDTO resp =
session.Character.Respawns.Find(s => s.RespawnMapTypeId == ReturnPointId + 50);
if (resp == null)
{
resp = new RespawnDTO
{
CharacterId = session.Character.CharacterId,
MapId = session.Character.MapId,
X = session.Character.MapX,
Y = session.Character.MapY,
RespawnMapTypeId = ReturnPointId + 50
};
session.Character.Respawns.Add(resp);
}
else
{
resp.X = session.Character.PositionX;
resp.Y = session.Character.PositionY;
resp.MapId = session.Character.MapInstance.Map.MapId;
}
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RETURNPOINT_SET"), 10));
}
}
else
{
session.SendPacket(session.Character.GenerateSay(ReturnHelp(), 10));
}
}
private RespawnDTO Insert(RespawnDTO respawn, OpenNosContainer context)
{
Respawn entity = new Respawn()
{
CharacterId = respawn.CharacterId
};
context.respawn.Add(entity);
context.SaveChanges();
return(Mapper.Map <RespawnDTO>(entity));
}
public IEnumerable <RespawnDTO> LoadByCharacter(long characterId)
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List <RespawnDTO> result = new List <RespawnDTO>();
foreach (Respawn respawnobject in context.Respawn.AsNoTracking().Where(i => i.CharacterId.Equals(characterId)))
{
RespawnDTO dto = new RespawnDTO();
Mapper.Mappers.RespawnMapper.ToRespawnDTO(respawnobject, dto);
result.Add(dto);
}
return(result);
}
}
private static RespawnDTO Update(Respawn entity, RespawnDTO respawn, OpenNosContext context)
{
if (entity != null)
{
Mapper.Mappers.RespawnMapper.ToRespawn(respawn, entity);
context.SaveChanges();
}
if (Mapper.Mappers.RespawnMapper.ToRespawnDTO(entity, respawn))
{
return(respawn);
}
return(null);
}
public static bool ToRespawnDTO(Respawn input, RespawnDTO output)
{
if (input == null)
{
return(false);
}
output.CharacterId = input.CharacterId;
output.MapId = input.MapId;
output.RespawnId = input.RespawnId;
output.RespawnMapTypeId = input.RespawnMapTypeId;
output.X = input.X;
output.Y = input.Y;
return(true);
}
private RespawnDTO Update(Respawn entity, RespawnDTO respawn, OpenNosContainer context)
{
using (context)
{
var result = context.respawn.SingleOrDefault(c => c.RespawnId == respawn.RespawnId);
if (result != null)
{
result = Mapper.Map <RespawnDTO, Respawn>(respawn, entity);
context.SaveChanges();
}
}
return(Mapper.Map <RespawnDTO>(entity));
}
private void ExecuteHandler(ClientSession session)
{
if (_isParsed)
{
if (session.Character.StaticBonusList.All(s => s.StaticBonusType != StaticBonusType.MultipleReturns))
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RETURNPOINT_NOT_PERMITTED"),
10));
return;
}
if (session.Character.MapInstance.MapInstanceType != MapInstanceType.BaseMapInstance)
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("CANT_USE_THAT"), 10));
return;
}
if (ReturnPointId < 1 || ReturnPointId > 5)
{
return;
}
RespawnDTO resp = session.Character.Respawns.Find(s => s.RespawnMapTypeId == ReturnPointId + 50);
if (resp == null)
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RETURNPOINT_NOT_SET"), 10));
return;
}
if (ServerManager.Instance.ChannelId == 51 || ServerManager
.GetMapInstance(ServerManager.GetBaseMapInstanceIdByMapId(resp.MapId)).Map.MapTypes
.Any(s => s.MapTypeId == (short)MapTypeEnum.Act4))
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("CANT_USE_THAT"), 10));
return;
}
ServerManager.Instance.LeaveMap(session.Character.CharacterId);
ServerManager.Instance.ChangeMap(session.Character.CharacterId, resp.MapId, resp.X, resp.Y);
}
else
{
session.SendPacket(session.Character.GenerateSay(ReturnHelp(), 10));
}
}
private RespawnDTO Insert(RespawnDTO respawn, OpenNosContext context)
{
try
{
Respawn entity = new Respawn()
{
CharacterId = respawn.CharacterId
};
context.Respawn.Add(entity);
context.SaveChanges();
return(_mapper.Map <RespawnDTO>(entity));
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
private static RespawnDTO Insert(RespawnDTO respawn, OpenNosContext context)
{
try
{
Respawn entity = new Respawn();
Mapper.Mappers.RespawnMapper.ToRespawn(respawn, entity);
context.Respawn.Add(entity);
context.SaveChanges();
if (Mapper.Mappers.RespawnMapper.ToRespawnDTO(entity, respawn))
{
return(respawn);
}
return(null);
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
public RespawnDTO LoadById(long respawnId)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
RespawnDTO dto = new RespawnDTO();
if (Mapper.Mappers.RespawnMapper.ToRespawnDTO(context.Respawn.AsNoTracking().FirstOrDefault(s => s.RespawnId.Equals(respawnId)), dto))
{
return(dto);
}
return(null);
}
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
public SaveResult InsertOrUpdate(ref RespawnDTO respawn)
{
using (var context = DataAccessHelper.CreateContext())
{
long characterId = respawn.CharacterId;
short respawnType = respawn.RespawnType;
Respawn entity = context.respawn.SingleOrDefault(c => c.RespawnType.Equals(respawnType) && c.CharacterId.Equals(characterId));
if (entity == null) //new entity
{
respawn = Insert(respawn, context);
return(SaveResult.Inserted);
}
else //existing entity
{
respawn.RespawnId = entity.RespawnId;
respawn = Update(entity, respawn, context);
return(SaveResult.Updated);
}
}
}
public SaveResult InsertOrUpdate(ref RespawnDTO respawn)
{
throw new NotImplementedException();
}
