/// <summary>
/// Gets the user.
/// </summary>
/// <param name="filter">The filter.</param>
/// <returns></returns>
public AppUserModel GetUser(AppUserFilter filter)
{
var baseQuery = QueryBuilderFactory.AppUserQueryBuilder.GetUsers(filter);
var items = Repository.Query <AppUserModel>(baseQuery.Query, baseQuery.Param);
return(items.FirstOrDefault());
}
private async Task <bool> ValidateEmployees(KpiGeneral KpiGeneral)
{
if (KpiGeneral.EmployeeIds == null || !KpiGeneral.EmployeeIds.Any())
{
KpiGeneral.AddError(nameof(KpiGeneralValidator), nameof(KpiGeneral.EmployeeIds), ErrorCode.EmployeeIdsEmpty);
}
else
{
AppUserFilter AppUserFilter = new AppUserFilter
{
Skip = 0,
Take = int.MaxValue,
Id = new IdFilter {
In = KpiGeneral.EmployeeIds
},
OrganizationId = new IdFilter(),
Selects = AppUserSelect.Id
};
var EmployeeIdsInDB = (await UOW.AppUserRepository.List(AppUserFilter)).Select(x => x.Id).ToList();
var listIdsNotExisted = KpiGeneral.EmployeeIds.Except(EmployeeIdsInDB).ToList();
if (listIdsNotExisted != null && listIdsNotExisted.Any())
{
foreach (var Id in listIdsNotExisted)
{
KpiGeneral.AddError(nameof(KpiGeneralValidator), nameof(KpiGeneral.EmployeeIds), ErrorCode.IdNotExisted);
}
}
}
return(KpiGeneral.IsValidated);
}
public async Task <List <AppUser> > Collection(AppUserFilter filter)
{
var query = _db.AppUsers.AsQueryable();
if (filter.Created.HasValue)
{
query = query.Where(a => a.Created >= filter.Created.Start && a.Created <= filter.Created.End);
}
if (filter.IsActive.HasValue)
{
query = query.Where(a => a.IsActive == filter.IsActive);
}
if (filter.Modified.HasValue)
{
query = query.Where(a => a.Modified >= filter.Modified.Start && a.Modified <= filter.Modified.End);
}
if (!string.IsNullOrWhiteSpace(filter.SearchCriteria))
{
query = query.Where(a => a.SearchContent.Contains(filter.SearchCriteria));
}
return(await Task.FromResult(query.ToList()));
}
public async Task <ActionResult <List <Notification_AppUserDTO> > > SingleListAppUser([FromBody] Notification_AppUserFilterDTO Notification_AppUserFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter AppUserFilter = new AppUserFilter();
AppUserFilter.Skip = 0;
AppUserFilter.Take = 20;
AppUserFilter.OrderBy = AppUserOrder.Id;
AppUserFilter.OrderType = OrderType.ASC;
AppUserFilter.Selects = AppUserSelect.Id | AppUserSelect.Username | AppUserSelect.DisplayName;
AppUserFilter.Id = Notification_AppUserFilterDTO.Id;
AppUserFilter.Username = Notification_AppUserFilterDTO.Username;
AppUserFilter.DisplayName = Notification_AppUserFilterDTO.DisplayName;
AppUserFilter.StatusId = new IdFilter {
Equal = StatusEnum.ACTIVE.Id
};
//if (AppUserFilter.Id == null) AppUserFilter.Id = new IdFilter();
//AppUserFilter.Id.In = await FilterAppUser(AppUserService, OrganizationService, CurrentContext);
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
List <Notification_AppUserDTO> StoreCheckerMonitor_AppUserDTOs = AppUsers
.Select(x => new Notification_AppUserDTO(x)).ToList();
return(StoreCheckerMonitor_AppUserDTOs);
}
private IQueryable <AppUser> GetData(AppUserFilter filter)
{
var data = GetAll.Where(a => a.IsActive);
//Filter
if (!string.IsNullOrWhiteSpace(filter.LastName))
{
filter.LastName = filter.LastName.Trim();
data = data.Where(a => a.LastName.Contains(filter.LastName));
}
if (!string.IsNullOrWhiteSpace(filter.FirstName))
{
filter.FirstName = filter.FirstName.Trim();
data = data.Where(a => a.FirstName.Contains(filter.FirstName));
}
if (!string.IsNullOrWhiteSpace(filter.MiddleName))
{
filter.MiddleName = filter.MiddleName.Trim();
data = data.Where(a => a.MiddleName.Contains(filter.MiddleName));
}
if (!string.IsNullOrWhiteSpace(filter.UserName))
{
filter.UserName = filter.UserName.Trim();
data = data.Where(a => a.UserName.Contains(filter.UserName));
}
//if (!string.IsNullOrWhiteSpace(filter.CreatedBy))
//{
// filter.CreatedBy = filter.CreatedBy.Trim();
// data = data.Where(a => (a.CreatedByAppUser.FirstName + " "
// + a.CreatedByAppUser.LastName)
// .Trim().Contains(filter.CreatedBy));
//}
return(data);
}
public async Task <List <Role_AppUserDTO> > SingleListAppUser([FromBody] Role_AppUserFilterDTO Role_AppUserFilterDTO)
{
AppUserFilter AppUserFilter = new AppUserFilter();
AppUserFilter.Skip = 0;
AppUserFilter.Take = 20;
AppUserFilter.OrderBy = AppUserOrder.Id;
AppUserFilter.OrderType = OrderType.ASC;
AppUserFilter.Selects = AppUserSelect.Id | AppUserSelect.Username | AppUserSelect.DisplayName | AppUserSelect.Email | AppUserSelect.Phone;
AppUserFilter.Id = Role_AppUserFilterDTO.Id;
AppUserFilter.Username = Role_AppUserFilterDTO.Username;
AppUserFilter.DisplayName = Role_AppUserFilterDTO.DisplayName;
AppUserFilter.Email = Role_AppUserFilterDTO.Email;
AppUserFilter.Phone = Role_AppUserFilterDTO.Phone;
AppUserFilter.StatusId = new IdFilter {
Equal = StatusEnum.ACTIVE.Id
};
//if (AppUserFilter.Id == null) AppUserFilter.Id = new IdFilter();
//AppUserFilter.Id.In = await FilterAppUser(AppUserService, OrganizationService, CurrentContext);
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
List <Role_AppUserDTO> Role_AppUserDTOs = AppUsers
.Select(x => new Role_AppUserDTO(x)).ToList();
return(Role_AppUserDTOs);
}
public async Task <List <Ticket_AppUserDTO> > SingleListAppUser([FromBody] Ticket_AppUserFilterDTO Ticket_AppUserFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter AppUserFilter = new AppUserFilter();
AppUserFilter.Skip = 0;
AppUserFilter.Take = 20;
AppUserFilter.OrderBy = AppUserOrder.Id;
AppUserFilter.OrderType = OrderType.ASC;
AppUserFilter.Selects = AppUserSelect.ALL;
AppUserFilter.Id = Ticket_AppUserFilterDTO.Id;
AppUserFilter.Username = Ticket_AppUserFilterDTO.Username;
AppUserFilter.DisplayName = Ticket_AppUserFilterDTO.DisplayName;
//if (AppUserFilter.Id == null) AppUserFilter.Id = new IdFilter();
//AppUserFilter.Id.In = await FilterAppUser(AppUserService, OrganizationService, CurrentContext);
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
List <Ticket_AppUserDTO> Ticket_AppUserDTOs = AppUsers
.Select(x => new Ticket_AppUserDTO(x)).ToList();
return(Ticket_AppUserDTOs);
}
public async Task AppUserCollectionShouldReturnInactiveRecordsIfSpecified()
{
var fakeUsers = new AppUser[] {
new AppUser()
{
IsActive = true
},
new AppUser()
{
IsActive = true
},
new AppUser()
{
IsActive = false
}
};
var mockedDb = new Mock <AppUserContext>();
mockedDb.Setup(a => a.AppUsers).ReturnsDbSet(fakeUsers);
var filter = new AppUserFilter();
filter.IsActive = false;
var service = new AppUserService(_mapper, mockedDb.Object, _jwtService, _logger);
var collection = await service.Collection(filter);
var expectedCount = 1;
var actualCount = collection.Count;
Assert.Equal(expectedCount, actualCount);
}
private async Task <bool> ValidateEmployee(CustomerSalesOrder CustomerSalesOrder)
{
if (CustomerSalesOrder.SalesEmployeeId == 0)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.SalesEmployee), ErrorCode.SalesEmployeeEmpty);
}
else
{
AppUserFilter AppUserFilter = new AppUserFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = CustomerSalesOrder.SalesEmployeeId
},
StatusId = new IdFilter {
Equal = Enums.StatusEnum.ACTIVE.Id
},
Selects = AppUserSelect.Id | AppUserSelect.Organization
};
var count = await UOW.AppUserRepository.Count(AppUserFilter);
if (count == 0)
{
CustomerSalesOrder.AddError(nameof(CustomerSalesOrderValidator), nameof(CustomerSalesOrder.SalesEmployee), ErrorCode.SalesEmployeeNotExisted);
}
}
return(CustomerSalesOrder.IsValidated);
}
public async Task <List <Tracking_AppUserDTO> > FilterListAppUser([FromBody] Tracking_AppUserFilterDTO Tracking_AppUserFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter AppUserFilter = new AppUserFilter();
AppUserFilter.Skip = 0;
AppUserFilter.Take = 20;
AppUserFilter.OrderBy = AppUserOrder.Id;
AppUserFilter.OrderType = OrderType.ASC;
AppUserFilter.Selects = AppUserSelect.ALL;
AppUserFilter.Id = Tracking_AppUserFilterDTO.Id;
AppUserFilter.Username = Tracking_AppUserFilterDTO.Username;
AppUserFilter.Password = Tracking_AppUserFilterDTO.Password;
AppUserFilter.DisplayName = Tracking_AppUserFilterDTO.DisplayName;
AppUserFilter.Email = Tracking_AppUserFilterDTO.Email;
AppUserFilter.Phone = Tracking_AppUserFilterDTO.Phone;
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
List <Tracking_AppUserDTO> Tracking_AppUserDTOs = AppUsers
.Select(x => new Tracking_AppUserDTO(x)).ToList();
return(Tracking_AppUserDTOs);
}
public AppUserFilter ToFilter(AppUserFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <AppUserFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
AppUserFilter subFilter = new AppUserFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.OrganizationId))
{
subFilter.OrganizationId = FilterPermissionDefinition.IdFilter;
}
}
}
return(filter);
}
public List <CCGAppUser> FilterAppUsers(List <CCGAppUser> users, AppUserFilter filter)
{
switch (filter)
{
case AppUserFilter.AllAppUsers:
return(users);
case AppUserFilter.Administrator:
return(users.FindAll(u => AuthHelper.IsInRole(u.Email, AppUserRole.Admin)));
case AppUserFilter.DeaconLeadership:
return(users.FindAll(u => AuthHelper.IsInRole(u.Email, AppUserRole.DeaconLeadership)));
case AppUserFilter.Deacon:
return(users.FindAll(u => AuthHelper.IsInRole(u.Email, AppUserRole.Deacon)));
case AppUserFilter.Pastor:
return(users.FindAll(u => AuthHelper.IsInRole(u.Email, AppUserRole.Pastor)));
case AppUserFilter.AdminAndDeacon:
return(users.FindAll(u => AuthHelper.IsInRole(u.Email, AppUserRole.Admin) &&
AuthHelper.IsInRole(u.Email, AppUserRole.DeaconLeadership)));
case AppUserFilter.LeadershipAndDeacon:
return(users.FindAll(u => AuthHelper.IsInRole(u.Email, AppUserRole.DeaconLeadership) &&
AuthHelper.IsInRole(u.Email, AppUserRole.Deacon)));
case AppUserFilter.ChangeRequestManager:
return(users.FindAll(u => u.ChangeRequestManager));
default:
return(users);
}
}
public async IAsyncEnumerable <ListResponse <AppUserVM> > UserList(
AppUserFilter filter,
AppUserSort sort,
Paginate paginate)
{
yield return(await HubHelper.WrapAsync(_logger, async() =>
{
IQueryable <AppUser> query = _db.Users
.Include(m => m.UserClaims)
.Include(m => m.UserRoles)
.ThenInclude(m => m.Role);
switch (sort)
{
case AppUserSort.EmailAsc:
query = query.OrderBy(m => m.Email);
break;
case AppUserSort.EmailDesc:
query = query.OrderByDescending(m => m.Email);
break;
}
if (!string.IsNullOrEmpty(filter.Email))
{
query = query.Where(m => EF.Functions.ILike(m.Email, $"%{filter.Email}%"));
}
return await PaginationHelper.FromQueryAsync <AppUser, AppUserVM>(paginate, query);
}));
}
private AppUserFilter ConvertFilterDTOToFilterEntity(AppUser_AppUserFilterDTO AppUser_AppUserFilterDTO)
{
AppUserFilter AppUserFilter = new AppUserFilter();
AppUserFilter.Selects = AppUserSelect.ALL;
AppUserFilter.Skip = AppUser_AppUserFilterDTO.Skip;
AppUserFilter.Take = AppUser_AppUserFilterDTO.Take;
AppUserFilter.OrderBy = AppUser_AppUserFilterDTO.OrderBy;
AppUserFilter.OrderType = AppUser_AppUserFilterDTO.OrderType;
AppUserFilter.Id = AppUser_AppUserFilterDTO.Id;
AppUserFilter.Username = AppUser_AppUserFilterDTO.Username;
AppUserFilter.Password = AppUser_AppUserFilterDTO.Password;
AppUserFilter.DisplayName = AppUser_AppUserFilterDTO.DisplayName;
AppUserFilter.Address = AppUser_AppUserFilterDTO.Address;
AppUserFilter.Email = AppUser_AppUserFilterDTO.Email;
AppUserFilter.Phone = AppUser_AppUserFilterDTO.Phone;
AppUserFilter.PositionId = AppUser_AppUserFilterDTO.PositionId;
AppUserFilter.Department = AppUser_AppUserFilterDTO.Department;
AppUserFilter.OrganizationId = AppUser_AppUserFilterDTO.OrganizationId;
AppUserFilter.ERouteScopeId = AppUser_AppUserFilterDTO.ERouteScopeId;
AppUserFilter.SexId = AppUser_AppUserFilterDTO.SexId;
AppUserFilter.StatusId = AppUser_AppUserFilterDTO.StatusId;
AppUserFilter.ProvinceId = AppUser_AppUserFilterDTO.ProvinceId;
return(AppUserFilter);
}
public async Task <ActionResult <List <Organization_AppUserDTO> > > FilterListAppUser([FromBody] Organization_AppUserFilterDTO Organization_AppUserFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
AppUserFilter AppUserFilter = new AppUserFilter();
AppUserFilter.Skip = 0;
AppUserFilter.Take = 20;
AppUserFilter.OrderBy = AppUserOrder.Id;
AppUserFilter.OrderType = OrderType.ASC;
AppUserFilter.Selects = AppUserSelect.ALL;
AppUserFilter.Id = Organization_AppUserFilterDTO.Id;
AppUserFilter.Username = Organization_AppUserFilterDTO.Username;
AppUserFilter.Password = Organization_AppUserFilterDTO.Password;
AppUserFilter.DisplayName = Organization_AppUserFilterDTO.DisplayName;
AppUserFilter.Address = Organization_AppUserFilterDTO.Address;
AppUserFilter.Email = Organization_AppUserFilterDTO.Email;
AppUserFilter.Phone = Organization_AppUserFilterDTO.Phone;
AppUserFilter.Department = Organization_AppUserFilterDTO.Department;
AppUserFilter.OrganizationId = Organization_AppUserFilterDTO.OrganizationId;
AppUserFilter.SexId = Organization_AppUserFilterDTO.SexId;
AppUserFilter.StatusId = null;
//if (AppUserFilter.Id == null) AppUserFilter.Id = new IdFilter();
//AppUserFilter.Id.In = await FilterAppUser(AppUserService, OrganizationService, CurrentContext);
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
List <Organization_AppUserDTO> Organization_AppUserDTOs = AppUsers
.Select(x => new Organization_AppUserDTO(x)).ToList();
return(Organization_AppUserDTOs);
}
private async Task <bool> ValidateAssignAppUser(Role Role)
{
List <long> ids = Role.AppUserRoleMappings.Select(a => a.AppUserId).ToList();
AppUserFilter AppUserFilter = new AppUserFilter
{
Skip = 0,
Take = int.MaxValue,
Id = new IdFilter {
In = ids
},
OrganizationId = new IdFilter(),
Selects = AppUserSelect.Id,
OrderBy = AppUserOrder.Id,
};
var listInDB = await UOW.AppUserRepository.List(AppUserFilter);
var listExcept = Role.AppUserRoleMappings.Select(a => a.AppUserId).Except(listInDB.Select(a => a.Id));
if (listExcept.Any())
{
foreach (var AppUserID in listExcept)
{
Role.AddError(nameof(RoleValidator), AppUserID.ToString(), ErrorCode.AppUserNotExisted);
}
}
return(Role.IsValidated);
}
public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter AppUserFilter = new AppUserFilter();
AppUserFilter.Id = new IdFilter {
In = Ids
};
AppUserFilter.Selects = AppUserSelect.Id;
AppUserFilter.Skip = 0;
AppUserFilter.Take = int.MaxValue;
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
AppUsers = await AppUserService.BulkDelete(AppUsers);
if (AppUsers.Any(x => !x.IsValidated))
{
return(BadRequest(AppUsers.Where(x => !x.IsValidated)));
}
return(true);
}
public async Task <int> Count(AppUserFilter filter)
{
IQueryable <AppUserDAO> AppUsers = DataContext.AppUser.AsNoTracking();
AppUsers = DynamicFilter(AppUsers, filter);
return(await AppUsers.CountAsync());
}
public async Task<List<AppUser>> List(AppUserFilter filter)
{
if (filter == null) return new List<AppUser>();
IQueryable<AppUserDAO> AppUserDAOs = DataContext.AppUser;
AppUserDAOs = DynamicFilter(AppUserDAOs, filter);
AppUserDAOs = DynamicOrder(AppUserDAOs, filter);
List<AppUser> AppUsers = await DynamicSelect(AppUserDAOs, filter);
return AppUsers;
}
private async Task <bool> RejectStep(Guid RequestId, Dictionary <string, string> Parameters)
{
RequestWorkflowDefinitionMapping RequestWorkflowDefinitionMapping = await UOW.RequestWorkflowDefinitionMappingRepository.Get(RequestId);
WorkflowDefinition WorkflowDefinition = await UOW.WorkflowDefinitionRepository.Get(RequestWorkflowDefinitionMapping.WorkflowDefinitionId);
List <RequestWorkflowStepMapping> RequestWorkflowStepMappings = await UOW.RequestWorkflowStepMappingRepository.List(RequestId);
if (WorkflowDefinition != null && RequestWorkflowStepMappings.Count > 0)
{
List <WorkflowStep> ToSteps = new List <WorkflowStep>();
List <Mail> Mails = new List <Mail>();
foreach (WorkflowStep WorkflowStep in WorkflowDefinition.WorkflowSteps)
{
if (CurrentContext.RoleIds.Contains(WorkflowStep.RoleId))
{
var StartRequestStep = RequestWorkflowStepMappings
.Where(x => x.WorkflowStateId == WorkflowStateEnum.PENDING.Id)
.Where(x => x.WorkflowStepId == WorkflowStep.Id).FirstOrDefault();
if (StartRequestStep == null)
{
continue;
}
StartRequestStep.WorkflowStateId = WorkflowStateEnum.REJECTED.Id;
StartRequestStep.UpdatedAt = StaticParams.DateTimeNow;
StartRequestStep.AppUserId = CurrentContext.UserId;
await UOW.RequestWorkflowStepMappingRepository.BulkMerge(RequestId, RequestWorkflowStepMappings);
AppUserFilter AppUserFilter = new AppUserFilter
{
Id = new IdFilter {
Equal = RequestWorkflowDefinitionMapping.CreatorId
},
Skip = 0,
Take = int.MaxValue,
Selects = AppUserSelect.Email
};
List <AppUser> appUsers = await UOW.AppUserRepository.List(AppUserFilter);
List <string> recipients = appUsers.Select(au => au.Email).Distinct().ToList();
Mail MailForReject = new Mail
{
Recipients = recipients,
Subject = CreateMailContent(WorkflowStep.SubjectMailForReject, Parameters),
Body = CreateMailContent(WorkflowStep.BodyMailForReject, Parameters),
RowId = Guid.NewGuid()
};
Mails.Add(MailForReject);
return(true);
}
}
List <EventMessage <Mail> > messages = Mails.Select(m => new EventMessage <Mail>(m, m.RowId)).ToList();
RabbitManager.PublishList(messages, RoutingKeyEnum.MailSend);
}
return(false);
}
public JsonResult SearchAppUser(AppUserFilter filter)
{
var result = _appUserService.SearchAppUser(filter);
return(Json(new
{
data = result.ToList(),
totalRecordCount = filter.FilteredRecordCount
}, JsonRequestBehavior.AllowGet));
}
public AppUserFilter ToFilter(AppUserFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <AppUserFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
AppUserFilter subFilter = new AppUserFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.Id))
{
subFilter.Id = FilterBuilder.Merge(subFilter.Id, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Username))
{
subFilter.Username = FilterBuilder.Merge(subFilter.Username, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Password))
{
subFilter.Password = FilterBuilder.Merge(subFilter.Password, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.DisplayName))
{
subFilter.DisplayName = FilterBuilder.Merge(subFilter.DisplayName, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Email))
{
subFilter.Email = FilterBuilder.Merge(subFilter.Email, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Phone))
{
subFilter.Phone = FilterBuilder.Merge(subFilter.Phone, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null)
{
if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id)
{
}
if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id)
{
}
}
}
}
return(filter);
}
public async Task <OpportunityEmail> Send(OpportunityEmail OpportunityEmail)
{
try
{
var oldData = await UOW.OpportunityEmailRepository.Get(OpportunityEmail.Id);
if (oldData == null)
{
await Create(OpportunityEmail);
}
else
{
await Update(OpportunityEmail);
}
var AppUserIds = OpportunityEmail.OpportunityEmailCCMappings?.Select(x => x.AppUserId).ToList();
var Reciepients = new List <string>();
Reciepients.Add(OpportunityEmail.Reciepient);
if (AppUserIds != null && AppUserIds.Count > 0)
{
AppUserFilter AppUserFilter = new AppUserFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = AppUserSelect.Id | AppUserSelect.Email
};
var AppUsers = await UOW.AppUserRepository.List(AppUserFilter);
var AppUserEmails = AppUsers.Select(x => x.Email).ToList();
Reciepients.AddRange(AppUserEmails);
}
Mail mail = new Mail
{
Subject = OpportunityEmail.Title,
Body = OpportunityEmail.Content,
Recipients = Reciepients,
RowId = Guid.NewGuid()
};
RabbitManager.PublishSingle(new EventMessage <Mail>(mail, mail.RowId), RoutingKeyEnum.MailSend);
OpportunityEmail.EmailStatusId = EmailStatusEnum.DONE.Id;
await UOW.OpportunityEmailRepository.Update(OpportunityEmail);
OpportunityEmail = await UOW.OpportunityEmailRepository.Get(OpportunityEmail.Id);
await Logging.CreateAuditLog(OpportunityEmail, new { }, nameof(OpportunityEmailService));
return(OpportunityEmail);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(OpportunityEmailService));
}
return(null);
}
public IActionResult GetUsers(string userName)
{
var userFilter = new AppUserFilter
{
UserName = userName
};
var user = ServiceFactory.AppUserService.GetUser(userFilter);
return(Json(user.RoleName));
}
private IQueryable <AppUserDAO> DynamicFilter(IQueryable <AppUserDAO> query, AppUserFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
query = query.Where(q => !q.DeletedAt.HasValue);
if (filter.CreatedAt != null && filter.CreatedAt.HasValue)
{
query = query.Where(q => q.CreatedAt, filter.CreatedAt);
}
if (filter.UpdatedAt != null && filter.UpdatedAt.HasValue)
{
query = query.Where(q => q.UpdatedAt, filter.UpdatedAt);
}
if (filter.Id != null && filter.Id.HasValue)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Username != null && filter.Username.HasValue)
{
query = query.Where(q => q.Username, filter.Username);
}
if (filter.Password != null && filter.Password.HasValue)
{
query = query.Where(q => q.Password, filter.Password);
}
if (filter.DisplayName != null && filter.DisplayName.HasValue)
{
query = query.Where(q => q.DisplayName, filter.DisplayName);
}
if (filter.Email != null && filter.Email.HasValue)
{
query = query.Where(q => q.Email, filter.Email);
}
if (filter.Phone != null && filter.Phone.HasValue)
{
query = query.Where(q => q.Phone, filter.Phone);
}
if (filter.SexId != null && filter.SexId.HasValue)
{
query = query.Where(q => q.SexId, filter.SexId);
}
if (filter.Birthday != null && filter.Birthday.HasValue)
{
query = query.Where(q => q.Birthday, filter.Birthday);
}
if (filter.RoleId != null && filter.RoleId.HasValue)
{
query = query.Where(q => q.RoleId, filter.RoleId);
}
query = OrFilter(query, filter);
return(query);
}
public BaseQuery GetUsers(AppUserFilter filter)
{
return
(GetUsersJoined(
filter,
@"this_.AppUserId AS UserId,
(this_.LastName + ', ' + this_.FirstName) AS FullName,
this_.UserName,
this_.Email,
this_.IsActive,
userRole_.Name as RoleName"));
}
public async Task <ActionResult <int> > Count([FromBody] AppUser_AppUserFilterDTO AppUser_AppUserFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter AppUserFilter = ConvertFilterDTOToFilterEntity(AppUser_AppUserFilterDTO);
int count = await AppUserService.Count(AppUserFilter);
return(count);
}
public async Task <ActionResult> ExportAppUser([FromBody] Organization_AppUserFilterDTO Organization_AppUserFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter AppUserFilter = new AppUserFilter();
AppUserFilter.Skip = 0;
AppUserFilter.Take = int.MaxValue;
AppUserFilter.Selects = AppUserSelect.Id | AppUserSelect.Username | AppUserSelect.Username | AppUserSelect.Address | AppUserSelect.Phone | AppUserSelect.Sex
| AppUserSelect.Birthday | AppUserSelect.Organization | AppUserSelect.Status;
AppUserFilter.OrganizationId = Organization_AppUserFilterDTO.OrganizationId;
AppUserFilter = AppUserService.ToFilter(AppUserFilter);
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
var AppUserHeaders = new List <string[]>()
{
new string[] { "STT", "Tên đăng nhập", "Tên hiển thị", "Địa chỉ", "Điện thoại", "Email", "Giới tính", "Ngày sinh", "Đơn vị quản lý", "Trạng thái" }
};
List <object[]> data = new List <object[]>();
for (int i = 0; i < AppUsers.Count; i++)
{
var appUser = AppUsers[i];
data.Add(new Object[]
{
i + 1,
appUser.Username,
appUser.DisplayName,
appUser.Address,
appUser.Phone,
appUser.Email,
appUser.Sex.Name,
appUser.Birthday?.ToString("dd-MM-yyyy"),
appUser.Organization.Code,
appUser.Status.Name,
});
}
excel.GenerateWorksheet("Tài khoản", AppUserHeaders, data);
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "Organization_AppUser" + ".xlsx"));
}
/// <summary>
/// Gets the users.
/// </summary>
/// <param name="filter">The filter.</param>
/// <param name="selectList">The select list.</param>
/// <returns></returns>
private BaseQuery GetUsersJoined(AppUserFilter filter, string selectList)
{
var builder = new StringBuilder();
builder.Append(
@"SELECT
" + selectList + @"
FROM [AppUser] this_
INNER JOIN [AppUserRole] userRole_ on this_.AppUserRoleId = userRole_.AppUserRoleId
WHERE (1 = 1)");
return(new BaseQuery(builder, null));
}
private IQueryable <AppUserDAO> OrFilter(IQueryable <AppUserDAO> query, AppUserFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <AppUserDAO> initQuery = query.Where(q => false);
foreach (AppUserFilter AppUserFilter in filter.OrFilter)
{
IQueryable <AppUserDAO> queryable = query;
if (AppUserFilter.Id != null && AppUserFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, filter.Id);
}
if (AppUserFilter.Username != null && AppUserFilter.Username.HasValue)
{
queryable = queryable.Where(q => q.Username, filter.Username);
}
if (AppUserFilter.Password != null && AppUserFilter.Password.HasValue)
{
queryable = queryable.Where(q => q.Password, filter.Password);
}
if (AppUserFilter.DisplayName != null && AppUserFilter.DisplayName.HasValue)
{
queryable = queryable.Where(q => q.DisplayName, filter.DisplayName);
}
if (AppUserFilter.Email != null && AppUserFilter.Email.HasValue)
{
queryable = queryable.Where(q => q.Email, filter.Email);
}
if (AppUserFilter.Phone != null && AppUserFilter.Phone.HasValue)
{
queryable = queryable.Where(q => q.Phone, filter.Phone);
}
if (AppUserFilter.SexId != null && AppUserFilter.SexId.HasValue)
{
queryable = queryable.Where(q => q.SexId, filter.SexId);
}
if (AppUserFilter.Birthday != null && AppUserFilter.Birthday.HasValue)
{
queryable = queryable.Where(q => q.Birthday, filter.Birthday);
}
if (AppUserFilter.RoleId != null && AppUserFilter.RoleId.HasValue)
{
queryable = queryable.Where(q => q.RoleId, filter.RoleId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
