} // ReadAll
public async Task<ExerciseEntry> CreateAsync( ExerciseEntry exerciseentry )
{
_db.ExerciseEntries.Add( exerciseentry );
await _db.SaveChangesAsync();
return exerciseentry;
} // Create
} // Create
public async Task UpdateAsync( Guid id, ExerciseEntry exerciseEntry )
{
var oldExerciseEntry = await ReadAsync( id );
if( oldExerciseEntry != null )
{
if( Config.AuditingOn )
{
var auditChange = new AuditChange();
if( !auditChange.CreateAuditTrail( AuditActionType.UPDATE, exerciseEntry.Id.ToString(), oldExerciseEntry, exerciseEntry ) )
await _auditRepo.CreateAsync( auditChange );
} // if
oldExerciseEntry.UserName = exerciseEntry.UserName;
oldExerciseEntry.Patient = exerciseEntry.Patient;
oldExerciseEntry.Name = exerciseEntry.Name;
oldExerciseEntry.Minutes = exerciseEntry.Minutes;
oldExerciseEntry.CreatedAt = exerciseEntry.CreatedAt;
oldExerciseEntry.UpdatedAt = exerciseEntry.UpdatedAt;
oldExerciseEntry.Timestamp = exerciseEntry.Timestamp;
_db.Entry( oldExerciseEntry ).State = EntityState.Modified;
await _db.SaveChangesAsync();
return;
}
} // UpdateAsync
public ExerciseEntryPage()
{
InitializeComponent();
Exercise = new ExerciseEntry();
BindingContext = this;
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,UserName,Name,Minutes,Steps,CreatedAt,UpdatedAt,Timestamp")] ExerciseEntry exerciseEntry)
{
if (id != exerciseEntry.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(exerciseEntry);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExerciseEntryExists(exerciseEntry.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UserName"] = new SelectList(_context.Patients, "Id", "Id", exerciseEntry.UserName);
return(View(exerciseEntry));
}
public async Task <IActionResult> Create([Bind("Id,UserName,Name,Minutes,Steps,CreatedAt,UpdatedAt,Timestamp")] ExerciseEntry exerciseEntry)
{
if (ModelState.IsValid)
{
exerciseEntry.Id = Guid.NewGuid();
_context.Add(exerciseEntry);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["UserName"] = new SelectList(_context.Patients, "Id", "Id", exerciseEntry.UserName);
return(View(exerciseEntry));
}
public async Task <IActionResult> NewExercise(ExerciseEntry exerciseEntry)
{
if (exerciseEntry != null)
{
_context.ExerciseEntry.Add(exerciseEntry);
await _context.SaveChangesAsync();
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ExerciseEntry = await _context.ExerciseEntry.FirstOrDefaultAsync(m => m.Id == id);
if (ExerciseEntry == null)
{
return(NotFound());
}
return(Page());
}
} // DeleteAsync
public ExerciseEntry Create(ExerciseEntry exerciseEntry)
{
_db.ExerciseEntries.Add(exerciseEntry);
_db.SaveChanges();
if( Config.AuditingOn )
{
var auditChange = new AuditChange();
auditChange.CreateAuditTrail( AuditActionType.CREATE, exerciseEntry.Id.ToString(), new ExerciseEntry(), exerciseEntry );
_auditRepo.CreateAsync( auditChange );
} // if
return exerciseEntry;
}// ExerciseEntry Create
} // CreateExerciseEntry
public async Task<IActionResult> ExerciseEntryUpdate(string userName, Guid loginToken, Guid exerciseId)
{
if (ModelState.IsValid)
{
ApplicationUser user = await _users.ReadAsync(userName);// Read user from the repository
user.RemoteLoginToken = Guid.NewGuid(); // Create a login token, similar to a "session id"
ExerciseEntry exercise = await _exercise.ReadAsync(exerciseId);
var exerciseModel = new ExerciseEntryViewModel
{
UserName = exercise.UserName,
Patient = exercise.Patient,
ExerciseName = exercise.Name,
Minutes = exercise.Minutes,
Date = exercise.CreatedAt,
Timestamp = exercise.Timestamp,
};
await _exercise.UpdateAsync(exercise.Id, exerciseModel.GetNewExcerciseEntry());
return new JsonResult( // This implements IActionResult. If you were
new // to inspect the output, you would see a
{ // Json-formatted string.
success = true,
errorCode = ErrorCode.NO_ERROR,
remoteMealToken = _exercise.ToString(),
exercise.UserName,
exercise.Patient,
exercise.Name,
exercise.Minutes,
exercise.CreatedAt,
exercise.Timestamp
}
);
}//end if(ModelState.IsValid)
return new JsonResult(
new
{
success = false,
errorCode = ErrorCode.UNKNOWN
}
);
}//end ExerciseEntrySync
public ExerciseDetailPage()
{
InitializeComponent();
var item = new ExerciseEntry
{
Id = 0,
Minutes = 40,
Date = DateTime.Now,
Exercise = ExerciseEntry.ExerciseType.Cardio,
Intensity = ExerciseEntry.IntensityType.Low,
Username = App.User.UserName
};
viewModel = new ExerciseDetailViewModel(item);
BindingContext = viewModel;
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ExerciseEntry = await _context.ExerciseEntry.FindAsync(id);
if (ExerciseEntry != null)
{
_context.ExerciseEntry.Remove(ExerciseEntry);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
} // Create
public async Task UpdateAsync( Guid id, ExerciseEntry exerciseEntry )
{
var oldExerciseEntry = await ReadAsync( id );
if( oldExerciseEntry != null )
{
oldExerciseEntry.UserName = exerciseEntry.UserName;
oldExerciseEntry.Patient = exerciseEntry.Patient;
oldExerciseEntry.Name = exerciseEntry.Name;
oldExerciseEntry.Minutes = exerciseEntry.Minutes;
oldExerciseEntry.CreatedAt = exerciseEntry.CreatedAt;
oldExerciseEntry.UpdatedAt = exerciseEntry.UpdatedAt;
oldExerciseEntry.Timestamp = exerciseEntry.Timestamp;
_db.Entry( oldExerciseEntry ).State = EntityState.Modified;
await _db.SaveChangesAsync();
return;
}
} // UpdateAsync
}// ExerciseEntry Read
public async Task CreateOrUpdateEntries( ICollection<ExerciseEntry> exerciseEntries )
{
foreach ( ExerciseEntry exerciseEntry in exerciseEntries )
{
ExerciseEntry dbExerciseEntry = await ReadAsync( exerciseEntry.Id );
if ( dbExerciseEntry == null ) // If meal entry doesn't exist
{
// Create in the database
await CreateAsync( exerciseEntry );
}
else if ( dbExerciseEntry.UpdatedAt < exerciseEntry.UpdatedAt ) // Otherwise...
{
// Update in the database
await UpdateAsync( exerciseEntry.Id, exerciseEntry );
}
} // foreach MealEntry
return;
} // CreateOrUpdateEntries
public async Task<IActionResult> CreateExerciseEntry(string userName, Guid loginToken, ExerciseEntry exerciseEntry)
{
// Get user from username, verify login token
var user = await _users.ReadAsync(userName);
if (user.RemoteLoginToken != loginToken) // Check login token
{
return new JsonResult( // Return error
new
{
success = false,
errorCode = ErrorCode.INVALID_LOGIN_TOKEN
}
);
} // if
if (!_exercise.ReadAll().Any(o => o.Id == exerciseEntry.Id))// Ensure exercise doesn't exist first
{
return new JsonResult( // If it does, return error
new
{
success = false,
errorCode = ErrorCode.ITEM_ALREADY_EXISTS
}
);
}
if (ModelState.IsValid)
{
var newExerciseEntry = await _exercise.CreateAsync(exerciseEntry);
return new JsonResult( // Return success
new
{
success = true,
errorCode = ErrorCode.NO_ERROR,
newExerciseEntry.Id
}
);
} // if
return new JsonResult( // Return unknown error
new
{
success = false,
errorCode = ErrorCode.UNKNOWN
}
);
} // CreateExerciseEntry
} // DeleteAsync
public ExerciseEntry Create(ExerciseEntry exerciseEntry)
{
_db.ExerciseEntries.Add(exerciseEntry);
_db.SaveChanges();
return exerciseEntry;
}// ExerciseEntry Create
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 = "" });
}
public ExerciseDetailViewModel(ExerciseEntry entry = null)
{
Title = entry?.Date.ToShortDateString();
Exercise = entry;
}
