Note Onion - 4 - API - NoteController

Here is the source code for NoteController.cs This is placed in the Controllers folder

using System.Net.NetworkInformation;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Note.Application.DTOs;
using Note.Application.Services;
using Note.Shared;
using Notes.API;
using Swashbuckle.AspNetCore.Annotations;
using Swashbuckle.AspNetCore.Filters;
using static System.Net.WebRequestMethods;

namespace Notes.API.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class NoteController : ControllerBase
    {
        private readonly INoteService _noteService;

        public NoteController(INoteService noteService)
        {
            _noteService = noteService;
        }

        /// <summary>
        /// Returns a list of all notes
        /// </summary>
        /// <param name="companyKey">This is a code given to your agency</param>
        /// <param name="applicationKey">This is a code representing your application</param>
        /// <param name="applicationSubKey">This is a code representing an object class in your application</param>
        /// <remarks>
        /// A result(NoteVM) object containing a collection of
        /// note type objects.
        /// 
        /// Get: api/v1/Notes
        /// </remarks>
        [HttpGet("{companyKey}/{applicationKey}/{applicationSubKey}")]
        [SwaggerResponse(
            StatusCodes.Status200OK,
            "HTTP 200 means a model is being returned. Check the WasSuccessfulTrue to determine if it worked properly", 
            typeof(IResult<List<NoteDto>>))]
        [SwaggerResponseExample(
            StatusCodes.Status200OK, 
            typeof(NoteControllerSwashbuckleExamples.NoteGetAllNotesAsync))]
        public async Task<IActionResult> GetNotes(
            string companyKey, 
            string applicationKey, 
            string applicationSubKey)
        {
            var result = await _noteService.GetAllNotesAsync(companyKey, applicationKey, applicationSubKey);
            return Ok(result);
        }

        //[HttpGet("{id}")]
        //[SwaggerResponse(StatusCodes.Status200OK, type: typeof(BaseResult<NoteDto>))]
        /// <summary>
        /// Returns a note object
        /// </summary>
        /// <param name="id" example="1">Note.Id</param>
        /// <returns>Result containing a NoteViewModel based Result Object</returns>
        [HttpGet("{companyKey}/{id}")]
        [SwaggerResponse(
            StatusCodes.Status200OK,
            "HTTP 200 means a model is being returned. Check the WasSuccessfulTrue to determine if it worked properly", 
            typeof(IResult<NoteDto>))]
        [SwaggerResponseExample(
            StatusCodes.Status200OK, 
            typeof(NoteControllerSwashbuckleExamples.NoteGetOneExample))]
        public async Task<IActionResult> GetNote(string companyKey, long id)
        {
            var result = await _noteService.GetNoteById(companyKey, id);
            return Ok(result);
        }


        ///// <summary>
        ///// If you do not pass a number to the GetOne function, 
        ///// then you will get a null model.
        ///// </summary>
        ///// <returns></returns>
        //[HttpGet("null")]
        //[SwaggerResponse(StatusCodes.Status200OK, null, typeof(IResult<NoteDto>))]
        ////[SwaggerResponseExample(StatusCodes.Status200OK, typeof(SwashbuckleExamples.NoteGetOneExampleNull))]
        //public IActionResult GetOne(string companyKey)
        //{
        //    return ReturnResult(new Result<List<NoteDto>>());
        //}


        //[SwaggerResponse(StatusCodes.Status200OK, type: typeof(BaseResult<long>))]
        /// <summary>
        /// Used to add a note to the note database
        /// </summary>
        /// <param name="noteVm">
        /// Pass in a NoteDto object
        /// </param>
        /// <returns></returns>
        [HttpPost]
        [SwaggerRequestExample(
            typeof(NoteDto), 
            typeof(NoteControllerSwashbuckleExamples.NotePostExample))]
        [SwaggerResponse(
            StatusCodes.Status200OK, 
            "HTTP 200 means a model is being returned. Check the WasSuccessfulTrue to determine if it worked properly", 
            typeof(IResult<NoteDto>))]
        [SwaggerResponseExample(
            StatusCodes.Status200OK, 
            typeof(NoteControllerSwashbuckleExamples.NotePostResultsExampleSuccess))]
        [SwaggerResponse(
            StatusCodes.Status400BadRequest, 
            "If your Request Body is incorrect, then you'll get 400 error. Look at the errors collection to see the problems.", 
            typeof(IResult<NoteDto>))]
        [SwaggerResponseExample(
            StatusCodes.Status400BadRequest, 
            typeof(NoteControllerSwashbuckleExamples.NotePostResultsExampleError400))]
        public async Task<IActionResult> CreateNote([FromBody] NoteDto noteDto)
        {
            var result = await _noteService.CreateNote(noteDto);
            return Ok(result);
        }

        /// <summary>
        /// Used to update an existing note.
        /// </summary>
        /// <param name="id">
        /// This ID of the NoteDto being updated.
        /// </param>
        /// <param name="noteVm">
        /// Pass in a NoteViewModel
        /// </param>
        /// <returns></returns>
        [HttpPut("{id}")]
        [SwaggerResponse(
            StatusCodes.Status200OK, 
            type: typeof(BaseResult<bool>))]
        [SwaggerRequestExample(
            typeof(NoteDto), 
            typeof(NoteControllerSwashbuckleExamples.NotePutExample))]
        [SwaggerResponseExample(StatusCodes.Status200OK, 
            typeof(NoteControllerSwashbuckleExamples.NotePostResultsExampleSuccess))]
        public async Task<IActionResult> UpdateNote(
            long id, 
            [FromBody] NoteDto noteDto)
        {
            noteDto.Id = id;
            var result = await _noteService.UpdateNote(noteDto);
            return Ok(result);
        }

        /// <summary>
        /// Used to Delete an existing note
        /// </summary>
        /// <param name="id">
        /// This is the ID of the note that should be deleted
        /// </param>
        /// <returns></returns>
        [HttpDelete("{companyKey}/{id}")]
        [SwaggerResponse(
            StatusCodes.Status200OK,
            "HTTP 200 means a model is being returned. Check the WasSuccessfulTrue to determine if it worked properly", 
            typeof(IResult<NoteDto>))]
        [SwaggerResponseExample(
            StatusCodes.Status200OK, 
            typeof(NoteControllerSwashbuckleExamples.NoteDeleteResultsExampleSuccess))]
        public async Task<IActionResult> DeleteNote(string companyKey, long id)
        {
            var result = await _noteService.DeleteNote(companyKey, id);
            return Ok(result);
        }
    }
}