Building Serverless API's Using Azure Functions And C#

#region Function Get Employees
        /// <summary>
        /// Get List of Employees
        /// </summary>
        /// <param name="req"></param>
        /// <param name="log"></param>
        /// <returns></returns>
        [FunctionName("GetAllEmployees")]
        public async Task<IActionResult> GetAllEmployees(
        [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)]
          HttpRequest req, ILogger log)
        {
            try
            {
                log.LogInformation("Getting Employee list items");
                return new OkObjectResult(await _appDbContext.Employee.ToListAsync());
            }
            catch (System.Exception)
            {
                throw;
            }
            
        }
        #endregion

Line - 8: Added Name for the Function name attribute.

Line - 9: Defining a Function (Method)

Line - 10: Attribute Property for HTTP Trigger.

• AuthorizationLevel - Azure Function protects your HTTP trigger using Authorization keys. Authorization Level comes in three flavors
  1. Anonymous: No key is required.
  2. Function: A specific function key is required. This is the default value if none is specified.
  3. Admin: A master key is required.
• Route - It defines the route template on which the endpoint is listening. The default value of the route is set to api/<FunctionName>.
• Method - This is used to define HTTP verbs for the functions.

Line 13- 21: Adding try catch block to handle the exceptions and fetching all the Employee data from the Database.

CreateEmployee

 #region Create Employee
        /// <summary>
        /// Create New Employee
        /// </summary>
        /// <param name="req"></param>
        /// <param name="log"></param>
        /// <returns></returns>
        [FunctionName("CreateEmployee")]
        public async Task<IActionResult> CreateEmployee(
        [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = Route +"/Create")]
          HttpRequest req, ILogger log)
        {
            log.LogInformation("Creating a new employee list item");
            var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            var input = JsonConvert.DeserializeObject<Employee>(requestBody);
            var employee = new Employee { Name = input.Name, Designation = input.Designation,City= input.City };
            await _appDbContext.Employee.AddAsync(employee);
            await _appDbContext.SaveChangesAsync();
            return new OkObjectResult(new { Message = "Record Saved SuccessFully", Data = employee });
        }
        #endregion

GetEmployeebyId

 #region Get Employee Based on Employee Id
        /// <summary>
        /// Get Employee by Querying with Id
        /// </summary>
        /// <param name="req"></param>
        /// <param name="log"></param>
        /// <param name="Id"></param>
        /// <returns></returns>
        [FunctionName("GetEmployeebyId")]
        public async Task<IActionResult> GetEmployeebyId(
        [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "{Id}")]
          HttpRequest req, ILogger log, int Id)
        {
            try
            {
                var result = await _appDbContext.Employee.FindAsync(Id);
                if (result is null)
                {
                    log.LogInformation($"Item {Id} not found");
                    return new NotFoundResult();
                }
                return new OkObjectResult(result);
            }
            catch (System.Exception)
            {
                throw;
            }
        }
        #endregion

UpdateEmployee

  #region Update Employee
      /// <summary>
      /// Update Employee - Changes
      /// </summary>
      /// <param name="req"></param>
      /// <param name="log"></param>
      /// <param name="Id"></param>
      /// <returns></returns>
        [FunctionName("UpdateEmployee")]
        public async Task<IActionResult> UpdateEmployee(
        [HttpTrigger(AuthorizationLevel.Anonymous, "put", Route = Route +"/Update")]
          HttpRequest req, ILogger log)
        {
            log.LogInformation("Updating a new employee list item");
            var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            var updated = JsonConvert.DeserializeObject<Employee>(requestBody);
            var employee = await _appDbContext.Employee.FindAsync(updated.Id);
            if(employee is null)
            {
                log.LogError($"Item {updated.Id} not found");
                return new NotFoundResult();
            }
            if(!string.IsNullOrEmpty(updated.Name) && !string.IsNullOrEmpty(updated.Designation))
            {
                employee.Name = updated.Name; employee.Designation = updated.Designation;
                employee.City = updated.City;
            }
            _appDbContext.Employee.Update(employee);
            await _appDbContext.SaveChangesAsync();
            return new OkObjectResult(new { Message = "Record Updated SuccessFully", Data = employee });
        }
        #endregion

DeleteEmployee

#region Delete Employee
        /// <summary>
        /// Deletion of Employee
        /// </summary>
        /// <param name="req"></param>
        /// <param name="log"></param>
        /// <param name="Id"></param>
        /// <returns></returns>
        [FunctionName("DeleteEmployee")]
        public async Task<IActionResult> DeleteEmployee(
        [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "DeleteEmployee/{Id}")]
          HttpRequest req, ILogger log,int Id)
        {
            log.LogInformation("Updating a new employee list item");
            var employee = await _appDbContext.Employee.FindAsync(Id);
            if (employee is null)
            {
                log.LogError($"Item {Id} not found");
                return new NotFoundResult();
            }
            _appDbContext.Employee.Remove(employee);
            await _appDbContext.SaveChangesAsync();
            return new OkObjectResult("Record Deleted !");
        }
        #endregion

Finally, we have managed to put all the code changes in place. Run the application and verify the all the methods are working as expected in the Postman. After running the application all our functions will be loaded in the terminal because the Azure Functions will use the Storage emulator to fetch the responses inside the terminal.

Funtion Run Time Version - The target framework we choosed at the time of Azure Function setup.

Now Listening on - The Port Number in which the Azure functions are running (7071).

Testing the APIs using Postman

Let's create the Employee First using the CreateEmployee API using Postman

How this actually works?

We were fetching the req body from the HTTP Trigger and attaching the Json to our Employee model class for deserialization and then passing the Employee object to the Database which you can see in the CreateEmployee Function.

Fetch the List of Employees from the GetEmployee API.

Update the Existing Record using the UpdateEmployee API and here in this object the Employee Id is mandatory. Based on Id we are fetching the existing record from the Db and updating the Same record with new object.

Delete the Record from the Database by passing the EmployeeId as Query Parameter in the route.

Conclusion

In this article, we learned how to implement the Serverless APIs using the Azure Functions and integrating with the Database by using the Entity Framework Core Dependency Injection. Thanks for staying until the end.

Thank you for reading, please let me know your questions, thoughts, or feedback in the comments section. I appreciate your feedback and encouragement.

Keep learning....!