public bool UpdateWord(Word updatedWord)
{
try
{
using (HangmanContext context = new HangmanContext())
{
Word word = context.Words.FirstOrDefault(w => w.WordID == updatedWord.WordID);
word = updatedWord;
context.SaveChanges();
}
return(true);
}
catch (Exception ex)
{
string path = HttpContext.Current.Server.MapPath("~/Logs");
if (!System.IO.Directory.Exists(path))
{
System.IO.Directory.CreateDirectory(path);
}
System.IO.File.AppendAllText(System.IO.Path.Combine(path, "Words.txt"), "Error: " + DateTime.Now.ToString() + " " + ex.ToString() + Environment.NewLine);
return(false);
}
}
public bool AddEntry(Review entry)
{
try
{
using (HangmanContext context = new HangmanContext())
{
entry.DateCreated = DateTime.Now;
entry.IsApproved = true;
context.Reviews.Add(entry);
context.SaveChanges();
}
return(true);
}
catch (Exception ex)
{
string path = HttpContext.Current.Server.MapPath("~/Logs");
if (!System.IO.Directory.Exists(path))
{
System.IO.Directory.CreateDirectory(path);
}
System.IO.File.AppendAllText(System.IO.Path.Combine(path, "Review.txt"), "Error: " + DateTime.Now.ToString() + " " + ex.ToString() + Environment.NewLine);
return(false);
}
}
public void AddScoreBoard(ScoreBoard scoreBoard)
{
using (var context = new HangmanContext())
{
context.ScoreBoards.Add(scoreBoard);
context.SaveChanges();
}
}
public void Update(Player entity)
{
using (var context = new HangmanContext())
{
context.Entry(entity).State = EntityState.Modified;
context.SaveChanges();
}
}
public void Delete(int key)
{
using (var context = new HangmanContext())
{
var entity = context.Players.Find(key);
context.Players.Remove(entity);
context.SaveChanges();
}
}
public List <Player> GetAll()
{
List <Player> list;
using (var context = new HangmanContext())
{
list = context.Players.Include(z => z.ScoreBoards).ToList();
}
return(list);
}
public Player Get(int key)
{
Player entity;
using (var context = new HangmanContext())
{
entity = context.Players.Where(z => z.PlayerId == key).Include(z => z.ScoreBoards).FirstOrDefault();
}
return(entity);
}
public static int RegisterAccount(Account account)
{
using (HangmanContext context = new HangmanContext())
{
context.Accounts.Add(account);
context.SaveChanges();
}
return(account.AccountID);
}
public Player GetByUserName(string userName)
{
Player entity;
using (var context = new HangmanContext())
{
entity = context.Players.Where(z => z.Name == userName).Include(z => z.ScoreBoards).FirstOrDefault();
}
return(entity);
}
public List <Subject> GetAllSubjects()
{
List <Subject> list;
using (var context = new HangmanContext())
{
list = context.Subjects.Include(e => e.Words).ToList();
}
return(list);
}
public static IEnumerable <Account> GetAllAccounts()
{
IEnumerable <Account> accounts;
using (HangmanContext context = new HangmanContext())
{
accounts = context.Accounts.AsEnumerable().ToList();
}
return(accounts);
}
public IEnumerable <Level> GetAllLevels()
{
IEnumerable <Level> allLevels;
using (HangmanContext context = new HangmanContext())
{
allLevels = context.Levels.OrderBy(l => l.Name).ToList();
}
return(allLevels);
}
public IEnumerable <Category> GetAllCategories()
{
IEnumerable <Category> allCategories;
using (HangmanContext context = new HangmanContext())
{
allCategories = context.Categories.OrderBy(l => l.Name).ToList();
}
return(allCategories);
}
public static bool ValidateAccount(string email, string password)
{
bool isSuccess = false;
using (HangmanContext context = new HangmanContext())
{
isSuccess = context.Accounts.FirstOrDefault(a => a.Email.ToLower() == email.ToLower() && (string.Compare(a.Password, password, false) == 0)) != null;
}
return(isSuccess);
}
public IEnumerable <Language> GetAllLanguages()
{
IEnumerable <Language> allLanguages;
using (HangmanContext context = new HangmanContext())
{
allLanguages = context.Languages.OrderBy(l => l.Name).ToList();
}
return(allLanguages);
}
public static int GetRoleID(string roleName)
{
int roleID = 0;
using (HangmanContext context = new HangmanContext())
{
roleID = context.Roles.FirstOrDefault(r => r.Name.ToLower() == roleName.ToLower()).RoleID;
}
return(roleID);
}
public static Account GetUserObjByEmail(string email)
{
Account account = new Account();
using (HangmanContext context = new HangmanContext())
{
account = context.Accounts.SingleOrDefault(u => u.Email == email);
}
return(account);
}
public static Account GetUserObjByEmail(string email, string passWord)
{
Account account = new Account();
using (HangmanContext context = new HangmanContext())
{
account = context.Accounts.SingleOrDefault(a => a.Email == email && a.Password == passWord);
}
return(account);
}
public WordHelp GetHelpForWord(int wordID)
{
WordHelp help;
using (HangmanContext context = new HangmanContext())
{
help = context.WordHelps.FirstOrDefault(h => h.WordID == wordID);
}
return(help);
}
public IEnumerable <Review> GetAllEntries()
{
IEnumerable <Review> guestBookEntries = new List <Review>();
using (HangmanContext context = new HangmanContext())
{
guestBookEntries = context.Reviews.ToList();
}
return(guestBookEntries);
}
public int Add(Player entity)
{
var key = 0;
using (var context = new HangmanContext())
{
context.Players.Add(entity);
context.SaveChanges();
key = entity.PlayerId;
}
return(key);
}
public ThemeDtoValidators(HangmanContext context)
{
_context = context;
RuleSet("PreValidation", () =>
{
RuleFor(x => x.Theme).NotNull().MinimumLength(3).WithMessage("Field Word is invalid");
});
RuleSet("PostValidation", () =>
{
RuleFor(x => x.Theme).Must(CheckDuplicate).MinimumLength(1).WithMessage("Theme is exist Database");
});
}
public IEnumerable <Account> GetAllAccounts(Func <Account, bool> filter = null)
{
IEnumerable <Account> accounts;
using (HangmanContext context = new HangmanContext())
{
if (filter == null)
{
filter = r => true;
}
accounts = context.Accounts.Where(filter).ToList();
}
return(accounts);
}
public IEnumerable <Review> GetAllReviews(Func <Review, bool> filter = null)
{
IEnumerable <Review> reviews;
using (HangmanContext context = new HangmanContext())
{
if (filter == null)
{
filter = r => true;
}
reviews = context.Reviews.Where(filter).ToList();
}
return(reviews);
}
public IEnumerable <Word> GetAllWords(Func <Word, bool> filter = null)
{
IEnumerable <Word> words;
using (HangmanContext context = new HangmanContext())
{
if (filter == null)
{
filter = w => true;
}
words = context.Words.Where(filter).ToList();
}
return(words);
}
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new HangmanContext(
serviceProvider.GetRequiredService <
DbContextOptions <HangmanContext> >()))
{
// Look for any Words
if (context.WordInfos.Any())
{
return; // DB has been seeded
}
context.WordInfos.AddRange(
new WordInfo
{
Word = "Test",
DateSubmitted = DateTime.MaxValue,
IsApproved = true,
Language = new Language
{
Games = new List <Game>(),
LanguageId = 0,
LanguageName = "Java",
Letters = new List <LetterInfo>(),
Words = new List <WordInfo>()
},
LanguageId = 0,
Submitter = new User
{
Games = new List <Game>(),
IsAdmin = true,
Mail = "*****@*****.**",
Password = "******",
UserId = 1,
Username = "******",
WordApprovals = new List <WordApproval>(),
Words = new List <WordInfo>()
},
SubmitterId = 1,
WordApprovals = new List <WordApproval>(),
WordId = 0,
WordInGames = new List <WordInGame>()
}
);
context.SaveChanges();
}
}
public int SaveResult(HangmanResult result)
{
try
{
using (HangmanContext context = new HangmanContext())
{
if (result.ResultID == 0)
{
result.PlayDate = DateTime.Now;
context.HangmanResults.Add(result);
context.SaveChanges();
}
else
{
HangmanResult updateResult = context.HangmanResults.FirstOrDefault(r => r.ResultID == result.ResultID);
updateResult.PlayDate = DateTime.Now;
updateResult.WrongAssumption = result.WrongAssumption;
updateResult.IsWinner = result.IsWinner;
if (result.WordID != 0)
{
updateResult.WordID = result.WordID;
}
context.SaveChanges();
}
}
return(result.ResultID);
}
catch (Exception ex)
{
string path = HttpContext.Current.Server.MapPath("~/Logs");
if (!System.IO.Directory.Exists(path))
{
System.IO.Directory.CreateDirectory(path);
}
System.IO.File.AppendAllText(System.IO.Path.Combine(path, "Hangman.txt"), "Error: " + DateTime.Now.ToString() + " " + ex.ToString() + Environment.NewLine);
return(0);
}
}
public virtual IEnumerable <ResultViewModel> GetPersonalStatistics(string email)
{
IEnumerable <ResultViewModel> results;
using (HangmanContext context = new HangmanContext())
{
results = context.HangmanResults.Where(w => w.Email.ToLower() == email.ToLower()).Select(r => new ResultViewModel
{
Category = r.Word.Category.Name,
Language = r.Word.Language.Name,
Level = r.Word.Level.Name,
WordName = r.Word.Name,
WrongAssumption = r.WrongAssumption,
PlayDate = r.PlayDate,
IsWinner = r.IsWinner
}).ToList();
}
return(results);
}
public Word GetRandomWord(Func <Word, bool> filter = null)
{
if (filter == null)
{
filter = w => true;
}
Word word = new Word();
using (HangmanContext context = new HangmanContext())
{
IQueryable <Word> records = context.Words.Where(filter).OrderBy(w => Guid.NewGuid()).AsQueryable();
// Random random = new Random();
// int selectRow = random.Next(0, records.Count());
word = records.FirstOrDefault();
}
return(word);
}
public UserStatisticsDtoValidators(HangmanContext context)
{
_context = context;
RuleSet("PreValidation", () =>
{
RuleFor(x => x.LossCount).NotNull().WithMessage("field LossCount is invalid");
RuleFor(x => x.Score).NotNull().WithMessage("field Score is invalid");
RuleFor(x => x.StatisticsId).NotNull().WithMessage("field StatisticsId is invalid");
RuleFor(x => x.WinCount).NotNull().WithMessage("field WinCount is invalid");
RuleFor(x => x.IsWin).NotNull().WithMessage("field WinCount is invalid");
});
RuleSet("PostValidation", () =>
{
RuleFor(x => x.LossCount).NotNull().WithMessage("field LossCount is invalid");
RuleFor(x => x.Score).NotNull().WithMessage("field Score is invalid");
RuleFor(x => x.StatisticsId).NotNull().WithMessage("field StatisticsId is invalid");
RuleFor(x => x.WinCount).NotNull().WithMessage("field WinCount is invalid");
RuleFor(x => x.IsWin).NotNull().WithMessage("field WinCount is invalid");
});
}
