コード例 #1
0
        public async Task <GetAllResourcesResult[]> GetResources(UseFiltersRequest filter)
        {
            var        resources = (await Redis.HashKeysAsync(ResourcesName)).Select(k => k.ToString()).ToList();
            RedisValue response;

            if (filter.Id.HasValue)
            {
                response = await Redis.HashGetAsync(ResourcesName, filter.Id);

                if (response.HasValue)
                {
                    GetAllResourcesResult result = Unpack <GetAllResourcesResult>(response.ToString());
                    result.Id = filter.Id.ToString();
                    return(new[] { result });
                }

                return(new GetAllResourcesResult[0]);
            }

            if (!string.IsNullOrEmpty(filter.Name))
            {
                var filterByName = (await Redis.HashGetAllAsync(Names))
                                   .ToDictionary(f => f.Name.ToString(), f => f.Value.ToString())
                                   .Where(f => f.Value.ToString().ToLowerInvariant().Contains(filter.Name.ToLowerInvariant()))
                                   .ToDictionary(x => x.Key, x => x.Value);

                resources = resources.Where(r => filterByName.Values.Contains(r)).ToList();
            }

            if (filter.CategoryId.HasValue)
            {
                response = await Redis.HashGetAsync(CategoriesName, filter.CategoryId.Value.ToString());

                if (response.HasValue)
                {
                    var resourcesInCategory = Unpack <Resources>(response.ToString()).ResourcesIds;
                    resources = resources.Where(r => resourcesInCategory.Contains(r)).ToList();
                }
                else
                {
                    resources.Clear();
                }
            }

            if (filter.ResourceGroupId.HasValue)
            {
                response = await Redis.HashGetAsync(ResourceGroupsName, filter.ResourceGroupId.Value.ToString());

                if (response.HasValue)
                {
                    var resourcesInGroup = Unpack <Resources>(response.ToString()).ResourcesIds;
                    resources = resources.Where(r => resourcesInGroup.Contains(r)).ToList();
                }
                else
                {
                    resources.Clear();
                }
            }

            if (filter.Tags != null && filter.Tags.Length != 0)
            {
                var allKeys = await Redis.HashKeysAsync(TagsName);

                var keys = new List <string>();
                foreach (string tag in filter.Tags)
                {
                    keys.AddRange(allKeys.Where(k => k.ToString().ToLowerInvariant().Contains(tag.ToLowerInvariant())).Select(k => k.ToString()));
                }

                var filterByTags = new Dictionary <string, string[]>();
                foreach (var key in keys)
                {
                    response = await Redis.HashGetAsync(TagsName, key);

                    filterByTags.Add(key, Unpack <Resources>(response.ToString()).ResourcesIds.ToArray());
                }

                var resourcesByTags = filterByTags.Select(f => f.Value).ToArray();
                for (int i = 0; i < resourcesByTags.GetLength(0) - 1; i++)
                {
                    resourcesByTags[i + 1] = resourcesByTags[i].Union(resourcesByTags[i + 1]).ToArray();
                }

                if (!resourcesByTags.Any())
                {
                    resources.Clear();
                }

                resources = resources.Where(r => resourcesByTags.Last().Contains(r.ToString())).ToList();
            }

            var allResourcesResults = new List <GetAllResourcesResult>();

            for (int i = 0; i < resources.Count; i++)
            {
                response = await Redis.HashGetAsync(ResourcesName, resources[i]);

                var res = Unpack <GetAllResourcesResult>(response.ToString());
                res.Id = resources[i];
                allResourcesResults.Add(res);
            }

            return(allResourcesResults.ToArray());
        }
コード例 #2
0
ファイル: ResourceService.cs プロジェクト: Vsailor/Registry
 public async Task <GetAllResourcesResult[]> GetResources(UseFiltersRequest filter)
 {
     return(await _resourceRepository.GetResourcesAsync(filter));
 }
コード例 #3
0
ファイル: Resources.xaml.cs プロジェクト: Vsailor/Registry
        private async void UseFiltersButton_Click(object sender, RoutedEventArgs e)
        {
            var request = new UseFiltersRequest();

            request.Name = NameTextBox.Text;

            if (!string.IsNullOrEmpty(UniqueIdentifier.Text))
            {
                int id;
                if (int.TryParse(UniqueIdentifier.Text, out id))
                {
                    request.Id = id;
                }
                else
                {
                    MessageBox.Show(
                        "Унікальний ідентифікатор має не вірний формат",
                        "Помилка",
                        MessageBoxButton.OK,
                        MessageBoxImage.Error);
                    return;
                }
            }

            if (CategoriesTree.SelectedItem != null)
            {
                request.CategoryId = Guid.Parse(((TreeViewItem)CategoriesTree.SelectedItem).Uid);
            }

            if (GroupsListBox.SelectedItems.Count != 0)
            {
                request.ResourceGroupId = _allGroups.First(x => x.Name == GroupsListBox.SelectedItems[0].ToString()).Id;
            }

            if (string.IsNullOrEmpty(TagsTextBox.Text))
            {
                request.Tags = new string[0];
            }
            else
            {
                var tags = TagsTextBox.Text.Split(',');
                for (int i = 0; i < tags.Length; i++)
                {
                    int count = 0;
                    for (int j = 0; j < tags[i].Length; j++)
                    {
                        if (tags[i][j] != ' ')
                        {
                            break;
                        }

                        count++;
                    }

                    tags[i] = tags[i].Remove(0, count);
                }

                request.Tags = tags;
            }

            ResourcesListBox.Items.Clear();

            var filteredResources = await _resourceService.GetResources(request);

            foreach (var res in filteredResources)
            {
                ResourcesListBox.Items.Add(new ResourceItem(res, _allResources));
            }
        }