public async Task AddUserRolesAsync(ChangeUserRolesBaseModel model)
{
#region Validation
var userInfo = BusinessContext.Current?.PrincipalInfo;
var validationData = new ValidationData();
// validation logic here
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
var appUser = await _userManager.FindByNameAsync(model.Username);
if (appUser == null)
{
throw AppValidationException.From(ResultCode.EntityNotFound);
}
var result = await _userManager.AddToRolesAsync(appUser, model.Roles);
if (result.Succeeded)
{
return;
}
foreach (var err in result.Errors)
{
validationData.Fail(err.Description, ResultCode.Identity_FailToChangeUserRoles, err);
}
throw validationData.BuildException();
}
public async Task RemoveUserRolesAsync(ChangeUserRolesBaseModel model)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
// validation logic here
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
var appUser = await _userManager.FindByNameAsync(model.Username);
if (appUser == null)
{
throw AppValidationException.From(resultLocalizer, ResultCode.EntityNotFound);
}
var result = await _userManager.RemoveFromRolesAsync(appUser, model.Roles);
if (result.Succeeded)
{
return;
}
foreach (var err in result.Errors)
{
validationData.Fail(code: ResultCode.Identity_FailToChangeUserRoles, data: err);
}
throw validationData.BuildException();
}
public Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (!context.ModelState.IsValid)
{
List <ValidationFailure> failures = new List <ValidationFailure>();
foreach (var item in context.ModelState)
{
foreach (var error in item.Value.Errors)
{
failures.Add(new ValidationFailure(item.Key, error.ErrorMessage));
}
}
var exception = new AppValidationException(failures);
var responseObj = Result.Failed(exception.Message, exception.Failures);
context.Result = new JsonResult(responseObj)
{
StatusCode = (int)HttpStatusCode.BadRequest
};
return(Task.CompletedTask);
}
else
{
return(next());
}
}
public AppValidationException BuildException()
{
if (IsValid)
{
throw new InvalidOperationException("This validation is valid");
}
return(AppValidationException.From(_localizer, this));
}
private Task HandleException(HttpContext context, AppValidationException e)
{
string result = JsonConvert.SerializeObject(e.ErrorResponse.Errors);
int statusCode = (int)e.ErrorResponse.HttpStatusCode;
context.Response.ContentType = "application/json";
context.Response.StatusCode = statusCode;
return(context.Response.WriteAsync(result));
}
public IActionResult OnGet(
[FromQuery(Name = "iS")] bool?initSuccess = null,
string returnUrl = Routing.Admin.Index)
{
if (!Url.IsLocalUrl(returnUrl))
{
throw AppValidationException.From(_resultLocalizer, ResultCode.Identity_InvalidRedirectUrl);
}
if (initSuccess != null)
{
_memoryCache.Set(CachingKeys.InitStatus, initSuccess.Value);
return(LocalRedirect(returnUrl));
}
ReturnUrl = returnUrl;
Init = !_memoryCache.Get <bool>(CachingKeys.InitStatus);
return(Page());
}
public async Task <ListResponseModel <TModel> > GetListAppUserAsync <TModel>(
ListAppUserRequestModel requestModel, ParsingConfig parsingConfig = null)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
// validation logic here
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
IQueryable <AppUserEntity> query = dbContext.Users.AsNoTracking();
#region Filter
if (requestModel.Ids?.Any() == true)
{
query = query.ByIds(requestModel.Ids);
}
if (requestModel.UserName != null)
{
query = query.ByUsername(requestModel.UserName);
}
if (!string.IsNullOrWhiteSpace(requestModel.SearchTerm))
{
query = query.BySearchTerm(requestModel.SearchTerm);
}
if (requestModel.RegisteredFromDate != null)
{
query = query.CreatedFrom(requestModel.RegisteredFromDate.Value);
}
if (requestModel.RegisteredToDate != null)
{
query = query.CreatedTo(requestModel.RegisteredToDate.Value);
}
#endregion
var orgQuery = query;
#region Sorting
var sortByArr = requestModel.GetSortByArr();
if (!sortByArr.IsNullOrEmpty())
{
foreach (var field in sortByArr)
{
var asc = field[0] == QueryConsts.SortAscPrefix;
var fieldName = field.Remove(0, 1);
switch (fieldName)
{
case ListAppUserRequestModel.SortByUsername:
{
if (asc)
{
query = query.SequentialOrderBy(o => o.UserName);
}
else
{
query = query.SequentialOrderByDesc(o => o.UserName);
}
}
break;
default:
throw AppValidationException.From(resultLocalizer, ResultCode.InvalidPagingRequest);
}
}
}
#endregion
if (requestModel.Page > 0)
{
query = query.Limit(requestModel.Page, requestModel.PageLimit);
}
#region Projection
var projectionArr = requestModel.GetFieldsArr().Select(o => ListAppUserRequestModel.Projections[o]).ToArray();
var projectionStr = string.Join(',', projectionArr);
var projectedQuery = query.Select <TModel>(
parsingConfig ?? DynamicLinqConsts.DefaultParsingConfig,
$"new {typeof(TModel).FullName}({projectionStr})");
#endregion
var responseModels = await projectedQuery.ToArrayAsync();
var response = new ListResponseModel <TModel>
{
List = responseModels,
};
if (requestModel.CountTotal)
{
response.TotalCount = await orgQuery.CountAsync();
}
return(response);
}
public async Task <GetListResponseModel <TModel> > GetListAppUsersAsync <TModel>(
GetListAppUsersRequestModel requestModel, ParsingConfig parsingConfig = null)
{
#region Validation
var userInfo = BusinessContext.Current?.PrincipalInfo;
var validationData = new ValidationData();
// validation logic here
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
var queryModel = requestModel.MapTo <DynamicQueryAppUserModel>();
IQueryable <AppUser> query = dbContext.Users.AsNoTracking();
#region Filter
if (queryModel.Id != null)
{
query = query.ById(queryModel.Id);
}
if (queryModel.UserName != null)
{
query = query.ByUsername(queryModel.UserName);
}
if (queryModel.SearchTerm != null)
{
query = query.BySearchTerm(queryModel.SearchTerm);
}
#endregion
var orgQuery = query;
#region Sorting
if (!queryModel.SortBy.IsNullOrEmpty())
{
foreach (var field in queryModel.SortBy)
{
var asc = field[0] == QueryConsts.SortAscPrefix;
var fieldName = field.Remove(0, 1);
switch (fieldName)
{
case DynamicQueryAppUserModel.SortByUsername:
{
if (asc)
{
query = query.SequentialOrderBy(o => o.UserName);
}
else
{
query = query.SequentialOrderByDesc(o => o.UserName);
}
}
break;
default:
throw AppValidationException.From(ResultCode.InvalidPagingRequest);
}
}
}
#endregion
if (queryModel.Page > 0)
{
query = query.Limit(queryModel.Page, queryModel.PageLimit);
}
#region Projection
var projectionArr = queryModel.Fields.Select(o => DynamicQueryAppUserModel.Projections[o]).ToArray();
var projectionStr = string.Join(',', projectionArr);
var projectedQuery = query.Select <TModel>(
parsingConfig ?? DynamicLinqEntityTypeProvider.DefaultParsingConfig,
$"new {typeof(TModel).FullName}({projectionStr})");
#endregion
var responseModels = await projectedQuery.ToArrayAsync();
var response = new GetListResponseModel <TModel>
{
List = responseModels,
};
if (queryModel.CountTotal)
{
response.TotalCount = await orgQuery.CountAsync();
}
return(response);
}
public async Task <ListResponseModel <TModel> > GetListPostCategoryAsync <TModel>(
ListPostCategoryRequestModel requestModel, ParsingConfig parsingConfig = null)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
// validation logic here
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
IQueryable <PostCategoryEntity> query = dbContext.PostCategory.AsNoTracking();
IQueryable <ListPostCategoryJoinModel> joinedQuery;
#region Filter
if (requestModel.Ids?.Any() == true)
{
query = query.ByIds(requestModel.Ids);
}
string lang = requestModel.Lang;
string region = requestModel.Region;
if (string.IsNullOrEmpty(lang))
{
lang = CultureInfo.CurrentUICulture.TwoLetterISOLanguageName;
}
var locQuery = dbContext.PostCategoryLocalization.ByCulture(lang, region);
joinedQuery = from pc in query
from pcl in locQuery.Where(o => o.EntityId == pc.Id).Take(1).DefaultIfEmpty()
select new ListPostCategoryJoinModel
{
CreatedTime = pc.CreatedTime,
Description = pcl.Description,
Id = pc.Id,
Lang = pcl.Lang,
Region = pcl.Region,
Title = pcl.Title
};
if (!string.IsNullOrWhiteSpace(requestModel.SearchTerm))
{
joinedQuery = joinedQuery.BySearchTerm(requestModel.SearchTerm);
}
#endregion
var orgQuery = joinedQuery;
#region Sorting
var sortByArr = requestModel.GetSortByArr();
if (!sortByArr.IsNullOrEmpty())
{
foreach (var field in sortByArr)
{
var asc = field[0] == QueryConsts.SortAscPrefix;
var fieldName = field.Remove(0, 1);
switch (fieldName)
{
case ListPostCategoryRequestModel.SortByTitle:
{
if (asc)
{
joinedQuery = joinedQuery.SequentialOrderBy(o => o.Title);
}
else
{
joinedQuery = joinedQuery.SequentialOrderByDesc(o => o.Title);
}
}
break;
default:
throw AppValidationException.From(resultLocalizer, ResultCode.InvalidPagingRequest);
}
}
}
#endregion
if (requestModel.Page > 0)
{
joinedQuery = joinedQuery.Limit(requestModel.Page, requestModel.PageLimit);
}
#region Projection
var projectionArr = requestModel.GetFieldsArr().Select(o => ListPostCategoryRequestModel.Projections[o]).ToArray();
var projectionStr = string.Join(',', projectionArr);
var projectedQuery = joinedQuery.Select <TModel>(
parsingConfig ?? DynamicLinqConsts.DefaultParsingConfig,
$"new {typeof(TModel).FullName}({projectionStr})");
#endregion
var responseModels = await projectedQuery.ToArrayAsync();
var response = new ListResponseModel <TModel>
{
List = responseModels,
};
if (requestModel.CountTotal)
{
response.TotalCount = await orgQuery.CountAsync();
}
return(response);
}
public async Task <PostCategoryDetailModel> GetPostCategoryDetailAsync(PostCategoryDetailRequestModel model)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
// validation logic here
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
var detailModel = await dbContext.PostCategory.ById(model.Id)
.DefaultProjectTo <PostCategoryDetailModel>().FirstOrDefaultAsync();
if (detailModel == null)
{
throw AppValidationException.From(resultLocalizer, ResultCode.EntityNotFound);
}
var locQuery = dbContext.PostCategoryLocalization.ByEntity(model.Id)
.Select(o => new PostCategoryLocalizationEntity
{
Description = o.Description,
Lang = o.Lang,
Region = o.Region,
Title = o.Title
});
string currentLang = CultureInfo.CurrentUICulture.TwoLetterISOLanguageName;
string lang = model.Lang;
string region = model.Region;
if (string.IsNullOrEmpty(lang))
{
lang = currentLang;
}
var locEntity = await locQuery.ByCulture(lang, region).FirstOrDefaultAsync();
if (locEntity == null && model.Fallback)
{
if (lang != currentLang)
{
locEntity = await locQuery.ByCulture(currentLang).FirstOrDefaultAsync();
}
if (locEntity == null)
{
locEntity = await locQuery.FirstOrDefaultAsync();
}
}
if (locEntity != null)
{
locEntity.CopyTo(detailModel);
}
return(detailModel);
}
