public async Task RateTheSubject(UserSubjectDTO ratedSubject)
{
UserSubject subj = _mapper.Map <UserSubject>(ratedSubject);
await _unitOfWork.Users.RateTheSubject(subj);
await _unitOfWork.SaveAsync();
}
public IHttpActionResult FollowSubject([FromUri] string AccessToken, [FromUri] int SubjectId)
{
var UserId = TokenValidator.VerifyToken(AccessToken);
var Subject = SQLContext.Subjects.Find(SubjectId);
if (Subject == null)
{
return(NotFound());
}
var AlreadyExists = UserAuxiliar.FollowedSubjects(UserId, SQLContext).Contains(Subject);
if (AlreadyExists)
{
return(Ok("Already Exists"));
}
var UserInterest = new UserSubject()
{
UserId = UserId,
SubjectId = SubjectId
};
SQLContext.UserSubjects.Add(UserInterest);
SQLContext.SaveChanges();
return(Ok(UserInterest));
}
public async Task UpdatesTheBeginningOfWeekProperty()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var oldUser = new MockUser {
BeginningOfWeek = oldBeginningOfWeek
};
var newUser = new MockUser {
BeginningOfWeek = newBeginningOfWeek
};
UserSubject.OnNext(oldUser);
NavigationService
.Navigate <SelectBeginningOfWeekViewModel, BeginningOfWeek, BeginningOfWeek>(Arg.Any <BeginningOfWeek>())
.Returns(Task.FromResult(newBeginningOfWeek));
DataSource
.User
.Update(Arg.Any <EditUserDTO>())
.Returns(Observable.Return(newUser));
await ViewModel.SelectBeginningOfWeek();
await DataSource.User.Received().Update(
Arg.Is <EditUserDTO>(dto => dto.BeginningOfWeek == newBeginningOfWeek
));
}
public async Task UpdatesTheBeginningOfWeekProperty()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var oldUser = new MockUser {
BeginningOfWeek = oldBeginningOfWeek
};
var newUser = new MockUser {
BeginningOfWeek = newBeginningOfWeek
};
UserSubject.OnNext(oldUser);
View.Select(
Arg.Any <string>(),
Arg.Any <IEnumerable <SelectOption <BeginningOfWeek> > >(),
Arg.Any <int>())
.Returns(Observable.Return(newBeginningOfWeek));
InteractorFactory
.UpdateUser(Arg.Any <EditUserDTO>())
.Execute()
.Returns(Observable.Return(newUser));
ViewModel.SelectBeginningOfWeek.Execute();
TestScheduler.Start();
await InteractorFactory.UpdateUser(
Arg.Is <EditUserDTO>(dto => dto.BeginningOfWeek == newBeginningOfWeek
)).Received().Execute();
}
public JsonResult AddStudentToSubject(string[] data)
{
foreach (string item in data)
{
string[] arrParam = item.Split('_');
string action = arrParam[0] + "";
string usId = arrParam[1] + "";
string subId = arrParam[2] + "";
UserSubject usrSub = subjecUser.GetSubjectUserData(subId, usId);
switch (action)
{
case "D":
if (usrSub != null)
{
subjecUser.Delete(subId, usId);
}
break;
case "C":
if (usrSub == null)
{
subjecUser.Add(subId, usId);
}
break;
}
}
return(new JsonResult {
Data = "Cập nhật thông tin môn học cho sinh viên thành công", JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public ActionResult CreateTeacher(UserModel model)
{
try{
if (ModelState.IsValid)
{
model.UserType = "T"; //teacher
// var HasUser = db.Users.Where(t => t.UserName == model.UserName).SingleOrDefault();
var user = new ApplicationUser()
{
UserName = model.UserName, UserType = model.UserType
};
var result = UserManager.Create(user, model.Password);
if (result.Succeeded)
{
//find user Id
var UserId = db.Users.Where(t => t.UserName == model.UserName).SingleOrDefault();
foreach (var Item in model.Subjects)
{
if (Item.IsCheck == "on")
{
UserSubject sub = new UserSubject();
sub.EntryBy = User.Identity.Name;
sub.EntryDate = DateTime.Now;
sub.ClassId = model.ClassId;
sub.FacultyId = model.FacultyId;
sub.ManualCode = Item.ManualCode;
sub.SubjectId = Item.Id;
sub.UserId = UserId.Id;
db.UserSubjects.Add(sub);
}
}
db.SaveChanges();
TempData["Success"] = "User Create Success with Subject";
return(RedirectToAction("CreateTeacher"));
}
else
{
AddErrors(result);
}
}
ViewBag.Class_Id = new SelectList(db.ClassInfoes.ToList(), "Id", "ClassName");
ViewBag.Faculty_Id = new SelectList(db.FacultyInfoes.ToList(), "Id", "FacultyName");
return(View(model));
}
catch (Exception ex) {
ViewBag.Error = ex.Message;
return(View("Error"));
}
}
public async Task UpdatesTheBeginningOfWeekProperty()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var oldUser = new MockUser {
BeginningOfWeek = oldBeginningOfWeek
};
var newUser = new MockUser {
BeginningOfWeek = newBeginningOfWeek
};
UserSubject.OnNext(oldUser);
NavigationService
.Navigate <SelectBeginningOfWeekViewModel, BeginningOfWeek, BeginningOfWeek>(Arg.Any <BeginningOfWeek>())
.Returns(Task.FromResult(newBeginningOfWeek));
InteractorFactory
.UpdateUser(Arg.Any <EditUserDTO>())
.Execute()
.Returns(Observable.Return(newUser));
ViewModel.SelectBeginningOfWeek.Execute();
TestScheduler.Start();
await InteractorFactory.UpdateUser(
Arg.Is <EditUserDTO>(dto => dto.BeginningOfWeek == newBeginningOfWeek
)).Received().Execute();
}
public ActionResult DeleteUserSubject(int id)
{
UserSubject userSubject = db.UserSubjects.Find(id);
db.UserSubjects.Remove(userSubject);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult EditUserSubject([Bind(Include = "ID,UserID,SubjectID")] UserSubject userSubject)
{
if (ModelState.IsValid)
{
db.Entry(userSubject).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(userSubject));
}
public ActionResult CreateUserSubject([Bind(Include = "ID,UserID,SubjectID")] UserSubject userSubject)
{
if (ModelState.IsValid)
{
db.UserSubjects.Add(userSubject);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(userSubject));
}
public ActionResult AddSubject(UserModelAddSubject model)
{
try
{
if (ModelState.IsValid)
{
var HasUser = db.Users.Where(t => t.Id == model.UserName).SingleOrDefault();
if (HasUser != null)
{
UserSubject userModel = db.UserSubjects.Where(t => t.SubjectId == model.SubjectId && t.ClassId == model.ClassId && t.FacultyId == model.FacultyId && t.UserId == model.UserName).SingleOrDefault();
if (userModel != null)
{
TempData["Success"] = "Subject allready assigned !";
}
else
{
UserSubject sub = new UserSubject();
sub.EntryBy = User.Identity.Name;
sub.EntryDate = DateTime.Now;
sub.ClassId = model.ClassId;
sub.FacultyId = model.FacultyId;
sub.ManualCode = db.SubjectInfoes.Find(model.SubjectId).ManualCode;
sub.SubjectId = model.SubjectId;
sub.UserId = HasUser.Id;
db.UserSubjects.Add(sub);
db.SaveChanges();
TempData["Success"] = "Subject Is successfully assigned !";
return(RedirectToAction("Index", "CreateUser", new { UserType = "T" }));
}
}
else
{
TempData["Success"] = "User is not found!";
}
}
ViewBag.TeacherList = new SelectList(db.Users.ToList(), "Id", "UserName");
ViewBag.Class_Id = new SelectList(db.ClassInfoes.ToList(), "Id", "ClassName");
ViewBag.Faculty_Id = new SelectList(db.FacultyInfoes.ToList(), "Id", "FacultyName");
return(View(model));
}
catch (Exception ex)
{
ViewBag.Error = ex.Message;
return(View("Error"));
}
}
// GET: Users/DeleteUserSubject/5
public ActionResult DeleteUserSubject(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserSubject userSubject = db.UserSubjects.Find(id);
if (userSubject == null)
{
return(HttpNotFound());
}
return(View(userSubject));
}
public async Task NavigatesToSelectBeginningOfWeekViewModelPassingCurrentBeginningOfWeek()
{
var beginningOfWeek = BeginningOfWeek.Friday;
var user = new MockUser {
BeginningOfWeek = beginningOfWeek
};
UserSubject.OnNext(user);
await ViewModel.SelectBeginningOfWeek();
await NavigationService
.Received()
.Navigate <SelectBeginningOfWeekViewModel, BeginningOfWeek, BeginningOfWeek>(beginningOfWeek);
}
public async Task <IActionResult> PutUserSubject(int id, UserSubject userSubject)
{
if (id != userSubject.Id)
{
return(BadRequest());
}
List <UserSubject> userSubjects = new List <UserSubject>();
if (userSubject.IsLearned == true)
{
userSubjects = _context.UserSubjects.Where(u => u.UserId == userSubject.UserId)
.Where(s => s.SubjectId == userSubject.SubjectId).ToList();
for (int i = 0; i < userSubjects.Count; i++)
{
userSubjects[i].IsLearned = true;
}
}
else
{
userSubjects.Add(userSubject);
}
for (int i = 0; i < userSubjects.Count; i++)
{
_context.Entry(userSubjects[i]).State = EntityState.Modified;
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserSubjectExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void CallsTheImageDownloadInteractor()
{
var observer = TestScheduler.CreateObserver <byte[]>();
ViewModel.UserAvatar.Subscribe(observer);
UserSubject.OnNext(new MockUser {
ImageUrl = "http://toggl.com/image.jpg"
});
UserSubject.OnNext(new MockUser {
ImageUrl = "http://toggl.com/image.jpg"
});
UserSubject.OnNext(new MockUser {
ImageUrl = "http://toggl.com/image2.jpg"
});
InteractorFactory.Received(2).GetUserAvatar(Arg.Any <string>());
}
public async Task SelectBeginningOfWeekCommandCallsPushSync()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var user = new MockUser {
BeginningOfWeek = oldBeginningOfWeek
};
UserSubject.OnNext(user);
NavigationService
.Navigate <SelectBeginningOfWeekViewModel, BeginningOfWeek, BeginningOfWeek>(Arg.Any <BeginningOfWeek>())
.Returns(Task.FromResult(newBeginningOfWeek));
ViewModel.SelectBeginningOfWeek.Execute();
TestScheduler.Start();
await SyncManager.Received().PushSync();
}
public void EmitsWheneverTheUserImageChanges()
{
var observer = TestScheduler.CreateObserver <byte[]>();
ViewModel.UserAvatar.Subscribe(observer);
UserSubject.OnNext(new MockUser {
ImageUrl = "http://toggl.com/image.jpg"
});
UserSubject.OnNext(new MockUser {
ImageUrl = "http://toggl.com/image.jpg"
});
UserSubject.OnNext(new MockUser {
ImageUrl = "http://toggl.com/image2.jpg"
});
observer.Messages.Count.Should().Be(2);
}
public void EmitsWheneverTheUserEmailChanges()
{
var observer = TestScheduler.CreateObserver <string>();
ViewModel.Email.Subscribe(observer);
UserSubject.OnNext(new MockUser {
Email = Email.From("*****@*****.**")
});
UserSubject.OnNext(new MockUser {
Email = Email.From("*****@*****.**")
});
UserSubject.OnNext(new MockUser {
Email = Email.From("*****@*****.**")
});
observer.Messages.Count.Should().Be(2);
}
public IHttpActionResult DeleteUserSubject([FromUri] string AccessToken, int SubjectId)
{
var UserId = TokenValidator.VerifyToken(AccessToken);
UserSubject UserSubject = SQLContext.UserSubjects
.Where(x => x.UserId == UserId && x.SubjectId == SubjectId)
.FirstOrDefault();
if (UserSubject == null)
{
return(NotFound());
}
SQLContext.UserSubjects.Remove(UserSubject);
SQLContext.SaveChanges();
return(Ok(UserSubject));
}
public ThePickDefaultWorkspaceMethod()
{
defaultWorkspace = new MockWorkspace {
Id = defaultWorkspaceId
};
workspace = new MockWorkspace {
Id = workspaceId, Name = workspaceName
};
UserSubject.OnNext(new MockUser());
InteractorFactory.GetDefaultWorkspace().Execute()
.Returns(Observable.Return(defaultWorkspace));
InteractorFactory.GetWorkspaceById(workspaceId).Execute()
.Returns(Observable.Return(workspace));
ViewModel.Prepare();
}
public async Task ShowsTheSelectModalPassingCurrentBeginningOfWeek()
{
var beginningOfWeek = BeginningOfWeek.Friday;
var user = new MockUser {
BeginningOfWeek = beginningOfWeek
};
UserSubject.OnNext(user);
ViewModel.SelectBeginningOfWeek.Execute();
TestScheduler.Start();
await View
.Received()
.Select(
Arg.Any <string>(),
Arg.Any <IEnumerable <SelectOption <BeginningOfWeek> > >(),
Arg.Is(5));
}
public async Task <IActionResult> PostUserSubject(UserSubject userSubject)
{
var days = userSubject.EndDateTime.Day - userSubject.StartDateTime.Day + 1;
var month = userSubject.StartDateTime.Month;
var user = _context.Users.Find(userSubject.UserId);
var userSubjectsForMonth = _context.UserSubjects.Where(u => u.UserId == user.Id)
.Where(u => u.StartDateTime.Month == month)
.ToList();
for (int i = 0; i < userSubjectsForMonth.Count; i++)
{
days += (userSubjectsForMonth[i].EndDateTime.Day - userSubjectsForMonth[i].StartDateTime.Day + 1);
}
if (days > 5)
{
Response.StatusCode = 400;
return(Content("Not enough learning days left for this month"));
}
if (userSubject.StartDateTime > userSubject.EndDateTime)
{
Response.StatusCode = 400;
return(Content("Incorrect start and end datetimes"));
}
var userSubjects = _context.UserSubjects.Where(u => u.UserId == userSubject.UserId)
.Where(s => s.SubjectId == userSubject.SubjectId)
.Where(s => s.StartDateTime.Date == userSubject.StartDateTime.Date)
.ToList();
if (userSubjects.Count > 0)
{
Response.StatusCode = 400;
return(Content("This user subject for this date already exists"));
}
user.LearningDaysLeft -= days;
_context.Users.Update(user);
_context.UserSubjects.Add(userSubject);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task UpdatesTheStoredPreferences()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var user = Substitute.For <IThreadSafeUser>();
user.BeginningOfWeek.Returns(oldBeginningOfWeek);
UserSubject.OnNext(user);
NavigationService
.Navigate <SelectBeginningOfWeekViewModel, BeginningOfWeek, BeginningOfWeek>(Arg.Any <BeginningOfWeek>())
.Returns(Task.FromResult(newBeginningOfWeek));
await ViewModel.SelectBeginningOfWeek();
await DataSource
.User
.Received()
.Update(Arg.Is <EditUserDTO>(dto => dto.BeginningOfWeek == newBeginningOfWeek));
}
public async Task SelectBeginningOfWeekCommandCallsPushSync()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var user = new MockUser {
BeginningOfWeek = oldBeginningOfWeek
};
UserSubject.OnNext(user);
NavigationService
.Navigate <SelectBeginningOfWeekViewModel, BeginningOfWeek, BeginningOfWeek>(Arg.Any <BeginningOfWeek>())
.Returns(Task.FromResult(newBeginningOfWeek));
var syncManager = Substitute.For <ISyncManager>();
DataSource.SyncManager.Returns(syncManager);
await ViewModel.SelectBeginningOfWeek();
await syncManager.Received().PushSync();
}
public async Task SelectBeginningOfWeekCommandCallsPushSync()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var user = new MockUser {
BeginningOfWeek = oldBeginningOfWeek
};
UserSubject.OnNext(user);
View.Select(
Arg.Any <string>(),
Arg.Any <IEnumerable <SelectOption <BeginningOfWeek> > >(),
Arg.Any <int>())
.Returns(Observable.Return(newBeginningOfWeek));
ViewModel.SelectBeginningOfWeek.Execute();
TestScheduler.Start();
await SyncManager.Received().PushSync();
}
public async Task UpdatesTheStoredPreferences()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var user = Substitute.For <IThreadSafeUser>();
user.BeginningOfWeek.Returns(oldBeginningOfWeek);
UserSubject.OnNext(user);
NavigationService
.Navigate <SelectBeginningOfWeekViewModel, BeginningOfWeek, BeginningOfWeek>(Arg.Any <BeginningOfWeek>(), View)
.Returns(Task.FromResult(newBeginningOfWeek));
ViewModel.SelectBeginningOfWeek.Execute();
TestScheduler.Start();
await InteractorFactory
.Received()
.UpdateUser(Arg.Is <EditUserDTO>(dto => dto.BeginningOfWeek == newBeginningOfWeek))
.Execute();
}
public async Task UpdatesTheStoredPreferences()
{
var oldBeginningOfWeek = BeginningOfWeek.Tuesday;
var newBeginningOfWeek = BeginningOfWeek.Sunday;
var user = Substitute.For <IThreadSafeUser>();
user.BeginningOfWeek.Returns(oldBeginningOfWeek);
UserSubject.OnNext(user);
View.Select(
Arg.Any <string>(),
Arg.Any <IEnumerable <SelectOption <BeginningOfWeek> > >(),
Arg.Any <int>())
.Returns(Observable.Return(newBeginningOfWeek));
ViewModel.SelectBeginningOfWeek.Execute();
TestScheduler.Start();
await InteractorFactory
.Received()
.UpdateUser(Arg.Is <EditUserDTO>(dto => dto.BeginningOfWeek == newBeginningOfWeek))
.Execute();
}
public ActionResult Register(RegisterModel model)
{
var db = new Context();
if (ModelState.IsValid)
{
try
{
WebSecurity.CreateUserAndAccount(model.UserName, model.Password, new { model.Email, model.First, model.Last });
WebSecurity.Login(model.UserName, model.Password);
var school = db.Schools.FirstOrDefault(t => t.Id == model.School);
var user = db.UserProfiles.FirstOrDefault(t => t.UserName == model.UserName);
db.UserProfileSchools.Add(new UserProfileSchool { School = school, UserProfile = user });
foreach (var gradeId in model.GradeIds)
{
var userGrade = new UserGrade { UserProfile = user, Grade_Id = gradeId };
db.UserGrades.Add(userGrade);
}
foreach (var subjectId in model.SubjectIds)
{
var userSubject = new UserSubject { UserProfile = user, Subject_Id = subjectId };
db.UserSubjects.Add(userSubject);
}
db.SaveChanges();
return RedirectToAction("TakeATour", "Home", new { Area = "" });
}
catch (MembershipCreateUserException e)
{
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
return View(GenerateRegisterForm(model));
}
public async Task RateTheSubject(UserSubject ratedSubject)
{
var user = await GetByIdAsync(ratedSubject.UserId);
user.UserSubjects.Add(ratedSubject);
}
