public static async Task <OperationsResponse> Delete(int id)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
User user = db.Users.FirstOrDefault(u => u.Id == id);
if (user != null)
{
db.Users.Remove(user);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}
));
}
public static async Task <OperationsResponse> AddPermission(int accountId, string role = "user")
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
bool checkIsExist = db.Permissions.Count() != 0 && db.Permissions.Any(el => el.AccountId == accountId);
if (!checkIsExist)
{
Permission newPermission = new Permission
{
AccountId = accountId,
Role = role
};
db.Permissions.Add(newPermission);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.UserExists;
}
}
catch (Exception e)
{
return OperationsResponse.ServerError;
}
}));
}
public static async Task <OperationsResponse> CreateUser(string login, string password)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
bool checkIsExist = db.Users.Count() != 0 && db.Users.Any(el => el.Login == login);
if (!checkIsExist)
{
User newUser = new User
{
Login = login,
HashedPassword = password
};
db.Users.Add(newUser);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.UserExists;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}));
}
public static async Task <OperationsResponse> Delete(int id)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Friend friend = db.Friends.FirstOrDefault(f => f.Id == id);
if (friend != null)
{
db.Friends.Remove(friend);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}
));
}
public static async Task <OperationsResponse> DeleteFriend(int senderId, int recipientId)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Friend friend = db.Friends.FirstOrDefault(el =>
el.SenderAccountId == senderId && el.RecipientAccountId == recipientId);
if (friend != null)
{
db.Friends.Remove(friend);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.UserNotExists;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}));
}
public static List <Role> SeedRoles(DataEntity context)
{
var courses = new List <Role>
{
new Role {
RoleName = "Admin"
},
new Role {
RoleName = "Lecturer"
},
new Role {
RoleName = "Student"
},
};
courses.ForEach(role =>
{
if (!context.Roles.Where(r => r.RoleName == role.RoleName).Any())
{
context.Roles.Add(role);
}
});
context.SaveChanges();
return(courses);
}
public static async Task <OperationsResponse> Update(Permission newPermission)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Permission permission = db.Permissions.FirstOrDefault(p => p.Id == newPermission.Id);
if (permission != null)
{
permission.AccountId = newPermission.AccountId;
permission.Role = newPermission.Role;
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}
));
}
public static async Task <OperationsResponse> UpdateAccount(int accountId, string image, string name, string email)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Account acc = db.Accounts.FirstOrDefault(el =>
el.Id == accountId);
if (acc != null)
{
acc.Image = image;
acc.Name = name;
acc.Email = email;
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.UserNotExists;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}));
}
public static List <User> SeedUsers(DataEntity context)
{
var courses = new List <User>
{
new User {
UserName = "******", Password = "******"
},
new User {
UserName = "******", Password = "******"
},
new User {
UserName = "******", Password = "******"
},
};
courses.ForEach(user =>
{
if (!context.Users.Where(u => u.UserName == user.UserName).Any())
{
context.Users.Add(user);
}
});
context.SaveChanges();
return(courses);
}
public static async Task <OperationsResponse> Update(Account newAccount)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Account account = db.Accounts.FirstOrDefault(a => a.Id == newAccount.Id);
if (account != null)
{
account.Name = newAccount.Name;
account.Image = newAccount.Image;
account.Email = newAccount.Email;
account.UserID = newAccount.UserID;
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}
));
}
public static async Task <OperationsResponse> Delete(int id)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Statistic statistic = db.Statistics.FirstOrDefault(s => s.Id == id);
if (statistic != null)
{
db.Statistics.Remove(statistic);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception e)
{
return OperationsResponse.ServerError;
}
}
));
}
public static async Task <OperationsResponse> AddDrinkInfo(int accountId, int count, DateTime date, TimeSpan time)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
bool checkIsExist = db.Accounts.Count() != 0 && db.Accounts.Any(el => el.Id == accountId);
if (checkIsExist)
{
Statistic newStatistic = new Statistic
{
AccountId = accountId,
Count = count,
Date = date,
Time = time
};
db.Statistics.Add(newStatistic);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.UserNotExists;
}
}
catch (Exception e)
{
return OperationsResponse.ServerError;
}
}));
}
public static async Task <OperationsResponse> Update(Statistic newStatistic)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Statistic statistic = db.Statistics.FirstOrDefault(s => s.Id == newStatistic.Id);
if (statistic != null)
{
statistic.AccountId = newStatistic.AccountId;
statistic.Count = newStatistic.Count;
statistic.Date = newStatistic.Date;
statistic.Time = newStatistic.Time;
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}
));
}
public static List <College> SeedColleges(DataEntity context)
{
var colleges = new List <College>
{
new College()
{
CollegeName = "College of Business and Social Sciences"
},
new College()
{
CollegeName = "College of Leadership Development Studies"
},
new College()
{
CollegeName = "College of Engineering"
},
new College()
{
CollegeName = "College of Science and Technology"
},
};
colleges.ForEach(college =>
{
if (!context.Colleges.Where(c => c.CollegeName == college.CollegeName).Any())
{
context.Colleges.Add(college);
}
});
context.SaveChanges();
return(colleges);
}
public static async Task <OperationsResponse> Delete(int id)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Account account = db.Accounts.FirstOrDefault(a => a.Id == id);
if (account != null)
{
db.Accounts.Remove(account);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}
));
}
public static async Task <OperationsResponse> Update(Friend newFriend)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
Friend friend = db.Friends.FirstOrDefault(f => f.Id == newFriend.Id);
if (friend != null)
{
friend.SenderAccountId = newFriend.SenderAccountId;
friend.RecipientAccountId = newFriend.RecipientAccountId;
friend.MessageText = newFriend.MessageText;
friend.Status = newFriend.Status;
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}
));
}
public static async Task <OperationsResponse> Update(User newUser)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
User user = db.Users.FirstOrDefault(u => u.Id == newUser.Id);
if (user != null)
{
user.Login = newUser.Login;
user.HashedPassword = newUser.HashedPassword;
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.ServerError;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}
));
}
public static List <Course> SeedCourses(DataEntity context)
{
var cengprogramme = context.Programmes.Where(c => c.ProgrammeName == "Computer Engineering").FirstOrDefault();
var courses = new List <Course>
{
new Course {
CourseCode = "CEN510", CourseName = "Digital System Design with VHDL", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "CEN511", CourseName = "Embedded System Design & Programming", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "DLD211", CourseName = "Leadership Development: Contextual Platform", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "EDS511", CourseName = "Entrepreneurial Development Studies IX", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "EIE510", CourseName = "Research Methodology", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "EIE511", CourseName = "Project Management", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "EIE512", CourseName = "Systems Reliability and Maintainability", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "EIE513", CourseName = "Cyberpreneurship and Cyber law", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "EIE515", CourseName = "Digital Signal Processing", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "EIE517", CourseName = "Applied Electronics", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "TMC511", CourseName = "Total Man Concept IX", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
new Course {
CourseCode = "TMC512", CourseName = "Total Man Concept - Sports", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Semester = "First", LevelId = 5
},
};
courses.ForEach(course =>
{
if (!context.Courses.Where(c => c.CourseName == course.CourseName).Any())
{
/*course.College = null;
* course.Programme = null;
* course.Lecturer = null;
* course.Level = null;*/
context.Courses.Add(course);
}
});
context.SaveChanges();
return(courses);
}
public static List <Lecturer> SeedLecturers(DataEntity context)
{
var cengprogramme = context.Programmes.Where(c => c.ProgrammeName == "Computer Engineering").FirstOrDefault();
var lecturers = new List <Lecturer>
{
new Lecturer {
Title = "Dr", FirstName = "Hope", LastName = "Orovwode", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Female"
},
new Lecturer {
Title = "Dr", FirstName = "Victoria", LastName = "Oguntosi", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Female"
},
new Lecturer {
Title = "Engr", FirstName = "Kennedy", LastName = "Okokpujie", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Male"
},
new Lecturer {
Title = "Dr", FirstName = "Charles", LastName = "Ndujiuba", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Male"
},
new Lecturer {
Title = "Engr", FirstName = "Nsikan", LastName = "Nkerdeh", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Male"
},
new Lecturer {
Title = "Engr", FirstName = "Osemwegie", LastName = "Omoruyi", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Male"
},
new Lecturer {
Title = "Dr", FirstName = "Sanjay", LastName = "Misra", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Female"
},
new Lecturer {
Title = "Dr", FirstName = "Joke", LastName = "Badejo", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Female"
},
new Lecturer {
Title = "Prof", FirstName = "Samuel", LastName = "Ndueso", MiddleName = "John", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Male"
},
new Lecturer {
Title = "Engr", FirstName = "Modupe", LastName = "Odusami", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Female"
},
new Lecturer {
Title = "Mrs", FirstName = "Onyinyechi", LastName = "Steve-Essi", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Male"
},
new Lecturer {
Title = "Mr", FirstName = "Jeremiah", LastName = "Abolade", MiddleName = "", CollegeId = cengprogramme.CollegeId, ProgrammeId = cengprogramme.ProgrammeId, Email = "*****@*****.**", Gender = "Male"
},
};
lecturers.ForEach(lecturer =>
{
if (!context.Lecturers.Where(c => c.FirstName == lecturer.FirstName && c.LastName == lecturer.LastName).Any())
{
context.Lecturers.Add(lecturer);
}
});
context.SaveChanges();
return(lecturers);
}
private void SaveAttendance(CurrentAttendance model)
{
var student = _db.Attendances.Where(c => c.MatricNo == model.MatricNo && c.CourseId == model.CourseId && DbFunctions.TruncateTime(c.AttendanceDate) == model.AttendanceDate.Date).AsNoTracking().FirstOrDefault();
if (student != null)
{
MessageBox.Show("This student Attendance already taken for this course on this date");
}
else
{
_db.Attendances.Add(model);
_db.SaveChanges();
}
}
public static async Task <OperationsResponse> CreateAchievement(int accountId, int achievementId)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
bool checkIsExist = db.AccountAchievements.Count() != 0 && db.AccountAchievements.Any(a => a.AccountId == accountId && a.AchievementId == achievementId);
if (!checkIsExist)
{
checkIsExist = db.Accounts.Count() != 0 && db.Accounts.Any(a => a.Id == accountId);
if (!checkIsExist)
{
return OperationsResponse.UserNotExists;
}
checkIsExist = db.Achievements.Count() != 0 && db.Achievements.Any(a => a.Id == achievementId);
if (!checkIsExist)
{
return OperationsResponse.ServerError;
}
AccountAchievement newAchievement = new AccountAchievement
{
AccountId = accountId,
AchievementId = achievementId,
Date = DateTime.Now
};
db.AccountAchievements.Add(newAchievement);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.UserExists;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}));
}
public void SaveChange()
{
try
{
context.SaveChanges();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entidade do tipo \"{0}\" no estado \"{1}\" tem os seguintes erros de validação:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Erro: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
}
public static async Task <OperationsResponse> CreateAccount(int userId, string name, string email, string image = "../Assets/AccountImages/acc_img1.jpg")
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
bool checkIsExist = db.Accounts.Count() != 0 && db.Accounts.Any(el => el.UserID == userId);
if (!checkIsExist)
{
checkIsExist = db.Users.Count() != 0 && db.Users.Any(el => el.Id == userId);
if (!checkIsExist)
{
return OperationsResponse.UserNotExists;
}
Account newAccount = new Account
{
Name = name,
Email = email,
UserID = userId,
Image = image
};
db.Accounts.Add(newAccount);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.UserExists;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}));
}
public static async Task <OperationsResponse> AddFriendRequest(int senderId, int recipientId, string message, FriendRequestStatus status = FriendRequestStatus.Pending)
{
return(await Task.Run(() =>
{
try
{
using (DataEntity db = new DataEntity())
{
bool accountExist = db.Accounts.Count() != 0 && db.Accounts.Any(a => a.Id == recipientId);
if (!accountExist)
{
return OperationsResponse.UserNotExists;
}
bool checkIsExist = db.Friends.Count() != 0 && db.Friends.Any(f => f.SenderAccountId == senderId && f.RecipientAccountId == recipientId);
if (!checkIsExist)
{
Friend newFriendRequest = new Friend
{
MessageText = message,
RecipientAccountId = recipientId,
SenderAccountId = senderId,
Status = status
};
db.Friends.Add(newFriendRequest);
db.SaveChanges();
return OperationsResponse.Ok;
}
return OperationsResponse.UserExists;
}
}
catch (Exception)
{
return OperationsResponse.ServerError;
}
}));
}
public void Add <T>(T item) where T : class
{
context.Set <T>().Add(item);
context.SaveChanges();
}
public static List <Programme> SeedProgrammes(DataEntity context)
{
var bsscollege = context.Colleges.Where(c => c.CollegeName == "College of Business and Social Sciences").FirstOrDefault();
var ldscollege = context.Colleges.Where(c => c.CollegeName == "College of Leadership Development Studies").FirstOrDefault();
var engcollege = context.Colleges.Where(c => c.CollegeName == "College of Engineering").FirstOrDefault();
var sntcollege = context.Colleges.Where(c => c.CollegeName == "College of Science and Technology").FirstOrDefault();
var programmes = new List <Programme>
{
new Programme {
ProgrammeName = "Accounting", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Banking and Finance", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Business Administration", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Industrial Relations and Human Resource Management", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Marketing", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Entrepreneurship", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Demography and Social Statistics", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Economics", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Mass Communication", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Sociology", CollegeId = bsscollege.CollegeId
},
new Programme {
ProgrammeName = "Marketing", CollegeId = ldscollege.CollegeId
},
new Programme {
ProgrammeName = "Entrepreneurship", CollegeId = ldscollege.CollegeId
},
new Programme {
ProgrammeName = "Demography and Social Statistics", CollegeId = ldscollege.CollegeId
},
new Programme {
ProgrammeName = "Economics", CollegeId = ldscollege.CollegeId
},
new Programme {
ProgrammeName = "Mass Communication", CollegeId = ldscollege.CollegeId
},
new Programme {
ProgrammeName = "Sociology", CollegeId = ldscollege.CollegeId
},
new Programme {
ProgrammeName = "Civil Engineering", CollegeId = engcollege.CollegeId
},
new Programme {
ProgrammeName = "Computer Engineering", CollegeId = engcollege.CollegeId
},
new Programme {
ProgrammeName = "Electrical and Electronics Engineering", CollegeId = engcollege.CollegeId
},
new Programme {
ProgrammeName = "Information and Communication Engineering", CollegeId = engcollege.CollegeId
},
new Programme {
ProgrammeName = "Mechanical Engineering", CollegeId = engcollege.CollegeId
},
new Programme {
ProgrammeName = "Petroleum Engineering", CollegeId = engcollege.CollegeId
},
new Programme {
ProgrammeName = "Chemical Engineering", CollegeId = engcollege.CollegeId
},
new Programme {
ProgrammeName = "Architecture", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Building Technology", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Estate Management", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Applied Biology and Biotechnology", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Biochemistry", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Microbiology", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Chemistry", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Computer Science", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Management Information System", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Industrial Mathematics", CollegeId = sntcollege.CollegeId
},
new Programme {
ProgrammeName = "Industrial Physics", CollegeId = sntcollege.CollegeId
},
};
programmes.ForEach(programme =>
{
if (!context.Programmes.Where(p => p.ProgrammeName == programme.ProgrammeName).Any())
{
context.Programmes.Add(programme);
}
});
context.SaveChanges();
return(programmes);
}
