7106474053

Committed 05 Dec 2023 08:58PM UTC coverage: 75.694% (+0.09%) from 75.603%

Build # 7106474053

Build Type

push

github

Committed by

tidyui

Commit Message

Optimized services for usage without cache.

Run Details

2042 of 2994 branches covered (0.0%)

Branch coverage included in aggregate %.

81 of 98 new or added lines in 6 files covered. (82.65%)

7 existing lines in 3 files now uncovered.

8428 of 10838 relevant lines covered (77.76%)

1763.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

52.68

/core/Piranha/Services/Internal/ContentTypeService.cs

/*
 * Copyright (c) .NET Foundation and Contributors
 *
 * This software may be modified and distributed under the terms
 * of the MIT license. See the LICENSE file for details.
 *
 * https://github.com/piranhacms/piranha.core
 *
 */

using System.ComponentModel.DataAnnotations;
using Piranha.Cache;
using Piranha.Models;
using Piranha.Repositories;

namespace Piranha.Services;

internal sealed class ContentTypeService : IContentTypeService
{
    private readonly IContentTypeRepository _repo;
    private readonly ICache _cache;
    private static readonly string CacheKey = "Piranha_ContentTypes";

    /// <summary>
    /// Default constructor.
    /// </summary>
    /// <param name="repo">The main repository</param>
    /// <param name="cache">The optional model cache</param>
    public ContentTypeService(IContentTypeRepository repo, ICache cache = null)
    {
        _repo = repo;

        if (App.CacheLevel != CacheLevel.None)
        {
            _cache = cache;
        }
    }

    /// <summary>
    /// Gets all available models.
    /// </summary>
    /// <returns>The available models</returns>
    public async Task<IEnumerable<ContentType>> GetAllAsync()
    {
        var types = await GetTypes().ConfigureAwait(false);
        return types ?? await _repo.GetAll().ConfigureAwait(false);
    }

    /// <summary>
    /// Gets all available models from the specified group.
    /// </summary>
    /// <param name="group">The content group</param>
    /// <returns>The available models</returns>
    public async Task<IEnumerable<ContentType>> GetByGroupAsync(string group)
    {
        var types = await GetTypes().ConfigureAwait(false);

        if (types != null)
        {
            return types.Where(t => t.Group == group).ToList();
        }
        return await _repo.GetByGroup(group).ConfigureAwait(false);
    }

    /// <summary>
    /// Gets the model with the specified id.
    /// </summary>
    /// <param name="id">The unique id</param>
    /// <returns>The model</returns>
    public async Task<ContentType> GetByIdAsync(string id)
    {
        var types = await GetTypes().ConfigureAwait(false);

        if (types != null)
        {
            return types.FirstOrDefault(t => t.Id == id);
        }
        return await _repo.GetById(id).ConfigureAwait(false);
    }

    /// <summary>
    /// Adds or updates the given model in the database
    /// depending on its state.
    /// </summary>
    /// <param name="model">The model</param>
    public async Task SaveAsync(ContentType model)
    {
        // Validate model
        var context = new ValidationContext(model);
        Validator.ValidateObject(model, context, true);

        // Validate regions
        foreach (var region in model.Regions)
        {
            var regionContext = new ValidationContext(region);
            Validator.ValidateObject(region, regionContext, true);

            // Validate fields
            foreach (var field in region.Fields)
            {
                var fieldContext = new ValidationContext(field);
                Validator.ValidateObject(field, fieldContext, true);
            }
        }

        // Call hooks & save
        App.Hooks.OnBeforeSave(model);
        await _repo.Save(model).ConfigureAwait(false);
        App.Hooks.OnAfterSave(model);

        // Clear cache
        _cache?.Remove(CacheKey);
    }

    /// <summary>
    /// Deletes the model with the specified id.
    /// </summary>
    /// <param name="id">The unique id</param>
    public async Task DeleteAsync(string id)
    {
        var model = await _repo.GetById(id).ConfigureAwait(false);

        if (model != null)
        {
            await DeleteAsync(model).ConfigureAwait(false);
        }
    }

    /// <summary>
    /// Deletes the given model.
    /// </summary>
    /// <param name="model">The model</param>
    public async Task DeleteAsync(ContentType model)
    {
        // Call hooks & delete
        App.Hooks.OnBeforeDelete(model);
        await _repo.Delete(model.Id).ConfigureAwait(false);
        App.Hooks.OnAfterDelete(model);

        // Clear cache
        _cache?.Remove(CacheKey);
    }

    /// <summary>
    /// Deletes the given models.
    /// </summary>
    /// <param name="models">The models</param>
    public async Task DeleteAsync(IEnumerable<ContentType> models)
    {
        if (models != null && models.Count() > 0)
        {
            foreach (var model in models)
            {
                // Call hooks & delete
                App.Hooks.OnBeforeDelete(model);
                await _repo.Delete(model.Id).ConfigureAwait(false);
                App.Hooks.OnAfterDelete(model);
            }
            // Clear cache
            _cache?.Remove(CacheKey);
        }
    }

    /// <summary>
    /// Gets the content types from the database.
    /// </summary>
    private async Task<IEnumerable<ContentType>> GetTypes()
    {
        if (_cache != null)
        {
            var types = _cache.Get<IEnumerable<ContentType>>(CacheKey);

            if (types == null)
            {
                types = await _repo.GetAll().ConfigureAwait(false);

                _cache.Set(CacheKey, types);
            }
            return types;
        }
        return null;
    }
}

1	/*
2	* Copyright (c) .NET Foundation and Contributors
3	*
4	* This software may be modified and distributed under the terms
5	* of the MIT license. See the LICENSE file for details.
6	*
7	* https://github.com/piranhacms/piranha.core
8	*
9	*/
10
11	using System.ComponentModel.DataAnnotations;
12	using Piranha.Cache;
13	using Piranha.Models;
14	using Piranha.Repositories;
15
16	namespace Piranha.Services;
17
18	internal sealed class ContentTypeService : IContentTypeService
19	{
20	private readonly IContentTypeRepository _repo;
21	private readonly ICache _cache;
22	private static readonly string CacheKey = "Piranha_ContentTypes";	1✔
23
24	/// <summary>
25	/// Default constructor.
26	/// </summary>
27	/// <param name="repo">The main repository</param>
28	/// <param name="cache">The optional model cache</param>
29	public ContentTypeService(IContentTypeRepository repo, ICache cache = null)	8,012✔
30	{	8,012✔
31	_repo = repo;	8,012✔
32
33	if (App.CacheLevel != CacheLevel.None)	8,012✔
34	{	8,012✔
35	_cache = cache;	8,012✔
36	}	8,012✔
37	}	8,012✔
38
39	/// <summary>
40	/// Gets all available models.
41	/// </summary>
42	/// <returns>The available models</returns>
43	public async Task<IEnumerable<ContentType>> GetAllAsync()
44	{	17✔
45	var types = await GetTypes().ConfigureAwait(false);	17✔
46	return types ?? await _repo.GetAll().ConfigureAwait(false);	17✔
47	}	17✔
48
49	/// <summary>
50	/// Gets all available models from the specified group.
51	/// </summary>
52	/// <param name="group">The content group</param>
53	/// <returns>The available models</returns>
54	public async Task<IEnumerable<ContentType>> GetByGroupAsync(string group)
55	{	×
NEW 56	var types = await GetTypes().ConfigureAwait(false);	×
57
NEW 58	if (types != null)	×
UNCOV 59	{	×
NEW 60	return types.Where(t => t.Group == group).ToList();	×
61	}
NEW 62	return await _repo.GetByGroup(group).ConfigureAwait(false);	×
UNCOV 63	}	×
64
65	/// <summary>
66	/// Gets the model with the specified id.
67	/// </summary>
68	/// <param name="id">The unique id</param>
69	/// <returns>The model</returns>
70	public async Task<ContentType> GetByIdAsync(string id)
71	{	4✔
72	var types = await GetTypes().ConfigureAwait(false);	4✔
73
74	if (types != null)	4!
UNCOV 75	{	×
NEW 76	return types.FirstOrDefault(t => t.Id == id);	×
77	}
78	return await _repo.GetById(id).ConfigureAwait(false);	4✔
79	}	4✔
80
81	/// <summary>
82	/// Adds or updates the given model in the database
83	/// depending on its state.
84	/// </summary>
85	/// <param name="model">The model</param>
86	public async Task SaveAsync(ContentType model)
87	{	21✔
88	// Validate model
89	var context = new ValidationContext(model);	21✔
90	Validator.ValidateObject(model, context, true);	21✔
91
92	// Validate regions
93	foreach (var region in model.Regions)	113✔
94	{	25✔
95	var regionContext = new ValidationContext(region);	25✔
96	Validator.ValidateObject(region, regionContext, true);	25✔
97
98	// Validate fields
99	foreach (var field in region.Fields)	129✔
100	{	27✔
101	var fieldContext = new ValidationContext(field);	27✔
102	Validator.ValidateObject(field, fieldContext, true);	27✔
103	}	27✔
104	}	25✔
105
106	// Call hooks & save
107	App.Hooks.OnBeforeSave(model);	21✔
108	await _repo.Save(model).ConfigureAwait(false);	21✔
109	App.Hooks.OnAfterSave(model);	21✔
110
111	// Clear cache
112	_cache?.Remove(CacheKey);	21✔
113	}	21✔
114
115	/// <summary>
116	/// Deletes the model with the specified id.
117	/// </summary>
118	/// <param name="id">The unique id</param>
119	public async Task DeleteAsync(string id)
120	{	×
121	var model = await _repo.GetById(id).ConfigureAwait(false);	×
122
123	if (model != null)	×
124	{	×
125	await DeleteAsync(model).ConfigureAwait(false);	×
126	}	×
127	}	×
128
129	/// <summary>
130	/// Deletes the given model.
131	/// </summary>
132	/// <param name="model">The model</param>
133	public async Task DeleteAsync(ContentType model)
134	{	7✔
135	// Call hooks & delete
136	App.Hooks.OnBeforeDelete(model);	7✔
137	await _repo.Delete(model.Id).ConfigureAwait(false);	7✔
138	App.Hooks.OnAfterDelete(model);	7✔
139
140	// Clear cache
141	_cache?.Remove(CacheKey);	7!
142	}	7✔
143
144	/// <summary>
145	/// Deletes the given models.
146	/// </summary>
147	/// <param name="models">The models</param>
148	public async Task DeleteAsync(IEnumerable<ContentType> models)
149	{	×
150	if (models != null && models.Count() > 0)	×
151	{	×
152	foreach (var model in models)	×
153	{	×
154	// Call hooks & delete
155	App.Hooks.OnBeforeDelete(model);	×
156	await _repo.Delete(model.Id).ConfigureAwait(false);	×
157	App.Hooks.OnAfterDelete(model);	×
158	}	×
159	// Clear cache
160	_cache?.Remove(CacheKey);	×
161	}	×
162	}	×
163
164	/// <summary>
165	/// Gets the content types from the database.
166	/// </summary>
167	private async Task<IEnumerable<ContentType>> GetTypes()
168	{	21✔
169	if (_cache != null)	21!
UNCOV 170	{	×
NEW 171	var types = _cache.Get<IEnumerable<ContentType>>(CacheKey);	×
172
NEW 173	if (types == null)	×
NEW 174	{	×
NEW 175	types = await _repo.GetAll().ConfigureAwait(false);	×
176
NEW 177	_cache.Set(CacheKey, types);	×
NEW 178	}	×
NEW 179	return types;	×
180	}
181	return null;	21✔
182	}	21✔
183	}

PiranhaCMS / piranha.core / 7106474053

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous