Deploy restore contacts feature

.dockerignore

@@ -0,0 +1,17 @@
+**/bin/
+**/obj/
+**/.vs/
+**/.vscode/
+**/.git/
+**/.venv/
+
+Deployment/
+Installers/
+Published/
+
+screenshots/
+*.rar
+*.zip
+*.7z
+*.pdf
+*.docx

ContactManagementAPI/ContactManagementAPI.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CsvHelper" Version="30.0.1" />
+    <PackageReference Include="EPPlus" Version="7.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="QuestPDF" Version="2024.12.3" />
+  </ItemGroup>
+
+</Project>

ContactManagementAPI/Controllers/AccountController.cs

@@ -0,0 +1,66 @@
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Models;
+using ContactManagementAPI.Services;
+using ContactManagementAPI.ViewModels;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace ContactManagementAPI.Controllers
+{
+    public class AccountController : Controller
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly PasswordHasher<AppUser> _passwordHasher = new();
+
+        public AccountController(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        [HttpGet]
+        public IActionResult Login(string? returnUrl = null)
+        {
+            return View(new LoginViewModel { ReturnUrl = returnUrl });
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public IActionResult Login(LoginViewModel model)
+        {
+            if (!ModelState.IsValid)
+                return View(model);
+
+            var user = _context.AppUsers
+                .Include(u => u.Group)
+                .FirstOrDefault(u => u.UserName == model.UserName);
+
+            if (user == null || !user.IsActive)
+            {
+                ModelState.AddModelError(string.Empty, "Invalid username or password.");
+                return View(model);
+            }
+
+            var result = _passwordHasher.VerifyHashedPassword(user, user.PasswordHash, model.Password);
+            if (result == PasswordVerificationResult.Failed)
+            {
+                ModelState.AddModelError(string.Empty, "Invalid username or password.");
+                return View(model);
+            }
+
+            HttpContext.Session.SetInt32(SessionKeys.UserId, user.Id);
+            return Redirect(string.IsNullOrWhiteSpace(model.ReturnUrl) ? "/" : model.ReturnUrl);
+        }
+
+        public IActionResult Logout()
+        {
+            HttpContext.Session.Clear();
+            return RedirectToAction("Login");
+        }
+
+        public IActionResult AccessDenied()
+        {
+            return View();
+        }
+    }
+}

ContactManagementAPI/Controllers/AdminController.cs

@@ -0,0 +1,1171 @@
+using System;
+using System.Linq;
+using System.IO.Compression;
+using Microsoft.Data.Sqlite;
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Models;
+using ContactManagementAPI.Security;
+using ContactManagementAPI.Services;
+using ContactManagementAPI.ViewModels;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace ContactManagementAPI.Controllers
+{
+    public class AdminController : Controller
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly UserContextService _userContextService;
+        private readonly AdminHistoryService _adminHistoryService;
+        private readonly IWebHostEnvironment _environment;
+        private readonly PasswordHasher<AppUser> _passwordHasher = new();
+
+        public AdminController(ApplicationDbContext context, UserContextService userContextService, AdminHistoryService adminHistoryService, IWebHostEnvironment environment)
+        {
+            _context = context;
+            _userContextService = userContextService;
+            _adminHistoryService = adminHistoryService;
+            _environment = environment;
+        }
+
+        private static bool IsSuperAdminUser(AppUser? user)
+        {
+            return user != null && string.Equals(user.UserName, SeedData.SuperAdminUserName, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static bool IsProtectedSystemUser(AppUser? user)
+        {
+            return user != null &&
+                   (IsSuperAdminUser(user) || string.Equals(user.UserName, "admin", StringComparison.OrdinalIgnoreCase));
+        }
+
+        private ContactGroup? ResolveContactGroupForUserGroup(UserGroup? userGroup)
+        {
+            if (userGroup == null)
+            {
+                return null;
+            }
+
+            if (!string.IsNullOrWhiteSpace(userGroup.Name) && userGroup.Name.StartsWith("ContactGroup - ", StringComparison.OrdinalIgnoreCase))
+            {
+                var contactGroupName = userGroup.Name.Substring("ContactGroup - ".Length).Trim();
+                if (!string.IsNullOrWhiteSpace(contactGroupName))
+                {
+                    return _context.ContactGroups.FirstOrDefault(cg => cg.Name == contactGroupName);
+                }
+            }
+
+            return _context.ContactGroups.FirstOrDefault(cg => cg.Id == userGroup.Id);
+        }
+
+        private string GetUploadsRoot()
+        {
+            var uploadsRoot = Environment.GetEnvironmentVariable("UPLOADS_ROOT");
+            if (!string.IsNullOrWhiteSpace(uploadsRoot))
+            {
+                Directory.CreateDirectory(uploadsRoot);
+                Directory.CreateDirectory(Path.Combine(uploadsRoot, "photos"));
+                Directory.CreateDirectory(Path.Combine(uploadsRoot, "documents"));
+                return uploadsRoot;
+            }
+
+            var fallback = Path.Combine(_environment.WebRootPath, "uploads");
+            Directory.CreateDirectory(fallback);
+            Directory.CreateDirectory(Path.Combine(fallback, "photos"));
+            Directory.CreateDirectory(Path.Combine(fallback, "documents"));
+            return fallback;
+        }
+
+        private static string NormalizeText(string? value)
+        {
+            return (value ?? string.Empty).Trim().ToUpperInvariant();
+        }
+
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public IActionResult Users()
+        {
+            var currentUser = _userContextService.CurrentUser;
+            var isSuperAdmin = IsSuperAdminUser(currentUser);
+
+            var usersQuery = _context.AppUsers
+                .Include(u => u.Group)
+                .AsQueryable();
+
+            if (!isSuperAdmin)
+            {
+                usersQuery = usersQuery.Where(u => !string.Equals(u.UserName, SeedData.SuperAdminUserName, StringComparison.OrdinalIgnoreCase));
+            }
+
+            var users = usersQuery
+                .OrderBy(u => u.UserName)
+                .ToList();
+
+            ViewBag.IsSuperAdmin = isSuperAdmin;
+
+            return View(users);
+        }
+
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public IActionResult CreateUser()
+        {
+            ViewData["Groups"] = _context.UserGroups.OrderBy(g => g.Name).ToList();
+            return View(new UserCreateViewModel());
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public IActionResult CreateUser(UserCreateViewModel model)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            var isSuperAdmin = IsSuperAdminUser(currentUser);
+
+            if (string.Equals(model.UserName, SeedData.SuperAdminUserName, StringComparison.OrdinalIgnoreCase) && !isSuperAdmin)
+            {
+                ModelState.AddModelError(nameof(UserCreateViewModel.UserName), "Super Admin user name is reserved.");
+            }
+
+            if (_context.AppUsers.Any(u => u.UserName == model.UserName))
+            {
+                ModelState.AddModelError(nameof(UserCreateViewModel.UserName), "User name already exists.");
+            }
+
+            if (!ModelState.IsValid)
+            {
+                ViewData["Groups"] = _context.UserGroups.OrderBy(g => g.Name).ToList();
+                return View(model);
+            }
+
+            var user = new AppUser
+            {
+                UserName = model.UserName,
+                FullName = model.FullName,
+                GroupId = model.GroupId,
+                IsAdmin = model.IsAdmin,
+                IsActive = model.IsActive,
+                CreatedAt = DateTime.Now,
+                UpdatedAt = DateTime.Now
+            };
+
+            user.PasswordHash = _passwordHasher.HashPassword(user, model.Password);
+            _context.AppUsers.Add(user);
+            _context.SaveChanges();
+
+            _adminHistoryService.Log(
+                actionType: "Create",
+                entityType: "User",
+                entityId: user.Id,
+                performedBy: _userContextService.CurrentUser?.UserName ?? "Unknown",
+                details: $"Created user '{user.UserName}' in group id '{user.GroupId}'.");
+
+            TempData["SuccessMessage"] = "User created successfully.";
+            return RedirectToAction("Users");
+        }
+
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public IActionResult EditUser(int id)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            var isSuperAdmin = IsSuperAdminUser(currentUser);
+
+            var user = _context.AppUsers.FirstOrDefault(u => u.Id == id);
+            if (user == null)
+                return NotFound();
+
+            if (IsSuperAdminUser(user) && !isSuperAdmin)
+            {
+                return NotFound();
+            }
+
+            var model = new UserEditViewModel
+            {
+                Id = user.Id,
+                UserName = user.UserName,
+                FullName = user.FullName,
+                GroupId = user.GroupId,
+                IsAdmin = user.IsAdmin,
+                IsActive = user.IsActive
+            };
+
+            ViewData["Groups"] = _context.UserGroups.OrderBy(g => g.Name).ToList();
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public IActionResult EditUser(UserEditViewModel model)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            var isSuperAdmin = IsSuperAdminUser(currentUser);
+
+            var user = _context.AppUsers.FirstOrDefault(u => u.Id == model.Id);
+            if (user == null)
+                return NotFound();
+
+            if (IsSuperAdminUser(user) && !isSuperAdmin)
+            {
+                return NotFound();
+            }
+
+            if (_context.AppUsers.Any(u => u.UserName == model.UserName && u.Id != model.Id))
+            {
+                ModelState.AddModelError(nameof(UserEditViewModel.UserName), "User name already exists.");
+            }
+
+            if (string.Equals(model.UserName, SeedData.SuperAdminUserName, StringComparison.OrdinalIgnoreCase) && !IsSuperAdminUser(user))
+            {
+                ModelState.AddModelError(nameof(UserEditViewModel.UserName), "Super Admin user name is reserved.");
+            }
+
+            if (!ModelState.IsValid)
+            {
+                ViewData["Groups"] = _context.UserGroups.OrderBy(g => g.Name).ToList();
+                return View(model);
+            }
+
+            var wasAdminUser = string.Equals(user.UserName, "admin", StringComparison.OrdinalIgnoreCase);
+            var wasSuperAdminUser = IsSuperAdminUser(user);
+
+            if (wasSuperAdminUser)
+            {
+                // Super Admin is immutable (prevents lockout and prevents admin-level changes even by mistake)
+                ModelState.AddModelError(string.Empty, "Super Admin account cannot be edited.");
+                ViewData["Groups"] = _context.UserGroups.OrderBy(g => g.Name).ToList();
+                return View(model);
+            }
+
+            user.UserName = model.UserName;
+            user.FullName = model.FullName;
+            user.GroupId = model.GroupId;
+            user.IsAdmin = model.IsAdmin;
+            user.IsActive = model.IsActive;
+            user.UpdatedAt = DateTime.Now;
+
+            if (wasAdminUser)
+            {
+                var administratorsGroupId = _context.UserGroups
+                    .Where(g => g.Name == "Administrators")
+                    .Select(g => g.Id)
+                    .FirstOrDefault();
+
+                user.IsAdmin = true;
+                user.IsActive = true;
+                if (administratorsGroupId > 0)
+                {
+                    user.GroupId = administratorsGroupId;
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(model.NewPassword))
+            {
+                user.PasswordHash = _passwordHasher.HashPassword(user, model.NewPassword);
+            }
+
+            _context.SaveChanges();
+
+            _adminHistoryService.Log(
+                actionType: "Edit",
+                entityType: "User",
+                entityId: user.Id,
+                performedBy: _userContextService.CurrentUser?.UserName ?? "Unknown",
+                details: $"Edited user '{user.UserName}' (Active: {user.IsActive}, Admin: {user.IsAdmin}).");
+
+            TempData["SuccessMessage"] = "User updated successfully.";
+            return RedirectToAction("Users");
+        }
+
+        [RequireRight(RightsCatalog.AdminManageRights)]
+        public IActionResult UserRights(int id)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            var isSuperAdmin = IsSuperAdminUser(currentUser);
+
+            var user = _context.AppUsers
+                .Include(u => u.Group)
+                .FirstOrDefault(u => u.Id == id);
+
+            if (user == null)
+                return NotFound();
+
+            if (IsSuperAdminUser(user) && !isSuperAdmin)
+            {
+                return NotFound();
+            }
+
+            var userRights = _context.UserRights
+                .Where(r => r.AppUserId == id)
+                .ToList();
+
+            var groupRights = _context.GroupRights
+                .Where(r => r.UserGroupId == user.GroupId)
+                .ToList();
+
+            var rights = RightsCatalog.All.Select(r =>
+            {
+                var userRight = userRights.FirstOrDefault(ur => ur.RightKey == r.Key);
+                var groupRight = groupRights.FirstOrDefault(gr => gr.RightKey == r.Key);
+                var selection = userRight == null ? "Inherit" : (userRight.IsGranted ? "Grant" : "Deny");
+                var effectiveGranted = user.IsAdmin || (userRight?.IsGranted ?? (groupRight?.IsGranted ?? false));
+                var effectiveSource = user.IsAdmin ? "Admin" : userRight != null ? "User" : groupRight != null ? "Group" : "None";
+
+                return new RightAssignmentViewModel
+                {
+                    Key = r.Key,
+                    Label = r.Label,
+                    Category = r.Category,
+                    Selection = selection,
+                    EffectiveGranted = effectiveGranted,
+                    EffectiveSource = effectiveSource
+                };
+            }).ToList();
+
+            var model = new UserRightsViewModel
+            {
+                UserId = user.Id,
+                UserName = user.UserName,
+                GroupName = user.Group?.Name,
+                Rights = rights
+            };
+
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageRights)]
+        public IActionResult UserRights(UserRightsViewModel model)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            var isSuperAdmin = IsSuperAdminUser(currentUser);
+
+            var user = _context.AppUsers.FirstOrDefault(u => u.Id == model.UserId);
+            if (user == null)
+                return NotFound();
+
+            if (IsSuperAdminUser(user) && !isSuperAdmin)
+            {
+                return NotFound();
+            }
+
+            foreach (var right in model.Rights)
+            {
+                var existing = _context.UserRights.FirstOrDefault(r => r.AppUserId == model.UserId && r.RightKey == right.Key);
+                if (right.Selection == "Inherit")
+                {
+                    if (existing != null)
+                        _context.UserRights.Remove(existing);
+                    continue;
+                }
+
+                var isGranted = right.Selection == "Grant";
+                if (existing == null)
+                {
+                    _context.UserRights.Add(new UserRight
+                    {
+                        AppUserId = model.UserId,
+                        RightKey = right.Key,
+                        IsGranted = isGranted
+                    });
+                }
+                else
+                {
+                    existing.IsGranted = isGranted;
+                }
+            }
+
+            _context.SaveChanges();
+
+            _adminHistoryService.Log(
+                actionType: "Edit",
+                entityType: "UserRights",
+                entityId: model.UserId,
+                performedBy: _userContextService.CurrentUser?.UserName ?? "Unknown",
+                details: $"Updated rights for user '{user.UserName}'.");
+
+            TempData["SuccessMessage"] = "User rights updated successfully.";
+            return RedirectToAction("UserRights", new { id = model.UserId });
+        }
+
+        [RequireRight(RightsCatalog.AdminManageGroups)]
+        public IActionResult Groups()
+        {
+            var groups = _context.UserGroups
+                .OrderBy(g => g.Name)
+                .ToList();
+
+            ViewBag.IsSuperAdmin = IsSuperAdminUser(_userContextService.CurrentUser);
+
+            return View(groups);
+        }
+
+        [RequireRight(RightsCatalog.AdminManageGroups)]
+        public IActionResult CreateGroup()
+        {
+            return View(new GroupEditViewModel());
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageGroups)]
+        public IActionResult CreateGroup(GroupEditViewModel model)
+        {
+            if (_context.UserGroups.Any(g => g.Name == model.Name))
+            {
+                ModelState.AddModelError(nameof(GroupEditViewModel.Name), "Group name already exists.");
+            }
+
+            if (!ModelState.IsValid)
+                return View(model);
+
+            var group = new UserGroup
+            {
+                Name = model.Name,
+                Description = model.Description,
+                CreatedAt = DateTime.Now
+            };
+
+            _context.UserGroups.Add(group);
+            _context.SaveChanges();
+
+            var rights = RightsCatalog.All.Select(r => new GroupRight
+            {
+                UserGroupId = group.Id,
+                RightKey = r.Key,
+                IsGranted = false
+            }).ToList();
+
+            _context.GroupRights.AddRange(rights);
+            _context.SaveChanges();
+
+            _adminHistoryService.Log(
+                actionType: "Create",
+                entityType: "Group",
+                entityId: group.Id,
+                performedBy: _userContextService.CurrentUser?.UserName ?? "Unknown",
+                details: $"Created group '{group.Name}'.");
+
+            TempData["SuccessMessage"] = "Group created successfully.";
+            return RedirectToAction("Groups");
+        }
+
+        [RequireRight(RightsCatalog.AdminManageGroups)]
+        public IActionResult EditGroup(int id)
+        {
+            var group = _context.UserGroups.FirstOrDefault(g => g.Id == id);
+            if (group == null)
+                return NotFound();
+
+            var model = new GroupEditViewModel
+            {
+                Id = group.Id,
+                Name = group.Name,
+                Description = group.Description
+            };
+
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public IActionResult DeleteSelectedUsers(List<int> userIds)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (!IsSuperAdminUser(currentUser))
+            {
+                return Forbid();
+            }
+
+            if (userIds == null || userIds.Count == 0)
+            {
+                TempData["ErrorMessage"] = "No users selected.";
+                return RedirectToAction(nameof(Users));
+            }
+
+            var messages = new System.Collections.Generic.List<string>();
+            var deleted = 0;
+
+            foreach (var userId in userIds.Distinct())
+            {
+                var user = _context.AppUsers
+                    .Include(u => u.Group)
+                    .FirstOrDefault(u => u.Id == userId);
+
+                if (user == null)
+                {
+                    continue;
+                }
+
+                if (IsProtectedSystemUser(user))
+                {
+                    messages.Add($"User '{user.UserName}' cannot be deleted.");
+                    continue;
+                }
+
+                var mappedContactGroup = ResolveContactGroupForUserGroup(user.Group);
+                if (mappedContactGroup != null)
+                {
+                    var hasContacts = _context.Contacts.Any(c => c.GroupId == mappedContactGroup.Id);
+                    if (hasContacts)
+                    {
+                        messages.Add($"Delete contacts in '{mappedContactGroup.Name}' first, then delete user '{user.UserName}'.");
+                        continue;
+                    }
+                }
+
+                _context.AppUsers.Remove(user);
+                deleted++;
+
+                _adminHistoryService.Log(
+                    actionType: "Delete",
+                    entityType: "User",
+                    entityId: user.Id,
+                    performedBy: currentUser?.UserName ?? "Unknown",
+                    details: $"Deleted user '{user.UserName}'.");
+            }
+
+            if (deleted > 0)
+            {
+                _context.SaveChanges();
+            }
+
+            if (messages.Count > 0)
+            {
+                TempData["ErrorMessage"] = string.Join(" ", messages);
+            }
+
+            if (deleted > 0)
+            {
+                TempData["SuccessMessage"] = $"Deleted {deleted} user(s).";
+            }
+
+            return RedirectToAction(nameof(Users));
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageGroups)]
+        public IActionResult DeleteSelectedGroups(List<int> groupIds)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (!IsSuperAdminUser(currentUser))
+            {
+                return Forbid();
+            }
+
+            if (groupIds == null || groupIds.Count == 0)
+            {
+                TempData["ErrorMessage"] = "No groups selected.";
+                return RedirectToAction(nameof(Groups));
+            }
+
+            var messages = new System.Collections.Generic.List<string>();
+            var deleted = 0;
+
+            foreach (var groupId in groupIds.Distinct())
+            {
+                var group = _context.UserGroups
+                    .Include(g => g.Users)
+                    .FirstOrDefault(g => g.Id == groupId);
+
+                if (group == null)
+                {
+                    continue;
+                }
+
+                if (string.Equals(group.Name, "Administrators", StringComparison.OrdinalIgnoreCase))
+                {
+                    messages.Add("Administrators group cannot be deleted.");
+                    continue;
+                }
+
+                var mappedContactGroup = ResolveContactGroupForUserGroup(group);
+                if (mappedContactGroup != null)
+                {
+                    var hasContacts = _context.Contacts.Any(c => c.GroupId == mappedContactGroup.Id);
+                    if (hasContacts)
+                    {
+                        messages.Add($"Delete contacts in '{mappedContactGroup.Name}' first, then delete users, then delete group '{group.Name}'.");
+                        continue;
+                    }
+                }
+
+                if (group.Users.Any())
+                {
+                    messages.Add($"Delete users in group '{group.Name}' first, then delete the group.");
+                    continue;
+                }
+
+                _context.UserGroups.Remove(group);
+                deleted++;
+
+                _adminHistoryService.Log(
+                    actionType: "Delete",
+                    entityType: "Group",
+                    entityId: group.Id,
+                    performedBy: currentUser?.UserName ?? "Unknown",
+                    details: $"Deleted group '{group.Name}'.");
+            }
+
+            if (deleted > 0)
+            {
+                _context.SaveChanges();
+            }
+
+            if (messages.Count > 0)
+            {
+                TempData["ErrorMessage"] = string.Join(" ", messages);
+            }
+
+            if (deleted > 0)
+            {
+                TempData["SuccessMessage"] = $"Deleted {deleted} group(s).";
+            }
+
+            return RedirectToAction(nameof(Groups));
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageGroups)]
+        public IActionResult EditGroup(GroupEditViewModel model)
+        {
+            var group = _context.UserGroups.FirstOrDefault(g => g.Id == model.Id);
+            if (group == null)
+                return NotFound();
+
+            if (_context.UserGroups.Any(g => g.Name == model.Name && g.Id != model.Id))
+            {
+                ModelState.AddModelError(nameof(GroupEditViewModel.Name), "Group name already exists.");
+            }
+
+            if (!ModelState.IsValid)
+                return View(model);
+
+            if (string.Equals(group.Name, "Administrators", StringComparison.OrdinalIgnoreCase) &&
+                !string.Equals(model.Name, "Administrators", StringComparison.OrdinalIgnoreCase))
+            {
+                ModelState.AddModelError(nameof(GroupEditViewModel.Name), "Administrators group name cannot be changed.");
+                return View(model);
+            }
+
+            group.Name = model.Name;
+            group.Description = model.Description;
+            _context.SaveChanges();
+
+            _adminHistoryService.Log(
+                actionType: "Edit",
+                entityType: "Group",
+                entityId: group.Id,
+                performedBy: _userContextService.CurrentUser?.UserName ?? "Unknown",
+                details: $"Edited group '{group.Name}'.");
+
+            TempData["SuccessMessage"] = "Group updated successfully.";
+            return RedirectToAction("Groups");
+        }
+
+        [RequireRight(RightsCatalog.AdminManageRights)]
+        public IActionResult GroupRights(int id)
+        {
+            var group = _context.UserGroups.FirstOrDefault(g => g.Id == id);
+            if (group == null)
+                return NotFound();
+
+            var groupRights = _context.GroupRights
+                .Where(r => r.UserGroupId == id)
+                .ToList();
+
+            var rights = RightsCatalog.All.Select(r =>
+            {
+                var existing = groupRights.FirstOrDefault(gr => gr.RightKey == r.Key);
+                return new RightAssignmentViewModel
+                {
+                    Key = r.Key,
+                    Label = r.Label,
+                    Category = r.Category,
+                    IsGranted = existing?.IsGranted ?? false
+                };
+            }).ToList();
+
+            var model = new GroupRightsViewModel
+            {
+                GroupId = group.Id,
+                GroupName = group.Name,
+                Rights = rights
+            };
+
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageRights)]
+        public IActionResult GroupRights(GroupRightsViewModel model)
+        {
+            foreach (var right in model.Rights)
+            {
+                var existing = _context.GroupRights.FirstOrDefault(r => r.UserGroupId == model.GroupId && r.RightKey == right.Key);
+                if (existing == null)
+                {
+                    _context.GroupRights.Add(new GroupRight
+                    {
+                        UserGroupId = model.GroupId,
+                        RightKey = right.Key,
+                        IsGranted = right.IsGranted
+                    });
+                }
+                else
+                {
+                    existing.IsGranted = right.IsGranted;
+                }
+            }
+
+            _context.SaveChanges();
+
+            _adminHistoryService.Log(
+                actionType: "Edit",
+                entityType: "GroupRights",
+                entityId: model.GroupId,
+                performedBy: _userContextService.CurrentUser?.UserName ?? "Unknown",
+                details: $"Updated rights for group '{model.GroupName}'.");
+
+            TempData["SuccessMessage"] = "Group rights updated successfully.";
+            return RedirectToAction("GroupRights", new { id = model.GroupId });
+        }
+
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public IActionResult History(int take = 200)
+        {
+            var entries = _adminHistoryService
+                .GetLatest(take)
+                .Select(e => new AdminHistoryEntryViewModel
+                {
+                    ActionType = e.ActionType,
+                    EntityType = e.EntityType,
+                    EntityId = e.EntityId,
+                    Details = e.Details,
+                    PerformedBy = e.PerformedBy,
+                    PerformedAt = e.PerformedAt
+                })
+                .ToList();
+
+            var model = new AdminHistoryListViewModel
+            {
+                Entries = entries
+            };
+
+            return View(model);
+        }
+
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public IActionResult RestoreContacts()
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (!IsSuperAdminUser(currentUser))
+            {
+                return Forbid();
+            }
+
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.AdminManageUsers)]
+        public async Task<IActionResult> RestoreContacts(IFormFile backupZip)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (!IsSuperAdminUser(currentUser))
+            {
+                return Forbid();
+            }
+
+            if (backupZip == null || backupZip.Length == 0)
+            {
+                TempData["ErrorMessage"] = "Please select a backup ZIP file.";
+                return RedirectToAction(nameof(RestoreContacts));
+            }
+
+            var tempRoot = Path.Combine(Path.GetTempPath(), "cms-restore-" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(tempRoot);
+
+            try
+            {
+                var zipPath = Path.Combine(tempRoot, "backup.zip");
+                await using (var fs = System.IO.File.Create(zipPath))
+                {
+                    await backupZip.CopyToAsync(fs);
+                }
+
+                ZipFile.ExtractToDirectory(zipPath, tempRoot);
+
+                // Expect: ContactManagement.db + uploads/photos + uploads/documents
+                var backupDbPath = Directory.GetFiles(tempRoot, "ContactManagement.db", SearchOption.AllDirectories)
+                    .FirstOrDefault();
+
+                if (string.IsNullOrWhiteSpace(backupDbPath) || !System.IO.File.Exists(backupDbPath))
+                {
+                    TempData["ErrorMessage"] = "Backup ZIP must contain ContactManagement.db";
+                    return RedirectToAction(nameof(RestoreContacts));
+                }
+
+                var backupUploadsRoot = Directory.GetDirectories(tempRoot, "uploads", SearchOption.AllDirectories)
+                    .FirstOrDefault();
+
+                if (string.IsNullOrWhiteSpace(backupUploadsRoot) || !Directory.Exists(backupUploadsRoot))
+                {
+                    TempData["ErrorMessage"] = "Backup ZIP must contain uploads/photos and uploads/documents.";
+                    return RedirectToAction(nameof(RestoreContacts));
+                }
+
+                var targetUploadsRoot = GetUploadsRoot();
+
+                var backupConnString = new SqliteConnectionStringBuilder { DataSource = backupDbPath }.ToString();
+                await using var backupConn = new SqliteConnection(backupConnString);
+                await backupConn.OpenAsync();
+
+                var wantedNames = new[] { "ABRAHAM", "PREMA", "PONNURAJ" };
+                var contactsToRestore = new System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, object?>>();
+
+                var contactCmd = backupConn.CreateCommand();
+                contactCmd.CommandText = @"
+SELECT Id, FirstName, LastName, NickName, Gender, DateOfBirth, Email,
+       Mobile1, Mobile2, Mobile3, WhatsAppNumber,
+       PassportNumber, PanNumber, AadharNumber, DrivingLicenseNumber, VotersId,
+       BankAccountNumber, BankName, BranchName, IfscCode,
+       Address, City, State, PostalCode, Country,
+       PhotoPath, GroupId, OtherDetails, CreatedAt, UpdatedAt
+FROM Contacts
+WHERE lower(FirstName) IN ('abraham','prema','ponnuraj');";
+
+                await using (var reader = await contactCmd.ExecuteReaderAsync())
+                {
+                    while (await reader.ReadAsync())
+                    {
+                        var dict = new System.Collections.Generic.Dictionary<string, object?>();
+                        for (var i = 0; i < reader.FieldCount; i++)
+                        {
+                            dict[reader.GetName(i)] = await reader.IsDBNullAsync(i) ? null : reader.GetValue(i);
+                        }
+                        contactsToRestore.Add(dict);
+                    }
+                }
+
+                if (contactsToRestore.Count == 0)
+                {
+                    TempData["ErrorMessage"] = "No Abraham/Prema/Ponnuraj contacts were found in the backup DB.";
+                    return RedirectToAction(nameof(RestoreContacts));
+                }
+
+                // Pull related rows from backup
+                var backupContactIds = contactsToRestore.Select(c => Convert.ToInt32(c["Id"])).ToArray();
+                var idList = string.Join(",", backupContactIds);
+
+                var backupPhotos = new System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, object?>>>();
+                var photoCmd = backupConn.CreateCommand();
+                photoCmd.CommandText = $@"
+SELECT ContactId, PhotoPath, FileName, FileSize, ContentType, IsProfilePhoto, UploadedAt
+FROM ContactPhotos
+WHERE ContactId IN ({idList});";
+                await using (var reader = await photoCmd.ExecuteReaderAsync())
+                {
+                    while (await reader.ReadAsync())
+                    {
+                        var contactId = reader.GetInt32(0);
+                        if (!backupPhotos.TryGetValue(contactId, out var list))
+                        {
+                            list = new System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, object?>>();
+                            backupPhotos[contactId] = list;
+                        }
+
+                        list.Add(new System.Collections.Generic.Dictionary<string, object?>
+                        {
+                            ["PhotoPath"] = reader.IsDBNull(1) ? null : reader.GetString(1),
+                            ["FileName"] = reader.IsDBNull(2) ? null : reader.GetString(2),
+                            ["FileSize"] = reader.IsDBNull(3) ? 0L : reader.GetInt64(3),
+                            ["ContentType"] = reader.IsDBNull(4) ? null : reader.GetString(4),
+                            ["IsProfilePhoto"] = !reader.IsDBNull(5) && reader.GetBoolean(5),
+                            ["UploadedAt"] = reader.IsDBNull(6) ? (DateTime?)null : reader.GetDateTime(6)
+                        });
+                    }
+                }
+
+                var backupDocs = new System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, object?>>>();
+                var docCmd = backupConn.CreateCommand();
+                docCmd.CommandText = $@"
+SELECT ContactId, DocumentPath, FileName, FileSize, ContentType, DocumentType, UploadedAt
+FROM ContactDocuments
+WHERE ContactId IN ({idList});";
+                await using (var reader = await docCmd.ExecuteReaderAsync())
+                {
+                    while (await reader.ReadAsync())
+                    {
+                        var contactId = reader.GetInt32(0);
+                        if (!backupDocs.TryGetValue(contactId, out var list))
+                        {
+                            list = new System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, object?>>();
+                            backupDocs[contactId] = list;
+                        }
+
+                        list.Add(new System.Collections.Generic.Dictionary<string, object?>
+                        {
+                            ["DocumentPath"] = reader.IsDBNull(1) ? null : reader.GetString(1),
+                            ["FileName"] = reader.IsDBNull(2) ? null : reader.GetString(2),
+                            ["FileSize"] = reader.IsDBNull(3) ? 0L : reader.GetInt64(3),
+                            ["ContentType"] = reader.IsDBNull(4) ? null : reader.GetString(4),
+                            ["DocumentType"] = reader.IsDBNull(5) ? null : reader.GetString(5),
+                            ["UploadedAt"] = reader.IsDBNull(6) ? (DateTime?)null : reader.GetDateTime(6)
+                        });
+                    }
+                }
+
+                var backupBanks = new System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, object?>>>();
+                var bankCmd = backupConn.CreateCommand();
+                bankCmd.CommandText = $@"
+SELECT ContactId, AccountNumber, BankName, BranchName, IfscCode, CreatedAt, UpdatedAt
+FROM ContactBankAccounts
+WHERE ContactId IN ({idList});";
+                await using (var reader = await bankCmd.ExecuteReaderAsync())
+                {
+                    while (await reader.ReadAsync())
+                    {
+                        var contactId = reader.GetInt32(0);
+                        if (!backupBanks.TryGetValue(contactId, out var list))
+                        {
+                            list = new System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, object?>>();
+                            backupBanks[contactId] = list;
+                        }
+
+                        list.Add(new System.Collections.Generic.Dictionary<string, object?>
+                        {
+                            ["AccountNumber"] = reader.IsDBNull(1) ? null : reader.GetString(1),
+                            ["BankName"] = reader.IsDBNull(2) ? null : reader.GetString(2),
+                            ["BranchName"] = reader.IsDBNull(3) ? null : reader.GetString(3),
+                            ["IfscCode"] = reader.IsDBNull(4) ? null : reader.GetString(4),
+                            ["CreatedAt"] = reader.IsDBNull(5) ? (DateTime?)null : reader.GetDateTime(5),
+                            ["UpdatedAt"] = reader.IsDBNull(6) ? (DateTime?)null : reader.GetDateTime(6)
+                        });
+                    }
+                }
+
+                // Merge into current DB
+                _context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.TrackAll;
+
+                var restoredCount = 0;
+                var copiedFiles = 0;
+
+                foreach (var backupContact in contactsToRestore)
+                {
+                    var firstName = backupContact["FirstName"]?.ToString() ?? string.Empty;
+                    var lastName = backupContact["LastName"]?.ToString();
+                    var nickName = backupContact["NickName"]?.ToString();
+
+                    var normalizedFirstName = NormalizeText(firstName);
+                    if (!wantedNames.Contains(normalizedFirstName))
+                    {
+                        continue;
+                    }
+
+                    var normalizedLastName = NormalizeText(lastName);
+                    var normalizedNickName = NormalizeText(nickName);
+
+                    var existing = _context.Contacts
+                        .Include(c => c.Photos)
+                        .Include(c => c.Documents)
+                        .Include(c => c.BankAccounts)
+                        .FirstOrDefault(c =>
+                            NormalizeText(c.FirstName) == normalizedFirstName &&
+                            NormalizeText(c.LastName) == normalizedLastName &&
+                            NormalizeText(c.NickName) == normalizedNickName);
+
+                    if (existing == null)
+                    {
+                        existing = new Contact();
+                        _context.Contacts.Add(existing);
+                    }
+
+                    // Copy scalar fields
+                    existing.FirstName = firstName;
+                    existing.LastName = lastName;
+                    existing.NickName = nickName;
+                    existing.Gender = backupContact["Gender"]?.ToString();
+                    existing.DateOfBirth = backupContact["DateOfBirth"] as DateTime?;
+                    existing.Email = backupContact["Email"]?.ToString();
+                    existing.Mobile1 = backupContact["Mobile1"]?.ToString();
+                    existing.Mobile2 = backupContact["Mobile2"]?.ToString();
+                    existing.Mobile3 = backupContact["Mobile3"]?.ToString();
+                    existing.WhatsAppNumber = backupContact["WhatsAppNumber"]?.ToString();
+                    existing.PassportNumber = backupContact["PassportNumber"]?.ToString();
+                    existing.PanNumber = backupContact["PanNumber"]?.ToString();
+                    existing.AadharNumber = backupContact["AadharNumber"]?.ToString();
+                    existing.DrivingLicenseNumber = backupContact["DrivingLicenseNumber"]?.ToString();
+                    existing.VotersId = backupContact["VotersId"]?.ToString();
+                    existing.BankAccountNumber = backupContact["BankAccountNumber"]?.ToString();
+                    existing.BankName = backupContact["BankName"]?.ToString();
+                    existing.BranchName = backupContact["BranchName"]?.ToString();
+                    existing.IfscCode = backupContact["IfscCode"]?.ToString();
+                    existing.Address = backupContact["Address"]?.ToString();
+                    existing.City = backupContact["City"]?.ToString();
+                    existing.State = backupContact["State"]?.ToString();
+                    existing.PostalCode = backupContact["PostalCode"]?.ToString();
+                    existing.Country = backupContact["Country"]?.ToString();
+                    existing.PhotoPath = backupContact["PhotoPath"]?.ToString();
+                    existing.GroupId = backupContact["GroupId"] as int?;
+                    existing.OtherDetails = backupContact["OtherDetails"]?.ToString();
+
+                    existing.CreatedAt = backupContact["CreatedAt"] as DateTime? ?? existing.CreatedAt;
+                    existing.UpdatedAt = DateTime.Now;
+
+                    await _context.SaveChangesAsync();
+
+                    // Replace related data
+                    if (existing.Photos.Any())
+                    {
+                        _context.ContactPhotos.RemoveRange(existing.Photos);
+                    }
+                    if (existing.Documents.Any())
+                    {
+                        _context.ContactDocuments.RemoveRange(existing.Documents);
+                    }
+                    if (existing.BankAccounts.Any())
+                    {
+                        _context.ContactBankAccounts.RemoveRange(existing.BankAccounts);
+                    }
+                    await _context.SaveChangesAsync();
+
+                    var sourceId = Convert.ToInt32(backupContact["Id"]);
+
+                    if (backupPhotos.TryGetValue(sourceId, out var photos))
+                    {
+                        foreach (var row in photos)
+                        {
+                            var photoPath = row["PhotoPath"]?.ToString();
+                            if (!string.IsNullOrWhiteSpace(photoPath))
+                            {
+                                CopyBackupFile(backupUploadsRoot, targetUploadsRoot, photoPath, ref copiedFiles);
+                            }
+
+                            _context.ContactPhotos.Add(new ContactPhoto
+                            {
+                                ContactId = existing.Id,
+                                PhotoPath = photoPath ?? string.Empty,
+                                FileName = row["FileName"]?.ToString() ?? string.Empty,
+                                FileSize = row["FileSize"] is long l ? l : 0L,
+                                ContentType = row["ContentType"]?.ToString() ?? "application/octet-stream",
+                                IsProfilePhoto = row["IsProfilePhoto"] is bool b && b,
+                                UploadedAt = row["UploadedAt"] as DateTime? ?? DateTime.Now
+                            });
+                        }
+                    }
+
+                    if (backupDocs.TryGetValue(sourceId, out var docs))
+                    {
+                        foreach (var row in docs)
+                        {
+                            var docPath = row["DocumentPath"]?.ToString();
+                            if (!string.IsNullOrWhiteSpace(docPath))
+                            {
+                                CopyBackupFile(backupUploadsRoot, targetUploadsRoot, docPath, ref copiedFiles);
+                            }
+
+                            _context.ContactDocuments.Add(new ContactDocument
+                            {
+                                ContactId = existing.Id,
+                                DocumentPath = docPath ?? string.Empty,
+                                FileName = row["FileName"]?.ToString() ?? string.Empty,
+                                FileSize = row["FileSize"] is long l ? l : 0L,
+                                ContentType = row["ContentType"]?.ToString() ?? "application/octet-stream",
+                                DocumentType = row["DocumentType"]?.ToString() ?? "Other",
+                                UploadedAt = row["UploadedAt"] as DateTime? ?? DateTime.Now
+                            });
+                        }
+                    }
+
+                    if (backupBanks.TryGetValue(sourceId, out var banks))
+                    {
+                        foreach (var row in banks)
+                        {
+                            _context.ContactBankAccounts.Add(new ContactBankAccount
+                            {
+                                ContactId = existing.Id,
+                                AccountNumber = row["AccountNumber"]?.ToString(),
+                                BankName = row["BankName"]?.ToString(),
+                                BranchName = row["BranchName"]?.ToString(),
+                                IfscCode = row["IfscCode"]?.ToString(),
+                                CreatedAt = row["CreatedAt"] as DateTime? ?? DateTime.Now,
+                                UpdatedAt = row["UpdatedAt"] as DateTime? ?? DateTime.Now
+                            });
+                        }
+                    }
+
+                    await _context.SaveChangesAsync();
+                    restoredCount++;
+                }
+
+                _context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
+
+                _adminHistoryService.Log(
+                    actionType: "Restore",
+                    entityType: "Contacts",
+                    entityId: 0,
+                    performedBy: currentUser?.UserName ?? "Unknown",
+                    details: $"Restored {restoredCount} key contacts from backup (copied {copiedFiles} files)."
+                );
+
+                TempData["SuccessMessage"] = $"Restored {restoredCount} contact(s) and copied {copiedFiles} file(s).";
+                return RedirectToAction("Index", "Home");
+            }
+            catch (Exception ex)
+            {
+                TempData["ErrorMessage"] = $"Restore failed: {ex.Message}";
+                return RedirectToAction(nameof(RestoreContacts));
+            }
+            finally
+            {
+                try
+                {
+                    if (Directory.Exists(tempRoot))
+                    {
+                        Directory.Delete(tempRoot, recursive: true);
+                    }
+                }
+                catch
+                {
+                    // ignore cleanup issues
+                }
+            }
+
+            static void CopyBackupFile(string backupUploadsRoot, string targetUploadsRoot, string webPath, ref int copiedFiles)
+            {
+                var normalized = webPath.Trim();
+                if (normalized.StartsWith("/") == false)
+                {
+                    normalized = "/" + normalized;
+                }
+
+                if (!normalized.StartsWith("/uploads/", StringComparison.OrdinalIgnoreCase))
+                {
+                    return;
+                }
+
+                var relative = normalized.Substring("/uploads/".Length).Replace('/', Path.DirectorySeparatorChar);
+                var source = Path.Combine(backupUploadsRoot, relative);
+                var dest = Path.Combine(targetUploadsRoot, relative);
+
+                var destDir = Path.GetDirectoryName(dest);
+                if (!string.IsNullOrWhiteSpace(destDir))
+                {
+                    Directory.CreateDirectory(destDir);
+                }
+
+                if (System.IO.File.Exists(source))
+                {
+                    System.IO.File.Copy(source, dest, overwrite: true);
+                    copiedFiles++;
+                }
+            }
+        }
+    }
+}

ContactManagementAPI/Controllers/DocumentController.cs

@@ -0,0 +1,100 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Models;
+using ContactManagementAPI.Services;
+using ContactManagementAPI.Security;
+
+namespace ContactManagementAPI.Controllers
+{
+    public class DocumentController : Controller
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly FileUploadService _fileUploadService;
+
+        public DocumentController(ApplicationDbContext context, FileUploadService fileUploadService)
+        {
+            _context = context;
+            _fileUploadService = fileUploadService;
+        }
+
+        // GET: Document/List/5
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> List(int? id)
+        {
+            if (id == null)
+                return NotFound();
+
+            var contact = await _context.Contacts
+                .Include(c => c.Documents)
+                .FirstOrDefaultAsync(c => c.Id == id);
+
+            if (contact == null)
+                return NotFound();
+
+            return View(contact);
+        }
+
+        // POST: Document/Upload
+        [HttpPost]
+        [RequireRight(RightsCatalog.DocumentsManage)]
+        public async Task<IActionResult> Upload(int contactId, IFormFile documentFile, string documentType = "Other")
+        {
+            var contact = await _context.Contacts.FindAsync(contactId);
+            if (contact == null)
+                return Json(new { success = false, message = "Contact not found" });
+
+            var (success, filePath, errorMessage) = await _fileUploadService.UploadDocumentAsync(documentFile, contactId);
+            if (!success)
+                return Json(new { success = false, message = errorMessage });
+
+            var document = new ContactDocument
+            {
+                ContactId = contactId,
+                DocumentPath = filePath,
+                FileName = documentFile.FileName,
+                FileSize = documentFile.Length,
+                ContentType = documentFile.ContentType,
+                DocumentType = documentType,
+                UploadedAt = DateTime.Now
+            };
+
+            _context.ContactDocuments.Add(document);
+            await _context.SaveChangesAsync();
+
+            return Json(new { success = true, documentId = document.Id, documentPath = filePath });
+        }
+
+        // POST: Document/Delete
+        [HttpPost]
+        [RequireRight(RightsCatalog.DocumentsManage)]
+        public async Task<IActionResult> Delete(int id, int contactId)
+        {
+            var document = await _context.ContactDocuments.FirstOrDefaultAsync(d => d.Id == id && d.ContactId == contactId);
+            if (document == null)
+                return Json(new { success = false, message = "Document not found" });
+
+            _fileUploadService.DeleteFile(document.DocumentPath);
+            _context.ContactDocuments.Remove(document);
+            await _context.SaveChangesAsync();
+
+            return Json(new { success = true, message = "Document deleted" });
+        }
+
+        // GET: Document/Download
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> Download(int id, int contactId)
+        {
+            var document = await _context.ContactDocuments.FirstOrDefaultAsync(d => d.Id == id && d.ContactId == contactId);
+            if (document == null)
+                return NotFound();
+
+            var filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", document.DocumentPath.TrimStart('/'));
+            if (!System.IO.File.Exists(filePath))
+                return NotFound();
+
+            var fileBytes = System.IO.File.ReadAllBytes(filePath);
+            return File(fileBytes, document.ContentType, document.FileName);
+        }
+    }
+}

ContactManagementAPI/Controllers/HomeController.cs

@@ -0,0 +1,1045 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Models;
+using ContactManagementAPI.Services;
+using ContactManagementAPI.Security;
+using System.Globalization;
+
+namespace ContactManagementAPI.Controllers
+{
+    public class HomeController : Controller
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly FileUploadService _fileUploadService;
+        private readonly ImportExportService _importExportService;
+        private readonly ContactStatisticsService _statisticsService;
+        private readonly UserContextService _userContextService;
+        private readonly AdminHistoryService _adminHistoryService;
+
+        public HomeController(
+            ApplicationDbContext context,
+            FileUploadService fileUploadService,
+            ImportExportService importExportService,
+            ContactStatisticsService statisticsService,
+            UserContextService userContextService,
+            AdminHistoryService adminHistoryService)
+        {
+            _context = context;
+            _fileUploadService = fileUploadService;
+            _importExportService = importExportService;
+            _statisticsService = statisticsService;
+            _userContextService = userContextService;
+            _adminHistoryService = adminHistoryService;
+        }
+
+        // GET: Home/Index - Display all contacts with search functionality
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> Index(string searchTerm = "")
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            var contacts = ApplyContactScope(
+                    _context.Contacts
+                        .Include(c => c.Group)
+                        .AsQueryable(),
+                    currentUser)
+                .AsQueryable();
+
+            if (!string.IsNullOrEmpty(searchTerm))
+            {
+                contacts = contacts.Where(c =>
+                    c.FirstName.Contains(searchTerm) ||
+                    (c.LastName != null && c.LastName.Contains(searchTerm)) ||
+                    (c.Email != null && c.Email.Contains(searchTerm)) ||
+                    (c.Mobile1 != null && c.Mobile1.Contains(searchTerm)) ||
+                    (c.Mobile2 != null && c.Mobile2.Contains(searchTerm)) ||
+                    (c.Mobile3 != null && c.Mobile3.Contains(searchTerm)));
+            }
+
+            ViewBag.SearchTerm = searchTerm;
+            return View(await contacts.OrderByDescending(c => c.UpdatedAt).ToListAsync());
+        }
+
+        // GET: Home/Details/5
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> Details(int? id)
+        {
+            if (id == null)
+                return NotFound();
+
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            var contact = await _context.Contacts
+                .Include(c => c.Group)
+                .Include(c => c.Photos)
+                .Include(c => c.Documents)
+                .Include(c => c.BankAccounts)
+                .FirstOrDefaultAsync(c => c.Id == id);
+
+            if (contact == null)
+                return NotFound();
+
+            if (!CanAccessContact(currentUser, contact))
+            {
+                TempData["ErrorMessage"] = "You can view only contacts from your group.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            return View(contact);
+        }
+
+        // GET: Home/Create
+        [RequireRight(RightsCatalog.ContactsCreate)]
+        public IActionResult Create()
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            PopulateFormData();
+
+            if (!currentUser.IsAdmin)
+            {
+                var scopedContactGroupId = ResolveContactGroupIdForUser(currentUser);
+                if (scopedContactGroupId.HasValue)
+                {
+                    ViewData["ForcedGroupId"] = scopedContactGroupId.Value;
+                }
+            }
+
+            return View();
+        }
+
+        // POST: Home/Create
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.ContactsCreate)]
+        public async Task<IActionResult> Create([Bind("FirstName,LastName,NickName,Gender,DateOfBirth,Email,Mobile1,Mobile2,Mobile3,WhatsAppNumber,PassportNumber,PanNumber,AadharNumber,DrivingLicenseNumber,VotersId,Address,City,State,PostalCode,Country,GroupId,OtherDetails")] Contact contact, List<ContactBankAccount>? bankAccounts, IFormFile? profilePhoto)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (!currentUser.IsAdmin)
+            {
+                var scopedContactGroupId = ResolveContactGroupIdForUser(currentUser);
+                if (!scopedContactGroupId.HasValue)
+                {
+                    ModelState.AddModelError(nameof(Contact.GroupId), "Your account is not assigned to a contact group.");
+                }
+                else
+                {
+                    contact.GroupId = scopedContactGroupId.Value;
+                }
+            }
+
+            NormalizeOptionalBankAccountModelState();
+            ValidateDuplicateContact(contact);
+
+            if (ModelState.IsValid)
+            {
+                contact.CreatedAt = DateTime.Now;
+                contact.UpdatedAt = DateTime.Now;
+
+                var preparedBankAccounts = PrepareBankAccounts(bankAccounts);
+                SyncLegacyBankFields(contact, preparedBankAccounts.FirstOrDefault());
+                
+                // Save contact first to get the ID
+                _context.Add(contact);
+                await _context.SaveChangesAsync();
+
+                if (preparedBankAccounts.Any())
+                {
+                    foreach (var bankAccount in preparedBankAccounts)
+                    {
+                        bankAccount.ContactId = contact.Id;
+                    }
+
+                    _context.ContactBankAccounts.AddRange(preparedBankAccounts);
+                    await _context.SaveChangesAsync();
+                }
+                
+                // Handle profile photo upload after we have the contact ID
+                if (profilePhoto != null)
+                {
+                    var result = await _fileUploadService.UploadPhotoAsync(profilePhoto, contact.Id);
+                    if (result.Success)
+                    {
+                        contact.PhotoPath = result.FilePath;
+                        _context.Update(contact);
+                        await _context.SaveChangesAsync();
+                    }
+                }
+
+                _adminHistoryService.Log(
+                    actionType: "Create",
+                    entityType: "Contact",
+                    entityId: contact.Id,
+                    performedBy: _userContextService.CurrentUser?.UserName ?? "Unknown",
+                    details: $"Created contact '{contact.FirstName} {contact.LastName}'.");
+                
+                TempData["SuccessMessage"] = "Contact created successfully!";
+                return RedirectToAction(nameof(Details), new { id = contact.Id });
+            }
+            PopulateFormData(contact, PrepareBankAccounts(bankAccounts));
+            return View(contact);
+        }
+
+        // GET: Home/Edit/5
+        [RequireRight(RightsCatalog.ContactsEdit)]
+        public async Task<IActionResult> Edit(int? id)
+        {
+            if (id == null)
+                return NotFound();
+
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (!currentUser.IsAdmin)
+            {
+                TempData["ErrorMessage"] = "Only admin can edit existing contacts.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            var contact = await _context.Contacts
+                .Include(c => c.BankAccounts)
+                .FirstOrDefaultAsync(c => c.Id == id);
+            if (contact == null)
+                return NotFound();
+
+            PopulateFormData(contact);
+            return View(contact);
+        }
+
+        // POST: Home/Edit/5
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.ContactsEdit)]
+        public async Task<IActionResult> Edit(int id, List<ContactBankAccount>? bankAccounts, IFormFile? profilePhoto)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (!currentUser.IsAdmin)
+            {
+                TempData["ErrorMessage"] = "Only admin can edit existing contacts.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            NormalizeOptionalBankAccountModelState();
+
+            var existingContact = await _context.Contacts
+                .AsTracking()
+                .Include(c => c.BankAccounts)
+                .FirstOrDefaultAsync(c => c.Id == id);
+
+            if (existingContact == null)
+                return NotFound();
+
+            var updateSucceeded = await TryUpdateModelAsync(
+                existingContact,
+                "",
+                c => c.FirstName,
+                c => c.LastName,
+                c => c.NickName,
+                c => c.Gender,
+                c => c.DateOfBirth,
+                c => c.Email,
+                c => c.Mobile1,
+                c => c.Mobile2,
+                c => c.Mobile3,
+                c => c.WhatsAppNumber,
+                c => c.PassportNumber,
+                c => c.PanNumber,
+                c => c.AadharNumber,
+                c => c.DrivingLicenseNumber,
+                c => c.VotersId,
+                c => c.Address,
+                c => c.City,
+                c => c.State,
+                c => c.PostalCode,
+                c => c.Country,
+                c => c.GroupId,
+                c => c.OtherDetails);
+
+            if (!updateSucceeded)
+            {
+                PopulateFormData(existingContact, PrepareBankAccounts(bankAccounts));
+                return View(existingContact);
+            }
+
+            ValidateDuplicateContact(existingContact, id);
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    var postedGender = Request.Form["Gender"].ToString();
+                    existingContact.Gender = string.IsNullOrWhiteSpace(postedGender) ? null : postedGender;
+
+                    var postedDateOfBirth = Request.Form["DateOfBirth"].ToString();
+                    if (string.IsNullOrWhiteSpace(postedDateOfBirth))
+                    {
+                        existingContact.DateOfBirth = null;
+                    }
+                    else if (DateTime.TryParseExact(postedDateOfBirth, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsedDateOfBirth) ||
+                             DateTime.TryParse(postedDateOfBirth, out parsedDateOfBirth))
+                    {
+                        existingContact.DateOfBirth = parsedDateOfBirth;
+                    }
+
+                    existingContact.UpdatedAt = DateTime.Now;
+
+                    var preparedBankAccounts = PrepareBankAccounts(bankAccounts);
+                    if (existingContact.BankAccounts.Any())
+                    {
+                        _context.ContactBankAccounts.RemoveRange(existingContact.BankAccounts);
+                    }
+
+                    if (preparedBankAccounts.Any())
+                    {
+                        foreach (var bankAccount in preparedBankAccounts)
+                        {
+                            bankAccount.ContactId = existingContact.Id;
+                        }
+
+                        _context.ContactBankAccounts.AddRange(preparedBankAccounts);
+                    }
+
+                    SyncLegacyBankFields(existingContact, preparedBankAccounts.FirstOrDefault());
+
+                    // Handle profile photo upload
+                    if (profilePhoto != null)
+                    {
+                        var result = await _fileUploadService.UploadPhotoAsync(profilePhoto, existingContact.Id);
+                        if (result.Success)
+                        {
+                            // Delete old photo if exists
+                            if (!string.IsNullOrEmpty(existingContact.PhotoPath))
+                            {
+                                _fileUploadService.DeleteFile(existingContact.PhotoPath);
+                            }
+                            existingContact.PhotoPath = result.FilePath;
+                        }
+                    }
+                    
+                    await _context.SaveChangesAsync();
+
+                    _adminHistoryService.Log(
+                        actionType: "Edit",
+                        entityType: "Contact",
+                        entityId: existingContact.Id,
+                        performedBy: _userContextService.CurrentUser?.UserName ?? "Unknown",
+                        details: $"Edited contact '{existingContact.FirstName} {existingContact.LastName}'.");
+
+                    TempData["SuccessMessage"] = "Contact updated successfully!";
+                    return RedirectToAction(nameof(Details), new { id = existingContact.Id });
+                }
+                catch (DbUpdateConcurrencyException)
+                {
+                    if (!ContactExists(id))
+                        return NotFound();
+                    throw;
+                }
+            }
+            PopulateFormData(existingContact, PrepareBankAccounts(bankAccounts));
+            return View(existingContact);
+        }
+
+        // GET: Home/Delete/5
+        [RequireRight(RightsCatalog.ContactsDelete)]
+        public async Task<IActionResult> Delete(int? id)
+        {
+            if (id == null)
+                return NotFound();
+
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (!currentUser.IsAdmin)
+            {
+                TempData["ErrorMessage"] = "Only admin can delete contacts.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            var contact = await _context.Contacts
+                .Include(c => c.Group)
+                .FirstOrDefaultAsync(c => c.Id == id);
+
+            if (contact == null)
+                return NotFound();
+
+            return View(contact);
+        }
+
+        // POST: Home/Delete/5
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.ContactsDelete)]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (!currentUser.IsAdmin)
+            {
+                TempData["ErrorMessage"] = "Only admin can delete contacts.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            var contact = await _context.Contacts.FindAsync(id);
+            if (contact != null)
+            {
+                _context.Contacts.Remove(contact);
+                await _context.SaveChangesAsync();
+                TempData["SuccessMessage"] = "Contact deleted successfully!";
+            }
+            return RedirectToAction(nameof(Index));
+        }
+
+        // POST: Home/DeleteMultiple - Bulk delete contacts
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.ContactsDelete)]
+        public async Task<IActionResult> DeleteMultiple(List<int> contactIds)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (!currentUser.IsAdmin)
+            {
+                TempData["ErrorMessage"] = "Only admin can delete contacts.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            if (contactIds == null || !contactIds.Any())
+            {
+                TempData["ErrorMessage"] = "No contacts selected for deletion.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            try
+            {
+                var contactsToDelete = await _context.Contacts
+                    .Where(c => contactIds.Contains(c.Id))
+                    .ToListAsync();
+
+                if (contactsToDelete.Any())
+                {
+                    _context.Contacts.RemoveRange(contactsToDelete);
+                    await _context.SaveChangesAsync();
+
+                    TempData["SuccessMessage"] = $"Successfully deleted {contactsToDelete.Count} contact(s)!";
+                }
+                else
+                {
+                    TempData["ErrorMessage"] = "No matching contacts found to delete.";
+                }
+            }
+            catch (Exception ex)
+            {
+                TempData["ErrorMessage"] = $"Error deleting contacts: {ex.Message}";
+            }
+
+            return RedirectToAction(nameof(Index));
+        }
+
+        private bool ContactExists(int id)
+        {
+            return _context.Contacts.Any(e => e.Id == id);
+        }
+
+        private void PopulateFormData(Contact? contact = null, List<ContactBankAccount>? bankAccounts = null)
+        {
+            ViewData["Groups"] = _context.ContactGroups.OrderBy(g => g.Name).ToList();
+
+            var bankNames = _context.ContactBankAccounts
+                .Where(b => !string.IsNullOrWhiteSpace(b.BankName))
+                .Select(b => b.BankName!)
+                .Distinct()
+                .OrderBy(name => name)
+                .ToList();
+
+            if (!string.IsNullOrWhiteSpace(contact?.BankName) && !bankNames.Contains(contact.BankName))
+            {
+                bankNames.Add(contact.BankName);
+                bankNames = bankNames.OrderBy(name => name).ToList();
+            }
+
+            ViewData["BankNames"] = bankNames;
+
+            if (bankAccounts != null && bankAccounts.Any())
+            {
+                ViewData["BankAccounts"] = bankAccounts;
+                return;
+            }
+
+            if (contact?.BankAccounts != null && contact.BankAccounts.Any())
+            {
+                ViewData["BankAccounts"] = contact.BankAccounts.OrderBy(b => b.Id).ToList();
+                return;
+            }
+
+            if (contact != null && (!string.IsNullOrWhiteSpace(contact.BankAccountNumber) || !string.IsNullOrWhiteSpace(contact.BankName) || !string.IsNullOrWhiteSpace(contact.BranchName) || !string.IsNullOrWhiteSpace(contact.IfscCode)))
+            {
+                ViewData["BankAccounts"] = new List<ContactBankAccount>
+                {
+                    new ContactBankAccount
+                    {
+                        AccountNumber = contact.BankAccountNumber,
+                        BankName = contact.BankName,
+                        BranchName = contact.BranchName,
+                        IfscCode = contact.IfscCode
+                    }
+                };
+                return;
+            }
+
+            ViewData["BankAccounts"] = new List<ContactBankAccount> { new ContactBankAccount() };
+        }
+
+        private static List<ContactBankAccount> PrepareBankAccounts(List<ContactBankAccount>? bankAccounts)
+        {
+            return (bankAccounts ?? new List<ContactBankAccount>())
+                .Where(b => !string.IsNullOrWhiteSpace(b.AccountNumber) || !string.IsNullOrWhiteSpace(b.BankName) || !string.IsNullOrWhiteSpace(b.BranchName) || !string.IsNullOrWhiteSpace(b.IfscCode))
+                .Select(b => new ContactBankAccount
+                {
+                    AccountNumber = b.AccountNumber,
+                    BankName = b.BankName,
+                    BranchName = b.BranchName,
+                    IfscCode = b.IfscCode,
+                    CreatedAt = DateTime.Now,
+                    UpdatedAt = DateTime.Now
+                })
+                .ToList();
+        }
+
+        private static void SyncLegacyBankFields(Contact contact, ContactBankAccount? primaryBankAccount)
+        {
+            if (primaryBankAccount == null)
+            {
+                contact.BankAccountNumber = null;
+                contact.BankName = null;
+                contact.BranchName = null;
+                contact.IfscCode = null;
+                return;
+            }
+
+            contact.BankAccountNumber = primaryBankAccount.AccountNumber;
+            contact.BankName = primaryBankAccount.BankName;
+            contact.BranchName = primaryBankAccount.BranchName;
+            contact.IfscCode = primaryBankAccount.IfscCode;
+        }
+
+        private void NormalizeOptionalBankAccountModelState()
+        {
+            var bankAccountKeys = ModelState.Keys
+                .Where(key => key.StartsWith("bankAccounts[", StringComparison.OrdinalIgnoreCase))
+                .ToList();
+
+            foreach (var key in bankAccountKeys)
+            {
+                ModelState.Remove(key);
+            }
+        }
+
+        private void ValidateDuplicateContact(Contact contact, int? excludeContactId = null)
+        {
+            var normalizedMobile = NormalizeDigits(contact.Mobile1);
+            var normalizedAadhar = NormalizeDigits(contact.AadharNumber);
+
+            if (!string.IsNullOrWhiteSpace(normalizedMobile))
+            {
+                var mobileConflict = _context.Contacts
+                    .AsNoTracking()
+                    .Where(c => c.Id != (excludeContactId ?? 0) && !string.IsNullOrWhiteSpace(c.Mobile1))
+                    .Select(c => new { c.FirstName, c.LastName, c.Mobile1 })
+                    .ToList()
+                    .FirstOrDefault(c => NormalizeDigits(c.Mobile1) == normalizedMobile);
+
+                if (mobileConflict != null)
+                {
+                    ModelState.AddModelError(nameof(Contact.Mobile1),
+                        $"Mobile number already exists for contact '{mobileConflict.FirstName} {mobileConflict.LastName}'.");
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(normalizedAadhar))
+            {
+                var aadharConflict = _context.Contacts
+                    .AsNoTracking()
+                    .Where(c => c.Id != (excludeContactId ?? 0) && !string.IsNullOrWhiteSpace(c.AadharNumber))
+                    .Select(c => new { c.FirstName, c.LastName, c.AadharNumber })
+                    .ToList()
+                    .FirstOrDefault(c => NormalizeDigits(c.AadharNumber) == normalizedAadhar);
+
+                if (aadharConflict != null)
+                {
+                    ModelState.AddModelError(nameof(Contact.AadharNumber),
+                        $"Aadhar number already exists for contact '{aadharConflict.FirstName} {aadharConflict.LastName}'.");
+                }
+            }
+
+            if (string.IsNullOrWhiteSpace(normalizedMobile) && string.IsNullOrWhiteSpace(normalizedAadhar))
+            {
+                var firstName = NormalizeText(contact.FirstName);
+                var lastName = NormalizeText(contact.LastName);
+                var nickName = NormalizeText(contact.NickName);
+
+                if (!string.IsNullOrWhiteSpace(firstName))
+                {
+                    var nameConflict = _context.Contacts
+                        .AsNoTracking()
+                        .Where(c => c.Id != (excludeContactId ?? 0) && !string.IsNullOrWhiteSpace(c.FirstName))
+                        .Select(c => new { c.FirstName, c.LastName, c.NickName })
+                        .ToList()
+                        .FirstOrDefault(c =>
+                            NormalizeText(c.FirstName) == firstName &&
+                            NormalizeText(c.LastName) == lastName &&
+                            NormalizeText(c.NickName) == nickName);
+
+                    if (nameConflict != null)
+                    {
+                        ModelState.AddModelError(nameof(Contact.FirstName),
+                            "A contact with the same First Name, Last Name, and Nick Name already exists. Provide Mobile1 or Aadhar if this is a different person.");
+                    }
+                }
+            }
+        }
+
+        private List<Contact> FilterDuplicateImportedContacts(List<Contact> contacts, List<string> errors)
+        {
+            var validContacts = new List<Contact>();
+
+            var existingContacts = _context.Contacts
+                .AsNoTracking()
+                .Select(c => new { c.FirstName, c.LastName, c.NickName, c.Mobile1, c.AadharNumber })
+                .ToList();
+
+            var seenMobiles = new HashSet<string>();
+            var seenAadhars = new HashSet<string>();
+            var seenNames = new HashSet<string>();
+
+            for (var i = 0; i < contacts.Count; i++)
+            {
+                var contact = contacts[i];
+                var rowLabel = $"Row {i + 1} ({contact.FirstName} {contact.LastName})";
+
+                var normalizedMobile = NormalizeDigits(contact.Mobile1);
+                var normalizedAadhar = NormalizeDigits(contact.AadharNumber);
+                var firstName = NormalizeText(contact.FirstName);
+                var lastName = NormalizeText(contact.LastName);
+                var nickName = NormalizeText(contact.NickName);
+                var nameKey = $"{firstName}|{lastName}|{nickName}";
+
+                var hasError = false;
+
+                if (!string.IsNullOrWhiteSpace(normalizedMobile))
+                {
+                    var existsInDb = existingContacts.Any(c => NormalizeDigits(c.Mobile1) == normalizedMobile);
+                    var existsInImport = seenMobiles.Contains(normalizedMobile);
+                    if (existsInDb || existsInImport)
+                    {
+                        errors.Add($"{rowLabel}: Mobile1 already exists.");
+                        hasError = true;
+                    }
+                }
+
+                if (!string.IsNullOrWhiteSpace(normalizedAadhar))
+                {
+                    var existsInDb = existingContacts.Any(c => NormalizeDigits(c.AadharNumber) == normalizedAadhar);
+                    var existsInImport = seenAadhars.Contains(normalizedAadhar);
+                    if (existsInDb || existsInImport)
+                    {
+                        errors.Add($"{rowLabel}: AadharNumber already exists.");
+                        hasError = true;
+                    }
+                }
+
+                if (string.IsNullOrWhiteSpace(normalizedMobile) && string.IsNullOrWhiteSpace(normalizedAadhar))
+                {
+                    var existsInDb = existingContacts.Any(c =>
+                        NormalizeText(c.FirstName) == firstName &&
+                        NormalizeText(c.LastName) == lastName &&
+                        NormalizeText(c.NickName) == nickName);
+                    var existsInImport = seenNames.Contains(nameKey);
+
+                    if (existsInDb || existsInImport)
+                    {
+                        errors.Add($"{rowLabel}: Same First Name + Last Name + Nick Name already exists.");
+                        hasError = true;
+                    }
+                }
+
+                if (hasError)
+                {
+                    continue;
+                }
+
+                if (!string.IsNullOrWhiteSpace(normalizedMobile))
+                {
+                    seenMobiles.Add(normalizedMobile);
+                }
+
+                if (!string.IsNullOrWhiteSpace(normalizedAadhar))
+                {
+                    seenAadhars.Add(normalizedAadhar);
+                }
+
+                if (string.IsNullOrWhiteSpace(normalizedMobile) && string.IsNullOrWhiteSpace(normalizedAadhar))
+                {
+                    seenNames.Add(nameKey);
+                }
+
+                validContacts.Add(contact);
+            }
+
+            return validContacts;
+        }
+
+        private static string NormalizeDigits(string? value)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                return string.Empty;
+            }
+
+            return new string(value.Where(char.IsDigit).ToArray());
+        }
+
+        private static string NormalizeText(string? value)
+        {
+            return (value ?? string.Empty).Trim().ToUpperInvariant();
+        }
+
+        #region Import/Export Actions
+
+        // GET: Home/Dashboard - Display contact statistics
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> Dashboard()
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (!currentUser.IsAdmin)
+            {
+                TempData["ErrorMessage"] = "Dashboard is available only for admin.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            var statistics = await _statisticsService.GetStatisticsAsync();
+            return View(statistics);
+        }
+
+        // GET: Home/FindDuplicates - Display potential duplicate contacts
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> FindDuplicates()
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (!currentUser.IsAdmin)
+            {
+                TempData["ErrorMessage"] = "Find Duplicates is available only for admin.";
+                return RedirectToAction(nameof(Index));
+            }
+
+            var duplicates = await _statisticsService.FindDuplicatesAsync();
+            return View(duplicates);
+        }
+
+        // GET: Home/Import - Display import page
+        [RequireRight(RightsCatalog.ContactsCreate)]
+        public IActionResult Import()
+        {
+            return View();
+        }
+
+        // POST: Home/ImportFile - Handle file import
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        [RequireRight(RightsCatalog.ContactsCreate)]
+        public async Task<IActionResult> ImportFile(IFormFile file, string fileType)
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            if (file == null || file.Length == 0)
+            {
+                TempData["ErrorMessage"] = "Please select a file to import.";
+                return RedirectToAction(nameof(Import));
+            }
+
+            List<Contact> contacts;
+            List<string> errors;
+
+            try
+            {
+                using var stream = file.OpenReadStream();
+
+                if (fileType == "excel")
+                {
+                    (contacts, errors) = await _importExportService.ImportFromExcel(stream);
+                }
+                else if (fileType == "csv")
+                {
+                    (contacts, errors) = await _importExportService.ImportFromCsv(stream);
+                }
+                else
+                {
+                    TempData["ErrorMessage"] = "Invalid file type selected.";
+                    return RedirectToAction(nameof(Import));
+                }
+
+                if (errors.Any())
+                {
+                    TempData["ErrorMessage"] = $"Import completed with errors:<br/>{string.Join("<br/>", errors)}";
+                }
+
+                if (contacts.Any())
+                {
+                    if (!currentUser.IsAdmin)
+                    {
+                        var scopedContactGroupId = ResolveContactGroupIdForUser(currentUser);
+                        if (!scopedContactGroupId.HasValue)
+                        {
+                            TempData["ErrorMessage"] = "Your account is not assigned to a contact group.";
+                            return RedirectToAction(nameof(Import));
+                        }
+
+                        foreach (var importedContact in contacts)
+                        {
+                            importedContact.GroupId = scopedContactGroupId.Value;
+                        }
+                    }
+
+                    contacts = FilterDuplicateImportedContacts(contacts, errors);
+
+                    if (errors.Any())
+                    {
+                        TempData["ErrorMessage"] = $"Import completed with errors:<br/>{string.Join("<br/>", errors)}";
+                    }
+
+                    if (!contacts.Any())
+                    {
+                        TempData["ErrorMessage"] = TempData["ErrorMessage"] ?? "No valid contacts found in the file.";
+                        return RedirectToAction(nameof(Import));
+                    }
+
+                    // Set change tracking to true for saving
+                    _context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.TrackAll;
+                    
+                    await _context.Contacts.AddRangeAsync(contacts);
+                    await _context.SaveChangesAsync();
+                    
+                    // Reset tracking behavior
+                    _context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
+
+                    TempData["SuccessMessage"] = $"Successfully imported {contacts.Count} contact(s)!";
+                }
+                else
+                {
+                    TempData["ErrorMessage"] = "No valid contacts found in the file.";
+                }
+            }
+            catch (Exception ex)
+            {
+                TempData["ErrorMessage"] = $"Error importing file: {ex.Message}";
+            }
+
+            return RedirectToAction(nameof(Index));
+        }
+
+        // GET: Home/ExportExcel - Export to Excel
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> ExportExcel()
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            var contacts = await ApplyContactScope(
+                    _context.Contacts
+                        .Include(c => c.Group)
+                        .OrderBy(c => c.FirstName),
+                    currentUser)
+                .ToListAsync();
+
+            var fileBytes = await _importExportService.ExportToExcel(contacts);
+            var fileName = $"Contacts_{DateTime.Now:yyyyMMdd_HHmmss}.xlsx";
+            
+            return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", fileName);
+        }
+
+        // GET: Home/ExportCsv - Export to CSV
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> ExportCsv()
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            var contacts = await ApplyContactScope(
+                    _context.Contacts
+                        .Include(c => c.Group)
+                        .OrderBy(c => c.FirstName),
+                    currentUser)
+                .ToListAsync();
+
+            var fileBytes = await _importExportService.ExportToCsv(contacts);
+            var fileName = $"Contacts_{DateTime.Now:yyyyMMdd_HHmmss}.csv";
+            
+            return File(fileBytes, "text/csv", fileName);
+        }
+
+        // GET: Home/ExportPdf - Export to PDF
+        [RequireRight(RightsCatalog.ContactsView)]
+        public async Task<IActionResult> ExportPdf()
+        {
+            var currentUser = _userContextService.CurrentUser;
+            if (currentUser == null)
+            {
+                return RedirectToAction("Login", "Account");
+            }
+
+            var contacts = await ApplyContactScope(
+                    _context.Contacts
+                        .Include(c => c.Group)
+                        .OrderBy(c => c.FirstName),
+                    currentUser)
+                .ToListAsync();
+
+            var fileBytes = await _importExportService.ExportToPdf(contacts);
+            var fileName = $"Contacts_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";
+            
+            return File(fileBytes, "application/pdf", fileName);
+        }
+
+        // GET: Home/DownloadTemplate - Download import template
+        public async Task<IActionResult> DownloadTemplate(string type)
+        {
+            if (type == "excel")
+            {
+                var fileBytes = await _importExportService.GenerateExcelTemplate();
+                return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Contact_Import_Template.xlsx");
+            }
+            else if (type == "csv")
+            {
+                var fileBytes = await _importExportService.GenerateCsvTemplate();
+                return File(fileBytes, "text/csv", "Contact_Import_Template.csv");
+            }
+
+            return NotFound();
+        }
+
+        private IQueryable<Contact> ApplyContactScope(IQueryable<Contact> query, AppUser currentUser)
+        {
+            if (currentUser.IsAdmin)
+            {
+                return query;
+            }
+
+            var scopedContactGroupId = ResolveContactGroupIdForUser(currentUser);
+            if (!scopedContactGroupId.HasValue)
+            {
+                return query.Where(c => false);
+            }
+
+            var groupId = scopedContactGroupId.Value;
+            return query.Where(c => c.GroupId == groupId);
+        }
+
+        private bool CanAccessContact(AppUser currentUser, Contact contact)
+        {
+            if (currentUser.IsAdmin)
+            {
+                return true;
+            }
+
+            var scopedContactGroupId = ResolveContactGroupIdForUser(currentUser);
+            return scopedContactGroupId.HasValue && contact.GroupId == scopedContactGroupId.Value;
+        }
+
+        private int? ResolveContactGroupIdForUser(AppUser user)
+        {
+            if (user.IsAdmin)
+            {
+                return null;
+            }
+
+            if (user.GroupId <= 0)
+            {
+                return null;
+            }
+
+            var userGroupName = _context.UserGroups
+                .Where(g => g.Id == user.GroupId)
+                .Select(g => g.Name)
+                .FirstOrDefault();
+
+            if (!string.IsNullOrWhiteSpace(userGroupName) && userGroupName.StartsWith("ContactGroup - ", StringComparison.OrdinalIgnoreCase))
+            {
+                var contactGroupName = userGroupName.Substring("ContactGroup - ".Length).Trim();
+                var mappedContactGroupId = _context.ContactGroups
+                    .Where(cg => cg.Name == contactGroupName)
+                    .Select(cg => (int?)cg.Id)
+                    .FirstOrDefault();
+
+                if (mappedContactGroupId.HasValue)
+                {
+                    return mappedContactGroupId.Value;
+                }
+            }
+
+            var directMatch = _context.ContactGroups
+                .Where(cg => cg.Id == user.GroupId)
+                .Select(cg => (int?)cg.Id)
+                .FirstOrDefault();
+
+            return directMatch;
+        }
+
+        #endregion
+    }
+}

ContactManagementAPI/Controllers/PhotoController.cs

@@ -0,0 +1,176 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Models;
+using ContactManagementAPI.Services;
+using ContactManagementAPI.Security;
+using System.Text.Json;
+
+namespace ContactManagementAPI.Controllers
+{
+    public class PhotoController : Controller
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly FileUploadService _fileUploadService;
+
+        public PhotoController(ApplicationDbContext context, FileUploadService fileUploadService)
+        {
+            _context = context;
+            _fileUploadService = fileUploadService;
+        }
+
+        // GET: Photo/Gallery/5
+        [RequireRight(RightsCatalog.PhotosManage)]
+        public async Task<IActionResult> Gallery(int? id)
+        {
+            if (id == null)
+                return NotFound();
+
+            var contact = await _context.Contacts
+                .Include(c => c.Photos)
+                .FirstOrDefaultAsync(c => c.Id == id);
+
+            if (contact == null)
+                return NotFound();
+
+            return View(contact);
+        }
+
+        // POST: Photo/Upload
+        [HttpPost]
+        [RequireRight(RightsCatalog.PhotosManage)]
+        public async Task<IActionResult> Upload(int contactId, IFormFile photoFile)
+        {
+            var contact = await _context.Contacts.FindAsync(contactId);
+            if (contact == null)
+                return Json(new { success = false, message = "Contact not found" });
+
+            var (success, filePath, errorMessage) = await _fileUploadService.UploadPhotoAsync(photoFile, contactId);
+            if (!success)
+                return Json(new { success = false, message = errorMessage });
+
+            var photo = new ContactPhoto
+            {
+                ContactId = contactId,
+                PhotoPath = filePath,
+                FileName = photoFile.FileName,
+                FileSize = photoFile.Length,
+                ContentType = photoFile.ContentType,
+                IsProfilePhoto = false,
+                UploadedAt = DateTime.Now
+            };
+
+            _context.ContactPhotos.Add(photo);
+            await _context.SaveChangesAsync();
+
+            return Json(new { success = true, photoId = photo.Id, photoPath = filePath });
+        }
+
+        // POST: Photo/SetProfilePhoto
+        [HttpPost]
+        [RequireRight(RightsCatalog.PhotosManage)]
+        public async Task<IActionResult> SetProfilePhoto(int contactId, int photoId)
+        {
+            (contactId, photoId) = await ResolveContactAndPhotoIdsAsync(contactId, photoId);
+
+            var contact = await _context.Contacts
+                .Include(c => c.Photos)
+                .FirstOrDefaultAsync(c => c.Id == contactId);
+
+            if (contact == null)
+                return Json(new { success = false, message = "Contact not found" });
+
+            var photo = await _context.ContactPhotos.FirstOrDefaultAsync(p => p.Id == photoId && p.ContactId == contactId);
+            if (photo == null)
+                return Json(new { success = false, message = "Photo not found" });
+
+            // Unset all other profile photos
+            foreach (var p in contact.Photos.Where(p => p.IsProfilePhoto))
+            {
+                p.IsProfilePhoto = false;
+            }
+
+            photo.IsProfilePhoto = true;
+            contact.PhotoPath = photo.PhotoPath;
+            _context.Update(contact);
+            await _context.SaveChangesAsync();
+
+            return Json(new { success = true, message = "Profile photo updated" });
+        }
+
+        // POST: Photo/Delete
+        [HttpPost]
+        [RequireRight(RightsCatalog.PhotosManage)]
+        public async Task<IActionResult> Delete(int id, int contactId)
+        {
+            (contactId, id) = await ResolveContactAndPhotoIdsAsync(contactId, id);
+
+            var photo = await _context.ContactPhotos.FirstOrDefaultAsync(p => p.Id == id && p.ContactId == contactId);
+            if (photo == null)
+            {
+                photo = await _context.ContactPhotos.FirstOrDefaultAsync(p => p.Id == id);
+            }
+
+            if (photo == null)
+                return Json(new { success = false, message = "Photo not found" });
+
+            _fileUploadService.DeleteFile(photo.PhotoPath);
+            _context.ContactPhotos.Remove(photo);
+            await _context.SaveChangesAsync();
+
+            return Json(new { success = true, message = "Photo deleted" });
+        }
+
+        private async Task<(int contactId, int photoId)> ResolveContactAndPhotoIdsAsync(int contactId, int photoId)
+        {
+            if (Request.HasFormContentType)
+            {
+                if (contactId <= 0 && int.TryParse(Request.Form["contactId"], out var formContactId))
+                    contactId = formContactId;
+
+                if (photoId <= 0)
+                {
+                    if (int.TryParse(Request.Form["photoId"], out var formPhotoId))
+                        photoId = formPhotoId;
+                    else if (int.TryParse(Request.Form["id"], out var formId))
+                        photoId = formId;
+                }
+            }
+
+            if (contactId <= 0 && int.TryParse(Request.Query["contactId"], out var queryContactId))
+                contactId = queryContactId;
+
+            if (photoId <= 0)
+            {
+                if (int.TryParse(Request.Query["photoId"], out var queryPhotoId))
+                    photoId = queryPhotoId;
+                else if (int.TryParse(Request.Query["id"], out var queryId))
+                    photoId = queryId;
+            }
+
+            if ((contactId <= 0 || photoId <= 0) && Request.ContentType?.Contains("application/json", StringComparison.OrdinalIgnoreCase) == true)
+            {
+                Request.EnableBuffering();
+                Request.Body.Position = 0;
+
+                using var document = await JsonDocument.ParseAsync(Request.Body);
+                var root = document.RootElement;
+
+                if (contactId <= 0 && root.TryGetProperty("contactId", out var jsonContactId) && jsonContactId.TryGetInt32(out var parsedContactId))
+                    contactId = parsedContactId;
+
+                if (photoId <= 0)
+                {
+                    if (root.TryGetProperty("photoId", out var jsonPhotoId) && jsonPhotoId.TryGetInt32(out var parsedPhotoId))
+                        photoId = parsedPhotoId;
+                    else if (root.TryGetProperty("id", out var jsonId) && jsonId.TryGetInt32(out var parsedId))
+                        photoId = parsedId;
+                }
+
+                Request.Body.Position = 0;
+            }
+
+            return (contactId, photoId);
+        }
+    }
+}

ContactManagementAPI/Data/ApplicationDbContext.cs

@@ -0,0 +1,104 @@
+using Microsoft.EntityFrameworkCore;
+using ContactManagementAPI.Models;
+
+namespace ContactManagementAPI.Data
+{
+    public class ApplicationDbContext : DbContext
+    {
+        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
+            : base(options)
+        {
+        }
+
+        public DbSet<Contact> Contacts { get; set; }
+        public DbSet<ContactGroup> ContactGroups { get; set; }
+        public DbSet<ContactPhoto> ContactPhotos { get; set; }
+        public DbSet<ContactDocument> ContactDocuments { get; set; }
+        public DbSet<ContactBankAccount> ContactBankAccounts { get; set; }
+        public DbSet<AppUser> AppUsers { get; set; }
+        public DbSet<UserGroup> UserGroups { get; set; }
+        public DbSet<GroupRight> GroupRights { get; set; }
+        public DbSet<UserRight> UserRights { get; set; }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            base.OnModelCreating(modelBuilder);
+
+            // Contact - ContactGroup relationship
+            modelBuilder.Entity<Contact>()
+                .HasOne(c => c.Group)
+                .WithMany(g => g.Contacts)
+                .HasForeignKey(c => c.GroupId)
+                .OnDelete(DeleteBehavior.SetNull);
+
+            // Contact - ContactPhoto relationship
+            modelBuilder.Entity<ContactPhoto>()
+                .HasOne(cp => cp.Contact)
+                .WithMany(c => c.Photos)
+                .HasForeignKey(cp => cp.ContactId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            // Contact - ContactDocument relationship
+            modelBuilder.Entity<ContactDocument>()
+                .HasOne(cd => cd.Contact)
+                .WithMany(c => c.Documents)
+                .HasForeignKey(cd => cd.ContactId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            modelBuilder.Entity<ContactBankAccount>()
+                .HasOne(cb => cb.Contact)
+                .WithMany(c => c.BankAccounts)
+                .HasForeignKey(cb => cb.ContactId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            // AppUser - UserGroup relationship
+            modelBuilder.Entity<AppUser>()
+                .HasOne(u => u.Group)
+                .WithMany(g => g.Users)
+                .HasForeignKey(u => u.GroupId)
+                .OnDelete(DeleteBehavior.SetNull);
+
+            // GroupRight - UserGroup relationship
+            modelBuilder.Entity<GroupRight>()
+                .HasOne(gr => gr.UserGroup)
+                .WithMany(g => g.GroupRights)
+                .HasForeignKey(gr => gr.UserGroupId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            // UserRight - AppUser relationship
+            modelBuilder.Entity<UserRight>()
+                .HasOne(ur => ur.AppUser)
+                .WithMany(u => u.UserRights)
+                .HasForeignKey(ur => ur.AppUserId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            modelBuilder.Entity<AppUser>()
+                .HasIndex(u => u.UserName)
+                .IsUnique();
+
+            modelBuilder.Entity<UserGroup>()
+                .HasIndex(g => g.Name)
+                .IsUnique();
+
+            modelBuilder.Entity<GroupRight>()
+                .HasIndex(gr => new { gr.UserGroupId, gr.RightKey })
+                .IsUnique();
+
+            modelBuilder.Entity<UserRight>()
+                .HasIndex(ur => new { ur.AppUserId, ur.RightKey })
+                .IsUnique();
+
+            // Seed default contact groups
+            modelBuilder.Entity<ContactGroup>().HasData(
+                new ContactGroup { Id = 1, Name = "Family", Description = "Family members", CreatedAt = DateTime.Now },
+                new ContactGroup { Id = 2, Name = "Friends", Description = "Friends", CreatedAt = DateTime.Now },
+                new ContactGroup { Id = 3, Name = "Business", Description = "Business contacts", CreatedAt = DateTime.Now },
+                new ContactGroup { Id = 4, Name = "School", Description = "School contacts", CreatedAt = DateTime.Now },
+                new ContactGroup { Id = 5, Name = "Church", Description = "Church members", CreatedAt = DateTime.Now },
+                new ContactGroup { Id = 6, Name = "Others", Description = "Other contacts", CreatedAt = DateTime.Now },
+                new ContactGroup { Id = 7, Name = "College", Description = "College contacts", CreatedAt = DateTime.Now },
+                new ContactGroup { Id = 8, Name = "AA", Description = "Alcoholics Anonymous", CreatedAt = DateTime.Now }
+            );
+        }
+    }
+}

ContactManagementAPI/Migrations/20260206165849_InitialCreate.Designer.cs

@@ -0,0 +1,305 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260206165849_InitialCreate")]
+    partial class InitialCreate
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2243),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2260),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2263),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2266),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2270),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2273),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Migrations/20260206165849_InitialCreate.cs

@@ -0,0 +1,162 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
+
+namespace ContactManagementAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialCreate : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "ContactGroups",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Name = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Description = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ContactGroups", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Contacts",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    FirstName = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    LastName = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    NickName = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Email = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Mobile1 = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Mobile2 = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Mobile3 = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    WhatsAppNumber = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Address = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    City = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    State = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    PostalCode = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Country = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    PhotoPath = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    GroupId = table.Column<int>(type: "int", nullable: true),
+                    OtherDetails = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Contacts", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Contacts_ContactGroups_GroupId",
+                        column: x => x.GroupId,
+                        principalTable: "ContactGroups",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ContactDocuments",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    ContactId = table.Column<int>(type: "int", nullable: false),
+                    DocumentPath = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    FileName = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    FileSize = table.Column<long>(type: "bigint", nullable: false),
+                    ContentType = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    DocumentType = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    UploadedAt = table.Column<DateTime>(type: "datetime2", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ContactDocuments", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ContactDocuments_Contacts_ContactId",
+                        column: x => x.ContactId,
+                        principalTable: "Contacts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ContactPhotos",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    ContactId = table.Column<int>(type: "int", nullable: false),
+                    PhotoPath = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    FileName = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    FileSize = table.Column<long>(type: "bigint", nullable: false),
+                    ContentType = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    IsProfilePhoto = table.Column<bool>(type: "bit", nullable: false),
+                    UploadedAt = table.Column<DateTime>(type: "datetime2", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ContactPhotos", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ContactPhotos_Contacts_ContactId",
+                        column: x => x.ContactId,
+                        principalTable: "Contacts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.InsertData(
+                table: "ContactGroups",
+                columns: new[] { "Id", "CreatedAt", "Description", "Name" },
+                values: new object[,]
+                {
+                    { 1, new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2243), "Family members", "Family" },
+                    { 2, new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2260), "Friends", "Friends" },
+                    { 3, new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2263), "Business contacts", "Business" },
+                    { 4, new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2266), "School contacts", "School" },
+                    { 5, new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2270), "Church members", "Church" },
+                    { 6, new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2273), "Other contacts", "Others" }
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ContactDocuments_ContactId",
+                table: "ContactDocuments",
+                column: "ContactId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ContactPhotos_ContactId",
+                table: "ContactPhotos",
+                column: "ContactId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Contacts_GroupId",
+                table: "Contacts",
+                column: "GroupId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ContactDocuments");
+
+            migrationBuilder.DropTable(
+                name: "ContactPhotos");
+
+            migrationBuilder.DropTable(
+                name: "Contacts");
+
+            migrationBuilder.DropTable(
+                name: "ContactGroups");
+        }
+    }
+}

ContactManagementAPI/Migrations/20260208162549_MakeContactFieldsNullable.Designer.cs

@@ -0,0 +1,291 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260208162549_MakeContactFieldsNullable")]
+    partial class MakeContactFieldsNullable
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5320),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5332),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5333),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5335),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5339),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5340),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Migrations/20260208162549_MakeContactFieldsNullable.cs

@@ -0,0 +1,355 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class MakeContactFieldsNullable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "WhatsAppNumber",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "State",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PostalCode",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PhotoPath",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "OtherDetails",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "NickName",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Mobile3",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Mobile2",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Mobile1",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LastName",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Email",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Country",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "City",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Address",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)");
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5320));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5332));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5333));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5335));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5339));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5340));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "WhatsAppNumber",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "State",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PostalCode",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PhotoPath",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "OtherDetails",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "NickName",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Mobile3",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Mobile2",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Mobile1",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LastName",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Email",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Country",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "City",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Address",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2243));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2260));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2263));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2266));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2270));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 6, 22, 28, 46, 432, DateTimeKind.Local).AddTicks(2273));
+        }
+    }
+}

ContactManagementAPI/Migrations/20260209052719_AddSampleData.Designer.cs

@@ -0,0 +1,291 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260209052719_AddSampleData")]
+    partial class AddSampleData
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8518),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8531),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8533),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8535),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8537),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8538),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Migrations/20260209052719_AddSampleData.cs

@@ -0,0 +1,197 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSampleData : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8518));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8531));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8533));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8535));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8537));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8538));
+
+            // Insert sample contacts
+            migrationBuilder.InsertData(
+                table: "Contacts",
+                columns: new[] { "Id", "FirstName", "LastName", "NickName", "Email", "Mobile1", "Mobile2", "Mobile3", "WhatsAppNumber", "Address", "City", "State", "PostalCode", "Country", "PhotoPath", "GroupId", "OtherDetails", "CreatedAt", "UpdatedAt" },
+                values: new object[,]
+                {
+                    { 1, "John", "Doe", "Johnny", "john.doe@email.com", "+1-555-0101", "+1-555-0102", null, "+1-555-0101", "123 Main Street", "New York", "NY", "10001", "USA", "/uploads/photos/1_sample.jpg", 1, "Close friend from college", new DateTime(2026, 2, 9, 10, 30, 0), new DateTime(2026, 2, 9, 10, 30, 0) },
+                    { 2, "Sarah", "Smith", "Sara", "sarah.smith@email.com", "+1-555-0201", "+1-555-0202", "+1-555-0203", "+1-555-0201", "456 Oak Avenue", "Los Angeles", "CA", "90001", "USA", "/uploads/photos/2_sample.jpg", 2, "Works at Tech Corp", new DateTime(2026, 2, 9, 10, 32, 0), new DateTime(2026, 2, 9, 10, 32, 0) },
+                    { 3, "Michael", "Johnson", "Mike", "michael.j@email.com", "+1-555-0301", null, null, "+1-555-0301", "789 Pine Road", "Chicago", "IL", "60601", "USA", "/uploads/photos/3_sample.jpg", 3, "Project manager", new DateTime(2026, 2, 9, 10, 34, 0), new DateTime(2026, 2, 9, 10, 34, 0) },
+                    { 4, "Emily", "Brown", "Em", "emily.brown@email.com", "+1-555-0401", "+1-555-0402", null, "+1-555-0401", "321 Elm Street", "Houston", "TX", "77001", "USA", "/uploads/photos/4_sample.jpg", 1, "Sister, lives in Houston", new DateTime(2026, 2, 9, 10, 36, 0), new DateTime(2026, 2, 9, 10, 36, 0) },
+                    { 5, "David", "Wilson", "Dave", "david.w@email.com", "+1-555-0501", "+1-555-0502", "+1-555-0503", "+1-555-0501", "654 Cedar Lane", "Phoenix", "AZ", "85001", "USA", "/uploads/photos/5_sample.jpg", 4, "School principal", new DateTime(2026, 2, 9, 10, 38, 0), new DateTime(2026, 2, 9, 10, 38, 0) }
+                });
+
+            // Insert sample documents
+            migrationBuilder.InsertData(
+                table: "ContactDocuments",
+                columns: new[] { "ContactId", "DocumentPath", "FileName", "FileSize", "ContentType", "DocumentType", "UploadedAt" },
+                values: new object[,]
+                {
+                    { 1, "/uploads/documents/1_ID_Proof.pdf", "john_doe_id.pdf", 145000L, "application/pdf", "ID", new DateTime(2026, 2, 9, 10, 30, 0) },
+                    { 1, "/uploads/documents/1_Resume.pdf", "john_doe_resume.pdf", 235000L, "application/pdf", "Resume", new DateTime(2026, 2, 9, 10, 31, 0) },
+                    { 2, "/uploads/documents/2_Business_Card.pdf", "sarah_smith_business.pdf", 89000L, "application/pdf", "Business", new DateTime(2026, 2, 9, 10, 32, 0) },
+                    { 2, "/uploads/documents/2_Address_Proof.pdf", "sarah_address.pdf", 156000L, "application/pdf", "Address", new DateTime(2026, 2, 9, 10, 33, 0) },
+                    { 3, "/uploads/documents/3_Contract.pdf", "michael_contract.pdf", 289000L, "application/pdf", "Contract", new DateTime(2026, 2, 9, 10, 34, 0) },
+                    { 4, "/uploads/documents/4_ID_Proof.pdf", "emily_id.pdf", 167000L, "application/pdf", "ID", new DateTime(2026, 2, 9, 10, 36, 0) },
+                    { 5, "/uploads/documents/5_Certification.pdf", "david_certification.pdf", 198000L, "application/pdf", "Certification", new DateTime(2026, 2, 9, 10, 38, 0) },
+                    { 5, "/uploads/documents/5_License.pdf", "david_license.pdf", 142000L, "application/pdf", "License", new DateTime(2026, 2, 9, 10, 39, 0) }
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DeleteData(
+                table: "ContactDocuments",
+                keyColumn: "Id",
+                keyValue: 1);
+
+            migrationBuilder.DeleteData(
+                table: "ContactDocuments",
+                keyColumn: "Id",
+                keyValue: 2);
+
+            migrationBuilder.DeleteData(
+                table: "ContactDocuments",
+                keyColumn: "Id",
+                keyValue: 3);
+
+            migrationBuilder.DeleteData(
+                table: "ContactDocuments",
+                keyColumn: "Id",
+                keyValue: 4);
+
+            migrationBuilder.DeleteData(
+                table: "ContactDocuments",
+                keyColumn: "Id",
+                keyValue: 5);
+
+            migrationBuilder.DeleteData(
+                table: "ContactDocuments",
+                keyColumn: "Id",
+                keyValue: 6);
+
+            migrationBuilder.DeleteData(
+                table: "ContactDocuments",
+                keyColumn: "Id",
+                keyValue: 7);
+
+            migrationBuilder.DeleteData(
+                table: "ContactDocuments",
+                keyColumn: "Id",
+                keyValue: 8);
+
+            migrationBuilder.DeleteData(
+                table: "Contacts",
+                keyColumn: "Id",
+                keyValue: 1);
+
+            migrationBuilder.DeleteData(
+                table: "Contacts",
+                keyColumn: "Id",
+                keyValue: 2);
+
+            migrationBuilder.DeleteData(
+                table: "Contacts",
+                keyColumn: "Id",
+                keyValue: 3);
+
+            migrationBuilder.DeleteData(
+                table: "Contacts",
+                keyColumn: "Id",
+                keyValue: 4);
+
+            migrationBuilder.DeleteData(
+                table: "Contacts",
+                keyColumn: "Id",
+                keyValue: 5);
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5320));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5332));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5333));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5335));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5339));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 8, 21, 55, 46, 992, DateTimeKind.Local).AddTicks(5340));
+        }
+    }
+}

ContactManagementAPI/Migrations/20260209090000_AddUserSecurity.Designer.cs

@@ -0,0 +1,463 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260209090000_AddUserSecurity")]
+    partial class AddUserSecurity
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8518),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8531),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8533),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8535),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8537),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8538),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FullName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("AppUsers");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("UserGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserGroupId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("GroupRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("UserGroups");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AppUserId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AppUserId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "Group")
+                        .WithMany("Users")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "UserGroup")
+                        .WithMany("GroupRights")
+                        .HasForeignKey("UserGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UserGroup");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.AppUser", "AppUser")
+                        .WithMany("UserRights")
+                        .HasForeignKey("AppUserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AppUser");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Navigation("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Navigation("GroupRights");
+
+                    b.Navigation("Users");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Migrations/20260209090000_AddUserSecurity.cs

@@ -0,0 +1,143 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddUserSecurity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "UserGroups",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Name = table.Column<string>(type: "nvarchar(150)", maxLength: 150, nullable: false),
+                    Description = table.Column<string>(type: "nvarchar(500)", maxLength: 500, nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserGroups", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AppUsers",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    UserName = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: false),
+                    PasswordHash = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    FullName = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: true),
+                    IsAdmin = table.Column<bool>(type: "bit", nullable: false),
+                    IsActive = table.Column<bool>(type: "bit", nullable: false),
+                    GroupId = table.Column<int>(type: "int", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AppUsers", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_AppUsers_UserGroups_GroupId",
+                        column: x => x.GroupId,
+                        principalTable: "UserGroups",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "GroupRights",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    UserGroupId = table.Column<int>(type: "int", nullable: false),
+                    RightKey = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: false),
+                    IsGranted = table.Column<bool>(type: "bit", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GroupRights", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_GroupRights_UserGroups_UserGroupId",
+                        column: x => x.UserGroupId,
+                        principalTable: "UserGroups",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "UserRights",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    AppUserId = table.Column<int>(type: "int", nullable: false),
+                    RightKey = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: false),
+                    IsGranted = table.Column<bool>(type: "bit", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserRights", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_UserRights_AppUsers_AppUserId",
+                        column: x => x.AppUserId,
+                        principalTable: "AppUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AppUsers_GroupId",
+                table: "AppUsers",
+                column: "GroupId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AppUsers_UserName",
+                table: "AppUsers",
+                column: "UserName",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GroupRights_UserGroupId_RightKey",
+                table: "GroupRights",
+                columns: new[] { "UserGroupId", "RightKey" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserGroups_Name",
+                table: "UserGroups",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserRights_AppUserId_RightKey",
+                table: "UserRights",
+                columns: new[] { "AppUserId", "RightKey" },
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "UserRights");
+
+            migrationBuilder.DropTable(
+                name: "GroupRights");
+
+            migrationBuilder.DropTable(
+                name: "AppUsers");
+
+            migrationBuilder.DropTable(
+                name: "UserGroups");
+        }
+    }
+}

ContactManagementAPI/Migrations/20260216070933_AddNewContactGroups.Designer.cs

@@ -0,0 +1,478 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260216070933_AddNewContactGroups")]
+    partial class AddNewContactGroups
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FullName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("AppUsers");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7842),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7855),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7857),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7858),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7860),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7862),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            CreatedAt = new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7863),
+                            Description = "College contacts",
+                            Name = "College"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            CreatedAt = new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7864),
+                            Description = "Alcoholics Anonymous",
+                            Name = "AA"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("UserGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserGroupId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("GroupRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("UserGroups");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AppUserId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AppUserId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "Group")
+                        .WithMany("Users")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "UserGroup")
+                        .WithMany("GroupRights")
+                        .HasForeignKey("UserGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UserGroup");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.AppUser", "AppUser")
+                        .WithMany("UserRights")
+                        .HasForeignKey("AppUserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AppUser");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Navigation("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Navigation("GroupRights");
+
+                    b.Navigation("Users");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Migrations/20260216070933_AddNewContactGroups.cs

@@ -0,0 +1,142 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
+
+namespace ContactManagementAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddNewContactGroups : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<int>(
+                name: "GroupId",
+                table: "AppUsers",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7842));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7855));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7857));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7858));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7860));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7862));
+
+            migrationBuilder.InsertData(
+                table: "ContactGroups",
+                columns: new[] { "Id", "CreatedAt", "Description", "Name" },
+                values: new object[,]
+                {
+                    { 7, new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7863), "College contacts", "College" },
+                    { 8, new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7864), "Alcoholics Anonymous", "AA" }
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DeleteData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 7);
+
+            migrationBuilder.DeleteData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 8);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GroupId",
+                table: "AppUsers",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8518));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8531));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8533));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8535));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8537));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 9, 10, 57, 18, 734, DateTimeKind.Local).AddTicks(8538));
+        }
+    }
+}

ContactManagementAPI/Migrations/20260220171502_AddContactIdentityBankGenderDobFields.Designer.cs

@@ -0,0 +1,508 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260220171502_AddContactIdentityBankGenderDobFields")]
+    partial class AddContactIdentityBankGenderDobFields
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FullName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("AppUsers");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AadharNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankAccountNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BranchName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DrivingLicenseNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Gender")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("IfscCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PassportNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("VotersId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5689),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5716),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5720),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5722),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5723),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5725),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5727),
+                            Description = "College contacts",
+                            Name = "College"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5729),
+                            Description = "Alcoholics Anonymous",
+                            Name = "AA"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("UserGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserGroupId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("GroupRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("UserGroups");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AppUserId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AppUserId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "Group")
+                        .WithMany("Users")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "UserGroup")
+                        .WithMany("GroupRights")
+                        .HasForeignKey("UserGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UserGroup");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.AppUser", "AppUser")
+                        .WithMany("UserRights")
+                        .HasForeignKey("AppUserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AppUser");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Navigation("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Navigation("GroupRights");
+
+                    b.Navigation("Users");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Migrations/20260220171502_AddContactIdentityBankGenderDobFields.cs

@@ -0,0 +1,231 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddContactIdentityBankGenderDobFields : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "AadharNumber",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "BankAccountNumber",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "BankName",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "BranchName",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "DateOfBirth",
+                table: "Contacts",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "DrivingLicenseNumber",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Gender",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "IfscCode",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "PassportNumber",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "VotersId",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5689));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5716));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5720));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5722));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5723));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5725));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 7,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5727));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 8,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5729));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "AadharNumber",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "BankAccountNumber",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "BankName",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "BranchName",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "DateOfBirth",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "DrivingLicenseNumber",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "Gender",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "IfscCode",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "PassportNumber",
+                table: "Contacts");
+
+            migrationBuilder.DropColumn(
+                name: "VotersId",
+                table: "Contacts");
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7842));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7855));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7857));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7858));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7860));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7862));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 7,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7863));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 8,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 16, 12, 39, 30, 575, DateTimeKind.Local).AddTicks(7864));
+        }
+    }
+}

ContactManagementAPI/Migrations/20260220171919_AddContactBankAccountsTable.Designer.cs

@@ -0,0 +1,557 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260220171919_AddContactBankAccountsTable")]
+    partial class AddContactBankAccountsTable
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FullName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("AppUsers");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AadharNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankAccountNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BranchName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DrivingLicenseNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Gender")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("IfscCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PassportNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("VotersId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactBankAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccountNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BranchName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("IfscCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactBankAccounts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4198),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4211),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4213),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4214),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4216),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4217),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4218),
+                            Description = "College contacts",
+                            Name = "College"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            CreatedAt = new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4220),
+                            Description = "Alcoholics Anonymous",
+                            Name = "AA"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("UserGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserGroupId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("GroupRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("UserGroups");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AppUserId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AppUserId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "Group")
+                        .WithMany("Users")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactBankAccount", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("BankAccounts")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "UserGroup")
+                        .WithMany("GroupRights")
+                        .HasForeignKey("UserGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UserGroup");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.AppUser", "AppUser")
+                        .WithMany("UserRights")
+                        .HasForeignKey("AppUserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AppUser");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Navigation("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("BankAccounts");
+
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Navigation("GroupRights");
+
+                    b.Navigation("Users");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Migrations/20260220171919_AddContactBankAccountsTable.cs

@@ -0,0 +1,164 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddContactBankAccountsTable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "ContactBankAccounts",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    ContactId = table.Column<int>(type: "int", nullable: false),
+                    AccountNumber = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    BankName = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    BranchName = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    IfscCode = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ContactBankAccounts", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ContactBankAccounts_Contacts_ContactId",
+                        column: x => x.ContactId,
+                        principalTable: "Contacts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4198));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4211));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4213));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4214));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4216));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4217));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 7,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4218));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 8,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4220));
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ContactBankAccounts_ContactId",
+                table: "ContactBankAccounts",
+                column: "ContactId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ContactBankAccounts");
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5689));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5716));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5720));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5722));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5723));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5725));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 7,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5727));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 8,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 44, 58, 435, DateTimeKind.Local).AddTicks(5729));
+        }
+    }
+}

ContactManagementAPI/Migrations/20260221045734_AddPanNumberToContact.Designer.cs

@@ -0,0 +1,560 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260221045734_AddPanNumberToContact")]
+    partial class AddPanNumberToContact
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FullName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("AppUsers");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AadharNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankAccountNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BranchName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DrivingLicenseNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Gender")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("IfscCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PanNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PassportNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("VotersId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactBankAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccountNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BranchName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("IfscCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactBankAccounts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7176),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7190),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7192),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7196),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7198),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7199),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7200),
+                            Description = "College contacts",
+                            Name = "College"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7202),
+                            Description = "Alcoholics Anonymous",
+                            Name = "AA"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("UserGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserGroupId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("GroupRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("UserGroups");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AppUserId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AppUserId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "Group")
+                        .WithMany("Users")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactBankAccount", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("BankAccounts")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "UserGroup")
+                        .WithMany("GroupRights")
+                        .HasForeignKey("UserGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UserGroup");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.AppUser", "AppUser")
+                        .WithMany("UserRights")
+                        .HasForeignKey("AppUserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AppUser");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Navigation("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("BankAccounts");
+
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Navigation("GroupRights");
+
+                    b.Navigation("Users");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Migrations/20260221045734_AddPanNumberToContact.cs

@@ -0,0 +1,141 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPanNumberToContact : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "PanNumber",
+                table: "Contacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7176));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7190));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7192));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7196));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7198));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7199));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 7,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7200));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 8,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7202));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "PanNumber",
+                table: "Contacts");
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4198));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4211));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4213));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 4,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4214));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 5,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4216));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 6,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4217));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 7,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4218));
+
+            migrationBuilder.UpdateData(
+                table: "ContactGroups",
+                keyColumn: "Id",
+                keyValue: 8,
+                column: "CreatedAt",
+                value: new DateTime(2026, 2, 20, 22, 49, 18, 470, DateTimeKind.Local).AddTicks(4220));
+        }
+    }
+}

ContactManagementAPI/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -0,0 +1,557 @@
+// <auto-generated />
+using System;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ContactManagementAPI.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    partial class ApplicationDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FullName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("AppUsers");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AadharNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankAccountNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BranchName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DrivingLicenseNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Gender")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("GroupId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("IfscCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NickName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OtherDetails")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PanNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PassportNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("VotersId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WhatsAppNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactBankAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccountNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BranchName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("IfscCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactBankAccounts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDocuments");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ContactGroups");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7176),
+                            Description = "Family members",
+                            Name = "Family"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7190),
+                            Description = "Friends",
+                            Name = "Friends"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7192),
+                            Description = "Business contacts",
+                            Name = "Business"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7196),
+                            Description = "School contacts",
+                            Name = "School"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7198),
+                            Description = "Church members",
+                            Name = "Church"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7199),
+                            Description = "Other contacts",
+                            Name = "Others"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7200),
+                            Description = "College contacts",
+                            Name = "College"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            CreatedAt = new DateTime(2026, 2, 21, 10, 27, 31, 12, DateTimeKind.Local).AddTicks(7202),
+                            Description = "Alcoholics Anonymous",
+                            Name = "AA"
+                        });
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsProfilePhoto")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PhotoPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactPhotos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("UserGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserGroupId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("GroupRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("UserGroups");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AppUserId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsGranted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RightKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AppUserId", "RightKey")
+                        .IsUnique();
+
+                    b.ToTable("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "Group")
+                        .WithMany("Users")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.ContactGroup", "Group")
+                        .WithMany("Contacts")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactBankAccount", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("BankAccounts")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactDocument", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Documents")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactPhoto", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.Contact", "Contact")
+                        .WithMany("Photos")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.GroupRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.UserGroup", "UserGroup")
+                        .WithMany("GroupRights")
+                        .HasForeignKey("UserGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UserGroup");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserRight", b =>
+                {
+                    b.HasOne("ContactManagementAPI.Models.AppUser", "AppUser")
+                        .WithMany("UserRights")
+                        .HasForeignKey("AppUserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AppUser");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.AppUser", b =>
+                {
+                    b.Navigation("UserRights");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.Contact", b =>
+                {
+                    b.Navigation("BankAccounts");
+
+                    b.Navigation("Documents");
+
+                    b.Navigation("Photos");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.ContactGroup", b =>
+                {
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("ContactManagementAPI.Models.UserGroup", b =>
+                {
+                    b.Navigation("GroupRights");
+
+                    b.Navigation("Users");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ContactManagementAPI/Models/AdminHistoryEntry.cs

@@ -0,0 +1,12 @@
+namespace ContactManagementAPI.Models
+{
+    public class AdminHistoryEntry
+    {
+        public string ActionType { get; set; } = string.Empty;
+        public string EntityType { get; set; } = string.Empty;
+        public int? EntityId { get; set; }
+        public string Details { get; set; } = string.Empty;
+        public string PerformedBy { get; set; } = string.Empty;
+        public DateTime PerformedAt { get; set; }
+    }
+}

ContactManagementAPI/Models/AppUser.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace ContactManagementAPI.Models
+{
+    public class AppUser
+    {
+        public int Id { get; set; }
+
+        [Required]
+        [MaxLength(100)]
+        public string UserName { get; set; } = string.Empty;
+
+        [Required]
+        public string PasswordHash { get; set; } = string.Empty;
+
+        [MaxLength(200)]
+        public string? FullName { get; set; }
+
+        public bool IsAdmin { get; set; }
+        public bool IsActive { get; set; } = true;
+
+        [Required]
+        public int GroupId { get; set; }
+        public UserGroup? Group { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+        public DateTime UpdatedAt { get; set; }
+
+        public ICollection<UserRight> UserRights { get; set; } = new List<UserRight>();
+    }
+}

ContactManagementAPI/Models/Contact.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace ContactManagementAPI.Models
+{
+    public class Contact
+    {
+        public int Id { get; set; }
+        [Required]
+        public string FirstName { get; set; } = string.Empty;
+        public string? LastName { get; set; }
+        public string? NickName { get; set; }
+        public string? Gender { get; set; }
+        public DateTime? DateOfBirth { get; set; }
+        public string? Email { get; set; }
+        public string? Mobile1 { get; set; }
+        public string? Mobile2 { get; set; }
+        public string? Mobile3 { get; set; }
+        public string? WhatsAppNumber { get; set; }
+        public string? PassportNumber { get; set; }
+        public string? PanNumber { get; set; }
+        public string? AadharNumber { get; set; }
+        public string? DrivingLicenseNumber { get; set; }
+        public string? VotersId { get; set; }
+        public string? BankAccountNumber { get; set; }
+        public string? BankName { get; set; }
+        public string? BranchName { get; set; }
+        public string? IfscCode { get; set; }
+        public string? Address { get; set; }
+        public string? City { get; set; }
+        public string? State { get; set; }
+        public string? PostalCode { get; set; }
+        public string? Country { get; set; }
+        public string? PhotoPath { get; set; }
+        public int? GroupId { get; set; }
+        public ContactGroup? Group { get; set; }
+        public string? OtherDetails { get; set; }
+        public DateTime CreatedAt { get; set; }
+        public DateTime UpdatedAt { get; set; }
+
+        public ICollection<ContactPhoto> Photos { get; set; } = new List<ContactPhoto>();
+        public ICollection<ContactDocument> Documents { get; set; } = new List<ContactDocument>();
+        public ICollection<ContactBankAccount> BankAccounts { get; set; } = new List<ContactBankAccount>();
+    }
+}

ContactManagementAPI/Models/ContactBankAccount.cs

@@ -0,0 +1,15 @@
+namespace ContactManagementAPI.Models
+{
+    public class ContactBankAccount
+    {
+        public int Id { get; set; }
+        public int ContactId { get; set; }
+        public Contact? Contact { get; set; }
+        public string? AccountNumber { get; set; }
+        public string? BankName { get; set; }
+        public string? BranchName { get; set; }
+        public string? IfscCode { get; set; }
+        public DateTime CreatedAt { get; set; }
+        public DateTime UpdatedAt { get; set; }
+    }
+}

ContactManagementAPI/Models/ContactDocument.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace ContactManagementAPI.Models
+{
+    public class ContactDocument
+    {
+        public int Id { get; set; }
+        public int ContactId { get; set; }
+        public Contact Contact { get; set; }
+        public string DocumentPath { get; set; }
+        public string FileName { get; set; }
+        public long FileSize { get; set; }
+        public string ContentType { get; set; }
+        public string DocumentType { get; set; } // e.g., "ID", "Address", "Contract", etc.
+        public DateTime UploadedAt { get; set; }
+    }
+}

ContactManagementAPI/Models/ContactGroup.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+namespace ContactManagementAPI.Models
+{
+    public class ContactGroup
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public DateTime CreatedAt { get; set; }
+
+        public ICollection<Contact> Contacts { get; set; } = new List<Contact>();
+    }
+}

ContactManagementAPI/Models/ContactPhoto.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace ContactManagementAPI.Models
+{
+    public class ContactPhoto
+    {
+        public int Id { get; set; }
+        public int ContactId { get; set; }
+        public Contact Contact { get; set; }
+        public string PhotoPath { get; set; }
+        public string FileName { get; set; }
+        public long FileSize { get; set; }
+        public string ContentType { get; set; }
+        public bool IsProfilePhoto { get; set; }
+        public DateTime UploadedAt { get; set; }
+    }
+}

ContactManagementAPI/Models/GroupRight.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace ContactManagementAPI.Models
+{
+    public class GroupRight
+    {
+        public int Id { get; set; }
+
+        public int UserGroupId { get; set; }
+        public UserGroup? UserGroup { get; set; }
+
+        [Required]
+        [MaxLength(100)]
+        public string RightKey { get; set; } = string.Empty;
+
+        public bool IsGranted { get; set; }
+    }
+}

ContactManagementAPI/Models/RightsCatalog.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+
+namespace ContactManagementAPI.Models
+{
+    public static class RightsCatalog
+    {
+        public const string ContactsView = "Contacts.View";
+        public const string ContactsCreate = "Contacts.Create";
+        public const string ContactsEdit = "Contacts.Edit";
+        public const string ContactsDelete = "Contacts.Delete";
+        public const string DocumentsManage = "Documents.Manage";
+        public const string PhotosManage = "Photos.Manage";
+        public const string AdminManageUsers = "Admin.ManageUsers";
+        public const string AdminManageGroups = "Admin.ManageGroups";
+        public const string AdminManageRights = "Admin.ManageRights";
+
+        public static readonly IReadOnlyList<RightDefinition> All = new List<RightDefinition>
+        {
+            new RightDefinition(ContactsView, "Contacts", "View contacts"),
+            new RightDefinition(ContactsCreate, "Contacts", "Create contacts"),
+            new RightDefinition(ContactsEdit, "Contacts", "Edit contacts"),
+            new RightDefinition(ContactsDelete, "Contacts", "Delete contacts"),
+            new RightDefinition(PhotosManage, "Photos", "Manage photo gallery"),
+            new RightDefinition(DocumentsManage, "Documents", "Manage contact documents"),
+            new RightDefinition(AdminManageUsers, "Administration", "Manage users"),
+            new RightDefinition(AdminManageGroups, "Administration", "Manage user groups"),
+            new RightDefinition(AdminManageRights, "Administration", "Manage rights")
+        };
+    }
+
+    public class RightDefinition
+    {
+        public RightDefinition(string key, string category, string label)
+        {
+            Key = key;
+            Category = category;
+            Label = label;
+        }
+
+        public string Key { get; }
+        public string Category { get; }
+        public string Label { get; }
+    }
+}

ContactManagementAPI/Models/UserGroup.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace ContactManagementAPI.Models
+{
+    public class UserGroup
+    {
+        public int Id { get; set; }
+
+        [Required]
+        [MaxLength(150)]
+        public string Name { get; set; } = string.Empty;
+
+        [MaxLength(500)]
+        public string? Description { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+
+        public ICollection<AppUser> Users { get; set; } = new List<AppUser>();
+        public ICollection<GroupRight> GroupRights { get; set; } = new List<GroupRight>();
+    }
+}

ContactManagementAPI/Models/UserRight.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace ContactManagementAPI.Models
+{
+    public class UserRight
+    {
+        public int Id { get; set; }
+
+        public int AppUserId { get; set; }
+        public AppUser? AppUser { get; set; }
+
+        [Required]
+        [MaxLength(100)]
+        public string RightKey { get; set; } = string.Empty;
+
+        public bool IsGranted { get; set; }
+    }
+}

ContactManagementAPI/Program.cs

@@ -0,0 +1,179 @@
+using Microsoft.EntityFrameworkCore;
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Services;
+using Microsoft.Data.Sqlite;
+using Microsoft.AspNetCore.HttpOverrides;
+using Microsoft.Extensions.FileProviders;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to the container
+builder.Services.AddControllersWithViews()
+    .AddJsonOptions(options =>
+    {
+        // Prevent circular references
+        options.JsonSerializerOptions.ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.IgnoreCycles;
+    });
+builder.Services.AddRazorPages();
+builder.Services.AddHttpContextAccessor();
+builder.Services.AddSession(options =>
+{
+    options.Cookie.HttpOnly = true;
+    options.Cookie.IsEssential = true;
+    options.IdleTimeout = TimeSpan.FromHours(2); // Reduced from 8 to 2 hours to prevent memory buildup
+});
+
+// Add memory cache with size limit
+builder.Services.AddMemoryCache(options =>
+{
+    options.SizeLimit = 1024; // Limit cache size
+});
+
+// Configure Antiforgery with SameSite settings
+builder.Services.AddAntiforgery(options =>
+{
+    options.Cookie.SecurePolicy = CookieSecurePolicy.SameAsRequest;
+    options.Cookie.SameSite = SameSiteMode.Lax;
+});
+
+// Configure database connection (SQLite preferred for portable installs)
+var connectionString = builder.Configuration.GetConnectionString("DefaultConnection")
+    ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");
+
+var useSqlite = connectionString.TrimStart().StartsWith("Data Source=", StringComparison.OrdinalIgnoreCase);
+
+if (useSqlite)
+{
+    var sqliteBuilder = new SqliteConnectionStringBuilder(connectionString);
+    var sqliteDbPathOverride = Environment.GetEnvironmentVariable("SQLITE_DB_PATH");
+    var dataSource = sqliteBuilder.DataSource;
+
+    if (!string.IsNullOrWhiteSpace(sqliteDbPathOverride))
+    {
+        dataSource = sqliteDbPathOverride;
+    }
+
+    if (string.IsNullOrWhiteSpace(dataSource))
+    {
+        dataSource = "ContactManagement.db";
+    }
+
+    if (!Path.IsPathRooted(dataSource))
+    {
+        var appDataFolder = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "ContactManagementSystem");
+
+        Directory.CreateDirectory(appDataFolder);
+        dataSource = Path.Combine(appDataFolder, dataSource);
+    }
+
+    sqliteBuilder.DataSource = dataSource;
+    connectionString = sqliteBuilder.ToString();
+}
+
+builder.Services.AddDbContext<ApplicationDbContext>(options =>
+{
+    if (useSqlite)
+    {
+        options.UseSqlite(connectionString);
+    }
+    else
+    {
+        options.UseSqlServer(connectionString);
+    }
+
+    // Optimize EF Core for better memory management
+    options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
+    options.EnableSensitiveDataLogging(false);
+    options.EnableDetailedErrors(false);
+});
+
+// Add custom services
+builder.Services.AddScoped<FileUploadService>();
+builder.Services.AddScoped<AuthorizationService>();
+builder.Services.AddScoped<UserContextService>();
+builder.Services.AddScoped<ImportExportService>();
+builder.Services.AddScoped<ContactStatisticsService>();
+builder.Services.AddScoped<AdminHistoryService>();
+
+// Configure CORS if needed for future API consumption
+builder.Services.AddCors(options =>
+{
+    options.AddPolicy("AllowAll", policy =>
+    {
+        policy.WithOrigins("http://localhost:5000", "https://localhost:5001")
+            .AllowAnyMethod()
+            .AllowAnyHeader()
+            .AllowCredentials();
+    });
+});
+
+var app = builder.Build();
+
+// Support reverse proxies/load balancers in cloud hosting
+app.UseForwardedHeaders(new ForwardedHeadersOptions
+{
+    ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
+});
+
+var disableHttpsRedirection =
+    app.Configuration.GetValue<bool>("DisableHttpsRedirection") ||
+    string.Equals(Environment.GetEnvironmentVariable("DISABLE_HTTPS_REDIRECTION"), "true", StringComparison.OrdinalIgnoreCase);
+
+// Ensure database exists and seed defaults
+using (var scope = app.Services.CreateScope())
+{
+    var dbContext = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+
+    if (useSqlite)
+    {
+        dbContext.Database.EnsureCreated();
+    }
+    else
+    {
+        dbContext.Database.Migrate();
+    }
+
+    SeedData.Initialize(dbContext);
+}
+
+// Configure the HTTP request pipeline
+if (!app.Environment.IsDevelopment())
+{
+    app.UseExceptionHandler("/Home/Error");
+    app.UseHsts();
+}
+
+if (!disableHttpsRedirection)
+{
+    app.UseHttpsRedirection();
+}
+
+app.UseStaticFiles();
+
+var uploadsRoot = Environment.GetEnvironmentVariable("UPLOADS_ROOT");
+if (!string.IsNullOrWhiteSpace(uploadsRoot) && Directory.Exists(uploadsRoot))
+{
+    Directory.CreateDirectory(Path.Combine(uploadsRoot, "photos"));
+    Directory.CreateDirectory(Path.Combine(uploadsRoot, "documents"));
+
+    app.UseStaticFiles(new StaticFileOptions
+    {
+        FileProvider = new PhysicalFileProvider(uploadsRoot),
+        RequestPath = "/uploads"
+    });
+}
+
+app.UseRouting();
+app.UseSession();
+app.UseCors("AllowAll");
+app.UseAuthorization();
+
+app.MapControllerRoute(
+    name: "default",
+    pattern: "{controller=Home}/{action=Index}/{id?}");
+
+app.MapRazorPages();
+
+app.Run();

ContactManagementAPI/Properties/launchSettings.json

@@ -0,0 +1,37 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:7089",
+      "sslPort": 44318
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "http://localhost:5000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:5001;http://localhost:5000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

ContactManagementAPI/Security/RequireRightAttribute.cs

@@ -0,0 +1,49 @@
+using System.Threading.Tasks;
+using ContactManagementAPI.Models;
+using ContactManagementAPI.Services;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace ContactManagementAPI.Security
+{
+    public class RequireRightAttribute : TypeFilterAttribute
+    {
+        public RequireRightAttribute(string rightKey) : base(typeof(RequireRightFilter))
+        {
+            Arguments = new object[] { rightKey };
+        }
+    }
+
+    public class RequireRightFilter : IAsyncActionFilter
+    {
+        private readonly string _rightKey;
+        private readonly UserContextService _userContext;
+        private readonly AuthorizationService _authorizationService;
+
+        public RequireRightFilter(string rightKey, UserContextService userContext, AuthorizationService authorizationService)
+        {
+            _rightKey = rightKey;
+            _userContext = userContext;
+            _authorizationService = authorizationService;
+        }
+
+        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+        {
+            if (!_userContext.UserId.HasValue)
+            {
+                var returnUrl = context.HttpContext.Request.Path + context.HttpContext.Request.QueryString;
+                context.Result = new RedirectToActionResult("Login", "Account", new { returnUrl });
+                return;
+            }
+
+            var hasRight = _authorizationService.HasRight(_userContext.UserId.Value, _rightKey);
+            if (!hasRight)
+            {
+                context.Result = new RedirectToActionResult("AccessDenied", "Account", null);
+                return;
+            }
+
+            await next();
+        }
+    }
+}

ContactManagementAPI/Services/AdminHistoryService.cs

@@ -0,0 +1,73 @@
+using System.Text.Json;
+using ContactManagementAPI.Models;
+
+namespace ContactManagementAPI.Services
+{
+    public class AdminHistoryService
+    {
+        private readonly string _historyFilePath;
+        private static readonly JsonSerializerOptions JsonOptions = new()
+        {
+            WriteIndented = false
+        };
+
+        public AdminHistoryService(IWebHostEnvironment environment)
+        {
+            var historyDirectory = Path.Combine(environment.ContentRootPath, "App_Data");
+            Directory.CreateDirectory(historyDirectory);
+            _historyFilePath = Path.Combine(historyDirectory, "admin-history.jsonl");
+        }
+
+        public void Log(string actionType, string entityType, int? entityId, string performedBy, string details)
+        {
+            var entry = new AdminHistoryEntry
+            {
+                ActionType = actionType,
+                EntityType = entityType,
+                EntityId = entityId,
+                PerformedBy = string.IsNullOrWhiteSpace(performedBy) ? "Unknown" : performedBy,
+                Details = details,
+                PerformedAt = DateTime.Now
+            };
+
+            var line = JsonSerializer.Serialize(entry, JsonOptions);
+            File.AppendAllText(_historyFilePath, line + Environment.NewLine);
+        }
+
+        public IReadOnlyList<AdminHistoryEntry> GetLatest(int take = 200)
+        {
+            if (!File.Exists(_historyFilePath))
+            {
+                return Array.Empty<AdminHistoryEntry>();
+            }
+
+            var entries = new List<AdminHistoryEntry>();
+            var lines = File.ReadLines(_historyFilePath);
+            foreach (var line in lines)
+            {
+                if (string.IsNullOrWhiteSpace(line))
+                {
+                    continue;
+                }
+
+                try
+                {
+                    var entry = JsonSerializer.Deserialize<AdminHistoryEntry>(line);
+                    if (entry != null)
+                    {
+                        entries.Add(entry);
+                    }
+                }
+                catch
+                {
+                    // Ignore malformed history lines and continue
+                }
+            }
+
+            return entries
+                .OrderByDescending(e => e.PerformedAt)
+                .Take(take)
+                .ToList();
+        }
+    }
+}

ContactManagementAPI/Services/AuthorizationService.cs

@@ -0,0 +1,52 @@
+using System.Linq;
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace ContactManagementAPI.Services
+{
+    public class AuthorizationService
+    {
+        private readonly ApplicationDbContext _context;
+
+        public AuthorizationService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public bool HasRight(int userId, string rightKey)
+        {
+            var user = _context.AppUsers
+                .AsNoTracking()
+                .FirstOrDefault(u => u.Id == userId);
+
+            if (user == null || !user.IsActive)
+                return false;
+
+            if (user.IsAdmin)
+                return true;
+
+            var userRight = _context.UserRights
+                .AsNoTracking()
+                .FirstOrDefault(r => r.AppUserId == userId && r.RightKey == rightKey);
+
+            if (userRight != null)
+                return userRight.IsGranted;
+
+            var groupRight = _context.GroupRights
+                .AsNoTracking()
+                .FirstOrDefault(r => r.UserGroupId == user.GroupId && r.RightKey == rightKey);
+
+            return groupRight?.IsGranted ?? false;
+        }
+
+        public bool IsAdmin(int userId)
+        {
+            var user = _context.AppUsers
+                .AsNoTracking()
+                .FirstOrDefault(u => u.Id == userId);
+
+            return user?.IsAdmin == true && user.IsActive;
+        }
+    }
+}

ContactManagementAPI/Services/ContactStatisticsService.cs

@@ -0,0 +1,173 @@
+using ContactManagementAPI.Models;
+using ContactManagementAPI.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ContactManagementAPI.Services
+{
+    public class ContactStatisticsService
+    {
+        private readonly ApplicationDbContext _context;
+
+        public ContactStatisticsService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<ContactStatistics> GetStatisticsAsync()
+        {
+            var totalContacts = await _context.Contacts.CountAsync();
+            var contactsWithEmail = await _context.Contacts.Where(c => !string.IsNullOrEmpty(c.Email)).CountAsync();
+            var contactsWithPhone = await _context.Contacts.Where(c => 
+                !string.IsNullOrEmpty(c.Mobile1) || !string.IsNullOrEmpty(c.Mobile2) || !string.IsNullOrEmpty(c.Mobile3)).CountAsync();
+            
+            var topCities = await _context.Contacts
+                .Where(c => !string.IsNullOrEmpty(c.City))
+                .GroupBy(c => c.City)
+                .Select(g => new CityStatistic { City = g.Key, Count = g.Count() })
+                .OrderByDescending(x => x.Count)
+                .Take(5)
+                .ToListAsync();
+
+            var contactsByGroup = await _context.Contacts
+                .Include(c => c.Group)
+                .GroupBy(c => c.Group == null ? "Unassigned" : c.Group.Name)
+                .Select(g => new GroupStatistic { GroupName = g.Key, Count = g.Count() })
+                .OrderByDescending(x => x.Count)
+                .ToListAsync();
+
+            return new ContactStatistics
+            {
+                TotalContacts = totalContacts,
+                ContactsWithEmail = contactsWithEmail,
+                ContactsWithPhone = contactsWithPhone,
+                TopCities = topCities,
+                ContactsByGroup = contactsByGroup,
+                LastUpdated = DateTime.Now
+            };
+        }
+
+        // Detect potential duplicates
+        public async Task<List<ContactDuplicate>> FindDuplicatesAsync()
+        {
+            var duplicates = new List<ContactDuplicate>();
+            var contacts = await _context.Contacts.ToListAsync();
+
+            for (int i = 0; i < contacts.Count; i++)
+            {
+                for (int j = i + 1; j < contacts.Count; j++)
+                {
+                    var similarity = CalculateSimilarity(contacts[i], contacts[j]);
+                    if (similarity >= 0.7) // 70% similarity threshold
+                    {
+                        duplicates.Add(new ContactDuplicate
+                        {
+                            Contact1Id = contacts[i].Id,
+                            Contact1Name = $"{contacts[i].FirstName} {contacts[i].LastName}",
+                            Contact2Id = contacts[j].Id,
+                            Contact2Name = $"{contacts[j].FirstName} {contacts[j].LastName}",
+                            SimilarityScore = similarity
+                        });
+                    }
+                }
+            }
+
+            return duplicates.OrderByDescending(x => x.SimilarityScore).ToList();
+        }
+
+        private double CalculateSimilarity(Contact c1, Contact c2)
+        {
+            double score = 0;
+            int factors = 0;
+
+            // Compare names
+            if (!string.IsNullOrEmpty(c1.FirstName) && !string.IsNullOrEmpty(c2.FirstName))
+            {
+                if (c1.FirstName.Equals(c2.FirstName, StringComparison.OrdinalIgnoreCase))
+                    score += 1;
+                else if (LevenshteinDistance(c1.FirstName, c2.FirstName) <= 2)
+                    score += 0.8;
+                factors++;
+            }
+
+            if (!string.IsNullOrEmpty(c1.LastName) && !string.IsNullOrEmpty(c2.LastName))
+            {
+                if (c1.LastName.Equals(c2.LastName, StringComparison.OrdinalIgnoreCase))
+                    score += 1;
+                else if (LevenshteinDistance(c1.LastName, c2.LastName) <= 2)
+                    score += 0.8;
+                factors++;
+            }
+
+            // Compare emails
+            if (!string.IsNullOrEmpty(c1.Email) && !string.IsNullOrEmpty(c2.Email))
+            {
+                if (c1.Email.Equals(c2.Email, StringComparison.OrdinalIgnoreCase))
+                    score += 2; // High weight for email match
+                factors++;
+            }
+
+            // Compare phones
+            if (!string.IsNullOrEmpty(c1.Mobile1) && !string.IsNullOrEmpty(c2.Mobile1))
+            {
+                if (c1.Mobile1.Equals(c2.Mobile1))
+                    score += 2; // High weight for phone match
+                factors++;
+            }
+
+            return factors > 0 ? score / (factors * 1.5) : 0;
+        }
+
+        private int LevenshteinDistance(string s1, string s2)
+        {
+            var length1 = s1.Length;
+            var length2 = s2.Length;
+            var d = new int[length1 + 1, length2 + 1];
+
+            for (int i = 0; i <= length1; i++)
+                d[i, 0] = i;
+
+            for (int j = 0; j <= length2; j++)
+                d[0, j] = j;
+
+            for (int i = 1; i <= length1; i++)
+                for (int j = 1; j <= length2; j++)
+                {
+                    int cost = (s1[i - 1] == s2[j - 1]) ? 0 : 1;
+                    d[i, j] = Math.Min(Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1), d[i - 1, j - 1] + cost);
+                }
+
+            return d[length1, length2];
+        }
+    }
+
+    public class ContactStatistics
+    {
+        public int TotalContacts { get; set; }
+        public int ContactsWithEmail { get; set; }
+        public int ContactsWithPhone { get; set; }
+        public List<CityStatistic> TopCities { get; set; } = new();
+        public List<GroupStatistic> ContactsByGroup { get; set; } = new();
+        public DateTime LastUpdated { get; set; }
+    }
+
+    public class CityStatistic
+    {
+        public string City { get; set; }
+        public int Count { get; set; }
+    }
+
+    public class GroupStatistic
+    {
+        public string GroupName { get; set; }
+        public int Count { get; set; }
+    }
+
+    public class ContactDuplicate
+    {
+        public int Contact1Id { get; set; }
+        public string Contact1Name { get; set; }
+        public int Contact2Id { get; set; }
+        public string Contact2Name { get; set; }
+        public double SimilarityScore { get; set; }
+    }
+}

ContactManagementAPI/Services/FileUploadService.cs

@@ -0,0 +1,142 @@
+using Microsoft.AspNetCore.Http;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace ContactManagementAPI.Services
+{
+    public class FileUploadService
+    {
+        private readonly IWebHostEnvironment _environment;
+        private readonly IConfiguration _configuration;
+        private const long MAX_PHOTO_SIZE = 5242880; // 5MB
+        private const long MAX_DOCUMENT_SIZE = 10485760; // 10MB
+
+        public FileUploadService(IWebHostEnvironment environment, IConfiguration configuration)
+        {
+            _environment = environment;
+            _configuration = configuration;
+        }
+
+        private string GetUploadsRoot()
+        {
+            var uploadsRoot = Environment.GetEnvironmentVariable("UPLOADS_ROOT");
+            if (!string.IsNullOrWhiteSpace(uploadsRoot))
+            {
+                Directory.CreateDirectory(uploadsRoot);
+                return uploadsRoot;
+            }
+
+            return Path.Combine(_environment.WebRootPath, "uploads");
+        }
+
+        public async Task<(bool Success, string FilePath, string ErrorMessage)> UploadPhotoAsync(IFormFile file, int contactId)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                    return (false, "", "No file selected");
+
+                if (file.Length > MAX_PHOTO_SIZE)
+                    return (false, "", "Photo size exceeds maximum limit of 5MB");
+
+                var allowedExtensions = _configuration.GetSection("FileUpload:AllowedPhotoExtensions").Get<string[]>();
+                var fileExtension = Path.GetExtension(file.FileName).ToLower();
+
+                if (!allowedExtensions.Contains(fileExtension))
+                    return (false, "", "Invalid file format. Allowed formats: JPG, PNG, GIF, BMP");
+
+                var uploadPath = Path.Combine(GetUploadsRoot(), "photos");
+                if (!Directory.Exists(uploadPath))
+                    Directory.CreateDirectory(uploadPath);
+
+                var fileName = $"{contactId}_{DateTime.Now.Ticks}{fileExtension}";
+                var filePath = Path.Combine(uploadPath, fileName);
+
+                using (var stream = new FileStream(filePath, FileMode.Create))
+                {
+                    await file.CopyToAsync(stream);
+                }
+
+                return (true, $"/uploads/photos/{fileName}", "");
+            }
+            catch (Exception ex)
+            {
+                return (false, "", $"Error uploading file: {ex.Message}");
+            }
+        }
+
+        public async Task<(bool Success, string FilePath, string ErrorMessage)> UploadDocumentAsync(IFormFile file, int contactId)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                    return (false, "", "No file selected");
+
+                if (file.Length > MAX_DOCUMENT_SIZE)
+                    return (false, "", "Document size exceeds maximum limit of 10MB");
+
+                var allowedExtensions = _configuration.GetSection("FileUpload:AllowedDocumentExtensions").Get<string[]>();
+                var fileExtension = Path.GetExtension(file.FileName).ToLower();
+
+                if (!allowedExtensions.Contains(fileExtension))
+                    return (false, "", "Invalid file format");
+
+                var uploadPath = Path.Combine(GetUploadsRoot(), "documents");
+                if (!Directory.Exists(uploadPath))
+                    Directory.CreateDirectory(uploadPath);
+
+                var fileName = $"{contactId}_{DateTime.Now.Ticks}{fileExtension}";
+                var filePath = Path.Combine(uploadPath, fileName);
+
+                using (var stream = new FileStream(filePath, FileMode.Create))
+                {
+                    await file.CopyToAsync(stream);
+                }
+
+                return (true, $"/uploads/documents/{fileName}", "");
+            }
+            catch (Exception ex)
+            {
+                return (false, "", $"Error uploading file: {ex.Message}");
+            }
+        }
+
+        public bool DeleteFile(string filePath)
+        {
+            try
+            {
+                var trimmed = (filePath ?? string.Empty).Trim();
+                if (string.IsNullOrWhiteSpace(trimmed))
+                {
+                    return false;
+                }
+
+                var normalized = trimmed.StartsWith("/") ? trimmed : "/" + trimmed;
+                var uploadsRoot = GetUploadsRoot();
+                string fullPath;
+
+                if (normalized.StartsWith("/uploads/", StringComparison.OrdinalIgnoreCase))
+                {
+                    var relative = normalized.Substring("/uploads/".Length).Replace('/', Path.DirectorySeparatorChar);
+                    fullPath = Path.Combine(uploadsRoot, relative);
+                }
+                else
+                {
+                    fullPath = Path.Combine(_environment.WebRootPath, normalized.TrimStart('/').Replace('/', Path.DirectorySeparatorChar));
+                }
+
+                if (File.Exists(fullPath))
+                {
+                    File.Delete(fullPath);
+                    return true;
+                }
+                return false;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+    }
+}

ContactManagementAPI/Services/ImportExportService.cs

@@ -0,0 +1,573 @@
+using ContactManagementAPI.Models;
+using CsvHelper;
+using CsvHelper.Configuration;
+using OfficeOpenXml;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+using System.Globalization;
+using System.Text;
+
+namespace ContactManagementAPI.Services
+{
+    public class ImportExportService
+    {
+        public ImportExportService()
+        {
+            // Set EPPlus license context
+            ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
+            
+            // Set QuestPDF license
+            QuestPDF.Settings.License = LicenseType.Community;
+        }
+
+        #region Import Methods
+
+        public async Task<(List<Contact> contacts, List<string> errors)> ImportFromExcel(Stream stream)
+        {
+            var contacts = new List<Contact>();
+            var errors = new List<string>();
+
+            try
+            {
+                using var package = new ExcelPackage(stream);
+                var worksheet = package.Workbook.Worksheets.FirstOrDefault();
+                
+                if (worksheet == null)
+                {
+                    errors.Add("No worksheet found in the Excel file.");
+                    return (contacts, errors);
+                }
+
+                var rowCount = worksheet.Dimension?.Rows ?? 0;
+                
+                // Start from row 2 (skip header)
+                for (int row = 2; row <= rowCount; row++)
+                {
+                    try
+                    {
+                        var contact = new Contact
+                        {
+                            FirstName = worksheet.Cells[row, 1].Value?.ToString() ?? "",
+                            LastName = worksheet.Cells[row, 2].Value?.ToString() ?? "",
+                            NickName = worksheet.Cells[row, 3].Value?.ToString(),
+                            Gender = worksheet.Cells[row, 4].Value?.ToString(),
+                            DateOfBirth = DateTime.TryParse(worksheet.Cells[row, 5].Value?.ToString(), out var dob) ? dob : null,
+                            Email = worksheet.Cells[row, 6].Value?.ToString(),
+                            Mobile1 = worksheet.Cells[row, 7].Value?.ToString(),
+                            Mobile2 = worksheet.Cells[row, 8].Value?.ToString(),
+                            Mobile3 = worksheet.Cells[row, 9].Value?.ToString(),
+                            WhatsAppNumber = worksheet.Cells[row, 10].Value?.ToString(),
+                            PassportNumber = worksheet.Cells[row, 11].Value?.ToString(),
+                            PanNumber = worksheet.Cells[row, 12].Value?.ToString(),
+                            AadharNumber = worksheet.Cells[row, 13].Value?.ToString(),
+                            DrivingLicenseNumber = worksheet.Cells[row, 14].Value?.ToString(),
+                            VotersId = worksheet.Cells[row, 15].Value?.ToString(),
+                            BankAccountNumber = worksheet.Cells[row, 16].Value?.ToString(),
+                            BankName = worksheet.Cells[row, 17].Value?.ToString(),
+                            BranchName = worksheet.Cells[row, 18].Value?.ToString(),
+                            IfscCode = worksheet.Cells[row, 19].Value?.ToString(),
+                            Address = worksheet.Cells[row, 20].Value?.ToString(),
+                            City = worksheet.Cells[row, 21].Value?.ToString(),
+                            State = worksheet.Cells[row, 22].Value?.ToString(),
+                            PostalCode = worksheet.Cells[row, 23].Value?.ToString(),
+                            Country = worksheet.Cells[row, 24].Value?.ToString(),
+                            OtherDetails = worksheet.Cells[row, 25].Value?.ToString(),
+                            CreatedAt = DateTime.Now,
+                            UpdatedAt = DateTime.Now
+                        };
+
+                        if (!string.IsNullOrWhiteSpace(contact.FirstName) || !string.IsNullOrWhiteSpace(contact.LastName))
+                        {
+                            contacts.Add(contact);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        errors.Add($"Row {row}: {ex.Message}");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                errors.Add($"Error reading Excel file: {ex.Message}");
+            }
+
+            return (contacts, errors);
+        }
+
+        public async Task<(List<Contact> contacts, List<string> errors)> ImportFromCsv(Stream stream)
+        {
+            var contacts = new List<Contact>();
+            var errors = new List<string>();
+
+            try
+            {
+                using var reader = new StreamReader(stream);
+                var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+                {
+                    HasHeaderRecord = true,
+                    MissingFieldFound = null,
+                    BadDataFound = null
+                };
+
+                using var csv = new CsvReader(reader, config);
+                
+                csv.Read();
+                csv.ReadHeader();
+                int rowNumber = 1;
+
+                while (csv.Read())
+                {
+                    rowNumber++;
+                    try
+                    {
+                        string? ReadField(string name, int index)
+                        {
+                            if (csv.TryGetField<string>(name, out var namedValue))
+                                return namedValue;
+
+                            if (csv.TryGetField<string>(index, out var indexedValue))
+                                return indexedValue;
+
+                            return null;
+                        }
+
+                        var contact = new Contact
+                        {
+                            FirstName = ReadField("FirstName", 0) ?? "",
+                            LastName = ReadField("LastName", 1) ?? "",
+                            NickName = ReadField("NickName", 2),
+                            Gender = ReadField("Gender", 3),
+                            DateOfBirth = DateTime.TryParse(ReadField("DateOfBirth", 4), out var dob) ? dob : null,
+                            Email = ReadField("Email", 5),
+                            Mobile1 = ReadField("Mobile1", 6),
+                            Mobile2 = ReadField("Mobile2", 7),
+                            Mobile3 = ReadField("Mobile3", 8),
+                            WhatsAppNumber = ReadField("WhatsAppNumber", 9),
+                            PassportNumber = ReadField("PassportNumber", 10),
+                            PanNumber = ReadField("PanNumber", 11),
+                            AadharNumber = ReadField("AadharNumber", 12),
+                            DrivingLicenseNumber = ReadField("DrivingLicenseNumber", 13),
+                            VotersId = ReadField("VotersId", 14),
+                            BankAccountNumber = ReadField("BankAccountNumber", 15),
+                            BankName = ReadField("BankName", 16),
+                            BranchName = ReadField("BranchName", 17),
+                            IfscCode = ReadField("IfscCode", 18),
+                            Address = ReadField("Address", 19),
+                            City = ReadField("City", 20),
+                            State = ReadField("State", 21),
+                            PostalCode = ReadField("PostalCode", 22),
+                            Country = ReadField("Country", 23),
+                            OtherDetails = ReadField("OtherDetails", 24),
+                            CreatedAt = DateTime.Now,
+                            UpdatedAt = DateTime.Now
+                        };
+
+                        if (!string.IsNullOrWhiteSpace(contact.FirstName) || !string.IsNullOrWhiteSpace(contact.LastName))
+                        {
+                            contacts.Add(contact);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        errors.Add($"Row {rowNumber}: {ex.Message}");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                errors.Add($"Error reading CSV file: {ex.Message}");
+            }
+
+            return (contacts, errors);
+        }
+
+        #endregion
+
+        #region Export Methods
+
+        public async Task<byte[]> ExportToExcel(List<Contact> contacts)
+        {
+            using var package = new ExcelPackage();
+            var worksheet = package.Workbook.Worksheets.Add("Contacts");
+
+            // Add headers
+            worksheet.Cells[1, 1].Value = "First Name";
+            worksheet.Cells[1, 2].Value = "Last Name";
+            worksheet.Cells[1, 3].Value = "Nick Name";
+            worksheet.Cells[1, 4].Value = "Gender";
+            worksheet.Cells[1, 5].Value = "Date Of Birth";
+            worksheet.Cells[1, 6].Value = "Email";
+            worksheet.Cells[1, 7].Value = "Mobile 1";
+            worksheet.Cells[1, 8].Value = "Mobile 2";
+            worksheet.Cells[1, 9].Value = "Mobile 3";
+            worksheet.Cells[1, 10].Value = "WhatsApp";
+            worksheet.Cells[1, 11].Value = "Passport Number";
+            worksheet.Cells[1, 12].Value = "PAN Number";
+            worksheet.Cells[1, 13].Value = "Aadhar Number";
+            worksheet.Cells[1, 14].Value = "Driving License Number";
+            worksheet.Cells[1, 15].Value = "Voters ID";
+            worksheet.Cells[1, 16].Value = "Bank Account Number";
+            worksheet.Cells[1, 17].Value = "Bank Name";
+            worksheet.Cells[1, 18].Value = "Branch Name";
+            worksheet.Cells[1, 19].Value = "IFSC Code";
+            worksheet.Cells[1, 20].Value = "Address";
+            worksheet.Cells[1, 21].Value = "City";
+            worksheet.Cells[1, 22].Value = "State";
+            worksheet.Cells[1, 23].Value = "Postal Code";
+            worksheet.Cells[1, 24].Value = "Country";
+            worksheet.Cells[1, 25].Value = "Other Details";
+            worksheet.Cells[1, 26].Value = "Group";
+            worksheet.Cells[1, 27].Value = "Created At";
+
+            // Style headers
+            using (var range = worksheet.Cells[1, 1, 1, 27])
+            {
+                range.Style.Font.Bold = true;
+                range.Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
+                range.Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightBlue);
+            }
+
+            // Add data
+            for (int i = 0; i < contacts.Count; i++)
+            {
+                var contact = contacts[i];
+                var row = i + 2;
+
+                worksheet.Cells[row, 1].Value = contact.FirstName;
+                worksheet.Cells[row, 2].Value = contact.LastName;
+                worksheet.Cells[row, 3].Value = contact.NickName;
+                worksheet.Cells[row, 4].Value = contact.Gender;
+                worksheet.Cells[row, 5].Value = contact.DateOfBirth?.ToString("yyyy-MM-dd");
+                worksheet.Cells[row, 6].Value = contact.Email;
+                worksheet.Cells[row, 7].Value = contact.Mobile1;
+                worksheet.Cells[row, 8].Value = contact.Mobile2;
+                worksheet.Cells[row, 9].Value = contact.Mobile3;
+                worksheet.Cells[row, 10].Value = contact.WhatsAppNumber;
+                worksheet.Cells[row, 11].Value = contact.PassportNumber;
+                worksheet.Cells[row, 12].Value = contact.PanNumber;
+                worksheet.Cells[row, 13].Value = contact.AadharNumber;
+                worksheet.Cells[row, 14].Value = contact.DrivingLicenseNumber;
+                worksheet.Cells[row, 15].Value = contact.VotersId;
+                worksheet.Cells[row, 16].Value = contact.BankAccountNumber;
+                worksheet.Cells[row, 17].Value = contact.BankName;
+                worksheet.Cells[row, 18].Value = contact.BranchName;
+                worksheet.Cells[row, 19].Value = contact.IfscCode;
+                worksheet.Cells[row, 20].Value = contact.Address;
+                worksheet.Cells[row, 21].Value = contact.City;
+                worksheet.Cells[row, 22].Value = contact.State;
+                worksheet.Cells[row, 23].Value = contact.PostalCode;
+                worksheet.Cells[row, 24].Value = contact.Country;
+                worksheet.Cells[row, 25].Value = contact.OtherDetails;
+                worksheet.Cells[row, 26].Value = contact.Group?.Name;
+                worksheet.Cells[row, 27].Value = contact.CreatedAt.ToString("yyyy-MM-dd HH:mm:ss");
+            }
+
+            // Auto-fit columns
+            worksheet.Cells[worksheet.Dimension.Address].AutoFitColumns();
+
+            return await Task.FromResult(package.GetAsByteArray());
+        }
+
+        public async Task<byte[]> ExportToCsv(List<Contact> contacts)
+        {
+            using var memoryStream = new MemoryStream();
+            using var writer = new StreamWriter(memoryStream, Encoding.UTF8);
+            using var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+
+            // Write headers
+            csv.WriteField("FirstName");
+            csv.WriteField("LastName");
+            csv.WriteField("NickName");
+            csv.WriteField("Gender");
+            csv.WriteField("DateOfBirth");
+            csv.WriteField("Email");
+            csv.WriteField("Mobile1");
+            csv.WriteField("Mobile2");
+            csv.WriteField("Mobile3");
+            csv.WriteField("WhatsAppNumber");
+            csv.WriteField("PassportNumber");
+            csv.WriteField("PanNumber");
+            csv.WriteField("AadharNumber");
+            csv.WriteField("DrivingLicenseNumber");
+            csv.WriteField("VotersId");
+            csv.WriteField("BankAccountNumber");
+            csv.WriteField("BankName");
+            csv.WriteField("BranchName");
+            csv.WriteField("IfscCode");
+            csv.WriteField("Address");
+            csv.WriteField("City");
+            csv.WriteField("State");
+            csv.WriteField("PostalCode");
+            csv.WriteField("Country");
+            csv.WriteField("OtherDetails");
+            csv.WriteField("Group");
+            csv.WriteField("CreatedAt");
+            csv.NextRecord();
+
+            // Write data
+            foreach (var contact in contacts)
+            {
+                csv.WriteField(contact.FirstName);
+                csv.WriteField(contact.LastName);
+                csv.WriteField(contact.NickName);
+                csv.WriteField(contact.Gender);
+                csv.WriteField(contact.DateOfBirth?.ToString("yyyy-MM-dd"));
+                csv.WriteField(contact.Email);
+                csv.WriteField(contact.Mobile1);
+                csv.WriteField(contact.Mobile2);
+                csv.WriteField(contact.Mobile3);
+                csv.WriteField(contact.WhatsAppNumber);
+                csv.WriteField(contact.PassportNumber);
+                csv.WriteField(contact.PanNumber);
+                csv.WriteField(contact.AadharNumber);
+                csv.WriteField(contact.DrivingLicenseNumber);
+                csv.WriteField(contact.VotersId);
+                csv.WriteField(contact.BankAccountNumber);
+                csv.WriteField(contact.BankName);
+                csv.WriteField(contact.BranchName);
+                csv.WriteField(contact.IfscCode);
+                csv.WriteField(contact.Address);
+                csv.WriteField(contact.City);
+                csv.WriteField(contact.State);
+                csv.WriteField(contact.PostalCode);
+                csv.WriteField(contact.Country);
+                csv.WriteField(contact.OtherDetails);
+                csv.WriteField(contact.Group?.Name);
+                csv.WriteField(contact.CreatedAt.ToString("yyyy-MM-dd HH:mm:ss"));
+                csv.NextRecord();
+            }
+
+            await writer.FlushAsync();
+            return memoryStream.ToArray();
+        }
+
+        public async Task<byte[]> ExportToPdf(List<Contact> contacts)
+        {
+            var document = Document.Create(container =>
+            {
+                container.Page(page =>
+                {
+                    page.Size(PageSizes.A4.Landscape());
+                    page.Margin(1, Unit.Centimetre);
+                    page.PageColor(Colors.White);
+                    page.DefaultTextStyle(x => x.FontSize(9));
+
+                    page.Header()
+                        .Text("Contact List")
+                        .SemiBold().FontSize(20).FontColor(Colors.Blue.Medium);
+
+                    page.Content()
+                        .PaddingVertical(1, Unit.Centimetre)
+                        .Table(table =>
+                        {
+                            // Define columns
+                            table.ColumnsDefinition(columns =>
+                            {
+                                columns.RelativeColumn(2); // Name
+                                columns.RelativeColumn(2); // Email
+                                columns.RelativeColumn(1.5f); // Mobile1
+                                columns.RelativeColumn(1.5f); // Mobile2
+                                columns.RelativeColumn(2); // City
+                                columns.RelativeColumn(1.5f); // State
+                            });
+
+                            // Header
+                            table.Header(header =>
+                            {
+                                header.Cell().Element(CellStyle).Text("Name").Bold();
+                                header.Cell().Element(CellStyle).Text("Email").Bold();
+                                header.Cell().Element(CellStyle).Text("Mobile 1").Bold();
+                                header.Cell().Element(CellStyle).Text("Mobile 2").Bold();
+                                header.Cell().Element(CellStyle).Text("City").Bold();
+                                header.Cell().Element(CellStyle).Text("State").Bold();
+
+                                static IContainer CellStyle(IContainer container)
+                                {
+                                    return container.DefaultTextStyle(x => x.SemiBold())
+                                        .PaddingVertical(5).BorderBottom(1).BorderColor(Colors.Black);
+                                }
+                            });
+
+                            // Data rows
+                            foreach (var contact in contacts)
+                            {
+                                table.Cell().Element(CellStyle).Text($"{contact.FirstName} {contact.LastName}");
+                                table.Cell().Element(CellStyle).Text(contact.Email ?? "-");
+                                table.Cell().Element(CellStyle).Text(contact.Mobile1 ?? "-");
+                                table.Cell().Element(CellStyle).Text(contact.Mobile2 ?? "-");
+                                table.Cell().Element(CellStyle).Text(contact.City ?? "-");
+                                table.Cell().Element(CellStyle).Text(contact.State ?? "-");
+
+                                static IContainer CellStyle(IContainer container)
+                                {
+                                    return container.BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
+                                        .PaddingVertical(5);
+                                }
+                            }
+                        });
+
+                    page.Footer()
+                        .AlignCenter()
+                        .Text(x =>
+                        {
+                            x.Span("Page ");
+                            x.CurrentPageNumber();
+                            x.Span(" of ");
+                            x.TotalPages();
+                            x.Span(" | Generated on ");
+                            x.Span(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
+                        });
+                });
+            });
+
+            return await Task.FromResult(document.GeneratePdf());
+        }
+
+        #endregion
+
+        #region Template Methods
+
+        public async Task<byte[]> GenerateExcelTemplate()
+        {
+            using var package = new ExcelPackage();
+            var worksheet = package.Workbook.Worksheets.Add("Contacts Template");
+
+            // Add headers
+            worksheet.Cells[1, 1].Value = "FirstName";
+            worksheet.Cells[1, 2].Value = "LastName";
+            worksheet.Cells[1, 3].Value = "NickName";
+            worksheet.Cells[1, 4].Value = "Gender";
+            worksheet.Cells[1, 5].Value = "DateOfBirth";
+            worksheet.Cells[1, 6].Value = "Email";
+            worksheet.Cells[1, 7].Value = "Mobile1";
+            worksheet.Cells[1, 8].Value = "Mobile2";
+            worksheet.Cells[1, 9].Value = "Mobile3";
+            worksheet.Cells[1, 10].Value = "WhatsAppNumber";
+            worksheet.Cells[1, 11].Value = "PassportNumber";
+            worksheet.Cells[1, 12].Value = "PanNumber";
+            worksheet.Cells[1, 13].Value = "AadharNumber";
+            worksheet.Cells[1, 14].Value = "DrivingLicenseNumber";
+            worksheet.Cells[1, 15].Value = "VotersId";
+            worksheet.Cells[1, 16].Value = "BankAccountNumber";
+            worksheet.Cells[1, 17].Value = "BankName";
+            worksheet.Cells[1, 18].Value = "BranchName";
+            worksheet.Cells[1, 19].Value = "IfscCode";
+            worksheet.Cells[1, 20].Value = "Address";
+            worksheet.Cells[1, 21].Value = "City";
+            worksheet.Cells[1, 22].Value = "State";
+            worksheet.Cells[1, 23].Value = "PostalCode";
+            worksheet.Cells[1, 24].Value = "Country";
+            worksheet.Cells[1, 25].Value = "OtherDetails";
+
+            // Style headers
+            using (var range = worksheet.Cells[1, 1, 1, 25])
+            {
+                range.Style.Font.Bold = true;
+                range.Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
+                range.Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGreen);
+            }
+
+            // Add sample row
+            worksheet.Cells[2, 1].Value = "John";
+            worksheet.Cells[2, 2].Value = "Doe";
+            worksheet.Cells[2, 3].Value = "Johnny";
+            worksheet.Cells[2, 4].Value = "Male";
+            worksheet.Cells[2, 5].Value = "1990-01-01";
+            worksheet.Cells[2, 6].Value = "john.doe@example.com";
+            worksheet.Cells[2, 7].Value = "+1234567890";
+            worksheet.Cells[2, 8].Value = "+0987654321";
+            worksheet.Cells[2, 9].Value = "";
+            worksheet.Cells[2, 10].Value = "+1234567890";
+            worksheet.Cells[2, 11].Value = "P1234567";
+            worksheet.Cells[2, 12].Value = "ABCDE1234F";
+            worksheet.Cells[2, 13].Value = "1234-5678-9012";
+            worksheet.Cells[2, 14].Value = "DL-12345-2020";
+            worksheet.Cells[2, 15].Value = "VOTER12345";
+            worksheet.Cells[2, 16].Value = "123456789012";
+            worksheet.Cells[2, 17].Value = "State Bank";
+            worksheet.Cells[2, 18].Value = "Main Branch";
+            worksheet.Cells[2, 19].Value = "SBIN0001234";
+            worksheet.Cells[2, 20].Value = "123 Main St";
+            worksheet.Cells[2, 21].Value = "New York";
+            worksheet.Cells[2, 22].Value = "NY";
+            worksheet.Cells[2, 23].Value = "10001";
+            worksheet.Cells[2, 24].Value = "USA";
+            worksheet.Cells[2, 25].Value = "Sample contact";
+
+            // Auto-fit columns
+            worksheet.Cells[worksheet.Dimension.Address].AutoFitColumns();
+
+            return await Task.FromResult(package.GetAsByteArray());
+        }
+
+        public async Task<byte[]> GenerateCsvTemplate()
+        {
+            using var memoryStream = new MemoryStream();
+            using var writer = new StreamWriter(memoryStream, Encoding.UTF8);
+            using var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+
+            // Write headers
+            csv.WriteField("FirstName");
+            csv.WriteField("LastName");
+            csv.WriteField("NickName");
+            csv.WriteField("Gender");
+            csv.WriteField("DateOfBirth");
+            csv.WriteField("Email");
+            csv.WriteField("Mobile1");
+            csv.WriteField("Mobile2");
+            csv.WriteField("Mobile3");
+            csv.WriteField("WhatsAppNumber");
+            csv.WriteField("PassportNumber");
+            csv.WriteField("PanNumber");
+            csv.WriteField("AadharNumber");
+            csv.WriteField("DrivingLicenseNumber");
+            csv.WriteField("VotersId");
+            csv.WriteField("BankAccountNumber");
+            csv.WriteField("BankName");
+            csv.WriteField("BranchName");
+            csv.WriteField("IfscCode");
+            csv.WriteField("Address");
+            csv.WriteField("City");
+            csv.WriteField("State");
+            csv.WriteField("PostalCode");
+            csv.WriteField("Country");
+            csv.WriteField("OtherDetails");
+            csv.NextRecord();
+
+            // Write sample row
+            csv.WriteField("John");
+            csv.WriteField("Doe");
+            csv.WriteField("Johnny");
+            csv.WriteField("Male");
+            csv.WriteField("1990-01-01");
+            csv.WriteField("john.doe@example.com");
+            csv.WriteField("+1234567890");
+            csv.WriteField("+0987654321");
+            csv.WriteField("");
+            csv.WriteField("+1234567890");
+            csv.WriteField("P1234567");
+            csv.WriteField("ABCDE1234F");
+            csv.WriteField("1234-5678-9012");
+            csv.WriteField("DL-12345-2020");
+            csv.WriteField("VOTER12345");
+            csv.WriteField("123456789012");
+            csv.WriteField("State Bank");
+            csv.WriteField("Main Branch");
+            csv.WriteField("SBIN0001234");
+            csv.WriteField("123 Main St");
+            csv.WriteField("New York");
+            csv.WriteField("NY");
+            csv.WriteField("10001");
+            csv.WriteField("USA");
+            csv.WriteField("Sample contact");
+            csv.NextRecord();
+
+            await writer.FlushAsync();
+            return memoryStream.ToArray();
+        }
+
+        #endregion
+    }
+}

ContactManagementAPI/Services/SeedData.cs

@@ -0,0 +1,333 @@
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Models;
+using Microsoft.AspNetCore.Identity;
+
+namespace ContactManagementAPI.Services
+{
+    public static class SeedData
+    {
+        public const string SuperAdminUserName = "abrahamcbe@gmail.com";
+        public const string SuperAdminDefaultPassword = "M@ld1ves";
+
+        private static string GetSuperAdminPassword()
+        {
+            var fromEnv = Environment.GetEnvironmentVariable("SUPERADMIN_PASSWORD");
+            return string.IsNullOrWhiteSpace(fromEnv) ? SuperAdminDefaultPassword : fromEnv;
+        }
+
+        public static void Initialize(ApplicationDbContext context)
+        {
+            var hasher = new PasswordHasher<AppUser>();
+
+            if (!context.UserGroups.Any())
+            {
+                var adminGroup = new UserGroup
+                {
+                    Name = "Administrators",
+                    Description = "System administrators with full access",
+                    CreatedAt = DateTime.Now
+                };
+
+                context.UserGroups.Add(adminGroup);
+                context.SaveChanges();
+
+                var groupRights = RightsCatalog.All
+                    .Select(r => new GroupRight
+                    {
+                        UserGroupId = adminGroup.Id,
+                        RightKey = r.Key,
+                        IsGranted = true
+                    })
+                    .ToList();
+
+                context.GroupRights.AddRange(groupRights);
+                context.SaveChanges();
+            }
+            else
+            {
+                var adminGroup = context.UserGroups.FirstOrDefault(g => g.Name == "Administrators");
+                if (adminGroup != null)
+                {
+                    var existingAdminRights = context.GroupRights
+                        .Where(r => r.UserGroupId == adminGroup.Id)
+                        .ToList();
+
+                    foreach (var right in RightsCatalog.All)
+                    {
+                        var existing = existingAdminRights.FirstOrDefault(r => r.RightKey == right.Key);
+                        if (existing == null)
+                        {
+                            context.GroupRights.Add(new GroupRight
+                            {
+                                UserGroupId = adminGroup.Id,
+                                RightKey = right.Key,
+                                IsGranted = true
+                            });
+                        }
+                        else if (!existing.IsGranted)
+                        {
+                            existing.IsGranted = true;
+                        }
+                    }
+
+                    context.SaveChanges();
+                }
+            }
+
+            if (!context.AppUsers.Any())
+            {
+                var adminGroupId = context.UserGroups
+                    .Where(g => g.Name == "Administrators")
+                    .Select(g => g.Id)
+                    .First();
+
+                var adminUser = new AppUser
+                {
+                    UserName = "admin",
+                    FullName = "System Administrator",
+                    IsAdmin = true,
+                    IsActive = true,
+                    GroupId = adminGroupId,
+                    CreatedAt = DateTime.Now,
+                    UpdatedAt = DateTime.Now
+                };
+
+                adminUser.PasswordHash = hasher.HashPassword(adminUser, "Admin@123");
+
+                context.AppUsers.Add(adminUser);
+                context.SaveChanges();
+            }
+
+            EnsureSuperAdminUser(context, hasher);
+
+            EnsureContactGroupUsers(context, hasher);
+
+            EnsureInitialContacts(context);
+        }
+
+        private static void EnsureInitialContacts(ApplicationDbContext context)
+        {
+            var now = DateTime.Now;
+
+            var familyGroupId = context.ContactGroups
+                .Where(g => g.Name == "Family")
+                .Select(g => (int?)g.Id)
+                .FirstOrDefault();
+
+            void EnsureNamedContact(string firstName, string? lastName, string? nickName)
+            {
+                var exists = context.Contacts.Any(c => c.FirstName.ToLower() == firstName.ToLower());
+                if (exists)
+                {
+                    return;
+                }
+
+                context.Contacts.Add(new Contact
+                {
+                    FirstName = firstName,
+                    LastName = lastName,
+                    NickName = nickName,
+                    Mobile1 = null,
+                    GroupId = familyGroupId,
+                    CreatedAt = now,
+                    UpdatedAt = now,
+                    OtherDetails = "Seeded default contact (restored if missing)."
+                });
+            }
+
+            EnsureNamedContact("Abraham", "CBE", "Abraham");
+            EnsureNamedContact("Prema", null, "Prema");
+            EnsureNamedContact("Ponnuraj", null, "Ponnuraj");
+
+            // Add one test contact per contact group (to help validate group scoping after a fresh DB)
+            var contactGroups = context.ContactGroups
+                .OrderBy(g => g.Id)
+                .ToList();
+
+            foreach (var group in contactGroups)
+            {
+                var exists = context.Contacts.Any(c => c.GroupId == group.Id && c.OtherDetails == "Seeded test contact for group validation.");
+                if (exists)
+                {
+                    continue;
+                }
+
+                context.Contacts.Add(new Contact
+                {
+                    FirstName = $"{group.Name} Test",
+                    LastName = "Contact",
+                    NickName = group.Name,
+                    Mobile1 = null,
+                    GroupId = group.Id,
+                    CreatedAt = now,
+                    UpdatedAt = now,
+                    OtherDetails = "Seeded test contact for group validation."
+                });
+            }
+
+            context.SaveChanges();
+        }
+
+        private static void EnsureSuperAdminUser(ApplicationDbContext context, PasswordHasher<AppUser> hasher)
+        {
+            var adminGroupId = context.UserGroups
+                .Where(g => g.Name == "Administrators")
+                .Select(g => g.Id)
+                .FirstOrDefault();
+
+            if (adminGroupId <= 0)
+            {
+                return;
+            }
+
+            var existing = context.AppUsers.FirstOrDefault(u => u.UserName == SuperAdminUserName);
+            if (existing == null)
+            {
+                var password = GetSuperAdminPassword();
+                var user = new AppUser
+                {
+                    UserName = SuperAdminUserName,
+                    FullName = "Abraham",
+                    IsAdmin = true,
+                    IsActive = true,
+                    GroupId = adminGroupId,
+                    CreatedAt = DateTime.Now,
+                    UpdatedAt = DateTime.Now
+                };
+
+                user.PasswordHash = hasher.HashPassword(user, password);
+                context.AppUsers.Add(user);
+                context.SaveChanges();
+                return;
+            }
+
+            var updated = false;
+            var enforcedPassword = GetSuperAdminPassword();
+
+            if (!existing.IsAdmin)
+            {
+                existing.IsAdmin = true;
+                updated = true;
+            }
+
+            if (!existing.IsActive)
+            {
+                existing.IsActive = true;
+                updated = true;
+            }
+
+            if (existing.GroupId != adminGroupId)
+            {
+                existing.GroupId = adminGroupId;
+                updated = true;
+            }
+
+            if (string.IsNullOrWhiteSpace(existing.FullName))
+            {
+                existing.FullName = "Abraham";
+                updated = true;
+            }
+
+            // Enforce Super Admin password so it matches the required credential.
+            existing.PasswordHash = hasher.HashPassword(existing, enforcedPassword);
+            updated = true;
+
+            if (updated)
+            {
+                existing.UpdatedAt = DateTime.Now;
+                context.SaveChanges();
+            }
+        }
+
+        private static void EnsureContactGroupUsers(ApplicationDbContext context, PasswordHasher<AppUser> hasher)
+        {
+            var contactGroups = context.ContactGroups
+                .OrderBy(g => g.Name)
+                .ToList();
+
+            foreach (var contactGroup in contactGroups)
+            {
+                var userGroupName = $"ContactGroup - {contactGroup.Name}";
+                var userGroup = context.UserGroups.FirstOrDefault(g => g.Name == userGroupName);
+                if (userGroup == null)
+                {
+                    userGroup = new UserGroup
+                    {
+                        Name = userGroupName,
+                        Description = $"Full access group for contact group '{contactGroup.Name}'",
+                        CreatedAt = DateTime.Now
+                    };
+
+                    context.UserGroups.Add(userGroup);
+                    context.SaveChanges();
+                }
+
+                var groupRights = context.GroupRights
+                    .Where(r => r.UserGroupId == userGroup.Id)
+                    .ToList();
+
+                foreach (var right in RightsCatalog.All)
+                {
+                    var existing = groupRights.FirstOrDefault(r => r.RightKey == right.Key);
+                    if (existing == null)
+                    {
+                        context.GroupRights.Add(new GroupRight
+                        {
+                            UserGroupId = userGroup.Id,
+                            RightKey = right.Key,
+                            IsGranted = true
+                        });
+                    }
+                    else if (!existing.IsGranted)
+                    {
+                        existing.IsGranted = true;
+                    }
+                }
+
+                context.SaveChanges();
+
+                var preferredUserName = BuildGroupUserName(contactGroup.Name);
+                var appUser = context.AppUsers.FirstOrDefault(u => u.UserName == preferredUserName);
+                if (appUser == null)
+                {
+                    appUser = new AppUser
+                    {
+                        UserName = preferredUserName,
+                        FullName = $"{contactGroup.Name} Group User",
+                        GroupId = userGroup.Id,
+                        IsAdmin = false,
+                        IsActive = true,
+                        CreatedAt = DateTime.Now,
+                        UpdatedAt = DateTime.Now
+                    };
+
+                    appUser.PasswordHash = hasher.HashPassword(appUser, "Group@123");
+                    context.AppUsers.Add(appUser);
+                }
+                else
+                {
+                    appUser.GroupId = userGroup.Id;
+                    appUser.IsActive = true;
+                    appUser.UpdatedAt = DateTime.Now;
+                }
+
+                context.SaveChanges();
+            }
+        }
+
+        private static string BuildGroupUserName(string? groupName)
+        {
+            var raw = string.IsNullOrWhiteSpace(groupName) ? "group" : groupName.Trim().ToLowerInvariant();
+            var slug = Regex.Replace(raw, "[^a-z0-9]+", ".").Trim('.');
+            if (string.IsNullOrWhiteSpace(slug))
+            {
+                slug = "group";
+            }
+
+            return $"{slug}.user";
+        }
+    }
+}

ContactManagementAPI/Services/SessionKeys.cs

@@ -0,0 +1,7 @@
+namespace ContactManagementAPI.Services
+{
+    public static class SessionKeys
+    {
+        public const string UserId = "UserId";
+    }
+}

ContactManagementAPI/Services/UserContextService.cs

@@ -0,0 +1,49 @@
+using ContactManagementAPI.Data;
+using ContactManagementAPI.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.EntityFrameworkCore;
+
+namespace ContactManagementAPI.Services
+{
+    public class UserContextService
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly IHttpContextAccessor _httpContextAccessor;
+        private readonly AuthorizationService _authorizationService;
+
+        public UserContextService(ApplicationDbContext context, IHttpContextAccessor httpContextAccessor, AuthorizationService authorizationService)
+        {
+            _context = context;
+            _httpContextAccessor = httpContextAccessor;
+            _authorizationService = authorizationService;
+        }
+
+        public int? UserId => _httpContextAccessor.HttpContext?.Session.GetInt32(SessionKeys.UserId);
+
+        public bool IsAuthenticated => UserId.HasValue;
+
+        public AppUser? CurrentUser
+        {
+            get
+            {
+                if (!UserId.HasValue)
+                    return null;
+
+                return _context.AppUsers
+                    .AsNoTracking()
+                    .Include(u => u.Group)
+                    .FirstOrDefault(u => u.Id == UserId.Value);
+            }
+        }
+
+        public bool HasRight(string rightKey)
+        {
+            if (!UserId.HasValue)
+                return false;
+
+            return _authorizationService.HasRight(UserId.Value, rightKey);
+        }
+
+        public bool IsAdmin => UserId.HasValue && _authorizationService.IsAdmin(UserId.Value);
+    }
+}

ContactManagementAPI/ViewModels/AdminViewModels.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace ContactManagementAPI.ViewModels
+{
+    public class LoginViewModel
+    {
+        [Required]
+        [MaxLength(100)]
+        public string UserName { get; set; } = string.Empty;
+
+        [Required]
+        [DataType(DataType.Password)]
+        public string Password { get; set; } = string.Empty;
+
+        public string? ReturnUrl { get; set; }
+    }
+
+    public class UserCreateViewModel
+    {
+        [Required]
+        [MaxLength(100)]
+        public string UserName { get; set; } = string.Empty;
+
+        [Required]
+        [DataType(DataType.Password)]
+        public string Password { get; set; } = string.Empty;
+
+        [MaxLength(200)]
+        public string? FullName { get; set; }
+
+        [Required]
+        public int GroupId { get; set; }
+        public bool IsAdmin { get; set; }
+        public bool IsActive { get; set; } = true;
+    }
+
+    public class UserEditViewModel
+    {
+        public int Id { get; set; }
+
+        [Required]
+        [MaxLength(100)]
+        public string UserName { get; set; } = string.Empty;
+
+        [MaxLength(200)]
+        public string? FullName { get; set; }
+
+        [DataType(DataType.Password)]
+        public string? NewPassword { get; set; }
+
+        [Required]
+        public int GroupId { get; set; }
+        public bool IsAdmin { get; set; }
+        public bool IsActive { get; set; } = true;
+    }
+
+    public class GroupEditViewModel
+    {
+        public int Id { get; set; }
+
+        [Required]
+        [MaxLength(150)]
+        public string Name { get; set; } = string.Empty;
+
+        [MaxLength(500)]
+        public string? Description { get; set; }
+    }
+
+    public class RightAssignmentViewModel
+    {
+        public string Key { get; set; } = string.Empty;
+        public string Category { get; set; } = string.Empty;
+        public string Label { get; set; } = string.Empty;
+        public bool IsGranted { get; set; }
+        public string Selection { get; set; } = "Inherit";
+        public bool EffectiveGranted { get; set; }
+        public string EffectiveSource { get; set; } = "";
+    }
+
+    public class GroupRightsViewModel
+    {
+        public int GroupId { get; set; }
+        public string GroupName { get; set; } = string.Empty;
+        public List<RightAssignmentViewModel> Rights { get; set; } = new();
+    }
+
+    public class UserRightsViewModel
+    {
+        public int UserId { get; set; }
+        public string UserName { get; set; } = string.Empty;
+        public string? GroupName { get; set; }
+        public List<RightAssignmentViewModel> Rights { get; set; } = new();
+    }
+
+    public class AdminHistoryEntryViewModel
+    {
+        public string ActionType { get; set; } = string.Empty;
+        public string EntityType { get; set; } = string.Empty;
+        public int? EntityId { get; set; }
+        public string Details { get; set; } = string.Empty;
+        public string PerformedBy { get; set; } = string.Empty;
+        public DateTime PerformedAt { get; set; }
+    }
+
+    public class AdminHistoryListViewModel
+    {
+        public List<AdminHistoryEntryViewModel> Entries { get; set; } = new();
+    }
+}

ContactManagementAPI/Views/Account/AccessDenied.cshtml

@@ -0,0 +1,11 @@
+@{
+    ViewData["Title"] = "Access Denied";
+}
+
+<div class="form-container" style="max-width: 520px; margin: 40px auto; text-align: center;">
+    <h2><i class="fas fa-ban"></i> Access Denied</h2>
+    <p>You do not have permission to access this page.</p>
+    <a href="/" class="btn btn-primary">
+        <i class="fas fa-arrow-left"></i> Back to Home
+    </a>
+</div>

ContactManagementAPI/Views/Account/Login.cshtml

@@ -0,0 +1,42 @@
+@model ContactManagementAPI.ViewModels.LoginViewModel
+@{
+    ViewData["Title"] = "Login";
+}
+
+<div class="form-container" style="max-width: 520px; margin: 40px auto;">
+    <h2><i class="fas fa-sign-in-alt"></i> Sign In</h2>
+
+    <form method="post" asp-action="Login">
+        @Html.AntiForgeryToken()
+        <input type="hidden" asp-for="ReturnUrl" />
+
+        <div class="form-group">
+            <label asp-for="UserName"></label>
+            <input asp-for="UserName" class="form-control" />
+            <span asp-validation-for="UserName" class="text-danger"></span>
+        </div>
+
+        <div class="form-group">
+            <label asp-for="Password"></label>
+            <input asp-for="Password" class="form-control" type="password" />
+            <span asp-validation-for="Password" class="text-danger"></span>
+        </div>
+
+        <div class="form-actions">
+            <button type="submit" class="btn btn-primary">
+                <i class="fas fa-lock"></i> Login
+            </button>
+        </div>
+
+        @if (!ViewData.ModelState.IsValid)
+        {
+            <div class="alert alert-danger" style="margin-top: 15px;">
+                Please check your credentials and try again.
+            </div>
+        }
+    </form>
+</div>
+
+@section Scripts {
+    <partial name="_ValidationScriptsPartial" />
+}