< Summary

Information
Class: TreeGrouping.Web.Controllers.CategoryController
Assembly: OzonOrdersWeb
File(s): /home/runner/work/Studio2Prod/Studio2Prod/OzonOrdersWeb/Areas/CategoryTree/Controllers/CategoryController.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 178
Coverable lines: 178
Total lines: 333
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 26
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
Index()100%210%
GetCategoriesWithCache()0%620%
GetVolnaCategories()100%210%
GetVolnaCategoriesById()0%620%
UpdateVolnaCategories()100%210%
GetOzonCategories()100%210%
GetOzonCategoriesById()0%620%
UpdateOzonCategories()100%210%
GetCtCategories()0%620%
UpdateCtCategories()100%210%
GetCtCategoriesById()100%210%
GetCatTreeCategories()100%210%
GetCatTreeCategoriesById()100%210%
UpdateCatTreeCategories()100%210%
GetICGroupsCategories()100%210%
GetICGroupsCategoriesById()100%210%
UpdateICGroupsCategories()100%210%
LinkCategories()0%210140%
Unlink()100%210%
CreateUnifiedCategory()100%210%
CreateCategoryTranslation()0%620%
TryGetIntValue(...)0%2040%

File(s)

/home/runner/work/Studio2Prod/Studio2Prod/OzonOrdersWeb/Areas/CategoryTree/Controllers/CategoryController.cs

#LineLine coverage
 1using ConsoleApp1;
 2using Microsoft.AspNetCore.Mvc;
 3using Microsoft.Extensions.Caching.Memory;
 4using TreeGrouping.Application.CategoryService;
 5using TreeGrouping.Application.DbService;
 6using TreeGrouping.Application.DbService.Models;
 7using TreeGrouping.Web.Models;
 8
 9namespace TreeGrouping.Web.Controllers;
 10
 11[Area("CategoryTree")]
 12public class CategoryController : Controller
 13{
 14    private readonly IDatabaseService _dbService;
 15    private readonly CategoryCacheService _cacheService;
 16    private readonly CategoryFilterService _filterService;
 17    private readonly CategoryTreeService _treeService;
 18
 019    public CategoryController(
 020        IDatabaseService dbService,
 021        CategoryCacheService cacheService,
 022        CategoryFilterService filterService,
 023        CategoryTreeService treeService)
 24    {
 025        _dbService = dbService;
 026        _cacheService = cacheService;
 027        _filterService = filterService;
 028        _treeService = treeService;
 029    }
 30
 31    public async Task<IActionResult> Index()
 32    {
 033        await Task.CompletedTask;
 034        return View();
 035    }
 36
 37    private async Task<List<CategoryModel>> GetCategoriesWithCache(string cacheKey, StoredProcedureType storedProcedureT
 38    {
 039        var categories = await _cacheService.GetCategoriesFromCache(cacheKey, storedProcedureType);
 040        if (!string.IsNullOrEmpty(name))
 41        {
 042            categories = _filterService.FilterCategoriesByName(categories, name);
 43        }
 044        return _filterService.OrderCategoriesByName(categories);
 045    }
 46
 47    [HttpGet]
 48    public async Task<IActionResult> GetVolnaCategories(string? name = null)
 49    {
 050        var categories = await GetCategoriesWithCache("volna_categories", StoredProcedureType.GetVolnaCategories, name);
 051        var tree = _treeService.BuildTree(categories);
 052        var model = Tuple.Create(tree, "Volna");
 53
 054        return PartialView("_CategoryTree", model);
 055    }
 56
 57    [HttpGet]
 58    public async Task<IActionResult> GetVolnaCategoriesById(int id)
 59    {
 060        var categories = await _dbService.ExecuteStoredProcedureAsync(StoredProcedureType.SearchVolnaCategoryById, id);
 061        foreach (var category in categories)
 62        {
 063            category.IsFiltred = true;
 64        }
 065        var orderedCategories = _filterService.OrderCategoriesByName(categories.ToList());
 066        var tree = _treeService.BuildTree(orderedCategories);
 067        var model = Tuple.Create(tree, "Volna");
 68
 069        return PartialView("_CategoryTree", model);
 070    }
 71
 72    [HttpGet]
 73    public async Task<IActionResult> UpdateVolnaCategories()
 74    {
 075        var categories = await _cacheService.UpdateCache("volna_categories", StoredProcedureType.GetVolnaCategories);
 076        var orderedCategories = _filterService.OrderCategoriesByName(categories);
 077        var tree = _treeService.BuildTree(orderedCategories);
 078        var model = Tuple.Create(tree, "Volna");
 79
 080        return PartialView("_CategoryTree", model);
 081    }
 82
 83    [HttpGet]
 84    public async Task<IActionResult> GetOzonCategories(string? name = null)
 85    {
 086        var categories = await GetCategoriesWithCache("ozon_categories", StoredProcedureType.GetOzonCategories, name);
 087        var tree = _treeService.BuildTree(categories);
 088        var model = Tuple.Create(tree, "Ozon");
 89
 090        return PartialView("_CategoryTree", model);
 091    }
 92
 93    [HttpGet]
 94    public async Task<IActionResult> GetOzonCategoriesById(int id)
 95    {
 096        var categories = await _dbService.ExecuteStoredProcedureAsync(StoredProcedureType.SearchOzonCategoryById, id);
 097        foreach (var category in categories)
 98        {
 099            category.IsFiltred = true;
 100        }
 0101        var orderedCategories = _filterService.OrderCategoriesByName(categories.ToList());
 0102        var tree = _treeService.BuildTree(orderedCategories);
 0103        var model = Tuple.Create(tree, "Ozon");
 104
 0105        return PartialView("_CategoryTree", model);
 0106    }
 107
 108    [HttpGet]
 109    public async Task<IActionResult> UpdateOzonCategories()
 110    {
 0111        var categories = await _cacheService.UpdateCache("ozon_categories", StoredProcedureType.GetOzonCategories);
 0112        var orderedCategories = _filterService.OrderCategoriesByName(categories);
 0113        var tree = _treeService.BuildTree(orderedCategories);
 0114        var model = Tuple.Create(tree, "Ozon");
 115
 0116        return PartialView("_CategoryTree", model);
 0117    }
 118
 119    [HttpGet]
 120    public async Task<IActionResult> GetCtCategories(string? name = null)
 121    {
 0122        var categories = await _cacheService.GetCategoriesFromCache("ct_categories", StoredProcedureType.GetCtCategories
 0123        var links = await _dbService.GetAllCategoryLinksAsync();
 0124        var newCategories = await _treeService.CategoryLinkToModel(_dbService, categories, links.ToList());
 0125        newCategories = string.IsNullOrEmpty(name)
 0126            ? newCategories
 0127            : _filterService.FilterCategoriesByName(newCategories, name);
 0128        var orderedCategories = _filterService.OrderCategoriesByName(newCategories);
 0129        var tree = _treeService.BuildTree(orderedCategories);
 0130        var model = Tuple.Create(tree, "CT");
 131
 0132        return PartialView("_CategoryTree", model);
 0133    }
 134
 135    [HttpGet]
 136    public async Task<IActionResult> UpdateCtCategories()
 137    {
 0138        var categories = await _cacheService.UpdateCache("ct_categories", StoredProcedureType.GetCtCategories);
 0139        var links = await _dbService.GetAllCategoryLinksAsync();
 0140        var newCategories = await _treeService.CategoryLinkToModel(_dbService, categories, links.ToList());
 0141        var orderedCategories = _filterService.OrderCategoriesByName(newCategories);
 0142        var tree = _treeService.BuildTree(orderedCategories);
 0143        var model = Tuple.Create(tree, "CT");
 144
 0145        return PartialView("_CategoryTree", model);
 0146    }
 147
 148    [HttpGet]
 149    public async Task<IActionResult> GetCtCategoriesById(int id)
 150    {
 0151        var categories = await _dbService.ExecuteStoredProcedureAsync(StoredProcedureType.SearchCtCategoryById, id);
 0152        var orderedCategories = _filterService.OrderCategoriesByName(categories.ToList());
 0153        var tree = _treeService.BuildTree(orderedCategories);
 0154        var model = Tuple.Create(tree, "CT");
 155
 0156        return PartialView("_CategoryTree", model);
 0157    }
 158
 159    [HttpGet]
 160    public async Task<IActionResult> GetCatTreeCategories(string? name = null)
 161    {
 0162        var categories = await GetCategoriesWithCache("cat_tree_categories", StoredProcedureType.GetCatTreeCategories, n
 0163        var tree = _treeService.BuildTree(categories);
 0164        var model = Tuple.Create(tree, "CatTree");
 0165        return PartialView("_CategoryTree", model);
 0166    }
 167
 168    [HttpGet]
 169    public async Task<IActionResult> GetCatTreeCategoriesById(int id)
 170    {
 0171        var categories = await _dbService.ExecuteStoredProcedureAsync(StoredProcedureType.SearchCatTreeCategoryById, id)
 0172        var orderedCategories = _filterService.OrderCategoriesByName(categories.ToList());
 0173        var tree = _treeService.BuildTree(orderedCategories);
 0174        var model = Tuple.Create(tree, "CatTree");
 175
 0176        return PartialView("_CategoryTree", model);
 0177    }
 178
 179    [HttpGet]
 180    public async Task<IActionResult> UpdateCatTreeCategories()
 181    {
 0182        var categories = await _cacheService.UpdateCache("cat_tree_categories", StoredProcedureType.GetCatTreeCategories
 0183        var orderedCategories = _filterService.OrderCategoriesByName(categories);
 0184        var tree = _treeService.BuildTree(orderedCategories);
 0185        var model = Tuple.Create(tree, "CatTree");
 186
 0187        return PartialView("_CategoryTree", model);
 0188    }
 189
 190    [HttpGet]
 191    public async Task<IActionResult> GetICGroupsCategories(string? name = null)
 192    {
 0193        var categories = await GetCategoriesWithCache("ic_groups", StoredProcedureType.GetICGroups, name);
 0194        var tree = _treeService.BuildTree(categories);
 0195        var model = Tuple.Create(tree, "IC");
 196
 0197        return PartialView("_CategoryTree", model);
 0198    }
 199
 200    [HttpGet]
 201    public async Task<IActionResult> GetICGroupsCategoriesById(int id)
 202    {
 0203        var categories = await _dbService.ExecuteStoredProcedureAsync(StoredProcedureType.SearchICGroupById, id);
 0204        var orderedCategories = _filterService.OrderCategoriesByName(categories.ToList());
 0205        var tree = _treeService.BuildTree(orderedCategories);
 0206        var model = Tuple.Create(tree, "IC");
 207
 0208        return PartialView("_CategoryTree", model);
 0209    }
 210
 211    [HttpGet]
 212    public async Task<IActionResult> UpdateICGroupsCategories()
 213    {
 0214        var categories = await _cacheService.UpdateCache("ic_groups", StoredProcedureType.GetICGroups);
 0215        var orderedCategories = _filterService.OrderCategoriesByName(categories);
 0216        var tree = _treeService.BuildTree(orderedCategories);
 0217        var model = Tuple.Create(tree, "IC");
 218
 0219        return PartialView("_CategoryTree", model);
 0220    }
 221
 222    // Остальные методы остаются без изменений
 223    [HttpPost]
 224    public async Task<IActionResult> LinkCategories([FromBody] Dictionary<string, int> selectedCategories)
 225    {
 226        try
 227        {
 0228            if (selectedCategories == null || selectedCategories.Count <= 1 || !selectedCategories.ContainsKey("CT"))
 229            {
 0230                return BadRequest(new
 0231                {
 0232                    success = false,
 0233                    message = "Ошибка: Должен быть выбран элемент с ключом 'CT' и должно быть более одной категории."
 0234                });
 235            }
 236
 0237            var ctValue = selectedCategories["CT"];
 238
 0239            var categoryPairs = new List<Dictionary<string, int>>();
 240
 0241            foreach (var key in selectedCategories.Keys.Where(k => k != "CT"))
 242            {
 0243                var pair = new Dictionary<string, int>
 0244                {
 0245                    { "CT", ctValue },
 0246                    { key, selectedCategories[key] }
 0247                };
 248
 0249                categoryPairs.Add(pair);
 250            }
 0251            foreach (var pair in categoryPairs)
 252            {
 0253                int ct = pair.ContainsKey("CT") ? pair["CT"] : 0;
 254
 0255                var secondKey = pair.Keys.FirstOrDefault(k => k != "CT");
 0256                var secondValue = secondKey != null ? pair[secondKey] : 0;
 0257                await _dbService.ExecuteStoredProcedureAsync(
 0258                    StoredProcedureType.AddCategoryLink,
 0259                    (ct, secondValue, secondKey)
 0260                );
 261            }
 0262            return Ok(new { success = true, message = "Категории успешно связаны!", data = categoryPairs });
 263        }
 0264        catch (Exception ex)
 265        {
 0266            return BadRequest(new
 0267                { success = false, message = "Ошибка при связывании категорий!", error = ex.Message });
 268        }
 0269    }
 270
 271    [HttpPost]
 272    [ValidateAntiForgeryToken]
 273    public async Task<IActionResult> Unlink(int id)
 274    {
 0275        await _dbService.ExecuteStoredProcedureAsync(StoredProcedureType.DeleteCategoryLink, id);
 0276        return Ok();
 0277    }
 278
 279    [HttpPost]
 280    public async Task<IActionResult> CreateUnifiedCategory([FromBody] Dictionary<string, string> categoryNames)
 281    {
 0282        int? ozonId = TryGetIntValue(categoryNames, "Ozon");
 0283        int? volnaId = TryGetIntValue(categoryNames, "Volna");
 0284        int? icId = TryGetIntValue(categoryNames, "IC");
 0285        await _dbService.ExecuteStoredProcedureAsync(StoredProcedureType.InsertUnifiedCategoryIfNotExists, (ozonId, voln
 286
 0287        return Ok(new { ozonId, volnaId, icId });
 0288    }
 289
 290    [HttpPost]
 291    public async Task<IActionResult> CreateCategoryTranslation([FromBody] TranslationRequest request)
 292    {
 293        try
 294        {
 0295            var results = new List<object>();
 296
 0297            foreach (var translation in request.CategoryNames)
 298            {
 0299                var result = await _dbService.ExecuteStoredProcedureAsync(
 0300                    StoredProcedureType.AddCategoryTranslations,
 0301                    (translation.Value, // category_id
 0302                        translation.Key,             // link_type_name
 0303                        request.Translation));
 304
 0305                results.Add(new {
 0306                    CategoryId = translation.Value,
 0307                    LinkType = translation.Key,
 0308                    Result = result
 0309                });
 0310            }
 311
 0312            return Ok(new {
 0313                Success = true,
 0314                Results = results
 0315            });
 316        }
 0317        catch (Exception ex)
 318        {
 0319            return StatusCode(500, new {
 0320                Success = false,
 0321                Error = ex.Message
 0322            });
 323        }
 0324    }
 325
 326    private int? TryGetIntValue(Dictionary<string, string> dict, string key)
 327    {
 0328        if (dict.TryGetValue(key, out var value) && int.TryParse(value, out var result))
 0329            return result;
 330
 0331        return null;
 332    }
 333}
Generated by: ReportGenerator 5.5.11.0
10/25/2026 - 07:43:45
GitHub | reportgenerator.io

Methods/Properties

.ctor(TreeGrouping.Application.DbService.IDatabaseService,TreeGrouping.Application.CategoryService.CategoryCacheService,TreeGrouping.Application.CategoryService.CategoryFilterService,TreeGrouping.Application.CategoryService.CategoryTreeService)
Index()
GetCategoriesWithCache()
GetVolnaCategories()
GetVolnaCategoriesById()
UpdateVolnaCategories()
GetOzonCategories()
GetOzonCategoriesById()
UpdateOzonCategories()
GetCtCategories()
UpdateCtCategories()
GetCtCategoriesById()
GetCatTreeCategories()
GetCatTreeCategoriesById()
UpdateCatTreeCategories()
GetICGroupsCategories()
GetICGroupsCategoriesById()
UpdateICGroupsCategories()
LinkCategories()
Unlink()
CreateUnifiedCategory()
CreateCategoryTranslation()
TryGetIntValue(System.Collections.Generic.Dictionary`2<System.String,System.String>,System.String)