CODEWITHSUNDEEP
jsonapiresthttp
Czeshirecat
Czeshirecat

Reputation: 546

GET,POST,PUT Which should be used for receiving a json object to my rest api and send a json object in response?

I'm writing my first web API using MVC.

I'm aware that POST and PUT are usually implemented to define the HTTP methods for inserting or updating a database behind an API. But all I want to do is receive a JSON object from the caller, do some processing then return another JSON object in response. No database is involved.

I've tested using both POST and GET in my API controller method and they both work ok but which http method should I actually be using for best practice?

eg

public IHttpActionResult Get(ApiEquipment equipment)
{
    // Convert equipment to a compatible buffer
    return Ok(new ConvertToBuffer(equipment));
}

Upvotes: 0

Views: 1244

Answers (4)

Bharath theorare
Bharath theorare

Reputation: 554

I would suggest you to use 'HTTPPOST' if you require to process your JSON object else useGETmethod.

Consider this example for using HttpPost method since I process the JSON object to get some info from database.

    [HttpPost]
    public IHttpActionResult Masters([FromBody]Download_Config_UserInfo Info)
    {
        List<TestMaster> testMaster = null;
        ResponseValidation objValidation = new ResponseValidation();
        try
        {
            #region Validation
            objValidation = base.ValidateRequest(Info);
            if (!objValidation.isValid)
                return base.JsonErrorResult(this.MasterName, objValidation.ErrorCode, objValidation.ErrorDesc);
            #endregion

            #region Initialization
            this.Initialization();
            #endregion

            #region Functionality

            //testMaster = this.GetTestMaster();
            testMaster = this.GetTestDateMaster();                
            if (testMaster == null)
                return base.JsonErrorResult(this.MasterName, "E19", "Data Not Available");

            var result = (from a in testMaster
                          select new object[]
                          {
                              a.TestId,
                              a.TestName
                          });
            #endregion

            return base.JsonResult(this.MasterName, this.Fields, result);

        }
        catch (Exception ex)
        {
            loggerService.Error(Info.ToJSON(), this.MasterName, ex);
            return base.JsonErrorResult(this.MasterName, "E20", "Internal Server Error", ex.Message + "_" + ex.StackTrace);
        }
        finally
        {
            testMaster = null; objValidation = null; base.UserMaster = null; base.UserPositionMapping = null;
        }
    }

    #endregion

    #region Functionality

    [NonAction]
    public List<TestMaster> GetTestMaster()
    {
        List<ADM_Retailer> testMaster = null;
        try
        {
            testMaster = this.GetTest();
            if (testMaster == null || (testMaster.Count == 0)) { return null; }

            string weekNo = base.GetWeekNumber();

            return (from a in testMaster
                    select new TestMaster
                    {
                        TestId = a.ARTR_Id,
                        TestName = a.ARTR_Name,
                    }).ToList();
        }
        finally { }
    }

Upvotes: 1

J&#248;rn Wildt
J&#248;rn Wildt

Reputation: 4482

GET is useful for SAFE(*) operations where you do not need to pass many parameters to the server - all of the parameters must be in the URL as GET operations do not pass data in the HTTP body.

POST is useful for UNSAFE(*) operations or operations where you need to pass large amounts of data to the server as the data can be passed in the HTTP body.

Use GET for simple queries and calculations with few parameters. Use POST for large payloads or operations that change server state (such as updating something or performing complex bussiness operations).

See the HTTP method definitions in RFC 7231 for more in-depth information.

(*) SAFE operations are operations that do not change (visible) server state. UNSAFE operations do change (visible) server state.

Upvotes: 2

cassiomolin
cassiomolin

Reputation: 130877

The POST verb seems to be what you want.

If I understand correctly, you want to send a JSON from the client to server. Then the server will modify the JSON and return it to the client.

In REST APIs, POST is commonly used to create a new resource. But it's also a catch-all verb for operations that should not be executed using the other methods.

For more details on using POST to invoke arbitrary processing, have a look at this answer.

Upvotes: 1

Mango Wong
Mango Wong

Reputation: 649

GET

It seems that your just want to retrieve data in a meaningful representation (response after processing) from the raw data (request from the caller). There is no modification / insertion of data, so GET should be use.

Upvotes: 1

Related Questions