public void StartLevel(string lvlName)
{
LevelViewModel level = levels.Where(lvl => lvl.Name == lvlName).FirstOrDefault();
level.Init(width, height);
CurrentView = level;
}
public List <LevelViewModel> GetAllLevels()
{
string connectionString = "server=localhost;uid=root;password=Reset1234;database=OnlineTestManagement;";
List <LevelViewModel> model = new List <LevelViewModel>();
string queryString =
"SELECT * FROM OnlineTestManagement.Level;";
using (MySqlConnection connection =
new MySqlConnection(connectionString))
{
MySqlCommand command =
new MySqlCommand(queryString, connection);
connection.Open();
MySqlDataReader reader = command.ExecuteReader();
// Call Read before accessing data.
while (reader.Read())
{
LevelViewModel obj = new LevelViewModel();
obj.Id = (int)reader[0];
obj.Value = reader[1].ToString();
model.Add(obj);
}
// Call Close when done reading.
connection.Close();
}
return(model);
}
public Grid(LevelViewModel level, int x, int y)
{
levelVM = level;
xSize = x;
ySize = y;
DrawGrid();
}
public static void ReadLevelSubjects(ObservableCollection <LevelViewModel> levels, ObservableCollection <SubjectViewModel> subjects, int year)
{
using (SqlConnection connection = new SqlConnection(Settings.Default.SQLConnection))
{
connection.Open();
using (SqlCommand command = new SqlCommand($"SELECT * FROM [LevelSubject] WHERE Year = {year}", connection))
{
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
int idLevel = (int)reader["IdLevel"];
LevelViewModel level = levels.FirstOrDefault(l => l.Id == idLevel);
if (level != null)
{
int idSubject = (int)reader["IdSubject"];
SubjectViewModel subject = subjects.FirstOrDefault(s => s.Id == idSubject);
if (subject != null)
{
level.Subjects.Add(subject);
subject.Levels.Add(level);
}
}
}
}
}
}
}
private LevelViewModel GetNextLevel()
{
Level currentLevel = (Level)level;
LevelViewModel result = new LevelViewModel(currentLevel);
BaseGame baseGame = new BaseGame();
using (var db = new GameContext())
{
switch (currentLevel.RuleMode)
{
case "RuleAddition":
GameAddition additionLevel = db.GamesAddition.Single(p => p.BeginRange == currentLevel.BeginRange &&
p.EndRange == currentLevel.EndRange);
baseGame = db.GamesAddition.Single(p => p.GameAdditionId == (additionLevel.GameAdditionId + 1));
break;
case "RuleMultiplication":
GameMultiplication multiplicationLevel = db.GamesMultiplication.Single(p => p.BeginRange == currentLevel.BeginRange &&
p.EndRange == currentLevel.EndRange);
baseGame = db.GamesMultiplication.Single(p => p.GameMultiplicationId == (multiplicationLevel.GameMultiplicationId + 1));
break;
default:
break;
}
}
if (baseGame != new BaseGame())
{
Level nextLevel = new Level(baseGame.IsOpen, baseGame.Raiting, baseGame.BeginRange, baseGame.EndRange);
result = new LevelViewModel(nextLevel);
}
return(result);
}
public async Task <IActionResult> Create([FromForm] LevelViewModel request)
{
var result = _mapper.Map <Level>(request);
var levels = await _levelRepositoryAsync.AddAsync(result);
return(Ok(levels));
}
private void RollHitDie(LevelViewModel levelView)
{
if (Int32.TryParse(levelView.HitDie.Replace("d", ""), out int hitDie))
{
levelView.HitDieRestRoll = _diceService.RandomNumber(1, hitDie);
UpdateTotal();
}
}
public async Task UpdateLevel(int Id, LevelViewModel level)
{
var result = await GetByIdAsync(Id);
result.sign = level.sign;
result.name = level.name;
await UpdateAsync(result);
}
private List <string> GetAllPropertyNameOfLevelViewModel()
{
var levelViewModel = new LevelViewModel();
var type = levelViewModel.GetType();
return(ReflectionUtilities.GetAllPropertyNamesOfType(type));
}
public LevelSelectPage(LevelViewModel lvlVM)
{
InitializeComponent();
IsBusy = false;
firstLoaded = true;
vm = lvlVM;
listLevels.ItemsSource = vm.Levels;
listLevels.ItemClickCommand = ItemClickCommand;
}
public static void PutOne(int id, LevelViewModel levelModel)
{
using (var context = new FinalSchool())
{
var level = context.Levels.Find(id);
level.Name = levelModel.Name;
context.SaveChanges();
}
}
public void PaintShape(LevelViewModel level)
{
this.levelVM = level;
levelGridXSize = level.GridWidth;
levelGridYSize = level.GridHeight;
yPos = (yIndex + level.GridHeight) * level.CellSize;
xPos = (xIndex + level.GridWidth) * level.CellSize;
GenerateShape(matrix);
}
public async Task <IActionResult> Index()
{
var levels = await _levelService.GetAllAsync();
var viewModel = new LevelViewModel
{
EmployeeLevels = levels
};
return(View(viewModel));
}
private static void CreateLevelSubjects(MainViewModel mainViewModel, int year)
{
foreach (LevelViewModel _level in MainViewModel.Instance.Parameters.Levels)
{
LevelViewModel level = mainViewModel.Parameters.Levels.FirstOrDefault(l => l.Name == _level.Name);
foreach (SubjectViewModel subject in _level.Subjects)
{
level.Subjects.Add(mainViewModel.Parameters.Subjects.FirstOrDefault(s => s.Name == subject.Name));
}
LevelSubjectModel.SaveLevelSubjects(level);
}
}
public static LevelViewModel GetOne(int id)
{
using (var context = new FinalSchool())
{
var level = context.Levels.Find(id);
var levelModel = new LevelViewModel()
{
Name = level.Name
};
return(levelModel);
}
}
public ShortRestViewModel(List <LevelModel> levelModels, int conModifier)
{
foreach (LevelModel level in levelModels)
{
LevelViewModel levelView = new LevelViewModel(level);
levelView.PropertyChanged += LevelView_PropertyChanged;
_levelViewModels.Add(levelView);
}
_conModifier = conModifier;
_rollHitDieCommand = new RelayCommand(obj => true, obj => RollHitDie((LevelViewModel)obj));
}
public void ProcessUnlockedChange(LevelViewModel changedLvl)
{
var disabled = !changedLvl.IsUnlocked;
// If the level is branched we need to unlock the previous levels
if (changedLvl.Branched)
{
var prevLev = Levels[Levels.FindItemIndex(x => x == changedLvl) - 1];
Levels[prevLev.Link].IsUnlocked = true;
return;
}
bool reachedItem = false;
// Update normal levels
foreach (LevelViewModel lvl in Levels)
{
// Skip branched and linked levels
if (lvl.Branched || lvl.Link != -1)
{
continue;
}
if (reachedItem && disabled)
{
lvl.SetIsUnlocked(false);
}
if (lvl == changedLvl)
{
reachedItem = true;
}
if (!reachedItem && !disabled)
{
lvl.SetIsUnlocked(true);
}
}
// Update linked levels
foreach (LevelViewModel lvl in Levels.Where(x => x.Link != -1))
{
var isUnlocked = Levels[lvl.Link].IsUnlocked;
lvl.SetIsUnlocked(isUnlocked);
// If we lock a linked level we also have to lock the next level which is always the branched one
if (!isUnlocked)
{
Levels[Levels.FindItemIndex(x => x == lvl) + 1].SetIsUnlocked(false);
}
}
}
public static int GetLevelByName(string levelName)
{
using (var context = new FinalSchool())
{
var level = context.Levels.FirstOrDefault(x => x.Name == levelName);
var levelview = new LevelViewModel()
{
Name = level.Name,
LevelId = level.LevelId,
};
return(levelview.LevelId);
}
}
public static int PostOne(LevelViewModel levelModel)
{
using (var context = new FinalSchool())
{
var level = new Level()
{
Name = levelModel.Name, LevelId = levelModel.LevelId
};
context.Levels.Add(level);
context.SaveChanges();
return(level.LevelId);
}
}
public ActionResult UpdateLevel(LevelViewModel newLevelData)
{
Level level = new Level()
{
Year = newLevelData.Year,
Semester = newLevelData.Semester,
Description = newLevelData.Description,
InsertedDate = DateTime.Now
};
levelService.UpdateLevel(level);
return(RedirectToAction("Index"));
}
public ActionResult Edit(int LevelID)
{
Level level = levelService.GetLevelById(LevelID);
LevelViewModel levelViewModel = new LevelViewModel()
{
LevelID = level.LevelID,
Year = level.Year,
Semester = level.Semester,
Description = level.Description,
};
return(View(levelViewModel));
}
public ActionResult SaveLevel(LevelViewModel levelData)
{
levelService = new LevelService();
Level Level = new Level()
{
Year = levelData.Year,
Semester = levelData.Semester,
Description = levelData.Description,
InsertedDate = DateTime.Now,
};
levelService.SaveLevel(Level);
return(View(levelData));
}
public ScientificWorkViewModel(ScientificWork scientificWork) : this()
{
if (scientificWork != null)
{
Id = scientificWork.Id;
Name = scientificWork.Name;
Content = scientificWork.Content;
Time = scientificWork.Time;
Level = new LevelViewModel(scientificWork.Level);
Lecturers = GetLecturer(scientificWork);
//User = new UserViewModel(scientificWork.User);
//Lecturer = new LecturerViewModel;
}
}
public void Then_The_Title_Is_Code_And_Name_Combined(Level level)
{
// Arrange
var levelViewModel = new LevelViewModel
{
Name = level.Name,
Code = level.Code
};
// Act
var actual = levelViewModel.Title;
// Assert
actual.Should().Be("Level " + levelViewModel.Code + " - " + levelViewModel.Name);
}
public async Task <IActionResult> Add(LevelViewModel model, CancellationToken token)
{
var result = await _mediatr.Process(new CreateLevelCommand(await GetRequestUserAsync(token))
{
Name = model.Name,
RequiredPoints = model.RequiredPoints,
}, token);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Exception.Message);
return(View(model));
}
return(RedirectToAction("Edit", new { id = result.Data }));
}
public ActionResult Update(int id, [FromBody] LevelViewModel level)
{
if (level.Id != id)
{
return(BadRequest());
}
if (!_repo.ExistsEntity(id))
{
return(NotFound());
}
_repo.Update(_mapper.Map <Level>(level));
return(NoContent());
}
public List <LevelViewModel> GetLevel()
{
IQueryable <Level> levels = unitOfWork.Repository <Level>().GetAll();
List <LevelViewModel> levelViewModels = new List <LevelViewModel>();
foreach (Level leval in levels)
{
LevelViewModel levelViewModel = new LevelViewModel()
{
Id = leval.Id,
Name = leval.Name
};
levelViewModels.Add(levelViewModel);
}
return(levelViewModels);
}
private void LoadLevels()
{
//LevelViewModel level1 = new LevelViewModel(this, 5, 5, GetPuzzlePiecesForLevel1(), "Level 1", "None");
LevelViewModel level1 = new LevelViewModel(this, 6, 6, GetPuzzlePiecesForLevel1(), "Level 1", "None");
LevelWithUnionViewModel level2 = new LevelWithUnionViewModel(this, 5, 5, GetPuzzlePiecesForLevel2(), "Level 2", "Union");
//LevelViewModel level2 = new LevelViewModel(this, 5, 5, GetPuzzlePiecesForLevel2(), "Level 2");
//LevelViewModel level3 = new LevelViewModel(this, 6, 6, GetPuzzlePiecesForLevel3(), "Level 3");
//LevelViewModel level4 = new LevelViewModel(this, 10, 10, GetPuzzlePiecesForLevel4(), "Level 4");
//levels.Add(level1);
levels.Add(level1);
levels.Add(level2);
//levels.Add(level3);
//levels.Add(level4);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var param = e.Parameter as EndEventArgs;
level = param.level;
title.Text = param.IsWin ? "You Win" : "You Lose";
if (param.IsWin)
{
next_play.Visibility = Visibility.Visible;
}
else
{
next_play.Visibility = Visibility.Collapsed;
}
score.Text = "Score: " + (param.Time.TotalSeconds * 10).ToString();
gameMode = param.GameMode;
}
public async Task <IActionResult> Edit(LevelViewModel model, CancellationToken token)
{
var result = await _mediatr.Process(new UpdateLevelCommand(await GetRequestUserAsync(token))
{
LevelId = model.Id,
Name = model.Name,
RequiredPoints = model.RequiredPoints
}, token);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Exception.Message);
return(View(model));
}
return(RedirectToAction("Index"));
}
public ObjectManager(LevelViewModel levelViewModel)
{
_levelViewModel = levelViewModel;
_defs = new ObjectDefinitions(this);
}
