Asp.net Core2 Web API with AngularJs6

Core API Introduction
- I will explain about Asp.net Core Web API2
1) How to create project?
2) Setup Program.cs file
3) First setup for startup.cs file
4) Add migration
5) Add repository pattern
6) Entity framework
7) Database connection
8) Call your repository in the controller
9) Run API in Postman

Step 1

Step 2

Change code in the Program.cs file

using System.IO;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;

namespace ProjectsManagementSystem
{
    public class Program
    {
        public static void Main(string[] args)
        {
            BuildWebHost(args).Run();
        }

        public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .ConfigureAppConfiguration(SetUpConfiguration)
            .UseIISIntegration()
            .ConfigureKestrel(option=>option.AddServerHeader = false)
            .UseContentRoot(Directory.GetCurrentDirectory())               
                .Build();

        private static void SetUpConfiguration(WebHostBuilderContext ctx, IConfigurationBuilder builder)
        {
            //Remove the default configration options
            builder.Sources.Clear();
            builder.AddJsonFile("config.json", false, true)
                .AddEnvironmentVariables();
        }
    }
}

Step 3 Startup.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
using Newtonsoft.Json.Serialization;
using ProjectsManagementSystem.Data;
using ProjectsManagementSystem.Data.Repository;
using ProjectsManagementSystem.Helpers;

namespace ProjectsManagementSystem
{
    public class Startup
    {
        private readonly IConfiguration _config;
        private readonly IHostingEnvironment _env;


        public Startup(IConfiguration config, IHostingEnvironment env)
        {
            this._config = config;
            this._env = env;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {

            services.AddDbContext<ProjectsManageContext>(cfg =>
            {
                cfg.UseSqlServer(_config.GetConnectionString("ConnectionString"));
            });

            services.AddMvc();
            services.AddScoped<IDomainInfoRepository, DomainInfoRepository>();
            services.AddScoped<IDomainsRepository, DomainsRepository>();
            services.AddScoped<IUserInfoRepository, UserInfoRepository>();
            services.AddScoped<IHolidaysInfoRepository, HolidaysInfoRepository>();
            services.AddScoped<IFTPDetailsRepository, FTPDetailsRepository>();
            services.AddScoped<ILeaveManageInfoRepository, LeaveManageRepository>();

            services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddJwtBearer(options =>
            {
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuer = true,
                    ValidateAudience = true,
                    ValidateLifetime = true,
                    ValidateIssuerSigningKey = true,                   
                    ValidIssuer = "http://localhost:5000/",
                    ValidAudience = "http://localhost:5000/",
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("superSecretKey@345"))
                };

                //ValidIssuer = "http://localhost:8081/",
                //ValidAudience = "http://localhost:8081/",
                //ValidIssuer = "http://domaininfoapi.bexcodeservices.com/",
                //ValidAudience = "http://domaininfoapi.bexcodeservices.com/",

            });

            services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
            {
                builder.AllowAnyOrigin()
                       .AllowAnyMethod()
                       .AllowAnyHeader()
                       .AllowCredentials();
                //builder.WithOrigins("http://domaininfo.bexcodeservices.com", "http://domaininfoapi.bexcodeservices.com");
                builder.WithOrigins("http://localhost:4200", "http://localhost:5000");

            }));

            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

            services.AddMvc().AddJsonOptions(options =>
            {
                // we need this
                options.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
                options.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
            });
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            //If you use app.UserDefaultFiles() will directly run defaul index file from wroot no need to describ in Url
            app.UseDefaultFiles();
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseHsts();
            }
            app.UseStaticFiles();
            //You able to run any static html file from Wroot directry

            app.UseAuthentication();
            app.UseHttpsRedirection();
            app.UseMvc(cfg =>
            {
                cfg.MapRoute("Default", "{controller}/{action}/{id?}",
                  new { controller = "App", Action = "Index" });
            });
            app.UseCors("MyPolicy");
        }
    }
}

===============================================================

Step 4  Add Migration

- Create one folder called Data
   -> In Data create folder Entities
   -> In Data create folder Repository

Migration Command
Add-Migration InitialCreate (First time)
Update-Database (Update database)
Add-Migration AddProductReviews (Second time with file name)

For more about Migration please visite link 
https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/ 

Entities Sample

 public class UserInfo
    {
        public int ID { get; set; }
        public string Username { get; set; }
        public string Password { get; set; }
        public string Email { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string RollType { get; set; }
        public string Telegram { get; set; }
        public string ContactNo { get; set; }
        public string Skype { get; set; }
        public string EmployeeStatus { get; set; }
        public bool IsActive { get; set; }
        public string Token { get; set; }

    }

-----------------------------------------------------------------------------------------

Step 5 Add repository pattern (Repository Sample)

using ProjectsManagementSystem.Data.Entities;
using ProjectsManagementSystem.ViewModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace ProjectsManagementSystem.Data.Repository
{
    public class DomainInfoRepository : IDomainInfoRepository
    {
        private readonly ProjectsManageContext _ctx;

        public DomainInfoRepository(ProjectsManageContext ctx)
        {
            this._ctx = ctx;
        }
        public IEnumerable<DomainInfo> GetAllDomainInfo()
        {
            try
            {
                return _ctx.DomainInfo.Where(z => z.parentID == 0 && z.isActive == true).OrderBy(p => p.domainName).ToList();
            }
            catch (Exception)
            {
                throw;
            }
        }
        public IEnumerable<DomainInfo> GetAllSubDomainInfo(int ParentId)
        {
            try
            {
                return _ctx.DomainInfo.Where(z => z.parentID == ParentId && z.isActive == true).OrderBy(p => p.domainName).ToList();
            }
            catch (Exception)
            {
                throw;
            }
        }
        public DomainInfo GetDomainInfoById(int id)
        {
            try
            {
                DomainInfo domainInfo = new DomainInfo();
                domainInfo = _ctx.DomainInfo.Where(p => p.id == id).FirstOrDefault();
                if (domainInfo != null)
                {
                    return domainInfo;
                }
                else return domainInfo;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public bool AddEntity(DomainInfo domainInfo)
        {
            _ctx.DomainInfo.Add(domainInfo);
            return _ctx.SaveChanges() > 0;
        }

        public bool UpdateEntity(DomainInfo domainInfo, int Id)
        {
            var domainInfoOld = _ctx.DomainInfo.Where(z => z.id == Id).FirstOrDefault();
            if (domainInfo != null)
            {
                domainInfoOld.id = domainInfo.id;
                domainInfoOld.hostingExpiryDate = domainInfo.hostingExpiryDate;
                domainInfoOld.hostingOn = domainInfo.hostingOn;
                domainInfoOld.isActive = domainInfo.isActive;
                domainInfoOld.projectManageBy = domainInfo.projectManageBy;
                domainInfoOld.projectPath = domainInfo.projectPath;
                domainInfoOld.registerOn = domainInfo.registerOn;
                domainInfoOld.sSLCertificationAccount = domainInfo.sSLCertificationAccount;
                domainInfoOld.sSLRegisterAccountPass = domainInfo.sSLRegisterAccountPass;
                domainInfoOld.sSLRegisterAccountUser = domainInfo.sSLRegisterAccountUser;
                domainInfoOld.technologyUsed = domainInfo.technologyUsed;
                domainInfoOld.updatedBy = domainInfo.updatedBy;
                domainInfoOld.updatedDate = domainInfo.updatedDate;
                domainInfoOld.userID = domainInfo.userID;
                domainInfoOld.expiryDate = domainInfo.expiryDate;
                domainInfoOld.domainRegisterUserID = domainInfo.domainRegisterUserID;
                domainInfoOld.domainRegisterPassword = domainInfo.domainRegisterPassword;
                domainInfoOld.domainRegisterAccountPin = domainInfo.domainRegisterAccountPin;
                domainInfoOld.domainRegisterAccountCustomerID = domainInfo.domainRegisterAccountCustomerID;
                domainInfoOld.domainName = domainInfo.domainName;
                domainInfoOld.databaseUserName = domainInfo.databaseUserName;
                domainInfoOld.databaseType = domainInfo.databaseType;
                domainInfoOld.databaseServerName = domainInfo.databaseServerName;
                domainInfoOld.databasePassword = domainInfo.databasePassword;
                domainInfoOld.databaseName = domainInfo.databaseName;
                domainInfoOld.currentProjectStatus = domainInfo.currentProjectStatus;
                domainInfoOld.createdDate = domainInfo.createdDate;
                domainInfoOld.cpanelUserName = domainInfo.cpanelUserName;
                domainInfoOld.cpanelPassword = domainInfo.cpanelPassword;
                return _ctx.SaveChanges() > 0;
            }
            return false;
        }

        public bool DeleteRecord(int Id)
        {
            try
            {
                var domainInfoOld = _ctx.DomainInfo.Where(z => z.id == Id).FirstOrDefault();
                if (domainInfoOld != null)
                {
                    domainInfoOld.isActive = false;
                    int test = _ctx.SaveChanges();

                    return _ctx.SaveChanges() > 0;
                }
                else
                {
                    return false;
                }

            }
            catch (Exception ex)
            {
                return false;
            }

        }

        public DomainHistoryModel domainHistory()
        {
            DomainHistoryModel _domainHistory = new DomainHistoryModel();
            int DomainCount = _ctx.DomainInfo.Where(z => z.parentID == 0).OrderBy(p => p.domainName).Count();
            int SubDomainCount = _ctx.DomainInfo.Where(z => z.parentID != 0).OrderBy(p => p.domainName).Count();
            int SSLCount = _ctx.DomainInfo.Where(z => z.sSLCertificationAccount != null).OrderBy(p => p.domainName).Count();
            int FTPCount = _ctx.FTPofDomain.Count();
            int ProjectsCount = _ctx.DomainInfo.Count();

            _domainHistory.DomainsCount = DomainCount;
            _domainHistory.FTPsCount = FTPCount;
            _domainHistory.ProjectCount = ProjectsCount;
            _domainHistory.SSLCount = SSLCount;
            _domainHistory.SubDomainCount = SubDomainCount;
            return _domainHistory;
        }
    }
} 

Step 6 Entity framework

 Install Entity framework using NugetPackate

Step 7 Database connection

create config.json on root and replace code as per bellow

{
  "ConnectionStrings": {
    "ConnectionString": "Data Source=servername;Initial Catalog=databasename;Persist Security info=True;user id=sa;password=password;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    }
  }
}

Step 8 Call your repository in the controller

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.Mvc;
using ProjectsManagementSystem.Data.Entities;
using ProjectsManagementSystem.Data.Repository;
using ProjectsManagementSystem.ViewModel;

namespace ProjectsManagementSystem.Controllers
{
    [Route("api/[controller]")]
    [EnableCors("MyPolicy")]
   
    public class DomainInfoController : Controller
    {
        private readonly IDomainInfoRepository _domainInfoRepository;
        private readonly IDomainsRepository _domainsRepository;
        public DomainInfoController(IDomainInfoRepository domainInfoRepository, IDomainsRepository domainsRepository)
        {
            this._domainInfoRepository = domainInfoRepository;
            this._domainsRepository = domainsRepository;
        }
        // GET api/values
        [HttpGet, Authorize]
        public IActionResult Get()
        {
            var DomainInfo = _domainInfoRepository.GetAllDomainInfo();
            List<DomainInfoViewModel> domainInfoView = new List<DomainInfoViewModel>();
            foreach (var item in DomainInfo)
            {
                var row = new DomainInfoViewModel
                {
                    DatabaseName = item.databaseName,
                    DomainName = item.domainName,
                    ID = item.id,
                    ProjectManageBy = item.projectManageBy,
                    DomainRegisterAccountCustomerID = item.domainRegisterAccountCustomerID,
                    ExpiryDate = item.expiryDate.Date.ToString("MM/dd/yyyy"),
                    RegisterOn = item.registerOn

                };
                domainInfoView.Add(row);
            }
            return Ok(domainInfoView);
        }

        [HttpGet("DomainsList"), Authorize]
        public IActionResult DomainsList()
        {
            List<Domains> domainsList = new List<Domains>();
            domainsList = _domainsRepository.GetAllDomains().ToList();
            //domainsList.Insert(0, new Domains() { DomainName = "Choose a domain", ID = 0 });
            return Ok(domainsList);
        }

        [HttpGet("AllChildDomains/{ParentId}")]
        public IActionResult GetAllChildDomains_Projects(int ParentId)
        {
            var DomainInfo = _domainInfoRepository.GetAllSubDomainInfo(ParentId);
            List<ProjectsViewModel> domainInfoView = new List<ProjectsViewModel>();
            foreach (var item in DomainInfo)
            {
                var row = new ProjectsViewModel
                {
                    DatabaseName = item.databaseName,
                    DomainName = item.domainName,
                    ID = item.id,
                    ProjectManageBy = item.projectManageBy,
                    CurrentProjectStatus = item.currentProjectStatus,
                    SourceCodePath = item.projectPath,
                    TechnologyUsed = item.technologyUsed
                };
                domainInfoView.Add(row);
            }
            return Ok(domainInfoView);
        }

        // GET api/values/5
        [HttpGet("{id}"), Authorize]
        public IActionResult Get(int id)
        {
            var DomainInfo = _domainInfoRepository.GetDomainInfoById(id);
            return Ok(DomainInfo);
        }

        // POST api/values
        [HttpPost, Authorize]
        public IActionResult Post([FromBody]DomainInfo model)
        {
            if (_domainInfoRepository.AddEntity(model)) { return Ok("Domain " + model.domainName + "Added Successfully"); }
            else { return BadRequest(); }
        }

        // PUT api/values/5
        [HttpPut("{id}"), Authorize]
        public IActionResult Put(int id, [FromBody]DomainInfo model)
        {
            if (_domainInfoRepository.UpdateEntity(model, id)) { return Ok("Domain " + model.domainName + "Updated Successfully"); }
            else { return BadRequest("Operation fail"); }
        }

        // DELETE api/values/5
        [HttpDelete("{id}"), Authorize]
        public IActionResult Delete(int id)
        {
            if (_domainInfoRepository.DeleteRecord(id)) { return Ok("Deleted Successfully"); }
            else { return BadRequest(); }
        }

        [HttpGet("DomainHistory"), Authorize]
        public IActionResult DomainHistory()
        {
            DomainHistoryModel domainHistory = new DomainHistoryModel();
            domainHistory = _domainInfoRepository.domainHistory();
            return Ok(domainHistory);
        }


  
    }
}