Exemplo n.º 1
0
        private static IQueryable <entities.EntityMap> AddWhereClauses(SearchQueryEntityMap searchQuery, IQueryable <entities.EntityMap> query)
        {
            query = query.Where(x => x.IntegrationId == searchQuery.IntegrationId);

            if (searchQuery.LocalId > 0)
            {
                query = query.Where(x => x.EntityId == searchQuery.LocalId);
            }

            if (!string.IsNullOrWhiteSpace(searchQuery.EntityName))
            {
                query = query.Where(x => x.EntityName == searchQuery.EntityName);
            }

            if (!string.IsNullOrEmpty(searchQuery.ExternalEntity))
            {
                query = query.Where(x => x.ExternalEntity == searchQuery.ExternalEntity);
            }

            if (!string.IsNullOrEmpty(searchQuery.ExternalProperty))
            {
                query = query.Where(x => x.ExternalPropertyName == searchQuery.ExternalProperty);
            }

            return(query);
        }
        public async Task <ActionResult <IEnumerable <EntityMap> > > GetEntityMaps([FromQuery] SearchQueryEntityMap entityMaps)
        {
            var mapEntity = _mapper.Map <domain.SearchQueryEntityMap>(entityMaps);

            var entityMapsResult = await _entityMapService.Search(mapEntity);

            var entityMapsContracts = _mapper.Map <IEnumerable <Domain.Models.EntityMap>, IEnumerable <EntityMap> >(entityMapsResult.ToList());

            return(Ok(entityMapsContracts));
        }
        public async Task <IEnumerable <EntityMap> > Search(SearchQueryEntityMap searchQuery)
        {
            if (searchQuery.IntegrationId <= 0)
            {
                var integrationId = await SearchForIntegrationId(searchQuery);

                searchQuery.IntegrationId = integrationId ?? 0;
            }

            return(await _repository.Search(searchQuery));
        }
Exemplo n.º 4
0
        public async Task <IList <EntityMap> > Search(SearchQueryEntityMap searchQuery)
        {
            if (searchQuery.IntegrationId <= 0)
            {
                return(new List <EntityMap>());
            }

            using (var context = await _contextFactory.CreateDbContext())
            {
                var query = context.EntityMaps.AsQueryable();
                query = AddWhereClauses(searchQuery, query);

                var result = _mapper.Map <IList <EntityMap> >(query);
                return(result);
            }
        }
        private async Task <int?> SearchForIntegrationId(SearchQueryEntityMap searchQuery)
        {
            int?integrationId = null;

            if (searchQuery.UnitId > 0 && searchQuery.ExternalSystemId > 0 && searchQuery.IntegrationCategory > 0)
            {
                var integrationQuery = new SearchQueryIntegration(searchQuery.UnitId, searchQuery.IntegrationCategory, searchQuery.ExternalSystemId);
                var unitIds          = await _unitQueries.GetHierarchyUp(searchQuery.UnitId);

                integrationQuery.UnitIds = unitIds.Select(u => u.Id).ToList();
                var integrations = await _integrationService.Search(integrationQuery);

                integrationId = integrations?.FirstOrDefault()?.Id;
            }

            return(integrationId);
        }
 public async Task <IEnumerable <EntityMap> > SearchEntityMaps(SearchQueryEntityMap searchQuery)
 {
     return(await Request <IEnumerable <EntityMap> >($"{_customerIdService.GetCustomerId()}/entitymaps?{WebUtility.GetQueryString(searchQuery)}"));
 }