public IActionResult GetSoSaoDanhGiaOfTruyen(int id)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var soSao = _repository.Truyen.GetDanhGiaSaoOfTruyenAsync(id);
return(Ok(soSao));
}
catch
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm GetTacGiaByDetails"
}));
}
}
public async Task <IActionResult> GetAllChuongsWithNoiDungChuong()
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var chuongs = await _repository.Chuong.GetAllChuongsAsync();
return(Ok(chuongs));
}
catch
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm GetAllChuongsWithNoiDungChuong"
}));
}
}
public async Task <IActionResult> GetTacGiaByDetails(int id)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var tacGia = await _repository.TacGia.GetTacGiaByDetailAsync(id);
if (tacGia == null)
{
return(NotFound());
}
else
{
var ownerResult = _mapper.Map <TacGiaDto>(tacGia);
return(Ok(ownerResult));
}
}
catch
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm GetTacGiaByDetails"
}));
}
}
public async Task <IActionResult> GetNoiDungChuongById(int id)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var noiDungChuong = await _repository.NoiDungChuong.GetNoiDungChuongByIdAsync(id);
if (noiDungChuong == null)
{
return(NotFound());
}
else
{
var noiDungChuongResult = _mapper.Map <NoiDungChuongDto>(noiDungChuong);
return(Ok(noiDungChuongResult));
}
}
catch
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm GetTheLoaiById"
}));
}
}
public IActionResult GetSoLuotTheoDoisByTruyenId(int id)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var soLuotTheoDoi = _repository.TheoDoi.GetLuotTheoDoiByTruyenID(id);
return(Ok(soLuotTheoDoi));
}
catch
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm GetSoLuotTheoDoisByTruyenId"
}));
}
}
public async Task <IActionResult> GetAllTacGias()
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var tacGias = await _repository.TacGia.GetAllTacGiasAsync();
var tacGiasResult = _mapper.Map <IEnumerable <TacGiaDto> >(tacGias);
return(Ok(tacGiasResult));
}
catch
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm GetAllTacGias"
}));
}
}
public IActionResult CreateTruyen([FromBody] IEnumerable <TruyenForCreationDto> truyen)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (truyen == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Thông tin trống"
}));
}
if (!ModelState.IsValid)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Các trường dữ liệu chưa đúng"
}));
}
var truyenEntity = _mapper.Map <IEnumerable <Truyen> >(truyen);
var response = _repository.Truyen.CreateTruyen(truyenEntity);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
var createdTruyen = _mapper.Map <IEnumerable <TruyenDto> >(truyenEntity);
_logger.LogInfo("Thêm mới danh sách truyện thành công");
return(Ok(createdTruyen));
}
catch (Exception ex)
{
_logger.LogError("Lỗi khi create list truyện: " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm CreateTruyen"
}));
}
}
public IActionResult CreateUser([FromBody] UserForCreationDto user)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (user == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Thông tin trống"
}));
}
if (!ModelState.IsValid)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Các trường dữ liệu chưa đúng"
}));
}
var userEntity = _mapper.Map <User>(user);
var response = _repository.User.CreateUser(userEntity);
if (response != null)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
var createdUser = _mapper.Map <UserDto>(userEntity);
_logger.LogInfo("User mới đăng ký với ID là: " + userEntity.UserID);
return(Ok(createdUser));
}
catch (Exception ex)
{
_logger.LogError("Lỗi khi create new user: "******"Lỗi execption ở hàm CreateUser"
}));
}
}
public async Task <IActionResult> UpdateAvatar([FromBody] UpdateUserAvatarDto updateUserAvatarDto)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (!ModelState.IsValid)
{
return(BadRequest("Các trường dữ liệu nhập vào chưa chính xác!"));
}
if (updateUserAvatarDto.HinhAnh == "")
{
return(BadRequest("Hình ảnh không được để trống!"));
}
var userRepo = await _repository.User.GetUserByIDAsync(updateUserAvatarDto.UserID);
if (userRepo == null)
{
return(BadRequest("Tài khoản không tồn tại!"));
}
//Ta cập nhật lại bảng user nhưng chỉ với trường dữ liệu là HinhAnh
ResponseDetails response = _repository.User.UpdateUser(new User()
{
UserID = userRepo.UserID,
ApplicationUserID = userRepo.ApplicationUserID,
Quyen = userRepo.Quyen,
TinhTrang = userRepo.TinhTrang,
HinhAnh = updateUserAvatarDto.HinhAnh,
RefreshToken = userRepo.RefreshToken,
RefreshTokenExpiryTime = userRepo.RefreshTokenExpiryTime,
UserName = userRepo.UserName
});
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
}
catch (Exception ex)
{
_logger.LogError($"Lỗi khi cập nhật avatar cho user với id {updateUserAvatarDto.UserID}: ${ex}");
}
return(Ok());
}
public async Task <IActionResult> UpdateTheLoai(int id, [FromBody] TheLoaiForUpdateDto theLoai)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (theLoai == null)
{
return(BadRequest("TheLoai object is null"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid model object"));
}
var theLoaiEntity = await _repository.TheLoai.GetTheLoaiByIdAsync(id);
if (theLoaiEntity == null)
{
return(NotFound());
}
_mapper.Map(theLoai, theLoaiEntity);
ResponseDetails response = _repository.TheLoai.UpdateTheLoai(theLoaiEntity);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi cập nhật thể loại có ID " + id + ": " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm UpdateTheLoai"
}));
}
}
public IActionResult CreateTheoDoi([FromBody] TheoDoiForCreationDto theoDoi)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (theoDoi == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Thông tin trống"
}));
}
if (!ModelState.IsValid)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Các trường dữ liệu chưa đúng"
}));
}
var theoDoiEntity = _mapper.Map <TheoDoi>(theoDoi);
var response = _repository.TheoDoi.CreateTheoDoi(theoDoiEntity);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
var createdTheoDoi = _mapper.Map <TheoDoiDto>(theoDoiEntity);
return(Ok(createdTheoDoi));
}
catch (Exception ex)
{
_logger.LogError("User " + theoDoi.UserID + " gặp lỗi khi tạo mới theo dõi truyện có ID " + theoDoi.TruyenID + ": " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm CreateTheoDoi"
}));
}
}
public IActionResult CreateBinhLuan([FromBody] BinhLuanForCreationDto binhLuan)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (binhLuan == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Thông tin trống"
}));
}
if (!ModelState.IsValid)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Các trường dữ liệu chưa đúng"
}));
}
var binhLuanEntity = _mapper.Map <BinhLuan>(binhLuan);
var response = _repository.BinhLuan.CreateBinhLuan(binhLuanEntity);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
var createdBinhLuan = _mapper.Map <BinhLuanDto>(binhLuanEntity);
return(Ok(createdBinhLuan));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi tạo mới bình luận: " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm CreateBinhLuan"
}));
}
}
public IActionResult CreateTacGia([FromBody] IEnumerable <TacGiaForCreationDto> tacGia)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (tacGia == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Thông tin trống"
}));
}
if (!ModelState.IsValid)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Các trường dữ liệu chưa đúng"
}));
}
var tacGiaEntity = _mapper.Map <IEnumerable <TacGia> >(tacGia);
ResponseDetails response = _repository.TacGia.CreateTacGia(tacGiaEntity);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
var createdTacGia = _mapper.Map <IEnumerable <TacGiaDto> >(tacGiaEntity);
return(Ok(createdTacGia));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi tạo mới tác giả: " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm CreateTacGia"
}));
}
}
public IActionResult CreateChuong([FromBody] IEnumerable <ChuongForCreationDto> chuong)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (chuong == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Thông tin trống"
}));
}
if (!ModelState.IsValid)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Các trường dữ liệu chưa đúng"
}));
}
var chuongEntity = _mapper.Map <IEnumerable <Chuong> >(chuong);
var response = _repository.Chuong.CreateChuong(chuongEntity);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
var createdChuong = _mapper.Map <IEnumerable <ChuongDto> >(chuongEntity);
return(Ok(createdChuong));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi tạo mới danh sách chương: " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm CreateChuong"
}));
}
}
public async Task <IActionResult> AdminLogin([FromBody] UserForAuthenticationDto userForAuthentication)
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var user = await _userManager.FindByEmailAsync(userForAuthentication.Email);
if (user == null)
{
return(BadRequest(new AuthResponseDto {
Message = "Tài khoản không tồn tại!"
}));
}
//Nếu validate có lỗi thì trả về bad request
var validate = _repository.Authenticate.ValidateLogin(userForAuthentication);
if (validate != null)
{
return(BadRequest(validate));
}
if (!await _userManager.CheckPasswordAsync(user, userForAuthentication.Password))
{
return(BadRequest(new AuthResponseDto {
Message = "Thông tin đăng nhập sai"
}));
}
var userGetting = await _repository.User.GetUserByApplicationUserIDAsync(user.Id);
if (userGetting.Quyen == Data.UserRole)
{
return(Unauthorized(new AuthResponseDto {
Message = "Bạn không có được cấp quyền vào admin"
}));
}
if (user.LockoutEnabled)
{
return(Unauthorized(new AuthResponseDto {
Message = "Bạn chưa được admin phê duyệt"
}));
}
return(Ok(userGetting));
}
public IActionResult UpdatePhuLuc([FromBody] IEnumerable <PhuLucForUpdateDto> phuLuc)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (phuLuc == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Thông tin trống"
}));
}
if (!ModelState.IsValid)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "Các trường dữ liệu chưa đúng"
}));
}
var phuLucsResult = _mapper.Map <IEnumerable <PhuLuc> >(phuLuc);
ResponseDetails response = _repository.PhuLuc.UpdatePhuLuc(phuLucsResult);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi cập nhật danh sách phụ lục của truyện: " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm UpdatePhuLuc"
}));
}
}
public async Task <IActionResult> Revoke(TokenApiModel tokenApiModel)
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (tokenApiModel is null)
{
return(BadRequest(new ResponseDetails()
{
Message = "Token body truyền vào không hợp lệ", StatusCode = ResponseCode.Error
}));
}
var principal = _tokenService.GetPrincipalFromExpiredToken(tokenApiModel.AccessToken, _config);
if (principal == null)
{
return(BadRequest(new ResponseDetails()
{
Message = "Token không được cấp quyền", StatusCode = ResponseCode.Error
}));
}
var userID = principal.Claims?.FirstOrDefault(x => x.Type.Equals(NamePars.ClaimSid, StringComparison.OrdinalIgnoreCase))?.Value;
var user = await _repository.User.GetUserByIDAsync(userID);
if (user == null || user.RefreshToken != tokenApiModel.RefreshToken)
{
return(BadRequest(new ResponseDetails()
{
Message = "các giá trị token không khớp với dữ liệu trong database", StatusCode = ResponseCode.Error
}));
}
ResponseDetails response = _repository.User.UpdateUserRefreshToken(user, null, null);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
_logger.LogError($"Lỗi khi revoke token cho user với id {user.UserID}");
}
return(Ok());
}
public async Task <IActionResult> GetTruyenByTheoDoiForPagination([FromQuery] TheoDoiParameters theoDoiParameters)
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (theoDoiParameters.GetAll)
{
var truyens = await _repository.TheoDoi.GetTruyenByTheoDoiForPagination(theoDoiParameters);
var metadata = new
{
truyens.TotalCount,
truyens.PageSize,
truyens.CurrentPage,
truyens.TotalPages,
truyens.HasNext,
truyens.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(truyens));
}
if (theoDoiParameters.LastestUpdate)
{
var theoDois = await _repository.TheoDoi.GetTheoDoiLastestForPagination(theoDoiParameters);
var metadata = new
{
theoDois.TotalCount,
theoDois.PageSize,
theoDois.CurrentPage,
theoDois.TotalPages,
theoDois.HasNext,
theoDois.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(theoDois));
}
else
{
return(BadRequest("wrong request to get theo doi pagination"));
}
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordDto resetPasswordDto)
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (!ModelState.IsValid)
{
return(BadRequest(new AuthResponseDto {
Message = "Các trường dữ liệu nhập vào chưa chính xác!"
}));
}
//Nếu validate có lỗi thì trả về bad request
var validate = _repository.Authenticate.ValidateResetPassword(resetPasswordDto);
if (validate != null)
{
return(BadRequest(validate));
}
var user = await _userManager.FindByEmailAsync(resetPasswordDto.Email);
if (user == null)
{
return(BadRequest(new AuthResponseDto {
Message = "Tài khoản không tồn tại!"
}));
}
var resetPassResult = await _userManager.ResetPasswordAsync(user, resetPasswordDto.Token, resetPasswordDto.Password);
if (!resetPassResult.Succeeded)
{
var errors = resetPassResult.Errors.Select(e => e.Description);
return(BadRequest(new { Errors = errors }));
}
await _userManager.SetLockoutEnabledAsync(user, false);
await _userManager.SetLockoutEndDateAsync(user, new DateTime(2000, 1, 1));
return(Ok());
}
public IActionResult CreateTheLoai([FromBody] IEnumerable <TheLoaiForCreationDto> theLoai)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (theLoai == null)
{
return(BadRequest("TheLoai object is null"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid model object"));
}
var theLoaiEntity = _mapper.Map <IEnumerable <TheLoai> >(theLoai);
ResponseDetails response = _repository.TheLoai.CreateTheLoai(theLoaiEntity);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
var createdTheLoai = _mapper.Map <IEnumerable <TheLoaiDto> >(theLoaiEntity);
return(Ok(createdTheLoai));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi tạo mới danh sách thể loại: " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm CreateTheLoai"
}));
}
}
public async Task <IActionResult> DeleteTheLoai(int id)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var theLoai = await _repository.TheLoai.GetTheLoaiByIdAsync(id);
if (theLoai == null)
{
return(NotFound());
}
if (_repository.PhuLuc.TheLoaisInPhuLuc(id).Any())
{
return(BadRequest(new ResponseDetails()
{
StatusCode = 500,
Message = "Không thể xóa TheLoai này. Tồn tại khóa ngoại tới bảng PhuLucs."
}));
}
ResponseDetails response = _repository.TheLoai.DeleteTheLoai(theLoai);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi cập nhật thể loại có ID " + id + ": " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = 500, Message = "Lỗi execption ở hàm DeleteTheLoai"
}));
}
}
public async Task <IActionResult> GetUserByDetails(string userid)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var user = await _repository.User.GetUserByUserIDDetailAsync(userid);
if (user == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "User không tồn tại"
}));
}
else
{
//var UserResult = _mapper.Map<UserDto>(User);
var userApp = await _userManager.FindByIdAsync(user.ApplicationUserID);
return(Ok(new UserInfo()
{
Email = userApp.Email,
UserName = user.UserName,
FirstName = userApp.FirstName,
LastName = userApp.LastName,
HinhAnh = user.HinhAnh,
TheoDois = user.TheoDois,
BinhLuans = user.BinhLuans
}));
}
}
catch
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm GetUserByDetails"
}));
}
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordDto forgotPasswordDto)
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (!ModelState.IsValid)
{
return(BadRequest(new AuthResponseDto {
Message = "Các trường dữ liệu nhập vào chưa chính xác!"
}));
}
var user = await _userManager.FindByEmailAsync(forgotPasswordDto.Email);
if (user == null)
{
return(BadRequest(new AuthResponseDto {
Message = "Tài khoản không tồn tại!"
}));
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
var param = new Dictionary <string, string>
{
{ "token", token },
{ "email", forgotPasswordDto.Email }
};
var callback = QueryHelpers.AddQueryString(forgotPasswordDto.ClientURI, param);
var message = new Message(new string[] { forgotPasswordDto.Email }, "Đặt lại mật khẩu", $"Vui lòng nhấn vào đường dẫn này để tiến hành đặt lại mật khẩu: {callback}", null);
await _emailSender.SendEmailAsync(message);
return(Ok());
}
public async Task <IActionResult> DeleteTacGia(int id)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var tacGia = await _repository.TacGia.GetTacGiaByIdAsync(id);
if (tacGia == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "ID tác giả không tồn tại"
}));
}
ResponseDetails response = _repository.TacGia.DeleteTacGia(tacGia);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi xóa tác giả với ID " + id + ": " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm DeleteTacGia"
}));
}
}
public async Task <IActionResult> DeleteNoiDungChuong(int id)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var noiDungChuong = await _repository.NoiDungChuong.GetNoiDungChuongByIdAsync(id);
if (noiDungChuong == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "ID Nội dung chương không tồn tại"
}));
}
ResponseDetails response = _repository.NoiDungChuong.DeleteNoiDungChuong(noiDungChuong);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi xóa nội dung chương với ID " + id + ": " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm DeleteNoiDungChuong"
}));
}
}
public async Task <IActionResult> DeleteTheoDoiForUser([FromQuery] TheoDoiParameters theoDoiParameters)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var theoDoi = await _repository.TheoDoi.GetTheoDoiByUserIdAndTruyenIdAsync(theoDoiParameters.UserID, theoDoiParameters.TruyenID);
if (theoDoi == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "ID TheoDoi không tồn tại"
}));
}
ResponseDetails response = _repository.TheoDoi.DeleteTheoDoi(theoDoi);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi xóa theo dõi có userID " + theoDoiParameters.UserID + " và truyện ID " + theoDoiParameters.TruyenID + ": " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm DeleteTheoDoiForUser"
}));
}
}
public async Task <IActionResult> GetAllUsers()
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var users = await _repository.User.GetAllUsersAsync();
var applicationUsers = await _userManager.Users.ToListAsync();
var result = (from m in users
join n in applicationUsers
on m.ApplicationUserID equals n.Id
select new UserDto {
UserID = m.UserID,
LockoutEnabled = n.LockoutEnabled,
Quyen = m.Quyen,
UserName = m.UserName,
HinhAnh = m.HinhAnh,
TinhTrang = m.TinhTrang
});
var usersResult = _mapper.Map <IEnumerable <UserDto> >(result);
return(Ok(usersResult));
}
catch
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm GetAllUsers"
}));
}
}
public async Task <IActionResult> DeleteUser(string userid)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var user = await _repository.User.GetUserByIDAsync(userid);
if (user == null)
{
return(NotFound(new ResponseDetails()
{
StatusCode = ResponseCode.Error, Message = "ID truyện không tồn tại"
}));
}
ResponseDetails response = _repository.User.DeleteUser(user);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError("Lỗi khi delete user " + userid + ": " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm DeleteUser"
}));
}
}
public async Task <IActionResult> SendMail([FromQuery] SendMailParameters mail)
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
if (mail.Address == "" || mail.Address == null)
{
return(BadRequest("Địa chỉ email không được để trống"));
}
var message = new Message(new string[] { mail.Address }, mail.Subject, mail.Content, null);
await _emailSender.SendEmailAsync(message);
return(Ok("Email gửi thành công!"));
}
public IActionResult DeleteMultipleNoiDungChuong([FromBody] IEnumerable <NoiDungChuongForDeleteDto> noiDungChuong)
{
try
{
var apiKeyAuthenticate = APICredentialAuth.APIKeyCheck(Request.Headers[NamePars.APIKeyStr]);
if (apiKeyAuthenticate.StatusCode == ResponseCode.Error)
{
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = apiKeyAuthenticate.Message
}));
}
var noiDungChuongEntity = _mapper.Map <IEnumerable <NoiDungChuong> >(noiDungChuong);
var response = _repository.NoiDungChuong.DeleteMultipleNoiDungChuong(noiDungChuongEntity);
if (response.StatusCode == ResponseCode.Success)
{
_repository.Save();
}
else
{
return(BadRequest(response));
}
return(Ok(noiDungChuongEntity));
}
catch (Exception ex)
{
_logger.LogError("Gặp lỗi khi xóa danh sách nội dung chương: " + ex);
return(BadRequest(new ResponseDetails()
{
StatusCode = ResponseCode.Exception, Message = "Lỗi execption ở hàm DeleteMultipleNoiDungChuong"
}));
}
}