private Result <CallClientTypeFilter> MapCallTypeEnums(CallTypeFilter filter)
{
CallClientTypeFilter typeFilter;
switch (filter)
{
case CallTypeFilter.All:
typeFilter = CallClientTypeFilter.All;
break;
case CallTypeFilter.Incoming:
typeFilter = CallClientTypeFilter.Incoming;
break;
case CallTypeFilter.Outgoing:
typeFilter = CallClientTypeFilter.Outgoing;
break;
default:
var message = $"CallManagementService. Error on converting CallTypeFilter to CallClientTypeFilter. CallTypeFilter value: {(int)filter}";
_logger.Warning(message);
return(Result.Failure <CallClientTypeFilter>(ErrorCodes.ValidationError));
}
return(Result.Success(typeFilter));
}
public async Task <ActionResult <List <CallLog_CallTypeDTO> > > FilterListCallType([FromBody] CallLog_CallTypeFilterDTO CallLog_CallTypeFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CallTypeFilter CallTypeFilter = new CallTypeFilter();
CallTypeFilter.Skip = 0;
CallTypeFilter.Take = 20;
CallTypeFilter.OrderBy = CallTypeOrder.Id;
CallTypeFilter.OrderType = OrderType.ASC;
CallTypeFilter.Selects = CallTypeSelect.ALL;
CallTypeFilter.Id = CallLog_CallTypeFilterDTO.Id;
CallTypeFilter.Code = CallLog_CallTypeFilterDTO.Code;
CallTypeFilter.Name = CallLog_CallTypeFilterDTO.Name;
CallTypeFilter.ColorCode = CallLog_CallTypeFilterDTO.ColorCode;
CallTypeFilter.StatusId = CallLog_CallTypeFilterDTO.StatusId;
List <CallType> CallTypes = await CallTypeService.List(CallTypeFilter);
List <CallLog_CallTypeDTO> CallLog_CallTypeDTOs = CallTypes
.Select(x => new CallLog_CallTypeDTO(x)).ToList();
return(CallLog_CallTypeDTOs);
}
private IQueryable <CallTypeDAO> OrFilter(IQueryable <CallTypeDAO> query, CallTypeFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <CallTypeDAO> initQuery = query.Where(q => false);
foreach (CallTypeFilter CallTypeFilter in filter.OrFilter)
{
IQueryable <CallTypeDAO> queryable = query;
if (CallTypeFilter.Id != null)
{
queryable = queryable.Where(q => q.Id, CallTypeFilter.Id);
}
if (CallTypeFilter.Code != null)
{
queryable = queryable.Where(q => q.Code, CallTypeFilter.Code);
}
if (CallTypeFilter.Name != null)
{
queryable = queryable.Where(q => q.Name, CallTypeFilter.Name);
}
if (CallTypeFilter.ColorCode != null)
{
queryable = queryable.Where(q => q.ColorCode, CallTypeFilter.ColorCode);
}
if (CallTypeFilter.StatusId != null)
{
queryable = queryable.Where(q => q.StatusId, CallTypeFilter.StatusId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public async Task <int> Count(CallTypeFilter filter)
{
IQueryable <CallTypeDAO> CallTypes = DataContext.CallType.AsNoTracking();
CallTypes = DynamicFilter(CallTypes, filter);
return(await CallTypes.CountAsync());
}
public async Task <demoResult <List <JournalCallsDto> > > GetJournalCalls(CallTypeFilter filter, bool notAcceptedOnly)
{
var journalCallsResult = await _callManagementService.GetJournalCalls(GetUserId(), filter, notAcceptedOnly);
if (journalCallsResult.IsFailure)
{
_logger.Warning($"Error on CallsController GetJournalCalls. {journalCallsResult.ErrorMessage}");
return(BadRequest(journalCallsResult.ErrorCode));
}
return(Answer(journalCallsResult));
}
public async Task <List <CallType> > List(CallTypeFilter filter)
{
if (filter == null)
{
return(new List <CallType>());
}
IQueryable <CallTypeDAO> CallTypeDAOs = DataContext.CallType.AsNoTracking();
CallTypeDAOs = DynamicFilter(CallTypeDAOs, filter);
CallTypeDAOs = DynamicOrder(CallTypeDAOs, filter);
List <CallType> CallTypes = await DynamicSelect(CallTypeDAOs, filter);
return(CallTypes);
}
public CallTypeFilter ToFilter(CallTypeFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <CallTypeFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
CallTypeFilter subFilter = new CallTypeFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.Id))
{
subFilter.Id = FilterPermissionDefinition.IdFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Code))
{
subFilter.Code = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Name))
{
subFilter.Name = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.ColorCode))
{
subFilter.ColorCode = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.StatusId))
{
subFilter.StatusId = FilterPermissionDefinition.IdFilter;
}
}
}
return(filter);
}
public async Task <bool> ValidateId(CallType CallType)
{
CallTypeFilter CallTypeFilter = new CallTypeFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = CallType.Id
},
Selects = CallTypeSelect.Id
};
int count = await UOW.CallTypeRepository.Count(CallTypeFilter);
if (count == 0)
{
CallType.AddError(nameof(CallTypeValidator), nameof(CallType.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <bool> ValidateCode(CallType CallType)
{
if (string.IsNullOrWhiteSpace(CallType.Code))
{
CallType.AddError(nameof(CallTypeValidator), nameof(CallType.Code), ErrorCode.CodeEmpty);
}
else
{
var Code = CallType.Code;
if (CallType.Code.Contains(" ") || !FilterExtension.ChangeToEnglishChar(Code).Equals(CallType.Code))
{
CallType.AddError(nameof(CallTypeValidator), nameof(CallType.Code), ErrorCode.CodeHasSpecialCharacter);
}
CallTypeFilter CallTypeFilter = new CallTypeFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
NotEqual = CallType.Id
},
Code = new StringFilter {
Equal = CallType.Code
},
Selects = CallTypeSelect.Code
};
int count = await UOW.CallTypeRepository.Count(CallTypeFilter);
if (count != 0)
{
CallType.AddError(nameof(CallTypeValidator), nameof(CallType.Code), ErrorCode.CodeExisted);
}
}
return(CallType.IsValidated);
}
public async Task <List <CallType> > List(CallTypeFilter CallTypeFilter)
{
try
{
List <CallType> CallTypes = await UOW.CallTypeRepository.List(CallTypeFilter);
return(CallTypes);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(CallTypeService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(CallTypeService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(CallTypeFilter CallTypeFilter)
{
try
{
int result = await UOW.CallTypeRepository.Count(CallTypeFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(CallTypeService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(CallTypeService));
throw new MessageException(ex.InnerException);
}
}
}
/// <summary>
/// Получить журнал звонков
/// </summary>
public async Task <Result <List <JournalCallsDto> > > GetJournalCalls(Guid userId, CallTypeFilter filter, bool notAcceptedOnly)
{
var callClientTypeFilterResult = MapCallTypeEnums(filter);
if (callClientTypeFilterResult.IsFailure)
{
_logger.Information($"Failed to get call journal by userId: {userId}, filter: {filter}, notAcceptedOnly: {notAcceptedOnly} в CallManagementService. {callClientTypeFilterResult.ErrorMessage}");
return(Result.Failure <List <JournalCallsDto> >(callClientTypeFilterResult.ErrorCode));
}
var callListClientResult = await _callManagementServiceClient.GetJournalCalls(callClientTypeFilterResult.Value, notAcceptedOnly);
if (callListClientResult.IsFailure)
{
var name = Enum.GetName(typeof(CallClientTypeFilter), filter);
var message = $"Failed to get call journal by userId: {userId}, filter: {name}, notAcceptedOnly: {notAcceptedOnly} в CallManagementService. {callListClientResult.ErrorMessage}";
_logger.Information(message);
return(Result.Failure <List <JournalCallsDto> >(ErrorCodes.UnableToGetJournalCalls));
}
_unitOfWork.Begin();
var journalCalls = await CreateJournalFromCallList(callListClientResult.Value);
return(Result.Success(journalCalls));
}
public async Task <ActionResult> ExportTemplate([FromBody] CallLog_CallLogFilterDTO CallLog_CallLogFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
#region CallLog
var CallLogHeaders = new List <string[]>()
{
new string[] {
"Id",
"EntityReferenceId",
"CallTypeId",
"CallEmotionId",
"AppUserId",
"Title",
"Content",
"Phone",
"CallTime",
"Used",
}
};
List <object[]> CallLogData = new List <object[]>();
excel.GenerateWorksheet("CallLog", CallLogHeaders, CallLogData);
#endregion
#region AppUser
var AppUserFilter = new AppUserFilter();
AppUserFilter.Selects = AppUserSelect.ALL;
AppUserFilter.OrderBy = AppUserOrder.Id;
AppUserFilter.OrderType = OrderType.ASC;
AppUserFilter.Skip = 0;
AppUserFilter.Take = int.MaxValue;
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
var AppUserHeaders = new List <string[]>()
{
new string[] {
"Id",
"Username",
"DisplayName",
"Address",
"Email",
"Phone",
"SexId",
"Birthday",
"Avatar",
"PositionId",
"Department",
"OrganizationId",
"ProvinceId",
"Longitude",
"Latitude",
"StatusId",
}
};
List <object[]> AppUserData = new List <object[]>();
for (int i = 0; i < AppUsers.Count; i++)
{
var AppUser = AppUsers[i];
AppUserData.Add(new Object[]
{
AppUser.Id,
AppUser.Username,
AppUser.DisplayName,
AppUser.Address,
AppUser.Email,
AppUser.Phone,
AppUser.SexId,
AppUser.Birthday,
AppUser.Avatar,
AppUser.PositionId,
AppUser.Department,
AppUser.OrganizationId,
AppUser.ProvinceId,
AppUser.Longitude,
AppUser.Latitude,
AppUser.StatusId,
});
}
excel.GenerateWorksheet("AppUser", AppUserHeaders, AppUserData);
#endregion
#region EntityReference
var EntityReferenceFilter = new EntityReferenceFilter();
EntityReferenceFilter.Selects = EntityReferenceSelect.ALL;
EntityReferenceFilter.OrderBy = EntityReferenceOrder.Id;
EntityReferenceFilter.OrderType = OrderType.ASC;
EntityReferenceFilter.Skip = 0;
EntityReferenceFilter.Take = int.MaxValue;
List <EntityReference> EntityReferences = await EntityReferenceService.List(EntityReferenceFilter);
var EntityReferenceHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
}
};
List <object[]> EntityReferenceData = new List <object[]>();
for (int i = 0; i < EntityReferences.Count; i++)
{
var EntityReference = EntityReferences[i];
EntityReferenceData.Add(new Object[]
{
EntityReference.Id,
EntityReference.Code,
EntityReference.Name,
});
}
excel.GenerateWorksheet("EntityReference", EntityReferenceHeaders, EntityReferenceData);
#endregion
#region CallType
var CallTypeFilter = new CallTypeFilter();
CallTypeFilter.Selects = CallTypeSelect.ALL;
CallTypeFilter.OrderBy = CallTypeOrder.Id;
CallTypeFilter.OrderType = OrderType.ASC;
CallTypeFilter.Skip = 0;
CallTypeFilter.Take = int.MaxValue;
List <CallType> CallTypes = await CallTypeService.List(CallTypeFilter);
var CallTypeHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
"ColorCode",
"StatusId",
"Used",
}
};
List <object[]> CallTypeData = new List <object[]>();
for (int i = 0; i < CallTypes.Count; i++)
{
var CallType = CallTypes[i];
CallTypeData.Add(new Object[]
{
CallType.Id,
CallType.Code,
CallType.Name,
CallType.ColorCode,
CallType.StatusId,
CallType.Used,
});
}
excel.GenerateWorksheet("CallType", CallTypeHeaders, CallTypeData);
#endregion
#region CallEmotion
var CallEmotionFilter = new CallEmotionFilter();
CallEmotionFilter.Selects = CallEmotionSelect.ALL;
CallEmotionFilter.OrderBy = CallEmotionOrder.Id;
CallEmotionFilter.OrderType = OrderType.ASC;
CallEmotionFilter.Skip = 0;
CallEmotionFilter.Take = int.MaxValue;
List <CallEmotion> CallEmotions = await CallEmotionService.List(CallEmotionFilter);
var CallEmotionHeaders = new List <string[]>()
{
new string[] {
"Id",
"Name",
"Code",
"StatusId",
"DisplayOrder",
"Description",
}
};
List <object[]> CallEmotionData = new List <object[]>();
for (int i = 0; i < CallEmotions.Count; i++)
{
var CallEmotion = CallEmotions[i];
CallEmotionData.Add(new Object[]
{
CallEmotion.Id,
CallEmotion.Name,
CallEmotion.Code,
CallEmotion.StatusId,
CallEmotion.Description,
});
}
excel.GenerateWorksheet("CallEmotion", CallEmotionHeaders, CallEmotionData);
#endregion
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "CallLog.xlsx"));
}
public async Task <ActionResult> Import(IFormFile file)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter AppUserFilter = new AppUserFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = AppUserSelect.ALL
};
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
EntityReferenceFilter EntityReferenceFilter = new EntityReferenceFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = EntityReferenceSelect.ALL
};
List <EntityReference> EntityReferences = await EntityReferenceService.List(EntityReferenceFilter);
CallTypeFilter CallTypeFilter = new CallTypeFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = CallTypeSelect.ALL
};
List <CallType> CallTypes = await CallTypeService.List(CallTypeFilter);
CallEmotionFilter CallEmotionFilter = new CallEmotionFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = CallEmotionSelect.ALL
};
List <CallEmotion> CallEmotions = await CallEmotionService.List(CallEmotionFilter);
List <CallLog> CallLogs = new List <CallLog>();
using (ExcelPackage excelPackage = new ExcelPackage(file.OpenReadStream()))
{
ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.FirstOrDefault();
if (worksheet == null)
{
return(Ok(CallLogs));
}
int StartColumn = 1;
int StartRow = 1;
int IdColumn = 0 + StartColumn;
int EntityReferenceIdColumn = 1 + StartColumn;
int CallTypeIdColumn = 2 + StartColumn;
int CallEmotionIdColumn = 3 + StartColumn;
int AppUserIdColumn = 4 + StartColumn;
int TitleColumn = 5 + StartColumn;
int ContentColumn = 6 + StartColumn;
int PhoneColumn = 7 + StartColumn;
int CallTimeColumn = 8 + StartColumn;
int UsedColumn = 12 + StartColumn;
for (int i = StartRow; i <= worksheet.Dimension.End.Row; i++)
{
if (string.IsNullOrEmpty(worksheet.Cells[i + StartRow, StartColumn].Value?.ToString()))
{
break;
}
string IdValue = worksheet.Cells[i + StartRow, IdColumn].Value?.ToString();
string EntityReferenceIdValue = worksheet.Cells[i + StartRow, EntityReferenceIdColumn].Value?.ToString();
string CallTypeIdValue = worksheet.Cells[i + StartRow, CallTypeIdColumn].Value?.ToString();
string CallEmotionIdValue = worksheet.Cells[i + StartRow, CallEmotionIdColumn].Value?.ToString();
string AppUserIdValue = worksheet.Cells[i + StartRow, AppUserIdColumn].Value?.ToString();
string TitleValue = worksheet.Cells[i + StartRow, TitleColumn].Value?.ToString();
string ContentValue = worksheet.Cells[i + StartRow, ContentColumn].Value?.ToString();
string PhoneValue = worksheet.Cells[i + StartRow, PhoneColumn].Value?.ToString();
string CallTimeValue = worksheet.Cells[i + StartRow, CallTimeColumn].Value?.ToString();
string UsedValue = worksheet.Cells[i + StartRow, UsedColumn].Value?.ToString();
CallLog CallLog = new CallLog();
CallLog.Title = TitleValue;
CallLog.Content = ContentValue;
CallLog.Phone = PhoneValue;
CallLog.CallTime = DateTime.TryParse(CallTimeValue, out DateTime CallTime) ? CallTime : DateTime.Now;
AppUser AppUser = AppUsers.Where(x => x.Id.ToString() == AppUserIdValue).FirstOrDefault();
CallLog.AppUserId = AppUser == null ? 0 : AppUser.Id;
CallLog.AppUser = AppUser;
EntityReference EntityReference = EntityReferences.Where(x => x.Id.ToString() == EntityReferenceIdValue).FirstOrDefault();
CallLog.EntityReferenceId = EntityReference == null ? 0 : EntityReference.Id;
CallLog.EntityReference = EntityReference;
CallType CallType = CallTypes.Where(x => x.Id.ToString() == CallTypeIdValue).FirstOrDefault();
CallLog.CallTypeId = CallType == null ? 0 : CallType.Id;
CallLog.CallType = CallType;
CallEmotion CallEmotion = CallEmotions.Where(x => x.Id.ToString() == CallEmotionIdValue).FirstOrDefault();
CallLog.CallEmotionId = CallEmotion == null ? 0 : CallEmotion.Id;
CallLog.CallEmotion = CallEmotion;
CallLogs.Add(CallLog);
}
}
CallLogs = await CallLogService.Import(CallLogs);
if (CallLogs.All(x => x.IsValidated))
{
return(Ok(true));
}
else
{
List <string> Errors = new List <string>();
for (int i = 0; i < CallLogs.Count; i++)
{
CallLog CallLog = CallLogs[i];
if (!CallLog.IsValidated)
{
string Error = $"Dòng {i + 2} có lỗi:";
if (CallLog.Errors.ContainsKey(nameof(CallLog.Id)))
{
Error += CallLog.Errors[nameof(CallLog.Id)];
}
if (CallLog.Errors.ContainsKey(nameof(CallLog.EntityReferenceId)))
{
Error += CallLog.Errors[nameof(CallLog.EntityReferenceId)];
}
if (CallLog.Errors.ContainsKey(nameof(CallLog.CallTypeId)))
{
Error += CallLog.Errors[nameof(CallLog.CallTypeId)];
}
if (CallLog.Errors.ContainsKey(nameof(CallLog.CallEmotionId)))
{
Error += CallLog.Errors[nameof(CallLog.CallEmotionId)];
}
if (CallLog.Errors.ContainsKey(nameof(CallLog.AppUserId)))
{
Error += CallLog.Errors[nameof(CallLog.AppUserId)];
}
if (CallLog.Errors.ContainsKey(nameof(CallLog.Title)))
{
Error += CallLog.Errors[nameof(CallLog.Title)];
}
if (CallLog.Errors.ContainsKey(nameof(CallLog.Content)))
{
Error += CallLog.Errors[nameof(CallLog.Content)];
}
if (CallLog.Errors.ContainsKey(nameof(CallLog.Phone)))
{
Error += CallLog.Errors[nameof(CallLog.Phone)];
}
if (CallLog.Errors.ContainsKey(nameof(CallLog.CallTime)))
{
Error += CallLog.Errors[nameof(CallLog.CallTime)];
}
Errors.Add(Error);
}
}
return(BadRequest(Errors));
}
}
private IQueryable <CallTypeDAO> DynamicOrder(IQueryable <CallTypeDAO> query, CallTypeFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case CallTypeOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case CallTypeOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case CallTypeOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case CallTypeOrder.ColorCode:
query = query.OrderBy(q => q.ColorCode);
break;
case CallTypeOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
case CallTypeOrder.Used:
query = query.OrderBy(q => q.Used);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case CallTypeOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case CallTypeOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case CallTypeOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case CallTypeOrder.ColorCode:
query = query.OrderByDescending(q => q.ColorCode);
break;
case CallTypeOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
case CallTypeOrder.Used:
query = query.OrderByDescending(q => q.Used);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <CallTypeDAO> DynamicFilter(IQueryable <CallTypeDAO> query, CallTypeFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
query = query.Where(q => !q.DeletedAt.HasValue);
if (filter.CreatedAt != null)
{
query = query.Where(q => q.CreatedAt, filter.CreatedAt);
}
if (filter.UpdatedAt != null)
{
query = query.Where(q => q.UpdatedAt, filter.UpdatedAt);
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Code != null)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.Name != null)
{
query = query.Where(q => q.Name, filter.Name);
}
if (filter.ColorCode != null)
{
query = query.Where(q => q.ColorCode, filter.ColorCode);
}
if (filter.StatusId != null)
{
query = query.Where(q => q.StatusId, filter.StatusId);
}
query = OrFilter(query, filter);
return(query);
}
private async Task <List <CallType> > DynamicSelect(IQueryable <CallTypeDAO> query, CallTypeFilter filter)
{
List <CallType> CallTypes = await query.Select(q => new CallType()
{
Id = filter.Selects.Contains(CallTypeSelect.Id) ? q.Id : default(long),
Code = filter.Selects.Contains(CallTypeSelect.Code) ? q.Code : default(string),
Name = filter.Selects.Contains(CallTypeSelect.Name) ? q.Name : default(string),
ColorCode = filter.Selects.Contains(CallTypeSelect.ColorCode) ? q.ColorCode : default(string),
StatusId = filter.Selects.Contains(CallTypeSelect.Status) ? q.StatusId : default(long),
Used = filter.Selects.Contains(CallTypeSelect.Used) ? q.Used : default(bool),
Status = filter.Selects.Contains(CallTypeSelect.Status) && q.Status != null ? new Status
{
Id = q.Status.Id,
Code = q.Status.Code,
Name = q.Status.Name,
} : null,
CreatedAt = q.CreatedAt,
UpdatedAt = q.UpdatedAt,
}).ToListAsync();
return(CallTypes);
}
