public JsonResult WeightEntry(WeightEntryModel model)
{
if (ModelState.IsValid)
{
using (var context = new DietJournalEntities())
{
WeightEntry weightEntry = null;
if (model.Id > 0)
{
weightEntry = context.WeightEntries.FirstOrDefault(e => e.Id == model.Id);
}
if (weightEntry == null)
{
weightEntry = context.WeightEntries.CreateObject();
context.WeightEntries.AddObject(weightEntry);
}
weightEntry.Amount = model.Amount;
weightEntry.EntryDate = model.ConsumedDate;
weightEntry.SavedDate = DateTime.Now;
weightEntry.UserId = CurrentUserId.Value;
context.SaveChanges();
}
return Json(new { IsValid = true, ReturnUrl = Url.Action("Index", new { date = model.ConsumedDate }) });
}
return Json(new { IsValid = false, ErrorMessage = "" });
}
public ActionResult Index(DateTime date)
{
ViewBag.Date = date;
ViewBag.Back = true;
var model = new WaterCollectionModel { EntriesDate = date };
date = date.Date;
var tomorrow = date.AddDays(1);
if (CurrentUserId.HasValue)
{
using (var entities = new DietJournalEntities())
{
var entries = entities.WaterEntries.Where(e => e.UserId == CurrentUserId.Value
&& e.EntryDate >= date && e.EntryDate < tomorrow);
if (entries != null)
{
foreach (var entry in entries)
{
model.Add(entry.Id, entry.Ounces);
}
}
}
}
return View("Index", model);
}
public void DeleteFavorite(int id)
{
using (var context = new DietJournalEntities())
{
var favorite = context.SupplementFavorites.FirstOrDefault(f => f.UserId == CurrentUserId && f.Id == id);
if (favorite != null)
context.SupplementFavorites.DeleteObject(favorite);
context.SaveChanges();
}
}
public void Delete(int id)
{
using (var context = new DietJournalEntities())
{
var entry = context.ExerciseEntries.FirstOrDefault(e => e.Id == id);
if (entry != null && entry.UserId == CurrentUserId.Value)
context.ExerciseEntries.DeleteObject(entry);
context.SaveChanges();
}
}
public ActionResult Entry(int id)
{
FoodEntryModel model = null;
using (var entities = new DietJournalEntities())
{
var result = entities.FoodEntries.FirstOrDefault(e => e.Id == id);
if (result != null && result.UserId == CurrentUserId.Value)
model = CreateEntryModel(result);
}
return EntryView(model);
}
public ActionResult Index(DateTime? date)
{
ViewBag.CurrentTab = "Entries";
var model = new JournalIndexModel
{
Date = date != null ? date.Value.Date : DateTime.Today
};
var tomorrow = model.Date.AddDays(1);
using (var context = new DietJournalEntities())
{
var weight = context.WeightEntries.FirstOrDefault(e => e.UserId == CurrentUserId
&& e.EntryDate >= model.Date && e.EntryDate < tomorrow);
if (weight != null)
model.Wieght = weight.Amount;
}
return View(model);
}
public JsonResult Add(WaterEntryModel model)
{
if (ModelState.IsValid)
{
using (var context = new DietJournalEntities())
{
var waterEntry = context.WaterEntries.CreateObject();
context.WaterEntries.AddObject(waterEntry);
waterEntry.Ounces = model.Ounces;
waterEntry.EntryDate = model.ConsumedDate;
waterEntry.SavedDate = DateTime.Now;
waterEntry.UserId = CurrentUserId.Value;
context.SaveChanges();
}
return Json(new { IsValid = true, ReturnUrl = Url.Action("Index", new { date = model.ConsumedDate }) });
}
return Json(new { IsValid = false, ErrorMessage = "" });
}
public ActionResult Entry(int id)
{
SupplementEntryModel model = null;
using (var entities = new DietJournalEntities())
{
var result = entities.SupplementEntries.FirstOrDefault(e => e.Id == id);
if (result != null && result.UserId == CurrentUserId.Value)
{
model = new SupplementEntryModel
{
Id = id,
Name = result.Name,
ConsumedDate = result.EntryDate,
Milligrams = result.Milligrams > 0 ? result.Milligrams.ToString() : string.Empty,
};
}
}
return EntryView(model);
}
public ActionResult Entry(int id)
{
ExerciseEntryModel model = null;
using (var entities = new DietJournalEntities())
{
var result = entities.ExerciseEntries.FirstOrDefault(e => e.Id == id);
if (result != null && result.UserId == CurrentUserId.Value)
{
model = new ExerciseEntryModel
{
Id = id,
Description = result.Description,
ConsumedDate = result.EntryDate,
ExerciseType = result.Type.ToString(),
AvailableExerciseTypes = GetAvailableExerciseTypes()
};
}
}
return EntryView(model);
}
public JsonResult Add(SupplementEntryModel model)
{
if (ModelState.IsValid)
{
using (var context = new DietJournalEntities())
{
var entry = context.SupplementEntries.CreateObject();
context.SupplementEntries.AddObject(entry);
entry.Name = model.Name;
if (!String.IsNullOrEmpty(model.Milligrams))
entry.Milligrams = decimal.Parse(model.Milligrams);
entry.EntryDate = model.ConsumedDate;
entry.SavedDate = DateTime.Now;
entry.UserId = CurrentUserId.Value;
context.SaveChanges();
}
return Json(new { IsValid = true, ReturnUrl = Url.Action("Index", new { date = model.ConsumedDate }) });
}
return Json(new { IsValid = false, ErrorMessage = "" });
}
public ActionResult Favorites()
{
ViewBag.Back = true;
ViewBag.CurrentTab = "Favorites";
Dictionary<string, IEnumerable<ExerciseFavoriteResultModel>> model = null;
using (var context = new DietJournalEntities())
{
model = (from f in context.ExerciseFavorites
where f.UserId == CurrentUserId
group f by f.Type into g
select new
{
ExerciseType = context.ExerciseTypes.FirstOrDefault(t => t.Id == g.Key),
Entries = g.Select(e => new ExerciseFavoriteResultModel { Id = e.Id, Title = e.Description })
}).ToDictionary(i => i.ExerciseType.Name, i => i.Entries);
}
return View(model);
}
public ActionResult FavoriteSearch(string Name)
{
List<SupplementFavoriteResultModel> searchResults = null;
using (var context = new DietJournalEntities())
{
searchResults = (from f in context.SupplementFavorites
where f.UserId == CurrentUserId.Value
&& (String.IsNullOrEmpty(Name) || f.Name.Contains(Name))
select new SupplementFavoriteResultModel
{
Id = f.Id,
Title = f.Name,
Milligrams = f.Milligrams.HasValue ? f.Milligrams.Value : 0M,
}).ToList();
}
return PartialView("FavoriteSearchResults", searchResults);
}
public ActionResult SelectFavorite(SupplementFavoriteSelectionModel model)
{
var entryModel = new SupplementEntryModel
{
ConsumedDate = model.ConsumedDate
};
if (ModelState.IsValid && !String.IsNullOrEmpty(model.Selection))
{
int favoriteId = int.Parse(model.Selection);
using (var context = new DietJournalEntities())
{
var favorite = context.SupplementFavorites.FirstOrDefault(f => f.Id == favoriteId);
if (favorite != null)
{
entryModel.Milligrams = favorite.Milligrams.HasValue ? favorite.Milligrams.Value.ToString() : string.Empty;
entryModel.Name = favorite.Name;
entryModel.Favorite = true;
}
}
}
return EntryView(entryModel);
}
public JsonResult Entry(SupplementEntryModel model)
{
if (ModelState.IsValid)
{
using (var entities = new DietJournalEntities())
{
SupplementEntry entry = null;
if (model.Id > 0)
entry = entities.SupplementEntries.FirstOrDefault(e => e.Id == model.Id);
if (entry == null)
{
entry = new SupplementEntry();
entities.SupplementEntries.AddObject(entry);
}
entry.UserId = CurrentUserId.Value;
entry.Name = model.Name;
entry.EntryDate = model.ConsumedDate;
entry.SavedDate = DateTime.Now;
entry.Milligrams = !String.IsNullOrEmpty(model.Milligrams) ? decimal.Parse(model.Milligrams) : 0M;
if (model.Favorite)
{
var favorite = new SupplementFavorite
{
UserId = CurrentUserId.Value,
Milligrams = entry.Milligrams,
Name = entry.Name
};
entities.SupplementFavorites.AddObject(favorite);
}
entities.SaveChanges();
}
return Json(new { IsValid = true });
}
return Json(new { IsValid = false, ErrorMessage = "" });
}
public ActionResult Favorites()
{
ViewBag.Back = true;
ViewBag.CurrentTab = "Favorites";
IEnumerable<SupplementFavoriteResultModel> model = null;
using (var context = new DietJournalEntities())
{
model = (from f in context.SupplementFavorites
where f.UserId == CurrentUserId
select new SupplementFavoriteResultModel
{
Id = f.Id,
Title = f.Name,
Milligrams = f.Milligrams.HasValue ? f.Milligrams.Value : 0M
}).ToList();
}
return View(model);
}
public ActionResult SelectFavorite(FoodFavoriteSelectionModel model)
{
var entryModel = new FoodEntryModel
{
ConsumedDate = model.ConsumedDate
};
if (ModelState.IsValid && !String.IsNullOrEmpty(model.Selection))
{
int favoriteId = int.Parse(model.Selection);
using (var context = new DietJournalEntities())
{
var favorite = context.FoodFavorites.FirstOrDefault(f => f.Id == favoriteId);
if (favorite != null)
{
entryModel.FoodEntryType = favorite.MealType.ToString();
entryModel.Title = favorite.Title;
entryModel.Description = favorite.Description;
entryModel.Calories = favorite.Calories.HasValue ? favorite.Calories.Value : 0;
entryModel.Protein = favorite.Protein.HasValue ? favorite.Protein.Value : 0;
entryModel.Carbs = favorite.Carbs.HasValue ? favorite.Carbs.Value : 0;
entryModel.Fat = favorite.Fat.HasValue ? favorite.Fat.Value : 0;
entryModel.Favorite = true;
}
}
}
SetFoodEntryProfileSettings(entryModel);
return EntryView(entryModel);
}
public JsonResult Entry(ExerciseEntryModel model)
{
if (ModelState.IsValid)
{
using (var entities = new DietJournalEntities())
{
ExerciseEntry entry = null;
if (model.Id > 0)
entry = entities.ExerciseEntries.FirstOrDefault(e => e.Id == model.Id);
if (entry == null)
{
entry = new ExerciseEntry();
entities.ExerciseEntries.AddObject(entry);
}
entry.UserId = CurrentUserId.Value;
entry.Description = model.Description;
entry.EntryDate = model.ConsumedDate;
entry.SavedDate = DateTime.Now;
entry.Type = !String.IsNullOrEmpty(model.ExerciseType) ? int.Parse(model.ExerciseType) : 0;
if (model.Favorite)
{
var favoriteModel = new ExerciseFavorite
{
Type = entry.Type,
Description = entry.Description,
UserId = CurrentUserId.Value
};
entities.ExerciseFavorites.AddObject(favoriteModel);
}
entities.SaveChanges();
if (model.EntryValues != null && model.EntryValues.Count > 0)
{
foreach (var entryValue in model.EntryValues)
{
ExerciseEntryExerciseTypeValue value = null;
if (!String.IsNullOrEmpty(entryValue.Id))
{
var entryValueId = int.Parse(entryValue.Id);
value = entities.ExerciseEntryExerciseTypeValues.FirstOrDefault(v => v.Id == entryValueId);
}
if (value == null)
{
value = new ExerciseEntryExerciseTypeValue
{
ExerciseTypeId = int.Parse(entryValue.EntryTypeValueId),
ExerciseEntryId = entry.Id
};
entities.ExerciseEntryExerciseTypeValues.AddObject(value);
}
value.Value = entryValue.Value;
}
entities.SaveChanges();
}
}
return Json(new { IsValid = true });
}
return Json(new { IsValid = false, ErrorMessage = "" });
}
private IEnumerable<SelectListItem> GetAvailableFoodEntryTypes(ProfileSetting profileSettings)
{
if (profileSettings.DietPlanId.HasValue)
{
using (var context = new DietJournalEntities())
{
var dietPlan = context.DietPlans.FirstOrDefault(d => d.Id == profileSettings.DietPlanId.Value);
var foodEntryTypes = (from t in context.FoodEntryTypes
where t.DietPlanId == profileSettings.DietPlanId.Value
||
(dietPlan.ParentId.HasValue && t.DietPlanId == dietPlan.ParentId.Value)
select t).ToList();
var availableFoodEntryTypes = foodEntryTypes.Select(t => new SelectListItem
{
Value = t.Id.ToString(),
Text = t.Name
}).ToList();
availableFoodEntryTypes.Insert(0, new SelectListItem {Text = "--Select Entry Type--", Value = ""});
return availableFoodEntryTypes;
}
}
return null;
}
private IEnumerable<SelectListItem> GetAvailableExerciseTypes()
{
var availableExerciseTypes = new List<SelectListItem>();
availableExerciseTypes.Add(new SelectListItem
{
Value = "",
Text = "--Select Exercise Type--"
});
using (var entities = new DietJournalEntities())
{
foreach (var exerciseType in entities.ExerciseTypes.Where(t => t.IsActive))
{
availableExerciseTypes.Add(new SelectListItem
{
Value = exerciseType.Id.ToString(),
Text = exerciseType.Name
});
}
}
return availableExerciseTypes;
}
public ActionResult Index(DateTime date)
{
ViewBag.Date = date;
ViewBag.Back = true;
var model = new ExerciseCollectionModel { EntriesDate = date };
date = date.Date;
var tomorrow = date.AddDays(1);
if (CurrentUserId.HasValue)
{
using (var entities = new DietJournalEntities())
{
var entries = entities.ExerciseEntries.Where(e => e.UserId == CurrentUserId.Value
&& e.EntryDate >= date && e.EntryDate < tomorrow);
if (entries != null)
{
var exerciseEntries = from e in entries.Cast<ExerciseEntry>()
group e by e.Type into g
select g;
foreach (var exerciseEntry in exerciseEntries)
{
var exerciseType = entities.ExerciseTypes.FirstOrDefault(t => t.Id == exerciseEntry.Key);
var values = exerciseEntry.ToDictionary(e => e.Id, e => e.Description);
model.Add(exerciseType.Name, values);
}
}
}
}
return View(model);
}
public ActionResult SelectFavorite(ExerciseFavoriteSelectionModel model)
{
var entryModel = new ExerciseEntryModel
{
ConsumedDate = model.ConsumedDate
};
if (ModelState.IsValid && !String.IsNullOrEmpty(model.Selection))
{
int favoriteId = int.Parse(model.Selection);
using (var context = new DietJournalEntities())
{
var favorite = context.ExerciseFavorites.FirstOrDefault(f => f.Id == favoriteId);
if (favorite != null)
{
entryModel.ExerciseType = favorite.Type.ToString();
entryModel.Description = favorite.Description;
entryModel.Favorite = true;
}
}
}
entryModel.AvailableExerciseTypes = GetAvailableExerciseTypes();
return EntryView(entryModel);
}
public ActionResult FavoriteSearch(string FoodEntryType, string Title)
{
List<FoodFavoriteResultModel> searchResults = null;
var mealType = !String.IsNullOrEmpty(FoodEntryType) ? int.Parse(FoodEntryType) : -1;
using(var context = new DietJournalEntities())
{
searchResults = (from f in context.FoodFavorites
where f.UserId == CurrentProfileSettings.UserId
&& (mealType < 0 || f.MealType == mealType)
&& (String.IsNullOrEmpty(Title) || f.Title.Contains(Title))
select new FoodFavoriteResultModel
{
Id = f.Id,
Title = f.Title
}).ToList();
}
return PartialView("FavoriteSearchResults", searchResults);
}
public JsonResult Entry(FoodEntryModel model)
{
if (ModelState.IsValid)
{
using (var entities = new DietJournalEntities())
{
FoodEntry foodEntry = null;
if (model.Id > 0)
foodEntry = entities.FoodEntries.FirstOrDefault(e => e.Id == model.Id);
if (foodEntry == null)
{
foodEntry = new FoodEntry();
entities.FoodEntries.AddObject(foodEntry);
}
foodEntry.UserId = CurrentUserId.Value;
foodEntry.Title = model.Title;
foodEntry.Description = model.Description;
foodEntry.Calories = model.Calories;
foodEntry.Carbs = model.Carbs;
foodEntry.EntryDate = model.ConsumedDate;
foodEntry.Fat = model.Fat;
foodEntry.Protein = model.Protein;
foodEntry.SavedDate = DateTime.Now;
foodEntry.MealType = !String.IsNullOrEmpty(model.FoodEntryType) ? int.Parse(model.FoodEntryType) : 0;
if (model.Favorite)
{
var favorite = new FoodFavorite
{
UserId = CurrentUserId,
MealType = foodEntry.MealType,
Title = foodEntry.Title,
Description = foodEntry.Description,
Calories = foodEntry.Calories,
Carbs = foodEntry.Carbs,
Protein = foodEntry.Protein,
Fat = foodEntry.Fat
};
entities.FoodFavorites.AddObject(favorite);
}
entities.SaveChanges();
if (model.EntryValues != null && model.EntryValues.Count > 0)
{
foreach (var entryValue in model.EntryValues)
{
FoodEntryMealTypeValue value = null;
if (!String.IsNullOrEmpty(entryValue.Id))
{
var entryValueId = int.Parse(entryValue.Id);
value = entities.FoodEntryMealTypeValues.FirstOrDefault(v => v.Id == entryValueId);
}
if (value == null)
{
value = new FoodEntryMealTypeValue
{
MealTypeValueId = int.Parse(entryValue.EntryTypeValueId),
FoodEntryId = foodEntry.Id
};
entities.FoodEntryMealTypeValues.AddObject(value);
}
value.Value = entryValue.Value;
}
entities.SaveChanges();
}
}
return Json(new { IsValid = true });
}
return Json(new { IsValid = false, ErrorMessage = "" });
}
public String EntryType(int exerciseTypeId, int exerciseEntryId)
{
var model = new List<ExerciseTypeValueModel>();
using (var context = new DietJournalEntities())
{
foreach (var exerciseTypeValue in context.ExerciseTypeValues.Where(v => v.ExerciseTypeId == exerciseTypeId))
{
var valueModel = new ExerciseTypeValueModel
{
Id = exerciseTypeValue.Id,
Label = exerciseTypeValue.Label,
InputType = exerciseTypeValue.InputType,
IsRequired = exerciseTypeValue.IsRequired
};
if (exerciseEntryId > 0)
{
var exerciseEntryMealTypeValue = context.ExerciseEntryExerciseTypeValues.FirstOrDefault(v => v.ExerciseEntryId == exerciseEntryId && v.ExerciseTypeId == exerciseTypeValue.Id);
if (exerciseEntryMealTypeValue != null)
{
valueModel.Value = new ExerciseEntryTypeValueModel
{
Id = exerciseEntryMealTypeValue.Id.ToString(),
EntryTypeValueId = exerciseEntryMealTypeValue.ExerciseTypeId.ToString(),
Value = exerciseEntryMealTypeValue.Value
};
}
}
model.Add(valueModel);
}
}
var rtnString = RenderPartialViewToString("EntryType", model);
return rtnString;
}
public ActionResult ProfileSettings(ProfileSettingsModel model)
{
var membership = Membership.GetUser(HttpContext.User.Identity.Name);
using (var context = new DietJournalEntities())
{
var result = context.ProfileSettings.FirstOrDefault(s => s.UserId == (Guid)membership.ProviderUserKey);
if (result == null)
{
result = context.ProfileSettings.CreateObject();
result.UserId = (Guid)membership.ProviderUserKey;
context.ProfileSettings.AddObject(result);
}
result.FirstName = model.FirstName.Trim();
result.LastName = model.LastName.Trim();
if (!String.IsNullOrEmpty(model.Birthday))
result.BirthDay = DateTime.Parse(model.Birthday);
else
result.BirthDay = null;
result.Gender = model.Gender;
result.CaloriesGoal = model.CaloriesGoal;
result.CaptureCalories = model.CaptureCalories;
result.CaptureCarbs = model.CaptureCarbs;
result.CaptureFat = model.CaptureFat;
result.CaptureProtein = model.CaptureProtein;
result.DietPlanId = model.DietPlanId;
result.WeightGoal = model.WeightGoal;
context.SaveChanges();
CurrentProfileSettings = result;
}
return RedirectToAction("Settings", "Journal");
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus;
var membershipUser = Membership.CreateUser(model.Email, model.Password, model.Email, null, null, true, null, out createStatus);
if (createStatus == MembershipCreateStatus.Success)
{
FormsAuthentication.SetAuthCookie(model.Email, false /* createPersistentCookie */);
using (var entities = new DietJournalEntities())
{
var settings = entities.ProfileSettings.CreateObject();
settings.UserId = (Guid)membershipUser.ProviderUserKey;
if (model.DietPlanId != NoDietPlanValue && model.DietPlanId != SelectDietPlanValue)
settings.DietPlanId = model.DietPlanId;
entities.ProfileSettings.AddObject(settings);
entities.SaveChanges();
}
return RedirectToAction("Index", "Home");
}
else
{
ModelState.AddModelError("", ErrorCodeToString(createStatus));
}
}
model.AvailableDietPlans = GetDietPlanSelectItems();
// If we got this far, something failed, redisplay form
return View(model);
}
public ActionResult FavoriteSearch(string ExerciseType, string Description)
{
List<ExerciseFavoriteResultModel> searchResults = null;
var exerciseType = !String.IsNullOrEmpty(ExerciseType) ? int.Parse(ExerciseType) : 0;
using (var context = new DietJournalEntities())
{
searchResults = (from f in context.ExerciseFavorites
where f.UserId == CurrentUserId.Value
&& (exerciseType == 0 || f.Type == exerciseType)
&& (String.IsNullOrEmpty(Description) || f.Description.Contains(Description))
select new ExerciseFavoriteResultModel
{
Id = f.Id,
Title = f.Description
}).ToList();
}
return PartialView("FavoriteSearchResults", searchResults);
}
public String EntryType(int foodEntryTypeId, int foodEntryId)
{
var model = new List<FoodEntryTypeValueModel>();
using (var context = new DietJournalEntities())
{
foreach (var foodEntryTypeValue in context.FoodEntryTypeValues.Where(v => v.FoodEntryTypeId == foodEntryTypeId))
{
var valueModel = new FoodEntryTypeValueModel
{
Id = foodEntryTypeValue.Id,
Label = foodEntryTypeValue.Label,
InputType = foodEntryTypeValue.ValueType,
IsRequired = foodEntryTypeValue.IsRequired
};
if (foodEntryId > 0)
{
var foodEntryMealTypeValue = context.FoodEntryMealTypeValues.FirstOrDefault(v => v.FoodEntryId == foodEntryId && v.MealTypeValueId == foodEntryTypeValue.Id);
if (foodEntryMealTypeValue != null)
{
valueModel.Value = new FoodEntryValueModel
{
Id = foodEntryMealTypeValue.Id.ToString(),
EntryTypeValueId = foodEntryMealTypeValue.MealTypeValueId.ToString(),
Value = foodEntryMealTypeValue.Value
};
}
}
var options = context.FoodEntryTypeValueOptions.Where(o => o.FoodEntryTypeValueId == foodEntryTypeValue.Id);
if (options != null && options.Count() > 0)
{
valueModel.Options = (from o in options.ToList()
select new SelectListItem
{
Value = o.Id.ToString(),
Text = o.Value
});
}
model.Add(valueModel);
}
}
var rtnString = RenderPartialViewToString("EntryType", model);
return rtnString;
}
