private void AddStudent(SqlConnection client, SqlTransaction transaction, CreateStudentDTO student, int idEnrollment)
{
using (var cmd = new SqlCommand())
{
var password = PasswordHelper.HashPassword(student.Password);
cmd.Connection = client;
cmd.Transaction = transaction;
cmd.CommandText = @"INSERT INTO [Student]
([IndexNumber]
,[FirstName]
,[LastName]
,[BirthDate]
,[IdEnrollment]
,[Password]
,[PasswordSalt])
VALUES
(@indexNumber
,@firstName
,@lastName
,@birthDate
,@enrollment
,@password
,@passwordSalt)";
cmd.Parameters.AddWithValue("indexNumber", student.IndexNumber);
cmd.Parameters.AddWithValue("firstName", student.FirstName);
cmd.Parameters.AddWithValue("lastName", student.LastName);
cmd.Parameters.AddWithValue("birthDate", student.BirthDate);
cmd.Parameters.AddWithValue("enrollment", idEnrollment);
cmd.Parameters.AddWithValue("password", password.PasswordHash);
cmd.Parameters.AddWithValue("passwordSalt", password.Salt);
cmd.ExecuteNonQuery();
}
}
public IActionResult CreateStudent(CreateStudentDTO student)
{
var studies = _dbService.GetStudiesByName(student.Studies);
if (studies == null)
{
return(BadRequest($"Nie znaleziono kierunku studiow {student.Studies}"));
}
if (_dbService.GetStudentByIndexNumber(student.IndexNumber) != null)
{
return(BadRequest($"Istnieje juz student z numerem indeksu {student.IndexNumber}"));
}
var enrollment = _dbService.GetLatestEnrollment(1, studies.IdStudy);
if (enrollment == null)
{
enrollment = _dbService.AddStudentWithNewEnrollment(student, new Enrollment()
{
IdStudy = studies.IdStudy, Semester = 1, StartDate = DateTime.Now
});
}
else
{
_dbService.AddStudentWithExistingEnrollment(student, enrollment.IdEnrollment);
}
return(Created("", enrollment));
}
public async Task <CreatedStudentDTO> CreateAsync(CreateStudentDTO student)
{
User user = _userRepository.Get().Include(s => s.Student)
.FirstOrDefault(s => s.Student.TelegramId == student.TelegramId);
if (user is null)
{
user = new User()
{
Firstname = student.Firstname,
Lastname = student.Lastname,
Student = new Student
{
TelegramId = student.TelegramId,
TelegramPhotoUrl = student.TelegramPhotoUrl,
TelegramUsername = student.TelegramUsername
}
};
await _userRepository.AddAsync(user);
await _storage.SaveAsync();
}
return(new CreatedStudentDTO(user));
}
public async Task <IActionResult> Create([FromBody] CreateStudentDTO dto)
{
if (null == dto)
{
return(BadRequest());
}
var command = new CreateStudent(dto.Id, dto.FirstName, dto.LastName);
await _mediator.Publish(command);
return(CreatedAtAction("GetById", new { id = dto.Id }, dto.Id));
}
public async Task Create_returns_500_on_internal_error()
{
var student = new CreateStudentDTO();
repository.Setup(r => r.CreateStudentAsync(student)).ThrowsAsync(new Exception());
var controller = new StudentRepositoryController(repository.Object);
var actual = await controller.Create(student, true);
var actionResult = Assert.IsType <ActionResult <Guid> >(actual);
var code = Assert.IsType <StatusCodeResult>(actionResult.Result);
Assert.Equal(500, code.StatusCode);
}
public IActionResult CreateStudent(CreateStudentDTO createStudentDto)
{
var studies = _studentsDbContext.Studies
.Include(x => x.Enrollments)
.FirstOrDefault(x => x.Name == createStudentDto.Studies);
if (studies == null)
{
return(BadRequest($"Nie znaleziono kierunku studiow {createStudentDto.Studies}"));
}
if (_studentsDbContext.Student.Any(x => x.IndexNumber == createStudentDto.IndexNumber))
{
return(BadRequest($"Istnieje juz student z numerem indeksu {createStudentDto.IndexNumber}"));
}
var enrollment = studies.Enrollments.OrderByDescending(x => x.StartDate)
.FirstOrDefault(x => x.Semester == 1);
if (enrollment == null)
{
enrollment = new ModelsEf.Enrollment()
{
IdEnrollment = _studentsDbContext.Enrollment.Max(x => x.IdEnrollment) + 1,
Studies = studies,
StartDate = DateTime.Now,
Semester = 1
};
_studentsDbContext.Enrollment.Add(enrollment);
}
var password = PasswordHelper.HashPassword(createStudentDto.Password);
var student = new Student()
{
IndexNumber = createStudentDto.IndexNumber,
Password = password.PasswordHash,
PasswordSalt = password.Salt,
LastName = createStudentDto.LastName,
FirstName = createStudentDto.FirstName,
BirthDate = createStudentDto.BirthDate,
Enrollment = enrollment
};
_studentsDbContext.Student.Add(student);
_studentsDbContext.SaveChanges();
return(Created("", enrollment));
}
public IActionResult CreateStudent([FromBody] CreateStudentDTO student)
{
var s = new Student
{
Name = student.Name,
Cnp = student.Cnp,
Restances = student.Restances
};
var result = _studentService.AddStudent(s);
if (result == null)
{
return(BadRequest());
}
return(Created($"/students/{result.Id}", result));
}
public async Task Create_returns_200_and_id_of_created_student()
{
var nextMockedId = Guid.NewGuid();
var student = new CreateStudentDTO();
repository.Setup(r => r.CreateStudentAsync(student)).ReturnsAsync(nextMockedId);
var controller = new StudentRepositoryController(repository.Object);
var actual = await controller.Create(student, true);
var actionResult = Assert.IsType <ActionResult <Guid> >(actual);
var okResult = Assert.IsType <OkObjectResult>(actionResult.Result);
var actualId = Assert.IsType <Guid>(okResult.Value);
Assert.Equal(200, okResult.StatusCode);
Assert.Equal(nextMockedId, actualId);
}
public async Task <IHttpActionResult> PostStudentAsync(CreateStudentDTO student)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await StudentService.AddStudentAsync(student);
if (!result.Created)
{
LoggingService.SaveErrorLog($"Adding student error. Student {JsonConvert.SerializeObject(student)}");
_logger.Error($"Adding student error. Student {JsonConvert.SerializeObject(student)}");
return(BadRequest("Adding student error. Try again."));
}
return(CreatedAtRoute("GetStudent", new { id = result.Student.RecordBookNumber }, result.Student));
}
public async Task CreateStudent_returns_the_id_of_created_student()
{
var id = Guid.NewGuid();
var student = new CreateStudentDTO
{
Id = id,
Degree = Degree.Bachelor,
KeywordNames = new [] { "Testing" },
MinSalary = 100,
MinWorkingHours = 5,
MaxWorkingHours = 20,
Agreement = false,
Location = "Nowhere"
};
var actual = await repository.CreateStudentAsync(student);
Assert.Equal(student.Id, actual);
}
public async Task <ActionResult <Guid> > Create([FromBody] CreateStudentDTO student, bool isTest = false)
{
try
{
var id = await repository.CreateStudentAsync(student);
return(Ok(id));
}
catch (ArgumentException e)
{
Util.LogError(e, isTest);
return(StatusCode(StatusCodes.Status409Conflict));
}
catch (Exception e)
{
Util.LogError(e, isTest);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <Guid> CreateStudentAsync(CreateStudentDTO student)
{
var entity = new Student
{
Id = student.Id,
Degree = student.Degree,
Keywords = GetKeywords(student.KeywordNames).ToList(),
MinSalary = student.MinSalary,
MinWorkingHours = student.MinWorkingHours,
MaxWorkingHours = student.MaxWorkingHours,
Agreement = student.Agreement,
Location = student.Location
};
await context.Students.AddAsync(entity);
await context.SaveChangesAsync();
return(entity.Id);
}
public void AddStudentWithExistingEnrollment(CreateStudentDTO student, int existingIdEnrollment)
{
using (var client = new SqlConnection(
"Data Source=db-mssql;Initial Catalog=s17428;Integrated Security=True"))
{
client.Open();
using (var transaction = client.BeginTransaction())
{
try
{
AddStudent(client, transaction, student, existingIdEnrollment);
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
}
public async Task <NewStudentResultDTO> AddStudentAsync(CreateStudentDTO studentDTO)
{
var createResult = new NewStudentResultDTO
{
Created = false,
Student = null
};
var user = new ApplicationUser()
{
UserName = studentDTO.Email, Email = studentDTO.Email, CreatedDate = DateTime.Now, FirstName = studentDTO.FirstName, LastName = studentDTO.LastName, EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, studentDTO.Pesel.ToString() + studentDTO.LastName.ToLower().Substring(0, Math.Min(studentDTO.LastName.Length, 3)));
//var saveUserResult = _store.Context.SaveChanges();
var roleResult = await _userManager.AddToRoleAsync(user.Id, "student");
if (!result.Succeeded || !roleResult.Succeeded)
{
return(createResult);
}
var student = Mapper.Map <Student>(studentDTO);
student.UserId = user.Id;
var createdStudent = _repository.InsertStudent(student);
if (_repository.Save())
{
createResult.Created = true;
createResult.Student = Mapper.Map <GetStudentDTO>(createdStudent);
return(createResult);
}
return(createResult);
}
public Enrollment AddStudentWithNewEnrollment(CreateStudentDTO student, Enrollment enrollment)
{
using (var client = new SqlConnection(
"Data Source=db-mssql;Initial Catalog=s17428;Integrated Security=True"))
{
client.Open();
using (var transaction = client.BeginTransaction())
{
try
{
enrollment = AddEnrollment(client, transaction, enrollment);
AddStudent(client, transaction, student, enrollment.IdEnrollment);
transaction.Commit();
return(enrollment);
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
}
