public async Task ExecuteNotify()
{
using (var db = new BusinessDbContext())
{
var tenants = await db.Tenants.AsNoTracking()
.Where(x => x.IsActive && x.Active && !x.IsDeleted && x.SubscriptionEndTime >= DateTime.Today).ToListAsync();
foreach (var tenant in tenants)
{
var company = await db.Companies.AsNoTracking().FirstOrDefaultAsync(x => x.TenantId == tenant.Id);
if (company != null)
{
if (tenant.SubscriptionEndTime.HasValue)
{
var fiveDaysToExpire = tenant.SubscriptionEndTime.GetValueOrDefault().Date == DateTime.Today.AddDays(5);
var oneDayToExpire = tenant.SubscriptionEndTime.GetValueOrDefault().Date == DateTime.Today.AddDays(1);
if (fiveDaysToExpire || oneDayToExpire)
{
string href = $"{TenantHelper.GetTenantBaseUrl(tenant.TenancyName)}/{StaticResource.Private.MultiTenant.ManageSubscription.Path.PrefixAngularHashUri()}";
string subject = oneDayToExpire
? $"Renew your subscription within tomorrow"
: $"Your subscription will expire soon";
string body =
$"Your subscription will expire on {tenant.SubscriptionEndTime: dd/MM/yyyy}. To continue with {AppSettings.ApplicationName.ToLower().RemoveSpace()} you need to renew or upgrade your subscription. <br/> You can upgrade to a new package or you can renew your existing subscription from <a href='{href}'>Manage Subscription</a><br/>.";
await _emailSender.SendSecurityEmailAsync(company.Email, company.Name, subject, body);
if (oneDayToExpire && company.IsPhoneConfirmed)
{
_smsService.SendOneToOneSingleSmsUsingApi(company.Phone,
SmsHelper.SubscriptionExpireMessage);
}
}
}
}
}
}
}
public BaseUser Process(BusinessDbContext context, string validationToken, BaseUser exisitingUser, TempUser tempUser)
{
if (exisitingUser.Enabled)
{
throw new ProcessEventException("User has already been enabled");
}
if (!string.IsNullOrEmpty(exisitingUser.Email) && tempUser.TokenType == TokenType.EmailToken)
{
exisitingUser.ValidatedEmail = true;
exisitingUser.EnabledEmail = true;
}
if (!string.IsNullOrEmpty(exisitingUser.PhoneNumber) && tempUser.TokenType == TokenType.SmsToken)
{
exisitingUser.ValidatedSms = true;
exisitingUser.EnabledSms = true;
}
exisitingUser.Enabled = true;
context.SaveChanges();
return(exisitingUser);
}
public async Task <Tuple <List <ProductDetailViewModel>, int> > SearchByWarehouseAsync(ProductDetailRequestModel request)
{
BusinessDbContext db = base.Repository.Db as BusinessDbContext;
var tuple = await base.SearchAsync(request);
var whProducts = db.WarehouseProducts.Where(x => x.ShopId == request.ShopId && x.WarehouseId == request.WarehouseId);
var enumerable = from m in tuple.Item1
join wh in whProducts on m.Id equals wh.ProductDetailId into ps
from wh in ps.DefaultIfEmpty()
select new { ProductDetail = m, Quantity = wh?.OnHand ?? 0 };
foreach (var v in enumerable)
{
v.ProductDetail.OnHand = v.Quantity;
}
var list = enumerable.Select(x => x.ProductDetail).ToList();
var tuple1 = new Tuple <List <ProductDetailViewModel>, int>(list, tuple.Item2);
return(tuple1);
}
public static void RunSeed()
{
BusinessModelSeedDataManager.CheckMultiTenantData();
using (var context = BusinessDbContext.Create())
{
context.DisableAllFilters();
ResourceBuilder.Build(context);
RoleBuilder.Build(context, null);
PermissionBuilder.Build(context, null);
UserBuilder.Build(context, null);
UserRoleBuilder.Build(context, null);
TenantBuilder.BuildTenantRoles(context);
TenantBuilder.BuildTenantUserRoles(context);
TenantBuilder.BuildTenantPermissions(context);
context.EnableAllFilters();
}
}
public static void AddSupplier(BusinessDbContext db)
{
if (db.Suppliers.Any())
{
return;
}
var tenant = db.Tenants.FirstOrDefault(x => x.Name == StaticTenant.Host);
var company = db.Companies.FirstOrDefault(x => x.Name == StaticCompany.Host);
var suppliers = StaticSupplier.GetSuppliers();
var i = 0;
foreach (var supplier in suppliers)
{
i = i + 1;
db.Suppliers.Add(new Supplier
{
Id = Guid.NewGuid().ToString(),
Created = DateTime.Now,
Modified = DateTime.Now,
CreatedBy = null,
ModifiedBy = null,
Active = true,
Code = supplier,
Name = supplier,
Type = SupplierType.Company,
Phone = "",
OpeningDue = 0,
TotalDue = 0,
TenantId = tenant?.Id,
CompanyId = company?.Id
});
}
db.SaveChanges();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
ISiteRepository repository;
BusinessDbContext dbContext;
var optionsBuilder = new DbContextOptionsBuilder <BusinessDbContext>();
optionsBuilder.UseMySql("Server=localhost;database=book2site;uid=root;pwd=P@ssword;charset=utf8;port=3306;SslMode=None");
dbContext = new BusinessDbContext(optionsBuilder.Options);
repository = new SiteRepository(dbContext);
var entityRepository = new DomainRepository <Site>(dbContext);
var site = new Site(new TenantId("abc"), "def", "def", true);
entityRepository.Add(site);
entityRepository.SaveChanges();
var result = entityRepository.Find(site.Id);
}
public static void FillTenantSubscription()
{
using (var db = new BusinessDbContext())
{
var tenants = db.Tenants.ToList();
var subscriptions = db.Subscriptions.AsNoTracking().ToList();
foreach (var tenant in tenants)
{
var subscription = subscriptions.Where(x => x.TenantId == tenant.Id).OrderByDescending(x => x.ExpireOn).FirstOrDefault();
if (subscription != null)
{
tenant.SubscriptionId = subscription.Id;
db.Entry(tenant).State = EntityState.Modified;
}
}
db.SaveChanges();
}
}
public static void AddBranches()
{
using (var context = new BusinessDbContext())
{
if (context.Branches.Any())
{
return;
}
AddWarehouses(context);
var tenant = context.Tenants.FirstOrDefault(x => x.Name == StaticTenant.Host);
var company = context.Companies.FirstOrDefault(x => x.Name == StaticCompany.Host);
var warehouse = context.Warehouses.FirstOrDefault(x => x.Type == WarehouseType.HeadOffice);
var entity = new Branch()
{
Id = Guid.NewGuid().ToString(),
Active = true,
Created = DateTime.Now,
CreatedBy = null,
Code = "HO",
Name = "Head Office",
Address = "",
Type = BranchType.HeadOffice,
LinkedWarehouseId = warehouse?.Id,
CompanyId = company?.Id,
TenantId = tenant?.Id,
};
context.Branches.Add(entity);
context.SaveChanges();
}
}
public bool UpdateBalance(string shopId, string smsId, double amount, string text)
{
BusinessDbContext db = this.Repository.Db as BusinessDbContext;
SmsHistory entity = new SmsHistory()
{
ShopId = shopId,
Id = Guid.NewGuid().ToString(),
Created = DateTime.Now,
Modified = DateTime.Now,
IsActive = true,
CreatedBy = "System",
CreatedFrom = "BizBook",
ModifiedBy = "System",
Amount = amount,
Text = text,
SmsId = smsId
};
var history = db.SmsHistorys.Add(entity);
int i = db.SaveChanges();
return(i > 0);
}
public GenericUser Process(BusinessDbContext context,
TempUser tempUser)
{
var exisitingUser = context.Users.FirstOrDefault(x => x.Id == tempUser.Id);
// we already have an existing user,
// instead of throwing out an error we will do the right thing and just retoken them
Debug.Assert(exisitingUser != null, "Shouldn't ever be trying to update a null'ed user");
if (!string.IsNullOrEmpty(exisitingUser.Email) && tempUser.TokenType == TokenType.EmailToken)
{
// remove old account
var existingUsername = context.Users.FirstOrDefault(x => x.UserName == tempUser.Email && (x.Id != exisitingUser.Id));
if (existingUsername != null)
{
context.AllUsers.Remove(existingUsername);
}
exisitingUser.Email = tempUser.Email;
exisitingUser.ValidatedEmail = true;
}
if (!string.IsNullOrEmpty(exisitingUser.PhoneNumber) && tempUser.TokenType == TokenType.SmsToken)
{
// remove old account
var existingUsername = context.Users.FirstOrDefault(x => x.UserName == tempUser.PhoneNumber && (x.Id != exisitingUser.Id));
if (existingUsername != null)
{
context.AllUsers.Remove(existingUsername);
}
exisitingUser.PhoneNumber = tempUser.PhoneNumber;
exisitingUser.ValidatedSms = true;
}
context.SaveChanges();
Log.Information("Updating User {exisitingUser}", exisitingUser);
return(exisitingUser);
}
public async Task <GenericUser> Process(BusinessDbContext context, ValidationSender validationSender)
{
var user = GetUser(context);
if (user == null)
{
throw new ProcessEventException(Constants.Messages.UserNotFound);
}
if (!string.IsNullOrWhiteSpace(Name))
{
user.Name = Name;
}
if (!string.IsNullOrWhiteSpace(Email) && Email != user.Email)
{
await validationSender.SendValidationToEmail(new TempUser(user));
}
if (!string.IsNullOrWhiteSpace(PhoneNumber) && PhoneNumber != user.PhoneNumber)
{
await validationSender.SendValidationToSms(new TempUser(user));
}
if (string.IsNullOrWhiteSpace(NewPassowrd) || string.IsNullOrWhiteSpace(ExistingPassword))
{
var check = user.VerifyPassowrd(ExistingPassword);
if (check == PasswordVerificationResult.Success)
{
user.SetPassword(NewPassowrd);
}
}
context.SaveChanges();
return(user);
}
public bool QuickUpdate(DateTime date, string shopId)
{
BusinessDbContext db = BusinessDbContext.Create();
ReportDbContext reportDb = new ReportDbContext();
date = date.Date;
var salesToday = db.Sales.Where(x => x.ShopId == shopId && DbFunctions.TruncateTime(x.Created) == date)
.ToList();
var report = reportDb.SaleReports.Where(x => x.ShopId == shopId).FirstOrDefault(x => x.Date == date);
if (report == null)
{
bool b = ShopStart(date, shopId);
}
List <SaleReport> allReports = reportDb.SaleReports.Where(x => x.ShopId == shopId && DbFunctions.TruncateTime(x.Date) == date).ToList();
SaleReport reportSaleTypeAll = allReports.First(x => x.SaleType == SaleType.All);
CalculateAmounts(reportSaleTypeAll, salesToday);
reportSaleTypeAll.Modified = DateTime.Now;
reportDb.Entry(reportSaleTypeAll).State = EntityState.Modified;
SaleReport reportDealerSale = allReports.First(x => x.SaleType == SaleType.DealerSale);
List <Sale> dealerSalesToday = salesToday.Where(x => x.IsDealerSale).ToList();
CalculateAmounts(reportDealerSale, dealerSalesToday);
reportDealerSale.Modified = DateTime.Now;
reportDb.Entry(reportDealerSale).State = EntityState.Modified;
SaleReport reportCustomerSale = allReports.First(x => x.SaleType == SaleType.CustomerSale);
List <Sale> customerSalesToday = salesToday.Where(x => x.IsDealerSale == false).ToList();
CalculateAmounts(reportCustomerSale, customerSalesToday);
reportCustomerSale.Modified = DateTime.Now;
reportDb.Entry(reportCustomerSale).State = EntityState.Modified;
reportDb.SaveChanges();
return(true);
}
public StartupFixture()
{
//Use a PostgreSQL database
var sqlConnectionString = Configuration.GetConnectionString("Testing");
var options = new DbContextOptionsBuilder <BusinessDbContext>();
options.UseNpgsql(sqlConnectionString, b => b.MigrationsAssembly(Constants.ProjectName)
);
ContextOptions = options.Options;
if (!DidClear)
{
DidClear = true;
using (var dbContext = new BusinessDbContext(options.Options))
{
dbContext.Database.OpenConnection();
dbContext.Database.Migrate();
dbContext.AllUsers.Clear();
dbContext.SaveChanges();
}
}
if (_server == null)
{
var solutionRelativeTargetProjectParentDir = Path.Combine("src");
var contentRoot = Extensions.GetProjectPath(solutionRelativeTargetProjectParentDir);
var builder = new WebHostBuilder()
.UseContentRoot(contentRoot)
.UseEnvironment("Testing")
.UseStartup <TStartup>().ConfigureServices(InitializeServices);
_server = new TestServer(builder);
}
}
public ProductGroup GetDefaultProductGroup(BusinessDbContext db, string shopId, string username)
{
ProductGroup productGroup = db.ProductGroups.FirstOrDefault(x => x.Name == "General" && x.ShopId == shopId);
if (productGroup == null)
{
productGroup = new ProductGroup
{
Id = Guid.NewGuid().ToString(),
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow,
CreatedBy = username,
ModifiedBy = username,
ShopId = shopId,
CreatedFrom = "Server",
Name = "General",
};
db.ProductGroups.Add(productGroup);
db.SaveChanges();
}
return(productGroup);
}
public async Task <Tuple <List <HistoryViewModel>, int> > GetProductHistoryAsync(Rm rm)
{
BusinessDbContext db = this.Repository.Db as BusinessDbContext;
IQueryable <PurchaseDetail> purchaseDetails = db.PurchaseDetails.Include(x => x.Purchase).Include(x => x.ProductDetail).Where(x => x.ShopId == rm.ShopId);
purchaseDetails = purchaseDetails.Where(x => x.Purchase.SupplierId == rm.ParentId);
List <PurchaseDetail> models = await purchaseDetails.ToListAsync();
List <PurchaseDetailViewModel> viewModels = models.ConvertAll(x => new PurchaseDetailViewModel(x)).ToList();
List <HistoryViewModel> historyViewModels = viewModels.ConvertAll(x => new HistoryViewModel(x, x.ProductDetailName, x.CostPricePerUnit)).ToList();
var list = historyViewModels.GroupBy(x => x.ProductDetailId).ToList();
var histories = new List <HistoryViewModel>();
foreach (var v in list)
{
HistoryViewModel m = new HistoryViewModel();
string pid = v.Key;
var pList = v.ToList();
m.ProductName = pList.First().ProductName;
m.ProductDetailId = pid;
m.Quantity = pList.Sum(x => x.Quantity);
m.Total = pList.Sum(x => x.Total);
if (m.Quantity > 0)
{
m.UnitPrice = m.Total / m.Quantity;
}
m.Paid = pList.Sum(x => x.Paid);
m.Due = pList.Sum(x => x.Due);
histories.Add(m);
}
return(new Tuple <List <HistoryViewModel>, int>(histories, histories.Count));
}
public bool DayStartAll(string shopId, DateTime startDate)
{
startDate = startDate.Date;
DateTime yesterday = startDate.AddDays(-1).Date;
DayEndUpdateAll(shopId, yesterday);
ReportDbContext rDb = new ReportDbContext();
BusinessDbContext bDb = new BusinessDbContext();
List <string> ids = bDb.ProductDetails.Where(x => x.ShopId == shopId).Select(x => x.Id).ToList();
foreach (string pId in ids)
{
ProductReport report = GetReportObject(pId, bDb);
this.SetDefaults(report, shopId, startDate);
ProductReport yesterdayReport = rDb.ProductReports.Where(x => x.ShopId == shopId && x.ProductDetailId == pId).FirstOrDefault(x => DbFunctions.TruncateTime(x.Date) == yesterday);
if (yesterdayReport != null)
{
report.QuantityStartingToday = yesterdayReport.QuantityEndingToday;
}
var todayExists = rDb.ProductReports.Any(
x => x.ShopId == shopId && x.ProductDetailId == pId && DbFunctions.TruncateTime(x.Date) == startDate);
if (todayExists)
{
this.QuickUpdate(shopId, pId, startDate);
}
else
{
rDb.ProductReports.Add(report);
rDb.SaveChanges();
}
}
return(true);
}
public static void Build(BusinessDbContext db, string tenantId)
{
var manager = new Security.Server.Managers.UserManager(new AppUserStore(new SecurityDbContext()));
Company company;
Tenant tenant;
if (string.IsNullOrWhiteSpace(tenantId))
{
company = db.Companies.FirstOrDefault(x => x.Name == StaticCompany.Host);
tenant = db.Tenants.FirstOrDefault(x => x.Name == StaticTenant.Host);
tenantId = tenant?.Id;
}
else
{
company = db.Companies.FirstOrDefault(x => x.TenantId == tenantId);
tenant = db.Tenants.FirstOrDefault(x => x.Id == tenantId);
}
manager.SetTenantId(tenantId);
var adminRole = db.Roles.AsNoTracking().FirstOrDefault(x => x.TenantId == tenantId && x.Name == StaticRoles.Admin.Name);
var users = db.Users.Where(x => x.TenantId == tenantId && !x.Roles.Any()).ToList();
foreach (var user in users)
{
if (user.UserName.ToLower() == "systemadmin")
{
var systemAdminRole = db.Roles.AsNoTracking().FirstOrDefault(x => x.TenantId == tenantId && x.Name == StaticRoles.SystemAdmin.Name);
manager.AddRoleToUser(user.Id, systemAdminRole.Id, tenantId, company.Id);
}
else
{
manager.AddRoleToUser(user.Id, adminRole.Id, tenantId, company.Id);
}
}
}
private void SaveReport(ProductReport report)
{
var db = BusinessDbContext.Create();
//M dbReport = db.ProductReports.FirstOrDefault(
// x => x.ShopId == report.ShopId
// && x.ReportTimeType == report.ReportTimeType
// && x.Date == report.Date
// && x.ProductReportType == report.ProductReportType
// && x.ProductDetailId == report.ProductDetailId);
//if (dbReport == null)
//{
// db.ProductReports.Add(report);
//}
//else
//{
// dbReport.PurchaseTotal = report.PurchaseTotal;
// dbReport.PurchaseQuantity = report.PurchaseQuantity;
// dbReport.PurchasePricePerUnitAverage =
// report.PurchaseQuantity == 0 ? 0 : report.PurchaseTotal / report.PurchaseQuantity;
// dbReport.SaleTotal = report.SaleTotal;
// dbReport.SaleCostTotal = report.SaleCostTotal;
// dbReport.SalePriceTotal = report.SalePriceTotal;
// dbReport.SaleDiscountTotal = report.SaleDiscountTotal;
// dbReport.SaleQuantity = report.SaleQuantity;
// dbReport.SaleCostPricePerUnitAverage = report.SaleCostPricePerUnitAverage;
// dbReport.SalePricePerUnitAverage = report.SalePricePerUnitAverage;
// dbReport.StartingQuantity = report.StartingQuantity;
// dbReport.EndingQuantity = report.EndingQuantity;
//}
db.SaveChanges();
}
public static Employee AddEmployee(BusinessDbContext db, User user)
{
var count = db.Employees.Count(x => x.TenantId == user.TenantId);
var employee = new Employee()
{
Id = Guid.NewGuid().ToString(),
Created = DateTime.Now,
Modified = null,
CreatedBy = null,
Active = true,
Code = $"EMP-000{count + 1}",
Name = user.FirstName,
Surname = user.LastName,
Email = user.Email,
Phone = user.PhoneNumber,
Type = EmployeeType.FullTime,
DateOfBirth = null,
TenantId = user.TenantId,
CompanyId = user.CompanyId,
BranchId = user.BranchId
};
if (!db.Employees.Any(x => x.TenantId == employee.TenantId && x.Email == employee.Email))
{
db.Employees.Add(employee);
db.SaveChanges();
return(employee);
}
return(db.Employees.FirstOrDefault(x => x.TenantId == employee.TenantId && x.Email == employee.Email));
}
protected Repository(BusinessDbContext db) : base(db)
{
Context = db;
AppSession = new AppSession();
}
//public static AuthenticationProperties CreateProperties(string userName)
//{
// IDictionary<string, string> data = new Dictionary<string, string>
// {
// { "userName", userName }
// };
// return new AuthenticationProperties(data);
//}
public static AuthenticationProperties CreateProperties(ApplicationUser user, IList <string> roles, Shop shop, BusinessDbContext businessDb)
{
IDictionary <string, string> data = new Dictionary <string, string>();
data.Add("id", user.Id);
data.Add("name", user.FirstName + " " + user.LastName);
data.Add("userName", user.UserName);
// role
IdentityUserRole identityUserRole = user.Roles.FirstOrDefault();
if (identityUserRole != null)
{
data.Add("roleId", identityUserRole.RoleId);
}
string roleName = roles.First();
data.Add("role", roleName);
data.Add("connectionId", "");
if (string.IsNullOrWhiteSpace(user.ShopId))
{
user.ShopId = new Guid().ToString();
}
data.Add("shopId", user.ShopId);
EmployeeInfo employeeInfo = businessDb.EmployeeInfos.FirstOrDefault(x => x.Email == user.Email && x.ShopId == user.ShopId);
if (employeeInfo != null && !string.IsNullOrWhiteSpace(employeeInfo.WarehouseId))
{
data.Add("warehouseId", employeeInfo.WarehouseId);
}
SecurityDbContext db = SecurityDbContext.Create();
IQueryable <ApplicationPermission> permissions = db.Permissions.Where(x => x.RoleId == identityUserRole.RoleId && x.IsAllowed);
var resources =
permissions.Select(x => new { name = x.Resource.Name, isAllowed = x.IsAllowed, isDisabled = x.IsDisabled })
.ToList();
string allowedResources = JsonConvert.SerializeObject(resources);
data.Add("resources", allowedResources);
var role = db.ApplicationRoles.Find(data["roleId"]);
if (role != null)
{
if (string.IsNullOrWhiteSpace(role.DefaultRoute))
{
role.DefaultRoute = "root.home";
}
data.Add("defaultRoute", role.DefaultRoute);
}
if (shop != null)
{
if (!string.IsNullOrWhiteSpace(shop.ChalanName))
{
data.Add("ChalanName", shop.ChalanName);
}
if (!string.IsNullOrWhiteSpace(shop.ReceiptName))
{
data.Add("ReceiptName", shop.ReceiptName);
}
data.Add("ShowOrderNumberAfterSave", shop.IsShowOrderNumber.ToString());
data.Add("AddToCartIfResultIsOne", shop.IsAutoAddToCart.ToString());
data.Add("DeliveryChargeAmount", shop.DeliveryCharge.ToString(CultureInfo.InvariantCulture));
}
return(new AuthenticationProperties(data));
}
public OperationLogDetailQueryController() : base(new BaseService <M, Rm, Vm>(new BaseRepository <M>(BusinessDbContext.Create())))
{
}
public CourierQueryController() : base(new BaseService <Courier, CourierRequestModel, CourierViewModel>(new BaseRepository <Courier>(BusinessDbContext.Create())))
{
}
public AuditLogRepository(BusinessDbContext db) : base(db)
{
}
public CompanySettingsRepository(BusinessDbContext db) : base(db)
{
}
public SupplierQueryController() : base(new SupplierService(new BaseRepository <M>(BusinessDbContext.Create())))
{
}
public BaseController()
{
Db = new BusinessDbContext();
}
public DealerController() : base(new BaseService <Dealer, DealerRequestModel, DealerViewModel>(new BaseRepository <Dealer>(BusinessDbContext.Create())))
{
}
public InvestorController(BusinessDbContext context)
{
_context = context;
}
public PurchaseRepository(BusinessDbContext db) : base(db)
{
}
