public void EditStudentNickname()
{
AddStudentRequest request = new AddStudentRequest()
{
Nickname = AlphaNumericStringGenerator.GetString(10),
SID = AlphaNumericStringGenerator.GetStudentIDString()
};
StudentFacade studentFacade = new StudentFacade();
AddStudentResponse response = studentFacade.AddStudentNickname(request);
Assert.AreEqual(HttpStatusCode.OK, response.Status);
EditStudentNicknameRequest editStudentNicknameRequest = new EditStudentNicknameRequest()
{
Nickname = AlphaNumericStringGenerator.GetString(10)
};
EditStudentNicknameResponse editStudentNicknameResponse = studentFacade.EditStudentNickname(response.StudentID, editStudentNicknameRequest);
Assert.AreEqual(HttpStatusCode.OK, editStudentNicknameResponse.Status);
Assert.IsTrue(editStudentNicknameResponse.Result);
using (helpdesksystemContext context = new helpdesksystemContext())
{
var nickname = context.Nicknames.FirstOrDefault(n => n.StudentId == response.StudentID);
Assert.AreEqual(editStudentNicknameRequest.Nickname, nickname.NickName);
}
}
public void GetStudentByNickname()
{
AddStudentRequest request = new AddStudentRequest()
{
Nickname = AlphaNumericStringGenerator.GetString(10),
SID = AlphaNumericStringGenerator.GetStudentIDString()
};
var facade = new StudentFacade();
var response = facade.AddStudentNickname(request);
Assert.AreEqual(HttpStatusCode.OK, response.Status);
Assert.IsTrue(response.StudentID > 0);
using (helpdesksystemContext context = new helpdesksystemContext())
{
var student = context.Nicknames.FirstOrDefault(p => p.StudentId == response.StudentID);
Assert.IsNotNull(student);
}
var getResponse = facade.GetStudentByNickname(request.Nickname);
Assert.AreEqual(HttpStatusCode.OK, getResponse.Status);
Assert.IsNotNull(getResponse.Nickname);
}
public TestDataNickname AddNickname(string sID = "", string nickname = "")
{
var request = new AddStudentRequest();
if (sID != null)
{
if (sID == "" && PopulateEmptyStrings)
{
request.SID = AlphaNumericStringGenerator.GetStudentIDString();
}
else
{
request.SID = sID;
}
}
if (nickname != null)
{
if (nickname == "" && PopulateEmptyStrings)
{
request.Nickname = AlphaNumericStringGenerator.GetString(20);
}
else
{
request.Nickname = nickname;
}
}
var response = StudentFacade.AddStudentNickname(request);
TestDataNickname data = new TestDataNickname(request, response);
return(data);
}
/// <summary>
/// Adds a students to class
/// </summary>
public async Task <AddStudentResult> AddStudentAsync(AddStudentRequest model)
{
IEnumerable <ValidationMessage> validationMessages = _studentValidator.ValidateRules(model);
if (validationMessages.Any())
{
return(new AddStudentResult(validationMessages));
}
var @class = await _classRepository.GetAsync(model.ClassId);
if (@class == null)
{
return(new AddStudentResult(new ValidationMessage(nameof(model.ClassId), "No class was found")));
}
var student = new Student(Name.CreateFromString(model.FirstName),
model.Infix,
Name.CreateFromString(model.LastName));
@class.AddStudent(student);
ValidationMessage result = await _classRepository.UpdateAsync(@class);
if (result != null)
{
return(new AddStudentResult(result));
}
return(new AddStudentResult());
}
public static Student ProjectTo(this AddStudentRequest request, IMapper mapper, RoleEnum roleEnum)
{
Student std = mapper.Map<Student>(request);
std.DateCreated = DateTime.Now;
std.User = request.User.ProjectTo(mapper, roleEnum);
return std;
}
public async Task <EnrollStudentResponse> EnrollStudent(EnrollStudentRequest req)
{
var studiesExist = _context.Studies.Any(e => e.Name == req.Studies);
if (!studiesExist)
{
return(null);
}
else
{
var sList = _context.Studies.Where(s => s.Name == req.Studies).ToList();
var idStudy = sList[0].IdStudy;
int enrollId = 1;
var enrollmentExist = _context.Enrollment.Any(e => e.IdStudy == idStudy && e.Semester == 1);
if (enrollmentExist)
{
var eList = _context.Enrollment.Where(e => e.IdStudy == idStudy && e.Semester == 1).ToList();
enrollId = eList[0].IdEnrollment;
}
else
{
var enrollment = new Enrollment
{
Semester = 1,
IdStudy = idStudy,
StartDate = DateTime.Now
};
await _context.Enrollment.AddAsync(enrollment);
await _context.SaveChangesAsync();
var addStudent = new AddStudentRequest
{
IndexNumber = req.IndexNumber,
FirstName = req.FirstName,
LastName = req.LastName,
BirthDate = req.BirthDate,
IdEnrollment = enrollId
};
await AddStudent(addStudent);
var eStudentList = _context.Enrollment.Where(e => e.IdEnrollment == enrollId).ToList();
var resp = new EnrollStudentResponse
{
IdEnrollment = eStudentList[0].IdEnrollment,
IdStudy = eStudentList[0].IdStudy,
Semester = eStudentList[0].Semester,
StartDate = eStudentList[0].StartDate,
};
return(resp);
}
}
return(null);
}
public void Validate_ModelNull_ThrowsException()
{
AddStudentRequest input = null;
Action action = () => _sut.Validate(input);
action.Should().Throw <ArgumentNullException>();
}
public bool AddStudent(AddStudentRequest request)
{
var student = request.Map <Student, AddStudentRequest>();
Collection.Add(student);
DataWriter.WriterData(student, nameof(Student));
return(true);
}
public IActionResult AddStudent([FromBody] AddStudentRequest request)
{
var result = _studentService.AddStudent(request);
if (result.IsSucessful)
{
return(Ok(result));
}
return(BadRequest(result));
}
public void Validate_ValidFirstName_ReturnsNull()
{
AddStudentRequest input = _fixture.Build <AddStudentRequest>()
.With(x => x.FirstName, _fixture.Create <string>())
.Create();
Application.Validation.ValidationMessage result = _sut.Validate(input);
result.Should().BeNull();
}
public bool AddStudent([FromBody] AddStudentRequest request)
{
if (GetLibrarianById(request.LibrarianId).Authority < 2)
{
return(false);
}
LogsDataManager.SendLog(
request.LibrarianId,
"Librarian",
"added student " + request.Student.FirstName);
return(UsersDataManager.AddStudent(request.Student, request.Login, request.Password));
}
public IActionResult AddStudent(AddStudentRequest request)
{
try
{
var response = _service.AddStudent(request);
return(Created("AddStudent", response));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void Validate_FirstNameWhitespace_ReturnsValidationMessage()
{
AddStudentRequest input = _fixture.Build <AddStudentRequest>()
.With(x => x.FirstName, " ")
.Create();
Application.Validation.ValidationMessage result = _sut.Validate(input);
result.Should().NotBeNull();
result.Field.Should().Be("FirstName");
result.Message.Should().Be("First name is required");
}
public void Validate_EmptyLastName_ReturnsValidationMessage()
{
AddStudentRequest input = _fixture.Build <AddStudentRequest>()
.With(x => x.LastName, string.Empty)
.Create();
Application.Validation.ValidationMessage result = _sut.Validate(input);
result.Should().NotBeNull();
result.Field.Should().Be("LastName");
result.Message.Should().Be("Last name is required");
}
public async Task <IActionResult> AddStudent(AddStudentRequest req)
{
int res = await _service.AddStudent(req);
if (res == -1)
{
return(BadRequest());
}
else
{
return(Ok("Student was added"));
}
}
public Student AddStudent(AddStudentRequest request)
{
Student student = null;
if (request != null && request.Student != null)
{
var dataAccess = new StudentDataAccess(request.Context);
student = dataAccess.Add(request.Student);
}
return(student);
}
public Student AddStudent([FromBody] Student student)
{
if (student != null)
{
var business = StudentBusiness.Instance;
var request = new AddStudentRequest(this.Context);
request.Student = student;
student = business.AddStudent(request);
}
return(student);
}
public override async Task AddAsync(object request)
{
if (!(request is AddStudentRequest))
{
throw new Exception("Convert type not allowed");
}
AddStudentRequest rq = (AddStudentRequest)request;
var std = rq.ProjectTo(_mapper, RoleEnum.Student);
// update student
await _repository.AddOrUpdateAsync(std);
}
public IActionResult post(AddStudentRequest request)
{
//EF
context.Database.BeginTransaction();
var studies = context.studies.FirstOrDefault(a => a.Name == request.Studies);
if (studies == null)
{
context.Database.RollbackTransaction();
return(NotFound("Nie ma takiego kierunku"));
}
var enroll = context.enrollments.FirstOrDefault(a => a.IdStudy == studies.IdStudy);
//"select coalesce(min(t1.IdEnrollment) + 1, 0) from EnrollmentN t1 left outer join EnrollmentN t2 on t1.IdEnrollment = t2.IdEnrollment - 1 where t2.IdEnrollment is null";
//view findMinStudent select * from findMinStudent;
//Brak pomyslu jak to zrobic za pomoc EF
int newid = context.Database.ExecuteSqlRaw("select * from findMinStudent");
Student s = new Student {
IdStudent = newid, FirstName = request.FirstName, LastName = request.LastName, IndexNumber = request.IndexNumber, BirthDate = request.BirthDate, IdEnrollment = enroll.IdEnrollment
};
context.students.Add(s);
context.Database.CommitTransaction();
context.SaveChanges();
//Stare
//To przerobić na SameExpection i try catch, to jest fuuuuu
//Przychodzi ci student i robi takie cos :C
dbService.AddStudnet(request);
if (dbService.getMsg() == -1)
{
return(BadRequest("Can not add"));
}
if (dbService.getMsg() == -2)
{
return(BadRequest("Studies not found"));
}
if (dbService.getMsg() == -3)
{
return(BadRequest("Stident index is not uniqe"));
}
if (dbService.getMsg() == -4)
{
return(BadRequest("Something gone wrong :C"));
}
return(Created("", dbService.GetEnrollment()));
}
public async Task <AddStudentResponse> ExecuteAsync(AddStudentRequest request)
{
var id = _repository.AddStudent(new StudentEntity
{
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
Grade = request.Grade
});
if (id > 0)
{
return(new AddStudentResponse(true, "Student added", HttpStatusCode.Accepted));
}
return(new AddStudentResponse(false, "Add Student Failed", HttpStatusCode.BadRequest));
}
public AddStudentResponse AddStudent(AddStudentRequest request)
{
var study = _context.Studies.FirstOrDefault(s => s.Name == request.Studies);
if (study == null)
{
throw new Exception("There is no such study");
}
var enrollment = _context.Enrollment.Where(enr => enr.IdStudy == study.IdStudy && enr.Semester == request.Semester).FirstOrDefault();
if (enrollment == null)
{
enrollment = new Enrollment()
{
IdEnrollment = _context.Enrollment.Max(enr => enr.IdEnrollment) + 1,
Semester = request.Semester,
IdStudy = study.IdStudy,
StartDate = DateTime.Now
};
_context.Enrollment.Add(enrollment);
}
if (_context.Student.FirstOrDefault(s => s.IndexNumber == request.IndexNumber) != null)
{
throw new Exception("Student with such index number already exists");
}
var student = new Student()
{
IndexNumber = request.IndexNumber,
BirthDate = request.Birthdate,
FirstName = request.FirstName,
LastName = request.LastName,
IdEnrollment = enrollment.IdEnrollment
};
_context.Student.Add(student);
var response = new AddStudentResponse()
{
Semester = enrollment.Semester,
LastName = student.LastName,
StartDate = enrollment.StartDate
};
_context.SaveChanges();
return(response);
}
/// <summary>
/// Used to add a nickname to the database
/// </summary>
/// <param name="request">The nickname information</param>
/// <returns>The id of the nickname added</returns>
public int AddStudentNickname(AddStudentRequest request)
{
Nicknames nickname = new Nicknames()
{
NickName = request.Nickname,
Sid = request.SID
};
using (helpdesksystemContext context = new helpdesksystemContext())
{
context.Nicknames.Add(nickname);
context.SaveChanges();
}
return(nickname.StudentId);
}
public async Task <int> AddStudent(AddStudentRequest req)
{
var student = new Student
{
IndexNumber = req.IndexNumber,
FirstName = req.FirstName,
LastName = req.LastName,
BirthDate = DateTime.Parse(req.BirthDate),
IdEnrollment = req.IdEnrollment
};
_context.Student.Add(student);
await _context.SaveChangesAsync();
return(1);
}
public IResult Execute(IRequest request)
{
if (request is AddStudentRequest addStudentRequest)
{
AddStudentRequest model = addStudentRequest;
ICollection <ValidationResult> results = new List <ValidationResult>();
if (!model.Validate(out results))
{
return(new Result(false, results.First().ErrorMessage));
}
_uow.Students.AddStudent(addStudentRequest);
_uow.SaveChanges();
return(new Result <Student>(true, null, "Student Added Successfully"));
}
return(new Result(true, ""));
}
private async Task AddStudentFlowAsync(Guid classId)
{
string firstName = SharedConsoleFlows.AskForString("What is the first name of the student?");
string infix = SharedConsoleFlows.AskForOptionalString("What is the infix of the student?");
string lastName = SharedConsoleFlows.AskForString("What is the last name of the student?");
var model = new AddStudentRequest
{
ClassId = classId,
FirstName = firstName,
Infix = infix,
LastName = lastName
};
AddStudentResult addStudentResponse = await _classController.AddStudentAsync(model);
if (addStudentResponse.ValidationMessages.Any())
{
SharedConsoleFlows.PrintValidationMessages(addStudentResponse.ValidationMessages);
await AddStudentFlowAsync(classId);
}
}
public IResult AddStudent(AddStudentRequest request)
{
ICollection <ValidationResult> results = new List <ValidationResult>();
if (!request.Validate(out results))
{
return(new Result(false, results.First().ErrorMessage));
}
var program = _uow.Programs.GetprogramByName(request.ProgramOfStudy);
if (program is null)
{
return(new Result(false, $"Can not find program {request.ProgramOfStudy}"));
}
request.DepartmentId = program.DepartmentId;
_uow.Students.AddStudent(request);
_uow.SaveChanges();
return(new Result(true, "Student Added Successfully"));
}
public IActionResult post(AddStudentRequest request)
{
dbService.AddStudnet(request);
if (dbService.getMsg() == -1)
{
return(BadRequest("Can not add"));
}
if (dbService.getMsg() == -2)
{
return(BadRequest("Studies not found"));
}
if (dbService.getMsg() == -3)
{
return(BadRequest("Stident index is not uniqe"));
}
if (dbService.getMsg() == -4)
{
return(BadRequest("Something gone wrong :C"));
}
return(Created("", dbService.GetEnrollment()));
}
public async Task <IHttpActionResult> AddStudent([FromBody] AddStudentRequest studentReq)
{
try
{
if (ModelState.IsValid)
{
await _service.AddAsync(studentReq);
await _service.CommitAsync();
return(Ok());
}
return(BadRequest(ModelState));
}
catch (Exception ex)
{
await _service.RollbackAsync();
return(BadRequest(GetError(ex)));
}
}
public async Task <IActionResult> Post([FromBody] AddStudentRequest request)
{
var response = await _addStudentUseCase.ExecuteAsync(request);
if (!response.Success)
{
return(BadRequest(new ErrorResponse
{
Status = (int)HttpStatusCode.BadRequest,
Error = new ErrorData <string>
{
Message = "Bad request",
Description = response.Message
}
}));
}
return(Created("", new SuccessResponse <string>
{
Status = (int)HttpStatusCode.Created
}));
}
public void EditStudentNicknameExists()
{
AddStudentRequest request = new AddStudentRequest()
{
Nickname = AlphaNumericStringGenerator.GetString(10),
SID = AlphaNumericStringGenerator.GetStudentIDString()
};
StudentFacade studentFacade = new StudentFacade();
AddStudentResponse response = studentFacade.AddStudentNickname(request);
Assert.AreEqual(HttpStatusCode.OK, response.Status);
EditStudentNicknameRequest editStudentNicknameRequest = new EditStudentNicknameRequest()
{
Nickname = request.Nickname
};
EditStudentNicknameResponse editStudentNicknameResponse = studentFacade.EditStudentNickname(response.StudentID, editStudentNicknameRequest);
Assert.AreEqual(HttpStatusCode.BadRequest, editStudentNicknameResponse.Status);
}
