public async Task <IActionResult> DeleteCourse(int courseId)
{
var course = unitOfWork.GetRepository <Course>().Get(s => s.Id == courseId, null, "Institude,Currency,Organizer.Country.City,CourTra.Trainer.TrainerNationality,CourRel.Reliance,CourseDayType,CourseType").FirstOrDefault();
if (course == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, "Product not found", ErrorCodes.ProductNotFound));
}
foreach (var item in course.CourRel)
{
await unitOfWork.GetRepository <CourRel>().DeleteAsync(item);
}
foreach (var item in course.CourTra)
{
await unitOfWork.GetRepository <CourTra>().DeleteAsync(item);
}
foreach (var item in course.CourseDayType)
{
await unitOfWork.GetRepository <CourseDayType>().DeleteAsync(item);
}
foreach (var item in course.CourseFavorite)
{
await unitOfWork.GetRepository <Favorite>().DeleteAsync(item);
}
await unitOfWork.GetRepository <Course>().DeleteAsync(course);
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Deleted"));
}
public IActionResult TrainersDetails(int trainerId)
{
var trainer = unitOfWork.GetRepository <Trainer>().Get(s => s.Id == trainerId, null, "CourTra.Course,Country,City").FirstOrDefault();
if (trainer == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, "Trainer not found", ErrorCodes.TrainerNotFound));
}
var trainerDetailsReturnModel = new TrainerDetailsReturnModel()
{
Id = trainer.Id,
Name = trainer.Name,
Country = trainer.Country.Name,
City = trainer.City.Name,
Gender = trainer.Gender,
About = trainer.About,
Avatar = trainer.Logo,
Major = trainer.Major,
Contact = new ContactTrainerReturnModel()
{
ContactNumber = trainer.ContactNumber,
Email = trainer.Email,
Facebook = trainer.Facebook,
Twitter = trainer.Twitter,
Instagram = trainer.Instagram,
},
OldCourses = new List <TrainerCounserBriefReturModel>(),
NewCourses = new List <TrainerCounserBriefReturModel>(),
};
foreach (var item in trainer.CourTra)
{
if (item.Course.EndDate < DateTime.Now)
{
var oldCourseItem = new TrainerCounserBriefReturModel()
{
Id = item.Course.Id,
Image = item.Course.Image,
};
trainerDetailsReturnModel.OldCourses.Add(oldCourseItem);
}
else if (item.Course.StartDate > DateTime.Now)
{
var newCourseItem = new TrainerCounserBriefReturModel()
{
Id = item.Course.Id,
Image = item.Course.Image,
};
trainerDetailsReturnModel.NewCourses.Add(newCourseItem);
}
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, trainerDetailsReturnModel));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
List <string> validationErrors = ErrorBuilder.BuildInvalidModelStateError(context.ModelState);
if (validationErrors != null && validationErrors.Count > 0)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.UnprocessableEntity, validationErrors,
ErrorCodes.ValidationError);
}
}
public async Task <IActionResult> UpdateTrainer([FromBody] TrainerDTO trainerDTO, int trainerId)
{
var data = unitOfWork.GetRepository <Trainer>().Get(s => s.Id == trainerId).FirstOrDefault();
if (data == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, "Trainer not found", ErrorCodes.TrainerNotFound));
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Updated"));
}
public async Task <IActionResult> RegisterInstitudeAccount([FromBody] InstitudeRegisterBindModel institudeModel)
{
User user = await RegisterInstitudeAccount(institudeModel.Email, institudeModel.Password, institudeModel.Name);
if (user == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, Account.RegisterFail, ErrorCodes.RegisterFailed));
}
return(await RespondJwtTokenTo(user, false));
}
public async Task <IActionResult> RegisterFactoryAccount([FromBody] FactoryAccountRegisterBindModel factoryModel)
{
ApplicationUser user = await RegisterFactoryUser(factoryModel.Email, factoryModel.Password, factoryModel.CompanyName, factoryModel.DeviceToken, UserRole.Factory, factoryModel.IsLookingCustomer, factoryModel.PhoneNumber, factoryModel.Address);
if (user == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, localizerAccount["RegisterFail"], ErrorCodes.RegisterFailed));
}
return(await RespondJwtTokenTo(user, false));
}
public async Task <IActionResult> Register([FromBody] RegisterDTO registerDTO)
{
ApplicationUser user = await RegisterPersonalUser(registerDTO);
if (user == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, localizerAccount["RegisterFail"], ErrorDefine.REGISTER_FAIL));
}
return(await RespondJwtTokenTo(user, false));
}
public async Task <IActionResult> Register([FromBody] TraineeRegisterBindModel personalModel)
{
User user = await Register(personalModel.PhoneNumber, personalModel.Password, personalModel.CountryId, personalModel.CityId, personalModel.Sex, personalModel.Email, personalModel.Role);
if (user == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, Account.RegisterFail, ErrorCodes.RegisterFailed));
}
return(await RespondJwtTokenTo(user, false));
}
public async Task <IActionResult> DeleteInstitude(int institudeId)
{
var institute = unitOfWork.GetRepository <Institute>().Get(s => s.Id == institudeId, null, "Course,Country,City").FirstOrDefault();
if (institute == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, "Institute not found", ErrorCodes.TrainerNotFound));
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Deleted"));
}
public IActionResult InstituteDetails(int instituteId)
{
var institute = unitOfWork.GetRepository <Institute>().Get(s => s.Id == instituteId, null, "Course,Country,City").FirstOrDefault();
if (institute == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, "Institute not found", ErrorCodes.TrainerNotFound));
}
var instituteDetailsReturnModel = new InstituteDetailsReturnModel()
{
Id = institute.Id,
Name = institute.Name,
Country = institute.Country.Name,
City = institute.City.Name,
About = institute.About,
Logo = institute.Logo,
Contact = new InstituteContactReturnModel()
{
ContactNumber = institute.TelePhoneNumber,
Email = institute.Email,
Facebook = institute.Facebook,
Twitter = institute.Twitter,
Instagram = institute.Instagram,
},
OldCourse = new List <InstituteCounserBriefReturModel>(),
NewCourse = new List <InstituteCounserBriefReturModel>(),
};
foreach (var item in institute.Course)
{
if (item.EndDate < DateTime.Now)
{
var oldCourseItem = new InstituteCounserBriefReturModel()
{
Id = item.Id,
Image = item.Image,
};
instituteDetailsReturnModel.OldCourse.Add(oldCourseItem);
}
else if (item.StartDate > DateTime.Now)
{
var newCourseItem = new InstituteCounserBriefReturModel()
{
Id = item.Id,
Image = item.Image,
};
instituteDetailsReturnModel.NewCourse.Add(newCourseItem);
}
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, instituteDetailsReturnModel));
}
public IActionResult GetGradeQuestion(int grandNumber, string mathType)
{
var questions = _grandeQuestionStore.Find(s => s.Grande(grandNumber) && s.MathType(mathType))?.GennerateAnwersQuestion();
if (questions == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, "Can not generate question", ErrorDefine.CAN_NOT_FIND_GRANDE_QUESTION));
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, questions));
}
public async Task <IActionResult> RegisterPersonalAccount([FromBody] PersonalAccountRegisterBindModel personalModel)
{
ApplicationUser user = await RegisterPersonalUser(personalModel.Email, personalModel.Password, personalModel.FullName, personalModel.CompanyName, personalModel.DeviceToken, UserRole.Personal);
if (user == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, localizerAccount["RegisterFail"], ErrorCodes.RegisterFailed));
}
return(await RespondJwtTokenTo(user, false));
}
public IActionResult GetCourseDetails(int courseId)
{
var course = unitOfWork.GetRepository <Course>().Get(s => s.Id == courseId, null, "Institude,Currency,Organizer.Country.City,CourTra.Trainer.TrainerNationality,CourRel.Reliance,CourseDayType,CourseType").FirstOrDefault();
if (course == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, "Product not found", ErrorCodes.ProductNotFound));
}
var data = mapper.Map <Course, CourseDetailsReturnModel>(course);
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, data));
}
public async Task <IActionResult> RejectCourse(int courseId)
{
var course = unitOfWork.GetRepository <Course>().Get(s => s.Id == courseId, null, "Institude,Currency,Organizer.Country.City,CourTra.Trainer.TrainerNationality,CourRel.Reliance,CourseDayType,CourseType").FirstOrDefault();
if (course == null)
{
return(ApiResponder.RespondFailureTo(HttpStatusCode.Ok, "Product not found", ErrorCodes.ProductNotFound));
}
course.IsApproved = false;
await unitOfWork.GetRepository <Course>().UpdateAsync(course);
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Rejected"));
}
public override void OnException(ExceptionContext context)
{
if (context.Exception is FailedModelValidationException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.UnprocessableEntity,
new[] { context.Exception.Message }, ErrorCodes.ValidationError);
}
if (context.Exception is FailedRegistrationException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.NotImplemented,
new[] { context.Exception.Message }, ErrorCodes.RegisterFailed);
}
else if (context.Exception is UserNotExistsException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.NotFound,
new[] { context.Exception.Message }, ErrorCodes.UserNotFound);
}
else if (context.Exception is IncorrectPasswordException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.NotFound,
new[] { context.Exception.Message }, ErrorCodes.IncorrectPassword);
}
else if (context.Exception is InvalidPinCodeException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.BadRequest,
new[] { context.Exception.Message }, ErrorCodes.InvalidPinCode);
}
else if (context.Exception is PinCodeExpiredException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.BadRequest,
new[] { context.Exception.Message }, ErrorCodes.PinCodeExpired);
}
else
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.InternalServerError,
new[] { context.Exception.Message }, ErrorCodes.GeneralCode);
}
}
public override void OnException(ExceptionContext context)
{
if (context.Exception is FailedModelValidationException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.UnprocessableEntity,
new[] { context.Exception.Message }, ErrorDefine.INVALID_MODEL);
}
if (context.Exception is FailedRegistrationException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.NotImplemented,
new[] { context.Exception.Message }, ErrorDefine.REGISTER_FAIL);
}
else if (context.Exception is UserNotExistsException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.NotFound,
new[] { context.Exception.Message }, ErrorDefine.USER_NOT_FOUND);
}
else if (context.Exception is IncorrectPasswordException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.NotFound,
new[] { context.Exception.Message }, ErrorDefine.INCORECT_PASSWORD);
}
else if (context.Exception is InvalidPinCodeException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.BadRequest,
new[] { context.Exception.Message }, ErrorDefine.INVALID_PIN_CODE);
}
else if (context.Exception is PinCodeExpiredException)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.BadRequest,
new[] { context.Exception.Message }, ErrorDefine.PIN_CODE_EXPIRED);
}
else
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.InternalServerError,
new[] { context.Exception.Message }, ErrorDefine.GENERAL_CODE);
}
}
public override void OnActionExecuting(ActionExecutingContext context)
{
StringValues token;
httpCotext.HttpContext.Request.Headers.TryGetValue("Authorization", out token);
//if (token == string.Empty)
// context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.UnAuthorize, "UNAUTHORIZE",
// ErrorDefine.UNAUTHORIZE);
//else
//{
// var userId = Convert.ToInt32(DecodingToken(token));
// if(userId != 0)
// {
// var usreInfo = unitOfWork.GetRepository<ApplicationUser>().Get(s => s.Id == userId).FirstOrDefault();
// if(usreInfo.JwtToken != token)
// context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.UnAuthorize, "UNAUTHORIZE",
// ErrorDefine.UNAUTHORIZE);
// }
// else
// context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.UnAuthorize, "UNAUTHORIZE",
// ErrorDefine.UNAUTHORIZE);
//}
var userId = Convert.ToInt32(DecodingToken(token));
if (userId != 0)
{
var usreInfo = unitOfWork.GetRepository <ApplicationUser>().Get(s => s.Id == userId).FirstOrDefault();
if (usreInfo.JwtToken != token)
{
context.Result = ApiResponder.RespondFailureTo(HttpStatusCode.UnAuthorize, "UNAUTHORIZE",
ErrorDefine.UNAUTHORIZE);
}
}
base.OnActionExecuting(context);
}
