/// <summary>
/// Update All TriTech Default Templates in the System
/// </summary>
public static void UpdateAllAgencies()
{
// Get the list of Agencies in the System.
List <Guid> agencyIds;
using (var admin = new AdministrationDbContext())
agencyIds = admin.GetEntityQuery <Domain.Administration.Aggregates.Agency.Agency>()
.Select(x => x.Id)
.ToList();
// We can use the same Metadata Context because we are only reading data.
using (var meta = new MetadataDbContext())
{
foreach (var agencyId in agencyIds)
{
// Distribute the work so we do not pay the performance price
// of tracking too many entities at the same time.
// This is important in systems that have a lot of Agencies.
using (var admin = new AdministrationDbContext())
{
// Load the Agency
var agency = admin.GetAgency(agencyId);
// Update the Templates
UpdateTriTechDefaultTemplatesInAgency(agency, admin, meta);
// Commit the Work
admin.Commit();
}
}
}
}
private void ExportTemplatesButton_Click(object sender, RoutedEventArgs e)
{
if (_browserDialog.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return;
}
foreach (TemplateDescription templateDescription in TemplatesListBox.SelectedItems)
{
try
{
using (var admin = new AdministrationDbContext())
using (var meta = new MetadataDbContext())
{
// Create a Template Layout Service
var templateLayoutService = new TemplateLayoutService(admin, meta);
// Get the Layout Information for the Template
var templateLayout = templateLayoutService.GetTemplateLayout(templateDescription.Template.Id, State);
// Serialize the Layout Information to an XML File.
using (var s = new StreamWriter(Path.Combine(_browserDialog.SelectedPath, templateDescription.Template.Name + " Template.xml")))
{
s.Write(Serializer <TemplateLayout> .Serialize(templateLayout));
}
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(ex.Message);
}
}
}
public static async Task <string> GetTypesValidation(MetadataDbContext dbContext)
{
if (!await dbContext.EntityTypes.AnyAsync())
{
//return "Entity list is empty.";
}
return(string.Empty);
}
public ManageMetadataController(
MetadataDbContext dbContext,
IImplementationsContainer implementations,
IPermissionService permissionService)
{
_dbContext = dbContext;
_implementations = implementations;
_permissionService = permissionService;
}
public DataLogBusiness(
LobToolsDbContext lobToolsDbContext,
IHttpContextAccessor httpContextAccessor,
MetadataDbContext metadataDbContext)
{
_lobToolsDbContext = lobToolsDbContext;
_httpContextAccessor = httpContextAccessor;
_metadataDbContext = metadataDbContext;
// Todo. Should use ImplementationContainer here.
}
public void TestMethod1()
{
var connstring = "Server=DESKTOP-DIU834E\\SQLEXPRESS;Database=TaccomStrike;Trusted_Connection=true;";
var sqlServerMetadataManager = new MetadataManager();
using (var dbContext = new MetadataDbContext(connstring))
{
var tables = sqlServerMetadataManager.RetrieveTableEntities(dbContext);
var dataspaces = sqlServerMetadataManager.RetrieveDataSpaceEntities(dbContext);
var indexArchitecture = sqlServerMetadataManager.RetrieveIndexArchitecture("MyTable2", "test", 1, dbContext);
}
}
public ReportController(
IImplementationsContainer implementationsContainer,
IUsersService usersService,
IRichTextDocumentHandler richTextDocumentHandler,
IEntityHandler entityHandler,
MetadataDbContext metadataDbContext)
{
_implementationsContainer = implementationsContainer;
_usersService = usersService;
_richTextDocumentHandler = richTextDocumentHandler;
_entityHandler = entityHandler;
_metadataDbContext = metadataDbContext;
}
public IActionResult GetDataSpaces(string connString)
{
if (string.IsNullOrEmpty(connString))
{
return(StatusCode(404));
}
using (var dbContext = new MetadataDbContext(connString))
{
var dataSpaces = metadataManager.RetrieveDataSpaceEntities(dbContext);
return(Json(dataSpaces));
}
}
/// <summary>
/// Update all the Metadata in the System
/// </summary>
public static void Update(string implementation)
{
using (var metadataUnitOfWork = new MetadataDbContext())
{
// Metadata Manager Service Instance
var metadataManager = new MetadataManagementService(metadataUnitOfWork);
// Update the Metadata in the System
metadataManager.UpdateMetadata(implementation);
// Save Changes
metadataUnitOfWork.Commit();
}
}
/// <summary>
/// Update The Implementation Default Templates for all Agencies in the System.
/// </summary>
/// <param name="implementation">The State Implementation of the System.</param>
public static void UpdateAllAgencies(string implementation)
{
using (var meta = new MetadataDbContext())
using (var admin = new AdministrationDbContext())
{
// Install or Update Templates in All Agencies
admin.GetEntityQuery <Domain.Administration.Aggregates.Agency.Agency>()
.ToList()
.ForEach(agency => InstallOrUpdateTemplatesInAgency(agency, implementation, admin, meta));
// Commit the Work
admin.Commit();
}
}
private void button1_Click(object sender, EventArgs e)
{
var metadataContext = new MetadataDbContext();
var adminContext = new AdministrationDbContext();
foreach (var agency in adminContext.GetSystemInstance().Agencies)
{
foreach (var contract in metadataContext.GetEntityQuery <DataEntryContract>())
{
TemplateFactory.Create(agency, contract);
}
}
adminContext.SaveChanges();
}
public ReleaseMetadataController(
IWebHostEnvironment hostingEnvironment,
MetadataDbContext dbContext,
IBusinessAssemblyGenerator assemblyGenerator,
IImplementationsContainer implementationContainer,
IOptions <GlobalConfiguration> globalConfiguration,
IPermissionService permissionService
)
{
_hostingEnvironment = hostingEnvironment;
_dbContext = dbContext;
_assemblyGenerator = assemblyGenerator;
_implementationContainer = implementationContainer;
_globalConfiguration = globalConfiguration.Value;
_permissionService = permissionService;
}
/// <summary>
/// Installs the TriTech Default Templates into a specific Agency.
/// </summary>
public static void Install(Guid agencyId)
{
using (var admin = new AdministrationDbContext())
using (var meta = new MetadataDbContext())
{
var agency = admin.GetAgency(agencyId);
if (agency == null)
{
throw new Exception("Unable to Find Agency [" + agencyId + "]");
}
UpdateTriTechDefaultTemplatesInAgency(agency, admin, meta);
// Commit the Work
admin.Commit();
}
}
/// <summary>
/// Install the "Implementation Default" Templates in a Specific Agency.
/// </summary>
/// <param name="agencyId">Id of the Agency to setup templates in.</param>
/// <param name="implementation">Implementation of the Templates to Install.</param>
public static void Install(Guid agencyId, string implementation)
{
using (var meta = new MetadataDbContext())
using (var admin = new AdministrationDbContext())
{
var agency = admin.GetAgency(agencyId);
if (agency == null)
{
throw new Exception("Agency [" + agencyId + "] not found.");
}
// Install or Update Templates
InstallOrUpdateTemplatesInAgency(agency, implementation, admin, meta);
// Commit the Work
admin.Commit();
}
}
public static IndexArchitecture RetrieveIndexArchitecture(
this MetadataManager metadataManager,
string tableName,
string schema,
int indexID,
MetadataDbContext dbContext)
{
var table = dbContext
.GetTableMetadata()
.GetTableMetadata(tableName, schema);
var index = dbContext
.GetIndexMetadata()
.GetIndexMetadataInTables(table)
.Where((item) => item.IndexID == indexID)
.AsIndexes()
.FirstOrDefault();
return(metadataManager.RetrieveIndexArchitecture(
tableName,
schema,
index,
dbContext));
}
public static async Task <string> GetPropertiesValidation(EntityTypeDetailsRequest model, MetadataDbContext dbContext)
{
if (!await dbContext.EntityTypes.AnyAsync(x => x.Id == model.EntityTypeId))
{
return("Entity not found");
}
return(string.Empty);
}
public AppManagementController(MetadataDbContext dbContext)
{
_dbContext = dbContext;
}
public static async Task <string> GetTypeFacetsValidation(MetadataDbContext dbContext)
{
return(await Task.FromResult(string.Empty));
}
public static async Task <string> EditPropertyValidation(AddNEditPropertyModel model, MetadataDbContext dbContext)
{
if (!await dbContext.Properties.AnyAsync(x => x.Id == model.Id))
{
return("Property not found");
}
return(string.Empty);
}
public static async Task <ImplementationContainer> Create(IServiceScope scope, MetadataDbContext dbContext, int appInstanceId)
{
var instance = await dbContext.AppInstances.FirstOrDefaultAsync(x => x.Id == appInstanceId);
if (instance == null)
{
return(null);
}
if (!instance.IsEnabled)
{
return(null);
}
var appType = await dbContext.AppTypes.FirstOrDefaultAsync(x => x.Id == instance.AppTypeId);
var bundle = await MetadataBundle.FromDbWithoutNavigations(dbContext, instance.AppTypeId, instance.Id);
bundle.FixupRelationships();
var metadataCache = new MetadataCache(bundle);
var metadataModel = new MetadataModel(bundle);
var globalConfig = scope.ServiceProvider.GetRequiredService <IOptions <GlobalConfiguration> >().Value;
var config = scope.ServiceProvider.GetRequiredService <IConfiguration>();
var dataConnectionStringTemplate = config.GetConnectionString(instance.DataConnectionStringTemplateName);
if (string.IsNullOrWhiteSpace(dataConnectionStringTemplate))
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <ImplementationContainer> >();
logger.LogError($"No connection stirng named \"{instance.DataConnectionStringTemplateName}\" which is required for app instance {instance.Name}");
}
var lobConnectionStringTemplate = config.GetConnectionString(instance.LobConnectionStringTemplateName);
if (string.IsNullOrWhiteSpace(lobConnectionStringTemplate))
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <ImplementationContainer> >();
logger.LogError($"No connection stirng named \"{instance.LobConnectionStringTemplateName}\" which is required for app instance {instance.Name}");
}
InstanceSettings instanceSettings = null;
globalConfig?.InstanceSettings?.TryGetValue(instance.Name, out instanceSettings);
var instanceInfo = new InstanceInfo
{
AppInstanceId = appInstanceId,
AppTypeId = appType.Id,
InstanceName = instance.Name,
Provider = instance.DatabaseProviderId,
DataConnectionString = GetConnectionString(dataConnectionStringTemplate, instance.MainDatabaseName),
LobConnectionString = GetConnectionString(lobConnectionStringTemplate, instance.LobDatabaseName),
MigrateDatabase = instance.MigrateDatabase,
GeneratedCodeNamespace = instance.GeneratedCodeNamespace,
DbContextName = instance.DbContextName,
InstanceSettings = instanceSettings,
LoadBusinessFromAssemblyName = instanceSettings?.LoadBusinessFromAssemblyName,
SortOrder = instance.SortOrder,
};
var bridge = new BusinessAssemblyBridge(
instanceInfo, globalConfig,
scope.ServiceProvider.GetRequiredService <ILogger <BusinessAssemblyBridge> >());
var reflector = new BusinessReflector(metadataCache);
var implementationsContainer = new ImplementationContainer
{
Metadata = metadataCache,
MetadataModel = metadataModel,
BusinessAssemblyBridge = bridge,
Reflector = reflector,
InstanceInfo = instanceInfo
};
switch (instanceInfo.Provider)
{
case DatabaseProviderEnum.MySql:
var mySqlDbContextOptionsBuilder = new DbContextOptionsBuilder <LobToolsDbContext_MySql>();
implementationsContainer._lobToolsDbContextOptions = mySqlDbContextOptionsBuilder
.UseMySql(instanceInfo.LobConnectionString, ServerVersion.AutoDetect(instanceInfo.LobConnectionString)).Options;
break;
case DatabaseProviderEnum.SqlServer:
var lobToolsDbContextOptionsBuilder = new DbContextOptionsBuilder <LobToolsDbContext>();
implementationsContainer._lobToolsDbContextOptions = lobToolsDbContextOptionsBuilder.UseSqlServer(instanceInfo.LobConnectionString).Options;
break;
case DatabaseProviderEnum.PostgreSql:
var postgreSqlDbContextOptionsBuilder = new DbContextOptionsBuilder <LobToolsDbContext_PostgreSql>();
implementationsContainer._lobToolsDbContextOptions = postgreSqlDbContextOptionsBuilder.UseNpgsql(instanceInfo.LobConnectionString).Options;
break;
default:
throw new NotImplementedException($"The provider {instanceInfo.Provider} is not implemented");
}
if (bridge.BusinessDbContextFactory == null)
{
scope.ServiceProvider.GetRequiredService <ILogger <ImplementationContainer> >().LogError($"Business assembly not loaded");
}
else
{
var dbContextType = bridge.BusinessDbContextFactory.GetType().Assembly.GetTypes().Single(x => x.IsPublic && x.IsSubclassOf(typeof(DbContext)));
reflector.RegisterAssembly(dbContextType.Assembly);
var dbContextOptionsBuilder = Activator.CreateInstance(typeof(DbContextOptionsBuilder <>).MakeGenericType(dbContextType)) as DbContextOptionsBuilder;
switch (instanceInfo.Provider)
{
case DatabaseProviderEnum.MySql:
implementationsContainer._dbContextOptions = dbContextOptionsBuilder
.UseMySql(instanceInfo.DataConnectionString, ServerVersion.AutoDetect(instanceInfo.DataConnectionString)).Options;
break;
case DatabaseProviderEnum.SqlServer:
implementationsContainer._dbContextOptions = dbContextOptionsBuilder.UseSqlServer(instanceInfo.DataConnectionString).Options;
break;
case DatabaseProviderEnum.PostgreSql:
implementationsContainer._dbContextOptions = dbContextOptionsBuilder.UseNpgsql(instanceInfo.DataConnectionString).Options;
break;
default:
throw new NotImplementedException($"The provider {instanceInfo.Provider} is not implemented");
}
}
return(implementationsContainer);
}
public OfferingRepository(MetadataDbContext context)
: base(context)
{
_context = context;
}
public static async Task <string> DeleteEntityValidation(EntityTypeModel model, MetadataDbContext dbContext)
{
if (await dbContext.Properties.AnyAsync(x => x.OwnerEntityTypeId == model.Id))
{
return("The selected entity has referenced to one or more properties.");
}
if (!await dbContext.EntityTypes.AnyAsync(x => x.Id == model.Id))
{
return("The selected entity is not exist");
}
var relativeProperty = await dbContext.Properties.Where(x => x.DataEntityTypeId == model.Id).Include(x => x.OwnerEntityType).ToListAsync();
if (relativeProperty.Any())
{
return("The selected entity is navigated to '" + relativeProperty.FirstOrDefault().Name +
@"' in entity '" + relativeProperty.FirstOrDefault().OwnerEntityType.Name + "'");
}
return(string.Empty);
}
public static async Task <string> GetPropertyFacetsValidation(EntityTypeDetailsRequest model, MetadataDbContext dbContext)
{
return(await Task.FromResult(string.Empty));
}
public static async Task <string> AddEntityTypeValidation(EntityTypeModel model, MetadataDbContext dbContext, IImplementationsContainer implementationsContainer)
{
if (await dbContext.EntityTypes.AnyAsync(x => x.Name == model.Name && x.AppTypeId == implementationsContainer.InstanceInfo.AppTypeId))
{
return($"Another entity with name: \"{ model.Name }\" is already defiend.");
}
return(await Task.FromResult(string.Empty));
}
public static async Task <string> GetAllPropertyNamesValidation(MetadataDbContext dbContext)
{
return(await Task.FromResult(string.Empty));
}
public static async Task <string> SavePropertyLocalFacetValueValidation(SaveLocalFacetRequest model, MetadataDbContext dbContext)
{
return(await Task.FromResult(string.Empty));
}
public PortfolioRepository(MetadataDbContext context)
: base(context)
{
_context = context;
}
public static async Task <string> GetPropertyForEditValidation(PropertyDetailsRequest model, MetadataDbContext dbContext)
{
if (!await dbContext.Properties.AnyAsync(x => x.Id == model.PropertyId))
{
return("Property not found");
}
return(string.Empty);
}
public static async Task <string> EditEntityTypeValidation(EntityTypeModel model, MetadataDbContext dbContext)
{
if (!await dbContext.EntityTypes.AnyAsync(x => x.Id == model.Id))
{
return("Entity not found");
}
return(string.Empty);
}
public static async Task <string> AddPropertyValidation(AddNEditPropertyModel model, MetadataDbContext dbContext)
{
if (model.PropertyGeneralUsageCategoryId == 2 &&
await dbContext.EntityTypes.AnyAsync(x => x.Properties.Where(y => y.OwnerEntityTypeId == model.OwnerEntityTypeId).Any(y => y.GeneralUsageCategoryId == 2)))
{
return("This entity already has a primary key");
}
if (!await dbContext.EntityTypes.AnyAsync(x => x.Id == model.OwnerEntityTypeId))
{
return("Entity not found");
}
return(string.Empty);
}
