Exemplo n.º 1
0
        public BasicResponse Delete(int id)
        {
            var call = _context.Calls.FirstOrDefault(c => c.Id == id);

            if (call != null)
            {
                _context.Calls.Remove(call);
                _context.SaveChanges();
                return(BasicResponse.SuccessResult("Call does not exist"));
            }
            return(BasicResponse.FailureResult("Call does not exist"));
        }
Exemplo n.º 2
0
        public async Task <BasicResponse> Login(LoginViewModel model, string returnUrl = null)
        {
            var copy = _perm;

            ViewData["ReturnUrl"] = returnUrl;

            if (string.IsNullOrEmpty(returnUrl))
            {
                ViewData["ReturnUrl"] = "";
            }

            if (ModelState.IsValid)
            {
                var user = await _userManager.FindByNameAsync(model.UserName);

                if (user != null)
                {
                    var identity = $"{user.UserName}".Trim();

                    //var isRemoved = await _userManager.RemovePasswordAsync(user);
                    //var isAdded = await _userManager.AddPasswordAsync(user, "Password@1");

                    var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false);

                    if (result.Succeeded)
                    {
                        await _userManager.ResetAccessFailedCountAsync(user);

                        var defaultUrl = "/Home/Index";
                        if (user.LastLogin != null)
                        {
                            user.LastLogin = DateTime.Now;
                            await _userManager.UpdateAsync(user);

                            return(BasicResponse.SuccessResult(defaultUrl));
                        }
                        defaultUrl = $"/Home/FirstChangePassword?username={model.UserName}";
                        await _signInManager.SignOutAsync();

                        return(BasicResponse.SuccessResult(defaultUrl));
                    }
                    if (result.IsLockedOut)
                    {
                        return(BasicResponse.FailureResult("User account locked out."));
                    }
                }
                ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            }
            return(BasicResponse.FailureResult(ModelState.GetModelErrors()));
        }
Exemplo n.º 3
0
 public BasicResponse Assign(Call call)
 {
     try
     {
         var createCall         = Create(call);
         var createCalltimeline = CreateTimeline(createCall);
         var updateInitiateCall = UpdateInitiatedCall(createCalltimeline);
         var scheduleCall       = Schedule(updateInitiateCall);
         return(BasicResponse.SuccessResult("Call assigned successfully"));
     }
     catch (AppException ex)
     {
         return(BasicResponse.FailureResult(ex.Message));
     }
 }
Exemplo n.º 4
0
        public async Task <BasicResponse> ChangePassword(string Username, string OldPassword, string NewPassword, string ConfirmPassword)
        {
            if (!string.IsNullOrEmpty(Username))
            {
                var user = await _userManager.FindByNameAsync(Username);

                if (user != null)
                {
                    if (string.IsNullOrEmpty(NewPassword))
                    {
                        return(BasicResponse.FailureResult("Password change failed, New password is required!"));
                    }
                    if (NewPassword != ConfirmPassword)
                    {
                        return(BasicResponse.FailureResult("The new password and confirmation password do not match."));
                    }
                    var result = await _userManager.ChangePasswordAsync(user, OldPassword, NewPassword);

                    if (result.Succeeded)
                    {
                        user.LastLogin = DateTime.Now;
                        var response = await _userManager.UpdateAsync(user);

                        await _audit.CreateAudit("Change Password", "Password change successful");

                        if (_perm.IsSignedIn)
                        {
                            await _signInManager.SignOutAsync();
                        }
                        return(BasicResponse.SuccessResult("/Home/Login"));
                    }
                    await _audit.CreateAudit("Change Password", "Password change failed");

                    return(BasicResponse.FailureResult("Password change failed!"));
                }
                await _audit.CreateAudit("Change Password", "Password change failed");

                return(BasicResponse.FailureResult("Password change failed, User does not exist!"));
            }
            await _audit.CreateAudit("Change Password", "Password change failed");

            return(BasicResponse.FailureResult("Password change failed, Username is required!"));
        }
Exemplo n.º 5
0
        public async Task <BasicResponse> ResetPassword(string Username)
        {
            var username = Username;

            if (username != null)
            {
                var user = await _userManager.FindByNameAsync(username);

                if (user != null)
                {
                    // var password = RandomPassword.Generate(10);
                    var password  = "******";
                    var isRemoved = await _userManager.RemovePasswordAsync(user);

                    var isAdded = await _userManager.AddPasswordAsync(user, password);

                    if (isRemoved.Succeeded && isAdded.Succeeded)
                    {
                        user.Pwd = password;

                        //send email to new user
                        //var emailSetting = _db.Settings.FirstOrDefault(x => x.Key == "Admin.Email.ResetPassword")?.Value;
                        //var emailTemplate = communication.GetTemplatedMessage(emailSetting, user);
                        //var sendEmail = await communication.SendEmail($"{user.Email}", "PayAttitude Shopping Solution", emailTemplate, "Shopping");
                        //await _audit.CreateAudit("Reset Password", "Password reset successful");
                        // user.LastLogin = DateTime.Now;
                        user.LastLogin = null;
                        await _userManager.UpdateAsync(user);

                        return(BasicResponse.SuccessResult("/Home/Login"));
                    }
                    await _audit.CreateAudit("Reset Password", "Password reset failed");

                    return(BasicResponse.FailureResult("Password reset failed!"));
                }
                await _audit.CreateAudit("Reset Password", "Password reset failed");

                return(BasicResponse.FailureResult("Password reset failed, User does not exist!"));
            }
            await _audit.CreateAudit("Reset Password", "Password reset failed");

            return(BasicResponse.FailureResult("Password reset failed, Username is required!"));
        }
Exemplo n.º 6
0
 public BasicResponse Initiate(InitiatedCall initiatedcall)
 {
     try
     {
         var callInitiated = new InitiatedCall
         {
             CallOrderNumber  = initiatedcall.CallOrderNumber,
             ErrorCode        = initiatedcall.ErrorCode,
             ErrorDescription = initiatedcall.ErrorDescription,
             IsAssigned       = false,
             BankId           = initiatedcall.BankId,
             InitiatorId      = initiatedcall.InitiatorId,
             MachineId        = initiatedcall.MachineId,
             DateCreated      = DateTime.Now
         };
         _context.InitiatedCalls.Add(callInitiated);
         _context.SaveChanges();
         return(BasicResponse.SuccessResult("Call initiated successfully"));
     }
     catch (AppException ex)
     {
         return(BasicResponse.FailureResult(ex.Message));
     }
 }
Exemplo n.º 7
0
        public async Task <BasicResponse> Create([FromForm] CreateUserViewModel model)
        {
            if (model.File == null)
            {
                return(BasicResponse.FailureResult("Image is required"));
            }
            var resp = await _imageHandler.UploadImage(model.File);

            var url = "";

            if (!string.IsNullOrEmpty(resp))
            {
                url = resp;
            }

            var userName  = model.Username;
            var userEmail = model.Email;
            var userCode  = Utils.GenerateCode(8);

            //var bankCode = !string.IsNullOrEmpty(model.BankCode) ? model.BankCode : "";
            //var bankId = 0;
            if (string.IsNullOrEmpty(userName))
            {
                return(BasicResponse.FailureResult("User was not created, Username was not provided."));
            }
            if (string.IsNullOrEmpty(userEmail))
            {
                return(BasicResponse.FailureResult("User was not created, Email was not provided."));
            }
            if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(userEmail))
            {
                var user = await _userManager.FindByNameAsync(userName);

                var userE = await _userManager.FindByEmailAsync(userEmail);

                if (user != null)
                {
                    return(BasicResponse.FailureResult("User record was not saved, Username already exists."));
                }
                if (userE != null)
                {
                    return(BasicResponse.FailureResult("User record was not saved, Email already exists."));
                }
                if (user == null && userE == null)
                {
                    user = new CustomUser
                    {
                        UserName         = model.Username,
                        Email            = model.Email,
                        EmailConfirmed   = true,
                        ConcurrencyStamp = $"{Guid.NewGuid()}",
                        FirstName        = model.FirstName,
                        OtherName        = model.OtherName,
                        LastName         = model.LastName,
                        PhoneNumber      = model.Phone,
                        // BankCode = model.BankCode,
                        // LeadCode = model.LeadCode,
                        // IsActive = true,
                        // IsDeleted = false,
                        ImageName   = url,
                        DateCreated = DateTime.Now,
                        DateUpdated = DateTime.Now
                    };
                    var roleName = model.RoleName;
                    var role     = await _roleManager.FindByNameAsync(roleName);

                    if (role == null)
                    {
                        return(BasicResponse.FailureResult("Selected role does not exist!"));
                    }
                    //if (roleName == "Initiator" || roleName == "BankAdmin" )
                    //{
                    //    if (string.IsNullOrEmpty(bankCode)) return BasicResponse.FailureResult("Initiator must belong to bank");
                    //    var bank = _context.Banks.FirstOrDefault(b => b.BankCode == bankCode);
                    //    if (bank == null) return BasicResponse.FailureResult("Selected Bank does not exist, Contact Administrator");
                    //    bankId = (bank != null) ? bank.Id : 0;

                    //}

                    // var password = RandomPassword.Generate(8);

                    var password = "******";
                    var result   = await _userManager.CreateAsync(user, password);

                    if (result.Succeeded && !await _userManager.IsInRoleAsync(user, roleName))
                    {
                        await _userManager.AddToRoleAsync(user, roleName);

                        user.Pwd = password;

                        // add user to initiator, assigner or engineer table
                        var userIAE = await _userManager.FindByNameAsync(userName);

                        // var email = _context.Banks.Where(b => b.BankCode == bankCode).Select(b => b.Email).FirstOrDefault();
                        if (roleName == "TeamLead")
                        {
                            var teamLead = new TeamLead
                            {
                                LeadCode    = $"TL{userCode}",
                                FirstName   = model.FirstName,
                                OtherName   = model.OtherName,
                                LastName    = model.LastName,
                                Name        = $"{model.FirstName} {model.LastName}",
                                DateCreated = DateTime.Now,
                                DateUpdated = DateTime.Now
                            };
                            var msg = $"{"You have been profiled on our call logging platform in Ark Technology as a Team Lead with "}{ teamLead.FirstName}, { teamLead.LastName} {". And your password is "}{password} {"with username " }{user.UserName}{" on "}{teamLead.DateCreated} {"  Logon to http://52.14.79.38/ using your usersame and password"}";
                            if (teamLead.LastName != null)
                            {
                                var TLemail = model.Email.ToString();


                                var sendMail = _emailSender.SendEmailAsync(TLemail, "Call Notification", msg);
                            }
                            _context.TeamLeads.Add(teamLead);
                            await _context.SaveChangesAsync();

                            if (userIAE != null)
                            {
                                userIAE.LeadCode = teamLead.LeadCode;
                            }
                            var response = await _userManager.UpdateAsync(userIAE);
                        }
                        //else if (roleName == "BankAdmin")
                        //{
                        //    var bankAdmin = new BankAdmin
                        //    {
                        //        // InitiatorCode = $"BA{userCode}",
                        //        FirstName = model.FirstName,
                        //        OtherName = model.OtherName,
                        //        LastName = model.LastName,
                        //        Name = $"{model.FirstName} {model.LastName}",
                        //        BankId = bankId,
                        //        DateCreated = DateTime.Now,
                        //        DateUpdated = DateTime.Now
                        //    };
                        //    var msg = $"{"You have been profiled on our call logging platform in Ark Technology as a BankAdmin with  "}{ bankAdmin.LastName}, { bankAdmin.Name} {". And your password is "}{password} {"with username " }{user.UserName}{" on "}{bankAdmin.DateCreated}  {"  Logon to http://52.14.79.38/ using your usersame and password"}";
                        //    if (bankAdmin.LastName != null)
                        //    {
                        //      var Bemail = model.Email.ToString();


                        //        var sendMail = _emailSender.SendEmailAsync(Bemail, "Call Notification", msg);
                        //    }
                        //    _context.BankAdmins.Add(bankAdmin);
                        //    await _context.SaveChangesAsync();
                        //}
                        //else if (roleName == "Initiator")
                        //{
                        //    var initiator = new Initiator
                        //    {
                        //        InitiatorCode = $"IN{userCode}",
                        //        FirstName = model.FirstName,
                        //        OtherName = model.OtherName,
                        //        LastName = model.LastName,
                        //        Name = $"{model.FirstName} {model.LastName}",
                        //        BankId = bankId,
                        //        DateCreated = DateTime.Now,
                        //        DateUpdated = DateTime.Now
                        //    };
                        //    var msg = $"{"You have been created on our call logging platform in Ark Technology as a call Initiator with "}{ initiator.FirstName}, { initiator.Name} {". And your password is "}{password} {"with username " }{user.UserName}{" on "}{initiator.DateCreated}  {"  Logon to http://52.14.79.38/ using your usersame and password"}";
                        //    if (initiator.LastName != null)
                        //    {
                        //       var Iemail = model.Email.ToString();


                        //        var sendMail = _emailSender.SendEmailAsync(Iemail, "Call Notification", msg);
                        //    }
                        //    _context.Initiators.Add(initiator);
                        //    await _context.SaveChangesAsync();
                        //    if (userIAE != null) userIAE.InitiatorCode = initiator.InitiatorCode;
                        //    var response = await _userManager.UpdateAsync(userIAE);
                        //}
                        //else if (roleName == "Engineer")
                        //{
                        //    if (!model.TeamLeadId.HasValue)
                        //        return BasicResponse.FailureResult("Team lead must be selected for Engineer!");
                        //    var engineer = new Engineer
                        //    {
                        //        EngineerCode = $"EN{userCode}",
                        //        FirstName = model.FirstName,
                        //        OtherName = model.OtherName,
                        //        LastName = model.LastName,
                        //        TeamLeadId = model.TeamLeadId.Value,
                        //        Name = $"{model.FirstName} {model.LastName}",
                        //        DateCreated = DateTime.Now,
                        //        DateUpdated = DateTime.Now
                        //    };
                        //    var msg = $"{"You have been created on our call logging platform in Ark Technology as a field engineer with "}{ engineer.FirstName}, { engineer.Name} {". And your password is "}{password} {"with username " }{user.UserName}{" on "}{engineer.DateCreated}  {"  Logon to http://52.14.79.38/ using your usersame and password"}";
                        //    if (engineer.FirstName != null)
                        //    {
                        //     var   Engemail = model.Email.ToString();


                        //        var sendMail = _emailSender.SendEmailAsync(Engemail, "Call Notification", msg);
                        //    }
                        //    _context.Engineers.Add(engineer);
                        //    await _context.SaveChangesAsync();
                        //    if (userIAE != null) userIAE.EngineerCode = engineer.EngineerCode;
                        //    var response = await _userManager.UpdateAsync(userIAE);
                        //}
                        //else if (roleName == "Assigner")
                        //{
                        //    var assigner = new Assigner
                        //    {
                        //        AssignerCode = $"AS{userCode}",
                        //        FirstName = model.FirstName,
                        //        OtherName = model.OtherName,
                        //        LastName = model.LastName,
                        //        Name = $"{model.FirstName} {model.LastName}",
                        //        DateCreated = DateTime.Now,
                        //        DateUpdated = DateTime.Now
                        //    };
                        //    var msg = $"{"You have been created on our call logging platform in Ark Technology as an Assigner with "}{ assigner.AssignerCode}, { assigner.Name} {". And your password is "}{password} {"with username " }{user.UserName}{" on "}{assigner.DateCreated}  {"  Logon to http://52.14.79.38/ using your usersame and password"}";
                        //    if (assigner.LastName != null)
                        //    {
                        //       var Aemail = model.Email.ToString();


                        //        var sendMail = _emailSender.SendEmailAsync(Aemail, "Call Notification", msg);
                        //    }
                        //    _context.Assigners.Add(assigner);
                        //    await _context.SaveChangesAsync();
                        //    if (userIAE != null) userIAE.AssignerCode = assigner.AssignerCode;
                        //    var response = await _userManager.UpdateAsync(userIAE);
                        //}

                        else
                        {
                            // admin users
                        }

                        await _emailSender.SendEmailAsync($"{user.Email}", "Confirm your email",
                                                          $"An account has been created for you on the Call Scheduler Solution. <br />" +
                                                          $"Username: {user.UserName} <br /> Password: {user.Pwd}");

                        await _audit.CreateAudit("Create User", "Creation of user successful");

                        return(BasicResponse.SuccessResult("User saved!"));
                    }
                    return(BasicResponse.FailureResult("User was not saved!"));
                }
            }
            return(BasicResponse.FailureResult("Username and email are required."));
        }
Exemplo n.º 8
0
        public async Task <BasicResponse> Authorize <TEntity>(int id, bool isApproved, string checksum) where TEntity : class, IEntityBase
        {
            var authorization = await Db.Authorizations.AsNoTracking().SingleOrDefaultAsync(x => x.Id == id);

            if (authorization == null || authorization.IsApproved.HasValue)
            {
                return(BasicResponse.FailureResult("Authorization record not found."));
            }

            var type = typeof(TEntity);

            if (authorization.EntityType != type.Name || authorization.EntityId != checksum)
            {
                return(BasicResponse.FailureResult("Invalid authorization record."));
            }

            ////            var set = Db.Model.GetEntityTypes(x=>x.);
            //            var t = (from f in Db.Model.GetEntityTypes()
            //                where f.ClrType == type
            //                select f).FirstOrDefault();

            // authorization.Authorizer = Perm.CurrentUser.UserName;
            authorization.AuthorizeTimestamp = DateTime.Now;
            authorization.IsApproved         = isApproved;

            if (isApproved)
            {
                var props = from prop in type.GetProperties()
                            let info                     = prop.PropertyType.GetTypeInfo()
                                                 let map = prop.GetCustomAttributes(typeof(NotMappedAttribute), true)
                                                           // let empty = prop.GetCustomAttributes(typeof(ByPassAttribute), true)
                                                           where prop.Name != "Id" && prop.CanWrite && (info.IsValueType ||
                                                                                                        prop.PropertyType.IsAssignableFrom(typeof(string))) &&
                                                           !map.Any()
                                                           select prop;

                var set = Db.Set <TEntity>();
                var obj = authorization.EntityJson.Parse <TEntity>();
                try
                {
                    TEntity current;
                    switch (authorization.AuditType)
                    {
                    case AuditType.Create:
                        await set.AddAsync(obj);

                        break;

                    case AuditType.Update:
                    case AuditType.Resume:
                    case AuditType.Suspend:
                        var key = type.GetProperty("Id").GetValue(obj);
                        current = await set.FindAsync(key);

                        if (current == null)
                        {
                            return(BasicResponse.FailureResult("Original record not found."));
                        }

                        foreach (var prop in props)
                        {
                            prop.SetValue(current, prop.GetValue(obj));
                        }
                        break;

                    case AuditType.Delete:
                        //                            current = await set.FindAsync(authorization.EntityId);
                        current = await set.FindAsync(type.GetProperty("Id").GetValue(obj));

                        if (current == null)
                        {
                            return(BasicResponse.FailureResult("Original record not found."));
                        }
                        set.Remove(current);
                        break;

                    case AuditType.List:
                    case AuditType.Authorize:
                    case AuditType.View:
                    default:
                        return(BasicResponse.FailureResult("Invalid authorization request."));
                    }
                }
                catch (Exception e)
                { }
            }
            try
            {
                await Db.SaveChangesAsync();

                return(BasicResponse.SuccessResult("Successfully authorized record."));
            }
            catch (Exception e)
            {
                // Logger.LogError(e);
                return(BasicResponse.FailureResult(e.InnerMostMessage()));
            }
        }
Exemplo n.º 9
0
        public static async Task <BasicResponse> SeedRolesUsers(UserManager <CustomUser> userManager, RoleManager <CustomRole> roleManager)
        {
            string[] roleNames = { "Owner", "Admin" };

            foreach (var roleName in roleNames)
            {
                var role = await roleManager.FindByNameAsync(roleName);

                if (role == null)
                {
                    role = new CustomRole
                    {
                        Description = $"{roleName} role",
                        Name        = roleName,
                        Permissions = "",
                        IsActive    = true,
                        IsDeleted   = false
                    };
                    await roleManager.CreateAsync(role);
                }
            }

            var listUsers = new List <Dictionary <string, string> >();
            var ownerUser = new Dictionary <string, string>
            {
                { "username", "Owner" },
                { "email", "*****@*****.**" },
                { "password", "Owner@12345" },
                { "rolename", "Owner" }
            };
            var adminUser = new Dictionary <string, string>
            {
                { "username", "Admin" },
                { "email", "*****@*****.**" },
                { "password", "Admin@12345" },
                { "rolename", "Admin" }
            };

            //var assigner = new Dictionary<string, string>
            //{
            //    { "username", "assigner" },
            //    { "email", "*****@*****.**" },
            //    { "password", "Assigner@12345" },
            //    { "rolename", "assigner" }
            //};
            //var initiator = new Dictionary<string, string>
            //{
            //    { "username", "initiator" },
            //    { "email", "*****@*****.**" },
            //    { "password", "Initiator@12345" },
            //    { "rolename", "initiator" }
            //};
            listUsers.Add(ownerUser);
            listUsers.Add(adminUser);
            //listUsers.Add(assigner);
            //listUsers.Add(initiator);

            try
            {
                foreach (var userDict in listUsers)
                {
                    var username = userDict.GetValue("username", true);
                    var user     = await userManager.FindByNameAsync(username);

                    var result = new IdentityResult();

                    if (user == null)
                    {
                        user = new CustomUser
                        {
                            UserName         = username,
                            Email            = userDict.GetValue("email", true),
                            EmailConfirmed   = true,
                            LastLogin        = DateTime.Now,
                            ConcurrencyStamp = $"{Guid.NewGuid()}",
                            IsActive         = true,
                            IsDeleted        = false
                        };
                        result = await userManager.CreateAsync(user, userDict.GetValue("password", true));
                    }

                    if (result.Succeeded)
                    {
                        var roleName = userDict.GetValue("rolename", true);
                        var role     = await roleManager.FindByNameAsync(roleName);

                        if (role == null)
                        {
                            role = new CustomRole
                            {
                                Description = $"{roleName} role",
                                Name        = roleName,
                                Permissions = "",
                                IsActive    = true,
                                IsDeleted   = false
                            };
                            await roleManager.CreateAsync(role);
                        }
                        if (!await userManager.IsInRoleAsync(user, roleName))
                        {
                            await userManager.AddToRoleAsync(user, roleName);
                        }
                    }
                }
                return(BasicResponse.SuccessResult("Default roles and users seeded succesfully"));
            }
            catch (Exception e)
            {
                return(BasicResponse.FailureResult(e.Message));
            }
        }
Exemplo n.º 10
0
        public static async Task <BasicResponse> SeedBanks(CallSchedulerDbContext _context)
        {
            _context.Database.EnsureCreated();

            // banks dictionary
            var listBanks = new List <Dictionary <string, string> >();
            var UBA       = new Dictionary <string, string>
            {
                { "bankcode", "1033" },
                { "name", "UBA" },
                { "shortName", "UBA" },
                { "address", "Umuahia 1 Bo Atm 4" },
                { "email", "*****@*****.**" },
                { "phone", "08094446789" },
                { "rcNo", "123456" },
                { "slaStartTime", "08:00" },
                { "slaEndTime", "17:00" }
            };
            var UB = new Dictionary <string, string>
            {
                { "bankcode", "1215" },
                { "name", "Unity Bank" },
                { "shortName", "UB" },
                { "address", "Umuahia" },
                { "email", "*****@*****.**" },
                { "phone", "08095556743" },
                { "rcNo", "908765" },
                { "slaStartTime", "09:00" },
                { "slaEndTime", "18:00" }
            };
            var Keystone = new Dictionary <string, string>
            {
                { "bankcode", "1082" },
                { "name", "Keystone Bank" },
                { "shortName", "KB" },
                { "address", "Ph/Aba Road" },
                { "email", "*****@*****.**" },
                { "phone", "08095556743" },
                { "rcNo", "908761" },
                { "slaStartTime", "09:00" },
                { "slaEndTime", "18:00" }
            };
            var ECO = new Dictionary <string, string>
            {
                { "bankcode", "1050" },
                { "name", "Eco Bank" },
                { "shortName", "EB" },
                { "address", "Ab Ngwa Rd Aba" },
                { "email", "*****@*****.**" },
                { "phone", "08095556743" },
                { "rcNo", "908765" },
                { "slaStartTime", "09:00" },
                { "slaEndTime", "18:00" }
            };
            var Heritage = new Dictionary <string, string>
            {
                { "bankcode", "1030" },
                { "name", "Heritage Bank" },
                { "shortName", "HB" },
                { "address", "Lagos" },
                { "email", "*****@*****.**" },
                { "phone", "08095556743" },
                { "rcNo", "908765" },
                { "slaStartTime", "09:00" },
                { "slaEndTime", "18:00" }
            };
            var Polaris = new Dictionary <string, string>
            {
                { "bankcode", "1076" },
                { "name", "Polaris Bank" },
                { "shortName", "PB" },
                { "address", "Lagos" },
                { "email", "*****@*****.**" },
                { "phone", "08095556743" },
                { "rcNo", "908765" },
                { "slaStartTime", "09:00" },
                { "slaEndTime", "18:00" }
            };
            var Wema = new Dictionary <string, string>
            {
                { "bankcode", "1035" },
                { "name", "Wema Bank" },
                { "shortName", "WB" },
                { "address", "Lagos" },
                { "email", "*****@*****.**" },
                { "phone", "08095556743" },
                { "rcNo", "908765" },
                { "slaStartTime", "09:00" },
                { "slaEndTime", "18:00" }
            };
            var Access = new Dictionary <string, string>
            {
                { "bankcode", "1044" },
                { "name", "Access Bank" },
                { "shortName", "AB" },
                { "address", "Lagos" },
                { "email", "*****@*****.**" },
                { "phone", "08095556743" },
                { "rcNo", "908765" },
                { "slaStartTime", "09:00" },
                { "slaEndTime", "18:00" }
            };

            listBanks.Add(UBA);
            listBanks.Add(UB);
            listBanks.Add(Keystone);
            listBanks.Add(ECO);
            listBanks.Add(Heritage);
            listBanks.Add(Polaris);
            listBanks.Add(Wema);
            listBanks.Add(Access);

            // machine variants dictionary
            var listMachineVariants = new List <Dictionary <string, string> >();
            var NCR = new Dictionary <string, string>
            {
                { "code", "0001" },
                { "name", "NCR" }
            };
            var Wincor = new Dictionary <string, string>
            {
                { "code", "0002" },
                { "name", "Wincor" }
            };

            listMachineVariants.Add(NCR);
            listMachineVariants.Add(Wincor);



            try
            {
                foreach (var bankDict in listBanks)
                {
                    var bankCode = bankDict.GetValue("bankcode", true);
                    var bank     = _context.Banks.FirstOrDefault(c => c.BankCode == bankCode);
                    if (bank == null)
                    {
                        bank = new Bank()
                        {
                            BankCode     = bankCode,
                            Name         = bankDict.GetValue("name", true),
                            ShortName    = bankDict.GetValue("shortName", true),
                            Address      = bankDict.GetValue("address", true),
                            Email        = bankDict.GetValue("email", true),
                            Phone        = bankDict.GetValue("phone", true),
                            RcNo         = bankDict.GetValue("rcNo", true),
                            SLAAmount    = 5000.00m,
                            SLADuration  = 5,
                            SLAStartTime = bankDict.GetValue("slaStartTime", true),
                            SLAEndTime   = bankDict.GetValue("slaEndTime", true),
                            DateCreated  = DateTime.Now,
                            DateUpdated  = DateTime.Now
                        };
                        _context.Banks.Add(bank);
                        await _context.SaveChangesAsync();
                    }
                }
                foreach (var machineVariantDict in listMachineVariants)
                {
                    var code           = machineVariantDict.GetValue("code", true);
                    var name           = machineVariantDict.GetValue("name", true);
                    var machineVariant = _context.MachineVariants.FirstOrDefault(c => c.Code == code);
                    if (machineVariant == null)
                    {
                        machineVariant = new MachineVariant()
                        {
                            Code        = code,
                            Name        = name,
                            DateCreated = DateTime.Now,
                            DateUpdated = DateTime.Now
                        };
                        _context.MachineVariants.Add(machineVariant);
                        await _context.SaveChangesAsync();
                    }
                }
                return(BasicResponse.SuccessResult("Banks and machine variant seeded successfully!"));
            }
            catch (Exception e)
            {
                return(BasicResponse.FailureResult(e.Message));
            }
        }