public void CanCreateNewExerciseType()
{
using (var repository = new ExerciseTypeRepository())
{
var allBeforeItems = repository.FindAll();
var beforeCount = allBeforeItems.Count();
var exerciseType = new ExerciseType
{
Created = DateTime.Now,
CreatedBy = null,
ExerciseName = "CanCreateNewExerciseType",
MetricType = Domain.Entities.MetricType.WEIGHT,
Modified = DateTime.Now
};
repository.Create(exerciseType);
repository.Save();
var allAfterItems = repository.FindAll();
var afterCount = allAfterItems.Count();
Assert.IsTrue(beforeCount == (afterCount - 1));
var item = allAfterItems.Last();
repository.Delete(item);
repository.Save();
allAfterItems = repository.FindAll();
afterCount = allAfterItems.Count();
Assert.IsTrue(beforeCount == (afterCount));
}
}
public ExerciseModel(ExerciseType exerciseType, int firstNumber, int secondNumber, int result)
{
FirstNumber = firstNumber;
SecondNumber = secondNumber;
Result = result;
ExerciseType = exerciseType;
}
public ActionResult GetWorkoutType(string exerciseName)
{
var exercise = new ExerciseType {
ExerciseName = exerciseName,
MetricType = Domain.Entities.MetricType.DISTANCE,
ExerciseTypeId = 1
};
return new JsonActionResult(exercise, JsonRequestBehavior.AllowGet);
}
public ActionResult IsValid(ExerciseType exerciseType)
{
if (exerciseType != null)
{
var service = new ExerciseTypeService(Common.Constants.Database.DBKey);
if (!service.ExerciseExists(exerciseType))
return new HttpStatusCodeResult(200);
else
return new HttpStatusCodeResult(400, "Exercise type already exists");
}
return new HttpStatusCodeResult(500);
}
public bool ExerciseExists(ExerciseType exercise)
{
if (exercise == null || string.IsNullOrEmpty(exercise.ExerciseName)) return false;
using(var repo = new ExerciseTypeRepository(_dbKey))
{
var matcingExercises = repo.Find(dbExc =>
dbExc.ExerciseName.Equals(exercise.ExerciseName.Trim(), StringComparison.OrdinalIgnoreCase)
&&
dbExc.MetricType == exercise.MetricType
);
if (matcingExercises != null && matcingExercises.Count() > 0)
return true;
}
return false;
}
public ActionResult Add(ExerciseType exerciseType)
{
if(exerciseType != null)
{
var service = new ExerciseTypeService(Common.Constants.Database.DBKey);
try
{
service.AddNewExercise(exerciseType);
}
catch(ExerciseTypeAlreadyExists)
{
return new HttpStatusCodeResult(400, "Exercise type already exists");
}
catch(InvalidExerciseType)
{
return new HttpStatusCodeResult(400, "Invalid exercise type");
}
return new HttpStatusCodeResult(200);
}
return new HttpStatusCodeResult(500);
}
public void AddNewExercise(ExerciseType exercise)
{
if (exercise == null || string.IsNullOrEmpty(exercise.ExerciseName) || exercise.MetricType == Domain.Entities.MetricType.ERROR)
throw new InvalidExerciseType();
using (var repo = new ExerciseTypeRepository(_dbKey))
{
var matcingExercises = repo.Find(dbExc =>
dbExc.ExerciseName.Equals(exercise.ExerciseName.Trim(), StringComparison.OrdinalIgnoreCase)
&&
dbExc.MetricType == exercise.MetricType
);
if (matcingExercises != null && matcingExercises.Count() > 0)
throw new ExerciseTypeAlreadyExists();
exercise.Created = DateTime.Now;
exercise.Modified = DateTime.Now;
exercise.CreatedBy = null; // todo
repo.Create(exercise);
repo.Save();
}
}
private static bool ShowUserExercises(User user, ExerciseType exerciseType)
{
List <Exercise> exercises = exerciseController.GetUserExercises(user, exerciseType);
Console.WriteLine("[Список упражнений]");
if (exercises.Count < 1)
{
Console.WriteLine("Пусто.");
return(true);
}
for (int index = 0; index < exercises.Count; index++)
{
int number = index + 1;
Exercise exercise = exercises[index];
string exerciseAddedDate = exercise.Added.ToString("d");
switch (exerciseType)
{
case ExerciseType.ForAllTime:
Console.WriteLine($"{number}.{exercise.Name} - {exerciseAddedDate}");
break;
case ExerciseType.ForToday:
Console.WriteLine($"{number}.{exercise.Name}");
break;
}
}
Console.WriteLine();
return(false);
}
public static async Task <MultipleAttributes> LoadReps(MultipleAttributes ma)
{
//Clarify the attributes
Grid gridForm = ma.grid;
int currentRow = Grid.GetRow(gridForm.Children[0]);
ExerciseType selectedType = ma.type;
string repeatableLblText = ma.text;
Button btnAddRep = ma.btn;
for (int i = 0; i < selectedType.Reps.Count; i++)
{
selectedType.Reps[i].Index = i;
++currentRow;
gridForm.Children.Add(NewGridLabel(0, currentRow, repeatableLblText));
//Fill in each rep entry
Entry tempEntry = NewGridRepEntry(1, currentRow, null);
tempEntry.Text = selectedType.Reps[i].Amount;
gridForm.Children.Add(tempEntry);
gridForm = await AddDeleteButton(currentRow, gridForm, selectedType, btnAddRep);
//Move add button down with the new row
Grid.SetRow(btnAddRep, currentRow);
}
//Save changes back to class and return it
ma.grid = gridForm;
ma.num = currentRow;
ma.type = selectedType;
ma.text = repeatableLblText;
ma.btn = btnAddRep;
return(ma);
}
public Exercise Create(ExerciseType type, List <IdiomInCollection> idioms)
{
var args = (
type,
description : ExerciseDescriptions[type],
idioms,
factory : new QuestionFactory()
);
switch (type)
{
case ExerciseType.A:
case ExerciseType.C:
case ExerciseType.D:
case ExerciseType.E:
return(new Exercise(args));
case ExerciseType.B:
return(new ExerciseTypeB(args, new Randomizer()));
default:
throw new Exception("Unknown exercise type: " + type);
}
}
public DurationSet(ExerciseType exerciseType, int order) : base(exerciseType, order)
{
}
public Request(ExerciseType exerciseType, string name, string?imageRef)
{
this.ExerciseType = exerciseType;
this.Name = name;
this.ImageRef = imageRef;
}
public EventAction(string desctiprion, ExerciseType exercise_code)
{
Description = desctiprion;
this.ExerciseCode = exercise_code;
}
public IList <Exercise> Load(ExerciseType input)
{
return(_exerciseRepository.Where(new ExerciseTypeQuery(input)));
}
public void Create(ExerciseType entity)
{
repository.Create(entity);
}
public ExerciseView(MainWindow mainWindow, ExerciseType exerciseType)
{
this.mainWindow = mainWindow;
InitializeComponent();
ExerciseController = new ExerciseController(this, exerciseType);
}
private void AddExercise(ExerciseType type, List <IdiomInCollection> idioms)
{
this.Exercises.Add(exerciseFactory.Create(type, idioms));
}
public static bool TryParse(string exportedString, out ExerciseType exerciseType, bool ignoreCase = true)
{
return(Enum.TryParse(exportedString, ignoreCase, out exerciseType));
}
/// <summary>
/// Gets the 2-D lifts array.
/// </summary>
/// <param name="exerciseType">The exercise type.</param>
/// <param name="level">The player level.</param>
/// <returns>The 2-D array of maxes.</returns>
public int GetLiftFromLevel(ExerciseType exerciseType, int level)
{
return(MaxArray[(int)exerciseType, level]);
}
public UpdateExerciseCommand(int id, string description, ExerciseType type)
{
Id = id;
Description = description;
Type = type;
}
public IntervalSet(ExerciseType exerciseType, int order) : base(exerciseType, order)
{
}
public Accessory(ExerciseType type) : base(GetWeight(type))
{
_type = type;
}
public AddExerciseCommand(string description, ExerciseType type)
{
Description = description;
Type = type;
}
private void TransformSets(IEnumerable <Domain.Entities.TrainingLog.Set> sets, ExerciseType type, UserSetting settings)
{
foreach (var set in sets)
{
set.TransformSet(type, settings);
}
}
public Deadlift(double weight, ExerciseType type) : base(weight)
{
_type = type;
}
/// <summary>
/// 获得问题集合
/// </summary>
/// <param name="driverId">驾驶证类型</param>
/// <param name="provinceId">省份</param>
/// <param name="qt">问题类型,选择题或者判断题,Null:说明包含全部题</param>
/// <param name="categoryId">类别ID,可以是多个类别</param>
/// <returns></returns>
public static IList <ExamQuestion> GetExamQuestionList(int driverId, string categories, QuestionType qt, ExerciseType et)
{
string[] _categoryArray = categories.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
List <int> _categoryList = new List <int>();
IList <ExamQuestion> examQuestionList = new List <ExamQuestion>();
ExamQuestion examQuestion = null;
StringBuilder sbSql = new StringBuilder();
sbSql.AppendFormat(" SELECT {0} ", EXAMQUESTIONFILEDLIST);
sbSql.Append(" FROM ExamQuestion ");
sbSql.Append(" INNER JOIN ( ");
//判断是否根据用户选择分类来获取问题
foreach (string s in _categoryArray)
{
if (Utils.IsInt(s))
{
int __i = Convert.ToInt32(s);
if (__i > 0 && __i < 100)
{
//把0和分类ID大于100的排除掉
//因为总的分类ID也超不过100
_categoryList.Add(__i);
}
}
}
if (_categoryList.Count > 0)
{
sbSql.Append(ExamCategoryRepository.GetCategoryUnionAllTable(_categoryList));
}
else
{
sbSql.Append(ExamCategoryRepository.GetCategoryTableStringByDriverType(driverId));
}
sbSql.Append(" ) AS CategoryList ");
sbSql.Append(" ON ExamQuestion.CategoryID = CategoryList.CID ");
sbSql.Append(" WHERE 1 = 1 ");
switch (driverId)
{
case 1: //小车
case 2: //客车专用
case 3: //货车专用
case 4: //吊车电瓶车
case 5: //地方试题
sbSql.Append(" AND ExamQuestion.QuestionLibrary = 1 ");
break;
case 6: //摩托车
sbSql.Append(" AND ExamQuestion.QuestionLibrary = 2 ");
break;
}
if (qt == QuestionType.Choice)
{
sbSql.Append(" AND ExamQuestion.QuestionType = 1 ");
}
if (qt == QuestionType.Judgmeng)
{
sbSql.Append(" AND ExamQuestion.QuestionType = 2 ");
}
if (et == ExerciseType.Random)
{
sbSql.Append(" ORDER BY NEWID() ");
}
using (SqlDataReader dr = SqlHelper.ExecuteReader(CommandType.Text, sbSql.ToString()))
{
while (dr.Read())
{
examQuestion = GetExamQuestionByQuestionId(Convert.ToInt32(dr["QuestionID"]));
examQuestionList.Add(examQuestion);
}
}
return(examQuestionList);
}
public List <Sprite> GetSpritesForExercise(ExerciseType exerciseType)
{
return(listOfExerciseSpriteLists[(int)exerciseType]);
}
private bool TypeExists(ExerciseType type)
{
return(Enum.IsDefined(typeof(ExerciseType), type));
}
public void Add(ExerciseType exerciseType)
{
_exerciseTypeDal.Add(exerciseType);
}
public LocalizedExerciseType(ExerciseType ExerciseType)
{
this.exerciseType = ExerciseType;
}
public void Delete(ExerciseType exerciseType)
{
_exerciseTypeDal.Delete(exerciseType);
}
public void Update(ExerciseType entity)
{
repository.Update(entity);
}
public void Update(ExerciseType exerciseType)
{
_exerciseTypeDal.Update(exerciseType);
}
private static bool GetExerciseType(string exerciseTypeString, bool throwExceptions, out ExerciseType exerciseType)
{
if (throwExceptions)
{
exerciseType = ExerciseTypeExtensions.Parse(exerciseTypeString);
}
else
{
if (!ExerciseTypeExtensions.TryParse(exerciseTypeString, out exerciseType))
{
return(false);
}
}
return(true);
}
public ExerciseTypeQuery(ExerciseType exerciseType)
{
_exerciseType = exerciseType;
}
public ExerciseType GetExerciseTypeById(int id)
{
ExerciseType exerciseType = _context.ExerciseTypes.Find(id);
return(exerciseType);
}
public StrengthSet(ExerciseType exerciseType, int order) : base(exerciseType, order)
{
}
public Deadlift(ExerciseType type) : base(Stats.Deadlift)
{
_type = type;
}
public Exercise(ExerciseType exerciseType, string Name)
{
this.ExerciseType = exerciseType;
this.Name = Name;
}
