protected virtual bool HasUpdated(ClanWar stored, ClanWar fetched)
{
return(!(stored.EndTime == fetched.EndTime &&
stored.StartTime == fetched.StartTime &&
stored.State == fetched.State &&
stored.Attacks.Count == fetched.Attacks.Count));
}
/// <summary>
/// Inserts or Updates a Clan War depending on the parameters received.
/// </summary>
/// <param name="clanWarViewModel">A ClanWarViewModel object, if its Id is NULL then do an Insert, else Updates.</param>
public static int Upsert(ClanWarUpsertViewModel clanWarViewModel, int userId)
{
Enums.Action action = Enums.Action.Create;
ClanWar clanWar = ClanWarManager.ConvertViewToModel(clanWarViewModel);
using (var dbContext = new HouseOfClansEntities())
{
if (clanWarViewModel.Id == null)
{
clanWar.addedOn = DateTime.Now;
dbContext.ClanWars.Add(clanWar);
if (dbContext.SaveChanges() > 0)
{
ActionLogManager.Log <ClanWarUpsertViewModel>(action, userId, null, null, string.Format("Clan War Id: {0}", clanWar.id));
}
}
else
{
ClanWar original = ClanWarManager.SelectByClanWarId(clanWar.id);
action = Enums.Action.Update;
clanWar.updatedOn = DateTime.Now;
dbContext.Entry(clanWar).State = EntityState.Modified;
if (dbContext.SaveChanges() > 0)
{
List <ActionLog> changes = GetChanges(clanWar, original);
ActionLogManager.Log <ClanWarUpsertViewModel>(action, userId, changes);
}
}
}
return(clanWar.id);
}
/// <summary>
/// Returns a list ActionLog objects of the changed values for the passed object.
/// </summary>
/// <param name="current">A ClanWar object that has been updated.</param>
/// <param name="original">A ClanWar object with the original values.</param>
/// <returns>List of ActionLog</returns>
private static List <ActionLog> GetChanges(ClanWar current, ClanWar original)
{
//vv very inefficient way, but for now should be ok since we are behind schedule!
Type objectType = current.GetType();
List <ActionLog> changes = new List <ActionLog>();
ActionLog changedValue = new ActionLog();
if (current.warTypeId != original.warTypeId)
{
var propName = Nameof <ClanWar> .Property(e => e.warTypeId);
changedValue.propertyChanged = propName;
changedValue.newValue = current.warTypeId.ToString();
changedValue.oldValue = original.warTypeId.ToString();
changes.Add(changedValue);
}
if (current.clanVS != original.clanVS)
{
changedValue = new ActionLog();
var propName = Nameof <ClanWar> .Property(e => e.clanVS);
changedValue.propertyChanged = propName;
changedValue.newValue = current.clanVS.ToString();
changedValue.oldValue = original.clanVS.ToString();
changes.Add(changedValue);
}
if (current.warStartedOn != original.warStartedOn)
{
changedValue = new ActionLog();
var propName = Nameof <ClanWar> .Property(e => e.warStartedOn);
changedValue.propertyChanged = propName;
changedValue.newValue = current.warStartedOn.ToString();
changedValue.oldValue = original.warStartedOn.ToString();
changes.Add(changedValue);
}
if (current.note != original.note)
{
changedValue = new ActionLog();
var propName = Nameof <ClanWar> .Property(e => e.note);
changedValue.propertyChanged = propName;
changedValue.newValue = current.note.ToString();
changedValue.oldValue = original.note.ToString();
changes.Add(changedValue);
}
return(changes);
}
/// <summary>
/// Gets the clan war information based on the clan war id
/// </summary>
/// <param name="clanWarId">Clan War Id</param>
public static ClanWar SelectByClanWarId(int clanWarId)
{
ClanWar clanWarInfo = new ClanWar();
using (var dbContext = new HouseOfClansEntities())
{
clanWarInfo = dbContext.ClanWars.Where(p => p.id == clanWarId).Select(clanWar => clanWar).FirstOrDefault();
}
return(clanWarInfo);
}
/// <summary>
/// Deletes the current Clan War
/// </summary>
public static bool Delete(int warId)
{
bool isDeleted = false;
ClanWar deleteWar = ClanWarManager.SelectByClanWarId(warId);
using (var dbContext = new HouseOfClansEntities())
{
dbContext.ClanWars.Attach(deleteWar);
dbContext.ClanWars.Remove(deleteWar);
isDeleted = dbContext.SaveChanges() > 0;
}
return(isDeleted);
}
internal bool HasUpdated(CachedWar stored, CachedClanWar fetched)
{
if (stored.ServerExpiration > fetched.ServerExpiration)
{
return(false);
}
if (stored.Data == null ||
fetched.Data == null ||
ClanWar.IsSameWar(stored.Data, fetched.Data) == false)
{
throw new ArgumentException();
}
return(HasUpdated(stored.Data, fetched.Data));
}
private static ClanWar ConvertViewToModel(ClanWarUpsertViewModel viewModel)
{
ClanWar model = new ClanWar();
model.id = viewModel.Id ?? 0;
model.warTypeId = viewModel.WarTypeId;
model.clanId = viewModel.ClanId;
model.clanVS = viewModel.ClanVS;
model.clanVSTag = viewModel.ClanVSTag;
model.note = viewModel.Note;
model.warStartedOn = viewModel.WarStartedOn;
model.warNote = viewModel.WarNote;
model.isFinalized = viewModel.IsFinalized;
model.addedOn = viewModel.AddedOn;
model.updatedOn = viewModel.UpdatedOn;
return(model);
}
public static string Dump(this ClanWar clanWar)
{
var sb = new StringBuilder();
sb.Append(Environment.NewLine);
// When clan is not in war all the values are null
if (clanWar.State != State.NotInWar)
{
var pse = PSE(clanWar.PreparationStartTime, clanWar.StartTime, clanWar.EndTime);
sb.Append($"{clanWar.State} {pse}");
sb.Append(Environment.NewLine);
sb.Append($"{clanWar.Clan.Dump()}");
sb.Append(Environment.NewLine);
sb.Append($"{clanWar.Opponent.Dump()}");
}
else
{
sb.Append($"{State.NotInWar}");
}
return(sb.ToString());
}
private static bool ConquordConsole_CloseEvent(CtrlType sig)
{
if (MessageBox.Show("Do You Want To Close Console ...?", "Message", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
{
Save();
foreach (Client.GameClient client in Kernel.GamePool.Values)
{
client.Disconnect();
}
GameServer.Disable();
AuthServer.Disable();
if (GuildWar.IsWar)
{
GuildWar.End();
}
if (EliteGuildWar.IsWar)
{
EliteGuildWar.End();
}
if (ClanWar.IsWar)
{
ClanWar.End();
}
if (CaptureTheFlag.IsWar)
{
CaptureTheFlag.Close();
}
Application.Exit();
Environment.Exit(0);
return(false);
}
else
{
return(true);
}
}
internal void OnClanWarUpdated(ClanWar stored, ClanWar fetched)
{
Task.Run(() => ClanWarUpdated?.Invoke(this, new ClanWarUpdatedEventArgs(stored, fetched)));
}
internal void OnClanWarStartingSoon(ClanWar clanWar)
{
Task.Run(() => ClanWarStartingSoon?.Invoke(this, new ClanWarEventArgs(clanWar)));
}
internal void OnClanWarEnded(ClanWar clanWar)
{
Task.Run(() => ClanWarEnded?.Invoke(this, new ClanWarEventArgs(clanWar)));
}
public ClanWarEventArgs(ClanWar clanWar)
{
ClanWar = clanWar;
}
private Task OnClanWarUpdated(object sender, ClanWarUpdatedEventArgs e)
{
LogService.Log(LogLevel.Information, this.GetType().Name, null, "War updated " + ClanWar.NewAttacks(e.Stored, e.Fetched).Count);
return(Task.CompletedTask);
}
public ClanWarUpdatedEventArgs(ClanWar stored, ClanWar fetched)
{
Fetched = fetched;
Stored = stored;
}
