public IActionResult Register([FromBody] StudentRegisterDto student)
{
if (_service.IsUserExist(student.UserName))
{
ModelState.AddModelError("UserName", "Username already taken");
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var studentToCreate = new Student()
{
DepartmentId = student.DepartmentId,
User = new User()
{
Name = student.Name,
Surname = student.Surname,
UserName = student.UserName,
Email = student.Email
}
};
_service.Register(studentToCreate, student.Password);
// 201: Created Status
return(StatusCode(201));
}
public IActionResult Post(StudentRegisterDto model)
{
var student = _mapper.Map <Student>(model);
_repo.Add(student);
if (_repo.SaveChanges())
{
return(Created($"/api/student/{model.Id}", _mapper.Map <StudentDto>(student)));
}
return(BadRequest("Something is wrong"));
}
public IActionResult Post(StudentRegisterDto studentModel)
{
var student = _mapper.Map <Student>(studentModel);
_repository.Create(student);
if (_repository.SaveChanges())
{
return(Created($"/api/student/{studentModel.StudentID}", _mapper.Map <StudentDto>(student)));
}
return(BadRequest("Aluno não cadastrado."));
}
public async Task <IActionResult> AddStudentToTeacher(StudentRegisterDto studentRegisterDto, int id)
{
try
{
await _studentService.Add(studentRegisterDto, id);
return(Ok("Öğrenci Başarıyla Kaydedildi"));
}
catch
{
return(BadRequest("Öğrenci Eklenemedi"));
}
}
public async Task <IActionResult> Register(StudentRegisterDto studentRegisterDto)
{
try
{
await _studentService.Add(studentRegisterDto, null);
return(StatusCode(201));
}
catch
{
return(BadRequest());
}
}
public IActionResult Register([FromBody] StudentRegisterDto data)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_userRepository.EmailExists(data.Email))
{
ModelState.AddModelError("", "Email exists");
return(BadRequest("Данный email уже зарегистрирован"));
}
User user = _userService.RegisterUser(data, UserType.Student);
return(Ok(_mapper.Map <User, ProfileDto>(user)));
}
public IActionResult Put(int id, StudentRegisterDto model)
{
var student = _repo.GetStudentById(id, false);
if (student == null)
{
return(BadRequest("Student not found"));
}
_mapper.Map(model, student);
_repo.Update(student);
if (_repo.SaveChanges())
{
return(Created($"/api/student/{model.Id}", _mapper.Map <StudentDto>(student)));
}
return(BadRequest("Something is wrong"));
}
public async Task Add(StudentRegisterDto studentRegisterDto, int?teacherId)
{
Student student = _mapper.Map <Student>(studentRegisterDto);
student.SecurityStamp = Guid.NewGuid().ToString();
student.UserName = studentRegisterDto.Email;
if (teacherId != null)
{
Teacher teacher = await _teacherService.GetById(Convert.ToInt32(teacherId));
student.Teacher = teacher;
}
await _userManager.CreateAsync(student, studentRegisterDto.Password);
await _userManager.AddToRoleAsync(student, "Student");
}
public IActionResult Put(int id, StudentRegisterDto studentModel)
{
var student = _repository.GetStudentById(id);
if (student == null)
{
return(BadRequest("Aluno não encontrado."));
}
_mapper.Map(studentModel, student);
_repository.Update(student);
if (_repository.SaveChanges())
{
return(Created($"/api/student/{studentModel.StudentID}", _mapper.Map <StudentDto>(student)));
}
return(BadRequest("Aluno não atualizado."));
}
public async Task <ActionResponse <StudentRegisterDto> > Update(StudentRegisterDto entityDto)
{
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
var entityToUpdate = mapper.Map <StudentRegisterDto, StudentRegister>(entityDto);
unitOfWork.GetGenericRepository <StudentRegister>().Update(entityToUpdate);
unitOfWork.Save();
scope.Complete();
return(await ActionResponse <StudentRegisterDto> .ReturnSuccess(mapper.Map(entityToUpdate, entityDto)));
}
}
catch (Exception)
{
return(await ActionResponse <StudentRegisterDto> .ReturnError("Greška prilikom upisa matične knjige."));
}
}
public async Task <IActionResult> PostRegisterStudent(StudentRegisterDto student)
{
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(GetRegisterStudent)));
}
var result = await _repo.RegisterStudent(student);
if (result.IsSuccess)
{
return(RedirectToAction(
"GetRegisterStudent",
routeValues: new { info = result.Message }
));
}
return(RedirectToAction(
nameof(GetRegisterStudent),
routeValues: new { error = result.Message }
));
}
public IActionResult Register(StudentRegisterDto userRegisterDTO)
{
userRegisterDTO.Username = userRegisterDTO.Username.ToLower();
if (_authRepository.UserExists(userRegisterDTO.Username))
{
return(BadRequest("Username already exists!"));
}
var studentToCreate = new Student
{
Name = userRegisterDTO.Name,
Surname = userRegisterDTO.Surname,
Username = userRegisterDTO.Username,
Birthday = Convert.ToDateTime(userRegisterDTO.Birthday),
GroupId = userRegisterDTO.GroupId
};
var createdStudent = _authRepository.Register(studentToCreate, userRegisterDTO.Password);
return(StatusCode(201));
}
public async Task <RepoResponse <StudentReturnDto> > RegisterStudent(StudentRegisterDto registerCreds)
{
// Check for existing student:
var oldStudent = await _context.Students
.FirstOrDefaultAsync(s => registerCreds.Email.ToLower() == s.Email.ToLower() ||
s.CardNumber.ToLower() == registerCreds.CardNumber.ToLower());
if (oldStudent != null)
{
return(new RepoResponse <StudentReturnDto>()
{
IsSuccess = false,
Message = _config["ErrorCodes:record_exists"]
});
}
var student = new Student()
{
Id = Guid.NewGuid(),
Details = registerCreds.Details,
Email = registerCreds.Email,
Gender = registerCreds.Gender,
Name = registerCreds.Name,
Password = Helper.ComputeHash(registerCreds.Password),
Role = Role.Student,
SpecialityId = registerCreds.SpecialityId,
RegisterStatus = RegistrationStatus.Pending,
CardNumber = registerCreds.CardNumber
};
await _context.Students.AddAsync(student);
var contextResult = await _context.SaveChangesAsync();
if (contextResult > 0)
{
var studentReturn = await _context.Students
.AsNoTracking()
.Include(s => s.Speciality)
.Select(s => new StudentReturnDto()
{
Id = s.Id,
Details = s.Details,
Email = s.Email,
Gender = s.Gender,
Name = s.Name,
SpecialityId = s.SpecialityId,
SpecialityName = s.Speciality.Name,
RegisterStatus = s.RegisterStatus
})
.FirstOrDefaultAsync(s => s.Id == student.Id);
if (studentReturn != null)
{
return(new RepoResponse <StudentReturnDto>()
{
Content = studentReturn,
IsSuccess = true,
Message = _config["SuccessCodes:created"]
});
}
}
return(new RepoResponse <StudentReturnDto>()
{
IsSuccess = false,
Message = _config["ErrorCodes:db_error"]
});
}
public async Task <IActionResult> StudentRegister([FromBody] StudentRegisterDto dto)
{
StudentRegisterDtoValidator validator = new StudentRegisterDtoValidator();
ValidationResult result = await validator.ValidateAsync(dto);
if (result.IsValid)
{
#region 驗證重複
if (await _userManager.Users.AnyAsync(x => x.UserName == dto.UserName))
{
result.Errors.Add(new ValidationFailure("userName", "使用者名稱已經被使用"));
}
if (await _userManager.Users.AnyAsync(x => x.Email == dto.Email))
{
result.Errors.Add(new ValidationFailure("email", "電子郵件已經被使用"));
}
if (!string.IsNullOrEmpty(dto.PhoneNumber))
{
if (await _userManager.Users.AnyAsync(x => x.PhoneNumber == dto.PhoneNumber))
{
result.Errors.Add(new ValidationFailure("phoneNumber", "手機號碼已經被使用"));
}
}
if (!string.IsNullOrEmpty(dto.NationalId))
{
if (await _userManager.Users.AnyAsync(x => x.NationalId == dto.NationalId.ToUpper()))
{
result.Errors.Add(new ValidationFailure("nationalId", "身份證字號已經被使用"));
}
}
if (!string.IsNullOrEmpty(dto.NetworkId))
{
if (await _userManager.Users.AnyAsync(x =>
x.Administrator.NetworkId == dto.NetworkId.ToUpper() ||
x.Employee.NetworkId == dto.NetworkId.ToUpper() ||
x.Student.NetworkId == dto.NetworkId.ToUpper()))
{
result.Errors.Add(new ValidationFailure("networkId", "證號已經被使用"));
}
}
#endregion
if (result.IsValid)
{
var entity = _mapper.Map <ApplicationUser>(dto);
await using (var transaction = await _dbContext.Database.BeginTransactionAsync())
{
try
{
#region 建立使用者
if (await _userManager.CreateAsync(entity, dto.Password) != IdentityResult.Success)
{
throw new DbUpdateException();
}
#endregion
#region 添加 Claim
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, entity.Id),
new Claim(ClaimTypes.Name, entity.UserName),
new Claim(ClaimTypes.Email, entity.Email),
new Claim(ClaimTypes.Sid, entity.SecurityStamp)
};
if (await _userManager.AddClaimsAsync(entity, claims) != IdentityResult.Success)
{
throw new DbUpdateException();
}
#endregion
#region 添加角色
if (await _userManager.AddToRoleAsync(entity, "Student") != IdentityResult.Success)
{
throw new DbUpdateException();
}
#endregion
await transaction.CommitAsync();
}
catch (DbUpdateException)
{
await transaction.RollbackAsync();
throw;
}
}
#region 寄信
var link = $"{_configuration["FrontendUrl"]}/account/email/confirm" +
$"?userId={Uri.EscapeDataString(entity.Id)}" +
$"&token={Uri.EscapeDataString(await _userManager.GenerateEmailConfirmationTokenAsync(entity))}";
await _mailService.SendEmailConfirmAsync(entity.Email, entity.Email, link, true);
#endregion
var returnDto = _mapper.Map <StudentProfileDto>(entity);
return(CreatedAtAction(nameof(StudentProfile), null, returnDto));
}
}
return(BadRequest(result.Errors));
}
public async Task <ActionResponse <StudentRegisterEntryDto> > InsertEntry(StudentRegisterEntryInsertRequest request)
{
try
{
var transactionOptions = new TransactionOptions
{
IsolationLevel = IsolationLevel.ReadCommitted,
Timeout = TransactionManager.MaximumTimeout
};
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, transactionOptions, TransactionScopeAsyncFlowOption.Enabled))
{
if ((await GetEntriesForStudentAndProgram(request))
.IsNotSuccess(out ActionResponse <List <StudentRegisterEntryDto> > checkResponse, out List <StudentRegisterEntryDto> alreadyExisting))
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError(checkResponse.Message));
}
if (alreadyExisting.Any())
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError("Nemoguće unjeti novi zapis za kombinaciju studenta i edukacijskog programa, takav zapis već postoji."));
}
if ((await GetEntryForStudentNumberAndBookNumberAndBookYear(request))
.IsNotSuccess(out ActionResponse <StudentRegisterEntryDto> registerEntryResponse, out StudentRegisterEntryDto existingEntry))
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError(registerEntryResponse.Message));
}
if (alreadyExisting.Any())
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError("Nemoguće unjeti novi zapis jer zapis sa istim brojem studenta već postoji unutar izabrane knjige."));
}
if ((await PrepareForInsert(request))
.IsNotSuccess(out ActionResponse <StudentRegisterEntryInsertRequest> prepareResponse, out request))
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError(prepareResponse.Message));
}
if (request.CreateNewBook)
{
var entityDto = new StudentRegisterDto
{
BookNumber = request.BookNumber,
BookYear = request.BookYear,
};
if ((await Insert(entityDto)).IsNotSuccess(out ActionResponse <StudentRegisterDto> bookInsertResponse, out entityDto))
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError(bookInsertResponse.Message));
}
request.BookId = entityDto.Id;
}
var studentInGroup = unitOfWork.GetGenericRepository <StudentsInGroups>()
.ReadAllActiveAsQueryable()
.Where(sig => sig.StudentId == request.StudentId.Value &&
sig.StudentGroupId == request.StudentGroupId)
.FirstOrDefault();
if (studentInGroup == null)
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError("Specificirani student još ne postoji u grupi. Molimo prvo spremite studenta u grupu."));
}
var entityToAdd = new StudentRegisterEntry
{
StudentRegisterId = request.BookId.Value,
EducationProgramId = request.EducationProgramId.Value,
StudentsInGroupsId = studentInGroup.Id,
StudentRegisterNumber = request.StudentRegisterNumber.Value,
Notes = request.Notes,
EntryDate = request.EntryDate,
ExamDate = request.ExamDate,
ExamDateNumber = request.ExamDateNumber
};
unitOfWork.GetGenericRepository <StudentRegisterEntry>().Add(entityToAdd);
unitOfWork.Save();
if ((await GetById(request.BookId.Value))
.IsNotSuccess(out ActionResponse <StudentRegisterDto> bookResponse, out StudentRegisterDto registerDto))
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError(bookResponse.Message));
}
if (registerDto.NumberOfEntries >= 200)
{
if (request.CreateNewBook)
{
entityToAdd.StudentRegister.Full = true;
unitOfWork.Save();
}
else
{
registerDto.Full = true;
if ((await Update(registerDto)).IsNotSuccess(out bookResponse, out registerDto))
{
scope.Dispose();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError(bookResponse.Message));
}
}
}
scope.Complete();
return(await ActionResponse <StudentRegisterEntryDto> .ReturnSuccess(mapper.Map <StudentRegisterEntry, StudentRegisterEntryDto>(entityToAdd)));
}
}
catch (Exception)
{
return(await ActionResponse <StudentRegisterEntryDto> .ReturnError("Greška prilikom upisa u matičnu knjigu."));
}
//finally
//{
//var registerTask = cacheService.RefreshCache<List<StudentRegisterDto>>();
//var entryTask = cacheService.RefreshCache<List<StudentRegisterEntryDto>>();
//await Task.WhenAll(registerTask, entryTask);
//}
}
public ActionResult RegisterNewStudent(StudentRegisterDto model)
{
var nationalCode = model.NationalCode;
var person = _db.Set <Person>().Include(p => p.User.Student).FirstOrDefault(p => p.NationalCode == nationalCode);
if (person == null)
{
var newstudent = new Student
{
User = new User
{
Person = new Person
{
FirstName = model.FirstName,
LastName = model.LastName,
NationalCode = model.NationalCode,
MobileNo = model.CellPhoneNumber,
BirthDate = model.BirthDateJalali.ToGeorgianDateTime(),
BirthDateJalali = model.BirthDateJalali,
SexId = model.SexId,
FatherFirstName = model.FatherFirstName,
},
UserName = model.NationalCode,
Password = model.Password,
Status = true
},
ParentFirstName = model.ParentFirstName,
ParentLastName = model.ParentLastName,
CityOfBirthId = model.CityOfBirthId.Value,
CellPhoneNumber = model.CellPhoneNumber,
PhoneNumber = model.PhoneNumber,
CityOfHomeId = model.CityOfLocationId.Value
};
_db.Entry(newstudent).State = EntityState.Added;
_db.SaveChanges();
}
else
{
if (person.User.Student == null)
{
person.User.Student = new Student
{
ParentFirstName = model.ParentFirstName,
ParentLastName = model.ParentLastName,
CityOfBirthId = model.CityOfBirthId.Value,
CellPhoneNumber = model.CellPhoneNumber,
PhoneNumber = model.PhoneNumber,
CityOfHomeId = model.CityOfLocationId.Value
};
_db.Entry(person).State = EntityState.Modified;
_db.SaveChanges();
}
else
{
ModelState.AddModelError("", "دانش آموزی با این کد ملی از قبل وجود دارد. در صورتی که کد ملی را صحیح وارد نموده اید به بخش بازیابی رمز عبور مراجعه نمایید");
return(View(new StudentRegisterDto
{
Provinces = _db.Set <Province>().ToList().Select(p => new SelectListItem
{
Value = p.Id.ToString(),
Text = p.Name
}),
Sexes = _db.Set <Sex>().ToList().Select(s => new SelectListItem
{
Text = s.Name,
Value = s.Id.ToString()
}),
}));
}
}
return(View());
}
