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"));
}
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()));
}
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));
}
}
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!"));
}
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!"));
}
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));
}
}
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."));
}
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()));
}
}
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));
}
}
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));
}
}
