public IActionResult City()
{
var language = this.HeaderLanguage();
var charterCapitalReturn = new List <CompanySizeReturnModel>();
var charterCapital = unitOfWork.GetRepository <City>().Get().ToList();
if (language == "vi")
{
foreach (var item in charterCapital)
{
var charterCapitalItemReturn = new CompanySizeReturnModel()
{
Id = item.Id,
Name = item.Name,
};
charterCapitalReturn.Add(charterCapitalItemReturn);
}
}
else if (language == "en-US")
{
foreach (var item in charterCapital)
{
var companySizeItemReturn = new CompanySizeReturnModel()
{
Id = item.Id,
Name = item.Name,
};
charterCapitalReturn.Add(companySizeItemReturn);
}
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, charterCapitalReturn));
}
public async Task <IActionResult> TestPushMessage(string deviceToken)
{
try
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("https://onesignal.com");
client.DefaultRequestHeaders.Add("authorization", "Basic NDBmZWQyZDktNDIwZi00NWMxLWEzZWQtODUzMGMxNzhhM2Ez");
var obj = new
{
app_id = "e97913c0-0f01-4bac-8fc0-4fecfb87d8f2",
contents = new { en = "Duc Nguyen" + ": " + "Ich nhau nhe" },
data = new { userid = 1 },
include_player_ids = new string[] { deviceToken }
};
var jsonPost = JsonConvert.SerializeObject(obj);
var content = new StringContent(jsonPost, Encoding.UTF8, "application/json");
var result = await client.PostAsync("/api/v1/notifications", content);
string resultContent = await result.Content.ReadAsStringAsync();
Console.WriteLine(resultContent);
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Push ok"));
}
catch (Exception ex)
{
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Push ok"));
}
}
public IActionResult ScopeBusiness()
{
var language = this.HeaderLanguage();
var scopeBusinesesReturn = new List <ScopeBusinessReturnModel>();
var scopeBusinesses = unitOfWork.GetRepository <ScopeBusiness>().Get().ToList();
if (language == "vi")
{
foreach (var item in scopeBusinesses)
{
var scopeBusinessItemReturn = new ScopeBusinessReturnModel()
{
Id = item.Id,
Name = item.NameVI,
};
scopeBusinesesReturn.Add(scopeBusinessItemReturn);
}
}
else if (language == "en-US")
{
foreach (var item in scopeBusinesses)
{
var scopeBusinessItemReturn = new ScopeBusinessReturnModel()
{
Id = item.Id,
Name = item.NameEN,
};
scopeBusinesesReturn.Add(scopeBusinessItemReturn);
}
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, scopeBusinesesReturn));
}
public async Task <IActionResult> CreateTokenPurchaseRequest([FromBody] TokenTransactionInsertModel model)
{
var userId = long.Parse(User.Claims.First().Subject.Name);
var result = await _tokenService.CreateTokenPurchaseRequest(userId, model);
return(ApiResponder.RespondSuccess(result));
}
public async Task <IActionResult> UpdateBusinessProfile([FromBody] BusinessProfileBindModel businessModel)
{
using (var transaction = unitOfWork.GetContext().Database.BeginTransaction())
{
try
{
var userId = Convert.ToInt32(userManager.GetUserId(User));
var businessProfile = new Profile()
{
ApplicationUserId = userId,
RoleId = Enums.UserRole.Business,
FoundedYear = businessModel.FoundedYear,
Vision = businessModel.Vision,
Address = businessModel.Address,
CompanyDesciption = businessModel.CompanyDesciption,
WebSite = businessModel.WebSite,
EmailContact = businessModel.EmailContact,
PhoneNumberContact = businessModel.PhoneNumberContact,
ProductDescription = businessModel.ProductDescription,
ProductRequirement = businessModel.ProductRequirement,
TotalProductNeeded = businessModel.TotalProductNeeded,
PriceId = businessModel.PriceId,
Lat = businessModel.Lat,
Lng = businessModel.Lng,
};
var businessProfileAdded = await unitOfWork.GetRepository <Profile>().InsertAsync(businessProfile);
foreach (var item in businessModel.FocusIndustry)
{
var profileFocusIndustry = new ProfileFocusIndustry()
{
ProfileId = businessProfileAdded.Id,
FocusIndustryId = item,
};
await unitOfWork.GetRepository <ProfileFocusIndustry>().InsertAsync(profileFocusIndustry);
}
// update user role
var applicationUser = unitOfWork.GetRepository <ApplicationUser>().Get(s => s.Id == userId).FirstOrDefault();
applicationUser.RoleId = Enums.UserRole.Business;
applicationUser.IsCompleteProfile = true;
await unitOfWork.GetRepository <ApplicationUser>().UpdateAsync(applicationUser);
transaction.Commit();
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Updated Business Account"));
}
catch (Exception ex)
{
transaction.Rollback();
throw;
}
}
}
public async Task <IActionResult> CreateUserTokenPurchaseRequestBilling(long id)
{
var userId = long.Parse(User.Claims.First().Subject.Name);
var result = await _tokenService.CreateUserBilling(userId, id);
return(ApiResponder.RespondSuccess(result));
}
public IActionResult SearchCourse([FromBody] FavoriteBindModel favoriteModel)
{
var userId = Convert.ToInt32(userManager.GetUserId(User));
var courses = unitOfWork.GetRepository <Course>().Get(null, null, "Organizer.Country.City,Institude,Currency").ToList();
var lstCoursesBriefDetails = new List <CourseDetailsBriefReturnModel>();
foreach (var item in courses)
{
if (item.Organizer.CityId == favoriteModel.CityId && item.CourseTypeId == favoriteModel.CourseTypeId && item.CourseScopeId == favoriteModel.CourseScopeId && item.Gender == favoriteModel.Gender)
{
var coureseBriefDetailsItem = new CourseDetailsBriefReturnModel()
{
Id = item.Id,
Currency = item.Currency.Name,
Gender = item.Gender,
Name = item.Name,
InstituteId = item.InstituteId,
Image = item.Name,
InstituteName = item.Institude.Name,
MainPrice = item.MainPrice,
MotivationPrice = item.MotivationPrice,
StartDate = item.StartDate,
TotalDay = item.TotalDay,
Country = item.Organizer.Country.Name,
City = item.Organizer.City.Name,
};
lstCoursesBriefDetails.Add(coureseBriefDetailsItem);
}
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, lstCoursesBriefDetails));
}
public async Task <IActionResult> GetUserOrders(int page = 1, int count = 10)
{
var userId = long.Parse(User.Claims.First().Subject.Name);
var result = await _orderService.GetUserOrders(userId, page, count);
return(ApiResponder.RespondSuccess(result, null, result.GetPaginationData()));
}
public async Task <IActionResult> GetUsers([FromQuery] UserAccountFilterModel filterModel,
int count = 10, int page = 1)
{
var result = await _accountService.GetUsers(page, count, filterModel);
return(ApiResponder.RespondSuccess(result, null, result.GetPaginationData()));
}
public async Task <IActionResult> Checkout(CheckoutTransferModel model)
{
var userId = long.Parse(User.Claims.First().Subject.Name);
var result = await _orderService.Checkout(userId, model);
return(ApiResponder.RespondSuccess(result));
}
public async Task <IActionResult> GetUserOrder(long id)
{
var userId = long.Parse(User.Claims.First().Subject.Name);
var result = await _orderService.GetUserOrder(userId, id);
return(ApiResponder.RespondSuccess(result));
}
public IActionResult IsCompleteProfile()
{
var userId = Convert.ToInt32(userManager.GetUserId(User));
var applicationUser = unitOfWork.GetRepository <ApplicationUser>().Get(s => s.Id == userId).FirstOrDefault();
if (applicationUser == null)
{
throw new UserNotExistsException(localizerAccount["UserNotFound"]);
}
bool isComplete = false;
if (applicationUser.IsCompleteProfile)
{
isComplete = true;
}
var obj = new
{
IsCompelete = isComplete,
UserType = applicationUser.RoleId,
};
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, obj));
}
public IActionResult GetFeaturedCourse(int page, int pageSize)
{
var courses = unitOfWork.GetRepository <Course>().Get(null, null, "Organizer.Country.City,Institude,Currency").Skip((page - 1) * pageSize).Take(pageSize).ToList();
var lstCoursesBriefDetails = new List <CourseDetailsBriefReturnModel>();
foreach (var item in courses)
{
var totalDay = (item.EndDate - item.StartDate).TotalDays;
var coureseBriefDetailsItem = new CourseDetailsBriefReturnModel()
{
Id = item.Id,
Currency = item.Currency.Name,
Gender = item.Gender,
Name = item.Name,
InstituteId = item.InstituteId,
Image = item.Image,
InstituteName = item.Institude.Name,
MainPrice = item.MainPrice,
MotivationPrice = item.MotivationPrice,
StartDate = item.StartDate,
TotalDay = item.TotalDay,
Country = item.Organizer.Country.Name,
City = item.Organizer.City.Name,
};
lstCoursesBriefDetails.Add(coureseBriefDetailsItem);
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, lstCoursesBriefDetails));
}
public async Task <IActionResult> GetCurrentUserBalance()
{
var userId = long.Parse(User.Claims.First().Subject.Name);
var result = await _tokenService.GetUserBalance(userId);
return(ApiResponder.RespondSuccess(result));
}
public async Task <IActionResult> GetInventory([FromQuery] InventoryFilterModel filterModel,
int count = 10, int page = 1)
{
var result = await _inventoryService.GetInventory(page, count, filterModel);
return(ApiResponder.RespondSuccess(result, null, result.GetPaginationData()));
}
public async Task <IActionResult> CreateCourse([FromBody] CourseDTO course)
{
var institude = unitOfWork.GetRepository <Institute>().Get(s => s.UserId == UserIdRequested()).FirstOrDefault();
var dataInsert = mapper.Map <CourseDTO, Course>(course);
dataInsert.InstituteId = institude.Id;
var courseInserted = await unitOfWork.GetRepository <Course>().InsertAsync(dataInsert);
//foreach (var item in course.Trainers)
//{
// var courseTrainerItem = new CourTra()
// {
// CourseId = courseInserted.Id,
// TrainerId = item,
// };
// await unitOfWork.GetRepository<CourTra>().InsertAsync(courseTrainerItem);
//}
//foreach (var item in course.Reliances)
//{
// var courseRelianceItem = new CourRel()
// {
// CourseId = courseInserted.Id,
// RelianceId = item,
// };
// await unitOfWork.GetRepository<CourRel>().InsertAsync(courseRelianceItem);
//}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, courseInserted));
}
public async Task <IActionResult> ForgotPassword(string email)
{
User currentUser = await userManager.FindByEmailAsync(email);
if (currentUser == null)
{
throw new UserNotExistsException(Account.UsetNotFound);
}
int pinCode = new Random().Next(100000, 999999);
currentUser.PinCode = pinCode;
currentUser.PinCodeExpiration = DateTime.UtcNow.AddHours(PinCodeExpirationTime);
IdentityResult updateUserResult = await userManager.UpdateAsync(currentUser);
if (!updateUserResult.Succeeded)
{
throw new IdentityException(updateUserResult.Errors.FirstOrDefault().Description);
}
string message = System.IO.File.ReadAllText(@"./HtmlPages/Email.html");
await emailSender.SendEmailAsync(email, "Pin Code Confirmation",
String.Format(message, currentUser.UserName, pinCode.ToString()));
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Please check your email to setup new password"));
}
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 GetTrainers(int page, int pageSize)
{
var lstTrainerBirefReturnModel = new List <TrainerBirefReturnModel>();
var traineres = unitOfWork.GetRepository <Trainer>().Get(null, null, "CourTra.Course").Skip((page - 1) * pageSize).Take(pageSize).ToList();
foreach (var item in traineres)
{
var trainerBriefItem = new TrainerBirefReturnModel()
{
Id = item.Id,
Avatar = item.Logo,
Name = item.Name,
Major = item.Major,
};
foreach (var itemTrainer in item.CourTra)
{
if (itemTrainer.Course.StartDate < DateTime.Now)
{
trainerBriefItem.TotalActive += 1;
}
}
lstTrainerBirefReturnModel.Add(trainerBriefItem);
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, lstTrainerBirefReturnModel));
}
public async Task <IActionResult> ResetPassword(string email, string newPassword, int pinCode)
{
User currentUser = await userManager.FindByEmailAsync(email);
if (currentUser == null)
{
throw new UserNotExistsException(Account.UsetNotFound);
}
if (currentUser.PinCode != pinCode)
{
throw new InvalidPinCodeException(Account.InvalidPinCode);
}
if (currentUser.PinCodeExpiration < DateTime.UtcNow)
{
throw new PinCodeExpiredException(Account.PinCodeExpired);
}
IdentityResult deletePasswordResult = await userManager.RemovePasswordAsync(currentUser);
if (!deletePasswordResult.Succeeded)
{
throw new IdentityException(deletePasswordResult.Errors.FirstOrDefault().Description);
}
IdentityResult addPasswordResult = await userManager.AddPasswordAsync(currentUser, newPassword);
if (!addPasswordResult.Succeeded)
{
throw new IdentityException(addPasswordResult.Errors.FirstOrDefault().Description);
}
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Update new password sucessfully"));
}
public IActionResult NormalFilter([FromBody] NormalFilterBindModel normalfileModel)
{
var factoriesReturn = new List <FactoryBriefReturnModel>();
bool isEnableFavorite = false;
Expression <Func <Profile, bool> > filter;
var userId = Convert.ToInt32(userManager.GetUserId(User));
if (userId != 0)
{
isEnableFavorite = true;
}
filter = s0 => (s0.CompanyName.ToLower().Contains(normalfileModel.Key.ToLower()) ||
s0.ProfileScopeBusiness.Any(r => normalfileModel.ScopeBusinesses.Contains(r.ScopeBusinessId)) ||
normalfileModel.CityId.Contains(s0.CityId))
|| (s0.ProfileScopeBusiness.Any(r => r.ScopeBusiness.NameVI.ToLower().Contains(normalfileModel.Key.ToLower()) || r.ScopeBusiness.NameEN.ToLower().Contains(normalfileModel.Key.ToLower())) ||
s0.ProfileScopeBusiness.Any(r => normalfileModel.ScopeBusinesses.Contains(r.ScopeBusinessId)) ||
normalfileModel.CityId.Contains(s0.CityId));
var resultNumber = unitOfWork.GetContext().Profile.Where(filter).Count();
var profileFavorite = unitOfWork.GetRepository <ProfileFavorite>().Get(s => s.ApplicationUserId == userId).ToList();
var factories = unitOfWork.GetRepository <Profile>().Get(filter, null, "ProfileScopeBusiness.ScopeBusiness").Skip((normalfileModel.Page - 1) * normalfileModel.PageSize).Take(normalfileModel.PageSize).ToList();
foreach (var item in factories)
{
var factoryBriefReturn = new FactoryBriefReturnModel()
{
Id = item.Id,
Name = item.CompanyName,
LocationName = item.Address,
IsFavorite = profileFavorite.Any(s => s.ApplicationUserId == userId && s.ProfileId == item.Id) ? true : false,
};
factoryBriefReturn.ScopeBusiness = new List <string>();
foreach (var itemScopeBusiness in item.ProfileScopeBusiness)
{
if (HeaderLanguage() == "en-US")
{
factoryBriefReturn.ScopeBusiness.Add(itemScopeBusiness.ScopeBusiness.NameEN);
}
else if (HeaderLanguage() == "vi")
{
factoryBriefReturn.ScopeBusiness.Add(itemScopeBusiness.ScopeBusiness.NameVI);
}
}
factoriesReturn.Add(factoryBriefReturn);
}
var factoriesObjectReturn = new
{
ResultNumber = resultNumber,
Factories = factoriesReturn,
IsEnableFavorite = isEnableFavorite,
};
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, factoriesObjectReturn));
}
public async Task <IActionResult> GetUserTokenPurchaseRequests(int count = 10, int page = 1)
{
var userId = long.Parse(User.Claims.First().Subject.Name);
var result = await _tokenService.GetUserTokenPurchaseRequests(userId, count, page);
return(ApiResponder.RespondSuccess(result, null, result.GetPaginationData()));
}
public IActionResult BaseToByteArray(string input)
{
var input2 = ValidateBase64EncodedString(input);
byte[] decodedBytes = Convert.FromBase64String(input2);
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "ok"));
}
public async Task <IActionResult> UpdateFactoryProfile([FromBody] FactoryProfileBindModel factoryModel)
{
using (var transaction = unitOfWork.GetContext().Database.BeginTransaction())
{
try
{
var userId = Convert.ToInt32(userManager.GetUserId(User));
var factoryProfile = new Profile()
{
ApplicationUserId = userId,
RoleId = Enums.UserRole.Factory,
CompanyName = factoryModel.CompanyName,
TypicalProduct = factoryModel.TypicalProduct,
Address = factoryModel.Address,
FoundedYear = factoryModel.FoundedYear,
CompanyDesciption = factoryModel.CompanyDesciption,
WebSite = factoryModel.WebSite,
EmailContact = factoryModel.EmailContact,
PhoneNumberContact = factoryModel.PhoneNumberContact,
CompanySizeId = factoryModel.CompanySizeId,
CharterCapitalId = factoryModel.CharterCapitalId,
ProductionCapacityId = factoryModel.ProductionCapacityId,
RevenueId = factoryModel.RevenueId,
MarketId = factoryModel.MarketId,
CityId = factoryModel.CityId,
Lat = factoryModel.Lat,
Lng = factoryModel.Lng,
};
var businessProfileAdded = await unitOfWork.GetRepository <Profile>().InsertAsync(factoryProfile);
foreach (var item in factoryModel.ScopeBusinesses)
{
var profileScopeBuniness = new ProfileScopeBusiness()
{
ProfileId = businessProfileAdded.Id,
ScopeBusinessId = item,
};
await unitOfWork.GetRepository <ProfileScopeBusiness>().InsertAsync(profileScopeBuniness);
}
var applicationUser = unitOfWork.GetRepository <ApplicationUser>().Get(s => s.Id == userId).FirstOrDefault();
applicationUser.RoleId = Enums.UserRole.Factory;
applicationUser.IsCompleteProfile = true;
transaction.Commit();
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Updated Factory Profile"));
}
catch (Exception ex)
{
transaction.Rollback();
throw;
}
}
}
public IActionResult ChatHistory(int userId, int page, int pageSize, int totalSkipItem)
{
var myUserId = Convert.ToInt32(userManager.GetUserId(User));
var messageHistory = unitOfWork.GetRepository <Message>().Get(s => (s.ApplicationUserId == myUserId && s.ReceiverId == userId) || (s.ApplicationUserId == userId && s.ReceiverId == myUserId)).OrderByDescending(s => s.Id).Skip(totalSkipItem + ((page - 1) * pageSize)).Take(pageSize).ToList();
var messageFinal = messageHistory.OrderBy(s => s.Id);
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, messageFinal));
}
public async Task <IActionResult> ProcessCoinGateHook([FromForm] CoinGateHookTransferModel model)
{
foreach (var key in Request.Form.Keys)
{
switch (key)
{
case "order_id":
model.OrderId = long.Parse(Request.Form[key]);
break;
case "status":
model.Status = Request.Form[key];
break;
case "id":
model.Id = long.Parse(Request.Form[key]);
break;
case "price_amount":
model.PriceAmount = float.Parse(Request.Form[key]);
break;
case "price_currency":
model.PriceCurrency = Request.Form[key];
break;
case "receive_amount":
model.ReceiveAmount = float.Parse(Request.Form[key]);
break;
case "receive_currency":
model.ReceiveCurrency = Request.Form[key];
break;
case "pay_amount":
model.PayAmount = float.Parse(Request.Form[key]);
break;
case "pay_currency":
model.PayCurrency = Request.Form[key];
break;
case "created_at":
model.CreatedAt = DateTime.Parse(Request.Form[key]);
break;
case "token":
model.Token = Request.Form[key];
break;
}
}
await _tokenService.ProcessCoinGateHook(model);
return(ApiResponder.RespondStatusCode(HttpStatusCode.OK));
}
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 async Task <IActionResult> RegisterInternalAccount([FromBody] UserRegisterModel model, [FromHeader(Name = "X-Internal-Hail-Mary-Token")] string internalToken)
{
if (!internalToken.Equals(InternalHailMaryToken))
{
return(ApiResponder.RespondStatusCode(HttpStatusCode.Unauthorized));
}
await _accountService.RegisterAccount(model, UserType.InternalUser);
return(ApiResponder.RespondStatusCode(HttpStatusCode.Created));
}
public async Task <IActionResult> CreateNewTrainer([FromBody] TrainerDTO trainerDTO)
{
var dataInsert = mapper.Map <TrainerDTO, Trainer>(trainerDTO);
dataInsert.InstituteId = UserIdRequested();
await unitOfWork.GetRepository <Trainer>().InsertAsync(dataInsert);
return(ApiResponder.RespondSuccessTo(HttpStatusCode.Ok, "Added"));
}
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);
}
}
