public async Task <IActionResult> PutScheduleTraining(int id, ScheduleTraining scheduleTraining)
{
var email = GetEmail();
scheduleTraining.UserEmail = email;
if (id != scheduleTraining.ScheduleTrainingId)
{
return(BadRequest());
}
_context.Entry(scheduleTraining).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ScheduleTrainingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <ScheduleTraining> > PostScheduleTraining(ScheduleTraining model)
{
var email = GetEmail();
var scheduleTraining = await NewScheduleTraining(model.TrainingId, model.TrainingDate, email);
var trainingExercises = await trainingRepository.GetExercisesTrainingsAsync(model.TrainingId, email);
if (trainingExercises == null)
{
return(Ok());
}
foreach (var trainingExercise in trainingExercises)
{
var scheduleExercise = await NewScheduleExercise(email, scheduleTraining, trainingExercise);
var series = await seriesRespository.GetSeriesForExerciseAsync(trainingExercise.ExerciseId, email);
if (series == null)
{
continue;
}
foreach (var s in series)
{
await NewSeries(email, scheduleExercise, s);
}
}
return(CreatedAtAction("GetScheduleTraining", new { id = scheduleTraining.ScheduleTrainingId }, scheduleTraining));
}
public async Task Handle(ScheduleTraining message, IMessageHandlerContext context)
{
log.Info($"Received ScheduleTraining, TrainingId = {message.TrainingId}");
Data.TrainingId = message.TrainingId;
log.Info($"Starting cool down period for training #{Data.TrainingId}.");
await RequestTimeout(context, TimeSpan.FromSeconds(20), new SchedulingChangeIsOver());
}
public async Task <ScheduleTrainingResponse> SaveAsync(ScheduleTraining scheduleTraining)
{
try
{
await scheduleTrainingRepository.AddAsync(scheduleTraining);
await unitOfWork.CompleteAsync();
return(new ScheduleTrainingResponse(scheduleTraining));
}
catch (Exception ex)
{
return(new ScheduleTrainingResponse($"Ошибка при сохранении Расписание занятия: {ex.Message}"));
}
}
static async Task RunLoop(IEndpointInstance endpointInstance)
{
var lastTraining = string.Empty;
while (true)
{
log.Info("Press 'S' to schedule a training, 'C' to cancel last scheduled training, or 'Q' to quit.");
var key = Console.ReadKey();
Console.WriteLine();
switch (key.Key)
{
case ConsoleKey.S:
// Instantiate the command
var command = new ScheduleTraining
{
TrainingId = Guid.NewGuid().ToString()
};
// Send the command
log.Info($"Sending ScheduleTraining command, TrainingId = {command.TrainingId}");
await endpointInstance.Send(command)
.ConfigureAwait(false);
lastTraining = command.TrainingId; // Store training identifier to cancel if needed.
break;
case ConsoleKey.C:
var cancelCommand = new CancelTraining
{
TrainingId = lastTraining
};
await endpointInstance.Send(cancelCommand)
.ConfigureAwait(false);
log.Info($"Sent a correlated message to {cancelCommand.TrainingId}");
break;
case ConsoleKey.Q:
return;
default:
log.Info("Unknown input. Please try again.");
break;
}
}
}
private async Task <ScheduleTraining> NewScheduleTraining(int trainingId, DateTime date, string email)
{
var training = await trainingRepository.GetTraining(trainingId, email);
var newScheduleTraining = new ScheduleTraining
{
UserEmail = email,
TrainingId = trainingId,
TrainingDate = date,
Name = training.Name
};
await _context.ScheduleTrainings.AddAsync(newScheduleTraining);
await _context.SaveChangesAsync();
return(newScheduleTraining);
}
public async Task <ScheduleTrainingResponse> UpdateAsync(int id, ScheduleTraining scheduleTraining)
{
var existingScheduleTraining = await scheduleTrainingRepository.FindByIdAsync(id);
if (existingScheduleTraining == null)
{
return(new ScheduleTrainingResponse("Расписание занятия не найдено!"));
}
existingScheduleTraining.IdTraining = scheduleTraining.IdTraining;
try
{
scheduleTrainingRepository.Update(existingScheduleTraining);
await unitOfWork.CompleteAsync();
return(new ScheduleTrainingResponse(existingScheduleTraining));
}
catch (Exception ex)
{
return(new ScheduleTrainingResponse($"Ошибка при обновлении Расписание занятия: {ex.Message}"));
}
}
private async Task <Models.Schedule.Exercise.ScheduleExercise> NewScheduleExercise(string email, ScheduleTraining scheduleTraining,
TrainingExercise trainingExercise)
{
var nScheduleExercise = new Models.Schedule.Exercise.ScheduleExercise
{
ExerciseId = trainingExercise.ExerciseId,
ScheduleTraining = scheduleTraining,
UserEmail = email,
Order = trainingExercise.Order
};
await _context.ScheduleExercises.AddAsync(nScheduleExercise);
await _context.SaveChangesAsync();
return(nScheduleExercise);
}
public async Task <ActionResult> FinishTraining(FinishTrainingIn form)
{
var email = GetEmail();
var mScheduleTrainingTask = scheduleTrainingRepository.GetScheduleTrainingAsync(form.ScheduleTrainingId, email);
var mScheduleTraining = await mScheduleTrainingTask;
var seriesTask = scheduleSeriesRepository.GetScheduleSeriesForScheduleTrainingAsync(form.ScheduleTrainingId, email);
mScheduleTraining.TrainingFinishDate = form.FinishDate;
mScheduleTraining.Finish = true;
var seriesInFinishedTraining = await seriesTask;
var seriesToComplete = new List <ScheduleSeries>();
var scheduleExercises = new List <Models.Schedule.Exercise.ScheduleExercise>();
var scheduleTraining = new ScheduleTraining();
var t = await trainingRepository.GetTraining(mScheduleTraining.TrainingId, email);
if (form.CreateNextTraining)
{
scheduleTraining.TrainingDate = form.NextTrainingDate;
scheduleTraining.ExerciseNumber = mScheduleTraining.ExerciseNumber;
scheduleTraining.Name = t.Name;
scheduleTraining.Finish = false;
scheduleTraining.UserEmail = email;
scheduleTraining.TrainingId = mScheduleTraining.TrainingId;
var addTrainingTask = _context.ScheduleTrainings.AddAsync(scheduleTraining);
await addTrainingTask;
}
var exercisesList = new List <Models.Schedule.Exercise.ScheduleExercise>();
var seriesList = new List <ScheduleSeries>();
foreach (var series in seriesInFinishedTraining)
{
//Zakonczenie wszystkich serii
if (!series.Finish)
{
series.Finish = true;
seriesToComplete.Add(series);
}
if (form.CreateNextTraining)
{
if (exercisesList.Find(e =>
e.ExerciseId == series.ScheduleExercise.ExerciseId &&
e.Order == series.ScheduleExercise.Order) ==
null)
{
//przekopiowanie cwiczen do nowego treningu
var c = new Models.Schedule.Exercise.ScheduleExercise
{
ExerciseId = series.ScheduleExercise.ExerciseId,
ScheduleTraining = scheduleTraining,
Order = series.ScheduleExercise.Order,
UserEmail = email
};
exercisesList.Add(c);
}
//przekopiowanie serii do nowego treningu
var s = new ScheduleSeries
{
Time = series.Time,
Distance = series.Distance,
ScheduleExercise = exercisesList.Find(c =>
c.ExerciseId == series.ScheduleExercise.ExerciseId && c.Order == series.ScheduleExercise.Order),
Repeats = series.Repeats,
Order = series.Order,
Load = series.Load,
RestTime = series.RestTime,
Name = CreateSeriesName(series),
UserEmail = email
};
seriesList.Add(s);
}
//aktualizacja serii
if (!form.UpdateSeries)
{
continue;
}
var se = await seriesRespository.GetSeriesForExerciseAsync(series.ScheduleExercise.ExerciseId, email);
var newSeries = new Series
{
Time = series.Time,
Distance = series.Distance,
Repeats = series.Repeats,
Name = series.Name,
Load = series.Load,
RestTime = series.RestTime,
Order = series.Order,
ExerciseId = series.ScheduleExercise.ExerciseId,
UserEmail = email
};
if (se != null)
{
_context.RemoveRange(se);
}
await _context.Series.AddAsync(newSeries);
}
_context.UpdateRange(seriesToComplete);
_context.Update(mScheduleTraining);
await _context.SaveChangesAsync();
if (!form.CreateNextTraining)
{
return(Ok());
}
var addScheduleExerciseTask = _context.AddRangeAsync(scheduleExercises.Distinct());
await addScheduleExerciseTask;
var addScheduleSeriesTask = _context.ScheduleSeries.AddRangeAsync(seriesList);
await addScheduleSeriesTask;
await _context.SaveChangesAsync();
return(Ok());
}
public void Update(ScheduleTraining scheduleTraining)
{
context.ScheduleTraining.Update(scheduleTraining);
}
public void Remove(ScheduleTraining scheduleTraining)
{
context.ScheduleTraining.Remove(scheduleTraining);
}
public async Task AddAsync(ScheduleTraining scheduleTraining)
{
await context.ScheduleTraining.AddAsync(scheduleTraining);
}
//Dictionary<ScheduleTaskCtrl.TaskType, List<ScheduleBase>> m_listWorksData;
/// <summary>
/// 분석용 ScheduleTaskCtrl
/// </summary>
/// <param name="slotNo"></param>
/// <returns></returns>
//private List<ScheduleTaskCtrl.TaskButton> LoadYotogiData(int slotNo)
private static int LoadYotogiData(int slotNo)
{
//this.m_scheduleApi = this.m_scheduleMgr.GetScheduleApi();
List <ScheduleBase> scheduleData = ScheduleMgrPatch.m_scheduleApi.slot[slotNo].scheduleData.Where(x => x.workType != ScheduleType.Work).ToList();
//List<ScheduleBase> scheduleData = ScheduleMgrPatch.m_scheduleApi.slot[slotNo].scheduleData;
List <ScheduleBase> list = new List <ScheduleBase>();
Maid maid = ScheduleMgrPatch.m_scheduleApi.slot[slotNo].maid;
//this.m_listWorksData.Add(ScheduleTaskCtrl.TaskType.Yotogi, list);
//List<ScheduleTaskCtrl.TaskButton> list2 = new List<ScheduleTaskCtrl.TaskButton>();
MyLog.LogMessage(
"scheduleBase"
, maid.status.fullNameEnStyle
, slotNo
);
foreach (ScheduleBase scheduleBase in scheduleData)
{
bool flag = false;
//bool legacyDisable;
//if (DailyMgr.IsLegacy && ScheduleCSVData.WorkLegacyDisableId.Contains(scheduleBase.id))
//{
// legacyDisable = true;
//}
if (maid != null && scheduleBase.enabled)
{
flag = PersonalEventBlocker.IsEnabledScheduleTask(maid.status.personal, scheduleBase.id);
}
//list.Add(scheduleBase);
if (scheduleBase.workType == ScheduleType.Yotogi)
{
ScheduleYotogi scheduleYotogi = (ScheduleYotogi)scheduleBase;
if (scheduleYotogi.visible)
{
list.Add(scheduleBase);
}
if (configEntryUtill["LoadYotogiData", false])
{
MyLog.LogMessage(
"scheduleBase"
, scheduleBase.id
, scheduleBase.workType
, scheduleYotogi.visible
, scheduleYotogi.enabled
);
}
}
if (scheduleBase.workType == ScheduleType.Training)
{
//if (this.legacyDisable)
//{
// this.visible = false;
//}
ScheduleTraining scheduleTraining = (ScheduleTraining)scheduleBase;
if (scheduleTraining.visible)
{
list.Add(scheduleBase);
//list2.Add(new ScheduleTaskCtrl.TrainingTaskButton {
// id = scheduleTraining.id.ToString(),
// name = scheduleTraining.name,
// rank = scheduleTraining.lv,
// expRatio = scheduleTraining.expRatioFrom0To10,
// txtTaskIcon = scheduleTraining.icon,
// enableTask = scheduleTraining.enabled,
// type = scheduleTraining.type
//});
}
if (configEntryUtill["LoadYotogiData", false])
{
MyLog.LogMessage(
"scheduleBase"
, scheduleBase.id
, scheduleBase.workType
, scheduleTraining.visible
, scheduleTraining.enabled
);
}
}
}
int ic = UnityEngine.Random.Range(0, list.Count);
return(list[ic].id);
//return list2;
}
public ScheduleTrainingResponse(bool success, string message, ScheduleTraining scheduleTraining) : base(success, message)
{
ScheduleTraining = scheduleTraining;
}
public ScheduleTrainingResponse(ScheduleTraining scheduleTraining) : this(true, string.Empty, scheduleTraining)
{
}
