Exemple #1
0
        /// <summary>
        /// Prepares based on ActionResponseBuilder, an IActionResult with a BadRequestResult response
        /// </summary>
        /// <typeparam name="T">Generic object for value</typeparam>
        /// <param name="actionResponseBuilder">ActionResponseBuilder prepared in the process</param>
        /// <param name="exception">Exception raised</param>
        /// <returns>BadRequestObjectResult with errors in ActionResponse and StatusCode of 400</returns>
        protected IActionResult Ko <T>(ActionResponseBuilder <T> actionResponseBuilder, Exception exception)
        {
            _logger.LogError(exception, null);

            actionResponseBuilder.AddError(new ErrorMessage(ErrorType.Invalid, exception.Message));

            return(BadRequest(actionResponseBuilder.Build()));
        }
 private static void ValidateDataCollection <T, TElement>(ActionResponseBuilder <T> builder)
     where T : ICollection <TElement>
 {
     if (builder.ActionResponse.Data == null)
     {
         throw new ArgumentException(ExceptionResources.ArgumentException_ActionResponseBuilder_DataNull);
     }
 }
        public void Given_Data_When_ConstructorInvoked_Then_ActionResponseBuilderWithDataRetrived()
        {
            var data = DateTime.Now;

            var actionResponseBuilder = new ActionResponseBuilder <DateTime>(data);
            var builtActionResponse   = actionResponseBuilder.Build();

            Assert.AreEqual(data, builtActionResponse.Data);
        }
        /// <summary>
        /// Extension method for allowing add single elements to the existing data inside an ActionResponse in case of being a Collection
        /// </summary>
        /// <typeparam name="T">Type of Data inside ActionResponse</typeparam>
        /// <typeparam name="TElement">Type of element to add</typeparam>
        /// <param name="builder">The builder itself</param>
        /// <param name="element">Element to add</param>
        /// <returns>The builder itself</returns>
        public static ActionResponseBuilder <T> AddElement <T, TElement>(this ActionResponseBuilder <T> builder, TElement element)
            where T : ICollection <TElement>
        {
            ValidateDataCollection <T, TElement>(builder);

            AddSingleElement(builder, element);

            return(builder);
        }
        public void Given_ActionResponseBuilderAndData_When_AddDataInvoked_Then_ActionResponseBuilderWithDataRetrived()
        {
            var data = DateTime.Now;

            var builtActionResponse = new ActionResponseBuilder <DateTime>()
                                      .SetData(data)
                                      .Build();

            Assert.AreEqual(data, builtActionResponse.Data);
        }
        public void Given_ActionResponseBuilderAndFalseFlag_When_SetStatusInvoked_Then_ActionResponseBuilderWithDataAndStatusRetrived()
        {
            var data   = DateTime.Now;
            var status = ActionResponseType.Error;
            var builtActionResponse = new ActionResponseBuilder <DateTime>(data)
                                      .SetStatus(false)
                                      .Build();

            Assert.AreEqual(data, builtActionResponse.Data);
            Assert.AreEqual(status, builtActionResponse.Flag);
        }
        public void Given_ActionResponseBuilder_When_AddErrorInvokedFromErrorTypeAndMessage_Then_ActionResponseBuilderWithDataAndErrorsRetrived()
        {
            var data = DateTime.Now;

            var builtActionResponse = new ActionResponseBuilder <DateTime>(data)
                                      .AddError(ErrorType.Validation, "Test Validation")
                                      .Build();

            Assert.AreEqual(data, builtActionResponse.Data);
            Assert.IsTrue(builtActionResponse.Errors.Any());
        }
        public void Given_ActionResponseBuilder_When_AddErrorInvokedFromException_Then_ActionResponseBuilderWithDataAndErrorsRetrived()
        {
            var data = DateTime.Now;

            var builtActionResponse = new ActionResponseBuilder <DateTime>(data)
                                      .AddError(new BusinessException("Test Exception", null))
                                      .Build();

            Assert.AreEqual(data, builtActionResponse.Data);
            Assert.IsTrue(builtActionResponse.Errors.Any());
        }
        /// <summary>
        /// Extension method for allowing add a collection of elements to the existing data inside an ActionResponse in case of being a Collection
        /// </summary>
        /// <typeparam name="T">Type of Data inside ActionResponse</typeparam>
        /// <typeparam name="TElement">Type of element to add</typeparam>
        /// <param name="builder">The builder itself</param>
        /// <param name="element">Element collection to add</param>
        /// <returns>The builder itself</returns>
        public static ActionResponseBuilder <T> AddRange <T, TElement>(this ActionResponseBuilder <T> builder, ICollection <TElement> elements)
            where T : ICollection <TElement>
        {
            ValidateDataCollection <T, TElement>(builder);

            foreach (var element in elements.ToList())
            {
                AddSingleElement(builder, element);
            }

            return(builder);
        }
Exemple #10
0
        public void Given_ActionResponseBuilderAndCollectionData_When_AddRangeInvoked_Then_ActionResponseBuilderWithDataRetrived()
        {
            var data = new List <DateTime> {
                DateTime.Now, DateTime.Now
            };

            var builtActionResponse = new ActionResponseBuilder <List <DateTime> >()
                                      .SetData(data)
                                      .AddRange(data)
                                      .Build();

            Assert.IsTrue(builtActionResponse.Data.Count() == 4);
        }
Exemple #11
0
        public void Given_ActionResponseBuilderAndData_When_AddElementInvoked_Then_ActionResponseBuilderWithDataRetrived()
        {
            var data = DateTime.Now;

            var builtActionResponse = new ActionResponseBuilder <List <DateTime> >()
                                      .SetData(new List <DateTime> {
                data
            })
                                      .AddElement(data)
                                      .Build();

            Assert.IsTrue(builtActionResponse.Data.Count() == 2);
            Assert.IsTrue(builtActionResponse.Data.Any(x => x == data));
        }
        public void Given_ActionResponseBuilder_When_BuildInvokedWithMultipleInfo_Then_ActionResponseRetrived()
        {
            var data   = DateTime.Now;
            var status = ActionResponseType.Warning;

            var builtActionResponse = new ActionResponseBuilder <DateTime>()
                                      .SetData(data)
                                      .AddError(new BusinessException("Test Exception", null))
                                      .AddError(new ErrorMessage(new BusinessException("Test Exception", null)))
                                      .AddError(ErrorType.Validation, "Test Validation")
                                      .SetStatus(status)
                                      .Build();

            Assert.AreEqual(data, builtActionResponse.Data);
            Assert.IsTrue(builtActionResponse.Errors.Count == 3);
            Assert.AreEqual(status, builtActionResponse.Flag);
        }
Exemple #13
0
 internal IActionResult Expose_Ok <T>(ActionResponseBuilder <T> actionResponseBuilder)
 => Ok(actionResponseBuilder);
 private static void AddSingleElement <T, TElement>(ActionResponseBuilder <T> builder, TElement element)
     where T : ICollection <TElement>
 {
     builder.ActionResponse.Data.Add(element);
 }
Exemple #15
0
 /// <summary>
 /// Prepares based on ActionResponseBuilder, an IActionResult
 /// </summary>
 /// <typeparam name="T">Generic object for value</typeparam>
 /// <param name="actionResponseBuilder">ActionResponseBuilder prepared in the process</param>
 /// <returns>OkObjectResult with value data in ActionResponse and StatusCode of 200</returns>
 protected IActionResult Ok <T>(ActionResponseBuilder <T> actionResponseBuilder)
 {
     return(Ok(actionResponseBuilder.Build()));
 }
Exemple #16
0
 /// <summary>
 /// Creates a empty instance of ActionResponseBuilder with an OkResponse response
 /// </summary>
 /// <typeparam name="T">Generic object for value</typeparam>
 /// <returns>The builder for ActionResponse and the generic object specified</returns>
 protected ActionResponseBuilder <T> GetEmptyResponseBuilder <T>()
 => ActionResponseBuilder <T> .Create();
Exemple #17
0
 internal IActionResult Expose_Ko <T>(ActionResponseBuilder <T> actionResponseBuilder, Exception exception)
 => Ko(actionResponseBuilder, exception);