Swagger error Ambiguous HTTP method for action Actions require explicit HttpMethod binding

Question

I am trying to generate swagger docs for my API. Every time I navigate to the swagger docs I get this error:

Ambiguous HTTP method for action - [ControllerName]Controller.DownloadFile. Actions require an explicit HttpMethod binding for Swagger/OpenAPI 3.0

Here is the "offending" code it is complaining about in my controller:

    using Models;
using Utilities;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;


namespace Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class LibrarianController : ControllerBase
    {
        private IFileUploadUtilties fileUtilities;
        private IConfiguration config;
        private ApiContext context;
        private IFileRetrieval fileRetrieval;
        public LibrarianController(IFileUploadUtilties utilities, IConfiguration config, FinwiseApiContext context, IFileRetrieval fileRetrieval)
        {
            fileUtilities = utilities;
            this.config = config;
            this.context = context;
            this.fileRetrieval = fileRetrieval;
        }

       [HttpGet]
        public IActionResult Get()
        {
            return Ok("Ok");
        }

        // GET api/<LibrarianController>/5
        [HttpGet("/api/[controller]/{Id}")]
        public async Task<IActionResult> Get(int id)
        {
            try
            {
                return Ok(await fileRetrieval.GetFileForPartnerItemById(id));
            }
            catch(Exception ex)
            {
                return NotFound();
            }
            
        }
        [HttpGet ("/api/[controller]/[action]/{fileId}")]
        public async Task<IActionResult> DownloadFile(int fileId)
        {
            if (fileId == 0)
                return Content("File Id missing");

            var fileDownload = await fileRetrieval.GetFileForPartnerItemById(fileId);
            var contentType = await fileUtilities.GetFileType(Path.GetExtension(fileDownload.NewFileName));

            var path = Path.Combine(config.GetSection("StoredFilePath").Value, fileDownload.NewFileName);

            var memory = new MemoryStream();
            using (var stream = new FileStream(path, FileMode.Open))
            {
                await stream.CopyToAsync(memory);
            }
            memory.Position = 0;
            return File(memory, contentType, Path.GetFileName(path));
        }

        [HttpGet("api/[controller]/{PartnerId}/{ItemId}")]
        public async Task<List<FileUploads>> GetFiles(string PartnerId, string ItemId)
        {
            var getFiles =  await fileRetrieval.GetAllFilesForPartnerItem(PartnerId, ItemId);
            return getFiles;
        }
        
        
        // POST api/<LibrarianController>
        [HttpPost]
        public async Task<IActionResult> Post([FromForm] FileInformation fileInfo)
        {
            int newFileVersion = 1;

            if (fileInfo == null || fileInfo.Files == null || fileInfo.Files.Count == 0)
                return BadRequest("File(s) not found");

            try
            {
                foreach (var locFile in fileInfo.Files)
                {
                    //check for file extension, if not there, return an error
                    var fileExtension = Path.GetExtension(locFile.FileName);
                    if (string.IsNullOrEmpty(fileExtension))
                        return BadRequest("Files must include file extension");


                    var valid = await fileUtilities.IsFileValid(locFile);

                    var newFileName = string.Concat(Guid.NewGuid().ToString(),valid.fileExtension);

                    var newFileLocation = Path.Combine(config.GetSection("StoredFilePath").Value, newFileName);
                   

                    if (!valid.FileExtensionFound)
                    {
                        return BadRequest($"Error {valid.FileExtensionFoundError}");
                    }
                    if (!valid.FileSizeAllowed)
                    {
                        return BadRequest($"Error: {valid.FileSizeAllowedError}");
                    }


                    //check for an existing file in the database.  If there is one, increment the file version before the save
                    var currentFile = await fileUtilities.FileExists(fileInfo, locFile);

                    if (currentFile != null)
                    {
                        newFileVersion = currentFile.Version + 1;
                    }
              
                    //save to the file system
                    using (var stream = new FileStream(newFileLocation, FileMode.OpenOrCreate, FileAccess.ReadWrite))
                    {
                        await locFile.CopyToAsync(stream);
                    }

                    //save to the db.  Check to see if the file exists first.  If it does, do an insert, if not, return an error
                    if (System.IO.File.Exists(newFileLocation))
                    {
                        FileUploads upload = new FileUploads
                        {
                            EntityId = fileInfo.EntityId,
                            FileName = locFile.FileName,
                            ItemId = fileInfo.ItemId.ToString(),
                            NewFileName = newFileName,
                            ValidFile = true,
                            Version = newFileVersion
                        };
                        context.FileUploads.Add(upload);
                        context.SaveChanges();
                        //TODO: fire event the file has been saved provide Id key to find the record
                        //upload.Id;
                    }
                    else
                    {
                        return BadRequest("Error: File Could not be saved");
                    }

                }
            }
            catch (Exception ex)
            {
                return BadRequest("Failure to upload files.");
            }
            return Ok("File Uploaded");
        }

        // PUT api/<LibrarianController>/5
        [HttpPut("{id}")]
        public void Put(int id, [FromBody] string value)
        {
        }

        // DELETE api/<LibrarianController>/5
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }
    }
}

This end point works fine when I test it. I set the route and it is decorated with the HTTP so I don't understand what it is complaining about. I looked around for a solution, but from what I could see it is stating there is a public method not decorated in the controller, however there are not undecorated methods in this controller. What is the problem here? If I remove the routing info from the HttpGet the method is not reachable, so I need to have both the Route and the HttpGet decorators to reach this method (unless I did that wrong too). How can I fix this?

Can you include the full controller? Is there another Method named `DownloadFile` within that controller? Also curious why you included the `[Route]` annotation when you already specified the route in the `[HttpGet]` annotation. — Connor Low, Jul 17 '20 at 19:07

score 25 · Answer 1 · answered Feb 14 '21 at 14:17

25

I solved my problem by including the [NonAction] signature in the header of functions that were not endpoints

Example

[ApiVersion("1.0")]
[Route("api/v{version:apiVersion}/[controller]")]
[ApiController]
public class RequestController : ControllerBase {

    [NonAction]
    public ObjectResult SetError( Exception e)
    {
        return StatusCode(500, e.Message);
    }
}

answered Feb 14 '21 at 14:17

César Augusto

593
1
7
7

This worked for me. Adding [NonAction] to my helper function which is not the endpoint – sharooque Mar 28 '23 at 16:48
Same problem I have after multiple tries. I am not able to fix this but finally, this [NonAction] worked!! – Uday Aug 16 '23 at 06:38

score 11 · Accepted Answer · answered Jul 18 '20 at 02:10

Why Ambiguous

Here is your routing for DownloadFile():

[HttpGet ("/api/[controller]/[action]/{fileId}")]
public async Task<IActionResult> DownloadFile(int fileId)

And this is the one for GetFiles():

[HttpGet("api/[controller]/{PartnerId}/{ItemId}")]
public async Task<List<FileUploads>> GetFiles(string PartnerId, string ItemId)

Consider a GET request /api/Librarian/DownloadFile/62959061. This url fits BOTH actions:

For DownloadFile(), DownloadFile is [action] and 62959061 is fileId.
For GetFiles(), DownloadFile is PartnerId and 62959061 is ItemId. (.NET will treat 62959061 as a string when doing model binding.)

That's why you have the Ambiguous error.

Suggestions

Assign each action a unique name and a predictable route.

1. Method name duplication

Instead of having these:

public IActionResult Get() { /*...*/ }
public async Task<IActionResult> Get(int id) { /*...*/ }

Rename one of the method to avoid same method name:

public IActionResult Get() { /*...*/ }
public async Task<IActionResult> GetById(int id) { /*...*/ }

2. Defining a unique route

Form the controller you defined, I suggest you to use [RoutePrefix] at controller level and use [Route] or [Http{Method}] at action level. Here is the related discussion on what they are.

Defining the route using the same pattern can avoid creating ambiguous route accidentally. Below is my attempt to redefine the routings:

[RoutePrefix("api/[controller]")] // api/Librarian
[ApiController]
public class LibrarianController : ControllerBase
{
    [HttpGet("")] // GET api/Librarian/
    public IActionResult Get() { /*...*/ }

    [HttpGet("{Id}")] // GET api/Librarian/62959061
    public async Task<IActionResult> GetById(int id) { /*...*/ }

    [HttpGet("download/{fileId}")] // GET api/Librarian/download/62959061
    public async Task<IActionResult> DownloadFile(int fileId) { /*...*/ }

    [HttpGet("getfiles/{PartnerId}/{ItemId}")] // GET api/Librarian/getfiles/partnerid/itemid
    public async Task<List<FileUploads>> GetFiles(string PartnerId, string ItemId) { /*...*/ }

    [HttpPost("")] // POST api/Librarian/
    public async Task<IActionResult> Post([FromForm] FileInformation fileInfo) { /*...*/ }

    [HttpPut("{id}")] // PUT api/Librarian/62959061
    public void Put(int id, [FromBody] string value) { /*...*/ }

    [HttpDelete("{id}")] // DELETE api/Librarian/62959061
    public void Delete(int id) { /*...*/ }
}

By adding a path for DownloadFile() and GetFiles() the app should be able to identify the route correctly as the app knows all routes with /download must go to DownloadFile() and all routes with /getfiles must go to GetFiles().

Thanks this fixed it. What was killing me is on the decorators I was putting the paths in as /download/{fileId} instead of download/{fileId}. That forward slash was messing things up a lot so that's why I was doing the route decorators. Again, thanks. — john, Jul 19 '20 at 05:39

score 2 · Answer 3 · answered Jun 29 '22 at 06:47

My two cents.

I have a few endpoints, because of which I was getting errors in similar lines.

An unhandled exception has occurred while executing the request. Swashbuckle.AspNetCore.SwaggerGen.SwaggerGeneratorException: Ambiguous HTTP method for action - BuberDinner.Api.Controllers.ErrorsController.Error (BuberDinner.Api). Actions require an explicit HttpMethod binding for Swagger/OpenAPI 3.0

I had to the following tweaks to get over this.

When my end point is the following

using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Mvc;

namespace BuberDinner.Api.Controllers;

public class ErrorsController : ControllerBase
{
    [Route("error")]
    public IActionResult Error()
    {
        var exception = HttpContext.Features.Get<IExceptionHandlerFeature>()?.Error;
        return Problem();
    }
}

I added the following attribute to fix that.

[ApiExplorerSettings(IgnoreApi = true)]

So the api now looks as follows.

using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Mvc;

namespace BuberDinner.Api.Controllers;

[ApiExplorerSettings(IgnoreApi = true)]
public class ErrorsController : ControllerBase
{
    [Route("error")]
    public IActionResult Error()
    {
        var exception = HttpContext.Features.Get<IExceptionHandlerFeature>()?.Error;
        // return Problem(title: exception?.Message, statusCode: 400);
        return Problem();
    }
}

And in another 'login' endpoint,

using BuberDinner.Api.Filters;
using BuberDinner.Application.Services.Authentication;
using BuberDinner.Contracts.Authentication;
using Microsoft.AspNetCore.Mvc;

namespace BuberDinner.Api.Controllers;

[ApiController]
[Route("auth")]
public class AuthenticationController : ControllerBase
{
  private readonly IAuthenticationService _authenticationService;
  public AuthenticationController(IAuthenticationService authenticationService)
  {
    _authenticationService = authenticationService;
  }

    [Route("login")]
    public IActionResult Login(LoginRequest request)
    {
        var authenticationResult = _authenticationService.Login(request.Email,
                                                                request.Password);

        var response = new AuthenticationResponse(
            authenticationResult.User.Id,
            authenticationResult.User.FirstName,
            authenticationResult.User.LastName,
            authenticationResult.User.Email,
            authenticationResult.Token);
            
        return Ok(response);
    }    
}

I replaced the [Route("login")] with [HttpPost("login")]

Finally the swagger UI shows up now.

score 0 · Answer 4 · edited Mar 19 '21 at 14:23

0

I managed to resolve it using the following attribute: [HttpGet, ActionName ("GetId")]. I named the method using ActionName().

edited Mar 19 '21 at 14:23

Anouar

2,050
1
15
25

answered Mar 18 '21 at 20:11

LUAN PEDRO

1
1

Swagger error Ambiguous HTTP method for action Actions require explicit HttpMethod binding

4 Answers4

Why Ambiguous

Suggestions

1. Method name duplication

2. Defining a unique route