8506312017

Committed 01 Apr 2024 09:18AM UTC coverage: 85.942% (-3.2%) from 89.113%

Build # 8506312017

Build Type

Pull #112

github

Committed by

web-flow

Commit Message

Merge bec67a24f into 886b4a9f4

Pull Request Pull Request #112: #26 config

Run Details

250 of 331 branches covered (75.53%)

Branch coverage included in aggregate %.

218 of 259 new or added lines in 22 files covered. (84.17%)

3 existing lines in 1 file now uncovered.

1529 of 1739 relevant lines covered (87.92%)

19.95 hits per line

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

90.38

/source/core/Kyameru.Core/Chain/BaseChain.cs

﻿using System.Threading;
using System.Threading.Tasks;
using Kyameru.Core.Contracts;
using Kyameru.Core.Entities;
using Kyameru.Core.Extensions;
using Microsoft.Extensions.Logging;

namespace Kyameru.Core.Chain
{
    /// <summary>
    /// Base chain for processing
    /// </summary>
    internal abstract class BaseChain : IChain<Routable>
    {
        /// <summary>
        /// Logger interface.
        /// </summary>
        protected readonly ILogger Logger;

        /// <summary>
        /// Route identity.
        /// </summary>
        protected readonly string identity;

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseChain"/> class.
        /// </summary>
        /// <param name="logger">Logging class.</param>
        /// <param name="identity">Identity of route.</param>
        protected BaseChain(ILogger logger, string identity)
        {
            Logger = logger;
            this.identity = identity;
        }

        /// <summary>
        /// Gets or sets the next component.
        /// </summary>
        private IChain<Routable> Next { get; set; }

        /// <summary>
        /// Pass the processing onto the next component.
        /// </summary>
        /// <param name="item">Message to process.</param>
        public virtual void Handle(Routable item)
        {
            if (!item.ExitRoute)
            {

                Next?.Handle(item);
            }
            else
            {
                Logger.KyameruWarning(identity, string.Format(Resources.WARNING_ROUTE_EXIT, item.ExitReason));
            }
        }

        /// <summary>
        /// Pass the processing onto the next component.
        /// </summary>
        /// <param name="item">Message to process.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        public virtual async Task HandleAsync(Routable item, CancellationToken cancellationToken)
        {
            if (!item.ExitRoute)
            {
                // Really?
                if (Next != null)
                {
                    await Next?.HandleAsync(item, cancellationToken);
                }

            }
            else
            {
                Logger.KyameruWarning(identity, string.Format(Resources.WARNING_ROUTE_EXIT, item.ExitReason));
            }

        }

        /// <summary>
        /// Sets the next component in the chain.
        /// </summary>
        /// <param name="next">Next component.</param>
        /// <returns>Returns an instance of the <see cref="IChain{T}"/>/> interface.</returns>
        public IChain<Routable> SetNext(IChain<Routable> next)
        {
            Next = next;
            return Next;
        }

        /// <summary>
        /// Logging event handler.
        /// </summary>
        /// <param name="sender">Class sending the event.</param>
        /// <param name="e">Log object.</param>
        protected void OnLog(object sender, Log e)
        {
            if (e.Error == null)
            {
                Logger.KyameruLog(identity, e.Message, e.LogLevel);
            }
            else
            {
                Logger.KyameruError(identity, e.Message);
            }
        }
    }
}

1	using System.Threading;
2	using System.Threading.Tasks;
3	using Kyameru.Core.Contracts;
4	using Kyameru.Core.Entities;
5	using Kyameru.Core.Extensions;
6	using Microsoft.Extensions.Logging;
7
8	namespace Kyameru.Core.Chain
9	{
10	/// <summary>
11	/// Base chain for processing
12	/// </summary>
13	internal abstract class BaseChain : IChain<Routable>
14	{
15	/// <summary>
16	/// Logger interface.
17	/// </summary>
18	protected readonly ILogger Logger;
19
20	/// <summary>
21	/// Route identity.
22	/// </summary>
23	protected readonly string identity;
24
25	/// <summary>
26	/// Initializes a new instance of the <see cref="BaseChain"/> class.
27	/// </summary>
28	/// <param name="logger">Logging class.</param>
29	/// <param name="identity">Identity of route.</param>
30	protected BaseChain(ILogger logger, string identity)	68✔
31	{	68✔
32	Logger = logger;	68✔
33	this.identity = identity;	68✔
34	}	68✔
35
36	/// <summary>
37	/// Gets or sets the next component.
38	/// </summary>
39	private IChain<Routable> Next { get; set; }	161✔
40
41	/// <summary>
42	/// Pass the processing onto the next component.
43	/// </summary>
44	/// <param name="item">Message to process.</param>
45	public virtual void Handle(Routable item)
46	{	42✔
47	if (!item.ExitRoute)	42✔
48	{	40✔
49
50	Next?.Handle(item);	40✔
51	}	40✔
52	else
53	{	2✔
54	Logger.KyameruWarning(identity, string.Format(Resources.WARNING_ROUTE_EXIT, item.ExitReason));	2✔
55	}	2✔
56	}	42✔
57
58	/// <summary>
59	/// Pass the processing onto the next component.
60	/// </summary>
61	/// <param name="item">Message to process.</param>
62	/// <param name="cancellationToken">Cancellation token</param>
63	public virtual async Task HandleAsync(Routable item, CancellationToken cancellationToken)
64	{	6✔
65	if (!item.ExitRoute)	6!
66	{	6✔
67	// Really?
68	if (Next != null)	6✔
69	{	3✔
70	await Next?.HandleAsync(item, cancellationToken);	3!
71	}	3✔
72
73	}	6✔
74	else
75	{	×
NEW 76	Logger.KyameruWarning(identity, string.Format(Resources.WARNING_ROUTE_EXIT, item.ExitReason));	×
77	}	×
78
79	}	6✔
80
81	/// <summary>
82	/// Sets the next component in the chain.
83	/// </summary>
84	/// <param name="next">Next component.</param>
85	/// <returns>Returns an instance of the <see cref="IChain{T}"/>/> interface.</returns>
86	public IChain<Routable> SetNext(IChain<Routable> next)
87	{	56✔
88	Next = next;	56✔
89	return Next;	56✔
90	}	56✔
91
92	/// <summary>
93	/// Logging event handler.
94	/// </summary>
95	/// <param name="sender">Class sending the event.</param>
96	/// <param name="e">Log object.</param>
97	protected void OnLog(object sender, Log e)
98	{	32✔
99	if (e.Error == null)	32✔
100	{	26✔
101	Logger.KyameruLog(identity, e.Message, e.LogLevel);	26✔
102	}	26✔
103	else
104	{	6✔
105	Logger.KyameruError(identity, e.Message);	6✔
106	}	6✔
107	}	32✔
108	}
109	}

djsuperchief / Kyameru / 8506312017

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