< Summary

Information
Class: MRA.Services.AppService
Assembly: MRA.Services
File(s): D:\a\MiguelRomerART\MiguelRomerART\MRA.Services\AppService\AppService.cs
Line coverage
81%
Covered lines: 143
Uncovered lines: 32
Coverable lines: 175
Total lines: 400
Line coverage: 81.7%
Branch coverage
100%
Covered branches: 61
Total branches: 61
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
GetAllDrawings()100%11100%
<GetAllDrawings()100%11100%
GetAllInspirations()100%210%
<GetAllInspirations()100%210%
GetAllCollectionsAsync()100%210%
<GetAllCollectionsAsync()100%210%
FetchCollectionsAndLinkDrawings()100%210%
FetchCollectionAndLinkDrawings()100%210%
LinkDrawingsToCollections(...)100%22100%
LinkDrawingToCollection(...)100%11100%
FindCollectionByIdAsync()100%210%
<FindCollectionByIdAsync()100%210%
FilterDrawingsAsync()100%11100%
<FilterDrawingsAsync()100%11100%
FilterGivenList()100%88100%
SortDrawingsByFilter(...)100%1515100%
FilterDrawings(...)100%11100%
FilterDrawings_Collection(...)100%44100%
FilterDrawings_Spotify(...)100%44100%
FilterDrawings_Paper(...)100%22100%
FilterDrawings_Software(...)100%22100%
FilterDrawings_ProductType(...)100%22100%
FilterDrawings_Type(...)100%22100%
FilterDrawings_ModelName(...)100%44100%
FilterDrawings_CharacterName(...)100%44100%
FilterDrawings_ProductName(...)100%44100%
FilterDrawings_TextQuery(...)100%22100%
FilterDrawings_OnlyFavorites(...)100%22100%
FilterDrawings_OnlyVisible(...)100%22100%
SetBlobUrl(...)100%22100%
CalculatePopularityOfListDrawings(...)100%22100%
FindDrawingByIdAsync()100%210%
<FindDrawingByIdAsync()100%210%

File(s)

D:\a\MiguelRomerART\MiguelRomerART\MRA.Services\AppService\AppService.cs

#LineLine coverage
 1using Microsoft.Extensions.Logging;
 2using MRA.Infrastructure.Settings;
 3using MRA.DTO.ViewModels.Art;
 4using MRA.Infrastructure.Enums;
 5using MRA.Services.Models.Inspirations;
 6using MRA.Services.Models.Collections;
 7using MRA.DTO.Models;
 8using MRA.Services.Models.Drawings;
 9using MRA.Services.RemoteConfig;
 10using MRA.Services.Cache;
 11using MRA.Services.Storage;
 12using MRA.DTO.Enums.Drawing;
 13using MRA.Infrastructure.Cache;
 14using MRA.DTO.Enums.DrawingFilter;
 15
 16namespace MRA.Services
 17{
 18    public class AppService : CacheServiceBase, IAppService
 19    {
 20        private readonly IStorageService _storageService;
 21        private readonly IDrawingService _drawingService;
 22        private readonly IInspirationService _inspirationService;
 23        private readonly ICollectionService _collectionService;
 24        private readonly ILogger<AppService> _logger;
 25        private readonly IRemoteConfigService _remoteConfigService;
 26
 27        public const string CACHE_ALL_DRAWINGS = "all_drawings";
 28        public const string CACHE_ALL_INSPIRATIONS = "all_inspirations";
 29        public const string CACHE_ALL_COLLECTIONS = "all_collections";
 30
 31        public AppService(
 32            ICacheProvider cache,
 33            IStorageService storageService,
 34            IRemoteConfigService remoteConfigService,
 35            IDrawingService drawingService,
 36            IInspirationService inspirationService,
 37            ICollectionService collectionService,
 38            ILogger<AppService> logger,
 3539            AppSettings appConfig) : base(appConfig, cache)
 40        {
 3541            _logger = logger;
 3542            _storageService = storageService;
 3543            _remoteConfigService = remoteConfigService;
 3544            _drawingService = drawingService;
 3545            _inspirationService = inspirationService;
 3546            _collectionService = collectionService;
 3547        }
 48
 49        public async Task<IEnumerable<DrawingModel>> GetAllDrawings(bool onlyIfVisible, bool cache = true)
 50        {
 351            return await GetOrSetFromCacheAsync(CACHE_ALL_DRAWINGS + onlyIfVisible, async () =>
 352                {
 353                    return await _drawingService.GetAllDrawingsAsync(onlyIfVisible);
 354                },
 355                useCache: cache);
 356        }
 57
 58        public async Task<IEnumerable<InspirationModel>> GetAllInspirations()
 59        {
 060            return await GetOrSetFromCacheAsync(CACHE_ALL_INSPIRATIONS, async () =>
 061                {
 062                    return await _inspirationService.GetAllInspirationsAsync();
 063                },
 064                useCache: true);
 065        }
 66
 67        public async Task<IEnumerable<CollectionModel>> GetAllCollectionsAsync(bool onlyIfVisible, bool cache = true)
 68        {
 069            return await GetOrSetFromCacheAsync(CACHE_ALL_COLLECTIONS + onlyIfVisible, async () =>
 070                {
 071                    return await FetchCollectionsAndLinkDrawings(onlyIfVisible, cache);
 072                },
 073                useCache: cache);
 074        }
 75
 76        private async Task<IEnumerable<CollectionModel>> FetchCollectionsAndLinkDrawings(bool onlyIfVisible, bool cache)
 77        {
 078            var collections = await _collectionService.GetAllCollectionsAsync(onlyIfVisible);
 079            var drawgins = await GetAllDrawings(onlyIfVisible, cache);
 080            return LinkDrawingsToCollections(collections, drawgins);
 081        }
 82
 83        private async Task<CollectionModel> FetchCollectionAndLinkDrawings(string id, bool onlyIfVisible, bool cache)
 84        {
 085            var collection = await _collectionService.FindCollectionAsync(id);
 086            var drawgins = await GetAllDrawings(onlyIfVisible, cache);
 087            return LinkDrawingToCollection(collection, drawgins);
 088        }
 89
 90        private static IEnumerable<CollectionModel> LinkDrawingsToCollections(IEnumerable<CollectionModel> collections, 
 91        {
 3192            var newCollections = new List<CollectionModel>();
 93
 6494            foreach (var collection in collections)
 195                newCollections.Add(LinkDrawingToCollection(collection, drawings));
 96
 3297            newCollections = newCollections.Where(c => c.Drawings.Any()).ToList();
 3198            return newCollections;
 99        }
 100
 101        private static CollectionModel LinkDrawingToCollection(CollectionModel collection, IEnumerable<DrawingModel> dra
 102        {
 4103            collection.Drawings = drawgins.Where(d => (collection.DrawingIds.Contains(d.Id)));
 1104            return collection;
 105        }
 106
 107        public async Task<CollectionModel> FindCollectionByIdAsync(string collectionId, bool onlyIfVisible, bool cache =
 108        {
 0109            return await GetOrSetFromCacheAsync($"collection_{collectionId}", async () =>
 0110            {
 0111                return await FetchCollectionAndLinkDrawings(collectionId, onlyIfVisible: onlyIfVisible, cache: cache);
 0112            },
 0113            useCache: cache);
 0114        }
 115
 116
 117        public async Task<FilterResults> FilterDrawingsAsync(DrawingFilter filter)
 118        {
 31119            return await GetOrSetFromCacheAsync(filter.CacheKey, async () =>
 31120                {
 31121                    return await FilterGivenList(filter);
 31122                },
 31123                useCache: true);
 31124        }
 125
 126        private async Task<FilterResults> FilterGivenList(DrawingFilter filter)
 127        {
 31128            var drawings = await _drawingService.GetAllDrawingsAsync(filter.OnlyVisible);
 31129            var collections = await _collectionService.GetAllCollectionsAsync(filter.OnlyVisible);
 31130            collections = LinkDrawingsToCollections(collections, drawings);
 131
 31132            drawings = FilterDrawings(filter, drawings, collections);
 133
 31134            if (filter.OnlyFilterCollection())
 135            {
 2136                var selectedCollection = collections.FirstOrDefault(x => x.Id == filter.Collection);
 1137                if (selectedCollection != null)
 138                {
 1139                    var list = new List<DrawingModel>();
 5140                    foreach (var id in selectedCollection.Drawings.Select(x => x.Id))
 141                    {
 2142                        var d = drawings.FirstOrDefault(x => x.Id == id);
 1143                        if (d != null)
 144                        {
 1145                            list.Add(d);
 146                        }
 147                    }
 1148                    drawings = list;
 149                }
 150            }
 151            else
 152            {
 30153                drawings = SortDrawingsByFilter(filter, drawings);
 154            }
 31155            SetBlobUrl(ref drawings);
 156
 31157            return new FilterResults(drawings, collections, filter);
 31158        }
 159
 160        private IEnumerable<DrawingModel> SortDrawingsByFilter(DrawingFilter filter, IEnumerable<DrawingModel> drawings)
 161        {
 30162            return filter.Sortby switch
 30163            {
 1164                DrawingFilterSortBy.Latest => drawings.SortByLatest(),
 1165                DrawingFilterSortBy.Oldest => drawings.SortByOldest(),
 1166                DrawingFilterSortBy.NameAZ => drawings.SortByNameAZ(),
 1167                DrawingFilterSortBy.NameZA => drawings.SortByNameZA(),
 1168                DrawingFilterSortBy.LikeAscending => drawings.SortByLikeAscending(),
 1169                DrawingFilterSortBy.LikeDescending => drawings.SortByLikeDescending(),
 1170                DrawingFilterSortBy.ViewsAscending => drawings.SortByViewsAscending(),
 1171                DrawingFilterSortBy.ViewsDescending => drawings.SortByViewsDescending(),
 1172                DrawingFilterSortBy.AuthorScoreAscending => drawings.SortByAuthorScoreAscending(),
 1173                DrawingFilterSortBy.AuthorScoreDescending => drawings.SortByAuthorScoreDescending(),
 1174                DrawingFilterSortBy.UserScoreAscending => drawings.SortByUserScoreAscending(),
 1175                DrawingFilterSortBy.UserScoreDescending => drawings.SortByUserScoreDescending(),
 1176                DrawingFilterSortBy.Fastest => drawings.SortByFastest(),
 1177                DrawingFilterSortBy.Slowest => drawings.SortBySlowest(),
 16178                _ => CalculatePopularityOfListDrawings(drawings).SortByPopularity()
 30179            };
 180        }
 181
 182        private IEnumerable<DrawingModel> FilterDrawings(DrawingFilter filter, IEnumerable<DrawingModel> drawings, IEnum
 183        {
 31184            drawings = FilterDrawings_OnlyVisible(filter, drawings);
 31185            drawings = FilterDrawings_OnlyFavorites(filter, drawings);
 31186            drawings = FilterDrawings_TextQuery(filter, drawings);
 31187            drawings = FilterDrawings_ProductName(filter, drawings);
 31188            drawings = FilterDrawings_CharacterName(filter, drawings);
 31189            drawings = FilterDrawings_ModelName(filter, drawings);
 31190            drawings = FilterDrawings_Type(filter, drawings);
 31191            drawings = FilterDrawings_ProductType(filter, drawings);
 31192            drawings = FilterDrawings_Software(filter, drawings);
 31193            drawings = FilterDrawings_Paper(filter, drawings);
 31194            drawings = FilterDrawings_Spotify(filter, drawings);
 31195            drawings = FilterDrawings_Collection(filter, drawings, collections);
 31196            return drawings;
 197        }
 198
 199        private static IEnumerable<DrawingModel> FilterDrawings_Collection(DrawingFilter filter, IEnumerable<DrawingMode
 200        {
 31201            if (!String.IsNullOrEmpty(filter.Collection))
 202            {
 2203                var collection = collections.FirstOrDefault(x => x.Id.Equals(filter.Collection));
 204
 1205                if (collection != null)
 206                {
 2207                    var idsCollection = collection.Drawings.Select(x => x.Id).ToList();
 2208                    drawings = drawings.Where(d => idsCollection.Contains(d.Id)).ToList();
 209                }
 210            }
 211
 31212            return drawings;
 213        }
 214
 215        private static IEnumerable<DrawingModel> FilterDrawings_Spotify(DrawingFilter filter, IEnumerable<DrawingModel> 
 216        {
 31217            if (filter.Spotify != null)
 218            {
 2219                if (filter.Spotify ?? false)
 220                {
 2221                    drawings = drawings.Where(x => !string.IsNullOrEmpty(x.SpotifyUrl)).ToList();
 222                }
 223                else
 224                {
 2225                    drawings = drawings.Where(x => string.IsNullOrEmpty(x.SpotifyUrl)).ToList();
 226                }
 227            }
 228
 31229            return drawings;
 230        }
 231
 232        private static IEnumerable<DrawingModel> FilterDrawings_Paper(DrawingFilter filter, IEnumerable<DrawingModel> dr
 233        {
 31234            if (filter.Paper != EnumExtensions.GetDefaultValue<DrawingPaperSizes>())
 235            {
 2236                drawings = drawings.Where(x => x.Paper == (int) filter.Paper).ToList();
 237            }
 238
 31239            return drawings;
 240        }
 241
 242        private static IEnumerable<DrawingModel> FilterDrawings_Software(DrawingFilter filter, IEnumerable<DrawingModel>
 243        {
 31244            if (filter.Software != EnumExtensions.GetDefaultValue<DrawingSoftwares>())
 245            {
 2246                drawings = drawings.Where(x => x.Software == (int) filter.Software).ToList();
 247            }
 248
 31249            return drawings;
 250        }
 251
 252        private static IEnumerable<DrawingModel> FilterDrawings_ProductType(DrawingFilter filter, IEnumerable<DrawingMod
 253        {
 31254            if (filter.ProductType != EnumExtensions.GetDefaultValue<DrawingProductTypes>())
 255            {
 2256                drawings = drawings.Where(x => x.ProductType == (int) filter.ProductType).ToList();
 257            }
 258
 31259            return drawings;
 260        }
 261
 262        private static IEnumerable<DrawingModel> FilterDrawings_Type(DrawingFilter filter, IEnumerable<DrawingModel> dra
 263        {
 31264            if (filter.Type != EnumExtensions.GetDefaultValue<DrawingTypes>())
 265            {
 2266                drawings = drawings.Where(x => x.Type == (int) filter.Type).ToList();
 267            }
 268
 31269            return drawings;
 270        }
 271
 272        private static IEnumerable<DrawingModel> FilterDrawings_ModelName(DrawingFilter filter, IEnumerable<DrawingModel
 273        {
 31274            if (!String.IsNullOrEmpty(filter.ModelName))
 275            {
 2276                if (filter.ModelName.Equals(DrawingFilter.MODEL_NONE))
 277                {
 1278                    drawings = drawings.Where(x =>
 2279                        string.IsNullOrEmpty(x.ModelName)).ToList();
 280                }
 281                else
 282                {
 1283                    drawings = drawings.Where(x =>
 1284                        x.ModelName.Contains(filter.ModelName)).ToList();
 285
 286                }
 287            }
 288
 31289            return drawings;
 290        }
 291
 292        private static IEnumerable<DrawingModel> FilterDrawings_CharacterName(DrawingFilter filter, IEnumerable<DrawingM
 293        {
 31294            if (!String.IsNullOrEmpty(filter.CharacterName))
 295            {
 2296                if (filter.CharacterName.Equals(DrawingFilter.CHARACTER_NONE))
 297                {
 1298                    drawings = drawings.Where(x =>
 2299                        string.IsNullOrEmpty(x.Name)).ToList();
 300                }
 301                else
 302                {
 1303                    drawings = drawings.Where(x =>
 1304                        x.Name.Contains(filter.CharacterName)).ToList();
 305
 306                }
 307            }
 308
 31309            return drawings;
 310        }
 311
 312        private static IEnumerable<DrawingModel> FilterDrawings_ProductName(DrawingFilter filter, IEnumerable<DrawingMod
 313        {
 31314            if (!String.IsNullOrEmpty(filter.ProductName))
 315            {
 2316                if (filter.ProductName.Equals(DrawingFilter.PRODUCT_NONE))
 317                {
 1318                    drawings = drawings.Where(x =>
 2319                        string.IsNullOrEmpty(x.ProductName)).ToList();
 320                }
 321                else
 322                {
 1323                    drawings = drawings.Where(x =>
 2324                        x.ProductName.Contains(filter.ProductName)).ToList();
 325
 326                }
 327            }
 328
 31329            return drawings;
 330        }
 331
 332        private IEnumerable<DrawingModel> FilterDrawings_TextQuery(DrawingFilter filter, IEnumerable<DrawingModel> drawi
 333        {
 31334            if (!String.IsNullOrEmpty(filter.TextQuery))
 335            {
 2336                var tags = _drawingService.DeleteAndAdjustTags(filter.Tags).Select(x => x.ToLower());
 1337                drawings = drawings.Where(x =>
 5338                    x.Tags.Join(tags, t1 => t1.ToLower(), t2 => t2, (t1, t2) => t1.Contains(t2)).Any());
 339            }
 340
 31341            return drawings;
 342        }
 343
 344        private static IEnumerable<DrawingModel> FilterDrawings_OnlyFavorites(DrawingFilter filter, IEnumerable<DrawingM
 345        {
 31346            if (filter.Favorites)
 347            {
 2348                drawings = drawings.Where(x => x.Favorite).ToList();
 349            }
 350
 31351            return drawings;
 352        }
 353
 354        private static IEnumerable<DrawingModel> FilterDrawings_OnlyVisible(DrawingFilter filter, IEnumerable<DrawingMod
 355        {
 31356            if (filter.OnlyVisible)
 357            {
 2358                drawings = drawings.Where(x => x.Visible).ToList();
 359            }
 360
 31361            return drawings;
 362        }
 363
 364        private void SetBlobUrl(ref IEnumerable<DrawingModel> drawings)
 365        {
 192366            foreach (var d in drawings)
 367            {
 65368                d.UrlBase = _storageService.GetBlobURL();
 369            }
 31370        }
 371
 372        public IEnumerable<DrawingModel> CalculatePopularityOfListDrawings(IEnumerable<DrawingModel> drawings)
 373        {
 16374            double wDate = _remoteConfigService.GetPopularityDate();
 16375            int wMonths = _remoteConfigService.GetPopularityMonths();
 16376            double wCritic = _remoteConfigService.GetPopularityCritic();
 16377            double wPopular = _remoteConfigService.GetPopularityPopular();
 16378            double wFavorite = _remoteConfigService.GetPopularityFavorite();
 379
 16380            var newList = new List<DrawingModel>();
 64381            foreach (var d in drawings)
 382            {
 16383                d.CalculatePopularity(wDate, wMonths, wCritic, wPopular, wFavorite);
 16384                newList.Add(d);
 385            }
 386
 16387            return newList;
 388        }
 389
 390
 391        public async Task<DrawingModel> FindDrawingByIdAsync(string documentId, bool onlyIfVisible, bool updateViews = f
 392        {
 0393            return await GetOrSetFromCacheAsync($"drawing_{documentId}", async () =>
 0394            {
 0395                return await _drawingService.FindDrawingAsync(documentId, onlyIfVisible, updateViews);
 0396            },
 0397            useCache: cache);
 0398        }
 399    }
 400}
Generated by: ReportGenerator 5.4.8.0
7/13/2025 - 2:43:35 PM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MRA.Infrastructure.Cache.ICacheProvider,MRA.Services.Storage.IStorageService,MRA.Services.RemoteConfig.IRemoteConfigService,MRA.Services.Models.Drawings.IDrawingService,MRA.Services.Models.Inspirations.IInspirationService,MRA.Services.Models.Collections.ICollectionService,Microsoft.Extensions.Logging.ILogger`1<MRA.Services.AppService>,MRA.Infrastructure.Settings.AppSettings)
GetAllDrawings()
<GetAllDrawings()
GetAllInspirations()
<GetAllInspirations()
GetAllCollectionsAsync()
<GetAllCollectionsAsync()
FetchCollectionsAndLinkDrawings()
FetchCollectionAndLinkDrawings()
LinkDrawingsToCollections(System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.CollectionModel>,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
LinkDrawingToCollection(MRA.DTO.Models.CollectionModel,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FindCollectionByIdAsync()
<FindCollectionByIdAsync()
FilterDrawingsAsync()
<FilterDrawingsAsync()
FilterGivenList()
SortDrawingsByFilter(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.CollectionModel>)
FilterDrawings_Collection(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.CollectionModel>)
FilterDrawings_Spotify(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_Paper(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_Software(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_ProductType(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_Type(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_ModelName(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_CharacterName(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_ProductName(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_TextQuery(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_OnlyFavorites(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FilterDrawings_OnlyVisible(MRA.DTO.ViewModels.Art.DrawingFilter,System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
SetBlobUrl(System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>&)
CalculatePopularityOfListDrawings(System.Collections.Generic.IEnumerable`1<MRA.DTO.Models.DrawingModel>)
FindDrawingByIdAsync()
<FindDrawingByIdAsync()