CRUD Operation With Angular 5 HTTP Client And ASP.NET Core Web API

 HTTP is the messaging system between the client and the server-client that sends the request and server responds with the proper message. Angular HTTP client is the toolkit which enables us to send and receive the data over the RESTful HTTP endpoints. In Angular 4.3, this Angular HTTP API was provided which in the extension to the existing API providing some new feature and added to its own package of the @angular/common/http

Let’s divide this article into two sections - the first one being the Angular part and UI part while the second one is the Server-side code which will hold the API part of the project.

Client-side setup

To make the HTTP client module available in the application, we must make sure it is included and configured properly in the application. Let’s see step by step how we can do this.

Import the HTTP client module in the application module or root module. So, our root module is app.module.ts.

1. import { BrowserModule } from '@angular/platform-browser';  
2. import { NgModule } from '@angular/core';  
3. import { HttpClientModule } from '@angular/common/http';  
4. import {FormsModule} from '@angular/forms'  
5. import { AppComponent } from './app.component';  
6. @NgModule({  
7.   declarations: [  
8.     AppComponent,  
9.   ],  
10.   imports: [  
11.     BrowserModule,HttpClientModule,FormsModule  
12.   ],  
13.   providers: [],  
14.   bootstrap: [AppComponent]  
15. })  
16. export class AppModule { }  

Now, we have imported the HTTP Client into our application. We can use them in our component easily. For this demo, we are using the simple Employee as an entity and we are going to demo the Get, Post, Put and Delete Requests. For this demo purpose, let's add one component in our Angular application.

In my case, I have added the component Employee. The component looks like below.

1. <div class="container">  
2.   <h3>Employee List</h3>  
3.   <table class="table table-condensed">  
4.     <thead>  
5.       <tr>  
6.         <td>    </td>  
7.         <td>     </td>  
8.         <td>     </td>  
9.         <td>     </td>  
10.         <td>  <a (click)="ShowRegForm(e)">Add New</a></td>  
11.       </tr>  
12.       <tr>  
13.         <th>ID</th>  
14.         <th>First Name</th>  
15.         <th>Last Name</th>  
16.         <th>Email</th>  
17.         <th>Edit</th>  
18.       </tr>  
19.     </thead>  
20.     <tbody>  
21.       <tr class="success" *ngFor="let e of employeelist ">  
22.         <td> {{e.id}}</td>  
23.         <td>{{e.fname}}</td>  
24.         <td>{{e.lname}}</td>  
25.         <td>{{e.email}}</td>  
26.         <td><a (click)="ShowRegForm(e)">Edit</a></td>  
27.         <td><a (click)="ShowRegFormForDelete(e)">Delete</a></td>  
28.       </tr>  
29.     </tbody>  
30.   </table>  
31. </div>  
32. <hr >  
33.   
34. <form #regForm="ngForm">  
35. <div class="container" *ngIf="editCustomer">  
36.   <h3>{{FormHeader}}</h3>  
37.   <table class="table table-condensed">  
38.     <tbody>  
39.       <tr>  
40.         <td>First Name</td>  
41.         <td><input type="text" name="fname" [(ngModel)]='fname' ></td>  
42.         </tr>  
43.         <tr>  
44.         <td>Last Name</td>  
45.         <td><input type="text" name="lname" [(ngModel)]='lname'></td>  
46.         </tr>  
47.         <tr>  
48.         <td> Email</td>  
49.         <td><input type="text" name="email" [(ngModel)]='email'></td>  
50.         </tr>  
51.         <tr>  
52.         <td><input type="hidden" name="id" [(ngModel)]='id'></td>  
53.         <td><input type="button" value="Save" (click)="Save(regForm)"></td>  
54.   
55.       </tr>  
56.     </tbody>  
57.   </table>  
58.  </div>  
59. </form>  

Code Description

Here, we have an HTML page which has provision to display the List of the employees present in the database and then the Option to Add, Edit, List and Delete

Here based on the Button input the Form Header will be set according to the operation such as delete, add and edit.

Next step is the component itself and we have done the code for that

Import Statements

1. import { Component, OnInit } from '@angular/core';  
2. import {NgForm} from '@angular/forms'  
3. import {FormsModule} from '@angular/forms'  
4. import { Observable } from 'rxjs/Observable';  
5. import 'rxjs/add/operator/do';  
6. import 'rxjs/add/operator/filter';  
7. import 'rxjs/add/operator/map';  
8.   
9. import {EmployeeDataService} from '../DataServices/EmployeeDataService';  
10. import {employee} from '../Models/Employee';  

These are the basic imports that we can see here out of them, the others being the basic imports. We have some interesting imports like do, filter and map -- these are the operators which are used to transform the result that we get from the service

Another section we have is the Data Service part and the Modal part we have EmployeeDataService which we have created to handle the Data related operations .

Constructor and injecting the Data Service

Here we have used the Employee Data Service in our application to use it we have used the DI and injected it in constructor like below

1. constructor(private dataservice:EmployeeDataService) // Available at imports  
2.    {   
3.    }  

Next section is the code which we are using to call the data services as below

1. ngOnInit()  
2.    {  
3.      this.dataservice.getEmployee().subscribe((tempdate) =>{  this.employeelist=tempdate;})  
4.      ,err=>{  
5.        console.log(err);  
6.      }  
7.    }  
8.   ShowRegForm=function(employee)  
9.   {  
10.     this.editCustomer=true;  
11.     if(employee!=null)  
12.     {  
13.       this.SetValuesForEdit(employee)  
14.       
15.     }  
16.     else{  
17.       this.ResetValues();  
18.     }  
19.   }  
20.   
21.   ShowRegFormForDelete=function(employee)  
22.   {  
23.     this.editCustomer=true;  
24.     if(employee!=null)  
25.     {  
26.       this.SetValuesForDelete(employee)  
27.       
28.     }  
29.   }  
30.   
31.   SetValuesForDelete=function(employee)  
32. {  
33.   this.fname=employee.fname;  
34.   this.lname=employee.lname;  
35.   this.email=employee.email;  
36.   this.id=employee.id;  
37.   this.FormHeader="Delete"  
38.     
39. }  
40. //Function to set the values for edit form  
41. SetValuesForEdit=function(employee)  
42. {  
43.   this.fname=employee.fname;  
44.   this.lname=employee.lname;  
45.   this.email=employee.email;  
46.   this.id=employee.id;  
47.   this.FormHeader="Edit"  
48. }  
49. //Function to reset the values   
50. ResetValues(){  
51.   this.fname="";  
52.   this.lname="";  
53.   this.email="";  
54.   this.id="";  
55.   this.FormHeader="Add"  
56. }  
57. //Common function for the Operation   
58.   Save(regForm:NgForm)  
59.   {  
60.     this.GetDummyObject(regForm);  
61.   
62.     switch(this.FormHeader)  
63.     {  
64.     case "Add":  
65.            this.Addemployee(this.Dummyemployee);  
66.     break;  
67.     case "Edit":  
68.           this.UpdateEmployee(this.Dummyemployee);  
69.     break;  
70.     case "Delete":  
71.           this.DeleteEmployee(this.Dummyemployee);  
72.     break;  
73.            default:  
74.     break;  
75.   
76.     }  
77.   }  
78.   
79. GetDummyObject(regForm:NgForm):employee  
80. {  
81.   this.Dummyemployee= new employee  
82.   this.Dummyemployee.Email=regForm.value.email;  
83.   this.Dummyemployee.Fname=regForm.value.fname;  
84.   this.Dummyemployee.Lname=regForm.value.lname;  
85.   this.Dummyemployee.ID=regForm.value.id;  
86.   return this.Dummyemployee;  
87. }  
88.   Addemployee(e: employee)  
89.   {  
90.     this.dataservice.AddEmployee(this.Dummyemployee).subscribe(res=>  
91.       {  
92.         this.employeelist.push(res);  
93.         alert("Data added successfully !! ")  
94.         this.editCustomer=false;  
95.       })  
96.       ,err=>  
97.       {  
98.         console.log("Error Occured " + err);  
99.       }  
100.   }  
101.   
102.   UpdateEmployee(e: employee)  
103.   {  
104.     this.dataservice.EditEmployee(this.Dummyemployee).subscribe(res=>  
105.       {  
106.           this.editCustomer=false;  
107.           this.dataservice.getEmployee().subscribe(res=>{  
108.           this.employeelist=res;  
109.           });  
110.           alert("Employee data Updated successfully !!")  
111.       });  
112.   }  
113.   
114.   DeleteEmployee(e: employee)  
115.   {  
116.     this.dataservice.DeleteEmployee(this.Dummyemployee).subscribe(res=>  
117.       {  
118.         this.editCustomer=false;  
119.       this.dataservice.getEmployee().subscribe(res=>{  
120.                 this.employeelist=res;  
121.         });  
122.         alert("employee Deleted successfully !! ")  
123.       });  
124.   }  

We can see that we have called the get employee method from the ngOnInit Event of the component instead of calling in the constructor we have specifically done this to avoid the delay in loading of the component

Next, we have methods like Addemployee(),DeleteEmployee(),UpdateEmployee() which are  used for the calling the Data service methods from the application like Add Edit and Delete Employees

Other methods are the supplementary methods which are used to clear the inputs and  setting the object.

Next thing that we have used in our application is the Config.ts file Code for the same is as follows

1. export const ROOT_URL:string="http://localhost:39029/api/";  

Here in this code we have defined the Root_URL as the constant which holds the value of the API address. Next is the Model employee.ts which we use to map the Data which we are sending and receiving from the API code snippet for the same is

1. export interface employee{  
2.     ID:string;  
3.     Fname:string;  
4.     Lname:string;  
5.     Email:string;  
6.   
7. }  

Main and most important part of the application is the Data service which we have used

Code snippet for the same is as follows.

1. import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';  
2. import { Observable } from 'rxjs/Observable';  
3. import 'rxjs/add/operator/map';  
4. import 'rxjs/add/operator/catch';  
5. import 'rxjs/add/operator/retry';  
6. import 'rxjs/add/observable/of';  
7. import 'rxjs/Rx';  
8.   
9. import {employee} from '../Models/Employee';  
10. import {ROOT_URL} from '../Models/Config';  
11. import { Injectable }   from '@angular/core';  
12.   
13. @Injectable()  
14. export class EmployeeDataService  
15.   
16. {  
17.     employees: Observable<employee[]>;  
18.     newemployee:Observable<employee>;  
19.     
20.     constructor(private http:HttpClient)  
21.     {  
22.   
23.     }  
24. getEmployee()  
25. {  
26.  return this.http.get<employee[]>(ROOT_URL + '/Employees')  
27. }  
28. AddEmployee(emp:employee)  
29. {  
30.   
31.   const headers = new HttpHeaders().set('content-type', 'application/json');  
32.   var body = {  
33.                     Fname:emp.Fname,Lname:emp.Lname,Email:emp.Email  
34.              }  
35.   
36. return this.http.post<employee>(ROOT_URL+'/Employees',body,{headers})  
37.   
38. }  
39.   
40. EditEmployee(emp:employee)  
41. {  
42.     const params = new HttpParams().set('ID', emp.ID);  
43.   const headers = new HttpHeaders().set('content-type', 'application/json');  
44.   var body = {  
45.                     Fname:emp.Fname,Lname:emp.Lname,Email:emp.Email,ID:emp.ID  
46.              }  
47.         return this.http.put<employee>(ROOT_URL+'/Employees/'+emp.ID,body,{headers,params})  
48.   
49. }  
50.   
51.   
52.   
53. DeleteEmployee(emp:employee)  
54. {  
55.     const params = new HttpParams().set('ID', emp.ID);  
56.   const headers = new HttpHeaders().set('content-type', 'application/json');  
57.   var body = {  
58.                     Fname:emp.Fname,Lname:emp.Lname,Email:emp.Email,ID:emp.ID  
59.              }  
60.         return this.http.delete<employee>(ROOT_URL+'/Employees/'+emp.ID)  
61.   
62. }  
63. } 

This is the Data service class which we use to call the API. Let's see the methods and code description of the methods that are present in this class

To make the Http Client available in the class we have imported the http packages from common/http package which are as follows

1. Import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';  

In this Http client have the http method like get, post, put  etc.

HttpParams for sending the parameter to the methods like Put and delete

Another is the HttpHeaders which we can use to pass the Headers which can be used to pass the values 

Next is as every call to the Http client methods returns the Observable so we need to get the Observable package and some Transform method as well like below,

1. import 'rxjs/add/operator/map';  
2. import 'rxjs/add/operator/catch';  
3. import 'rxjs/add/operator/retry';  
4. import 'rxjs/add/observable/of';  
5. import 'rxjs/Rx';  

Next section is bringing the Employee model in application along with the App URL constant and @Injectable attribute so that we can inject this class as Dependency Injection to another class,

1. import {employee} from '../Models/Employee';  
2. import {ROOT_URL} from '../Models/Config';  
3. import { Injectable }   from '@angular/core';  

After making the class injectable we have Added the Http Client service as a dependency in the application using Constructor in that we have created the private variable http which is of type HttpClient 

First method we will see is the method getEmployee()

1. getEmployee()  
2. {  
3.  return this.http.get<employee[]>(ROOT_URL + '/Employees')  
4. }  

This method is returning the Observable of the employee after getting it from the API

One thing to notice here is that we are directly mapping the Response which we are getting from the API to the employee[] so Http Client allows us to map the response as a typed Response.

Next Method is the AddEmployee,

1. AddEmployee(emp:employee)  
2. {  
3.   const headers = new HttpHeaders().set('content-type', 'application/json');  
4.   var data = {Fname:emp.Fname,Lname:emp.Lname,Email:emp.Email}  
5. return this.http.post<employee>(ROOT_URL+'/Employees', data,{headers})  
6. }  

This method accepts the employee object which is our model object and receiving from the component.

In this Method  we have used the HttpHeaders to set the content type for the request  which is application/json. Next, we have converted the data from the Employee object in the JSON and then passed to the Post method of the http which is the verb of the HTTP

Post method has a signature like

Post(URL,Data Body,{Option data like Headers})

Another Operation is the EditEmployee which accepts the employee object as a parameter body of the method is as follows

1. EditEmployee(emp:employee)  
2. {  
3.     const params = new HttpParams().set('ID', emp.ID);  
4.     const headers = new HttpHeaders().set('content-type', 'application/json');  
5.   var body = {  
6.                     Fname:emp.Fname,Lname:emp.Lname,Email:emp.Email,ID:emp.ID  
7.              }  

return his.http.put<employee>(ROOT_URL+'/Employees/'+emp.ID,body,{headers,params})

In this method, we need the emp id as a parameter for the operation and we are passing it using the attribute HttpParams . we have set the Headers to the Application/json and converted the object to the json 

Next is the call the Put method of the http and it accepts the URL along with the Body header and parameter .

Last method to complete our CRUD application is the Delete Method which have following structure

1. DeleteEmployee(emp:employee)  
2. {  
3.     const params = new HttpParams().set('ID', emp.ID);  
4.   const headers = new HttpHeaders().set('content-type', 'application/json');  
5.   var body = {Fname:emp.Fname,Lname:emp.Lname,Email:emp.Email,ID:emp.ID}  
6.  return this.http.delete<employee>(ROOT_URL+'/Employees/'+emp.ID)  
7. }  

Here we again used the parameter for passing and for the delete the record we have set the headers and called the delete method of the http which will return the observable of the employee type and we can use it in the application

This was about the angular Code which we have used; let’s see some web Api code which we will be using in our application .

For this I have added new ASP.net core application enabling the web Api and without going into the details of adding the Web API and rest of the stuff will demonstrate some basic settings we dd to allow the angular app and avoid any CORS issues that may arise; for that we can check the Startup.cs which is as follows,

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Threading.Tasks;  
5. using Microsoft.AspNetCore.Builder;  
6. using Microsoft.AspNetCore.Hosting;  
7. using Microsoft.Extensions.Configuration;  
8. using Microsoft.Extensions.DependencyInjection;  
9. using Microsoft.Extensions.Logging;  
10. using Microsoft.Extensions.Options;  
11. using Microsoft.EntityFrameworkCore;  
12.   
13. namespace AngularWebAPI  
14. {  
15.     public class Startup  
16.     {  
17.         public Startup(IConfiguration configuration)  
18.         {  
19.             Configuration = configuration;  
20.         }  
21.   
22.         public IConfiguration Configuration { get; }  
23.   
24.         // This method gets called by the runtime. Use this method to add services to the container.  
25.         public void ConfigureServices(IServiceCollection services)  
26.         {  
27.             services.AddMvc();  
28.             services.AddCors();  
29.             services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer("Your Connection string"));  
30.             services.AddCors(options =>  
31.             {  
32.                 options.AddPolicy("CorsPolicy",  
33.                     builder => builder.AllowAnyOrigin()  
34.                     .AllowAnyMethod()  
35.                     .AllowAnyHeader()  
36.                     .AllowCredentials());  
37.             });  
38.         }  
39.   
40.         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.  
41.         public void Configure(IApplicationBuilder app, IHostingEnvironment env)  
42.         {  
43.             if (env.IsDevelopment())  
44.             {  
45.                 app.UseDeveloperExceptionPage();  
46.             }  
47.         app.UseCorsMiddleware();  
48.             app.UseMvc();  
49.             app.UseCors("CorsPolicy");  
50.         }  
51.     }  
52. }  

In this startup we have added the MVC Entity Framework and other stuff to run the application along with we have added one policy for the CORS which will allow the request from any origin

Also we have added one middleware which will handle the incoming request. CORS issues code for the same can be like below

1. using Microsoft.AspNetCore.Builder;  
2. using Microsoft.AspNetCore.Http;  
3. using System.Threading.Tasks;  
4.   
5. public class CorsMiddleware  
6. {  
7.     private readonly RequestDelegate _next;  
8.   
9.     public CorsMiddleware(RequestDelegate next)  
10.     {  
11.         _next = next;  
12.     }  
13.   
14.     public Task Invoke(HttpContext httpContext)  
15.     {  
16.         httpContext.Response.Headers.Add("Access-Control-Allow-Origin", "*");  
17.         httpContext.Response.Headers.Add("Access-Control-Allow-Credentials", "true");  
18.         httpContext.Response.Headers.Add("Access-Control-Allow-Headers", "Content-Type, Accept");  
19.         httpContext.Response.Headers.Add("Access-Control-Allow-Methods", "POST,GET,PUT,PATCH,DELETE,OPTIONS");  
20.         return _next(httpContext);  
21.     }  
22. }  
23.   
24. // Extension method used to add the middleware to the HTTP request pipeline.  
25. public static class CorsMiddlewareExtensions  
26. {  
27.     public static IApplicationBuilder UseCorsMiddleware(this IApplicationBuilder builder)  
28.     {  
29.         return builder.UseMiddleware<CorsMiddleware>();  
30.     }  
31. }  

This is middleware which adds the Headers in the incoming request and adds it in the Request pipeline.

In this API we are Using the Code First Approach of the Entity framework; here our model class will be employee which will be like below

1. namespace AngularWebAPI.Models  
2. {  
3.     public class Employee  
4.     {  
5.         public int ID { get; set; }  
6.         public string Fname { get; set; }  
7.         public string  Lname { get; set; }  
8.         public string email { get; set; }  
9.     }  
10. }  

Next is Adding the controller which will be a Web API controller and we can use this class to map all the operations and use them accordingly

1. namespace AngularWebAPI.Controllers  
2. {  
3.     [Produces("application/json")]  
4.     [Route("api/Employees")]  
5.     public class EmployeesController : Controller  
6.     {  
7.         private readonly ApplicationDbContext _context;  
8.   
9.         public EmployeesController(ApplicationDbContext context)  
10.         {  
11.             _context = context;  
12.         }  
13.   
14.         // GET: api/Employees  
15.         [HttpGet]  
16.         public IEnumerable<Employee> Getemployee()  
17.         {  
18.             return _context.employee;  
19.         }  
20.   
21.         // GET: api/Employees/5  
22.         [HttpGet("{id}")]  
23.         public async Task<IActionResult> GetEmployee([FromRoute] int id)  
24.         {  
25.             if (!ModelState.IsValid)  
26.             {  
27.                 return BadRequest(ModelState);  
28.             }  
29.   
30.             var employee = await _context.employee.SingleOrDefaultAsync(m => m.ID == id);  
31.   
32.             if (employee == null)  
33.             {  
34.                 return NotFound();  
35.             }  
36.   
37.             return Ok(employee);  
38.         }  
39.   
40.         // PUT: api/Employees/5  
41.         [HttpPut("{id}")]  
42.         public async Task<IActionResult> PutEmployee([FromRoute] int id, [FromBody] Employee employee)  
43.         {  
44.             if (!ModelState.IsValid)  
45.             {  
46.                 return BadRequest(ModelState);  
47.             }  
48.   
49.             if (id != employee.ID)  
50.             {  
51.                 return BadRequest();  
52.             }  
53.   
54.             _context.Entry(employee).State = EntityState.Modified;  
55.   
56.             try  
57.             {  
58.                 await _context.SaveChangesAsync();  
59.             }  
60.             catch (DbUpdateConcurrencyException)  
61.             {  
62.                 if (!EmployeeExists(id))  
63.                 {  
64.                     return NotFound();  
65.                 }  
66.                 else  
67.                 {  
68.                     throw;  
69.                 }  
70.             }  
71.   
72.             return NoContent();  
73.         }  
74.   
75.         // POST: api/Employees  
76.         [HttpPost]  
77.         public async Task<IActionResult> PostEmployee([FromBody] Employee employee)  
78.         {  
79.             if (!ModelState.IsValid)  
80.             {  
81.                 return BadRequest(ModelState);  
82.             }  
83.   
84.             _context.employee.Add(employee);  
85.             await _context.SaveChangesAsync();  
86.   
87.             return CreatedAtAction("GetEmployee", new { id = employee.ID }, employee);  
88.         }  
89.   
90.         // DELETE: api/Employees/5  
91.         [HttpDelete("{id}")]  
92.         public async Task<IActionResult> DeleteEmployee([FromRoute] int id)  
93.         {  
94.             if (!ModelState.IsValid)  
95.             {  
96.                 return BadRequest(ModelState);  
97.             }  
98.   
99.             var employee = await _context.employee.SingleOrDefaultAsync(m => m.ID == id);  
100.             if (employee == null)  
101.             {  
102.                 return NotFound();  
103.             }  
104.   
105.             _context.employee.Remove(employee);  
106.             await _context.SaveChangesAsync();  
107.   
108.             return Ok(employee);  
109.         }  
110.   
111.         private bool EmployeeExists(int id)  
112.         {  
113.             return _context.employee.Any(e => e.ID == id);  
114.         }  
115.     }  
116. }  

This is the web api controller which we use for all the database operations, as we are using the database we can apply the migration and generate the table in the database.

Note

We can use a better approach for handling the database operation like repository and using DTO this is just for the explanation and to check how it works .

When we run the application we can see the output like below .

When we click the Add New it will Open this form

Same form will be used for the rest of the Operation.

This was about the using Http Client to read, add, delete and update the employee data in the database. We have used the Asp.net web API core for the Web API we have added the Middleware to avoid the CORS issues in this we have used the EF Code first approach for interacting with the database.

Source code can be found at the following locations

1. Angularcode
2. web API

References

• https://blog.angularindepth.com/the-new-angular-httpclient-api-9e5c85fe3361
• https://medium.com/codingthesmartway-com-blog/angular-4-3-httpclient-accessing-rest-web-services-with-angular-2305b8fd654b
• https://Angular.io