public IHttpActionResult PostExcercise(Excercise excercise)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Excercises.Add(excercise);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (ExcerciseExists(excercise.Excercise_ID))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = excercise.Excercise_ID }, excercise));
}
public async Task <IActionResult> AddExcercise([FromBody] Excercise excercise, [FromQuery] List <int> imageVideoIds)
{
//Add Excercise details in database
await _excerciseRepository.AddAsync(excercise);
//Add Initial Progression details in database
await _initialProgressionRepository.AddAsync(excercise.InitialProgression);
//Add all progression details in database
foreach (Progression prog in excercise.InitialProgression.Progression)
{
await _progressionRepository.AddAsync(prog);
}
await _unitOfWork.SaveChangesAsync();
foreach (int imgId in imageVideoIds)
{
ImageVideo imgVid = new ImageVideo();
imgVid.ImageVideoId = imgId;
imgVid.ExcerciseId = excercise.ExcerciseId;
await _imageVideoRepository.UpdateAsync(imgVid);
}
await _unitOfWork.SaveChangesAsync();
return(Ok(excercise.ExcerciseId));
}
public async Task <IActionResult> Get()
{
using (SqlConnection conn = Connection)
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = "SELECT Id, ExcerciseName, ExcerciseLanguage FROM Excercise";
SqlDataReader reader = cmd.ExecuteReader();
List <Excercise> excercises = new List <Excercise>();
while (reader.Read())
{
Excercise excercise = new Excercise
{
Id = reader.GetInt32(reader.GetOrdinal("Id")),
ExcerciseName = reader.GetString(reader.GetOrdinal("ExcerciseName")),
ExcerciseLanguage = reader.GetString(reader.GetOrdinal("ExcerciseLanguage"))
};
excercises.Add(excercise);
}
reader.Close();
return(Ok(excercises));
}
}
}
private void saveExcercises()
{
var ExcercisesJson = "";
var RegionJson = "";
Task task = new Task(() => {
ExcercisesJson = GetExcerciseJson().Result;
RegionJson = GetRegionJson().Result;
});
task.Start();
task.Wait();
var convertedJsonExcercise = JsonConvert.DeserializeObject <List <Excercise> >(ExcercisesJson);
var convertedJsonRegion = JsonConvert.DeserializeObject <List <ExcerciseRegion> >(RegionJson);
foreach (var Region in convertedJsonRegion)
{
ExcerciseRegion excerciseRegionData = new ExcerciseRegion();
excerciseRegionData.ID_region = Region.ID_region;
excerciseRegionData.Region = Region.Region;
App.DatabaseRegions.SaveItemAsync(excerciseRegionData);
}
foreach (var excercise in convertedJsonExcercise)
{
Excercise excerciseData = new Excercise();
//excerciseData.ID_excercise = excercise.ID_excercise;
excerciseData.Name = excercise.Name;
excerciseData.Region = excercise.Region;
excerciseData.Tip = excercise.Tip;
excerciseData.Description = excercise.Description;
excerciseData.Specification = excercise.Specification;
App.DatabaseExcercise.SaveItemAsync(excerciseData);
}
}
public async Task <IActionResult> Get([FromRoute] int Id)
{
using (SqlConnection conn = Connection)
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = @"SELECT Id, ExcerciseName, ExcerciseLanguage
FROM Excercise
WHERE Id = @Id";
cmd.Parameters.Add(new SqlParameter("@Id", Id));
SqlDataReader reader = cmd.ExecuteReader();
Excercise excercise = null;
if (reader.Read())
{
excercise = new Excercise
{
Id = reader.GetInt32(reader.GetOrdinal("Id")),
ExcerciseName = reader.GetString(reader.GetOrdinal("ExcerciseName")),
ExcerciseLanguage = reader.GetString(reader.GetOrdinal("ExcerciseLanguage"))
};
}
reader.Close();
return(Ok(excercise));
}
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (((extypesTab.SelectedIndex == 1) && (excercisesLb.SelectedIndex != -1)) ||
((extypesTab.SelectedIndex == 2) && (supersetsLb.SelectedIndex != -1)) ||
((extypesTab.SelectedIndex == 0) && (favoritesLb.SelectedIndex != -1))
)
{
if (extypesTab.SelectedIndex == 0)
{
string name = favoritesLb.Items[favoritesLb.SelectedIndex].ToString();
Selected = MainWindow.ExcercisesLib.Lib.Single(c => c.Name == name);
if (Selected == null)
{
Selected = MainWindow.SuperSetsLib.Lib.Single(c => c.Name == name);
}
}
else if (extypesTab.SelectedIndex == 1)
{
Selected = (Excercise)excercisesLb.Items[excercisesLb.SelectedIndex];
}
else
{
Selected = (Excercise)supersetsLb.Items[supersetsLb.SelectedIndex];
}
DialogResult = true;
Close();
}
}
public ActionResult Edit(FormCollection fc)
{
if (Int32.TryParse(fc["Excercise.Id"], out int id))
{
Excercise excercise = db.Excercises.Find(id);
if (excercise == null)
{
return(HttpNotFound());
}
if (float.TryParse(fc["Excercise.Length"], out float length) && int.TryParse(fc["Excercise.ExType.Id"], out int excerciseTypeId) && DateTime.TryParse(fc["Excercise.Date"], out DateTime date))
{
ExcerciseType excerciseType = db.ExcerciseTypes.Find(excerciseTypeId);
if (excerciseType == null)
{
return(HttpNotFound());
}
excercise.ExType = excerciseType;
excercise.Length = length;
excercise.Date = date;
db.SaveChanges();
db.Entry(excercise).Reference(m => m.ExType).Load();
return(RedirectToAction("Edit", excercise));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public async Task <ExerciseResponse> UpdateAsync(int id, Excercise excercise)
{
var existingExercise = await _exerciseRepository.FindByIdAsync(id);
if (existingExercise == null)
{
return(new ExerciseResponse("Exercise not found ufunge"));
}
existingExercise.Name = excercise.Name;
existingExercise.Duration = excercise.Duration;
existingExercise.Calories = excercise.Calories;
try
{
_exerciseRepository.Update(existingExercise);
await _unitOfWork.CompleteAsync();
return(new ExerciseResponse(existingExercise));
}
catch (Exception e)
{
return(new ExerciseResponse($"An error occured while trying to update Exercise: {e.Message}"));
}
}
public IHttpActionResult PutExcercise(int id, Excercise excercise)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != excercise.Excercise_ID)
{
return(BadRequest());
}
db.Entry(excercise).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ExcerciseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult DeleteConfirmed(int id)
{
Excercise excercise = db.Excercises.Find(id);
db.Excercises.Remove(excercise);
db.SaveChanges();
return(RedirectToAction("Index"));
}
// GET: Excercises/Create
public ActionResult Create(DateTime?date = null)
{
Excercise tmp = new Excercise {
Date = date.GetValueOrDefault(DateTime.Now)
};
return(View(tmp));
}
private void RemoveAction(object obj)
{
Excercise excercise = obj as Excercise;
if (excercise != null)
{
Excercises.Remove(excercise);
}
}
static void Main(string[] args)
{
Excercise e = new Excercise();
e.plane();
e.run();
e.tennisShoes();
Console.ReadLine();
}
public override void ReverseInit(object returnedData)
{
Excercise ex = returnedData as Excercise;
TodaysTraining.TodayExcercises.Add(ex);
FinishedExcercises.Add(ex);
ExText = "XD";
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Excercise excercise = await db.Excercises.FindAsync(id);
db.Excercises.Remove(excercise);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public int Create(Excercise excercise)
{
var entity = new Exercise {
Name = excercise.Name
};
db.Exercises.Add(entity);
db.SaveChanges();
return(entity.Id);
}
private void AddExcerciseToPlan(Excercise e)
{
try
{
Excercises.Add(e);
}
catch (Exception ex)
{
Application.Current.MainPage.DisplayAlert("Alert", ex.Message, "ok");
}
}
public async Task <IHttpActionResult> GetExcercise(int id)
{
Excercise excercise = await db.Excercises.FindAsync(id);
if (excercise == null)
{
return(NotFound());
}
return(Ok(excercise));
}
public IHttpActionResult GetExcercise(int id)
{
Excercise excercise = db.Excercises.Find(id);
if (excercise == null)
{
return(NotFound());
}
return(Ok(excercise));
}
public async Task <ActionResult> Edit([Bind(Include = "ExcerciseId,Name,Picture,RutineId,Sets,Repetitions,Description,Duration,Rest")] Excercise excercise)
{
if (ModelState.IsValid)
{
db.Entry(excercise).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.RutineId = new SelectList(db.Rutines, "RutineId", "Name", excercise.RutineId);
return(View(excercise));
}
public async Task <IHttpActionResult> PostExcercise(Excercise excercise)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Excercises.Add(excercise);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = excercise.ExcerciseId }, excercise));
}
public MyNote()
{
InitializeComponent();
Semester s = new Semester("Q2", new DateTime(2020, 04, 27));
Course k = new Course("Deutsch Bauschke", new DateTime(2020, 04, 27), Color.Red, new MyNoteBase.Utils.Graphic.Icon("heft", new Bitmap(32, 32), 1), s);
Excercise c = new Excercise(new DateTime(2020, 04, 27), "Vormärz", k, new TestIManager(), "AB Vormärz");
c.Content.Add(new TextContent());
new IOManager(new SaveLoader()).SaveCanvas(c);
c = (Excercise) new IOManager(new SaveLoader()).LoadCanvas("G:\\mynote\\MyNote\\bin\\Debug\\userSaves\\Q2\\Deutsch Bauschke\\Vormärz.myn", new TestIManager());
}
public override void ReverseInit(object returnedData)
{
Excercise e = returnedData as Excercise;
ExcerciseChanged ech = returnedData as ExcerciseChanged;
if (e != null)
{
AddExcerciseToPlan(e);
}
if (ech != null)
{
UpdateExcercise(ech);
}
}
// GET: Excercises/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Excercise excercise = await db.Excercises.FindAsync(id);
if (excercise == null)
{
return(HttpNotFound());
}
return(View(excercise));
}
// GET: Excercises/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Excercise excercise = db.Excercises.Find(id);
if (excercise == null)
{
return(HttpNotFound());
}
return(View(CreateExcerciseViewModel(excercise)));
}
public IHttpActionResult DeleteExcercise(int id)
{
Excercise excercise = db.Excercises.Find(id);
if (excercise == null)
{
return(NotFound());
}
db.Excercises.Remove(excercise);
db.SaveChanges();
return(Ok(excercise));
}
public async Task <IHttpActionResult> DeleteExcercise(int id)
{
Excercise excercise = await db.Excercises.FindAsync(id);
if (excercise == null)
{
return(NotFound());
}
db.Excercises.Remove(excercise);
await db.SaveChangesAsync();
return(Ok(excercise));
}
public ActionResult Create([Bind(Include = "Id,Date")] Excercise excercise)
{
if (ModelState.IsValid)
{
excercise.ApplicationUser = db.GetCurrentApplicationUser(User.Identity);
excercise.ExType = db.ExcerciseTypes.First();
db.Excercises.Add(excercise);
db.SaveChanges();
return(RedirectToAction("Edit", excercise));
}
return(RedirectToAction("Index"));
}
public async Task <ExerciseResponse> SaveAsync(Excercise excercise)
{
try
{
await _exerciseRepository.AddAsync(excercise);
await _unitOfWork.CompleteAsync();
return(new ExerciseResponse(excercise));
}
catch (Exception e)
{
return(new ExerciseResponse($"An error occured when saving the exercise: {e.Message}"));
}
}
// GET: Excercises/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Excercise excercise = await db.Excercises.FindAsync(id);
if (excercise == null)
{
return(HttpNotFound());
}
ViewBag.RutineId = new SelectList(db.Rutines, "RutineId", "Name", excercise.RutineId);
return(View(excercise));
}
