public async Task <ResponseDTO <PagedList <MainTenantBasicDTO> > > SearchByCodeAndName(MainTenantCodeNameRequest search)
{
List <OrderExpression <MainTenantBasicDTO> > orderExpressionList = new List <OrderExpression <MainTenantBasicDTO> >();
orderExpressionList.Add(new OrderExpression <MainTenantBasicDTO>(OrderType.Asc, p => p.FullName));
Expression <Func <MainTenantBasicDTO, bool> > queryFilter = c => true;
if (!string.IsNullOrEmpty(search.Code))
{
queryFilter = queryFilter.And(p => p.Code.Contains(search.Code));
}
if (!string.IsNullOrEmpty(search.FullName))
{
queryFilter = queryFilter.And(p => p.FullName.Contains(search.FullName));
}
var mainTenant = await _mainTenantSearchBasicDataAccess.ListPagedAsync(queryFilter, search.Page, search.PageSize, orderExpressionList.ToArray());
var pagedResult = new PagedList <MainTenantBasicDTO>()
{
Items = mainTenant.Items,
PageSize = mainTenant.PageSize,
Page = mainTenant.Page,
Total = mainTenant.Total
};
return(ResponseBuilder.Correct(pagedResult));
}
public async Task <ResponseDTO <List <PeriodDTO> > > GetPeriodAllAsync()
{
Expression <Func <PeriodDTO, bool> > queryFilter = c => true;
var periods = await _periodDataAccess.ListAsync(queryFilter);
return(ResponseBuilder.Correct(periods.ToList()));
}
public async Task <ResponseDTO <PagedList <EquipmentDTO> > > SearchEquipmentAsync(EquipmentSearchRequest search)
{
Expression <Func <EquipmentDTO, bool> > queryFilter = c => c.RowStatus;
if (!string.IsNullOrEmpty(search.EquipmentNo))
{
queryFilter = queryFilter.And(p => p.EquipmentNo.Contains(search.EquipmentNo));
}
var equipment = await _equipmentDataAccess.ListPagedAsync(queryFilter, search.Page, search.PageSize);
var pagedResult = new PagedList <EquipmentDTO>()
{
Items = equipment.Items,
PageSize = equipment.PageSize,
Page = equipment.Page,
Total = equipment.Total
};
var response = ResponseBuilder.Correct(pagedResult);
response.Messages = new List <ApplicationMessage>();
response.Messages.Add(new ApplicationMessage()
{
Key = "Info",
Message = !pagedResult.Items.Any() ? "No records found for this request" : ""
});
return(response);
}
public async Task <ResponseDTO> UpdateActions(AmigoTenanttRolPermissionRequest actions)
{
var role = (await _rolDataAccess.FirstOrDefaultAsync(x => x.Code == actions.CodeRol && x.RowStatus));
CommandResult result = null;
switch (actions.TableStatus)
{
case DTOs.Requests.Common.ObjectStatus.Deleted:
var delete = _mapper.Map <AmigoTenanttRolPermissionRequest, DeletePermissionCommand>(actions);
result = await _bus.SendAsync(delete);
break;
case DTOs.Requests.Common.ObjectStatus.Added:
var register = _mapper.Map <AmigoTenanttRolPermissionRequest, RegisterPermissionCommand>(actions);
result = await _bus.SendAsync(register);
break;
default:
return(ResponseBuilder.InCorrect());
}
return(result.IsCorrect ? ResponseBuilder.Correct():ResponseBuilder.InCorrect());
}
public async Task <ResponseDTO <PagedList <ExpenseDetailSearchDTO> > > GetDetailByExpenseIdAsync(ExpenseSearchRequest search)
{
List <OrderExpression <ExpenseDetailSearchDTO> > orderExpressionList = new List <OrderExpression <ExpenseDetailSearchDTO> >();
orderExpressionList.Add(new OrderExpression <ExpenseDetailSearchDTO>(OrderType.Asc, p => p.ConceptName));
Expression <Func <ExpenseDetailSearchDTO, bool> > queryFilter = c => true;
if (search.ExpenseId.HasValue)
{
queryFilter = queryFilter.And(p => p.ExpenseId == search.ExpenseId);
}
var expense = await _expenseDetailSearchDataAccess.ListPagedAsync
(queryFilter, search.Page, search.PageSize, orderExpressionList.ToArray());
var pagedResult = new PagedList <ExpenseDetailSearchDTO>()
{
Items = expense.Items,
PageSize = expense.PageSize,
Page = expense.Page,
Total = expense.Total
};
return(ResponseBuilder.Correct(pagedResult));
}
public async Task <ResponseDTO <List <HouseDTO> > > SearchHouseAll()
{
Expression <Func <HouseDTO, bool> > queryFilter = c => c.RowStatus;
var list = (await _houseDataAccess.ListAsync(queryFilter)).ToList();
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <List <HouseFeatureAndDetailDTO> > > SearchHouseFeatureAndDetailAsync(int?houseId, int?contractId)
{
List <OrderExpression <HouseFeatureAndDetailDTO> > orderExpressionList = new List <OrderExpression <HouseFeatureAndDetailDTO> >();
orderExpressionList.Add(new OrderExpression <HouseFeatureAndDetailDTO>(OrderType.Desc, p => p.IsAllHouse));
orderExpressionList.Add(new OrderExpression <HouseFeatureAndDetailDTO>(OrderType.Asc, p => p.Sequence));
Expression <Func <HouseFeatureAndDetailDTO, bool> > queryFilter = c => c.HouseId == houseId;
var list = (await _houseFeatureAndDetailDataAccess.ListAsync(queryFilter, orderExpressionList.ToArray())).ToList();
list.ForEach(r =>
{
r.IsDisabled = r.ContractId.HasValue && contractId != r.ContractId;
});
Expression <Func <HouseFeatureDetailContractDTO, bool> > queryFilterDetailContract = c => c.HouseId == houseId;
var listDetailContract = await _houseFeatureDetailContractDataAccess.ListAsync(queryFilterDetailContract);
//Deshabilitar Complete "IsAllHouse" porque ha sido alquilada por partes
var existDisable = list.Any(r => r.IsDisabled.Value);
if (existDisable)
{
list.Where(r => r.IsAllHouse.Value).ToList().ForEach(r => r.IsDisabled = true);
}
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <ModuleActionsDTO> > GetModuleAsync(GetModuleRequest getRequest)
{
var moduleAux = await SearchModulesAsync(new ModuleSearchRequest { Code = getRequest.Code, Page = 1, PageSize = 1 });
var module = moduleAux.Data.Items.FirstOrDefault();
if (module != null)
{
var actions = await _actionDataAcces.ListAsync(w => w.ModuleCode == module.Code);
var moduleActions = new ModuleActionsDTO
{
Code = module.Code,
Name = module.Name,
Url = module.Url,
SortOrder = module.SortOrder,
ParentModuleCode = module.ParentModuleCode,
Actions = actions.ToList()
};
if (moduleActions.Actions != null)
{
moduleActions.Actions.ForEach(p => p.TableStatus = DTOs.Requests.Common.ObjectStatus.Unchanged);
}
return(ResponseBuilder.Correct(moduleActions));
}
else
{
ModuleActionsDTO obj = null;
return(ResponseBuilder.Correct(obj));
}
}
public async Task <ResponseDTO> RegisterContractAsync(ContractRegisterRequest request)
{
request.ContractCode = await GetNextCode(request);
request.PeriodId = await GetPeriodByCode(request.ContractCode.Substring(2, 6));
request.ContractDate = DateTime.Now;
//TODO: Matodo para agregar informacion a la tabla Obligation, conceptos del tipo obligations
var response = await ValidateEntityRegister(request);
if (response.IsValid)
{
//await CreateContractDetail(request);
//await CreateContractDetailObligation(request);
var command = _mapper.Map <ContractRegisterRequest, ContractRegisterCommand>(request);
command.ContractStatusId = await GetStatusbyEntityAndCodeAsync(Constants.EntityCode.Contract, Constants.EntityStatus.Contract.Draft);
var resp = await _bus.SendAsync(command);
return(ResponseBuilder.Correct(resp, command.ContractId, command.ContractCode));
}
return(response);
}
public async Task <ResponseDTO> Delete(AmigoTenantTRoleStatusDTO dto)
{
var command = _mapper.Map <AmigoTenantTRoleStatusDTO, DeleteAmigoTenantTRoleCommand>(dto);
var resp = await _bus.SendAsync(command);
return(ResponseBuilder.Correct(resp));
}
public async Task <ResponseDTO <PagedList <DispatchingPartyDTO> > > SearchDispatchingPartyAsync(DispatchingPartySearchRequest search)
{
Expression <Func <DispatchingPartyDTO, bool> > queryFilter = c => c.RowStatus;
if (search.DispatchingPartyId > 0)
{
queryFilter = queryFilter.And(p => p.DispatchingPartyId == search.DispatchingPartyId);
}
if (!string.IsNullOrEmpty(search.Code))
{
queryFilter = queryFilter.And(p => p.Code.Contains(search.Code));
}
if (!string.IsNullOrEmpty(search.Name))
{
queryFilter = queryFilter.And(p => p.Code.Contains(search.Name));
}
var DispatchingParty = await _DispatchingPartyDataAccess.ListPagedAsync(queryFilter, search.Page, search.PageSize);
var pagedResult = new PagedList <DispatchingPartyDTO>()
{
Items = DispatchingParty.Items,
PageSize = DispatchingParty.PageSize,
Page = DispatchingParty.Page,
Total = DispatchingParty.Total
};
return(ResponseBuilder.Correct(pagedResult));
}
public async Task <ResponseDTO <PagedList <InternalReportDTO> > > SearchInternalCurrentAsync(ReportCurrentRequest search)
{
var queryFilter = GetQueryFilter(search);
var eventLogs = await _reportDataAccess.ListPagedAsync(queryFilter, search.Page, search.PageSize);
eventLogs.Items.ToList().ForEach(x =>
{
x.Status = (x.ServiceFinishDate == null) ? Constants.ServiceStatus.Ongoing : Constants.ServiceStatus.Done;
x.IsHazardousLabel = (string.IsNullOrEmpty(x.IsHazardous) || x.IsHazardous == "0") ? Constants.YesNo.No : Constants.YesNo.Yes;
int?approvalStatus = null;
if (x.ServiceStatus.HasValue && x.ServiceStatus.Value)
{
approvalStatus = 1;
}
if (x.ServiceStatus.HasValue && !x.ServiceStatus.Value)
{
approvalStatus = 0;
}
x.ApprovalStatus = Constants.ApprovalStatus.FirstOrDefault(y => y.Item1 == approvalStatus).Item2;
x.ServiceStartDayName = x.ServiceStartDate?.DateTime.ToString("dddd") ?? "";
x.ServiceFinishDayName = x.ServiceFinishDate?.DateTime.ToString("dddd") ?? "";
x.ServiceTotalHours = GetServiceTotalHours(x.ServiceStartDate, x.ServiceFinishDate);
});
var pagedResult = new PagedList <InternalReportDTO>()
{
Items = eventLogs.Items,
PageSize = eventLogs.PageSize,
Page = eventLogs.Page,
Total = eventLogs.Total
};
return(ResponseBuilder.Correct(pagedResult));
}
public async Task <ResponseDTO> RegisterExpenseAsync(ExpenseRegisterRequest request)
{
var command = _mapper.Map <ExpenseRegisterRequest, ExpenseRegisterCommand>(request);
var resp = await _bus.SendAsync(command);
return(ResponseBuilder.Correct(resp, command.ExpenseId, ""));
}
public async Task <ResponseDTO <PagedList <CostCenterDTO> > > SearchCostCenterByNameAsync(CostCenterSearchRequest search)
{
List <OrderExpression <CostCenterDTO> > orderExpressionList = new List <OrderExpression <CostCenterDTO> >();
orderExpressionList.Add(new OrderExpression <CostCenterDTO>(OrderType.Desc, p => p.CostCenterId));
Expression <Func <CostCenterDTO, bool> > queryFilter = c => c.RowStatus;
if (!string.IsNullOrEmpty(search.Name))
{
queryFilter = queryFilter.And(p => p.Name.Contains(search.Name));
}
if (!string.IsNullOrEmpty(search.Code))
{
queryFilter = queryFilter.And(p => p.Code.Contains(search.Code));
}
var costCenter = await _costCenterDataAccess.ListPagedAsync(queryFilter, search.Page, search.PageSize, orderExpressionList.ToArray());
var pagedResult = new PagedList <CostCenterDTO>()
{
Items = costCenter.Items,
PageSize = costCenter.PageSize,
Page = costCenter.Page,
Total = costCenter.Total
};
return(ResponseBuilder.Correct(pagedResult));
}
public async Task <ResponseDTO <List <EquipmentStatusDTO> > > SearchEquipmentStatusAll()
{
Expression <Func <EquipmentStatusDTO, bool> > queryFilter = c => true;
var list = (await _statusDataAcces.ListAsync(queryFilter)).ToList();
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <List <ParentLocationDTO> > > GetParentLocationsAsync()
{
var parentLocations = await _parentLocationDataAccess.ListAsync(null);
var result = parentLocations.ToList();
return(ResponseBuilder.Correct(result));
}
public async Task <ResponseDTO <List <AppVersionDTO> > > GetAppVersionsAsync()
{
var appVersions = await _appVersionDataAccess.ListAsync(null);
var result = appVersions.ToList();
return(ResponseBuilder.Correct(result));
}
public async Task <ResponseDTO <List <DispatchingPartyDTO> > > GetAllAsync()
{
Expression <Func <DispatchingPartyDTO, bool> > queryFilter = c => c.RowStatus;
var list = (await _DispatchingPartyDataAccess.ListAsync(queryFilter)).ToList();
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <List <ServiceDTO> > > GetServiceAll()
{
Expression <Func <ServiceDTO, bool> > queryFilter = c => true;
var list = (await _serviceDataAcces.ListAsync(queryFilter)).ToList();
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <List <ConceptDTO> > > GetConceptByTypeIdListAsync(List <string> idList)
{
Expression <Func <ConceptDTO, bool> > queryFilter = p => p.RowStatus;
var concept = await _conceptDataAccess.ListAsync(queryFilter);
return(ResponseBuilder.Correct(concept.Where(q => idList.Contains(q.TypeId.Value.ToString())).ToList()));
}
public async Task <ResponseDTO <List <LocationCoordinateDTO> > > ListCoordinatesAsync(LocationCoordinatesListRequest search)
{
var locationCoordinates = await _locationCoordinatesDataAccess.ListAsync(x => x.LocationCode == search.LocationCode);
var result = locationCoordinates.ToList();
return(ResponseBuilder.Correct(result));
}
public async Task <ResponseDTO <List <ModelDTO> > > GetModelsAsync()
{
var models = await _modelDataAccess.ListAsync(null);
var result = models.ToList();
return(ResponseBuilder.Correct(result));
}
public async Task <ResponseDTO <List <AmigoTenantParameterDTO> > > GetAmigoTenantParameters()
{
Expression <Func <AmigoTenantParameterDTO, bool> > queryFilter = c => true;
var list = (await _amigoTenantParameterDataAcces.ListAsync(queryFilter)).ToList();
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <List <HouseBasicDTO> > > SearchForTypeAhead(string search)
{
Expression <Func <HouseBasicDTO, bool> > queryFilter = c => c.Name.Contains(search);
var list = (await _houseBasicDataAccess.ListAsync(queryFilter)).ToList();
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <List <CityDTO> > > GetCitiesAsync()
{
var cities = await _cityDataAccess.ListAsync(null);
var result = cities.ToList();
return(ResponseBuilder.Correct(result));
}
public async Task <ResponseDTO <List <HouseTypeDTO> > > GetHouseTypesAsync()
{
var houseTypes = await _houseTypeDataAccess.ListAsync(null);
var result = houseTypes.ToList();
return(ResponseBuilder.Correct(result));
}
public async Task <ResponseDTO <List <LocationTypeDTO> > > GetLocationTypesAsync()
{
var locationTypes = await _locationTypeDataAccess.ListAsync(null);
var result = locationTypes.ToList();
return(ResponseBuilder.Correct(result));
}
public async Task <ResponseDTO <List <ServiceHouseDTO> > > GetServicesHouseAllAsync()
{
Expression <Func <ServiceHouseDTO, bool> > masterQueryFilter = c => c.RowStatus;
var list = (await _serviceHouseDataAccess.ListAsync(masterQueryFilter)).ToList();
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <List <HouseFeatureDTO> > > GetFeaturesByHouseAsync(int houseId)
{
Expression <Func <HouseFeatureDTO, bool> > queryFilter = c => c.RowStatus == true && c.HouseId == houseId;
var list = (await _houseFeatureHouseDataAccess.ListAsync(queryFilter)).ToList();
return(ResponseBuilder.Correct(list));
}
public async Task <ResponseDTO <List <HouseFeatureDetailContractDTO> > > SearchHouseFeatureDetailContractAsync(int?houseId)
{
Expression <Func <HouseFeatureDetailContractDTO, bool> > queryFilter = c => c.HouseId == houseId;
var contract = await _houseFeatureDetailContractDataAccess.ListAsync(queryFilter);
return(ResponseBuilder.Correct(contract.ToList()));
}
