# Create a Web API Over Salesforce

## Content



This topic guides you through the steps of creating a WebAPI over Salesforce data.

### Create a Web API project

1.  Open Visual Studio, select **Create a new project**.
2.  From the available list of project templates, choose the **ASP.NET Core Web API** template and click **Next**.
3.  In the **Configure your new project** window, set the project name to **SalesforceAPI,** assign an appropriate location and click **Next**.
4.  In the **Additional Information** dialog, select the framework from **Target Framework,** set it to **.NET Core** **3.1** and click **Create**.

### Install NuGet Packages

After successfully creating the project, add the required NuGet packages for working with Salesforce data using DataConnectors, specifically with Salesforce .Net DataConnector.

To get started we must install the following NuGet Packages in the Web API project from NuGet:

*   **C1.AdoNet.Salesforce**
*   **C1.EntityFrameworkCore.Salesforce**
*   **Microsoft.EntityFrameworkCore.Tools**

### Add a Model Class and a Database Context

Now, let's generate the model class and database context for each table that we are looking forward to interact with, via WebAPI. ComponentOne DataConnectors support Scaffolding to generate the model and database context classes, as described in [Scaffolding](/componentone/docs/services/online-dataconnector/scaffolding).

Here, we are using the same scaffolding approach to automatically generate the Model and database context class for **Customer\_\_c** table. The following steps guide you on how to generate and register the model and database context classes:

1.  In **Solution Explorer**, right-click the project. Select **Add** | **New Folder**. Name the new folder **Models** and execute the following scaffold command to generate the Model and Context classes in the Models folder. Please note the command below does not specify the actual values for the connection string attributes, you must replace the placeholders with the true values.
    
    ```COMMAND
    Scaffold-DbContext "Username = *****; Password = *****; Security Token = *****; OAuth Client Id = *****; OAuth Client Secret = *****; OAuth Token Endpoint = https://ap16.salesforce.com/services/oauth2/token; Url=https://ap16.salesforce.com/services/data/v42.0; Use Cache = 'true'; Cache provider = 'Microsoft.Data.SqlClient'; Cache connection = 'Server=*****;Database=*****;User Id=*****;Password=*****;'" C1.EntityFrameworkCore.Salesforce -OutputDir "Models" -Context CustomerContext -Tables Customer__c
    ```
    
    In the above command, we are connecting to the database using SQL Server Cache to further enhance the DataConnector performance. For details on Salesforce DataConnector caching refer to Salesforce [caching](/componentone/docs/services/online-dataconnector/ado.net-provider-for-salesforce/salesforcecaching).
    
2.  Register the database context in **Startup.cs** file by adding the following code in **ConfigureServices** method:
    
    ```csharp
    public void ConfigureServices(IServiceCollection services) 
    { 
    services.AddControllers(); 
    string connectionString = @"Username = ******; Password = ******; Security Token = ******; OAuth Client Id = ******; OAuth Client Secret = ******; OAuth Token Endpoint = https://ap16.salesforce.com/services/oauth2/token; Url=https://ap16.salesforce.com/services/data/v42.0; Use Cache = 'true'; Cache provider = 'Microsoft.Data.SqlClient'; Cache connection = 'Server=******;Database=******;User Id=******;Password=******;'"; 
    services.AddDbContext<CustomerContext>(opt => opt.UseSalesforce(connectionString)); 
    }
    ```
    

### Scaffold a Controller with CRUD Methods

Define the CRUD methods in an API controller using the standard VS scaffolder. The following steps guide you with the same:

1.  Right-click the **Controllers** folder and select **Add** | **New Scaffolded Item**.
    
2.  Select **API Controller with actions, using Entity Framework**, and then select **Add**.
    
    ![](https://cdn.mescius.io/document-site-files/images/0d302e1a-ed9a-4636-b2ab-ee6e2f9613d8/images/add-scaffolder.png)
    
3.  In the **Add API Controller with actions, using Entity Framework** dialog, select **CustomerC (SalesforceAPI.Models)** in the **Model class** and **CustomerContext (SalesforceAPI.Models)** in the **Data context class.**
4.  Click **Add** button to add the controller and automatically generate all the CRUD methods to work on Salesforce data. The code snippet below depicts the generated controller:
    
    ```CONTROLLER
    using System; 
    using System.Collections.Generic; 
    using System.Linq; 
    using System.Threading.Tasks; 
    using Microsoft.AspNetCore.Http; 
    using Microsoft.AspNetCore.Mvc; 
    using Microsoft.EntityFrameworkCore; 
    using SalesforceAPI.Models; 
    namespace SalesforceAPI.Controllers 
    { 
    [Route("api/[controller]")] 
    [ApiController] 
    public class CustomerCsController : ControllerBase 
    { 
    private readonly CustomerContext _context; 
    public CustomerCsController(CustomerContext context) 
    { 
    _context = context; 
    } 
    // GET: api/CustomerCs 
    [HttpGet] 
    public async Task<ActionResult<IEnumerable<CustomerC>>> GetCustomerC() 
    { 
    return await _context.CustomerC.ToListAsync(); 
    } 
    // GET: api/CustomerCs/5 
    [HttpGet("{id}")] 
    public async Task<ActionResult<CustomerC>> GetCustomerC(string id) 
    { 
    var customerC = await _context.CustomerC.FindAsync(id); 
    if (customerC == null) 
    { 
    return NotFound(); 
    } 
    return customerC; 
    } 
    // PUT: api/CustomerCs/5 
    // To protect from overposting attacks, enable the specific properties you want to bind to, for 
    // more details, see https://go.microsoft.com/fwlink/?linkid=2123754. 
    [HttpPut("{id}")] 
    public async Task<IActionResult> PutCustomerC(string id, CustomerC customerC) 
    { 
    if (id != customerC.Id) 
    { 
    return BadRequest(); 
    } 
    _context.Entry(customerC).State = EntityState.Modified; 
    try 
    { 
    await _context.SaveChangesAsync(); 
    } 
    catch (DbUpdateConcurrencyException) 
    { 
    if (!CustomerCExists(id)) 
    { 
    return NotFound(); 
    } 
    else 
    { 
    throw; 
    } 
    } 
    return NoContent(); 
    } 
    // POST: api/CustomerCs 
    // To protect from overposting attacks, enable the specific properties you want to bind to, for 
    // more details, see https://go.microsoft.com/fwlink/?linkid=2123754. 
    
    [HttpPost] 
    public async Task<ActionResult<CustomerC>> PostCustomerC(CustomerC customerC) 
    { 
    _context.CustomerC.Add(customerC); 
    await _context.SaveChangesAsync(); 
    return CreatedAtAction("GetCustomerC", new { id=customerC.Id }, customerC); 
    } 
    // DELETE: api/CustomerCs/5 
    [HttpDelete("{id}")] 
    public async Task<ActionResult<CustomerC>> DeleteCustomerC(string id) 
    { 
    var customerC = await _context.CustomerC.FindAsync(id); 
    if (customerC == null) 
    { 
    return NotFound(); 
    } 
    _context.CustomerC.Remove(customerC); 
    await _context.SaveChangesAsync(); 
    return customerC; 
    } 
    private bool CustomerCExists(string id) 
    { 
    return _context.CustomerC.Any(e => e.Id == id); 
    } 
    } 
    }
    ```
    

The controller implements the **GET, GET(ID), PUT, POST** and **DELETE** methods to perform the **Read**, **Update**, **Create** and **Delete** operations over the Salesforce data respectively.

This completes the creation of a WebAPI over Salesforce. In the next step, we set the startup path of the application to execute and test the working of this API.

### Update the launchUrl

To launch the WebAPI on project execution, update **launchUrl** from "**weatherforecast**" to "**api/CustomerCs**" in **Properties | launchSettings.json** file as depicted in the screenshot below:

`![](https://cdn.mescius.io/document-site-files/images/0d302e1a-ed9a-4636-b2ab-ee6e2f9613d8/images/launchsetting-json.png)`

The WebAPI project is now ready to compile and execute.

On project execution, the **READ** method from the controller which is equivalent to invoking the **GET** method of API is invoked. It returns all the records from the **Customer\_\_c** table as depicted in the screenshot below:

`![](https://cdn.mescius.io/document-site-files/images/0d302e1a-ed9a-4636-b2ab-ee6e2f9613d8/images/project-execution.png)`

Similarly, you can invoke the **GET(id)** method by passing the id column value of a particular row as a parameter in the browser request. Refer to the screenshot below which depicts the same:

![](https://cdn.mescius.io/document-site-files/images/0d302e1a-ed9a-4636-b2ab-ee6e2f9613d8/images/browser-request.png)

All the other methods of the API i.e. **PUT, POST** and **DELETE** cannot be executed directly in the browser. Either use an API platform to test the methods in the browser or create a JS application to invoke the methods and display the results.

The sections ahead describes both these approaches of consuming an API in detail.