public void ManualSeed(EntitiesDbContext context)
{
this.AutomaticMigrationsEnabled = true;
this.AutomaticMigrationDataLossAllowed = false;
Database.SetInitializer(new MigrateDatabaseToLatestVersion<Entities.EntitiesDbContext, Configuration>());
Seed(context);
}
public PurechasesOperationsRepo(EntitiesDbContext context, ISafeOperationsRepo safeOperationsRepo, ISalesinvoicesOperationsRepo salesinvoicesOperationsRepo)
{
this._context = context;
_purechasesHeaderEntity = context.Set <PurechasesHeader>();
_safeOperationsRepo = safeOperationsRepo;
_salesinvoicesOperationsRepo = salesinvoicesOperationsRepo;
}
private void DeleteSalesinvoicesDetials(long headerId, EntitiesDbContext context)
{
IEnumerable <SalesinvoicesDetials> purchaseDetails = context.SalesinvoicesDetials.Where(x => x.SalesinvoicesHeaderId == headerId).AsEnumerable();
context.SalesinvoicesDetials.RemoveRange(purchaseDetails);
context.SaveChanges();
}
private void DeletePurchaseDetails(long headerId, EntitiesDbContext context)
{
IEnumerable <PurechasesDetials> purchaseDetails = context.PurechasesDetials.Where(x => x.PurechasesHeaderId == headerId);
context.PurechasesDetials.RemoveRange(purchaseDetails);
context.SaveChanges();
}
/// <summary>
/// Populate fields of table
/// </summary>
/// <param name="dbContext"></param>
/// <param name="model"></param>
/// <returns></returns>
public static async Task <EntityViewModel> ResolveAsync(EntitiesDbContext dbContext, EntityViewModel model)
{
Arg.NotNull(dbContext, nameof(EntitiesDbContext));
Arg.NotNull(model, nameof(EntityViewModel));
var baseModelFields = BaseModelBuilder.CreateBaseModel(model.TableName).Adapt <List <TableModelField> >();
foreach (var item in baseModelFields)
{
item.IsSystem = true;
}
foreach (var item in baseModelFields)
{
model.Fields.Add(new EntityFieldsViewModel
{
ColumnName = item.Name,
Type = item.DataType,
IsSystem = item.IsSystem
});
}
model.Fields.AddRange(await dbContext.InjectNonBaseMetaDataAsync(model.TableName));
return(model);
}
public bool Delete(long id)
{
var options = GetOptions();
using (var context = new EntitiesDbContext(options))
{
using (var transaction = context.Database.BeginTransaction())
{
try
{
OrderHeader orderHeader = _orderHeaderOperationsRepo.GetById(id, context);
_purechasesOperationsRepo.DeleteRelatedPurechase(id, context); //Delete related purechase
_safeOperationsRepo.DeleteByOrderId(id, context); //Delete from Safe
_orderHeaderOperationsRepo.DeleteRelatedOrderDetials(id, context); //Delelte related order details
_salesinvoicesOperationsRepo.DeleteSalesinvoiceDetails(orderHeader, context);
_salesinvoicesOperationsRepo.DeleteSalesinvoiceHeader(orderHeader.Created, context); //Delete related Salesinvoice _orderHeaderOperationsRepo.Delete(id, context);
_orderHeaderOperationsRepo.Delete(id, context); //Delete OrderHeader
transaction.Commit();
return(true);
}
catch (Exception)
{
transaction.Rollback();
return(false);
}
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dbContext"></param>
/// <param name="httpContextAccessor"></param>
/// <param name="userManager"></param>
/// <param name="localizer"></param>
public FormTagHelper(EntitiesDbContext dbContext, IHttpContextAccessor httpContextAccessor, UserManager <GearUser> userManager, IStringLocalizer localizer)
{
_dbContext = dbContext;
_userManager = userManager;
_httpContextAccessor = httpContextAccessor;
_localizer = localizer;
}
public bool Delete(long id, EntitiesDbContext context)
{
OrderHeader OrderHeader = GetById(id, context);
context.OrderHeaders.Remove(OrderHeader);
context.SaveChanges();
return(true);
}
public ProfileController(ApplicationDbContext context,
ILogger <ProfileController> logger,
EntitiesDbContext contextEntities)
{
_contextEntities = contextEntities;
_context = context;
_logger = logger;
}
public bool Add(PurechasesHeader purechasesHeader, EntitiesDbContext context)
{
context.Entry(purechasesHeader).State = EntityState.Added;
context.SaveChanges();
SetPurechasesHeaderId(purechasesHeader.Id, purechasesHeader.PurechasesDetialsList);
AddPurechasesDetials(purechasesHeader.PurechasesDetialsList, context);
return(true);
}
public bool DeleteRelatedOrderDetials(long headerId, EntitiesDbContext context)
{
IEnumerable <OrderDetails> orderDetails = context.OrderDetails.Where(x => x.OrderHeaderId == headerId);
context.OrderDetails.RemoveRange(orderDetails);
context.SaveChanges();
return(true);
}
public bool Delete(long id, EntitiesDbContext context)
{
PurechasesHeader purechasesHeader = GetById(id);
DeletePurchaseDetails(id);
context.PurechasesHeaders.Remove(purechasesHeader);
context.SaveChanges();
return(true);
}
public EntityService(EntitiesDbContext context, IMemoryCache memoryCache, IUserManager <GearUser> userManager, ITablesService tablesService, IConfiguration configuration, ILogger <EntityService> logger)
{
_context = context;
_memoryCache = memoryCache;
_userManager = userManager;
_tablesService = tablesService;
_configuration = configuration;
_logger = logger;
}
public bool Delete(long id, EntitiesDbContext context)
{
SalesinvoicesHeader salesinvoicesHeader = GetById(id, context);
DeleteSalesinvoicesDetials(id, context);
context.SalesinvoicesHeaders.Remove(salesinvoicesHeader);
context.SaveChanges();
return(true);
}
public IEntitiesDbContext CreateContext()
{
// Create connection to Effort
base.CreateConnection();
// Use the Effort connection to instantiate EntitiesDbConext
var context = new EntitiesDbContext(_connection);
return(context);
}
public bool Update(PurechasesHeader purechasesHeader, EntitiesDbContext context)
{
context.Entry(purechasesHeader).State = EntityState.Modified;
context.SaveChanges();
DeletePurchaseDetails(purechasesHeader.Id, context);
SetPurechasesHeaderId(purechasesHeader.Id, purechasesHeader.PurechasesDetialsList);
AddPurechasesDetials(purechasesHeader.PurechasesDetialsList, context);
_safeOperationsRepo.UpdateByHeaderId(purechasesHeader.Id, purechasesHeader.Total, AccountTypesEnum.Clients, context);
return(true);
}
public void DeleteRelatedPurechase(long orderHeaderId, EntitiesDbContext context)
{
Order_Purechase order_Purechase = _context.Order_Purechases.FirstOrDefault(x => x.OrderHeaderId == orderHeaderId);
if (order_Purechase != null && order_Purechase.PurechasesHeaderId != 0)
{
PurechasesHeader purechasesHeader = _context.PurechasesHeaders.FirstOrDefault(x => x.Id == order_Purechase.PurechasesHeaderId);
Delete(purechasesHeader.Id, context);
}
}
public PageRender(EntitiesDbContext context, ICacheService cacheService, UserManager <GearUser> userManager, IHttpContextAccessor contextAccessor, IDynamicPagesContext pagesContext, IOrganizationService <Tenant> organizationService, IClientsService appProvider, IEntityRoleAccessService entityRoleAccessService)
{
_context = context;
_cacheService = cacheService;
_userManager = userManager;
_contextAccessor = contextAccessor;
_pagesContext = pagesContext;
_organizationService = organizationService;
_appProvider = appProvider;
_entityRoleAccessService = entityRoleAccessService;
}
public bool Update(SalesinvoicesHeader salesinvoicesHeader, EntitiesDbContext context)
{
context.SalesinvoicesHeaders.Update(salesinvoicesHeader);
context.SaveChanges();
//DeleteSalesinvoicesDetials(salesinvoicesHeader.Id, context);
//SetSalesinvoicesHeaderId(salesinvoicesHeader, salesinvoicesHeader.SalesinvoicesDetialsList);
//AddSalesinvoicesDetials(salesinvoicesHeader.SalesinvoicesDetialsList, context);
//UpdateSalesinvoiceTotal(salesinvoicesHeader.SalesinvoicesDetialsList, context);
return(true);
}
public bool DeleteByHeaderId(long header, AccountTypesEnum accountTypesEnum, EntitiesDbContext context)
{
Safe safe = context.Safes.SingleOrDefault(x => x.HeaderId == header && x.AccountTypeId == (int)accountTypesEnum);
if (safe != null)
{
context.Safes.Remove(safe);
context.SaveChanges();
return(true);
}
return(false);
}
public bool DeleteByOrderId(long orderId, EntitiesDbContext context)
{
List <Safe> safes = context.Safes.Where(x => x.OrderId == orderId).ToList();
if (safes != null)
{
context.Safes.RemoveRange(safes);
context.SaveChanges();
return(true);
}
return(false);
}
public CompanyManageController(UserManager <GearUser> userManager,
RoleManager <GearRole> roleManager,
ApplicationDbContext applicationDbContext, EntitiesDbContext context, INotify <GearRole> notify,
IDataFilter dataFilter, IOrganizationService <Tenant> organizationService, IStringLocalizer localizer, IEntityService service, IUserManager <GearUser> userManager1, SignInManager <GearUser> signInManager, IPermissionService permissionService) :
base(userManager, roleManager, applicationDbContext, context, notify, dataFilter, localizer)
{
_organizationService = organizationService;
_service = service;
_userManager = userManager1;
_signInManager = signInManager;
_permissionService = permissionService;
_listSettings = new MultiTenantListSettings();
}
public void DeleteSalesinvoiceHeader(DateTime orderHeaderCreatedDate, EntitiesDbContext context)
{
List <SalesinvoicesHeader> salesinvoicesHeaderList = context.SalesinvoicesHeaders.Where(x => x.Created.ToShortDateString() == orderHeaderCreatedDate.ToShortDateString()).ToList();
foreach (SalesinvoicesHeader salesinvoicesHeader in salesinvoicesHeaderList)
{
List <SalesinvoicesDetials> salesinvoices = context.SalesinvoicesDetials.Where(x => x.SalesinvoicesHeaderId == salesinvoicesHeader.Id).ToList();
if (salesinvoices.Count == 0)
{
_safeOperationsRepo.DeleteByHeaderId(salesinvoicesHeader.Id, AccountTypesEnum.Sellers, context);//Delete old record in safe related to this Seller
Delete(salesinvoicesHeader.Id, context);
}
}
}
protected override void Seed(HanaSolution.Services.EntitiesDbContext context)
{
using (var db = new EntitiesDbContext())
{
if (db.Staffs.Where(x => x.Account == "admin").Count() == 0)
{
db.Staffs.Add(new Data.Models.Staff {
Account = "admin", Password = "******", Address = "Main", Gender = 1, Mail = "Main", Name = "Quản trị viên", Phone = "Main", Status = true
});;
db.Commit();
}
db.Dispose();
}
}
public bool Add(OrderDTO entity)
{
var options = GetOptions();
using (var context = new EntitiesDbContext(options))
{
using (var transaction = context.Database.BeginTransaction())
{
try
{
//[1] Save Order (Header and Details)
_orderHeaderOperationsRepo.Add(entity.OrderHeader, context); //Save in OrderHeader Table (Master Table)
entity.OrderDetails = SetOrderHeaderId(entity.OrderHeader.Id, entity.OrderDetails); //set OrderHeaderId to OrderDetails table
_orderDetailsOperationsRepo.AddRange(entity.OrderDetails, context); //Save in OrderDetails table (details for master table)
//[2] Save Purecchase pill
PurechasesHeader purechasesHeader = PreparePurechasesEntity(entity); //Prepare PurchaseEntity(Header and details for Cleint)
_purechasesOperationsRepo.Add(purechasesHeader, context); //Add Purchase(Header and Details)
//[3] Save farmer safe in Safe Entity as hidden rows
Safe farmerSafe = PrepareFarmerSafeEntity(purechasesHeader, entity.OrderHeader.Id); //Prepare Safe for Client
_safeOperationsRepo.Add(farmerSafe, context); //Add Client Safe row
//[4]Save Order_Purechase
Order_Purechase order_Purechase = PrepareOrder_Purechase(entity.OrderHeader.Id, purechasesHeader.Id);
_order_PurechaseOperationsRepo.Add(order_Purechase, context);
//[5] Save Salesinvoice pill
var salesinvoicesHeaderList = PrepareSalesinvoicesEntity(entity);//Prepare Salesinvoice(Header and Details)
foreach (var salesinvoicesHeader in salesinvoicesHeaderList)
{
SalesinvoicesHeader updatedSalesinvoicesHeader = _salesinvoicesOperationsRepo.Add(salesinvoicesHeader, entity.OrderHeader.Id, context); //Save in Salesinvoice(Header and Details) and update Total
_safeOperationsRepo.DeleteByHeaderId(updatedSalesinvoicesHeader.Id, AccountTypesEnum.Sellers, context); //Delete old record in safe related to this Seller
var sellerSafe = PrepareSellerSafeEntity(updatedSalesinvoicesHeader, updatedSalesinvoicesHeader.Total, entity.OrderHeader.Id);
_safeOperationsRepo.Add(sellerSafe, context);
}
transaction.Commit();
return(true);
}
catch (Exception ex)
{
transaction.Rollback();
return(false);
}
}
}
}
/// <summary>
/// Create object from table configuration
/// </summary>
/// <param name="context"></param>
/// <param name="httpContextAccessor"></param>
/// <returns></returns>
public async Task <DynamicObject> ResolveAsync(EntitiesDbContext context,
IHttpContextAccessor httpContextAccessor)
{
Arg.NotNull(context, nameof(EntitiesDbContext));
Arg.NotNull(httpContextAccessor, nameof(IHttpContextAccessor));
var entity = _assemblyName.Name;
var key = $"entity_{entity}";
var table = await context.Table.FirstOrDefaultAsync(x => x.Name.Equals(entity));
if (table == null)
{
throw new DynamicTableOperationException($"Table {entity} not found in database!");
}
var schema = table.EntityType;
var stored = TypeManager.TryGet(entity, schema);
if (stored.IsSuccess)
{
return(new DynamicObject
{
Type = stored.Result,
Service = IoC.Resolve <IDynamicService>()
});
}
var model = new EntityViewModel
{
TableName = entity,
TableSchema = schema,
Fields = new List <EntityFieldsViewModel>()
};
var proprieties = BaseModel.GetPropsName().ToList();
model = await ViewModelBuilderFactory.ResolveAsync(context, model);
var dynamicClass = CreateClass();
CreateConstructor(dynamicClass);
//Create base props
foreach (var field in model.Fields)
{
if (proprieties.Contains(field.ColumnName))
{
continue;
}
var fieldType = DynamicTypeMapper.GetTypeFromString(field.Type);
CreateProperty(dynamicClass, field.ColumnName, fieldType);
}
//Create references
foreach (var field in model.Fields)
{
if (field.Configurations == null)
{
continue;
}
if (!field.Configurations.Any())
{
continue;
}
var entityRef = field.Configurations.FirstOrDefault(x => x.Name == "ForeingTable");
var entityRefSchema = field.Configurations.FirstOrDefault(x => x.Name == "ForeingSchemaTable");
if (entityRef == null || entityRefSchema == null)
{
continue;
}
if (entityRef.Value == _assemblyName.Name)
{
CreateProperty(dynamicClass, $"{field.ColumnName}Reference", dynamicClass);
}
else
{
var refType = await Task.Run(async() =>
await new ObjectService(entityRef.Value).ResolveAsync(context, httpContextAccessor));
CreateProperty(dynamicClass, $"{field.ColumnName}Reference", refType.Type);
}
}
var type = dynamicClass.CreateTypeInfo();
TypeManager.Register(schema, entity, type);
return(new DynamicObject
{
Type = type,
Service = IoC.Resolve <IDynamicService>()
});
}
private void UpdateSalesInvoicTotal(List <SalesinvoicesDetials> deletedSalesinvoicesDetials, EntitiesDbContext context)
{
foreach (var item in deletedSalesinvoicesDetials)
{
var salesinvoiceHeader = _salesinvoicesOperationsRepo.GetById(item.SalesinvoicesHeaderId, context);
salesinvoiceHeader.Total = salesinvoiceHeader.Total - ((item.Weight * item.Price) + (AppSettings.MashalRate + AppSettings.ByaaRate) * item.Quantity);
_salesinvoicesOperationsRepo.Update(salesinvoiceHeader, context);
}
}
public bool Update(OrderDTO entity)
{
var options = GetOptions();
using (var context = new EntitiesDbContext(options))
{
using (var transaction = context.Database.BeginTransaction())
{
try
{
//[1] Update Order (Master and Details)
_orderHeaderOperationsRepo.Update(entity.OrderHeader, context); //Update Order table(Master)
_orderHeaderOperationsRepo.DeleteRelatedOrderDetials(entity.OrderHeader.Id, context); //Delete order details related to this order header
SetOrderHeaderId(entity.OrderHeader.Id, entity.OrderDetails);
_orderDetailsOperationsRepo.AddRange(entity.OrderDetails, context); //Adding of new Order Details
//[2] Update Purechase (Master and Details)
PurechasesHeader purechasesHeader = PreparePurechasesEntity(entity);
var orderHeader = _order_PurechaseOperationsRepo.GetByOrderHeaderId(entity.OrderHeader.Id);
if (orderHeader != null && orderHeader.PurechasesHeaderId != 0)
{
purechasesHeader.Id = orderHeader.PurechasesHeaderId;
_purechasesOperationsRepo.Update(purechasesHeader, context);
}
else
{
_purechasesOperationsRepo.Add(purechasesHeader, context);
}
//[3] Update Client Safe
_safeOperationsRepo.DeleteByOrderId(entity.OrderHeader.Id, context);
var safe = PrepareFarmerSafeEntity(purechasesHeader, entity.OrderHeader.Id);
_safeOperationsRepo.Add(safe, context);
//[4]Update Order_Purechase
Order_Purechase order_Purechase = PrepareOrder_Purechase(entity.OrderHeader.Id, purechasesHeader.Id);
_order_PurechaseOperationsRepo.Update(order_Purechase);
//[5] Update Salesinvoice
List <SalesinvoicesDetials> deletedSalesinvoicesDetials = _salesinvoicesOperationsRepo.DeleteSalesinvoiceDetails(entity.OrderHeader, context); //Delete SalesinvoiceDetails
UpdateSalesInvoicTotal(deletedSalesinvoicesDetials, context);
_salesinvoicesOperationsRepo.DeleteSalesinvoiceHeader(entity.OrderHeader.Created, context); //Delete Old Salesinvoice related to this Order
var salesinvoicesHeaderList = PrepareSalesinvoicesEntity(entity); //Prepare Salesinvoice(Header and Details)
foreach (var salesinvoicesHeader in salesinvoicesHeaderList)
{
SalesinvoicesHeader updatedSalesinvoicesHeader = _salesinvoicesOperationsRepo.Add(salesinvoicesHeader, entity.OrderHeader.Id, context); //Save in Salesinvoice(Header and Details) and update Total
_safeOperationsRepo.DeleteByHeaderId(salesinvoicesHeader.Id, AccountTypesEnum.Sellers, context); //Delete old record in safe related to this Seller
var sellerSafe = PrepareSellerSafeEntity(updatedSalesinvoicesHeader, updatedSalesinvoicesHeader.Total, entity.OrderHeader.Id);
_safeOperationsRepo.Add(sellerSafe, context);
}
transaction.Commit();
return(true);
}
catch (Exception ex)
{
LogFile.WriteLog(ex.Message);
transaction.Rollback();
return(false);
}
}
}
}
public MenuRepository(EntitiesDbContext db) : base(db)
{
}
/// <summary>
/// Create Entity viewmodel Configuration structure by entity name
/// </summary>
/// <param name="dbContext"></param>
/// <param name="entityName"></param>
/// <returns></returns>
public static async Task <List <EntityFieldsViewModel> > InjectNonBaseMetaDataAsync(this EntitiesDbContext dbContext, string entityName)
{
var service = IoC.Resolve <IEntityService>();
var model = new List <EntityFieldsViewModel>();
if (entityName.IsNullOrEmpty())
{
return(model);
}
var entityRequest = await service.FindTableByNameAsync(entityName, d => d.Name == entityName.Trim() &&
d.EntityType.Equals(GearSettings.DEFAULT_ENTITY_SCHEMA) ||
d.Name == entityName.Trim() && d.IsPartOfDbContext);
if (!entityRequest.IsSuccess)
{
return(model);
}
var entity = entityRequest.Result;
foreach (var item in entity.TableFields)
{
var field = new EntityFieldsViewModel
{
IsSystem = false,
ColumnName = item.Name,
Type = item.DataType
};
var fieldTypeConfig =
dbContext.TableFieldConfigs.Where(x => x.TableFieldTypeId == item.TableFieldTypeId);
var configFields = dbContext.TableFieldConfigValues.Where(x => x.TableModelFieldId == item.Id);
var configurations = new List <EntityConfigViewModel>();
foreach (var configField in configFields)
{
var fieldType = fieldTypeConfig.FirstOrDefault(x => x.Id == configField.TableFieldConfigId);
if (fieldType != null)
{
configurations.Add(new EntityConfigViewModel
{
Name = fieldType.Name,
Type = fieldType.Type,
Description = fieldType.Description,
Value = configField.Value
});
}
}
field.Configurations = configurations;
model.Add(field);
}
return(model);
}
