//public async Task<HttpResponseMessage> GetUserMobileOperationAccess()
//{
// var hasAccess = await SecurityManager.HasAccessAsync(BehshoResourceIds.Behsho_Security_MobileUser_View);
// var oprAccess = new OperationAccess() { CanView = hasAccess, CanUpdate = hasAccess };
// return Request.CreateResponse(HttpStatusCode.OK, new { resultCode = (int)ResultCode.Successful, data = oprAccess });
//}
public async Task <HttpResponseMessage> GetUserInfoAsync()
{
try
{
var userQuery = this.BusinessRule.Queryable();
var userList = await userQuery.Select(user => new
{
ID = user.ID,
OrganizationId = user.OrganizationId,
FirstName = user.FirstName,
LastName = user.LastName,
UserName = user.UserName
}).ToListAsync();
var result = userList.ConvertAll(user => new KeyValueVM
{
Key = user.ID,
Value = $"{user.FirstName} {user.LastName} | {user.UserName}"
});
return(Request.CreateResponse(HttpStatusCode.OK, new { resultCode = (int)ResultCode.Successful, data = result }));
}
catch (Exception ex)
{
return(await this.HandleExceptionAsync(ex));
}
finally
{
BusinessRule.Dispose();
}
}
public async Task <HttpResponseMessage> GetDocType(GetDocTypeBusi getDocTypeBusi)
{
try
{
SecurityManager.ThrowIfUserContextNull();
using (DocTypeRule noeDarkhastPayvastRule = new DocTypeRule())
{
var noeTasvir = await noeDarkhastPayvastRule.GetDocType(getDocTypeBusi.noeDocID);
List <KeyValueVM> result = noeTasvir.Select(p => new KeyValueVM()
{
Key = p.ID, Value = p.DocName
}).ToList();
return(Request.CreateResponse(HttpStatusCode.OK, new { resultCode = (int)ResultCode.Successful, data = new { records = result } }));
}
}
catch (Exception ex)
{
return(await this.HandleExceptionAsync(ex));
}
finally
{
BusinessRule.Dispose();
}
}
public async Task <HttpResponseMessage> UsersByRole()
{
try
{
var organId = Convert.ToInt32(SecurityManager.CurrentUserContext.OrganizationId);
using (var uow = new UnitOfWork())
{
var userInfosQuery = uow.Repository <UserInfo>().Queryable().Where(x => x.OrganizationId == organId);
var userRoleQuery = uow.Repository <UserRole>().Queryable();
var roleQuery = uow.Repository <Role>().Queryable();
var joinQuery = from userInfo in userInfosQuery
join userRole in userRoleQuery
on userInfo.ID equals userRole.UserId
join role in roleQuery
on userRole.RoleId equals role.ID
select new
{
ID = userInfo.ID,
Name = userInfo.FirstName + " " + userInfo.LastName,
RoleId = userRole.RoleId,
RoleName = role.Name,
// DetailAccount = new DetailAccount { }
};
var nasabs = await joinQuery.Where(x => x.RoleId == 10).ToListAsync();
var chapkhanes = await joinQuery.Where(x => x.RoleId == 9).ToListAsync();
var tarahs = await joinQuery.Where(x => x.RoleId == 8).ToListAsync();
var bazaryabs = await joinQuery.Where(x => x.RoleId == 7).ToListAsync();
//var nasabs = await joinQuery.ToListAsync();
//var chapkhanes = await joinQuery.ToListAsync();
//var tarahs = await joinQuery.ToListAsync();
//var bazaryabs = await joinQuery.ToListAsync();
// UserInfoVM userInfoVm = null;
// UserInfo userInfo = await BusinessRule.(userID);
//userInfoVm = TranslateEntityToCustomQueryEntity(userInfo);
return(Request.CreateResponse(HttpStatusCode.OK, new { resultCode = (int)ResultCode.Successful, data = new { nasabs, chapkhanes, tarahs, bazaryabs } }));
}
}
catch (Exception ex)
{
return(await this.HandleExceptionAsync(ex));
}
finally
{
BusinessRule.Dispose();
}
}
public async Task <HttpResponseMessage> UpdateOperations(PermisionUserVM permisionUser)
{
try
{
using (var operationBusiness = BusinessContext.GetBusinessRule <Operation>(this.BusinessRule.OperationAccess, this.BusinessRule.UnitOfWork))
using (var userOperationBusiness = BusinessContext.GetBusinessRule <UserOperation>(this.BusinessRule.OperationAccess, this.BusinessRule.UnitOfWork))
{
var operationQuery = operationBusiness.Queryable()
.Where(opr => opr.OperationType != OperationType.Other);
var dbUserOperations = userOperationBusiness.Queryable()
.Where(userOpr => userOpr.UserId == permisionUser.UserId);
var dbUserOperationsList = await(from opr in operationQuery
join userOpr in dbUserOperations
on opr.ID equals userOpr.OperationId
select userOpr).ToListAsync();
var currentUserOperationIds = permisionUser.OperationUsers.Select(s => s.OperationId);
var dbUserOprOperationIds = dbUserOperationsList.Select(dbUserOpr => dbUserOpr.OperationId);
var userOprOperationIdsForDelete = dbUserOprOperationIds.Except(currentUserOperationIds);
foreach (var userOprOperaionID in userOprOperationIdsForDelete)
{
UserOperation userOperation = dbUserOperationsList.FirstOrDefault(dbUserOpr => dbUserOpr.OperationId == userOprOperaionID);
userOperationBusiness.Delete(userOperation);
}
var userOperationIdsForInsert = permisionUser.OperationUsers.Select(currentUserOpr => currentUserOpr.OperationId).Except(dbUserOprOperationIds);
foreach (var userOprIdForInsert in userOperationIdsForInsert)
{
UserOperation userOperationForInsert = new UserOperation()
{
OperationId = userOprIdForInsert, UserId = permisionUser.UserId
};
userOperationBusiness.Insert(userOperationForInsert);
}
await userOperationBusiness.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK, new { resultCode = (int)ResultCode.Successful, data = permisionUser.UserId }));
}
}
catch (Exception ex)
{
return(await this.HandleExceptionAsync(ex));
}
finally
{
BusinessRule.Dispose();
}
}
public async Task <HttpResponseMessage> UpdateUserRole(AccessUserRoleVM accessUserRole)
{
try
{
using (var userRoleBusiness = BusinessContext.GetBusinessRule <UserRole>(this.BusinessRule.OperationAccess, this.BusinessRule.UnitOfWork))
{
var dbUserRoles = await userRoleBusiness.Queryable().Where(userRole => userRole.UserId == accessUserRole.UserId).ToListAsync();
var currentUserRoleIds = accessUserRole.UserRoles.Select(s => s.RoleId);
var dbUserRoleIds = dbUserRoles.Select(dbUserRole => dbUserRole.RoleId);
var userRoleIdsForDelete = dbUserRoleIds.Except(currentUserRoleIds);
foreach (var userRoleID in userRoleIdsForDelete)
{
UserRole userRole = dbUserRoles.FirstOrDefault(dbUserRole => dbUserRole.RoleId == userRoleID);
userRoleBusiness.Delete(userRole);
}
var userRoleIdsForInsert = accessUserRole.UserRoles.Select(currentUserRole => currentUserRole.RoleId).Except(dbUserRoleIds);
foreach (var userRoleIdForInsert in userRoleIdsForInsert)
{
UserRole userRoleForInsert = new UserRole()
{
RoleId = userRoleIdForInsert, UserId = accessUserRole.UserId
};
userRoleBusiness.Insert(userRoleForInsert);
}
await userRoleBusiness.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK, new { resultCode = (int)ResultCode.Successful, data = accessUserRole.UserId }));
}
}
catch (Exception ex)
{
return(await this.HandleExceptionAsync(ex));
}
finally
{
BusinessRule.Dispose();
}
}
public async Task <HttpResponseMessage> FindUserInfo(int userID)
{
try
{
UserInfoVM userInfoVm = null;
UserInfo userInfo = await BusinessRule.FindAsync(userID);
userInfoVm = TranslateEntityToCustomQueryEntity(userInfo);
return(Request.CreateResponse(HttpStatusCode.OK, new { resultCode = (int)ResultCode.Successful, data = userInfoVm }));
}
catch (Exception ex)
{
return(await this.HandleExceptionAsync(ex));
}
finally
{
BusinessRule.Dispose();
}
}
