Add project files.

CarParkValidationAPI/Repository/AdminUserFakeRepository.cs

@@ -0,0 +1,199 @@
+//using BCryptNet = BCrypt.Net.BCrypt;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using CarParkValidationAPI.Authorization;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Helpers;
+using CarParkValidationAPI.Models.Users;
+using CarParkValidationAPI.Models;
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Interface;
+using Microsoft.EntityFrameworkCore;
+using System;
+
+namespace CarParkValidationAPI.Repository
+{
+    public class AdminUserFakeRepository : IAdminUser
+	{
+        private DataContext _context;
+		List<AdminUserDto> _resultList = new List<AdminUserDto>();
+		private readonly AppSettings _appSettings;
+
+
+        public AdminUserFakeRepository(
+            DataContext context,
+
+            IOptions<AppSettings> appSettings)
+        {
+            _context = context;
+            _appSettings = appSettings.Value;
+        }
+
+        private AdminUserDto FillAdminUserDto(AdminUser model)
+        {
+			AdminUserDto dto = new AdminUserDto();
+			dto.Id = model.UserID;
+			dto.Name = model.Name;
+			dto.RoleType = model.RoleType;
+			dto.StafflinkNo = model.StafflinkNo;
+			dto.Active = model.Active;
+			dto.AddedBy = model.AddedBy;
+			dto.AddedOn = model.AddedOn;
+			return dto;
+        }
+
+		private AdminUser FillAdminUser(AdminUserDto dto, AdminUser model)
+		{
+
+			model.UserID = dto.Id;
+			model.Name = dto.Name;
+			model.RoleType = dto.RoleType;
+			model.StafflinkNo = dto.StafflinkNo;
+			model.Active = dto.Active;
+			model.AddedBy = dto.AddedBy;
+			model.AddedOn = dto.AddedOn;
+			return model;
+		}
+
+		public async Task<ResultModel<List<AdminUserDto>>> LoadAdminUserAsync(bool onlyActive)
+		{
+			/*
+			List<AdminUserDto> resultList = new List<AdminUserDto>();
+			try
+			{
+				var it = await _context.AdminUsers.AsQueryable().ToListAsync();
+
+				AdminUserDto dto;
+				for (int i = 0; i < it.Count; i++)
+				{
+					dto = FillAdminUserDto(it[i]);
+					resultList.Add(dto);
+				}
+				//var it = await Task.Run(() => _list);
+
+				return new ResultModel<List<AdminUserDto>>()
+				{
+					Data = resultList,
+					StateCode = 1
+				};
+
+			}
+			catch (Exception ex)
+			{
+				throw ex;
+			}
+			*/
+			for (int i =0; i < 10; i++)
+            {
+				AdminUserDto dto = new AdminUserDto();
+				dto.Id = i;
+				dto.Name = $"Name {i}";
+				dto.RoleType = AdminRole.Admin;
+				dto.StafflinkNo = $"{i+40000}";
+				dto.Active = true;
+				dto.AddedOn = DateTime.Today.AddDays(i);
+				dto.AddedBy = "ddfed";
+				_resultList.Add(dto);
+			}
+			return new ResultModel<List<AdminUserDto>>()
+			{
+				Data = _resultList,
+				StatusCode = 1
+			};
+		}
+		public async Task<ResultModel<AdminUserDto>> LoadAdminUserByIdAsync(int id)
+		{
+			AdminUserDto result = null;
+			/*
+			try
+            {
+				if (id > 0)
+                {
+					AdminUser model = await _context.AdminUsers.FindAsync(id);
+					result = FillAdminUserDto(model);
+
+                }
+            }
+			catch (Exception ex)
+            {
+				throw ex;
+            }
+			*/
+			int idx = _resultList.FindIndex(x => x.Id == id);
+			if (idx > -1)
+            {
+                result = _resultList[idx];
+            }
+
+            return new ResultModel<AdminUserDto>()
+			{
+				Data = result,
+				StatusCode = 1
+			};
+		}
+		public async Task<ResultModel<int>> SaveAdminUserAsync(AdminUserDto item)
+		{
+			int result = default(int);
+			try
+            {
+				AdminUser model;
+				if (item.Id > 0)
+                {
+					model = await _context.AdminUsers.FindAsync(item.Id);
+					model = FillAdminUser(item, model);
+					await _context.SaveChangesAsync();
+                }
+				else
+                {
+					model = new AdminUser();
+					model = FillAdminUser(item, model);
+					_context.AdminUsers.Add(model);
+					await _context.SaveChangesAsync();
+				}
+				result = 1;
+            }
+			catch (Exception ex)
+            {
+				result = -1;
+				throw ex;
+            }
+			
+			return new ResultModel<int>()
+			{
+				Data = result,
+				StatusCode = 1
+			};
+
+		}
+		
+		public async Task<ResultModel<bool>> DeleteAdminUserAsync(int id)
+		{
+			bool result = true;
+			
+			try
+			{
+				if (id > 0)
+				{
+				  AdminUser	model = await _context.AdminUsers.FindAsync(id);
+				  model.Active = false;
+				  await _context.SaveChangesAsync();
+				}
+			}
+			catch (Exception ex)
+			{
+				result = false;
+				throw ex;
+			}
+			
+			return new ResultModel<bool>()
+			{
+				Data = result,
+				StatusCode = 1
+			};
+		}
+
+
+	}
+}

CarParkValidationAPI/Repository/AdminUserRepository.cs

@@ -0,0 +1,196 @@
+//using BCryptNet = BCrypt.Net.BCrypt;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using CarParkValidationAPI.Authorization;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Helpers;
+using CarParkValidationAPI.Models.Users;
+using CarParkValidationAPI.Models;
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Interface;
+using Microsoft.EntityFrameworkCore;
+using System;
+
+namespace CarParkValidationAPI.Repository
+{
+    public class AdminUserRepository : IAdminUser
+	{
+        private DataContext _context;
+		
+		private readonly AppSettings _appSettings;
+
+
+        public AdminUserRepository(
+            DataContext context,
+
+            IOptions<AppSettings> appSettings)
+        {
+            _context = context;
+            _appSettings = appSettings.Value;
+        }
+
+        private AdminUserDto FillAdminUserDto(AdminUser model)
+        {
+			AdminUserDto dto = new AdminUserDto();
+			dto.Id = model.UserID;
+			dto.Name = model.Name;
+			dto.RoleType = model.RoleType;
+			dto.StafflinkNo = model.StafflinkNo;
+			dto.Active = model.Active;
+			dto.AddedBy = model.AddedBy;
+			dto.AddedOn = model.AddedOn;
+			return dto;
+        }
+
+		private AdminUser FillAdminUser(AdminUserDto dto, AdminUser model)
+		{
+
+			model.UserID = dto.Id;
+			model.Name = dto.Name;
+			model.RoleType = dto.RoleType;
+			model.StafflinkNo = dto.StafflinkNo;
+			model.Active = dto.Active;
+			model.AddedBy = dto.AddedBy;
+			model.AddedOn = dto.AddedOn;
+			return model;
+		}
+
+		public async Task<ResultModel<List<AdminUserDto>>> LoadAdminUserAsync(bool onlyActive)
+		{			
+			List<AdminUserDto> resultList = new List<AdminUserDto>();
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				//var list = await _context.AdminUsers.Where(x => x.Active == onlyActive).ToListAsync();
+				var list = await _context.AdminUsers.AsQueryable().ToListAsync();
+
+				AdminUserDto dto;
+				AdminUser user;
+				for (int i = 0; i < list.Count; i++)
+				{
+					user = list[i];					
+					dto = FillAdminUserDto(user);
+					resultList.Add(dto);
+					
+				}
+				statuscode = 1;
+			}
+			catch (Exception ex)
+			{
+				error = ex.ToString();
+				statuscode = 0;
+				throw ex;
+			}
+
+			return new ResultModel<List<AdminUserDto>>()
+			{
+				Data = resultList,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<AdminUserDto>> LoadAdminUserByIdAsync(int id)
+		{
+			AdminUserDto result = null;
+			int statuscode = 0;
+			string error = "";
+			try
+            {
+				if (id > 0)
+                {
+					AdminUser model = await _context.AdminUsers.FindAsync(id);
+					result = FillAdminUserDto(model);
+					statuscode = 1;
+                }
+            }
+			catch (Exception ex)
+            {
+				error = ex.ToString();
+				statuscode = 0;
+				throw ex;
+            }
+			
+            return new ResultModel<AdminUserDto>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<int>> SaveAdminUserAsync(AdminUserDto item)
+		{
+			int result = default(int);
+			int statuscode = 0;
+			string error = "";
+			try
+            {
+				AdminUser model;
+				if (item.Id > 0)
+                {
+					model = await _context.AdminUsers.FindAsync(item.Id);
+					model = FillAdminUser(item, model);
+					await _context.SaveChangesAsync();
+                }
+				else
+                {
+					model = new AdminUser();
+					model = FillAdminUser(item, model);
+					_context.AdminUsers.Add(model);
+					await _context.SaveChangesAsync();
+				}
+				result = 1;
+				statuscode = 1;
+            }
+			catch (Exception ex)
+            {
+				result = -1;
+				error = ex.ToString();
+				statuscode = 0;
+				throw ex;
+            }
+			
+			return new ResultModel<int>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		
+		public async Task<ResultModel<bool>> DeleteAdminUserAsync(int id)
+		{
+			bool result = true;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				if (id > 0)
+				{
+				  AdminUser	model = await _context.AdminUsers.FindAsync(id);
+				  model.Active = false;
+				  await _context.SaveChangesAsync();
+					statuscode = 1;
+				}
+			}
+			catch (Exception ex)
+			{
+				error = ex.ToString();
+				statuscode = 0;
+				result = false;
+				throw ex;
+			}
+			
+			return new ResultModel<bool>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+
+
+	}
+}

CarParkValidationAPI/Repository/ConcessionTypeRepository.cs

@@ -0,0 +1,184 @@
+//using BCryptNet = BCrypt.Net.BCrypt;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using CarParkValidationAPI.Authorization;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Helpers;
+using CarParkValidationAPI.Models.Users;
+using CarParkValidationAPI.Models;
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Interface;
+using Microsoft.EntityFrameworkCore;
+using System;
+
+namespace CarParkValidationAPI.Repository
+{
+    public class ConcessionTypeRepository : IConcessionType
+    {
+        private DataContext _context;
+    
+        private readonly AppSettings _appSettings;
+
+        public ConcessionTypeRepository(
+            DataContext context,
+          
+            IOptions<AppSettings> appSettings)
+        {
+            _context = context;            
+            _appSettings = appSettings.Value;
+        }
+
+		private ConcessionTypeDto FillConcessionTypeDto(ConcessionType model)
+        {
+			ConcessionTypeDto dto = new ConcessionTypeDto();
+			dto.Active = model.Active;
+			dto.Description = model.ConcessionDesc;
+			dto.Display = model.ConcessionDisplay;
+			dto.Id = model.ConcessionTypeID;
+			return dto;
+		}
+		private ConcessionType FillConcessionType(ConcessionTypeDto dto, ConcessionType model)
+		{			
+			model.Active = dto.Active;
+		    model.ConcessionDesc = dto.Description;
+			model.ConcessionDisplay = dto.Display;
+			model.ConcessionTypeID = dto.Id;
+			return model;
+		}
+		public async Task<ResultModel<List<ConcessionTypeDto>>> LoadConcessionTypeAsync(bool onlyActive)
+		{
+			List<ConcessionTypeDto> result = null;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				result = await _context.ConcessionTypes.Select(
+					x => new ConcessionTypeDto()
+					{
+						Id = x.ConcessionTypeID,
+						Description = x.ConcessionDesc,
+						Display = x.ConcessionDisplay,
+						Active = x.Active
+					}).ToListAsync();
+				statuscode = 1;
+			}
+			catch (Exception ex)
+			{
+				result = null;
+				error = ex.ToString();
+				statuscode = 0;
+				throw ex;
+			}
+			
+			return new ResultModel<List<ConcessionTypeDto>>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<ConcessionTypeDto>> LoadConcessionTypeByIdAsync(int id)
+		{
+			ConcessionType result = null;
+			int statuscode = 0;
+			string error = "";
+			ConcessionTypeDto dto;
+			try
+			{				
+				result = await _context.ConcessionTypes.FindAsync(id);
+				dto = FillConcessionTypeDto(result);
+				//result = _list.Find(x => x.Id == id);
+				//var dto = await Task.Run(() => result);
+				statuscode = 1;
+			}
+			catch (Exception ex)
+			{
+				error = ex.ToString();
+				statuscode = 0;
+				throw ex;
+			}
+			return new ResultModel<ConcessionTypeDto>()
+			{
+				Data = dto,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<int>> SaveConcessionTypeAsync(ConcessionTypeDto item)
+		{
+			int result = default(int);
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				ConcessionType model;
+				if (item.Id > 0)
+				{
+					model = await _context.ConcessionTypes.FindAsync(item.Id);
+					model = FillConcessionType(item, model);
+					await _context.SaveChangesAsync();
+					result = item.Id;
+				}
+				else //new record
+				{
+					model = new ConcessionType();
+					model = FillConcessionType(item, model);
+					_context.ConcessionTypes.Add(model);
+					var id = await _context.SaveChangesAsync();
+					result = id;
+					item.Id = id;
+				}
+				statuscode = 1;
+			}
+			catch (Exception ex)
+			{
+				error = ex.ToString();
+				statuscode = 0;
+				throw ex;
+			}
+			//var dto = await Task.Run(() => result);
+			return new ResultModel<int>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		
+		public async Task<ResultModel<bool>> DeleteConcessionTypeAsync(int id)
+		{
+			bool result = true;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				ConcessionType model;
+				if (id > 0)
+				{
+					model = await _context.ConcessionTypes.FindAsync(id);
+					model.Active = false;
+					//_context.ConcessionTypes.Remove(model);					
+					await _context.SaveChangesAsync();
+					statuscode = 1;
+				}
+			}
+			catch (Exception ex)
+			{
+				error = ex.ToString();
+				statuscode = 0;
+				throw;
+			}
+			//var dto = await Task.Run(() => result);
+			return new ResultModel<bool>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+
+
+	}
+}

CarParkValidationAPI/Repository/ConcessionValidationRepository.cs

@@ -0,0 +1,273 @@
+//using BCryptNet = BCrypt.Net.BCrypt;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using CarParkValidationAPI.Authorization;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Helpers;
+using CarParkValidationAPI.Models.Users;
+using CarParkValidationAPI.Models;
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Interface;
+using Microsoft.EntityFrameworkCore;
+using System;
+
+namespace CarParkValidationAPI.Repository
+{
+	public class ConcessionValidationRepository : IConcessionValidation
+	{
+		private DataContext _context;
+
+		private readonly AppSettings _appSettings;
+
+		public ConcessionValidationRepository(
+			DataContext context,
+
+			IOptions<AppSettings> appSettings)
+		{
+			_context = context;
+			_appSettings = appSettings.Value;
+		}
+
+		private ConcessionValidationDto FillConcessionValidationDto(ConcessionValidation model)
+		{
+			ConcessionValidationDto dto = new ConcessionValidationDto();
+			dto.Active = model.Active;
+			dto.ConcessionCard = model.ConcessionCard;
+			dto.ConcessionExpiry = model.ConcessionExpiry;
+			dto.ConcessionHolder = model.ConcessionHolder;
+			dto.ConcessionTypeId = model.ConcessionTypeID;
+			dto.Id = model.ValidationID;
+			dto.StafflinkNo = model.StafflinkNo;
+			dto.ValidateDate = model.ValidateDate;
+			dto.ValidationPointId = model.ValidationPointID;
+			return dto;
+		}
+
+		private ConcessionValidationExtDto FillConcessionValidationExtDto(ConcessionValidation model)
+		{
+			ConcessionValidationExtDto dto = new ConcessionValidationExtDto();
+			dto.Active = model.Active;
+			dto.ConcessionCard = model.ConcessionCard;
+			dto.ConcessionExpiry = model.ConcessionExpiry;
+			dto.ConcessionHolder = model.ConcessionHolder;
+			dto.ConcessionTypeId = model.ConcessionTypeID;
+			dto.Id = model.ValidationID;
+			dto.StafflinkNo = model.StafflinkNo;
+			dto.ValidateDate = model.ValidateDate;
+			dto.ValidationPointId = model.ValidationPointID;
+			return dto;
+		}
+
+		private ConcessionValidation FillConcessionValidation(ConcessionValidationDto dto, ConcessionValidation model)
+		{
+
+			model.Active = dto.Active;
+			model.ConcessionCard = dto.ConcessionCard;
+			model.ConcessionExpiry = dto.ConcessionExpiry;
+			model.ConcessionHolder = dto.ConcessionHolder;
+			model.ConcessionTypeID = dto.ConcessionTypeId;
+			model.ValidationID = dto.Id;
+			model.StafflinkNo = dto.StafflinkNo;
+			model.ValidateDate = dto.ValidateDate;
+			model.ValidationPointID = dto.ValidationPointId;
+			return model;
+		}
+		public async Task<ResultModel<List<ConcessionValidationExtDto>>> LoadConcessionValidationAsync(bool onlyActive)
+		{
+			int statuscode = 0;
+			string error = "";
+			List<ConcessionValidationExtDto> result = new List<ConcessionValidationExtDto>();
+			
+			ConcessionValidationExtDto dto;
+			ConcessionValidation model;			
+			try
+			{
+				List<ConcessionValidation> clist = await _context.ConcessionValidations.Where(x => x.Active == true).ToListAsync();
+				for (int i = 0; i < clist.Count; i++)
+				{
+					model = clist[i];
+					dto = FillConcessionValidationExtDto(model);
+					result.Add(dto);
+				}
+				statuscode = 1;
+			}
+			catch (Exception ex)
+			{
+				statuscode = 0;
+				error = ex.ToString();
+				throw;
+			}
+			
+			return new ResultModel<List<ConcessionValidationExtDto>>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+
+		public async Task<ResultModel<List<ConcessionValidationExtDto>>> LoadConcessionValidationStaffLinkNoAsync(string staffLinkNo, DateTime currentDate)
+		{
+			List<ConcessionValidationExtDto> result = new List<ConcessionValidationExtDto>();
+		//	ConcessionValidationExtDto dto;
+	//		ConcessionValidation model;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+
+				//List<ConcessionValidation> clist = await _context.ConcessionValidations.Where(x => 
+				//		x.Active == true
+				//		&& x.StafflinkNo == staffLinkNo 
+				//		&& x.ValidateDate.Date == currentDate.Date
+				//).ToListAsync();
+				result = await _context.SelectConcessionValidationByStaffId(true, staffLinkNo, currentDate, currentDate);
+				/*
+				//var clist = await _context.SPSelectValidation(true, staffLinkNo, currentDate);
+				for (int i = 0; i < clist.Count; i++)
+				{
+					model = clist[i];
+					dto = FillConcessionValidationExtDto(model);
+					result.Add(dto);
+
+				}
+				*/
+				statuscode = 1;
+
+			}
+			catch (Exception ex)
+			{
+				statuscode = 0;
+				error = ex.ToString();
+				throw;
+			}
+
+			return new ResultModel<List<ConcessionValidationExtDto>>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<ConcessionValidationDto>> LoadConcessionValidationByIdAsync(int id)
+		{
+			ConcessionValidationDto result = null;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				if (id > 0)
+				{
+					ConcessionValidation model = await _context.ConcessionValidations.FindAsync(id);
+					result = FillConcessionValidationDto(model);
+					statuscode = 1;
+				}
+
+			}
+			catch (Exception ex)
+			{
+				statuscode = 0;
+				error = ex.ToString();
+				throw;
+			}
+
+			return new ResultModel<ConcessionValidationDto>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<int>> SaveConcessionValidationAsync(ConcessionValidationDto item)
+		{
+			int result = default(int);
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				ConcessionValidation model;
+				if (item.Id > 0)
+				{
+					model = await _context.ConcessionValidations.FindAsync(item.Id);
+					model = FillConcessionValidation(item, model);
+					result = await _context.SaveChangesAsync();
+				}
+				else
+				{
+					model = new ConcessionValidation();
+					model = FillConcessionValidation(item, model);
+					_context.ConcessionValidations.Add(model);
+					result = await _context.SaveChangesAsync();
+				}
+				statuscode = 1;
+			}
+			catch (Exception ex)
+			{
+				statuscode = 0;
+				error = ex.ToString();
+				throw;
+			}
+
+
+			return new ResultModel<int>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+
+		}
+
+		public async Task<ResultModel<bool>> DeleteConcessionValidationAsync(int id)
+		{
+			bool result = true;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				if (id > 0)
+				{
+					ConcessionValidation model = await _context.ConcessionValidations.FindAsync(id);
+					model.Active = false;
+					await _context.SaveChangesAsync();
+					statuscode = 1;
+				}
+			}
+			catch (Exception ex)
+			{
+				result = false;
+				statuscode = 0;
+				error = ex.ToString();
+				throw;
+			}
+
+
+			return new ResultModel<bool>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<FileContent>> GetReport(DateTime fromDate, DateTime toDate)
+		{
+			int statusCode = 1;
+			string fileContext = "filecontain as string this is file contain in string format";
+			var result = new FileContent
+			{
+				Content = Convert.FromBase64String(fileContext),
+				FileName = "excel extension"
+			};
+			var task = await Task.Run(() => 1);
+			return new ResultModel<FileContent>
+			{
+				Data = result,
+				StatusCode = statusCode
+			};
+		}
+
+
+	}
+}

CarParkValidationAPI/Repository/LookupCodeRepository.cs

@@ -0,0 +1,92 @@
+//using BCryptNet = BCrypt.Net.BCrypt;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using CarParkValidationAPI.Authorization;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Helpers;
+using CarParkValidationAPI.Models.Users;
+using CarParkValidationAPI.Models;
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Interface;
+using Microsoft.EntityFrameworkCore;
+using System;
+
+namespace CarParkValidationAPI.Repository
+{
+	
+	public class LookupCodeRepository: ILookupCode
+	{
+        private DataContext _context;
+    
+        private readonly AppSettings _appSettings;
+
+        public LookupCodeRepository(
+            DataContext context,
+          
+            IOptions<AppSettings> appSettings)
+        {
+            _context = context;            
+            _appSettings = appSettings.Value;
+        }
+		public async Task<ResultModel<List<LookupCodeDto>>> LoadConcessionTypeAsync(bool onlyActive)
+		{
+			List<LookupCodeDto> result = null;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				result = await _context.ConcessionTypes.Where(x => x.Active == onlyActive).Select(
+					x => new LookupCodeDto()
+					{
+						Id = x.ConcessionTypeID,
+						Description = x.ConcessionDesc,
+
+					}).ToListAsync();
+				statuscode = 1;
+			}
+			catch (Exception ex)
+            {
+				statuscode = 0;
+				error = ex.ToString();
+				throw;
+            }
+			return new ResultModel<List<LookupCodeDto>>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<List<LookupCodeDto>>> LoadValidationPointAsync(bool onlyActive)
+		{
+			List<LookupCodeDto> result = null;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				result = await _context.Validations.Where(x => x.Active == onlyActive).Select(
+					x => new LookupCodeDto()
+					{
+						Id = x.ValidationPointID,
+						Description = x.Description
+					}).ToListAsync();
+				statuscode = 1;
+			}
+			catch (Exception ex)
+            {
+				statuscode = 0;
+				error = ex.ToString();
+				throw;
+            }
+			return new ResultModel<List<LookupCodeDto>>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		
+	}
+}

CarParkValidationAPI/Repository/UserFakeRepository.cs

@@ -0,0 +1,251 @@
+//using BCryptNet = BCrypt.Net.BCrypt;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using CarParkValidationAPI.Authorization;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Helpers;
+using CarParkValidationAPI.Models.Users;
+using CarParkValidationAPI.Models;
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Interface;
+using Microsoft.EntityFrameworkCore;
+using CommonAD.Models;
+using CommonAD;
+
+namespace CarParkValidationAPI.Repository
+{
+    public class UserFakeRepository : IUserService
+    {
+        private DataContext _context;
+        private IJwtUtils _jwtUtils;
+        private readonly AppSettings _appSettings;
+
+        public UserFakeRepository(
+            DataContext context,
+            IJwtUtils jwtUtils,
+            IOptions<AppSettings> appSettings)
+        {
+            _context = context;
+            _jwtUtils = jwtUtils;
+            _appSettings = appSettings.Value;
+          
+        }
+        public AuthenticateResponse Authenticate(AuthenticateRequest model)
+        {
+            var user = _context.Users.SingleOrDefault(x => x.Username == model.Username);
+
+            // validate
+            //  if (user == null || !BCryptNet.Verify(model.Password, user.PasswordHash))
+            if (user == null || (model.Password != user.PasswordHash))
+                throw new System.Exception("Username or password is incorrect");
+
+            // authentication successful so generate jwt token
+            var jwtToken = _jwtUtils.GenerateJwtToken(user);
+
+            return new AuthenticateResponse(user, jwtToken);
+        }
+        public async Task<ResultModel<AuthenticateResponse>> LoginApiAD(AuthenticateRequest model)
+        {
+            User user = new User();
+            int statusCode = 1;
+            if (model.Username.ToLower() == "admin")
+            {
+                user.FirstName = model.Username;
+                user.LastName = "LS Test";
+                user.Role = AdminRole.Admin;
+                user.Username = model.Username;
+            }
+            else
+            {
+                user.Username = model.Username;
+                user.FirstName = model.Username;
+                user.LastName = " LS Normal";
+                user.Role = AdminRole.Normal;
+            }
+
+            // authentication successful so generate jwt token
+            var jwtToken = _jwtUtils.GenerateJwtToken(user);
+
+            var retval = await Task.Run(() => new AuthenticateResponse(user, jwtToken));
+            return new ResultModel<AuthenticateResponse>()
+            {
+                Data = retval,
+                StatusCode = statusCode
+            };
+        }
+
+        public async Task<ResultModel<AuthenticateResponse>> NLoginApiAD(AuthenticateRequest model)
+        {
+            User myUser = null;
+            AuthenticateResponse retval = null;
+            int statuscode = 0;
+            string webAPIUrl = _appSettings.LoginWebAPI;
+            
+            var loginInfo = await CommonAD.WebAPIUtil.GetLoginADAsync(webAPIUrl, "CheckADCredentials", model.Username, model.Password);
+            if (loginInfo != null && loginInfo.result)
+            {
+                myUser = new User();
+                myUser.Email = loginInfo.Email;
+                myUser.FirstName = loginInfo.FirstName;
+                myUser.LastName = loginInfo.LastName;
+                myUser.Username = loginInfo.StafflinkNo;
+                //now check the adminuser table
+                var user = _context.AdminUsers.SingleOrDefault(x => x.StafflinkNo == model.Username);
+                if (user != null)
+                {
+                    myUser.Role = user.RoleType;
+                    myUser.Id = user.UserID;
+                }
+                else
+                    myUser.Role = AdminRole.Normal;
+
+                // validate
+                //  if (user == null || !BCryptNet.Verify(model.Password, user.PasswordHash))
+
+                // authentication successful so generate jwt token
+                var jwtToken = _jwtUtils.GenerateJwtToken(myUser);
+                statuscode = 1;
+                retval = new AuthenticateResponse(myUser, jwtToken);
+
+            }
+
+            return new ResultModel<AuthenticateResponse>()
+            {
+                Data = retval,
+                StatusCode = statuscode
+            };
+        }
+
+        public async Task<ResultModel<AuthenticateResponse>> LoginAD(AuthenticateRequest model)
+        {
+            User myUser = null;
+            AuthenticateResponse retval = null;
+            int statuscode = 0;
+            ADConfig adConfig = new ADConfig()
+            {
+                LDAPPassword = _appSettings.LDAPPassword,
+                LDAPPath = _appSettings.LDAPPath,
+                LDAPUser = _appSettings.LDAPUser,
+                ADTimeOutStr = _appSettings.ADTimeOut
+            };
+            myUser = await Task.Run(() => LoginADStaff(adConfig,model.Username, model.Password));
+            if (!string.IsNullOrEmpty(myUser.Username))
+            { 
+                statuscode = 1;           
+                // authentication successful so generate jwt token
+                var jwtToken = _jwtUtils.GenerateJwtToken(myUser);
+                
+                retval = new AuthenticateResponse(myUser, jwtToken);
+            }
+            return new ResultModel<AuthenticateResponse>()
+            {
+                Data = retval,
+                StatusCode = statuscode
+            };
+        }
+
+        public async Task<ResultModel<List<User>>> GetAllUsers()
+        {
+            var retval = await _context.Users.ToListAsync();
+            return new ResultModel<List<User>>()
+            {
+                Data = retval,
+                StatusCode = 1
+            };
+
+        }
+
+        public async Task<ResultModel<User>> GetById(int id) 
+        {
+            var user = await _context.Users.FindAsync(id);
+            if (user == null) throw new KeyNotFoundException("User not found");
+            return new ResultModel<User>()
+            {
+                Data = user,
+                StatusCode = 1
+            };
+        }
+        public async Task<ResultModel<User>> SearchApiStaff(string staffLinkNo)
+        {
+            User myUser = null;
+            int statuscode = 0;
+            string webAPIUrl = _appSettings.LoginWebAPI;
+            var loginInfo = await CommonAD.WebAPIUtil.SearchStaffAsync(webAPIUrl, "SearchStaff", staffLinkNo);
+            if (loginInfo != null && loginInfo.result)
+            {
+                myUser = new User();
+                myUser.Email = loginInfo.Email;
+                myUser.FirstName = loginInfo.FirstName;
+                myUser.LastName = loginInfo.LastName;
+                myUser.Username = loginInfo.StafflinkNo;
+                statuscode = 1;
+            }
+
+            return new ResultModel<User>()
+            {
+                Data = myUser,
+                StatusCode = statuscode
+            };
+           // return myUser;
+
+        }
+
+        public async Task<ResultModel<User>> SearchADStaff(string staffLinkNo)
+        {
+            int statuscode = 0;
+            ADConfig adConfig = new ADConfig()
+            {
+                LDAPPassword = _appSettings.LDAPPassword,
+                LDAPPath = _appSettings.LDAPPath,
+                LDAPUser = _appSettings.LDAPUser,
+                ADTimeOutStr = _appSettings.ADTimeOut
+            };
+            User myUser = await Task.Run(() => SearchADStaff(adConfig, staffLinkNo));
+            if (!string.IsNullOrEmpty(myUser.Username))
+                statuscode = 1;
+            return new ResultModel<User>()
+            {
+                Data = myUser,
+                StatusCode = statuscode
+            };
+
+
+        }
+        private User SearchADStaff(ADConfig adConfig, string username)
+        {
+
+            ADStaffLink staffLink = new ADStaffLink(adConfig);
+            MyADObject myADObj = staffLink.SearchStaff(username);
+            User user = new()
+            {
+                Username = myADObj.StafflinkNo,
+                Email = myADObj.Email,
+                FirstName = myADObj.FirstName,
+                LastName = myADObj.LastName
+            };
+            // myADObj.JobTitle;
+            return user;
+
+            // return null;
+        }
+        private User LoginADStaff(ADConfig adConfig, string username, string password)
+        {
+
+            ADStaffLink staffLink = new ADStaffLink(adConfig);
+            MyADObject myADObj = staffLink.CheckADCredentials(username,password);
+            User user = new()
+            {
+                Username = myADObj.StafflinkNo,
+                Email = myADObj.Email,
+                FirstName = myADObj.FirstName,
+                LastName = myADObj.LastName
+            };
+            // myADObj.JobTitle;
+            return user;
+
+            // return null;
+        }
+    }
+}

CarParkValidationAPI/Repository/UserRepository.cs

@@ -0,0 +1,223 @@
+//using BCryptNet = BCrypt.Net.BCrypt;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using CarParkValidationAPI.Authorization;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Helpers;
+using CarParkValidationAPI.Models.Users;
+using CarParkValidationAPI.Models;
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Interface;
+using Microsoft.EntityFrameworkCore;
+using CommonAD.Models;
+using CommonAD;
+
+namespace CarParkValidationAPI.Repository
+{
+    public class UserRepository : IUserService
+    {
+        private DataContext _context;
+        private IJwtUtils _jwtUtils;
+        private readonly AppSettings _appSettings;
+
+        public UserRepository(
+            DataContext context,
+            IJwtUtils jwtUtils,
+            IOptions<AppSettings> appSettings)
+        {
+            _context = context;
+            _jwtUtils = jwtUtils;
+            _appSettings = appSettings.Value;
+          
+        }
+
+        public AuthenticateResponse Authenticate(AuthenticateRequest model)
+        {
+            var user = _context.Users.SingleOrDefault(x => x.Username == model.Username);
+
+        // validate
+        //  if (user == null || !BCryptNet.Verify(model.Password, user.PasswordHash))
+        if (user == null || (model.Password != user.PasswordHash))
+        throw new System.Exception("Username or password is incorrect");
+
+            // authentication successful so generate jwt token
+            var jwtToken = _jwtUtils.GenerateJwtToken(user);
+
+            return new AuthenticateResponse(user, jwtToken);
+        }
+
+        public async Task<ResultModel<AuthenticateResponse>> LoginApiAD(AuthenticateRequest model)
+        {
+            User myUser = null;
+            AuthenticateResponse retval = null;
+            int statuscode = 0;
+            string webAPIUrl = _appSettings.LoginWebAPI;
+            
+            var loginInfo = await CommonAD.WebAPIUtil.GetLoginADAsync(webAPIUrl, "CheckADCredentials", model.Username, model.Password);
+            if (loginInfo != null && loginInfo.result)
+            {
+                myUser = new User();
+                myUser.Email = loginInfo.Email;
+                myUser.FirstName = loginInfo.FirstName;
+                myUser.LastName = loginInfo.LastName;
+                myUser.Username = loginInfo.StafflinkNo;
+                //now check the adminuser table
+                var user = _context.AdminUsers.SingleOrDefault(x => x.StafflinkNo == model.Username);
+                if (user != null)
+                {
+                    myUser.Role = user.RoleType;
+                    myUser.Id = user.UserID;
+                }
+                else
+                    myUser.Role = AdminRole.Normal;
+
+                // validate
+                //  if (user == null || !BCryptNet.Verify(model.Password, user.PasswordHash))
+
+                // authentication successful so generate jwt token
+                var jwtToken = _jwtUtils.GenerateJwtToken(myUser);
+                statuscode = 1;
+                retval = new AuthenticateResponse(myUser, jwtToken);
+
+            }
+
+            return new ResultModel<AuthenticateResponse>()
+            {
+                Data = retval,
+                StatusCode = statuscode
+            };
+        }
+
+        public async Task<ResultModel<AuthenticateResponse>> LoginAD(AuthenticateRequest model)
+        {
+            User myUser = null;
+            AuthenticateResponse retval = null;
+            int statuscode = 0;
+            ADConfig adConfig = new ADConfig()
+            {
+                LDAPPassword = _appSettings.LDAPPassword,
+                LDAPPath = _appSettings.LDAPPath,
+                LDAPUser = _appSettings.LDAPUser,
+                ADTimeOutStr = _appSettings.ADTimeOut
+            };
+            myUser = await Task.Run(() => LoginADStaff(adConfig,model.Username, model.Password));
+            if (!string.IsNullOrEmpty(myUser.Username))
+            { 
+                statuscode = 1;           
+                // authentication successful so generate jwt token
+                var jwtToken = _jwtUtils.GenerateJwtToken(myUser);
+                
+                retval = new AuthenticateResponse(myUser, jwtToken);
+            }
+            return new ResultModel<AuthenticateResponse>()
+            {
+                Data = retval,
+                StatusCode = statuscode
+            };
+        }
+
+        public async Task<ResultModel<List<User>>> GetAllUsers()
+        {
+            var retval = await _context.Users.ToListAsync();
+            return new ResultModel<List<User>>()
+            {
+                Data = retval,
+                StatusCode = 1
+            };
+
+        }
+
+        public async Task<ResultModel<User>> GetById(int id) 
+        {
+            var user = await _context.Users.FindAsync(id);
+            if (user == null) throw new KeyNotFoundException("User not found");
+            return new ResultModel<User>()
+            {
+                Data = user,
+                StatusCode = 1
+            };
+        }
+        public async Task<ResultModel<User>> SearchApiStaff(string staffLinkNo)
+        {
+            User myUser = null;
+            int statuscode = 0;
+            string webAPIUrl = _appSettings.LoginWebAPI;
+            var loginInfo = await CommonAD.WebAPIUtil.SearchStaffAsync(webAPIUrl, "SearchStaff", staffLinkNo);
+            if (loginInfo != null && loginInfo.result)
+            {
+                myUser = new User();
+                myUser.Email = loginInfo.Email;
+                myUser.FirstName = loginInfo.FirstName;
+                myUser.LastName = loginInfo.LastName;
+                myUser.Username = loginInfo.StafflinkNo;
+                statuscode = 1;
+            }
+
+            return new ResultModel<User>()
+            {
+                Data = myUser,
+                StatusCode = statuscode
+            };
+           // return myUser;
+
+        }
+
+        public async Task<ResultModel<User>> SearchADStaff(string staffLinkNo)
+        {
+            int statuscode = 0;
+            ADConfig adConfig = new ADConfig()
+            {
+                LDAPPassword = _appSettings.LDAPPassword,
+                LDAPPath = _appSettings.LDAPPath,
+                LDAPUser = _appSettings.LDAPUser,
+                ADTimeOutStr = _appSettings.ADTimeOut
+            };
+            User myUser = await Task.Run(() => SearchADStaff(adConfig, staffLinkNo));
+            if (!string.IsNullOrEmpty(myUser.Username))
+                statuscode = 1;
+            return new ResultModel<User>()
+            {
+                Data = myUser,
+                StatusCode = statuscode
+            };
+
+
+        }
+        private User SearchADStaff(ADConfig adConfig, string username)
+        {
+
+            ADStaffLink staffLink = new ADStaffLink(adConfig);
+            MyADObject myADObj = staffLink.SearchStaff(username);
+            User user = new()
+            {
+                Username = myADObj.StafflinkNo,
+                Email = myADObj.Email,
+                FirstName = myADObj.FirstName,
+                LastName = myADObj.LastName
+            };
+            // myADObj.JobTitle;
+            return user;
+
+            // return null;
+        }
+        private User LoginADStaff(ADConfig adConfig, string username, string password)
+        {
+
+            ADStaffLink staffLink = new ADStaffLink(adConfig);
+            MyADObject myADObj = staffLink.CheckADCredentials(username,password);
+            User user = new()
+            {
+                Username = myADObj.StafflinkNo,
+                Email = myADObj.Email,
+                FirstName = myADObj.FirstName,
+                LastName = myADObj.LastName
+            };
+            // myADObj.JobTitle;
+            return user;
+
+            // return null;
+        }
+    }
+}

CarParkValidationAPI/Repository/ValidationPointFackRepository.cs

@@ -0,0 +1,192 @@
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Interface;
+using CarParkValidationAPI.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace CarParkValidationAPI.Repository
+{
+	public class ValidationPointFakeRepository : IValidationPoint
+	{
+		private DataContext _context;
+
+		private readonly AppSettings _appSettings;
+
+		private List<ValidationPointDto> _list = new List<ValidationPointDto>();
+
+		public ValidationPointFakeRepository(
+			DataContext context,
+
+			IOptions<AppSettings> appSettings)
+		{
+			_context = context;
+			_appSettings = appSettings.Value;
+		}
+
+		private ValidationPointDto FillValidationDto(ValidationPoint item)
+        {
+			ValidationPointDto dto = new ValidationPointDto();
+			dto.Active = item.Active;
+			dto.Description = item.Description;
+			dto.Display = item.DisplayName;
+			dto.Id = item.ValidationPointID;
+			return dto;
+        }
+
+		private ValidationPoint FillValidationModel(ValidationPointDto item, ValidationPoint model)		{
+
+			model.Active = item.Active;
+			model.Description = item.Description;
+			model.DisplayName = item.Display;
+			model.ValidationPointID = item.Id;
+			return model;
+		}
+
+		public async Task<ResultModel<List<ValidationPointDto>>> LoadValidationPointAsync(bool onlyActive)
+		{
+			try
+			{
+				/*
+				var it = await _context.Validations.AsQueryable().ToListAsync();
+				*/
+
+				ValidationPointDto dto;
+				ValidationPoint val;
+				for (int i = 0; i < 10; i++)
+				{
+					val = new ValidationPoint()
+					{
+						ValidationPointID = i,
+						Description = $"Validation {i}",
+						DisplayName = $"Display {i}",
+						Active = true,
+
+
+					};
+
+					dto = FillValidationDto(val);
+					_list.Add(dto);
+				}
+				//var it = await Task.Run(() => _list);
+
+				return new ResultModel<List<ValidationPointDto>>()
+				{
+					Data = _list,
+					StatusCode = 1
+				};
+
+			}
+			catch (Exception ex)
+			{
+				throw ex;
+			}
+
+		}
+		public async Task<ResultModel<ValidationPointDto>> LoadValidationPointByIdAsync(int id)
+		{
+			ValidationPoint result = null;
+			try
+			{
+				ValidationPointDto dto;
+				result = await _context.Validations.FindAsync(id);
+				dto = FillValidationDto(result);
+				//result = _list.Find(x => x.Id == id);
+				//var dto = await Task.Run(() => result);
+				return new ResultModel<ValidationPointDto>()
+				{
+					Data = dto,
+					StatusCode = 1
+				};
+			}
+			catch (Exception ex)
+            {
+				throw ex;
+            }
+		}
+		public async Task<ResultModel<int>> SaveValidationPointAsync(ValidationPointDto item)
+		{
+			int result = default(int);
+			try
+			{				
+				ValidationPoint model;
+				if (item.Id > 0)
+				{
+					model = await _context.Validations.FindAsync(item.Id);
+					model = FillValidationModel(item, model);
+					await _context.SaveChangesAsync();
+					result = item.Id;
+				}
+				else //new record
+				{
+					model = new ValidationPoint();
+					model = FillValidationModel(item, model);
+					_context.Validations.Add(model);
+					var id = await _context.SaveChangesAsync();
+					result = id;
+					item.Id = id;
+				}
+
+				//var dto = await Task.Run(() => result);
+				return new ResultModel<int>()
+				{
+					Data = result,
+					StatusCode = 1
+				};
+			}
+			catch (Exception ex)
+			{
+				throw ex;
+			}
+			/*
+			ConcessionTypeDA dataAccess = new ConcessionTypeDA();
+			try
+			{
+				result = await dataAccess.InsertConcessionTypeAsync(item);
+			}
+			catch (Exception ex)
+			{
+				throw ex;
+			}
+			*/
+		
+
+		}
+
+		public async Task<ResultModel<bool>> DeleteValidationPointAsync(int id)
+		{
+			bool result = true;
+			try
+			{
+				
+
+				ValidationPoint model;
+				if (id > 0)
+				{
+					model = await _context.Validations.FindAsync(id);
+					model.Active = false;
+					//_context.Validations.Remove(model);					
+					await _context.SaveChangesAsync();
+				}
+				
+				//var dto = await Task.Run(() => result);
+				return new ResultModel<bool>()
+				{
+					Data = result,
+					StatusCode = 1
+				};
+			}
+			catch (Exception ex)
+			{
+				throw;
+			}
+			
+		}
+
+
+	}
+}

CarParkValidationAPI/Repository/ValidationPointRepository.cs

@@ -0,0 +1,179 @@
+using CarParkValidationAPI.Datas;
+using CarParkValidationAPI.Entities;
+using CarParkValidationAPI.Interface;
+using CarParkValidationAPI.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace CarParkValidationAPI.Repository
+{
+	public class ValidationPointRepository : IValidationPoint
+	{
+		private DataContext _context;
+
+		private readonly AppSettings _appSettings;
+
+		private List<ValidationPointDto> _list = new List<ValidationPointDto>();
+
+		public ValidationPointRepository(
+			DataContext context,
+
+			IOptions<AppSettings> appSettings)
+		{
+			_context = context;
+			_appSettings = appSettings.Value;
+		}
+
+		private ValidationPointDto FillValidationDto(ValidationPoint item)
+        {
+			ValidationPointDto dto = new ValidationPointDto();
+			dto.Active = item.Active;
+			dto.Description = item.Description;
+			dto.Display = item.DisplayName;
+			dto.Id = item.ValidationPointID;
+			return dto;
+        }
+
+		private ValidationPoint FillValidationModel(ValidationPointDto item, ValidationPoint model)		{
+
+			model.Active = item.Active;
+			model.Description = item.Description;
+			model.DisplayName = item.Display;
+			model.ValidationPointID = item.Id;
+			return model;
+		}
+
+		public async Task<ResultModel<List<ValidationPointDto>>> LoadValidationPointAsync(bool onlyActive)
+		{
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				var it = await _context.Validations.ToListAsync();
+
+				ValidationPointDto dto;
+				for (int i = 0; i < it.Count; i++)
+				{
+					dto = FillValidationDto(it[i]);
+					_list.Add(dto);
+				}
+				
+				statuscode = 1;
+
+			}
+			catch (Exception ex)
+			{
+				error = ex.ToString();
+				statuscode = 0;
+				throw ex;
+			}
+			return new ResultModel<List<ValidationPointDto>>()
+			{
+				Data = _list,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<ValidationPointDto>> LoadValidationPointByIdAsync(int id)
+		{
+			ValidationPoint result = null;
+			int statuscode = 0;
+			string error = "";
+			ValidationPointDto dto = null;
+			try
+			{				
+				result = await _context.Validations.FindAsync(id);
+				dto = FillValidationDto(result);
+				//result = _list.Find(x => x.Id == id);
+				//var dto = await Task.Run(() => result);
+				statuscode = 1;				
+			}
+			catch (Exception ex)
+            {
+				error = ex.ToString();
+				statuscode = 0;
+			}
+			return new ResultModel<ValidationPointDto>()
+			{
+				Data = dto,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+		public async Task<ResultModel<int>> SaveValidationPointAsync(ValidationPointDto item)
+		{
+			int result = default(int);
+			int statuscode = 0;
+			string error = "";
+			try
+			{				
+				ValidationPoint model;
+				if (item.Id > 0)
+				{
+					model = await _context.Validations.FindAsync(item.Id);
+					model = FillValidationModel(item, model);
+					await _context.SaveChangesAsync();
+					result = item.Id;
+				}
+				else //new record
+				{
+					model = new ValidationPoint();
+					model = FillValidationModel(item, model);
+					_context.Validations.Add(model);
+					var id = await _context.SaveChangesAsync();
+					result = id;
+					item.Id = id;
+				}
+				statuscode = 1;
+			}
+			catch (Exception ex)
+			{
+				error = ex.ToString();
+				statuscode = 0;
+			}
+			//var dto = await Task.Run(() => result);
+			return new ResultModel<int>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+
+		public async Task<ResultModel<bool>> DeleteValidationPointAsync(int id)
+		{
+			bool result = true;
+			int statuscode = 0;
+			string error = "";
+			try
+			{
+				ValidationPoint model;
+				if (id > 0)
+				{
+					model = await _context.Validations.FindAsync(id);
+					model.Active = false;
+					//_context.Validations.Remove(model);					
+					await _context.SaveChangesAsync();
+					statuscode = 1;
+				}
+			}
+			catch (Exception ex)
+			{
+				error = ex.ToString();
+				statuscode = 0;
+				throw;
+			}
+			//var dto = await Task.Run(() => result);
+			return new ResultModel<bool>()
+			{
+				Data = result,
+				StatusCode = statuscode,
+				Message = error
+			};
+		}
+	}
+}