initial commit

This commit is contained in:
2026-07-21 13:38:38 +07:00
commit 5047288f04
777 changed files with 57255 additions and 0 deletions
+104
View File
@@ -0,0 +1,104 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Indotalent.Data.Enums;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class BillSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.Bill.AnyAsync()) return;
var random = new Random();
var entityName = nameof(Bill);
var dateFinish = DateTime.Now;
var dateStart = new DateTime(dateFinish.AddMonths(-12).Year, dateFinish.AddMonths(-12).Month, 1);
var confirmedPurchaseOrders = await context.PurchaseOrder
.Where(po => po.OrderStatus == PurchaseOrderStatus.Confirmed)
.Select(po => po.Id)
.ToListAsync();
if (!confirmedPurchaseOrders.Any()) return;
for (DateTime date = dateStart; date < dateFinish; date = date.AddMonths(1))
{
DateTime[] billDates = GetRandomDays(date.Year, date.Month, 5);
foreach (var billDate in billDates)
{
if (confirmedPurchaseOrders.Count == 0) break;
var status = GetRandomStatus(random);
var purchaseOrderId = GetRandomAndRemove(confirmedPurchaseOrders, random);
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var bill = new Bill
{
AutoNumber = autoNo,
BillDate = billDate,
BillStatus = status,
Description = $"Bill for {billDate:MMMM yyyy}",
PurchaseOrderId = purchaseOrderId
};
await context.Bill.AddAsync(bill);
}
}
await context.SaveChangesAsync();
}
private static BillStatus GetRandomStatus(Random random)
{
var statuses = new[]
{
BillStatus.Draft,
BillStatus.Cancelled,
BillStatus.Confirmed
};
var weights = new[] { 1, 1, 4 };
int totalWeight = weights.Sum();
int randomNumber = random.Next(0, totalWeight);
for (int i = 0; i < statuses.Length; i++)
{
if (randomNumber < weights[i]) return statuses[i];
randomNumber -= weights[i];
}
return BillStatus.Confirmed;
}
private static string GetRandomAndRemove(List<string> list, Random random)
{
int index = random.Next(list.Count);
string value = list[index];
list.RemoveAt(index);
return value;
}
private static DateTime[] GetRandomDays(int year, int month, int count)
{
var random = new Random();
int daysInMonthCount = DateTime.DaysInMonth(year, month);
var daysInMonth = Enumerable.Range(1, daysInMonthCount).ToList();
var selectedDays = new List<int>();
for (int i = 0; i < count && daysInMonth.Count > 0; i++)
{
int day = daysInMonth[random.Next(daysInMonth.Count)];
selectedDays.Add(day);
daysInMonth.Remove(day);
}
return selectedDays.Select(day => new DateTime(year, month, day)).ToArray();
}
}
@@ -0,0 +1,26 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class BookingGroupSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.BookingGroup.AnyAsync()) return;
var bookingGroups = new List<BookingGroup>
{
new BookingGroup { Name = "Vehicle" },
new BookingGroup { Name = "Room" },
new BookingGroup { Name = "Electronic" }
};
foreach (var bookingGroup in bookingGroups)
{
await context.BookingGroup.AddAsync(bookingGroup);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,71 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class BookingResourceSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.BookingResource.AnyAsync()) return;
var vehicleGroup = await context.BookingGroup.Where(x => x.Name == "Vehicle").SingleOrDefaultAsync();
if (vehicleGroup != null)
{
var vehicleResources = new List<BookingResource>
{
new BookingResource { Name = "Audi 01", BookingGroupId = vehicleGroup.Id },
new BookingResource { Name = "Audi 02", BookingGroupId = vehicleGroup.Id },
new BookingResource { Name = "Audi 03", BookingGroupId = vehicleGroup.Id },
new BookingResource { Name = "BMW 01", BookingGroupId = vehicleGroup.Id },
new BookingResource { Name = "BMW 02", BookingGroupId = vehicleGroup.Id },
new BookingResource { Name = "BMW 03", BookingGroupId = vehicleGroup.Id },
new BookingResource { Name = "Lexus 01", BookingGroupId = vehicleGroup.Id },
new BookingResource { Name = "Lexus 02", BookingGroupId = vehicleGroup.Id },
new BookingResource { Name = "Lexus 03", BookingGroupId = vehicleGroup.Id }
};
await context.BookingResource.AddRangeAsync(vehicleResources);
}
var roomGroup = await context.BookingGroup.Where(x => x.Name == "Room").SingleOrDefaultAsync();
if (roomGroup != null)
{
var roomResources = new List<BookingResource>
{
new BookingResource { Name = "Room One", BookingGroupId = roomGroup.Id },
new BookingResource { Name = "Room Two", BookingGroupId = roomGroup.Id },
new BookingResource { Name = "Room Three", BookingGroupId = roomGroup.Id },
new BookingResource { Name = "Conference One", BookingGroupId = roomGroup.Id },
new BookingResource { Name = "Conference Two", BookingGroupId = roomGroup.Id },
new BookingResource { Name = "Conference Three", BookingGroupId = roomGroup.Id },
new BookingResource { Name = "Studio One", BookingGroupId = roomGroup.Id },
new BookingResource { Name = "Studio Two", BookingGroupId = roomGroup.Id },
new BookingResource { Name = "Studio Three", BookingGroupId = roomGroup.Id }
};
await context.BookingResource.AddRangeAsync(roomResources);
}
var electronicGroup = await context.BookingGroup.Where(x => x.Name == "Electronic").SingleOrDefaultAsync();
if (electronicGroup != null)
{
var electronicResources = new List<BookingResource>
{
new BookingResource { Name = "Epson Projector", BookingGroupId = electronicGroup.Id },
new BookingResource { Name = "Sony Projector", BookingGroupId = electronicGroup.Id },
new BookingResource { Name = "Bose Speaker", BookingGroupId = electronicGroup.Id },
new BookingResource { Name = "JBL Speaker", BookingGroupId = electronicGroup.Id },
new BookingResource { Name = "Microsoft Webcam", BookingGroupId = electronicGroup.Id },
new BookingResource { Name = "Logitech Webcam", BookingGroupId = electronicGroup.Id },
new BookingResource { Name = "Google Chromecast", BookingGroupId = electronicGroup.Id },
new BookingResource { Name = "Apple TV", BookingGroupId = electronicGroup.Id },
new BookingResource { Name = "Samsung Monitor 49", BookingGroupId = electronicGroup.Id }
};
await context.BookingResource.AddRangeAsync(electronicResources);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,85 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Indotalent.Data.Enums;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class BookingSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.Booking.AnyAsync()) return;
var random = new Random();
var bookingStatusValues = Enum.GetValues(typeof(BookingStatus)).Cast<BookingStatus>().ToList();
var entityName = nameof(Booking);
var dateEnd = DateTime.Now.AddMonths(6);
var dateStart = dateEnd.AddMonths(-6);
var bookingResources = await context.BookingResource
.Select(x => x.Id)
.ToListAsync();
if (!bookingResources.Any()) return;
var dummyLocations = new List<string>
{
"123 Main St, New York",
"456 Elm St, Los Angeles",
"789 Pine St, Chicago",
"101 Maple St, Houston",
"202 Oak St, Phoenix",
"303 Birch St, Philadelphia",
"404 Cedar St, San Antonio",
"505 Walnut St, San Diego",
"606 Aspen St, Dallas",
"707 Spruce St, San Jose"
};
for (DateTime date = dateStart; date < dateEnd; date = date.AddMonths(1))
{
DateTime[] transactionDates = GenerateRandomDays(date.Year, date.Month, 12);
foreach (DateTime transDate in transactionDates)
{
TimeSpan randomTime = TimeSpan.FromHours(random.Next(8, 12));
DateTime startTime = transDate.Date.Add(randomTime);
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var booking = new Booking
{
Subject = autoNo,
AutoNumber = autoNo,
StartTime = startTime,
EndTime = startTime.AddHours(random.Next(2, 12)),
BookingResourceId = GetRandomValue(bookingResources, random),
Status = bookingStatusValues[random.Next(bookingStatusValues.Count)],
Location = GetRandomValue(dummyLocations, random)
};
await context.Booking.AddAsync(booking);
}
}
await context.SaveChangesAsync();
}
private static DateTime[] GenerateRandomDays(int year, int month, int count)
{
var random = new Random();
int daysInMonthCount = DateTime.DaysInMonth(year, month);
return Enumerable.Range(1, count)
.Select(_ => new DateTime(year, month, random.Next(1, daysInMonthCount + 1)))
.ToArray();
}
private static T GetRandomValue<T>(List<T> list, Random random)
{
return list[random.Next(list.Count)];
}
}
@@ -0,0 +1,28 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class CustomerCategorySeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.CustomerCategory.AnyAsync()) return;
var customerCategories = new List<CustomerCategory>
{
new CustomerCategory { Name = "Enterprise" },
new CustomerCategory { Name = "Medium" },
new CustomerCategory { Name = "Small" },
new CustomerCategory { Name = "Startup" },
new CustomerCategory { Name = "Micro" }
};
foreach (var category in customerCategories)
{
await context.CustomerCategory.AddAsync(category);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,80 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class CustomerContactSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.CustomerContact.AnyAsync()) return;
var firstNames = new string[]
{
"Adam", "Sarah", "Michael", "Emily", "David", "Jessica",
"Kevin", "Samantha", "Jason", "Olivia", "Matthew", "Ashley",
"Christopher", "Jennifer", "Nicholas", "Amanda", "Alexander",
"Stephanie", "Jonathan", "Lauren"
};
var lastNames = new string[]
{
"Johnson", "Williams", "Brown", "Jones", "Miller", "Davis",
"Garcia", "Rodriguez", "Wilson", "Martinez", "Anderson", "Taylor",
"Thomas", "Hernandez", "Moore", "Martin", "Jackson", "Thompson",
"White", "Lopez"
};
var jobTitles = new string[]
{
"Chief Executive Officer", "Data Scientist", "Product Manager", "Business Development Executive",
"IT Consultant", "Social Media Specialist", "Research Analyst", "Content Writer",
"Operations Manager", "Financial Planner", "Software Developer", "Customer Success Manager",
"Marketing Coordinator", "Quality Assurance Tester", "HR Specialist", "Event Coordinator",
"Account Executive", "Network Administrator", "Sales Manager", "Legal Assistant"
};
var customerIds = await context.Customer.Select(x => x.Id).ToListAsync();
var random = new Random();
var entityName = nameof(CustomerContact);
foreach (var customerId in customerIds)
{
for (int i = 0; i < 3; i++)
{
var firstName = GetRandomString(firstNames, random);
var lastName = GetRandomString(lastNames, random);
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var contact = new CustomerContact
{
Name = $"{firstName} {lastName}",
AutoNumber = autoNo,
CustomerId = customerId,
JobTitle = GetRandomString(jobTitles, random),
EmailAddress = $"{firstName.ToLower()}.{lastName.ToLower()}@gmail.com",
PhoneNumber = GenerateRandomPhoneNumber(random)
};
await context.CustomerContact.AddAsync(contact);
}
}
await context.SaveChangesAsync();
}
private static string GetRandomString(string[] array, Random random)
{
return array[random.Next(array.Length)];
}
private static string GenerateRandomPhoneNumber(Random random)
{
return $"+1-{random.Next(100, 999)}-{random.Next(100, 999)}-{random.Next(1000, 9999)}";
}
}
@@ -0,0 +1,29 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class CustomerGroupSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.CustomerGroup.AnyAsync()) return;
var customerGroups = new List<CustomerGroup>
{
new CustomerGroup { Name = "Corporate" },
new CustomerGroup { Name = "Government" },
new CustomerGroup { Name = "Foundation" },
new CustomerGroup { Name = "Military" },
new CustomerGroup { Name = "Education" },
new CustomerGroup { Name = "Hospitality" }
};
foreach (var group in customerGroups)
{
await context.CustomerGroup.AddAsync(group);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,82 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class CustomerSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.Customer.AnyAsync()) return;
var groups = await context.CustomerGroup.Select(x => x.Id).ToArrayAsync();
var categories = await context.CustomerCategory.Select(x => x.Id).ToArrayAsync();
var cities = new string[] { "New York", "Los Angeles", "San Francisco", "Chicago" };
var streets = new string[] { "Main St", "Broadway", "Market St", "Elm St" };
var states = new string[] { "NY", "CA", "IL", "TX" };
var zipCodes = new string[] { "10001", "90001", "94101", "60601" };
var phoneNumbers = new string[] { "555-1234", "555-5678", "555-8765", "555-4321" };
var emailDomains = new string[] { "example.com", "demo.com", "test.com", "sample.com" };
var random = new Random();
var entityName = nameof(Customer);
var customers = new List<Customer>
{
new Customer { Name = "Citadel LLC" },
new Customer { Name = "Ironclad LLC" },
new Customer { Name = "Armada LLC" },
new Customer { Name = "Shield LLC" },
new Customer { Name = "Alpha LLC" },
new Customer { Name = "Capitol LLC" },
new Customer { Name = "Federal LLC" },
new Customer { Name = "Statewide LLC" },
new Customer { Name = "Harmony LLC" },
new Customer { Name = "Hope LLC" },
new Customer { Name = "Unity LLC" },
new Customer { Name = "Prosperity LLC" },
new Customer { Name = "Global LLC" },
new Customer { Name = "Sunset LLC" },
new Customer { Name = "Luxe LLC" },
new Customer { Name = "Serenity LLC" },
new Customer { Name = "Oasis LLC" },
new Customer { Name = "Grandeur LLC" },
new Customer { Name = "Bright LLC" },
new Customer { Name = "Stellar LLC" }
};
foreach (var customer in customers)
{
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
customer.AutoNumber = autoNo;
customer.CustomerGroupId = GetRandomValue(groups, random);
customer.CustomerCategoryId = GetRandomValue(categories, random);
customer.City = GetRandomString(cities, random);
customer.Street = GetRandomString(streets, random);
customer.State = GetRandomString(states, random);
customer.ZipCode = GetRandomString(zipCodes, random);
customer.PhoneNumber = GetRandomString(phoneNumbers, random);
customer.EmailAddress = $"{customer.Name?.Split(' ')[0].ToLower()}@{GetRandomString(emailDomains, random)}";
await context.Customer.AddAsync(customer);
}
await context.SaveChangesAsync();
}
private static T GetRandomValue<T>(T[] array, Random random)
{
return array[random.Next(array.Length)];
}
private static string GetRandomString(string[] array, Random random)
{
return array[random.Next(array.Length)];
}
}
@@ -0,0 +1,99 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Indotalent.Data.Enums;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class InvoiceSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.Invoice.AnyAsync()) return;
var random = new Random();
var entityName = nameof(Invoice);
var dateFinish = DateTime.Now;
var dateStart = new DateTime(dateFinish.AddMonths(-12).Year, dateFinish.AddMonths(-12).Month, 1);
var confirmedSalesOrders = await context.SalesOrder
.Where(so => so.OrderStatus == SalesOrderStatus.Confirmed)
.Select(so => so.Id)
.ToListAsync();
if (!confirmedSalesOrders.Any()) return;
for (DateTime date = dateStart; date < dateFinish; date = date.AddMonths(1))
{
DateTime[] invoiceDates = GetRandomDays(date.Year, date.Month, 5);
foreach (var invoiceDate in invoiceDates)
{
if (confirmedSalesOrders.Count == 0) break;
var status = GetRandomStatus(random);
var salesOrderId = GetRandomAndRemove(confirmedSalesOrders, random);
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var invoice = new Invoice
{
AutoNumber = autoNo,
InvoiceDate = invoiceDate,
InvoiceStatus = status,
Description = $"Invoice for {invoiceDate:MMMM yyyy}",
SalesOrderId = salesOrderId
};
await context.Invoice.AddAsync(invoice);
}
}
await context.SaveChangesAsync();
}
private static InvoiceStatus GetRandomStatus(Random random)
{
var statuses = new[] { InvoiceStatus.Draft, InvoiceStatus.Cancelled, InvoiceStatus.Confirmed };
var weights = new[] { 1, 1, 4 };
int totalWeight = weights.Sum();
int randomNumber = random.Next(0, totalWeight);
for (int i = 0; i < statuses.Length; i++)
{
if (randomNumber < weights[i]) return statuses[i];
randomNumber -= weights[i];
}
return InvoiceStatus.Confirmed;
}
private static string GetRandomAndRemove(List<string> list, Random random)
{
int index = random.Next(list.Count);
string value = list[index];
list.RemoveAt(index);
return value;
}
private static DateTime[] GetRandomDays(int year, int month, int count)
{
var random = new Random();
int daysInMonthCount = DateTime.DaysInMonth(year, month);
var daysInMonth = Enumerable.Range(1, daysInMonthCount).ToList();
var selectedDays = new List<int>();
for (int i = 0; i < count && daysInMonth.Count > 0; i++)
{
int day = daysInMonth[random.Next(daysInMonth.Count)];
selectedDays.Add(day);
daysInMonth.Remove(day);
}
return selectedDays.Select(day => new DateTime(year, month, day)).ToArray();
}
}
@@ -0,0 +1,117 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Indotalent.Data.Enums;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class PaymentDisburseSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.PaymentDisburse.AnyAsync()) return;
var random = new Random();
var entityName = nameof(PaymentDisburse);
var dateFinish = DateTime.Now;
var dateStart = new DateTime(dateFinish.AddMonths(-12).Year, dateFinish.AddMonths(-12).Month, 1);
var confirmedBills = await context.Bill
.Include(b => b.PurchaseOrder)
.Where(b => b.BillStatus == BillStatus.Confirmed)
.ToListAsync();
var paymentMethods = await context.PaymentMethod
.Select(pm => pm.Id)
.ToListAsync();
if (!paymentMethods.Any()) return;
for (DateTime date = dateStart; date < dateFinish; date = date.AddMonths(1))
{
DateTime[] paymentDates = GetRandomDays(date.Year, date.Month, 4);
foreach (var paymentDate in paymentDates)
{
if (confirmedBills.Count == 0) break;
var status = GetRandomStatus(random);
var bill = GetRandomAndRemove(confirmedBills, random);
var paymentMethodId = GetRandomValue(paymentMethods, random);
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var paymentDisburse = new PaymentDisburse
{
AutoNumber = autoNo,
Description = $"Payment Disbursed on {paymentDate:MMMM yyyy}",
PaymentDate = paymentDate,
PaymentMethodId = paymentMethodId,
PaymentAmount = bill.PurchaseOrder?.AfterTaxAmount,
Status = status,
BillId = bill.Id
};
await context.PaymentDisburse.AddAsync(paymentDisburse);
}
}
await context.SaveChangesAsync();
}
private static PaymentDisburseStatus GetRandomStatus(Random random)
{
var statuses = new[]
{
PaymentDisburseStatus.Draft,
PaymentDisburseStatus.Cancelled,
PaymentDisburseStatus.Confirmed,
PaymentDisburseStatus.Archived
};
var weights = new[] { 1, 1, 4, 1 };
int totalWeight = weights.Sum();
int randomNumber = random.Next(0, totalWeight);
for (int i = 0; i < statuses.Length; i++)
{
if (randomNumber < weights[i]) return statuses[i];
randomNumber -= weights[i];
}
return PaymentDisburseStatus.Confirmed;
}
private static T GetRandomAndRemove<T>(List<T> list, Random random)
{
int index = random.Next(list.Count);
T value = list[index];
list.RemoveAt(index);
return value;
}
private static T GetRandomValue<T>(List<T> list, Random random)
{
return list[random.Next(list.Count)];
}
private static DateTime[] GetRandomDays(int year, int month, int count)
{
var random = new Random();
int daysInMonthCount = DateTime.DaysInMonth(year, month);
var daysInMonth = Enumerable.Range(1, daysInMonthCount).ToList();
var selectedDays = new List<int>();
for (int i = 0; i < count && daysInMonth.Count > 0; i++)
{
int day = daysInMonth[random.Next(daysInMonth.Count)];
selectedDays.Add(day);
daysInMonth.Remove(day);
}
return selectedDays.Select(day => new DateTime(year, month, day)).ToArray();
}
}
@@ -0,0 +1,28 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class PaymentMethodSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.PaymentMethod.AnyAsync()) return;
var paymentMethods = new List<PaymentMethod>
{
new PaymentMethod { Name = "Credit Card" },
new PaymentMethod { Name = "Debit Card" },
new PaymentMethod { Name = "Bank Transfer" },
new PaymentMethod { Name = "PayPal" },
new PaymentMethod { Name = "Cash" }
};
foreach (var paymentMethod in paymentMethods)
{
await context.PaymentMethod.AddAsync(paymentMethod);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,117 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Indotalent.Data.Enums;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class PaymentReceiveSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.PaymentReceive.AnyAsync()) return;
var random = new Random();
var entityName = nameof(PaymentReceive);
var dateFinish = DateTime.Now;
var dateStart = new DateTime(dateFinish.AddMonths(-12).Year, dateFinish.AddMonths(-12).Month, 1);
var confirmedInvoices = await context.Invoice
.Include(i => i.SalesOrder)
.Where(i => i.InvoiceStatus == InvoiceStatus.Confirmed && i.SalesOrder != null)
.ToListAsync();
var paymentMethods = await context.PaymentMethod
.Select(pm => pm.Id)
.ToListAsync();
if (!paymentMethods.Any()) return;
for (DateTime date = dateStart; date < dateFinish; date = date.AddMonths(1))
{
DateTime[] paymentDates = GetRandomDays(date.Year, date.Month, 4);
foreach (var paymentDate in paymentDates)
{
if (confirmedInvoices.Count == 0) break;
var status = GetRandomStatus(random);
var invoice = GetRandomAndRemove(confirmedInvoices, random);
var paymentMethodId = GetRandomValue(paymentMethods, random);
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var paymentReceive = new PaymentReceive
{
AutoNumber = autoNo,
Description = $"Payment Received on {paymentDate:MMMM yyyy}",
PaymentDate = paymentDate,
PaymentMethodId = paymentMethodId,
PaymentAmount = invoice?.SalesOrder?.AfterTaxAmount,
Status = status,
InvoiceId = invoice?.Id
};
await context.PaymentReceive.AddAsync(paymentReceive);
}
}
await context.SaveChangesAsync();
}
private static PaymentReceiveStatus GetRandomStatus(Random random)
{
var statuses = new[]
{
PaymentReceiveStatus.Draft,
PaymentReceiveStatus.Cancelled,
PaymentReceiveStatus.Confirmed,
PaymentReceiveStatus.Archived
};
var weights = new[] { 1, 1, 4, 1 };
int totalWeight = weights.Sum();
int randomNumber = random.Next(0, totalWeight);
for (int i = 0; i < statuses.Length; i++)
{
if (randomNumber < weights[i]) return statuses[i];
randomNumber -= weights[i];
}
return PaymentReceiveStatus.Confirmed;
}
private static T GetRandomAndRemove<T>(List<T> list, Random random)
{
int index = random.Next(list.Count);
T value = list[index];
list.RemoveAt(index);
return value;
}
private static T GetRandomValue<T>(List<T> list, Random random)
{
return list[random.Next(list.Count)];
}
private static DateTime[] GetRandomDays(int year, int month, int count)
{
var random = new Random();
int daysInMonthCount = DateTime.DaysInMonth(year, month);
var daysInMonth = Enumerable.Range(1, daysInMonthCount).ToList();
var selectedDays = new List<int>();
for (int i = 0; i < count && daysInMonth.Count > 0; i++)
{
int day = daysInMonth[random.Next(daysInMonth.Count)];
selectedDays.Add(day);
daysInMonth.Remove(day);
}
return selectedDays.Select(day => new DateTime(year, month, day)).ToArray();
}
}
@@ -0,0 +1,29 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class ProductGroupSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.ProductGroup.AnyAsync()) return;
var productGroups = new List<ProductGroup>
{
new ProductGroup { Name = "Hardware" },
new ProductGroup { Name = "Networking" },
new ProductGroup { Name = "Storage" },
new ProductGroup { Name = "Device" },
new ProductGroup { Name = "Software" },
new ProductGroup { Name = "Service" }
};
foreach (var productGroup in productGroups)
{
await context.ProductGroup.AddAsync(productGroup);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,76 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class ProductSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.Product.AnyAsync()) return;
var productGroups = await context.ProductGroup.ToListAsync();
var measureId = await context.UnitMeasure
.Where(x => x.Name == "unit")
.Select(x => x.Id)
.FirstOrDefaultAsync();
if (string.IsNullOrEmpty(measureId)) return;
var groupMapping = productGroups
.Where(pg => !string.IsNullOrEmpty(pg.Name) && !string.IsNullOrEmpty(pg.Id))
.ToDictionary(pg => pg.Name!, pg => pg.Id!);
var entityName = nameof(Product);
var products = new List<Product>
{
// Hardware - Gunakan akhiran 'm' untuk decimal literal
new Product { Name = "Dell Servers", UnitPrice = 5000m, ProductGroupId = groupMapping["Hardware"] },
new Product { Name = "Dell Desktop Computers", UnitPrice = 2000m, ProductGroupId = groupMapping["Hardware"] },
new Product { Name = "Dell Laptops", UnitPrice = 3000m, ProductGroupId = groupMapping["Hardware"] },
// Networking
new Product { Name = "Network Cables", UnitPrice = 100m, ProductGroupId = groupMapping["Networking"] },
new Product { Name = "Routers and Switches", UnitPrice = 1000m, ProductGroupId = groupMapping["Networking"] },
new Product { Name = "Antennas and Signal Boosters", UnitPrice = 2000m, ProductGroupId = groupMapping["Networking"] },
new Product { Name = "Wifii", UnitPrice = 1000m, ProductGroupId = groupMapping["Networking"] },
// Storage
new Product { Name = "HDD 500", UnitPrice = 500m, ProductGroupId = groupMapping["Storage"] },
new Product { Name = "HDD 1T", UnitPrice = 800m, ProductGroupId = groupMapping["Storage"] },
new Product { Name = "SSD 500", UnitPrice = 1000m, ProductGroupId = groupMapping["Storage"] },
new Product { Name = "SSD 1T", UnitPrice = 1500m, ProductGroupId = groupMapping["Storage"] },
// Device
new Product { Name = "Dell Keyboard", UnitPrice = 700m, ProductGroupId = groupMapping["Device"] },
new Product { Name = "Dell Mouse", UnitPrice = 500m, ProductGroupId = groupMapping["Device"] },
new Product { Name = "Dell Monitor 27inch", UnitPrice = 1000m, ProductGroupId = groupMapping["Device"] },
new Product { Name = "Dell Monitor 32inch", UnitPrice = 1500m, ProductGroupId = groupMapping["Device"] },
new Product { Name = "Dell Webcams", UnitPrice = 500m, ProductGroupId = groupMapping["Device"] },
// Software
new Product { Name = "D365 License", UnitPrice = 800m, Physical = false, ProductGroupId = groupMapping["Software"] },
// Service
new Product { Name = "IT Security", UnitPrice = 500m, Physical = false, ProductGroupId = groupMapping["Service"] },
new Product { Name = "Discount", UnitPrice = -10m, Physical = false, ProductGroupId = groupMapping["Service"] }
};
foreach (var product in products)
{
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
product.AutoNumber = autoNo;
product.UnitMeasureId = measureId;
product.Physical ??= true;
await context.Product.AddAsync(product);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,28 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class ProgramManagerResourceSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.ProgramManagerResource.AnyAsync()) return;
var programResources = new List<ProgramManagerResource>
{
new ProgramManagerResource { Name = "Information Technology" },
new ProgramManagerResource { Name = "Human Resource" },
new ProgramManagerResource { Name = "Operations" },
new ProgramManagerResource { Name = "Sales Marketing" },
new ProgramManagerResource { Name = "Finance Accounting" }
};
foreach (var programResource in programResources)
{
await context.ProgramManagerResource.AddAsync(programResource);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,75 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Indotalent.Data.Enums;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class ProgramManagerSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.ProgramManager.AnyAsync()) return;
var random = new Random();
var entityName = nameof(ProgramManager);
var programManagerResources = await context.ProgramManagerResource.Select(x => x.Id).ToListAsync();
if (!programManagerResources.Any()) return;
var statusValues = Enum.GetValues(typeof(ProgramManagerStatus)).Cast<ProgramManagerStatus>().ToList();
var priorityValues = Enum.GetValues(typeof(ProgramManagerPriority)).Cast<ProgramManagerPriority>().ToList();
var dateFinish = DateTime.Now;
var dateStart = new DateTime(dateFinish.AddMonths(-6).Year, dateFinish.AddMonths(-6).Month, 1);
for (DateTime date = dateStart; date < dateFinish; date = date.AddMonths(1))
{
DateTime[] transactionDates = GetRandomDays(date.Year, date.Month, 12);
foreach (DateTime transDate in transactionDates)
{
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var programManager = new ProgramManager
{
Title = autoNo,
AutoNumber = autoNo,
Summary = $"Lorem Ipsum Dolor Sit Amet Program - #{Guid.NewGuid().ToString().Substring(0, 5)}",
ProgramManagerResourceId = GetRandomValue(programManagerResources, random),
Status = statusValues[random.Next(statusValues.Count)],
Priority = priorityValues[random.Next(priorityValues.Count)]
};
await context.ProgramManager.AddAsync(programManager);
}
}
await context.SaveChangesAsync();
}
private static T GetRandomValue<T>(List<T> list, Random random)
{
return list[random.Next(list.Count)];
}
private static DateTime[] GetRandomDays(int year, int month, int count)
{
var random = new Random();
int daysInMonthCount = DateTime.DaysInMonth(year, month);
var daysInMonth = Enumerable.Range(1, daysInMonthCount).ToList();
var selectedDays = new List<int>();
for (int i = 0; i < count && daysInMonth.Count > 0; i++)
{
int day = daysInMonth[random.Next(daysInMonth.Count)];
selectedDays.Add(day);
daysInMonth.Remove(day);
}
return selectedDays.Select(day => new DateTime(year, month, day)).ToArray();
}
}
@@ -0,0 +1,112 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Indotalent.Data.Enums;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class PurchaseOrderSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.PurchaseOrder.AnyAsync()) return;
var random = new Random();
var entityName = nameof(PurchaseOrder);
var vendors = await context.Vendor.Select(x => x.Id).ToListAsync();
var taxes = await context.Tax.Select(x => x.Id).ToListAsync();
var products = await context.Product.ToListAsync();
if (!vendors.Any() || !taxes.Any() || !products.Any()) return;
var allStatusValues = Enum.GetValues(typeof(PurchaseOrderStatus))
.Cast<PurchaseOrderStatus>()
.ToList();
var nonConfirmedStatusValues = allStatusValues
.Where(x => x != PurchaseOrderStatus.Confirmed)
.ToList();
var dateFinish = DateTime.Now;
var dateStart = new DateTime(dateFinish.AddMonths(-12).Year, dateFinish.AddMonths(-12).Month, 1);
for (DateTime date = dateStart; date < dateFinish; date = date.AddMonths(1))
{
DateTime[] transactionDates = GetRandomDays(date.Year, date.Month, 6);
foreach (DateTime transDate in transactionDates)
{
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
PurchaseOrderStatus selectedStatus;
int probability = random.Next(1, 101);
if (probability <= 90)
{
selectedStatus = PurchaseOrderStatus.Confirmed;
}
else
{
selectedStatus = nonConfirmedStatusValues[random.Next(nonConfirmedStatusValues.Count)];
}
var purchaseOrder = new PurchaseOrder
{
AutoNumber = autoNo,
OrderDate = transDate,
OrderStatus = selectedStatus,
VendorId = GetRandomValue(vendors, random),
TaxId = GetRandomValue(taxes, random),
};
await context.PurchaseOrder.AddAsync(purchaseOrder);
int numberOfProducts = random.Next(3, 6);
for (int i = 0; i < numberOfProducts; i++)
{
var product = products[random.Next(products.Count)];
var quantity = random.Next(20, 50);
var purchaseOrderItem = new PurchaseOrderItem
{
PurchaseOrderId = purchaseOrder.Id,
ProductId = product.Id,
Summary = product.AutoNumber,
UnitPrice = product.UnitPrice,
Quantity = (double)quantity,
Total = product.UnitPrice * (decimal)quantity
};
await context.PurchaseOrderItem.AddAsync(purchaseOrderItem);
}
await context.SaveChangesAsync();
context.RecalculatePurchaseOrder(purchaseOrder.Id);
await context.SaveChangesAsync();
}
}
}
private static T GetRandomValue<T>(List<T> list, Random random)
{
return list[random.Next(list.Count)];
}
private static DateTime[] GetRandomDays(int year, int month, int count)
{
var random = new Random();
int daysInMonthCount = DateTime.DaysInMonth(year, month);
var daysInMonth = Enumerable.Range(1, daysInMonthCount).ToList();
var selectedDays = new List<int>();
for (int i = 0; i < count && daysInMonth.Count > 0; i++)
{
int day = daysInMonth[random.Next(daysInMonth.Count)];
selectedDays.Add(day);
daysInMonth.Remove(day);
}
return selectedDays.Select(day => new DateTime(year, month, day)).ToArray();
}
}
@@ -0,0 +1,107 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Indotalent.Data.Enums;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class SalesOrderSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.SalesOrder.AnyAsync()) return;
var random = new Random();
var entityName = nameof(SalesOrder);
var customers = await context.Customer.Select(x => x.Id).ToListAsync();
var taxes = await context.Tax.Select(x => x.Id).ToListAsync();
var products = await context.Product.ToListAsync();
if (!customers.Any() || !taxes.Any() || !products.Any()) return;
var dateFinish = DateTime.Now;
var dateStart = new DateTime(dateFinish.AddMonths(-12).Year, dateFinish.AddMonths(-12).Month, 1);
for (DateTime date = dateStart; date < dateFinish; date = date.AddMonths(1))
{
DateTime[] transactionDates = GetRandomDays(date.Year, date.Month, 6);
foreach (DateTime transDate in transactionDates)
{
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var salesOrder = new SalesOrder
{
AutoNumber = autoNo,
OrderDate = transDate,
OrderStatus = GetHighProbabilityStatus(random),
CustomerId = GetRandomValue(customers, random),
TaxId = GetRandomValue(taxes, random),
};
await context.SalesOrder.AddAsync(salesOrder);
int numberOfProducts = random.Next(3, 6);
for (int i = 0; i < numberOfProducts; i++)
{
var qty = (double)random.Next(2, 5);
var product = products[random.Next(products.Count)];
var salesOrderItem = new SalesOrderItem
{
SalesOrderId = salesOrder.Id,
ProductId = product.Id,
Summary = product.AutoNumber,
UnitPrice = product.UnitPrice,
Quantity = qty,
Total = (product.UnitPrice ?? 0m) * (decimal)qty
};
await context.SalesOrderItem.AddAsync(salesOrderItem);
}
await context.SaveChangesAsync();
context.RecalculateSalesOrder(salesOrder.Id);
await context.SaveChangesAsync();
}
}
}
private static SalesOrderStatus GetHighProbabilityStatus(Random random)
{
int probability = random.Next(1, 101);
if (probability <= 90)
{
return SalesOrderStatus.Confirmed;
}
else
{
var otherStatuses = new[] { SalesOrderStatus.Draft, SalesOrderStatus.Cancelled, SalesOrderStatus.Archived };
return otherStatuses[random.Next(otherStatuses.Length)];
}
}
private static T GetRandomValue<T>(List<T> list, Random random)
{
return list[random.Next(list.Count)];
}
private static DateTime[] GetRandomDays(int year, int month, int count)
{
var random = new Random();
int daysInMonthCount = DateTime.DaysInMonth(year, month);
var daysInMonth = Enumerable.Range(1, daysInMonthCount).ToList();
var selectedDays = new List<int>();
for (int i = 0; i < count && daysInMonth.Count > 0; i++)
{
int day = daysInMonth[random.Next(daysInMonth.Count)];
selectedDays.Add(day);
daysInMonth.Remove(day);
}
return selectedDays.Select(day => new DateTime(year, month, day)).ToArray();
}
}
@@ -0,0 +1,28 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class UnitMeasureSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.UnitMeasure.AnyAsync()) return;
var unitMeasures = new List<UnitMeasure>
{
new UnitMeasure { Name = "m" },
new UnitMeasure { Name = "kg" },
new UnitMeasure { Name = "hour" },
new UnitMeasure { Name = "unit" },
new UnitMeasure { Name = "pcs" }
};
foreach (var unitMeasure in unitMeasures)
{
await context.UnitMeasure.AddAsync(unitMeasure);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,54 @@
using DocumentFormat.OpenXml.InkML;
using Indotalent.Data.Entities;
using Indotalent.Infrastructure.Authentication.Identity;
using Indotalent.Infrastructure.Authorization.Identity;
using Microsoft.AspNetCore.Identity;
namespace Indotalent.Infrastructure.Database.Demo;
public static class UserSeeder
{
public static async Task GenerateDataAsync(UserManager<ApplicationUser> userManager, AppDbContext context, IConfiguration configuration)
{
var adminSettings = configuration.GetSection("IdentitySettings:DefaultAdmin").Get<DefaultAdminSettings>();
if (adminSettings == null) return;
if (context.Users.Where(x => x.Email != adminSettings.Email).Any()) return;
var userNames = new List<string>
{
"Alex", "Taylor", "Jordan", "Morgan", "Riley",
"Casey", "Peyton", "Cameron", "Jamie", "Drew",
"Dakota", "Avery", "Quinn", "Harper", "Rowan",
"Emerson", "Finley", "Skyler", "Charlie", "Sage"
};
var defaultPassword = "123456";
var domain = "@example.com";
var role = ApplicationRoles.Member;
foreach (var name in userNames)
{
var email = $"{name.ToLower()}{domain}";
if (await userManager.FindByEmailAsync(email) == null)
{
var applicationUser = new ApplicationUser
{
UserName = email,
Email = email,
FullName = name,
EmailConfirmed = true
};
var result = await userManager.CreateAsync(applicationUser, defaultPassword);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(applicationUser, role);
}
}
}
}
}
@@ -0,0 +1,29 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class VendorCategorySeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.VendorCategory.AnyAsync()) return;
var vendorCategories = new List<VendorCategory>
{
new VendorCategory { Name = "Large" },
new VendorCategory { Name = "Medium" },
new VendorCategory { Name = "Small" },
new VendorCategory { Name = "Specialty" },
new VendorCategory { Name = "Local" },
new VendorCategory { Name = "Global" }
};
foreach (var category in vendorCategories)
{
await context.VendorCategory.AddAsync(category);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,75 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class VendorContactSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.VendorContact.AnyAsync()) return;
var firstNames = new string[]
{
"Adam", "Sarah", "Michael", "Emily", "David", "Jessica",
"Kevin", "Samantha", "Jason", "Olivia", "Matthew", "Ashley",
"Christopher", "Jennifer", "Nicholas", "Amanda", "Alexander",
"Stephanie", "Jonathan", "Lauren"
};
var lastNames = new string[]
{
"Johnson", "Williams", "Brown", "Jones", "Miller", "Davis",
"Garcia", "Rodriguez", "Wilson", "Martinez", "Anderson", "Taylor",
"Thomas", "Hernandez", "Moore", "Martin", "Jackson", "Thompson",
"White", "Lopez"
};
var jobTitles = new string[]
{
"Chief Executive Officer", "Data Scientist", "Product Manager", "Business Development Executive",
"IT Consultant", "Social Media Specialist", "Research Analyst", "Content Writer",
"Operations Manager", "Financial Planner", "Software Developer", "Vendor Success Manager",
"Marketing Coordinator", "Quality Assurance Tester", "HR Specialist", "Event Coordinator",
"Account Executive", "Network Administrator", "Sales Manager", "Legal Assistant"
};
var vendorIds = await context.Vendor.Select(x => x.Id).ToListAsync();
var random = new Random();
var entityName = nameof(VendorContact);
foreach (var vendorId in vendorIds)
{
for (int i = 0; i < 3; i++)
{
var firstName = GetRandomString(firstNames, random);
var lastName = GetRandomString(lastNames, random);
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
var contact = new VendorContact
{
Name = $"{firstName} {lastName}",
AutoNumber = autoNo,
VendorId = vendorId,
JobTitle = GetRandomString(jobTitles, random),
EmailAddress = $"{firstName.ToLower()}.{lastName.ToLower()}@gmail.com",
PhoneNumber = $"+1-{random.Next(100, 999)}-{random.Next(100, 999)}-{random.Next(1000, 9999)}"
};
await context.VendorContact.AddAsync(contact);
}
}
await context.SaveChangesAsync();
}
private static string GetRandomString(string[] array, Random random)
{
return array[random.Next(array.Length)];
}
}
@@ -0,0 +1,28 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class VendorGroupSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.VendorGroup.AnyAsync()) return;
var vendorGroups = new List<VendorGroup>
{
new VendorGroup { Name = "Manufacture" },
new VendorGroup { Name = "Supplier" },
new VendorGroup { Name = "Service Provider" },
new VendorGroup { Name = "Distributor" },
new VendorGroup { Name = "Freelancer" }
};
foreach (var group in vendorGroups)
{
await context.VendorGroup.AddAsync(group);
}
await context.SaveChangesAsync();
}
}
@@ -0,0 +1,82 @@
using Indotalent.ConfigBackEnd.Extensions;
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class VendorSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.Vendor.AnyAsync()) return;
var groups = await context.VendorGroup.Select(x => x.Id).ToArrayAsync();
var categories = await context.VendorCategory.Select(x => x.Id).ToArrayAsync();
var cities = new string[] { "New York", "Los Angeles", "San Francisco", "Chicago" };
var streets = new string[] { "Main Street", "Broadway", "Elm Street", "Maple Avenue" };
var states = new string[] { "NY", "CA", "IL", "TX" };
var zipCodes = new string[] { "10001", "90001", "60601", "73301" };
var phoneNumbers = new string[] { "123-456-7890", "987-654-3210", "555-123-4567", "111-222-3333" };
var emails = new string[] { "vendor1@example.com", "vendor2@example.com", "vendor3@example.com", "vendor4@example.com" };
var random = new Random();
var entityName = nameof(Vendor);
var vendors = new List<Vendor>
{
new Vendor { Name = "Quantum Industries" },
new Vendor { Name = "Apex Ventures" },
new Vendor { Name = "Horizon Enterprises" },
new Vendor { Name = "Nova Innovations" },
new Vendor { Name = "Phoenix Holdings" },
new Vendor { Name = "Titan Group" },
new Vendor { Name = "Zenith Corporation" },
new Vendor { Name = "Prime Solutions" },
new Vendor { Name = "Cascade Enterprises" },
new Vendor { Name = "Aurora Holdings" },
new Vendor { Name = "Vanguard Industries" },
new Vendor { Name = "Empyrean Ventures" },
new Vendor { Name = "Genesis Corporation" },
new Vendor { Name = "Equinox Enterprises" },
new Vendor { Name = "Summit Holdings" },
new Vendor { Name = "Sovereign Solutions" },
new Vendor { Name = "Spectrum Corporation" },
new Vendor { Name = "Elysium Enterprises" },
new Vendor { Name = "Infinity Holdings" },
new Vendor { Name = "Momentum Ventures" }
};
foreach (var vendor in vendors)
{
var autoNo = await context.GenerateAutoNumberAsync(
entityName: entityName,
prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/"
);
vendor.AutoNumber = autoNo;
vendor.VendorGroupId = GetRandomValue(groups, random);
vendor.VendorCategoryId = GetRandomValue(categories, random);
vendor.City = GetRandomString(cities, random);
vendor.Street = GetRandomString(streets, random);
vendor.State = GetRandomString(states, random);
vendor.ZipCode = GetRandomString(zipCodes, random);
vendor.PhoneNumber = GetRandomString(phoneNumbers, random);
vendor.EmailAddress = GetRandomString(emails, random);
await context.Vendor.AddAsync(vendor);
}
await context.SaveChangesAsync();
}
private static T GetRandomValue<T>(T[] array, Random random)
{
return array[random.Next(array.Length)];
}
private static string GetRandomString(string[] array, Random random)
{
return array[random.Next(array.Length)];
}
}
@@ -0,0 +1,27 @@
using Indotalent.Data.Entities;
using Microsoft.EntityFrameworkCore;
namespace Indotalent.Infrastructure.Database.Demo;
public static class WarehouseSeeder
{
public static async Task GenerateDataAsync(AppDbContext context)
{
if (await context.Warehouse.Where(x => x.SystemWarehouse == false).AnyAsync()) return;
var warehouses = new List<Warehouse>
{
new Warehouse { Name = "New York" },
new Warehouse { Name = "San Francisco" },
new Warehouse { Name = "Chicago" },
new Warehouse { Name = "Los Angeles" }
};
foreach (var warehouse in warehouses)
{
await context.Warehouse.AddAsync(warehouse);
}
await context.SaveChangesAsync();
}
}