public void InputWeightData(WeightViewModel model)
{
InputModel dataMappedModel = Mapper.Map <WeightViewModel, InputModel>(model);
dataMappedModel.user = _user;
AddModel(dataMappedModel);
}
protected async Task SaveWeight(WeightViewModel model)
{
if (model != null && model.Members != null)
{
foreach (var member in model.Members)
{
var weight = db.Weights.Where(w => w.Tag == member.Tag).SingleOrDefault();
if (weight == null)
{
weight = new Weight {
Tag = member.Tag, WarWeight = member.Weight, InWar = member.InWar, LastModified = DateTime.UtcNow
};
db.Weights.Add(weight);
}
else
{
if (weight.WarWeight != member.Weight || weight.InWar != member.InWar)
{
weight.WarWeight = member.Weight;
weight.InWar = member.InWar;
weight.LastModified = DateTime.UtcNow;
}
}
}
await db.SaveChangesAsync();
}
}
public async Task <IActionResult> Create([Bind("Date,Weight,Comment")] WeightViewModel weightViewModel)
{
if (ModelState.IsValid)
{
// First save weight to table
WeightModel weight = new WeightModel()
{
UserName = User.Identity.GetUserId(),
Date = weightViewModel.Date,
Weight = weightViewModel.Weight
};
_context.Add(weight);
await _context.SaveChangesAsync();
// Check if comment is added and save to database
if (weightViewModel.Comment != null)
{
int lastWeightId = _context.Weights.Max(item => item.Id);
CommentModel comment = new CommentModel()
{
WeightModelId = lastWeightId,
Comment = weightViewModel.Comment
};
_context.Add(comment);
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
return(View(weightViewModel));
}
public async Task <IActionResult> Post([FromBody] WeightViewModel weightViewModel)
{
try
{
if (ModelState.IsValid)
{
var weightEntry = _mapper.Map <WeightViewModel, WeightEntry>(weightViewModel);
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
weightEntry.User = currentUser;
_arthwindsRepository.AddEntity(weightEntry);
if (_arthwindsRepository.SaveAll())
{
return(Created($"/api/weights/{weightEntry.Id}", weightEntry));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save new weight: {ex}");
}
return(BadRequest("Failed to save new weight"));
}
public ActionResult AddWeight(WeightViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("Weight", viewModel));
}
Metric w = Metric.CreateMetric(User.Identity.GetUserId(), Infrastructure.enums.MetricType.Weight, viewModel.GetRecordedDateTime(), viewModel.Weight, true); _unitOfWork.Metrics.AddOrUpdateMetric(w);
_unitOfWork.Metrics.AddOrUpdateMetric(w);
if (viewModel.Bodyfat != null)
{
Metric bf = Metric.CreateMetric(User.Identity.GetUserId(), Infrastructure.enums.MetricType.BodyFat, viewModel.GetRecordedDateTime(), viewModel.Bodyfat.Value, true);
_unitOfWork.Metrics.AddOrUpdateMetric(bf);
}
_unitOfWork.Complete();
// as weight details have changed we need to refresh weights recorded against activities
ActivityWeight aw = new ActivityWeight(User.Identity.GetUserId());
aw.UpdateActivityWeight();
if (viewModel.MoveOntoNextDay)
{
WeightViewModel vm = new WeightViewModel(viewModel.GetRecordedDateTime().AddDays(1));
vm.MoveOntoNextDay = true;
return(RedirectToAction("Weight", vm));
}
return(RedirectToAction("Index", "Home"));
}
public IActionResult Index(WeightViewModel weightViewModel)
{
if (ModelState.IsValid)
{
ViewBag.UserMessage = "Weight added";
ModelState.Clear();
}
return(View());
}
public ActionResult Weight(WeightViewModel model)
{
if (ModelState.IsValid)
{
service.InputWeightData(model);
return(RedirectToAction("Index", "Input"));
}
return(View(model));
}
public IActionResult AddWeight([FromBody] WeightViewModel model)
{
if (ModelState.IsValid)
{
var weight = Mapper.Map <WeightViewModel, Weight>(model);
weight.CreatedDateUtc = System.DateTime.UtcNow;
weight.LastModifiedDateUtc = System.DateTime.UtcNow;
weight.LastModifiedBy = 1;
_weightService.AddWeight(weight);
}
return(new HttpStatusCodeResult(200));
}
public async Task <IActionResult> Edit(int id, [Bind("WeightId,Date,Weight,Comment")] WeightViewModel weightViewModel)
{
if (id != weightViewModel.WeightId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
// First update Weights tables
var weightModel = await _context.Weights.FirstOrDefaultAsync(m => m.Id == id);
weightModel.Date = weightViewModel.Date;
weightModel.Weight = weightViewModel.Weight;
_context.Update(weightModel);
var commentModel = await _context.Comments.FirstOrDefaultAsync(m => m.WeightModelId == id);
// If prior comment exist, update else create new
if (commentModel != null)
{
commentModel.Comment = weightViewModel.Comment;
_context.Update(commentModel);
}
else
{
CommentModel comment = new CommentModel()
{
WeightModelId = id,
Comment = weightViewModel.Comment
};
_context.Add(comment);
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WeightModelExists(weightViewModel.WeightId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(weightViewModel));
}
public ActionResult GoalsIndicator()
{
WeightViewModel weightVM = new WeightViewModel();
var userName = User.Identity.GetUserName();
var user = _context.Users.Where(x => x.UserName == userName).First();
var beginingWeights = _context.ProfileHistory.Where(x => x.UserId == user.Id).First();
List <string> listItemAdd = new List <string>()
{
beginingWeights.Weight
};
weightVM.Weight = listItemAdd;
weightVM.User = user;
return(View(weightVM));
}
public EventsOfficeHoursModel ParseEvents(List <ChannelEvent> channelEvents, DateTime startDateTime, DateTime endDateTime)
{
var dto = new DateDto();
var model = new EventsOfficeHoursModel
{
Day = startDateTime.DayOfWeek,
StartDateTime = startDateTime,
EndDateTime = endDateTime,
AmountOfMotions = new List <WeightViewModel>(),
Length = 0
};
model.Length = _context.ChannelEvent
.Count(
p => p.DateTime > model.StartDateTime &&
p.DateTime < model.EndDateTime
);
const int interval = 60 * 5; // 5 minutes
var i = dto.GetUnixTime(startDateTime);
while (i <= dto.GetUnixTime(endDateTime))
{
var eventItem = new WeightViewModel
{
StartDateTime = dto.UnixTimeToDateTime(i),
EndDateTime = dto.UnixTimeToDateTime(i + interval)
};
eventItem.LabelUtc = eventItem.StartDateTime.ToString("HH:mm");
eventItem.Label = dto.UtcDateTimeToAmsterdamDateTime(eventItem.StartDateTime).ToString("HH:mm");
var weightSum = channelEvents
.Where(p =>
p.DateTime > eventItem.StartDateTime &&
p.DateTime < eventItem.EndDateTime)
.Select(p => p.Weight).Sum();
eventItem.Weight = weightSum;
model.AmountOfMotions.Add(eventItem);
i += interval;
}
return(model);
}
public ActionResult WeightChart()
{
WeightViewModel weightVM = new WeightViewModel();
var userName = User.Identity.GetUserName();
var user = _context.Users.Where(x => x.UserName == userName).First();
var weights = _context.ProfileHistory.Where(x => x.UserId == user.Id).ToList();
List <string> weight = new List <string>();
List <DateTime?> dates = new List <DateTime?>();
foreach (var item in weights)
{
dates.Add(item.DateOfLog);
weight.Add(item.Weight);
}
weightVM.Weight = weight;
weightVM.DateAdded = dates;
return(View(weightVM));
}
//
// GET: /Front/Program/Weight/5
public ActionResult Weight(int id = 0)
{
Program program = db.Programs.Find(id);
if (program == null)
{
return(HttpNotFound());
}
var weights = program.Weights.OrderByDescending(w => w.date).Take(15);
var vm = new WeightViewModel();
vm.Program = program;
vm.Weights = weights.ToList();
vm.UserId = program.UserId;
vm.ProgramId = program.ProgramId;
vm.date = DateTime.Now;
return(View(vm));
}
public ActionResult Weight(Weight weight, int id = 0)
{
if (ModelState.IsValid)
{
db.Weights.Add(weight);
db.SaveChanges();
return(RedirectToAction("Weight"));
}
Program program = db.Programs.Find(id);
var weights = program.Weights.OrderByDescending(w => w.date).Take(15);
var vm = new WeightViewModel();
vm.Program = program;
vm.Weights = weights.ToList();
vm.UserId = program.UserId;
vm.ProgramId = program.ProgramId;
vm.date = DateTime.Now;
return(View(vm));
}
public async Task <IActionResult> Weight(string id, WeightViewModel model)
{
logger.LogInformation("Weight.Post {0}", id);
var tag = Utils.LinkIdToTag(id);
if (model.Command != null)
{
await SaveWeight(model);
if (model.Command.Equals("submit", StringComparison.OrdinalIgnoreCase))
{
var model2 = WeightData(id, model.WarID);
model2.WeightSubmitQueued = true;
await QueueWeightSubmit(model2);
return(View(model2));
}
}
return(Weight(id, model.WarID));
}
protected async Task QueueWeightSubmit(WeightViewModel weight)
{
var submit = new SubmitRequest
{
ClanTag = weight.ClanTag,
ClanName = weight.ClanName,
Mode = "submit",
Members = new List <SubmitMember>()
};
//Read clan name from Proud FWA List
var clans = await clanLoader.Load(Constants.LIST_FWA);
if (clans != null)
{
var clan = clans.Where(c => c.Tag == weight.ClanTag).SingleOrDefault();
if (clan != null)
{
submit.ClanName = clan.Name;
}
}
var position = 0;
foreach (var m in weight.Members)
{
submit.Members.Add(new SubmitMember
{
Position = ++position,
Tag = m.Tag,
Name = m.Name,
TownHall = m.TownHallLevel,
Weight = m.Weight
});
}
submitService.Queue(submit);
}
public JsonResult GetWeightData(string period)
{
List <WeightViewModel> model = WeightViewModel.GetWeightData(period);
return(Json(new { data = model }, JsonRequestBehavior.AllowGet));
}
protected WeightViewModel WeightData(string id, long WarID)
{
var tag = Utils.LinkIdToTag(id);
var clan = db.Clans.Where(c => c.Tag == tag).SingleOrDefault();
var warEndTime = Utils.WarIdToTime(WarID);
var model = new WeightViewModel {
ClanTag = clan.Tag, ClanLink = clan.LinkID, ClanName = clan.Name, ClanBadge = clan.BadgeUrl, WarID = WarID
};
var result = db.WeightResults.SingleOrDefault(r => r.Tag == tag);
if (result != null)
{
model.WeightSubmitDate = result.Timestamp;
model.PendingWeightSubmit = result.PendingResult;
}
model.Wars = new List <WeightWarModel>();
foreach (var war1 in this.GetDetailedWars(tag).Reverse())
{
model.Wars.Add(new WeightWarModel {
ID = Utils.WarTimeToId(war1.EndTime), OpponentName = war1.OpponentName
});
}
var war = db.Wars.Where(w => w.ClanTag == tag && w.EndTime == warEndTime).SingleOrDefault();
if (war == null) //All clan members
{
if (model.Wars != null && model.Wars.Count > 0)
{
model.OpponentName = model.Wars.First().OpponentName;
}
var members = db.Members.Where(m => m.ClanTag == tag).OrderBy(m => m.ClanRank).ToList();
var weights = (from m in db.Members where m.ClanTag == tag join w in db.Weights on m.Tag equals w.Tag select w).ToDictionary(w => w.Tag);
var thlevels = (from p in db.Players join m in db.Members on p.Tag equals m.Tag where m.ClanTag == tag select new { p.Tag, p.TownHallLevel }).ToDictionary(p => p.Tag, t => t.TownHallLevel);
var memberWeights = new List <MemberWeightModel>();
foreach (var member in members)
{
var memberWeight = new MemberWeightModel {
Tag = member.Tag, Name = member.Name
};
if (weights.TryGetValue(member.Tag, out Weight weight))
{
memberWeight.InWar = weight.InWar;
memberWeight.Weight = weight.WarWeight;
}
if (thlevels.TryGetValue(member.Tag, out int thlevel))
{
memberWeight.TownHallLevel = thlevel;
}
memberWeights.Add(memberWeight);
}
model.Members = memberWeights.OrderByDescending(w => w.Weight + w.TownHallLevel).ToList();
}
else //clan members of war
{
model.OpponentTag = war.OpponentTag;
model.OpponentName = war.OpponentName;
var members = db.WarMembers.Where(m => m.WarID == war.ID && m.IsOpponent == false).OrderBy(m => m.MapPosition).ToList();
var weights = (from m in db.WarMembers join w in db.Weights on m.Tag equals w.Tag where m.WarID == war.ID select w).ToDictionary(w => w.Tag);
var memberWeights = new List <MemberWeightModel>();
foreach (var member in members)
{
var memberWeight = new MemberWeightModel {
Tag = member.Tag, Name = member.Name, TownHallLevel = member.TownHallLevel, InWar = true
};
if (weights.TryGetValue(member.Tag, out Weight weight))
{
memberWeight.Weight = weight.WarWeight;
}
memberWeights.Add(memberWeight);
}
model.Members = memberWeights.ToList();
}
var clanWeight = 0;
var memberCount = 0;
var thCount = 0;
var comparisons = new Dictionary <int, WeightComparison>();
foreach (var member in model.Members.OrderByDescending(m => m.Weight))
{
if (member.Weight > 0 && member.InWar == true)
{
memberCount++;
clanWeight += member.Weight;
thCount += member.TownHallLevel;
comparisons.Add(memberCount, new WeightComparison {
Position = memberCount, Weight = member.Weight, Max = int.MinValue, Min = int.MaxValue
});
}
}
if (memberCount == Constants.WAR_SIZE1 || memberCount == Constants.WAR_SIZE2)
{
var maxWeight = clanWeight + Constants.WEIGHT_COMPARE; //30000
var minWeight = clanWeight - Constants.WEIGHT_COMPARE;
var results = db.WeightResults.Where(w => w.Weight >= minWeight && w.Weight <= maxWeight && w.TeamSize == memberCount && w.Tag != tag).ToList();
model.ComparisonSampleSize = results.Count;
//double sumOfSquares = 0D;
double sumOfAbs = 0D;
if (results.Count > 0)
{
foreach (var res in results)
{
for (var i = 1; i <= memberCount; i++)
{
if (comparisons.TryGetValue(i, out WeightComparison comparison))
{
var weight = res.GetBase(i);
comparison.Average += weight;
if (weight > comparison.Max)
{
comparison.Max = weight;
}
if (weight < comparison.Min)
{
comparison.Min = weight;
}
}
}
}
model.Comparisons = new List <WeightComparison>();
for (var i = 1; i <= memberCount; i++)
{
if (comparisons.TryGetValue(i, out WeightComparison comparison))
{
comparison.Average /= results.Count;
comparison.Average /= 1000;
comparison.Average = Math.Round(comparison.Average, 1);
comparison.Weight /= 1000;
comparison.Min /= 1000;
comparison.Max /= 1000;
model.Comparisons.Add(comparison);
var diff = comparison.Weight - comparison.Average;
//sumOfSquares += diff * diff;
sumOfAbs += Math.Abs(diff);
}
}
}
//model.ComparisonDeviation = (int)(Math.Sqrt(sumOfSquares) / memberCount * 1000);
model.ComparisonDeviation = (int)(sumOfAbs / memberCount * 1000);
}
return(model);
}
public WeightPage(WeightViewModel viewModel)
{
InitializeComponent();
BindingContext = viewModel;
}
