public async Task <IActionResult> PutTrainingDay([FromRoute] int id, [FromBody] TrainingDay trainingDay)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != trainingDay.Id)
{
return(BadRequest());
}
_context.Entry(trainingDay).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TrainingDayExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void importSizes(TrainingDay day, int oldTrainingDayId, SqlCeConnection oldConnection)
{
Log.WriteInfo("Importing sizes for trainingdate={0},oldTrainingDayId={1}", day.TrainingDate, oldTrainingDayId);
SqlCeCommand cmd = new SqlCeCommand();
cmd.Connection = oldConnection;
cmd.CommandText = "SELECT SpecificEntryObject_id,Wymiary_id FROM SizeEntry,EntryObject e WHERE e.Id=SpecificEntryObject_id AND e.TrainingDay_ID=" + oldTrainingDayId;
var reader = cmd.ExecuteReader();
Log.WriteInfo("sizes reader executed");
while (reader.Read())
{
SizeEntry entry = new SizeEntry();
entry.Wymiary = importWymiar(oldConnection, getInt32(reader, "Wymiary_id").Value);
if (!entry.IsEmpty)
{
day.AddEntry(entry);
}
}
reader.Close();
}
public void Delete_ReminderAttachedTOEntryObject()
{
var reminder = CreateReminder("test", profiles[0], DateTime.UtcNow, type: ReminderType.EntryObject);
TrainingDay day = new TrainingDay(DateTime.Now.Date);
day.Profile = profiles[0];
SizeEntry sizeEntry = new SizeEntry();
sizeEntry.Wymiary = new Wymiary();
sizeEntry.Reminder = reminder;
sizeEntry.Wymiary.Height = 100;
day.AddEntry(sizeEntry);
insertToDatabase(day);
reminder.ConnectedObject = "EntryObjectDTO:" + sizeEntry.GlobalId;
insertToDatabase(reminder);
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
ReminderOperationParam param = new ReminderOperationParam();
param.Operation = ReminderOperationType.Delete;
param.ReminderItemId = reminder.GlobalId;
var result = service.ReminderOperation(data.Token, param);
Assert.IsNull(result);
});
Assert.AreEqual(0, Session.QueryOver <ReminderItem>().RowCount());
}
private async Task <WorkoutPlan> GenerateShortPlan(GenerateWorkoutPlanInputModel inputModel)
{
var workoutPlan = new WorkoutPlan()
{
ExpireDate = DateTime.UtcNow.AddDays(inputModel.DurationInDays),
DaysInWeek = inputModel.WeekdaysCount,
UserId = inputModel.UserId,
};
switch (inputModel.Experience)
{
case Experience.Beginner:
workoutPlan.Difficulty = Difficulty.Easy;
break;
case Experience.Intermediate:
workoutPlan.Difficulty = Difficulty.Medium;
break;
case Experience.Advanced:
workoutPlan.Difficulty = Difficulty.Hard;
break;
}
for (int i = 0; i < inputModel.WeekdaysCount; i++)
{
TrainingDay trainingDay = await this.GenerateFullBodyDay(inputModel.Goal, workoutPlan.Difficulty, workoutPlan);
workoutPlan.TrainingDays.Add(trainingDay);
}
return(workoutPlan);
}
private List <TrainingExercise> FindTrainingExercise(TrainingDay trainingDay)
{
if (trainingDay == null)
{
return(null);
}
var criteria = new TrainingExerciseCriteria()
{
Year = new IntegerCriteria()
{
Equal = trainingDay.Year
},
WeekOfYear = new IntegerCriteria()
{
Equal = trainingDay.WeekOfYear
},
DayOfWeek = new IntegerCriteria()
{
Equal = trainingDay.DayOfWeek
},
TrainingDayId = new IntegerCriteria()
{
Equal = trainingDay.TrainingDayId
},
UserId = new StringCriteria()
{
Equal = trainingDay.UserId
}
};
return(_trainingExercisesService.FindTrainingExercise(criteria));
}
void importTrainingDays(int oldProfileId, Profile newProfile, SqlCeConnection oldConnection)
{
Log.WriteInfo("Importing training days for profile id {0}, name{1}", newProfile.Id, newProfile.Name);
SqlCeCommand cmd = new SqlCeCommand();
cmd.Connection = oldConnection;
cmd.CommandText = "SELECT ID,TrainingDate,StartTime,EndTime,Comment,WymiaryId FROM TrainingDay WHERE ProfileId=" + oldProfileId;
var reader = cmd.ExecuteReader();
Log.WriteInfo("TrainingDay reader executed");
while (reader.Read())
{
int oldTrainingDayId = getInt32(reader, "ID").Value;
DateTime date = getDateTime(reader, "TrainingDate").Value;
Log.WriteInfo("Training day id={0},TrainingDate={1}", oldTrainingDayId, date);
TrainingDay day = new TrainingDay(date);
day.ProfileId = newProfile.Id;
day.Comment = getString(reader, "Comment");
int?wymiaryId = getInt32(reader, "WymiaryId");
if (wymiaryId.HasValue)
{
Log.WriteInfo("TrainingDay has wymiary id={0}", wymiaryId.Value);
SizeEntry sizeEntry = new SizeEntry();
sizeEntry.Wymiary = importWymiar(oldConnection, wymiaryId.Value);
day.AddEntry(sizeEntry);
//session.SaveOrUpdate(sizeEntry);
}
importStrengthTraining(day, oldTrainingDayId, getDateTime(reader, "StartTime"), getDateTime(reader, "EndTime"), day.Comment, oldConnection);
day.Save();
Log.WriteInfo("TrainingDay saved");
}
Log.WriteInfo("TrainingDay import complete");
}
/// <summary>
/// Update data in database
/// </summary>
/// <param name="trainingDay">data</param>
/// <returns>updated data</returns>
public TrainingDay Update(TrainingDay trainingDay, TUnitType userUnit)
{
if (trainingDay == null || string.IsNullOrWhiteSpace(trainingDay.UserId) ||
trainingDay.Year == 0 || trainingDay.WeekOfYear == 0 ||
trainingDay.DayOfWeek < 0 || trainingDay.DayOfWeek > 6 || trainingDay.TrainingDayId == 0)
{
return(null);
}
var trainingJournalRow = _dbContext.TrainingDay.Where(t => t.UserId == trainingDay.UserId &&
t.Year == trainingDay.Year &&
t.WeekOfYear == trainingDay.WeekOfYear &&
t.DayOfWeek == trainingDay.DayOfWeek &&
t.TrainingDayId == trainingDay.TrainingDayId).FirstOrDefault();
if (trainingJournalRow == null)
{ // No data in database
return(Create(trainingDay, userUnit));
}
else
{ //Modify Data in database
TrainingDayTransformer.ToRow(trainingDay, trainingJournalRow);
_dbContext.SaveChanges();
return(TrainingDayTransformer.ToBean(trainingJournalRow, userUnit));
}
}
protected StrengthTrainingEntry AddTrainingDaySet(Profile profile, Customer customer, DateTime date, Exercise exercise, params Tuple <int?, decimal?>[] sets)
{
var trainingDay = new TrainingDay(date);
trainingDay.Customer = customer;
trainingDay.Profile = profile;
StrengthTrainingEntry entry = new StrengthTrainingEntry();
entry.MyPlace = GetDefaultMyPlace(profile);
trainingDay.AddEntry(entry);
StrengthTrainingItem item = new StrengthTrainingItem();
item.Exercise = exercise;
entry.AddEntry(item);
foreach (var tuple in sets)
{
Serie set1 = new Serie();
set1.RepetitionNumber = tuple.Item1;
set1.Weight = tuple.Item2;
item.AddSerie(set1);
}
insertToDatabase(trainingDay);
return(entry);
}
private void CompleteTrainingDayWithExercise(TrainingDay trainingJournalDay)
{
if (trainingJournalDay != null)
{
var trainingExerciseCriteria = new TrainingExerciseCriteria()
{
UserId = new StringCriteria()
{
Equal = trainingJournalDay.UserId
},
Year = new IntegerCriteria()
{
Equal = trainingJournalDay.Year
},
WeekOfYear = new IntegerCriteria()
{
Equal = trainingJournalDay.WeekOfYear
},
DayOfWeek = new IntegerCriteria()
{
Equal = trainingJournalDay.DayOfWeek
},
TrainingDayId = new IntegerCriteria()
{
Equal = trainingJournalDay.TrainingDayId
}
};
var trainingExerciseService = new TrainingExerciseService(DbContext);
trainingJournalDay.TrainingExercises = trainingExerciseService.FindTrainingExercise(trainingExerciseCriteria);
}
}
public void TestDeleteTrainingDay_Mode_OnlyWithoutMyTraining_TrainingDayShouldNotChanged()
{
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
DateTime date = DateTime.Now.AddDays(-2);
var day = new TrainingDay(date);
day.Profile = profiles[0];
SizeEntry size = new SizeEntry();
size.Wymiary = new Wymiary();
MyTraining training = new A6WTraining();
training.Name = "test";
training.Profile = day.Profile;
size.MyTraining = training;
day.AddEntry(size);
insertToDatabase(day);
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
var param = new DeleteTrainingDayParam();
param.TrainingDayId = day.GlobalId;
param.Mode = DeleteTrainingDayMode.OnlyWithoutMyTraining;
Service.DeleteTrainingDay(data.Token, param);
});
Assert.AreEqual(1, Session.QueryOver <TrainingDay>().RowCount());
Assert.AreEqual(1, Session.QueryOver <SizeEntry>().RowCount());
}
public void DeleteDayWithSystemEntry()
{
TrainingDay day = new TrainingDay(DateTime.Now);
day.Profile = profiles[0];
SizeEntry entry = new SizeEntry();
entry.Wymiary = new Wymiary();
entry.Wymiary.Height = 100;
entry.Status = Model.EntryObjectStatus.System;
day.AddEntry(entry);
insertToDatabase(day);
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
var param = new DeleteTrainingDayParam();
param.TrainingDayId = day.GlobalId;
Service.DeleteTrainingDay(data.Token, param);
});
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] TrainingDay trainingDay)
{
if (id != trainingDay.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(trainingDay);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TrainingDayExists(trainingDay.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(trainingDay));
}
private TrainingExerciseCriteria CreateTrainingExerciseCriteria(TrainingDay trainingDay)
{
return(new TrainingExerciseCriteria()
{
UserId = new StringCriteria()
{
Equal = trainingDay.UserId
},
Year = new IntegerCriteria()
{
Equal = trainingDay.Year
},
WeekOfYear = new IntegerCriteria()
{
Equal = trainingDay.WeekOfYear
},
DayOfWeek = new IntegerCriteria()
{
Equal = trainingDay.DayOfWeek
},
TrainingDayId = new IntegerCriteria()
{
Equal = trainingDay.TrainingDayId
}
});
}
public void DeleteCustomer_WithExerciseProfileData()
{
var customer = CreateCustomer("name", profiles[0]);
var exercise = CreateExercise(Session, null, "test", "test");
var trainingDay = new TrainingDay(DateTime.Now);
trainingDay.Customer = customer;
trainingDay.Profile = profiles[0];
StrengthTrainingEntry entry = new StrengthTrainingEntry();
entry.MyPlace = GetDefaultMyPlace(profiles[0]);
trainingDay.AddEntry(entry);
StrengthTrainingItem item = new StrengthTrainingItem();
item.Exercise = exercise;
entry.AddEntry(item);
insertToDatabase(trainingDay);
CreateExerciseRecord(exercise, profiles[0], new Tuple <int, decimal>(1, 22), trainingDay.TrainingDate, customer);
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
var customerDto = customer.Map <CustomerDTO>();
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
service.DeleteCustomer(data.Token, customerDto);
});
Assert.That(Session.QueryOver <Customer>().RowCount(), Is.EqualTo(0));
Assert.That(Session.QueryOver <ExerciseProfileData>().RowCount(), Is.EqualTo(0));
}
void importTrainingDays(int oldProfileId, Profile newProfile, SqlCeConnection oldConnection)
{
Log.WriteInfo("Importing training days for profile id {0}, name{1}", newProfile.Id, newProfile.Name);
SqlCeCommand cmd = new SqlCeCommand();
cmd.Connection = oldConnection;
cmd.CommandText = "SELECT ID,TrainingDate,Comment FROM TrainingDay WHERE ProfileId=" + oldProfileId;
var reader = cmd.ExecuteReader();
Log.WriteInfo("TrainingDay reader executed");
while (reader.Read())
{
int oldTrainingDayId = getInt32(reader, "ID").Value;
DateTime date = getDateTime(reader, "TrainingDate").Value;
Log.WriteInfo("Training day id={0},TrainingDate={1}", oldTrainingDayId, date);
TrainingDay day = new TrainingDay(date);
day.ProfileId = newProfile.Id;
day.Comment = getString(reader, "Comment");
importA6w(day, newProfile, oldTrainingDayId, oldConnection);
importStrengthTraining(day, oldTrainingDayId, oldConnection);
importSizes(day, oldTrainingDayId, oldConnection);
day.CreateAndFlush();
if (day.IsEmpty)
{
day.Delete();
}
Log.WriteInfo("TrainingDay saved");
}
Log.WriteInfo("TrainingDay import complete");
}
private async Task CreateTrainingDayActionAsync()
{
try
{
if (_trainingDays != null)
{
var newTrainingDay = new TrainingDay()
{
Year = Year,
WeekOfYear = WeekOfYear,
DayOfWeek = DayOfWeek,
TrainingDayId = 0,
UserId = UserId
};
if (await CreateTrainingDayViewModel.ShowAsync(newTrainingDay, TEditMode.Create, this))
{
_trainingDays.Add(newTrainingDay);
//Binding trainingDay for refresh view
CreateOrReplaceBindingTrainingDay(newTrainingDay);
}
}
}
catch (Exception except)
{
ILogger.Instance.Error("Unable to create training day", except);
}
}
private async Task DeleteTrainingDayActionAsync(TrainingDay trainingDay)
{
if (trainingDay == null)
{
return;
}
try
{
if (await _userDialog.ConfirmAsync(string.Format(Translation.Get(TRS.ARE_YOU_SURE_YOU_WANNA_DELETE_THIS_ELEMENT_PI), Translation.Get(TRS.TRAINING_DAY)),
Translation.Get(TRS.QUESTION), Translation.Get(TRS.YES), Translation.Get(TRS.NO)))
{
//Delete on server
if (await TrainingDayWebService.DeleteTrainingDayAsync(trainingDay))
{
//Delete on local
_trainingDayService.DeleteTrainingDay(trainingDay);
//Binding trainingDay for refresh view
_trainingDays.Remove(trainingDay);
var collection = GroupedTrainingExercises.Where(lgte => TrainingDayKey.IsEqualByKey((TrainingDay)lgte.ReferenceObject, trainingDay)).FirstOrDefault();
if (collection != null)
{
GroupedTrainingExercises.Remove(collection);
}
}
}
}
catch (Exception except)
{
ILogger.Instance.Error("Unable to delete training day", except);
await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
}
private void CreateOrReplaceBindingTrainingDay(TrainingDay trainingDay)
{
var newGroupedTrainingExercises = PopulateBindingTrainingDay(trainingDay);
var collection = GroupedTrainingExercises.Where(lgte => TrainingDayKey.IsEqualByKey((TrainingDay)lgte.ReferenceObject, trainingDay)).FirstOrDefault();
if (collection == null)
{
collection = new GenericGroupModelCollection <BindingTrainingExercise>();
GroupedTrainingExercises.Add(newGroupedTrainingExercises);
}
else
{
int indexOf = GroupedTrainingExercises.IndexOf(collection);
if (indexOf == -1)
{
return;
}
GroupedTrainingExercises[indexOf] = newGroupedTrainingExercises;
}
if (newGroupedTrainingExercises != null && newGroupedTrainingExercises.Count > 0)
{
List <BindingTrainingExercise> bindingList = new List <BindingTrainingExercise>();
bindingList.AddRange(newGroupedTrainingExercises);
Task t = CachingImagesAsync(bindingList);
}
}
/// <summary>
/// Update data in database
/// </summary>
/// <param name="trainingJournalDay">data</param>
/// <returns>updated data</returns>
public TrainingDay Update(TrainingDay trainingJournalDay)
{
if (trainingJournalDay == null || string.IsNullOrWhiteSpace(trainingJournalDay.UserId) ||
trainingJournalDay.Year == 0 || trainingJournalDay.WeekOfYear == 0 ||
trainingJournalDay.DayOfWeek < 0 || trainingJournalDay.DayOfWeek > 6 || trainingJournalDay.TrainingDayId == 0)
{
return(null);
}
var trainingJournalRow = _dbContext.Table <TrainingDayRow>().Where(t => t.UserId == trainingJournalDay.UserId &&
t.Year == trainingJournalDay.Year &&
t.WeekOfYear == trainingJournalDay.WeekOfYear &&
t.DayOfWeek == trainingJournalDay.DayOfWeek &&
t.TrainingDayId == trainingJournalDay.TrainingDayId).FirstOrDefault();
if (trainingJournalRow == null)
{ // No data in database
return(Create(trainingJournalDay));
}
else
{ //Modify Data in database
TrainingDayTransformer.ToRow(trainingJournalDay, trainingJournalRow);
_dbContext.Delete(trainingJournalRow); //Update don't work... need delete and insert
_dbContext.Insert(trainingJournalRow);
return(TrainingDayTransformer.ToBean(trainingJournalRow));
}
}
protected ExerciseProfileData CreateExerciseRecord(Exercise exercise, Profile profile, Tuple <int, decimal> serie, DateTime trainingDate, Customer customer = null)
{
var trainingDay = new TrainingDay(trainingDate);
trainingDay.Customer = customer;
trainingDay.Profile = profile;
StrengthTrainingEntry entry = new StrengthTrainingEntry();
entry.MyPlace = GetDefaultMyPlace(profile);
trainingDay.AddEntry(entry);
StrengthTrainingItem item = new StrengthTrainingItem();
item.Exercise = exercise;
entry.AddEntry(item);
Serie set1 = new Serie();
set1.RepetitionNumber = serie.Item1;
set1.Weight = serie.Item2;
item.AddSerie(set1);
insertToDatabase(trainingDay);
ExerciseProfileData data = new ExerciseProfileData();
data.Profile = profile;
data.Customer = customer;
data.Serie = set1;
data.TrainingDate = trainingDate;
data.Repetitions = serie.Item1;
data.MaxWeight = serie.Item2;
data.Exercise = exercise;
insertToDatabase(data);
return(data);
}
public async Task <ActionResult <TrainingDay> > getTrainingDayProto()
{
TrainingDay trainingDay = await _trainingDayRepo.GetByIdAsync(1);
// trainingDay = trainingDay;
// var trainingDayFlattened = trainingDay.
return(trainingDay);
}
public IEnumerable <Formula> GetByTrainingDay(TrainingDay trainingDay)
{
return(_formulas
.Include(f => f.FormulaTrainingDays)
.Where(f => f.FormulaTrainingDays
.Any(ftd => ftd.TrainingsDayId == trainingDay.TrainingDayId))
.ToList());
}
public static void Main(string[] args)
{
//TickerDataDownloader.Run();
//Relationshipper.Run();
//CreateTrainingDataSet.Run();
//Pruner.Run();
TrainingDay.Run();
}
public static async Task <bool> ShowAsync(TrainingDay trainingDay, TEditMode editMode, BaseViewModel parent = null)
{
var viewModel = new CreateTrainingDayViewModel();
viewModel._trainingDay = trainingDay;
viewModel._editMode = editMode;
return(await ShowModalViewModelAsync(viewModel, parent));
}
internal TrainingDay UpdateTrainingDay(TrainingDay trainingDay, TrainingDayScenario trainingDayScenario)
{
TrainingDay trainingDayResult = null;
trainingDayResult = _trainingDayModule.Update(trainingDay, AppUtils.GetUserUnit(_userInfosService, trainingDay.UserId));
SynchroManager.TrainingDayChange(DbContext, trainingDayResult);
if (trainingDayScenario != null && trainingDayScenario.ManageExercise)
{
var trainingExerciseCriteria = new TrainingExerciseCriteria()
{
UserId = new StringCriteria()
{
Equal = trainingDay.UserId
},
Year = new IntegerCriteria()
{
Equal = trainingDay.Year
},
WeekOfYear = new IntegerCriteria()
{
Equal = trainingDay.WeekOfYear
},
DayOfWeek = new IntegerCriteria()
{
Equal = trainingDay.DayOfWeek
},
TrainingDayId = new IntegerCriteria()
{
Equal = trainingDay.TrainingDayId
}
};
var trainingExercisesDb = _trainingExercisesService.FindTrainingExercise(trainingExerciseCriteria);
if (trainingExercisesDb != null && trainingExercisesDb.Count > 0)
{
foreach (var trainingExerciseDb in trainingExercisesDb)
{
//remove only training exercises who do not present (for keep exercise tempos: retrocompatibility)
if (trainingDay.TrainingExercises == null || !trainingDay.TrainingExercises.Any(te => te.Id == trainingExerciseDb.Id))
{
_trainingExercisesService.DeleteTrainingExercise(trainingExerciseDb);
}
}
}
if (trainingDay.TrainingExercises != null)
{
trainingDayResult.TrainingExercises = new List <TrainingExercise>();
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
trainingDayResult.TrainingExercises.Add(_trainingExercisesService.UpdateTrainingExercise(trainingExercise, true));
}
}
}
return(trainingDayResult);
}
public static void InitializeDatabaseSeed(DataBaseContext database)
{
if (!database.TrainingDay.Any())
{
var TrainingDayList = new TrainingDay[]
{
new TrainingDay {
DateOfTraining = DateTime.Now
}
};
foreach (TrainingDay i in TrainingDayList)
{
database.TrainingDay.Add(i);
}
database.SaveChanges();
}
if (!database.ExercisePerTrainingDay.Any())
{
var ExercisePerTrainingDayList = new ExercisePerTrainingDay[] {
new ExercisePerTrainingDay {
Name = "Squat", TrainingDayId = 1
}
};
foreach (ExercisePerTrainingDay i in ExercisePerTrainingDayList)
{
database.ExercisePerTrainingDay.Add(i);
}
database.SaveChanges();
}
if (!database.ExerciseDetail.Any())
{
var ExerciseDetails = new ExerciseDetails[] {
new ExerciseDetails {
Weight = 20, Reps = 5, SetNumber = 1, ExercisePerTrainingDayId = 1
}
};
foreach (ExerciseDetails i in ExerciseDetails)
{
database.ExerciseDetail.Add(i);
}
database.SaveChanges();
}
else
{
//then give each exercise their details according to whether it is squat deadlift or bench
return;
}
}
public static void UpdateMyBlogComments(ISession session, TrainingDay trainingDay)
{
session.Flush();
//var selectBlogEntryCountQuery = string.Format(@"SELECT Count(*) FROM TrainingDayComment bc, TrainingDay td,EntryObject eo,BlogEntry e WHERE bc.Profile_id<>td.Profile_id AND bc.BlogEntry_id=e.EntryObject_id AND e.EntryObject_id=eo.Id AND eo.TrainingDay_id=td.Id AND eo.Id={0}", blogEntry.Id);
//var selectBlogEntryCountQuery = string.Format(@"SELECT Count(*) FROM TrainingDayComment bc, TrainingDay td,EntryObject eo,BlogEntry e WHERE td.Profile_id={0} AND bc.Profile_id<>td.Profile_id AND bc.BlogEntry_id=e.EntryObject_id AND e.EntryObject_id=eo.GlobalId AND eo.TrainingDay_id=td.GlobalId AND td.Customer_id is null", blogEntry.TrainingDay.Profile.Id);
var selectBlogEntryCountQuery = @"SELECT Count(*) FROM TrainingDayComment bc, TrainingDay td WHERE td.Profile_id=:ProfileId AND bc.Profile_id<>td.Profile_id AND bc.TrainingDay_id=td.GlobalId AND td.Customer_id is null";
var query = session.CreateSQLQuery(string.Format(@"UPDATE ProfileStatistics SET MyTrainingDayCommentsCount=({0}) WHERE GlobalId=:StatisticsId", selectBlogEntryCountQuery));
query.SetGuid("StatisticsId", trainingDay.Profile.Statistics.GlobalId);
query.SetGuid("ProfileId", trainingDay.Profile.GlobalId);
query.ExecuteUpdate();
}
public async Task <IActionResult> Create([Bind("Id,Name")] TrainingDay trainingDay)
{
if (ModelState.IsValid)
{
_context.Add(trainingDay);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(trainingDay));
}
private async Task ViewTrainingDayActionAsync(DayOfWeek dayOfWeek)
{
try
{
if (TrainingWeek.TrainingDays == null)
{
TrainingWeek.TrainingDays = new List <TrainingDay>();
}
//Check training day exist. if not exist, create new training day
var trainingDays = TrainingWeek.TrainingDays.Where(td => td.DayOfWeek == (int)dayOfWeek).ToList();
if (trainingDays == null)
{
trainingDays = new List <TrainingDay>();
}
if (trainingDays.Count == 0)
{
var newTrainingDay = new TrainingDay()
{
Year = TrainingWeek.Year,
WeekOfYear = TrainingWeek.WeekOfYear,
DayOfWeek = (int)dayOfWeek,
TrainingDayId = 0,
UserId = UserData.Instance.UserInfo.UserId,
Unit = UserData.Instance.UserInfo.Unit
};
if (await CreateTrainingDayViewModel.ShowAsync(newTrainingDay, TEditMode.Create, this))
{
TrainingWeek.TrainingDays.Add(newTrainingDay);
trainingDays.Add(newTrainingDay);
FillWeekDays(TrainingWeek);
}
}
if (trainingDays.Count > 0)
{ //view training day
var trainingDayViewModelResut = await TrainingDayViewModel.ShowAsync(trainingDays, this);
//reload local data necessary
if (trainingDayViewModelResut.Result)
{
TrainingWeek.TrainingDays.RemoveAll(td => td.DayOfWeek == (int)dayOfWeek);
if (trainingDayViewModelResut.TrainingDays != null && trainingDayViewModelResut.TrainingDays.Count > 0)
{
TrainingWeek.TrainingDays.AddRange(trainingDayViewModelResut.TrainingDays);
}
FillWeekDays(TrainingWeek);
}
}
}
catch
{
}
}
internal TrainingDay UpdateTrainingDay(TrainingDay trainingDay, TrainingDayScenario trainingDayScenario)
{
TrainingDay trainingDayResult = null;
trainingDayResult = _trainingDayModule.Update(trainingDay);
if (trainingDayScenario != null && trainingDayScenario.ManageExercise)
{
var trainingExerciseService = new TrainingExerciseService(DbContext);
var trainingExerciseCriteria = new TrainingExerciseCriteria()
{
UserId = new StringCriteria()
{
Equal = trainingDay.UserId
},
Year = new IntegerCriteria()
{
Equal = trainingDay.Year
},
WeekOfYear = new IntegerCriteria()
{
Equal = trainingDay.WeekOfYear
},
DayOfWeek = new IntegerCriteria()
{
Equal = trainingDay.DayOfWeek
},
TrainingDayId = new IntegerCriteria()
{
Equal = trainingDay.TrainingDayId
}
};
var trainingExercisesDb = trainingExerciseService.FindTrainingExercise(trainingExerciseCriteria);
if (trainingExercisesDb != null && trainingExercisesDb.Count > 0)
{
foreach (var trainingExerciseDb in trainingExercisesDb)
{
trainingExerciseService.DeleteTrainingExercise(trainingExerciseDb);
}
}
if (trainingDay.TrainingExercises != null)
{
trainingDayResult.TrainingExercises = new List <TrainingExercise>();
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
trainingDayResult.TrainingExercises.Add(trainingExerciseService.UpdateTrainingExercise(trainingExercise, true));
}
}
}
return(trainingDayResult);
}
