MODEL:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web;

namespace DelonixRegiaServicesUpdated.Models
{
    public class BookingRoomDetails
    {
        public int Id { get; set; }
        [Required]
        public string guestFirstName { get; set; }
        public string guestLastName { get; set; }
        public int guestContactNumber { get; set; }
        public string guestEmailAddress { get; set; }
        public string guestCreditCardNumber { get; set; }
        public int roomNumber { get; set; }
        public int numberOfRooms { get; set; }
        public int totalNumberOfGuests { get; set; }
        public string roomType { get; set; }
        public string checkInDate { get; set; }
        public string checkOutDate { get; set; }
        public string checkInTime { get; set; }
        public string checkOutTime { get; set; }

    }
}

GLOBAL:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Http;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
using DelonixRegiaServicesUpdated.Utilities;

namespace DelonixRegiaServicesUpdated
{
    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            GlobalConfiguration.Configuration.MessageHandlers.Add(new CorsHandler());
        }
    }
}

CONTROLLER:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http;
using System.Web.Http.Description;
using DelonixRegiaServicesUpdated.Models;

namespace DelonixRegiaServicesUpdated.Controllers
{
    public class BookingRoomDetailsController : ApiController
    {
        private DelonixRegiaServicesUpdatedContext db = new DelonixRegiaServicesUpdatedContext();

        // GET: api/BookingRoomDetails
        public IQueryable<BookingRoomDetails> GetBookingRoomDetails()
        {
            return db.BookingRoomDetails;
        }

        // GET: api/BookingRoomDetails/5
        [ResponseType(typeof(BookingRoomDetails))]
        public async Task<IHttpActionResult> GetBookingRoomDetails(int Id)
        {
            BookingRoomDetails bookingRoomDetails = await db.BookingRoomDetails.FindAsync(Id);
            if (bookingRoomDetails == null)
            {
                return NotFound();
            }

            return Ok(bookingRoomDetails);
        }

        // PUT: api/BookingRoomDetails/5
        [ResponseType(typeof(void))]
        public async Task<IHttpActionResult> PutBookingRoomDetails(int Id, BookingRoomDetails bookingRoomDetails)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (Id != bookingRoomDetails.Id)
            {
                return BadRequest();
            }

            db.Entry(bookingRoomDetails).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!BookingRoomDetailsExists(Id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

        // POST: api/BookingRoomDetails
        [ResponseType(typeof(BookingRoomDetails))]
        public async Task<IHttpActionResult> PostBookingRoomDetails(BookingRoomDetails bookingRoomDetails)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            db.BookingRoomDetails.Add(bookingRoomDetails);
            await db.SaveChangesAsync();

            return CreatedAtRoute("DefaultApi", new { Id = bookingRoomDetails.Id }, bookingRoomDetails);
        }

        // DELETE: api/BookingRoomDetails/5
        [ResponseType(typeof(BookingRoomDetails))]
        public async Task<IHttpActionResult> DeleteBookingRoomDetails(int Id)
        {
            BookingRoomDetails bookingRoomDetails = await db.BookingRoomDetails.FindAsync(Id);
            if (bookingRoomDetails == null)
            {
                return NotFound();
            }

            db.BookingRoomDetails.Remove(bookingRoomDetails);
            await db.SaveChangesAsync();

            return Ok(bookingRoomDetails);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }

        private bool BookingRoomDetailsExists(int Id)
        {
            return db.BookingRoomDetails.Count(e => e.Id == Id) > 0;
        }
    }
}

CONFIGURATION:
namespace DelonixRegiaServicesUpdated.Migrations
{
    using System;
    using System.Data.Entity;
    using System.Data.Entity.Migrations;
    using System.Linq;
    using DelonixRegiaServicesUpdated.Models;
    using System.IO;


    internal sealed class Configuration : DbMigrationsConfiguration<DelonixRegiaServicesUpdated.Models.DelonixRegiaServicesUpdatedContext>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = false;
        }

        protected override void Seed(DelonixRegiaServicesUpdated.Models.DelonixRegiaServicesUpdatedContext context)
        {
            context.BookingRoomDetails.AddOrUpdate(x => x.Id,
            new BookingRoomDetails() { Id = 1, guestFirstName = "Jane", guestLastName = "Tan", guestContactNumber = 96712752, guestEmailAddress = "janetan@hotmail.com", guestCreditCardNumber = "5413 2968 2018 2300", roomNumber = 100, numberOfRooms = 2, totalNumberOfGuests = 4, roomType = "Suite", checkInDate = "4 July 2017", checkOutDate = "7 July 2017", checkInTime = "1200hrs", checkOutTime = "1500hrs" },
            new BookingRoomDetails() { Id = 2, guestFirstName = "Priya", guestLastName = "Kumar", guestContactNumber = 83710172, guestEmailAddress = "priyakumar@hotmail.com", guestCreditCardNumber = "5798 7379 6282 6718", roomNumber = 101, numberOfRooms = 1, totalNumberOfGuests = 4, roomType = "Duplex", checkInDate = "10 July 2017", checkOutDate = "14 July 2017", checkInTime = "1300hrs", checkOutTime = "1300 hrs" },
            new BookingRoomDetails() { Id = 3, guestFirstName = "Mohammad", guestLastName = "Hafiz", guestContactNumber = 82512962, guestEmailAddress = "mohammadhafiz@hotmail.com", guestCreditCardNumber = "5411 3748 2691 0324", roomNumber = 102, numberOfRooms = 1, totalNumberOfGuests = 2, roomType = "Double", checkInDate = "10 July 2017", checkOutDate = "14 July 2017", checkInTime = "1300hrs", checkOutTime = "1300 hrs" },
            new BookingRoomDetails() { Id = 4, guestFirstName = "Adam", guestLastName = "Saleh", guestContactNumber = 96780128, guestEmailAddress = "adamsaleh@hotmail.com", guestCreditCardNumber = "5142 9637 2138 3011", roomNumber = 103, numberOfRooms = 1, totalNumberOfGuests = 2, roomType = "Twin", checkInDate = "21 July 2017", checkOutDate = "24 July 2017", checkInTime = "1800hrs", checkOutTime = "1500 hrs" },
            new BookingRoomDetails() { Id = 5, guestFirstName = "John", guestLastName = "Lim", guestContactNumber = 80122731, guestEmailAddress = "johnlim@hotmail.com", guestCreditCardNumber = "5382 2962 3140 0481", roomNumber = 104, numberOfRooms = 1, totalNumberOfGuests = 2, roomType = "Suite", checkInDate = " 2 August 2017", checkOutDate = "8 August 2017", checkInTime = "2100hrs", checkOutTime = "1200 hrs" });

        }
    }
}

CORSHANDLER

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Net;

namespace DelonixRegiaServicesUpdated.Utilities
{
    public class CorsHandler : DelegatingHandler
    {
        const string Origin = "Origin";
        const string AccessControlRequestMethod = "Access-Control-Request-Method";
        const string AccessControlRequestHeaders = "Access-Control-Request-Headers";
        const string AccessControlAllowOrigin = "Access-Control-Allow-Origin";
        const string AccessControlAllowMethods = "Access-Control-Allow-Methods";
        const string AccessControlAllowHeaders = "Access-Control-Allow-Headers";

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            bool isCorsRequest = request.Headers.Contains(Origin);
            bool isPreflightRequest = request.Method == HttpMethod.Options;
            if (isCorsRequest)
            {
                if (isPreflightRequest)
                {
                    HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
                    response.Headers.Add(AccessControlAllowOrigin, request.Headers.GetValues(Origin).First());

                    string accessControlRequestMethod = request.Headers.GetValues(AccessControlRequestMethod).FirstOrDefault();
                    if (accessControlRequestMethod != null)
                    {
                        response.Headers.Add(AccessControlAllowMethods, accessControlRequestMethod);
                    }

                    string requestedHeaders = string.Join(", ", request.Headers.GetValues(AccessControlRequestHeaders));
                    if (!string.IsNullOrEmpty(requestedHeaders))
                    {
                        response.Headers.Add(AccessControlAllowHeaders, requestedHeaders);
                    }

                    TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
                    tcs.SetResult(response);
                    return tcs.Task;
                }
                else
                {
                    return base.SendAsync(request, cancellationToken).ContinueWith<HttpResponseMessage>(t =>
                    {
                        HttpResponseMessage resp = t.Result;
                        resp.Headers.Add(AccessControlAllowOrigin, request.Headers.GetValues(Origin).First());
                        return resp;
                    });
                }
            }
            else
            {
                return base.SendAsync(request, cancellationToken);
            }
        }
    }

}

BUNDLE CONFIG:

using System.Web;
using System.Web.Optimization;

namespace DelonixRegiaServicesUpdated
{
    public class BundleConfig
    {
        // For more information on bundling, visit http://go.microsoft.com/fwlink/?LinkId=301862
        public static void RegisterBundles(BundleCollection bundles)
        {
            bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
                        "~/Scripts/jquery-{version}.js"));

            // Use the development version of Modernizr to develop with and learn from. Then, when you're
            // ready for production, use the build tool at http://modernizr.com to pick only the tests you need.
            bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
                        "~/Scripts/modernizr-*"));

            bundles.Add(new ScriptBundle("~/bundles/bootstrap").Include(
                      "~/Scripts/bootstrap.js",
                      "~/Scripts/respond.js"));

            bundles.Add(new StyleBundle("~/Content/css").Include(
                      "~/Content/bootstrap.css",
                      "~/Content/site.css"));
        }
    }
}