/*----------------------------------------------------------------------------------------------------------------------------------------*/
//
// Constractor
//
/*----------------------------------------------------------------------------------------------------------------------------------------*/
#region Constractor
public EditTrainingScheduleViewModel(int week, StackLayout trainingStack)
{
InitCommands();
TrainingStack = trainingStack;
WeekLabel = ((WeekEnum)week).ToString();
_week = week;
var target = TrainingScheduleService.GetTrainingSchedule(week);
if (target != null)
{
_isUpdate = true;
_id = target.Id;
var trainingScheduleStructure =
JsonConvert.DeserializeObject <TrainingScheduleStructure>(target.TrainingMenu);
Off = trainingScheduleStructure.Off;
if (!Off)
{
foreach (var training in trainingScheduleStructure.TrainingContentList)
{
CommandAddTrainingAction(training);
}
}
else
{
CommandAddTrainingAction();
}
}
else
{
CommandAddTrainingAction();
}
}
public TrainingScheduleType(TrainingScheduleService trainingScheduleService, UserService userService)
{
Field(o => o.Id);
Field(o => o.Name);
Field <ListGraphType <TrainingScheduleExerciseType>, IEnumerable <Exercise> >()
.Name("exercises")
.Resolve(ctx => trainingScheduleService.GetExercisesForTrainingScheduleByIdAsync(ctx.Source.Id));
Field <UserType>("user",
resolve: context => userService.GetUserByIdAsync(context.Source.UserId));
}
/// <summary>
/// トレーニング画面遷移
/// </summary>
private static void CommandStartTrainingAction()
{
var check = TrainingResultService.CheckExitTargetDayData(DateTime.Now);
if (check)
{
Application.Current.MainPage.DisplayAlert(LanguageUtils.Get(LanguageKeys.Confirm),
LanguageUtils.Get(LanguageKeys.TodayTrainingAlreadyCompleted), LanguageUtils.Get(LanguageKeys.OK));
}
else
{
var exits = TrainingScheduleService.GetTrainingSchedule((int)DateTime.Now.DayOfWeek);
if (exits == null)
{
Application.Current.MainPage.DisplayAlert(LanguageUtils.Get(LanguageKeys.Confirm),
LanguageUtils.Get(LanguageKeys.NotSettingTrainingSchedule), LanguageUtils.Get(LanguageKeys.OK));
}
else
{
var training = JsonConvert
.DeserializeObject <TrainingScheduleStructure>(
TrainingScheduleService.GetTrainingSchedule((int)DateTime.Now.DayOfWeek).TrainingMenu);
if (training.Off)
{
Application.Current.MainPage.DisplayAlert(LanguageUtils.Get(LanguageKeys.Confirm),
LanguageUtils.Get(LanguageKeys.TodayIsRest), LanguageUtils.Get(LanguageKeys.OK));
}
else
{
ViewModelConst.TrainingPageNavigation.PushAsync(new TrainingView());
}
}
}
}
public SchemaMutation(ExerciseService exercises, TrainingScheduleService trainingSchedules, WorkoutService workoutService,
UserService userService)
{
Name = "Mutation";
Field <ExerciseType>(
"createExercise",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ExerciseCreateInputType> > {
Name = "exercise"
}),
resolve: context =>
{
var input = context.GetArgument <ExerciseCreateInputType>("exercise");
var order = new Exercise {
Name = input.Name
};
return(exercises.CreateAsync(order));
}
);
FieldAsync <TrainingScheduleType>(
"createTrainingSchedule",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <TrainingScheduleCreateInputType> >
{
Name = "trainingSchedule"
}),
resolve: async context =>
{
var input = context.GetArgument <TrainingScheduleCreateDto>("trainingSchedule");
var trainingSchedule = new TrainingSchedule
{
Name = input.Name,
User = await userService.GetUserByIdAsync(1),
TrainingScheduleExercises = input.ExercisesWithSets
.Select(
exerciseIdWithSets => new TrainingScheduleExercise
{
ExerciseId = exerciseIdWithSets.Id,
Sets = exerciseIdWithSets.Sets
}).ToList()
};
return(await context.TryAsyncResolve(async c =>
await trainingSchedules.CreateAsync(trainingSchedule)));
}
);
FieldAsync <WorkoutType>(
"createWorkout",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <WorkoutCreateInputType> >
{
Name = "workout"
}),
resolve: async context =>
{
var input = context.GetArgument <WorkoutCreateDto>("workout");
var trainingSchedule = new Workout
{
User = await userService.GetUserByIdAsync(1),
Exercises = input.Exercises
.Select(
exercise => new WorkoutExercise
{
ExerciseId = exercise.Id,
Sets = exercise.Sets,
DateTime = exercise.DateTime
}).ToList()
};
return(await context.TryAsyncResolve(async c =>
await workoutService.CreateAsync(trainingSchedule)));
}
);
}
public SchemaQuery(ExerciseService exercises, TrainingScheduleService trainingScheduleService, WorkshopService workshopService, WorkoutService workoutService, JourneyService journeyService)
{
Name = "Query";
Field <ListGraphType <ExerciseType> >(
"exercises",
resolve: context => exercises.GetExercisesAsync()
);
Field <ListGraphType <TrainingScheduleType> >(
"trainingSchedules",
resolve: context => trainingScheduleService.GetTrainingSchedulesAsync()
);
Field <ListGraphType <WorkshopType> >(
"workshops",
resolve: context => workshopService.GetWorkshopsAsync()
);
Field <ListGraphType <WorkoutType> >(
"workouts",
resolve: context => workoutService.GetWorkoutsAsync()
);
Field <ListGraphType <JourneyType> >(
"journeys",
resolve: context => journeyService.GetJourneysAsync()
);
FieldAsync <ExerciseType>(
"exercise",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "id"
}),
resolve: async context => {
return(await context.TryAsyncResolve(
async c => await exercises.GetExerciseByIdAsync(c.GetArgument <int>("id"))
));
}
);
FieldAsync <JourneyType>(
"journey",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "id"
}),
resolve: async context => {
return(await context.TryAsyncResolve(
async c => await journeyService.GetJourneyByIdAsync(c.GetArgument <int>("id"))
));
}
);
FieldAsync <WorkoutType>(
"workout",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "id"
}),
resolve: async context => {
return(await context.TryAsyncResolve(
async c => await workoutService.GetWorkoutAsync(c.GetArgument <int>("id"))
));
}
);
}
private async Task CommandSaveAction()
{
try
{
if (!Validate())
{
ViewModelCommonUtil.SendMessage(ViewModelConst.MessagingTrainingSelfScroll);
return;
}
IsLoading = true;
var trainingContentList = new List <TrainingListStructure>();
if (!Off)
{
// トレーニング一覧
var trainingStack = TrainingStack.Children;
foreach (var training in trainingStack)
{
var insert = new TrainingListStructure();
var trainingId =
((TrainingMasterModel)((Picker)((StackLayout)training).Children[1]).SelectedItem).Id;
var trainingseCount = ((Entry)((StackLayout)training).Children[3]).Text;
var loadContentList = new List <LoadContentStructure>();
var loadStack = ((StackLayout)((StackLayout)training).Children[4]).Children;
foreach (var load in loadStack)
{
var insertload = new LoadContentStructure();
var subLoad = ((StackLayout)load).Children[1];
var loadId = ((LoadUnitModel)((Picker)((StackLayout)subLoad).Children[1]).SelectedItem)
.LoadId;
var nums = ((Entry)((StackLayout)subLoad).Children[0]).Text;
var loadUnitId =
((LoadUnitModel)((Picker)((StackLayout)subLoad).Children[1]).SelectedItem).Id;
insertload.LoadId = loadId;
insertload.LoadUnitId = loadUnitId;
insertload.Nums = float.Parse(nums);
loadContentList.Add(insertload);
}
insert.LoadContentList = loadContentList;
insert.TrainingId = trainingId;
insert.TrainingSetCount = int.Parse(trainingseCount);
trainingContentList.Add(insert);
}
}
var trainingScheduleStructure =
new TrainingScheduleStructure
{
TrainingContentList = trainingContentList,
Off = Off,
Week = _week
};
var trainingScheduleStructureJson = JsonConvert.SerializeObject(trainingScheduleStructure);
if (_isUpdate)
{
TrainingScheduleService.UpdateTrainingSchedule(_id, trainingScheduleStructureJson,
_week);
}
else
{
TrainingScheduleService.RegistTrainingSchedule(trainingScheduleStructureJson,
_week);
}
IsLoading = false;
await Application.Current.MainPage.DisplayAlert(LanguageUtils.Get(LanguageKeys.Complete),
LanguageUtils.Get(LanguageKeys.SaveComplete), LanguageUtils.Get(LanguageKeys.OK));
// ホーム画面をリロードする
ViewModelCommonUtil.SendMessage(ViewModelConst.MessagingTrainingPrevPageReload);
ViewModelCommonUtil.TrainingBackPage();
}
catch (Exception e)
{
Debug.WriteLine(e);
}
}
public static TrainingScheduleSViewtructure CreateTrainingScheduleSViewtructure(WeekEnum week)
{
var model = TrainingScheduleService.GetTrainingSchedule((int)week);
if (model == null)
{
var empty = new TrainingScheduleSViewtructure
{
Week = (int)week,
WeekName = week.ToString(),
Off = false
};
return(empty);
}
var trainingScheduleStructure =
JsonConvert.DeserializeObject <TrainingScheduleStructure>(model.TrainingMenu);
var trainingScheduleViewStructure = new TrainingScheduleSViewtructure
{
Week = (int)week,
WeekName = week.ToString(),
Off = trainingScheduleStructure.Off
};
var trainingListViewStructureList = new List <TrainingListViewStructure>();
int count = 1;
foreach (var training in trainingScheduleStructure.TrainingContentList)
{
var trainingListViewStructure = new TrainingListViewStructure
{
TrainingId = training.TrainingId,
TrainingNo = count,
TrainingName = TrainingMasterService.GetTrainingMasterData(training.TrainingId).TrainingName,
TrainingSetCount = training.TrainingSetCount
};
var loadContentViewStructureList = new List <LoadContentViewStructure>();
foreach (var load in training.LoadContentList)
{
var loadContentViewStructure = new LoadContentViewStructure
{
LoadId = load.LoadId,
LoadName = LoadService.GetLoad(load.LoadId).LoadName,
Nums = load.Nums.ToString(),
LoadUnitId = load.LoadUnitId,
LoadUnitName = LoadUnitService.GetLoadUnit(load.LoadUnitId).UnitName
};
loadContentViewStructureList.Add(loadContentViewStructure);
}
trainingListViewStructure.LoadContentList = loadContentViewStructureList;
trainingListViewStructureList.Add(trainingListViewStructure);
count++;
}
trainingScheduleViewStructure.TrainingContentList = trainingListViewStructureList;
return(trainingScheduleViewStructure);
}
