private async Task <TResponse <IEnumerable <string> > > GetListValue(int clientId,
string sqlQuery)
{
try
{
var result = await ReadOnlyRepository.QueryAsync <string>(sqlQuery, new
{
ClientId = clientId
});
if (result.IsSuccess)
{
if (result.Data != null &&
result.Data.Any())
{
return(await Ok(result.Data));
}
return(await Ok(new List <string>().AsEnumerable()));
}
return(await Fail <IEnumerable <string> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <string> >(exception));
}
}
private async Task <List <CrmCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <CrmCacheModel>(SqlQuery.GET_ALL_CRM);
if (result.IsSuccess)
{
if (result.Data != null)
{
var crms = result.Data.ToList();
await DistributedCache.Set(_cacheKey,
crms);
return(await Task.FromResult(crms));
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
public async Task <TResponse <bool> > IsOriginAllowed(string origin)
{
try
{
var origins = await ReadOnlyRepository.QueryAsync <string>(SqlQuery.CLIENT_CORS_ORIGIN_GET_ALL);
if (origins.IsSuccess)
{
if (origins.Data != null &&
origins.Data.Any())
{
if (origins.Data.Contains(origin))
{
return(await Ok(true));
}
}
return(await Fail <bool>(string.Empty));
}
return(await Fail <bool>(origins.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
private async Task <List <InvoiceStatusCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <InvoiceStatusCacheModel>(SqlQuery.GET_ALL_INVOICE_STATUS);
if (result.IsSuccess)
{
if (result.Data != null)
{
await DistributedCache.Set(_cacheKey,
result.Data.ToList());
return(result.Data.ToList());
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
private async Task <List <TaskPriorityCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <TaskPriorityCacheModel>(SqlQuery.GET_ALL_TASK_PRIORITY);
if (result.IsSuccess)
{
if (result.Data != null)
{
await DistributedCache.Set(_cacheKey,
result.Data.ToList());
return(result.Data.ToList());
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
private async Task <List <CustomerSourceCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <CustomerSourceCacheModel>(SqlQuery.GET_ALL_CUSTOMER_SOURCE);
if (result.IsSuccess)
{
if (result.Data != null)
{
await DistributedCache.Set(_cacheKey,
result.Data.ToList());
return(result.Data.ToList());
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
public async Task <TResponse <IEnumerable <RoleModel> > > GetAll(int userId,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var result = await ReadOnlyRepository.QueryAsync <RoleModel>(SqlQuery.ROLE_GET_ALL);
if (result.IsSuccess)
{
return(await Ok(result.Data));
}
return(await Fail <IEnumerable <RoleModel> >(result.Message));
}
return(await Fail <IEnumerable <RoleModel> >(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <RoleModel> >(exception));
}
}
private async Task <TResponse <bool> > CanInsert(InsertUserModel user)
{
try
{
var users = await ReadOnlyRepository.QueryAsync <UserModel>(SqlQuery.USER_FIND_BY_NAME,
new
{
user.Username
});
if (users != null)
{
if (users.IsSuccess)
{
if (users.Data.Any())
{
return(await Fail <bool>(ErrorEnum.UserNameHasExist.GetStringValue()));
}
return(await Ok(true));
}
return(await Fail <bool>(users.Message));
}
return(await Ok(true));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
private async Task <List <ReceiptDescriptionCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <ReceiptDescriptionCacheModel>(SqlQuery.GET_ALL_RECEIPT_DESCRIPTION);
if (result.IsSuccess)
{
if (result.Data != null)
{
await DistributedCache.Set(_cacheKey,
result.Data.ToList());
return(result.Data.ToList());
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
private async Task <TResponse <IEnumerable <ClientPropertyDto> > > GetClientProperties(int clientId)
{
try
{
var result = await ReadOnlyRepository.QueryAsync <ClientPropertyDto>(SqlQuery.CLIENT_PROPERTY_GET_BY_CLIENT_ID, new
{
ClientId = clientId
});
if (result.IsSuccess)
{
if (result.Data != null &&
result.Data.Any())
{
return(await Ok(result.Data));
}
return(await Ok(new List <ClientPropertyDto>().AsEnumerable()));
}
return(await Fail <IEnumerable <ClientPropertyDto> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <ClientPropertyDto> >(exception));
}
}
/// <summary>
/// Get User By Id
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public async Task <TResponse <UserModel> > GetById(int userId)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <UserModel>(
SqlQuery.USER_GET_BY_ID, new
{
Id = userId
});
if (result != null)
{
if (result.IsSuccess)
{
if (result.Data != null)
{
var user = result.Data;
var sites = await ReadOnlyRepository.QueryAsync <SiteModel>(SqlQuery.SITE_GET_BY_USER_ID, new
{
UserId = user.Id
});
if (sites.IsSuccess &&
sites.Data != null &&
sites.Data.Any())
{
user.Sites.AddRange(sites.Data.Select(c => c.Id));
}
var roles = await ReadOnlyRepository.QueryAsync <RoleModel>(SqlQuery.ROLE_GET_BY_USER_ID, new
{
UserId = user.Id
});
if (roles.IsSuccess &&
roles.Data != null &&
roles.Data.Any())
{
user.Roles.AddRange(roles.Data.Select(c => c.Id));
}
return(await Ok(user));
}
return(await Fail <UserModel>(ErrorEnum.UserHasNotExist.GetStringValue()));
}
return(await Fail <UserModel>(result.Message));
}
return(await Ok <UserModel>(null));
}
catch (Exception exception)
{
return(await Fail <UserModel>(exception));
}
}
public async Task <TResponse <IEnumerable <IdentityResourceDto> > > GetByScopes(List <string> scopes)
{
try
{
if (scopes != null &&
scopes.Any())
{
var result = await ReadOnlyRepository.QueryAsync <IdentityResourceDto>(SqlQuery.IDENTITY_RESOURCE_GET_BY_SCOPES, new
{
Scopes = $"|{string.Join("|", scopes)}|"
});
if (result.IsSuccess)
{
if (result.Data != null)
{
var identityResources = result.Data.ToList();
foreach (var identityResource in identityResources)
{
identityResource.UserClaims = new List <string>();
var claims = await ReadOnlyRepository.QueryAsync <string>(SqlQuery.IDENTITY_RESOURCE_CLAIM_GET_BY_RESOURCE_ID, new
{
IdentityResourceId = identityResource.Id
});
if (claims.IsSuccess)
{
if (claims.Data != null)
{
identityResource.UserClaims.AddRange(claims.Data);
}
}
}
return(await Ok(identityResources.AsEnumerable()));
}
return(await Ok(new List <IdentityResourceDto>().AsEnumerable()));
}
return(await Fail <IEnumerable <IdentityResourceDto> >(result.Message));
}
return(await Fail <IEnumerable <IdentityResourceDto> >(ErrorEnum.ScopesIsMustNotNull.GetStringValue()));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <IdentityResourceDto> >(exception));
}
}
/// <summary>
/// Get All Sites
/// </summary>
/// <returns></returns>
public async Task <TResponse <IEnumerable <SiteModel> > > GetAll()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <SiteModel>(SqlQuery.SITE_GET_ALL);
if (result.IsSuccess)
{
return(await Ok(result.Data));
}
return(await Fail <IEnumerable <SiteModel> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <SiteModel> >(exception));
}
}
public async Task <TResponse <IEnumerable <IdentityResourceDto> > > GetAll()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <IdentityResourceDto>(SqlQuery.IDENTITY_RESOURCE_GET_ALL);
if (result.IsSuccess)
{
if (result.Data != null)
{
var identityResources = result.Data.ToList();
foreach (var identityResource in identityResources)
{
identityResource.UserClaims = new List <string>();
var claims = await ReadOnlyRepository.QueryAsync <string>(SqlQuery.IDENTITY_RESOURCE_CLAIM_GET_BY_RESOURCE_ID, new
{
IdentityResourceId = identityResource.Id
});
if (claims.IsSuccess)
{
if (claims.Data != null)
{
identityResource.UserClaims.AddRange(claims.Data);
}
}
}
return(await Ok(identityResources.AsEnumerable()));
}
return(await Ok(new List <IdentityResourceDto>().AsEnumerable()));
}
return(await Fail <IEnumerable <IdentityResourceDto> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <IdentityResourceDto> >(exception));
}
}
public async Task <TResponse <IEnumerable <RoleDto> > > GetAllByUserId(int userId)
{
try
{
var result = await ReadOnlyRepository.QueryAsync <RoleDto>(SqlQuery.ROLE_GET_ALL_BY_USER_ID, new
{
UserId = userId
});
if (result.IsSuccess)
{
return(await Ok(result.Data));
}
return(await Fail <IEnumerable <RoleDto> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <RoleDto> >(exception));
}
}
public async Task <TResponse <IEnumerable <SiteDto> > > GetAll()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <SiteDto>(SqlQuery.SITE_GET_ALL);
if (result.IsSuccess)
{
if (result.Data != null &&
result.Data.Any())
{
return(await Ok(result.Data));
}
return(await Ok(new List <SiteDto>().AsEnumerable()));
}
return(await Fail <IEnumerable <SiteDto> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <SiteDto> >(exception));
}
}
public async Task <TResponse <PageResult <InvoiceModel> > > GetPaging(int userId, GetInvoicePageModel request,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId, permissionId);
if (checkValid.IsSuccess)
{
var page = request.Page;
if (page <= 1)
{
page = 1;
}
var pageSize = request.PageSize;
if (pageSize <= 0)
{
pageSize = 20;
}
var result = await ReadOnlyRepository.QueryMultipleLFAsync <InvoiceModel, int>(
SqlQuery.INVOICE_GET_BY_PAGING, new
{
CustomerName = $"%{request.Customer}%",
CustomerPhone = $"%{request.CustomerPhone}%",
CustomerCode = $"%{request.CustomerCode}%",
Code = $"%{request.Code}%",
request.BranchId,
request.InvoiceStatusId,
request.UserSellId,
request.UserCreatedId,
request.FromDate,
request.ToDate,
Skip = (page - 1) * pageSize,
Take = pageSize
});
if (result.IsSuccess)
{
if (result.Data.Item1 != null && result.Data.Item1.Any())
{
var count = result.Data.Item2;
var invoices = result.Data.Item1.ToList();
foreach (var invoice in invoices)
{
var products = await ReadOnlyRepository.QueryAsync <string>(
SqlQuery.INVOICE_GET_PRODUCT_BY_INVOICE_ID, new
{
InvoiceId = invoice.Id
});
if (products.IsSuccess && products.Data != null)
{
invoice.Products.AddRange(products.Data);
}
var users = await ReadOnlyRepository.QueryAsync <string>(
SqlQuery.INVOICE_GET_USER_DELIVERY_BY_INVOICE_ID, new
{
InvoiceId = invoice.Id
});
if (users.IsSuccess && users.Data != null)
{
invoice.UserDelivery.AddRange(users.Data);
}
}
return(await Ok(new PageResult <InvoiceModel>(page, pageSize, result.Data.Item2,
result.Data.Item1)));
}
return(await Ok(new PageResult <InvoiceModel>(page, pageSize, result.Data.Item2,
new List <InvoiceModel>())));
}
return(await Fail <PageResult <InvoiceModel> >(result.Message));
}
return(await Fail <PageResult <InvoiceModel> >(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <PageResult <InvoiceModel> >(exception));
}
}
public async Task <TResponse <ApiResourceDto> > GetByName(string name)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <ApiResourceDto>(SqlQuery.API_RESOURCE_GET_BY_NAME, new
{
Name = name
});
if (result.IsSuccess)
{
if (result.Data != null)
{
var apiResource = result.Data;
#region Claim
apiResource.UserClaims = new List <string>();
var claims = await ReadOnlyRepository.QueryAsync <string>(SqlQuery.API_RESOURCE_CLAIM_GET_BY_RESOURCE_ID, new
{
ApiResourceId = apiResource.Id
});
if (claims.IsSuccess &&
claims.Data != null)
{
apiResource.UserClaims.AddRange(claims.Data);
}
#endregion
#region Secrets
apiResource.Secrets = new List <ApiSecretDto>();
var secrets = await ReadOnlyRepository.QueryAsync <ApiSecretDto>(SqlQuery.API_SECRET_GET_BY_RESOURCE_ID, new
{
ApiResourceId = apiResource.Id
});
if (secrets.IsSuccess &&
secrets.Data != null &&
secrets.Data.Any())
{
apiResource.Secrets.AddRange(secrets.Data);
}
#endregion
#region Scopes
apiResource.Scopes = new List <ApiScopeDto>();
var scopes = await ReadOnlyRepository.QueryAsync <ApiScopeDto>(SqlQuery.API_SCOPE_GET_BY_RESOURCE_ID, new
{
ApiResourceId = apiResource.Id
});
if (scopes.IsSuccess &&
scopes.Data != null &&
scopes.Data.Any())
{
foreach (var scope in scopes.Data)
{
scope.UserClaims = new List <string>();
var scopeClaims = await ReadOnlyRepository.QueryAsync <string>(SqlQuery.API_SCOPE_CLAIM_GET_BY_API_SCOPE_ID, new
{
ApiScopeId = scope.Id
});
if (scopeClaims.IsSuccess &&
scopeClaims.Data != null &&
scopeClaims.Data.Any())
{
scope.UserClaims.AddRange(scopeClaims.Data);
}
}
apiResource.Scopes.AddRange(scopes.Data);
}
#endregion
return(await Ok(apiResource));
}
return(await Fail <ApiResourceDto>(ErrorEnum.ApiResourceHasNotExist.GetStringValue()));
}
return(await Fail <ApiResourceDto>(result.Message));
}
catch (Exception exception)
{
return(await Fail <ApiResourceDto>(exception));
}
}
public async Task <TResponse <IEnumerable <ApiResourceDto> > > GetAll()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <ApiResourceDto>(SqlQuery.API_RESOURCE_GET_ALL);
if (result.IsSuccess)
{
if (result.Data != null)
{
var apiResources = result.Data.ToList();
foreach (var apiResource in apiResources)
{
#region Claim
apiResource.UserClaims = new List <string>();
var claims = await ReadOnlyRepository.QueryAsync <string>(SqlQuery.API_RESOURCE_CLAIM_GET_BY_RESOURCE_ID, new
{
ApiResourceId = apiResource.Id
});
if (claims.IsSuccess &&
claims.Data != null)
{
apiResource.UserClaims.AddRange(claims.Data);
}
#endregion
#region Secrets
apiResource.Secrets = new List <ApiSecretDto>();
var secrets = await ReadOnlyRepository.QueryAsync <ApiSecretDto>(SqlQuery.API_SECRET_GET_BY_RESOURCE_ID, new
{
ApiResourceId = apiResource.Id
});
if (secrets.IsSuccess &&
secrets.Data != null &&
secrets.Data.Any())
{
apiResource.Secrets.AddRange(secrets.Data);
}
#endregion
#region Scopes
apiResource.Scopes = new List <ApiScopeDto>();
var scopes = await ReadOnlyRepository.QueryAsync <ApiScopeDto>(SqlQuery.API_SCOPE_GET_BY_RESOURCE_ID, new
{
ApiResourceId = apiResource.Id
});
if (scopes.IsSuccess &&
scopes.Data != null &&
scopes.Data.Any())
{
foreach (var scope in scopes.Data)
{
scope.UserClaims = new List <string>();
var scopeClaims = await ReadOnlyRepository.QueryAsync <string>(SqlQuery.API_SCOPE_CLAIM_GET_BY_API_SCOPE_ID, new
{
ApiScopeId = scope.Id
});
if (scopeClaims.IsSuccess &&
scopeClaims.Data != null &&
scopeClaims.Data.Any())
{
scope.UserClaims.AddRange(scopeClaims.Data);
}
}
apiResource.Scopes.AddRange(scopes.Data);
}
#endregion
}
return(await Ok(apiResources.AsEnumerable()));
}
return(await Ok(new List <ApiResourceDto>().AsEnumerable()));
}
return(await Fail <IEnumerable <ApiResourceDto> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <ApiResourceDto> >(exception));
}
}
/// <summary>
/// Update User
/// </summary>
/// <param name="userId"></param>
/// <param name="user"></param>
/// <returns></returns>
public async Task <TResponse <bool> > Update(int userId,
UpdateUserModel user)
{
try
{
var canUpdate = await CanUpdate(user);
if (canUpdate.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE, new
{
user.Id,
user.Email,
user.Name,
user.Phone,
UserUpdated = userId
});
if (result != null)
{
if (result.IsSuccess)
{
if (result.Data == 0)
{
return(await Fail <bool>($"Update USER {user.Id} is failure"));
}
#region Set Sites
var sites = user.Sites ?? new List <int>();
var oldSites = await ReadOnlyRepository.QueryAsync <SiteModel>(SqlQuery.SITE_GET_BY_USER_ID, new
{
UserId = user.Id
});
//kiem tra site nao chua ton tai thi them moi
foreach (var site in sites)
{
var exist = await ReadOnlyRepository.QueryFirstOrDefaultAsync <int>(SqlQuery.USER_CHECK_SITE_VALID, new
{
UserId = user.Id,
SiteId = site
});
if (exist.IsSuccess)
{
if (exist.Data == 0)
{
//chua co, them moi vao
var siteId = await ReadOnlyRepository.QueryFirstOrDefaultAsync <SiteModel>(SqlQuery.SITE_GET_BY_ID, new
{
Id = site
});
if (siteId.IsSuccess &&
siteId.Data != null)
{
await WriteRepository.ExecuteAsync(SqlQuery.USER_SITE_INSERT, new
{
UserId = user.Id,
SiteId = siteId.Data.Id,
UserCreated = userId,
UserUpdated = userId
});
}
}
}
}
//kiem tra site nao bi xoa bo
if (oldSites.IsSuccess)
{
if (oldSites.Data != null &&
oldSites.Data.Any())
{
foreach (var oldSite in oldSites.Data)
{
if (!sites.Contains(oldSite.Id))
{
await WriteRepository.ExecuteAsync(SqlQuery.REMOVE_USER_FROM_SITE, new
{
UserId = user.Id,
SiteId = oldSite.Id,
UserUpdated = userId
});
}
}
}
}
#endregion
#region Set Roles
var roles = user.Roles ?? new List <int>();
var oldRoles = await ReadOnlyRepository.QueryAsync <RoleModel>(SqlQuery.ROLE_GET_BY_USER_ID, new
{
UserId = user.Id
});
//kiem tra role nao chua ton tai thi them moi
foreach (var role in roles)
{
var exist = await ReadOnlyRepository.QueryFirstOrDefaultAsync <int>(SqlQuery.USER_CHECK_ROLE_VALID, new
{
UserId = user.Id,
RoleId = role
});
if (exist.IsSuccess)
{
if (exist.Data == 0)
{
//chua co, them moi vao
var roleId = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_GET_BY_ID, new
{
Id = role
});
if (roleId.IsSuccess &&
roleId.Data != null)
{
await WriteRepository.ExecuteAsync(SqlQuery.USER_ROLE_INSERT, new
{
UserId = user.Id,
RoleId = roleId.Data.Id,
UserCreated = userId,
UserUpdated = userId
});
}
}
}
}
//kiem tra role nao bi xoa bo
if (oldRoles.IsSuccess)
{
if (oldRoles.Data != null &&
oldRoles.Data.Any())
{
foreach (var oldRole in oldRoles.Data)
{
if (!roles.Contains(oldRole.Id))
{
await WriteRepository.ExecuteAsync(SqlQuery.REMOVE_USER_FROM_ROLE, new
{
UserId = user.Id,
RoleId = oldRole.Id,
UserUpdated = userId
});
}
}
}
}
#endregion
return(await Ok(true));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>($"Update USER {user.Id} is failure"));
}
return(await Fail <bool>(canUpdate.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
