public async Task <byte[]> GetFileAsync(StoredFile storedFile, DatabaseOptions databaseOptions)
{
var fileId = ConvertUtil.DeserializeObject <DatabaseIdentifierOptions>(storedFile.FileIdentifierOptions).FileId;
var bucket = GetMongoBucket(databaseOptions);
return(await bucket.DownloadAsBytesAsync(ObjectId.Parse(fileId)));
}
public async Task <byte[]> GetFileAsync(StoredFile storedFile, DatabaseOptions databaseOptions)
{
var fileId = ConvertUtil.DeserializeObject <DatabaseIdentifierOptions>(storedFile.FileIdentifierOptions).FileId;
byte[] bytes = null;
using (var sqlDbConnection = new SqlConnection(databaseOptions.ConnectionString))
{
sqlDbConnection.Open();
using (var sqlCommand = new SqlCommand("SELECT * FROM uploadFiles Where id=@id", sqlDbConnection))
{
sqlCommand.Parameters.Add("id", System.Data.SqlDbType.NVarChar, 450).Value = fileId;
using (var sqlReader = await sqlCommand.ExecuteReaderAsync())
{
if (sqlReader.HasRows)
{
while (sqlReader.Read())
{
bytes = (byte[])sqlReader["File"];
break;
}
}
}
}
}
return(bytes);
}
private T Convert <T>(IEnumerable <VersionValue> versionValues)
{
var defaultValue = Activator.CreateInstance <T>();
var targetType = typeof(T);
var allVailableProperies = targetType
.GetProperties()
.Where(a => a.CanWrite && a.GetSetMethod() != null && a.PropertyType.GetCustomAttribute <NotManifestAttribute>() == null)
.ToList();
var allVailableNames = allVailableProperies.Select(a => a.Name);
foreach (var versionValue in versionValues)
{
var prop = allVailableProperies.First(a => a.Name == versionValue.Key);
var foundValue = versionValue.Value;
if (!string.IsNullOrEmpty(foundValue))
{
if (prop.PropertyType == typeof(string) ||
prop.PropertyType == typeof(decimal) ||
prop.PropertyType.IsValueType ||
prop.PropertyType.IsEnum)
{
var typeConverter = TypeDescriptor.GetConverter(prop.PropertyType);
var typeConverterObj = typeConverter.ConvertFromString(foundValue);
prop.SetValue(defaultValue, typeConverterObj);
}
else
{
var convertingObj = ConvertUtil.DeserializeObject(foundValue, prop.PropertyType);
prop.SetValue(defaultValue, convertingObj);
}
}
}
return(defaultValue);
}
public async Task <byte[]> GetFileAsync(StoredFile storedFile, DatabaseOptions databaseOptions)
{
var fileId = ConvertUtil.DeserializeObject <DatabaseIdentifierOptions>(storedFile.FileIdentifierOptions).FileId;
byte[] bytes;
using (var postgreDbConnection = new NpgsqlConnection(databaseOptions.ConnectionString))
{
postgreDbConnection.Open();
var manager = new NpgsqlLargeObjectManager(postgreDbConnection);
// Reading and writing Large Objects requires the use of a transaction
using (var transaction = postgreDbConnection.BeginTransaction())
{
// Open the file for reading and writing
using (var stream = manager.OpenRead(fileId))
{
using (var memoryStream = new MemoryStream())
{
await stream.CopyToAsync(memoryStream);
bytes = memoryStream.GetBuffer();
memoryStream.Close();
}
}
}
}
return(bytes);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var serviceBuilder = modelBuilder.Entity <Service>();
serviceBuilder.HasKey(a => a.Id);
serviceBuilder.HasOne(a => a.ServiceHardwareInfo).WithOne().OnDelete(DeleteBehavior.Cascade);
serviceBuilder.HasMany(a => a.MonitorCounters).WithOne(b => b.Service).OnDelete(DeleteBehavior.Cascade);
if (_options.ConnectionType == ConnectionType.MySQL)
{
serviceBuilder.Property(a => a.HealthCheckNotifyEnable).HasColumnType("BIT");
serviceBuilder.Property(a => a.LoggerNotifyEnable).HasColumnType("BIT");
}
var logEventBuilder = modelBuilder.Entity <LogEvent>();
logEventBuilder.HasKey(a => a.Id);
var jsonStackTracesConverter = new ValueConverter <IEnumerable <string>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <IEnumerable <string> >(v));
logEventBuilder.Property(a => a.StackTrace).HasConversion(jsonStackTracesConverter);
var monitorCounterBuilder = modelBuilder.Entity <MonitorCounter>();
monitorCounterBuilder.HasKey(a => a.Id);
monitorCounterBuilder.HasOne(a => a.HardwareCounter).WithOne().OnDelete(DeleteBehavior.Cascade);
monitorCounterBuilder.HasOne(a => a.HttpCounter).WithOne().OnDelete(DeleteBehavior.Cascade);
var hardwareBuilder = modelBuilder.Entity <HardwareCounter>();
if (_options.ConnectionType == ConnectionType.MySQL)
{
hardwareBuilder.Property(a => a.IsCpuBottleneck).HasColumnType("BIT");
hardwareBuilder.Property(a => a.IsMemoryThreshold).HasColumnType("BIT");
}
var monitorHardwareBuilder = modelBuilder.Entity <MonitorHardwareReport>();
if (_options.ConnectionType == ConnectionType.MySQL)
{
monitorHardwareBuilder.Property(a => a.IsCpuBottleneck).HasColumnType("BIT");
monitorHardwareBuilder.Property(a => a.IsMemoryThreshold).HasColumnType("BIT");
}
var monitorHttpBuilder = modelBuilder.Entity <MonitorHttpReport>();
foreach (var entity in modelBuilder.Model.GetEntityTypes())
{
foreach (var property in entity.GetProperties())
{
property.SetColumnName(ToCamelCase(property.GetColumnName()));
}
}
}
public async Task <UploadBackupResponseModel> UploadBackupFile(IFormFile uploadFile, string uploader)
{
var isFileValid = await _fileSeviceProvider.ValidateFile(uploadFile);
if (isFileValid)
{
Directory.CreateDirectory(_backupOptions.CurrentValue.RestoreFolderPath);
var tempFilePath = await SaveFormFileAsync(uploadFile, _backupOptions.CurrentValue.RestoreFolderPath);
var unzipFileName = Path.GetFileNameWithoutExtension(tempFilePath);
var unzipFolderPath = Path.Combine(_backupOptions.CurrentValue.RestoreFolderPath, Path.GetFileNameWithoutExtension(tempFilePath));
if (Directory.Exists(unzipFolderPath))
{
// Delete old directory
Directory.Delete(unzipFolderPath, true);
}
Directory.CreateDirectory(unzipFolderPath);
ZipFile.ExtractToDirectory(tempFilePath, unzipFolderPath);
var jsonFilePath = Path.Combine(unzipFolderPath, unzipFileName + ".json");
var jsonFound = File.ReadAllText(jsonFilePath);
var backupFlatternModel = ConvertUtil.DeserializeObject <BackupFlatternFileModel>(jsonFound);
// Save zip file into file service
var storedFile = await _fileSeviceProvider.UploadFileAsync(tempFilePath, uploader, true);
// Restore backup
var backup = backupFlatternModel.Backup;
backup.Id = DataUtil.GenerateUniqueId();
backup.FileId = storedFile.FileId;
backup.DownloadableUrl = storedFile.DownloadableUrl;
await _backupRepository.AddAsync(backup);
return(new UploadBackupResponseModel
{
Id = backup.Id,
Name = backup.Name,
Description = backup.Description,
Creator = backup.Creator,
CreatedDate = backup.CreatedDate,
TotalObjects = backupFlatternModel.TotalObjects,
IsFileValid = true
});
}
else
{
return(new UploadBackupResponseModel {
IsFileValid = false
});
}
}
public override async Task <T> InvokeAsyncT <T>(MethodInfo targetMethod, object[] args)
{
var argInfos = InitArgumentInfos(targetMethod.GetParameters(), args);
var urlTemplate = _urlBuilder.GetUrlTemplate(targetMethod);
var requestMessage = HttpRequestUtil.BuildHttpRequestMessage(_httpConfig?.RequestHeaders, argInfos, urlTemplate);
_logger?.LogDebug("Request url:{0} {1}", requestMessage.Method, requestMessage.RequestUri.AbsoluteUri);
var response = await _httpClient.SendAsync(requestMessage);
var content = await response.Content.ReadAsStringAsync();
return(ConvertUtil.DeserializeObject <T>(content));
}
private ToolsOptions GetToolsOptions(string filePath)
{
string fullPath;
if (!string.IsNullOrEmpty(filePath))
{
fullPath = Path.GetFullPath(filePath);
}
else
{
fullPath = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "tools.json");
}
Console.WriteLine(">>> Config file path: {0}", fullPath);
var foundText = File.ReadAllText(fullPath);
return(ConvertUtil.DeserializeObject <ToolsOptions>(foundText));
}
public override object Invoke(MethodInfo targetMethod, object[] args)
{
//if the method is 'Config',then save the config data and return this instance for the next invoke
if (IsConfigMethod(targetMethod, args))
{
_httpConfig = args[0] as HttpConfig;
_httpClient.Timeout = _httpConfig.Timeout;
return(this);
}
var argInfos = InitArgumentInfos(targetMethod.GetParameters(), args);
var urlTemplate = _urlBuilder.GetUrlTemplate(targetMethod);
var requestMessage = HttpRequestUtil.BuildHttpRequestMessage(_httpConfig?.RequestHeaders, argInfos, urlTemplate);
_logger?.LogDebug("Request url:{0} {1}", requestMessage.Method, requestMessage.RequestUri.AbsoluteUri);
var response = _httpClient.SendAsync(requestMessage).ConfigureAwait(false).GetAwaiter().GetResult();
var content = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
return(ConvertUtil.DeserializeObject(targetMethod.ReturnType, content));
}
public async Task <ExecutedDataSourceModel> GetDatasourceService(Datasource datasource)
{
var datasourceModels = new List <DatasourceModel>();
if (datasource.DatasourceType == DatasourceType.Static)
{
datasourceModels = ConvertUtil.DeserializeObject <List <DatasourceModel> >(datasource.Query);
}
else
{
var database = await _databaseServiceProvider.GetOneDatabaseConnectionAsync(datasource.DatabaseId);
var foundExtractionDatasource = _extractionDatasources.First(a => a.ConnectionType == database.GetConnectionType());
datasourceModels = await foundExtractionDatasource.ExtractionDatasource(database, datasource.Query, datasource.OutputProjection);
}
return(new ExecutedDataSourceModel
{
DatasourceModels = datasourceModels,
CanCache = datasource.CanCache
});
}
public static ChatSessionModel LoadFrom(ChatSession chatSession)
{
if (chatSession == null)
{
return(null);
}
var newSession = new ChatSessionModel
{
ChatRoomId = chatSession.ChatRoomId,
Messages = new Queue <MessageModel>(),
PreviousSessionId = chatSession.PreviousSessionId,
CreatedDate = chatSession.CreatedDate,
LeaveDate = chatSession.LeaveDate,
NextSessionId = chatSession.NextSessionId,
SessionId = chatSession.Id
};
if (chatSession.Conversations != null)
{
foreach (var message in chatSession.Conversations.OrderBy(a => a.Timestamp))
{
newSession.Messages.Enqueue(new MessageModel
{
Message = message.Message,
FormattedMessage = message.MessageTransform,
TimeStamp = message.Timestamp,
UserName = message.Username,
CreatedDate = message.CreatedDate,
AttachmentFiles = !string.IsNullOrEmpty(message.FileUrl)
? ConvertUtil.DeserializeObject <List <AttachmentFile> >(message.FileUrl)
: new List <AttachmentFile>()
});
}
}
return(newSession);
}
public async Task <byte[]> GetFileAsync(StoredFile storedFile)
{
var localFile = ConvertUtil.DeserializeObject <LocalFileOptions>(storedFile.FileIdentifierOptions);
return(await File.ReadAllBytesAsync(localFile.FileLocation));
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Declare all model builder
var jsonMenusConverter = new ValueConverter <List <Menu>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <Menu> >(v));
var jsonMenuProfilesConverter = new ValueConverter <List <MenuProfile>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <MenuProfile> >(v));
// App
var appBuilder = modelBuilder.Entity <App>();
appBuilder.HasKey(a => a.Id);
appBuilder.Property(a => a.Menus).HasConversion(jsonMenusConverter);
appBuilder.Property(a => a.MenuProfiles).HasConversion(jsonMenuProfilesConverter);
// Portal Version
var portalVersionBuilder = modelBuilder.Entity <LetPortal.Core.Versions.Version>();
portalVersionBuilder.HasKey(a => a.Id);
// Component
var componentBuilder = modelBuilder.Entity <Component>();
componentBuilder.HasKey(a => a.Id);
if (_options.ConnectionType == ConnectionType.MySQL)
{
componentBuilder.Property(a => a.AllowOverrideOptions).HasColumnType("BIT");
componentBuilder.Property(a => a.AllowPassingDatasource).HasColumnType("BIT");
}
var jsonShellOptionsConverter = new ValueConverter <List <ShellOption>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <ShellOption> >(v));
componentBuilder.Property(a => a.Options).HasConversion(jsonShellOptionsConverter);
// Dynamic List
var dynamicListBuilder = modelBuilder.Entity <DynamicList>();
dynamicListBuilder.HasBaseType <Component>();
var jsonDynamicListDatasourceConverter = new ValueConverter <DynamicListDatasource, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <DynamicListDatasource>(v));
var jsonParamsListConverter = new ValueConverter <ParamsList, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <ParamsList>(v));
var jsonFiltersListConverter = new ValueConverter <FiltersList, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <FiltersList>(v));
var jsonColumnsListConverter = new ValueConverter <ColumnsList, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <ColumnsList>(v));
var jsonCommandsListConverter = new ValueConverter <CommandsList, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <CommandsList>(v));
dynamicListBuilder.Property(a => a.ListDatasource).HasConversion(jsonDynamicListDatasourceConverter);
dynamicListBuilder.Property(a => a.ParamsList).HasConversion(jsonParamsListConverter);
dynamicListBuilder.Property(a => a.FiltersList).HasConversion(jsonFiltersListConverter);
dynamicListBuilder.Property(a => a.ColumnsList).HasConversion(jsonColumnsListConverter);
dynamicListBuilder.Property(a => a.CommandsList).HasConversion(jsonCommandsListConverter);
// Standard
var standardBuilder = modelBuilder.Entity <StandardComponent>();
standardBuilder.HasBaseType <Component>();
var jsonControlsConverter = new ValueConverter <List <PageControl>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PageControl> >(v));
standardBuilder.Property(a => a.Controls).HasConversion(jsonControlsConverter);
if (_options.ConnectionType == ConnectionType.MySQL)
{
standardBuilder.Property(a => a.AllowArrayData).HasColumnType("BIT");
}
// Chart
var chartBuilder = modelBuilder.Entity <Chart>();
chartBuilder.HasBaseType <Component>();
var jsonChartDatabaseOptions = new ValueConverter <Entities.Shared.DatabaseOptions, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <Entities.Shared.DatabaseOptions>(v));
chartBuilder.Property(a => a.DatabaseOptions).HasConversion(jsonChartDatabaseOptions);
var jsonChartDefinitions = new ValueConverter <ChartDefinitions, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <ChartDefinitions>(v));
chartBuilder.Property(a => a.Definitions).HasConversion(jsonChartDefinitions);
var jsonChartFiltersConverter = new ValueConverter <List <ChartFilter>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <ChartFilter> >(v));
chartBuilder.Property(a => a.ChartFilters).HasConversion(jsonChartFiltersConverter);
// Page
var pageBuilder = modelBuilder.Entity <Page>();
pageBuilder.HasKey(a => a.Id);
var jsonPortalClaimConverter = new ValueConverter <List <PortalClaim>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PortalClaim> >(v));
var jsonPageBuilderConverter = new ValueConverter <PageBuilder, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <PageBuilder>(v));
var jsonPageDatasourceConverter = new ValueConverter <List <PageDatasource>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PageDatasource> >(v));
var jsonPageEventConverter = new ValueConverter <List <PageEvent>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PageEvent> >(v));
var jsonPageButtonConverter = new ValueConverter <List <PageButton>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PageButton> >(v));
pageBuilder.Property(a => a.ShellOptions).HasConversion(jsonShellOptionsConverter);
pageBuilder.Property(a => a.Claims).HasConversion(jsonPortalClaimConverter);
pageBuilder.Property(a => a.Builder).HasConversion(jsonPageBuilderConverter);
pageBuilder.Property(a => a.PageDatasources).HasConversion(jsonPageDatasourceConverter);
pageBuilder.Property(a => a.Events).HasConversion(jsonPageEventConverter);
pageBuilder.Property(a => a.Commands).HasConversion(jsonPageButtonConverter);
// Database Connection
var databaseConnectionBuilder = modelBuilder.Entity <DatabaseConnection>();
databaseConnectionBuilder.HasKey(a => a.Id);
var datasourceBuilder = modelBuilder.Entity <Datasource>();
datasourceBuilder.HasKey(a => a.Id);
if (_options.ConnectionType == ConnectionType.MySQL)
{
datasourceBuilder.Property(a => a.CanCache).HasColumnType("BIT");
}
// Entity Schema
var entitySchemaBuilder = modelBuilder.Entity <EntitySchema>();
entitySchemaBuilder.HasKey(a => a.Id);
var jsonEntityFieldConverter = new ValueConverter <List <EntityField>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <EntityField> >(v));
entitySchemaBuilder.Property(a => a.EntityFields).HasConversion(jsonEntityFieldConverter);
// File
var fileBuilder = modelBuilder.Entity <File>();
fileBuilder.HasKey(a => a.Id);
if (_options.ConnectionType == ConnectionType.MySQL)
{
fileBuilder.Property(a => a.AllowCompress).HasColumnType("BIT");
}
// Backup
var backupBuilder = modelBuilder.Entity <Backup>();
backupBuilder.HasKey(a => a.Id);
var jsonBackupElementsConverter = new ValueConverter <BackupElements, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <BackupElements>(v));
backupBuilder.Property(a => a.BackupElements).HasConversion(jsonBackupElementsConverter);
// Localization
var localizationBuilder = modelBuilder.Entity <Localization>();
localizationBuilder.HasKey(a => a.Id);
localizationBuilder.HasMany(a => a.LocalizationContents)
.WithOne(b => b.Localization)
.OnDelete(DeleteBehavior.Cascade);
var localizationContentBuilder = modelBuilder.Entity <LocalizationContent>();
localizationContentBuilder.HasKey(a => a.Id);
foreach (var entity in modelBuilder.Model.GetEntityTypes())
{
foreach (var property in entity.GetProperties())
{
property.SetColumnName(ToCamelCase(property.GetColumnName()));
}
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var serviceBuilder = modelBuilder.Entity <Service>();
serviceBuilder.HasKey(a => a.Id);
serviceBuilder.HasOne(a => a.ServiceHardwareInfo).WithOne().OnDelete(DeleteBehavior.Cascade);
serviceBuilder.HasMany(a => a.MonitorCounters).WithOne(b => b.Service).OnDelete(DeleteBehavior.Cascade);
if (_options.ConnectionType == ConnectionType.MySQL)
{
serviceBuilder.Property(a => a.HealthCheckNotifyEnable).HasColumnType("BIT");
serviceBuilder.Property(a => a.LoggerNotifyEnable).HasColumnType("BIT");
}
var logEventBuilder = modelBuilder.Entity <LogEvent>();
logEventBuilder.HasKey(a => a.Id);
var jsonStackTracesConverter = new ValueConverter <IEnumerable <string>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <IEnumerable <string> >(v));
logEventBuilder.Property(a => a.StackTrace).HasConversion(jsonStackTracesConverter);
var monitorCounterBuilder = modelBuilder.Entity <MonitorCounter>();
monitorCounterBuilder.HasKey(a => a.Id);
monitorCounterBuilder.HasOne(a => a.HardwareCounter).WithOne().OnDelete(DeleteBehavior.Cascade);
monitorCounterBuilder.HasOne(a => a.HttpCounter).WithOne().OnDelete(DeleteBehavior.Cascade);
var hardwareBuilder = modelBuilder.Entity <HardwareCounter>();
if (_options.ConnectionType == ConnectionType.MySQL)
{
hardwareBuilder.Property(a => a.IsCpuBottleneck).HasColumnType("BIT");
hardwareBuilder.Property(a => a.IsMemoryThreshold).HasColumnType("BIT");
}
var monitorHardwareBuilder = modelBuilder.Entity <MonitorHardwareReport>();
if (_options.ConnectionType == ConnectionType.MySQL)
{
monitorHardwareBuilder.Property(a => a.IsCpuBottleneck).HasColumnType("BIT");
monitorHardwareBuilder.Property(a => a.IsMemoryThreshold).HasColumnType("BIT");
}
var monitorHttpBuilder = modelBuilder.Entity <MonitorHttpReport>();
// Declare all model builder
var jsonMenusConverter = new ValueConverter <List <Menu>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <Menu> >(v));
var jsonMenuProfilesConverter = new ValueConverter <List <MenuProfile>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <MenuProfile> >(v));
// App
var appBuilder = modelBuilder.Entity <App>();
appBuilder.HasKey(a => a.Id);
appBuilder.Property(a => a.Menus).HasConversion(jsonMenusConverter);
appBuilder.Property(a => a.MenuProfiles).HasConversion(jsonMenuProfilesConverter);
// Portal Version
var portalVersionBuilder = modelBuilder.Entity <LetPortal.Core.Versions.Version>();
portalVersionBuilder.HasKey(a => a.Id);
// Component
var componentBuilder = modelBuilder.Entity <Component>();
componentBuilder.HasKey(a => a.Id);
if (_options.ConnectionType == ConnectionType.MySQL)
{
componentBuilder.Property(a => a.AllowOverrideOptions).HasColumnType("BIT");
componentBuilder.Property(a => a.AllowPassingDatasource).HasColumnType("BIT");
}
var jsonShellOptionsConverter = new ValueConverter <List <ShellOption>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <ShellOption> >(v));
componentBuilder.Property(a => a.Options).HasConversion(jsonShellOptionsConverter);
// Dynamic List
var dynamicListBuilder = modelBuilder.Entity <DynamicList>();
dynamicListBuilder.HasBaseType <Component>();
var jsonDynamicListDatasourceConverter = new ValueConverter <DynamicListDatasource, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <DynamicListDatasource>(v));
var jsonParamsListConverter = new ValueConverter <ParamsList, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <ParamsList>(v));
var jsonFiltersListConverter = new ValueConverter <FiltersList, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <FiltersList>(v));
var jsonColumnsListConverter = new ValueConverter <ColumnsList, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <ColumnsList>(v));
var jsonCommandsListConverter = new ValueConverter <CommandsList, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <CommandsList>(v));
dynamicListBuilder.Property(a => a.ListDatasource).HasConversion(jsonDynamicListDatasourceConverter);
dynamicListBuilder.Property(a => a.ParamsList).HasConversion(jsonParamsListConverter);
dynamicListBuilder.Property(a => a.FiltersList).HasConversion(jsonFiltersListConverter);
dynamicListBuilder.Property(a => a.ColumnsList).HasConversion(jsonColumnsListConverter);
dynamicListBuilder.Property(a => a.CommandsList).HasConversion(jsonCommandsListConverter);
// Standard
var standardBuilder = modelBuilder.Entity <StandardComponent>();
standardBuilder.HasBaseType <Component>();
var jsonControlsConverter = new ValueConverter <List <PageControl>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PageControl> >(v));
standardBuilder.Property(a => a.Controls).HasConversion(jsonControlsConverter);
// Chart
var chartBuilder = modelBuilder.Entity <Chart>();
chartBuilder.HasBaseType <Component>();
var jsonChartDatabaseOptions = new ValueConverter <SharedDatabaseOptions, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <SharedDatabaseOptions>(v));
chartBuilder.Property(a => a.DatabaseOptions).HasConversion(jsonChartDatabaseOptions);
var jsonChartDefinitions = new ValueConverter <ChartDefinitions, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <ChartDefinitions>(v));
chartBuilder.Property(a => a.Definitions).HasConversion(jsonChartDefinitions);
var jsonChartFiltersConverter = new ValueConverter <List <ChartFilter>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <ChartFilter> >(v));
chartBuilder.Property(a => a.ChartFilters).HasConversion(jsonChartFiltersConverter);
// Page
var pageBuilder = modelBuilder.Entity <Page>();
pageBuilder.HasKey(a => a.Id);
var jsonPortalClaimConverter = new ValueConverter <List <PortalClaim>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PortalClaim> >(v));
var jsonPageBuilderConverter = new ValueConverter <PageBuilder, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <PageBuilder>(v));
var jsonPageDatasourceConverter = new ValueConverter <List <PageDatasource>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PageDatasource> >(v));
var jsonPageEventConverter = new ValueConverter <List <PageEvent>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PageEvent> >(v));
var jsonPageButtonConverter = new ValueConverter <List <PageButton>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <PageButton> >(v));
pageBuilder.Property(a => a.ShellOptions).HasConversion(jsonShellOptionsConverter);
pageBuilder.Property(a => a.Claims).HasConversion(jsonPortalClaimConverter);
pageBuilder.Property(a => a.Builder).HasConversion(jsonPageBuilderConverter);
pageBuilder.Property(a => a.PageDatasources).HasConversion(jsonPageDatasourceConverter);
pageBuilder.Property(a => a.Events).HasConversion(jsonPageEventConverter);
pageBuilder.Property(a => a.Commands).HasConversion(jsonPageButtonConverter);
// Database Connection
var databaseConnectionBuilder = modelBuilder.Entity <DatabaseConnection>();
databaseConnectionBuilder.HasKey(a => a.Id);
var datasourceBuilder = modelBuilder.Entity <Datasource>();
datasourceBuilder.HasKey(a => a.Id);
if (_options.ConnectionType == ConnectionType.MySQL)
{
datasourceBuilder.Property(a => a.CanCache).HasColumnType("BIT");
}
// Entity Schema
var entitySchemaBuilder = modelBuilder.Entity <EntitySchema>();
entitySchemaBuilder.HasKey(a => a.Id);
var jsonEntityFieldConverter = new ValueConverter <List <EntityField>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <EntityField> >(v));
entitySchemaBuilder.Property(a => a.EntityFields).HasConversion(jsonEntityFieldConverter);
// File
var fileBuilder = modelBuilder.Entity <File>();
fileBuilder.HasKey(a => a.Id);
if (_options.ConnectionType == ConnectionType.MySQL)
{
fileBuilder.Property(a => a.AllowCompress).HasColumnType("BIT");
}
// Backup
var backupBuilder = modelBuilder.Entity <Backup>();
backupBuilder.HasKey(a => a.Id);
var jsonBackupElementsConverter = new ValueConverter <BackupElements, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <BackupElements>(v));
backupBuilder.Property(a => a.BackupElements).HasConversion(jsonBackupElementsConverter);
// Localization
var localizationBuilder = modelBuilder.Entity <Localization>();
localizationBuilder.HasKey(a => a.Id);
localizationBuilder.HasMany(a => a.LocalizationContents)
.WithOne(b => b.Localization)
.OnDelete(DeleteBehavior.Cascade);
var localizationContentBuilder = modelBuilder.Entity <LocalizationContent>();
localizationContentBuilder.HasKey(a => a.Id);
// Composite control
var compositeControlBuilder = modelBuilder.Entity <CompositeControl>();
compositeControlBuilder.HasKey(a => a.Id);
var userBuilder = modelBuilder.Entity <User>();
userBuilder.HasKey(a => a.Id);
if (_options.ConnectionType == ConnectionType.MySQL)
{
userBuilder.Property(a => a.IsConfirmedEmail).HasColumnType("BIT");
userBuilder.Property(a => a.IsLockoutEnabled).HasColumnType("BIT");
}
var jsonRolesConverter = new ValueConverter <List <string>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <string> >(v));
var jsonClaimsConverter = new ValueConverter <List <BaseClaim>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <BaseClaim> >(v));
userBuilder.Property(a => a.Roles).HasConversion(jsonRolesConverter);
userBuilder.Property(a => a.Claims).HasConversion(jsonClaimsConverter);
var roleBuilder = modelBuilder.Entity <Role>();
roleBuilder.HasKey(a => a.Id);
roleBuilder.Property(a => a.Claims).HasConversion(jsonClaimsConverter);
var issueTokenBuilder = modelBuilder.Entity <IssuedToken>();
issueTokenBuilder.HasKey(a => a.Id);
if (_options.ConnectionType == ConnectionType.MySQL)
{
issueTokenBuilder.Property(a => a.Deactive).HasColumnType("BIT");
}
var userSessionBuilder = modelBuilder.Entity <UserSession>();
userSessionBuilder.HasKey(a => a.Id);
userSessionBuilder.HasMany(a => a.UserActivities).WithOne().OnDelete(DeleteBehavior.Cascade);
if (_options.ConnectionType == ConnectionType.MySQL)
{
userSessionBuilder.Property(a => a.AlreadySignOut).HasColumnType("BIT");
}
var userActivityBuilder = modelBuilder.Entity <UserActivity>();
userActivityBuilder.HasKey(a => a.Id);
foreach (var entity in modelBuilder.Model.GetEntityTypes())
{
foreach (var property in entity.GetProperties())
{
property.SetColumnName(ToCamelCase(property.GetColumnName()));
}
}
}
public async Task <UnpackResponseModel> Unpack(IFormFile uploadFile, string uploader)
{
var unpackResponse = new UnpackResponseModel {
};
var isFileValid = await _fileSeviceProvider.ValidateFile(uploadFile);
if (isFileValid)
{
var storedFilePath = Path.Combine(Environment.CurrentDirectory, "Temp", "Unpackages");
Directory.CreateDirectory(storedFilePath);
var tempFilePath = await SaveFormFileAsync(uploadFile, storedFilePath);
var unzipFileName = Path.GetFileNameWithoutExtension(tempFilePath);
var unzipFolderPath = Path.Combine(storedFilePath, Path.GetFileNameWithoutExtension(tempFilePath));
if (Directory.Exists(unzipFolderPath))
{
// Delete old directory
Directory.Delete(unzipFolderPath, true);
}
Directory.CreateDirectory(unzipFolderPath);
ZipFile.ExtractToDirectory(tempFilePath, unzipFolderPath);
var jsonFilePath = Path.Combine(unzipFolderPath, unzipFileName + ".json");
var jsonFound = File.ReadAllText(jsonFilePath);
var appFlatternModel = ConvertUtil.DeserializeObject <AppPackageFlatternModel>(jsonFound);
var app = await _appRepository.GetOneAsync(appFlatternModel.App.Id);
unpackResponse.IsExistedId = app != null;
unpackResponse.IsExistedName = await _appRepository.IsExistAsync(a => a.Name == appFlatternModel.App.Name);
// Save zip file into file service
var storedFile = await _fileSeviceProvider.UploadFileAsync(tempFilePath, uploader, true);
unpackResponse.App = appFlatternModel.App;
unpackResponse.UploadFileId = storedFile.FileId;
unpackResponse.Description = appFlatternModel.Description;
unpackResponse.PackagedDate = appFlatternModel.PackagedDate;
unpackResponse.Creator = appFlatternModel.Creator;
unpackResponse.TotalStandards = appFlatternModel.TotalStandards.GetValueOrDefault();
unpackResponse.TotalDynamicLists = appFlatternModel.TotalDynamicLists.GetValueOrDefault();
unpackResponse.TotalCharts = appFlatternModel.TotalCharts.GetValueOrDefault();
unpackResponse.TotalPages = appFlatternModel.TotalPages.GetValueOrDefault();
unpackResponse.TotalLocales = appFlatternModel.TotalLocales.GetValueOrDefault();
foreach (var chainingFile in appFlatternModel.ChainingFiles)
{
switch (chainingFile)
{
case STANDARD_FILE:
var standardFilePath = Path.Combine(unzipFolderPath, STANDARD_FILE);
var standardsString = File.ReadAllText(standardFilePath);
var standardsList = ConvertUtil.DeserializeObject <IEnumerable <StandardComponent> >(standardsString);
var standardStates = new List <ComponentInstallState>();
foreach (var standard in standardsList)
{
standardStates.Add(new ComponentInstallState
{
Name = standard.DisplayName,
IsExisted = await _standardServiceProvider.CheckStandardExist(a => a.Name == standard.Name || a.Id == standard.Id)
});
}
unpackResponse.Standards = standardStates;
break;
case DYNAMICLIST_FILE:
var dynamicListFilePath = Path.Combine(unzipFolderPath, DYNAMICLIST_FILE);
var dynamicListString = File.ReadAllText(dynamicListFilePath);
var dynamicListsList = ConvertUtil.DeserializeObject <IEnumerable <DynamicList> >(dynamicListString);
var dynamicListStates = new List <ComponentInstallState>();
foreach (var dynamicList in dynamicListsList)
{
dynamicListStates.Add(new ComponentInstallState
{
Name = dynamicList.DisplayName,
IsExisted = await _dynamicListServiceProvider.CheckDynamicListExist(a => a.Name == dynamicList.Name || a.Id == dynamicList.Id)
});
}
unpackResponse.DynamicLists = dynamicListStates;
break;
case CHART_FILE:
var chartFilePath = Path.Combine(unzipFolderPath, CHART_FILE);
var chartsString = File.ReadAllText(chartFilePath);
var chartsList = ConvertUtil.DeserializeObject <IEnumerable <Chart> >(chartsString);
var chartsListStates = new List <ComponentInstallState>();
foreach (var chart in chartsList)
{
chartsListStates.Add(new ComponentInstallState
{
Name = chart.DisplayName,
IsExisted = await _chartServiceProvider.CheckChartExist(a => a.Name == chart.Name || a.Id == chart.Id)
});
}
unpackResponse.Charts = chartsListStates;
break;
case PAGE_FILE:
var pageFilePath = Path.Combine(unzipFolderPath, PAGE_FILE);
var pagesString = File.ReadAllText(pageFilePath);
var pagesList = ConvertUtil.DeserializeObject <IEnumerable <Page> >(pagesString);
var pagesListStates = new List <ComponentInstallState>();
foreach (var page in pagesList)
{
pagesListStates.Add(new ComponentInstallState
{
Name = page.DisplayName,
IsExisted = await _pageServiceProvider.CheckPageExist(a => a.Name == page.Name || a.Id == page.Id)
});
}
unpackResponse.Pages = pagesListStates;
break;
case LOCALE_FILE:
var localeFilePath = Path.Combine(unzipFolderPath, LOCALE_FILE);
var localesString = File.ReadAllText(localeFilePath);
var localesList = ConvertUtil.DeserializeObject <IEnumerable <Localization> >(localesString);
var localesListStates = new List <ComponentInstallState>();
foreach (var locale in localesList)
{
localesListStates.Add(new ComponentInstallState
{
Name = locale.LocaleId,
IsExisted = await _localizationProvider.CheckLocaleExist(a => a.LocaleId == locale.LocaleId && a.AppId == locale.AppId)
});
}
unpackResponse.Locales = localesListStates;
break;
}
}
}
return(unpackResponse);
}
public async Task RestoreBackupPoint(string backupId)
{
var backup = await _backupRepository.GetOneAsync(backupId);
var zipFile = await _fileSeviceProvider.DownloadFileAsync(backup.FileId);
var fileNameWithoutExt = FileUtil.GetFileNameWithoutExt(zipFile.FileName);
var restoreFilePath = Path.Combine(_backupOptions.CurrentValue.RestoreFolderPath, zipFile.FileName);
Directory.CreateDirectory(_backupOptions.CurrentValue.RestoreFolderPath);
using (var fileStream = File.Create(restoreFilePath))
{
fileStream.Write(zipFile.FileBytes, 0, zipFile.FileBytes.Length);
}
// Release file in memory
zipFile.FileBytes = null;
var folderExtractingPath = Path.Combine(_backupOptions.CurrentValue.RestoreFolderPath, fileNameWithoutExt);
if (Directory.Exists(folderExtractingPath))
{
Directory.Delete(folderExtractingPath, true);
}
ZipFile.ExtractToDirectory(restoreFilePath, folderExtractingPath);
var jsonBackupFilePath = Path.Combine(folderExtractingPath, fileNameWithoutExt + ".json");
var jsonBackupString = File.ReadAllText(jsonBackupFilePath);
var backupFlatternModel = ConvertUtil.DeserializeObject <BackupFlatternFileModel>(jsonBackupString);
foreach (var chainingFile in backupFlatternModel.ChainingFiles)
{
switch (chainingFile)
{
case APP_FILE:
var appFilePath = Path.Combine(folderExtractingPath, APP_FILE);
var appsListString = File.ReadAllText(appFilePath);
var appsList = ConvertUtil.DeserializeObject <IEnumerable <App> >(appsListString);
await _appServiceProvider.ForceUpdateApps(appsList);
break;
case STANDARD_FILE:
var standardFilePath = Path.Combine(folderExtractingPath, STANDARD_FILE);
var standardsString = File.ReadAllText(standardFilePath);
var standardsList = ConvertUtil.DeserializeObject <IEnumerable <StandardComponent> >(standardsString);
await _standardServiceProvider.ForceUpdateStandards(standardsList);
break;
case TREE_FILE:
var treeFilePath = Path.Combine(folderExtractingPath, TREE_FILE);
var treeString = File.ReadAllText(treeFilePath);
var treeList = ConvertUtil.DeserializeObject <IEnumerable <StandardComponent> >(treeString);
await _standardServiceProvider.ForceUpdateStandards(treeList);
break;
case ARRAY_FILE:
var arrayFilePath = Path.Combine(folderExtractingPath, ARRAY_FILE);
var arrayString = File.ReadAllText(arrayFilePath);
var arrayList = ConvertUtil.DeserializeObject <IEnumerable <StandardComponent> >(arrayString);
await _standardServiceProvider.ForceUpdateStandards(arrayList);
break;
case CHART_FILE:
var chartFilePath = Path.Combine(folderExtractingPath, CHART_FILE);
var chartsString = File.ReadAllText(chartFilePath);
var chartsList = ConvertUtil.DeserializeObject <IEnumerable <Chart> >(chartsString);
await _chartServiceProvider.ForceUpdateCharts(chartsList);
break;
case DATABASE_FILE:
var databaseFilePath = Path.Combine(folderExtractingPath, DATABASE_FILE);
var databasesString = File.ReadAllText(databaseFilePath);
var databasesList = ConvertUtil.DeserializeObject <IEnumerable <DatabaseConnection> >(databasesString);
await _databaseServiceProvider.ForceUpdateDatabases(databasesList);
break;
case PAGE_FILE:
var pageFilePath = Path.Combine(folderExtractingPath, PAGE_FILE);
var pagesString = File.ReadAllText(pageFilePath);
var pagesList = ConvertUtil.DeserializeObject <IEnumerable <Page> >(pagesString);
await _pageServiceProvider.ForceUpdatePages(pagesList);
break;
case DYNAMICLIST_FILE:
var dynamicListFilePath = Path.Combine(folderExtractingPath, DYNAMICLIST_FILE);
var dynamicListString = File.ReadAllText(dynamicListFilePath);
var dynamicListsList = ConvertUtil.DeserializeObject <IEnumerable <DynamicList> >(dynamicListString);
await _dynamicListServiceProvider.ForceUpdateDynamicLists(dynamicListsList);
break;
case COMPOSITE_CONTROL_FILE:
var compositeFilePath = Path.Combine(folderExtractingPath, COMPOSITE_CONTROL_FILE);
var compositeString = File.ReadAllText(compositeFilePath);
var compositeList = ConvertUtil.DeserializeObject <IEnumerable <CompositeControl> >(compositeString);
await _compositeControlServiceProvider.ForceUpdate(compositeList);
break;
default:
break;
}
}
Directory.Delete(folderExtractingPath, true);
File.Delete(restoreFilePath);
}
public async Task Install(string uploadFileId, InstallWay installWay = InstallWay.Merge)
{
var zipFile = await _fileSeviceProvider.DownloadFileAsync(uploadFileId);
var fileNameWithoutExt = FileUtil.GetFileNameWithoutExt(zipFile.FileName);
var restoreFolderPath = Path.Combine(Environment.CurrentDirectory, "Temp", "InstallationPackages");
Directory.CreateDirectory(restoreFolderPath);
var restoreFilePath = Path.Combine(restoreFolderPath, zipFile.FileName);
using (var fileStream = File.Create(restoreFilePath))
{
fileStream.Write(zipFile.FileBytes, 0, zipFile.FileBytes.Length);
}
// Release file in memory
zipFile.FileBytes = null;
var folderExtractingPath = Path.Combine(restoreFolderPath, fileNameWithoutExt);
if (Directory.Exists(folderExtractingPath))
{
Directory.Delete(folderExtractingPath, true);
}
ZipFile.ExtractToDirectory(restoreFilePath, folderExtractingPath);
var jsonAppPackageFilePath = Path.Combine(folderExtractingPath, fileNameWithoutExt + ".json");
var jsonAppPackageString = File.ReadAllText(jsonAppPackageFilePath);
var appFlatternModel = ConvertUtil.DeserializeObject <AppPackageFlatternModel>(jsonAppPackageString);
var isExist = await _appRepository.IsExistAsync(a => a.Id == appFlatternModel.App.Id);
switch (installWay)
{
case InstallWay.Merge:
break;
case InstallWay.Wipe:
if (isExist)
{
// Wipe all data
await _standardServiceProvider.DeleteAllByAppIdAsync(appFlatternModel.App.Id);
await _dynamicListServiceProvider.DeleteByAppIdAsync(appFlatternModel.App.Id);
await _chartServiceProvider.DeleteByAppIdAsync(appFlatternModel.App.Id);
await _pageServiceProvider.DeleteByAppIdAsync(appFlatternModel.App.Id);
await _localizationProvider.DeleteByAppIdAsync(appFlatternModel.App.Id);
}
break;
}
foreach (var chainingFile in appFlatternModel.ChainingFiles)
{
switch (chainingFile)
{
case STANDARD_FILE:
var standardFilePath = Path.Combine(folderExtractingPath, STANDARD_FILE);
var standardsString = File.ReadAllText(standardFilePath);
var standardsList = ConvertUtil.DeserializeObject <IEnumerable <StandardComponent> >(standardsString);
await _standardServiceProvider.ForceUpdateStandards(standardsList);
break;
case DYNAMICLIST_FILE:
var dynamicListFilePath = Path.Combine(folderExtractingPath, DYNAMICLIST_FILE);
var dynamicListString = File.ReadAllText(dynamicListFilePath);
var dynamicListsList = ConvertUtil.DeserializeObject <IEnumerable <DynamicList> >(dynamicListString);
await _dynamicListServiceProvider.ForceUpdateDynamicLists(dynamicListsList);
break;
case CHART_FILE:
var chartFilePath = Path.Combine(folderExtractingPath, CHART_FILE);
var chartsString = File.ReadAllText(chartFilePath);
var chartsList = ConvertUtil.DeserializeObject <IEnumerable <Chart> >(chartsString);
await _chartServiceProvider.ForceUpdateCharts(chartsList);
break;
case PAGE_FILE:
var pageFilePath = Path.Combine(folderExtractingPath, PAGE_FILE);
var pagesString = File.ReadAllText(pageFilePath);
var pagesList = ConvertUtil.DeserializeObject <IEnumerable <Page> >(pagesString);
await _pageServiceProvider.ForceUpdatePages(pagesList);
break;
case LOCALE_FILE:
var localeFilePath = Path.Combine(folderExtractingPath, LOCALE_FILE);
var localesString = File.ReadAllText(localeFilePath);
var localesList = ConvertUtil.DeserializeObject <IEnumerable <Localization> >(localesString);
await _localizationProvider.ForceUpdateLocalizations(localesList);
break;
}
}
await _appRepository.ForceUpdateAsync(appFlatternModel.App.Id, appFlatternModel.App);
Directory.Delete(folderExtractingPath, true);
File.Delete(restoreFilePath);
}
public async Task <IEnumerable <string> > Proceed(
string folderPath,
DatabaseOptions databaseOptions)
{
// Ensure this folder is exist
if (!Directory.Exists(folderPath))
{
return(Enumerable.Empty <string>());
}
var allZipFiles = Directory.GetFiles(folderPath, "*.zip");
var allRunningFiles = new List <string>();
if (allZipFiles != null && allZipFiles.Length > 0)
{
if (Directory.Exists("Temp"))
{
Directory.Delete("Temp", true);
}
Directory.CreateDirectory("Temp");
foreach (var file in allZipFiles)
{
var fileNameWithoutExt = Path.GetFileNameWithoutExtension(file);
var extractFolder = Path.Combine("Temp", fileNameWithoutExt);
ZipFile.ExtractToDirectory(file, extractFolder);
var backupFlatternModel = ConvertUtil.DeserializeObject <BackupFlatternFileModel>(File.ReadAllText(Path.Combine(extractFolder, fileNameWithoutExt + ".json")));
foreach (var chainingFile in backupFlatternModel.ChainingFiles)
{
switch (chainingFile)
{
case BackupService.APP_FILE:
var appFilePath = Path.Combine(extractFolder, BackupService.APP_FILE);
var appsListString = File.ReadAllText(appFilePath);
var appsList = ConvertUtil.DeserializeObject <IEnumerable <App> >(appsListString);
IAppRepository appRepository;
if (databaseOptions.ConnectionType == ConnectionType.MongoDB)
{
#pragma warning disable CA2000 // Dispose objects before losing scope
appRepository = new AppMongoRepository(new MongoConnection(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
else
{
#pragma warning disable CA2000 // Dispose objects before losing scope
appRepository = new AppEFRepository(new Portal.Repositories.PortalDbContext(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
var appServiceProvider = new InternalAppServiceProvider(appRepository);
await appServiceProvider.ForceUpdateApps(appsList);
appServiceProvider.Dispose();
break;
case BackupService.STANDARD_FILE:
var standardFilePath = Path.Combine(extractFolder, BackupService.STANDARD_FILE);
var standardsString = File.ReadAllText(standardFilePath);
var standardsList = ConvertUtil.DeserializeObject <IEnumerable <StandardComponent> >(standardsString);
IStandardRepository standardRepository;
if (databaseOptions.ConnectionType == ConnectionType.MongoDB)
{
#pragma warning disable CA2000 // Dispose objects before losing scope
standardRepository = new StandardMongoRepository(new MongoConnection(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
else
{
#pragma warning disable CA2000 // Dispose objects before losing scope
standardRepository = new StandardEFRepository(new Portal.Repositories.PortalDbContext(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
var standardServiceProvider = new InternalStandardServiceProvider(standardRepository);
await standardServiceProvider.ForceUpdateStandards(standardsList);
standardServiceProvider.Dispose();
break;
case BackupService.CHART_FILE:
var chartFilePath = Path.Combine(extractFolder, BackupService.CHART_FILE);
var chartsString = File.ReadAllText(chartFilePath);
var chartsList = ConvertUtil.DeserializeObject <IEnumerable <Chart> >(chartsString);
IChartRepository chartRepository;
if (databaseOptions.ConnectionType == ConnectionType.MongoDB)
{
#pragma warning disable CA2000 // Dispose objects before losing scope
chartRepository = new ChartMongoRepository(new MongoConnection(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
else
{
#pragma warning disable CA2000 // Dispose objects before losing scope
chartRepository = new ChartEFRepository(new Portal.Repositories.PortalDbContext(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
var chartServiceProvider = new InternalChartServiceProvider(chartRepository);
await chartServiceProvider.ForceUpdateCharts(chartsList);
chartServiceProvider.Dispose();
break;
case BackupService.DATABASE_FILE:
var databaseFilePath = Path.Combine(extractFolder, BackupService.DATABASE_FILE);
var databasesString = File.ReadAllText(databaseFilePath);
var databasesList = ConvertUtil.DeserializeObject <IEnumerable <DatabaseConnection> >(databasesString);
IDatabaseRepository databaseRepository;
if (databaseOptions.ConnectionType == ConnectionType.MongoDB)
{
#pragma warning disable CA2000 // Dispose objects before losing scope
databaseRepository = new DatabaseMongoRepository(new MongoConnection(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
else
{
#pragma warning disable CA2000 // Dispose objects before losing scope
databaseRepository = new DatabaseEFRepository(new PortalDbContext(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
var databaseServiceProvider = new InternalDatabaseServiceProvider(new DatabaseService(null, null), databaseRepository);
await databaseServiceProvider.ForceUpdateDatabases(databasesList);
databaseServiceProvider.Dispose();
break;
case BackupService.PAGE_FILE:
var pageFilePath = Path.Combine(extractFolder, BackupService.PAGE_FILE);
var pagesString = File.ReadAllText(pageFilePath);
var pagesList = ConvertUtil.DeserializeObject <IEnumerable <Page> >(pagesString);
IPageRepository pageRepository;
if (databaseOptions.ConnectionType == ConnectionType.MongoDB)
{
#pragma warning disable CA2000 // Dispose objects before losing scope
pageRepository = new PageMongoRepository(new MongoConnection(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
else
{
#pragma warning disable CA2000 // Dispose objects before losing scope
pageRepository = new PageEFRepository(new PortalDbContext(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
var pageServiceProvider = new InternalPageServiceProvider(pageRepository, null, null, null);
await pageServiceProvider.ForceUpdatePages(pagesList);
pageServiceProvider.Dispose();
break;
case BackupService.DYNAMICLIST_FILE:
var dynamicListFilePath = Path.Combine(extractFolder, BackupService.DYNAMICLIST_FILE);
var dynamicListString = File.ReadAllText(dynamicListFilePath);
var dynamicListsList = ConvertUtil.DeserializeObject <IEnumerable <DynamicList> >(dynamicListString);
IDynamicListRepository dynamicListRepository;
if (databaseOptions.ConnectionType == ConnectionType.MongoDB)
{
#pragma warning disable CA2000 // Dispose objects before losing scope
dynamicListRepository = new DynamicListMongoRepository(new MongoConnection(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
else
{
#pragma warning disable CA2000 // Dispose objects before losing scope
dynamicListRepository = new DynamicListEFRepository(new PortalDbContext(databaseOptions));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
var dynamicListServiceProvider = new InternalDynamicListServiceProvider(dynamicListRepository);
await dynamicListServiceProvider.ForceUpdateDynamicLists(dynamicListsList);
dynamicListServiceProvider.Dispose();
break;
default:
break;
}
}
allRunningFiles.Add(fileNameWithoutExt + ".zip");
}
}
return(allRunningFiles);
}
public async Task <PreviewRestoreModel> PreviewBackup(string backupId)
{
var previewModel = new PreviewRestoreModel();
var backup = await _backupRepository.GetOneAsync(backupId);
var zipFile = await _fileSeviceProvider.DownloadFileAsync(backup.FileId);
var fileNameWithoutExt = FileUtil.GetFileNameWithoutExt(zipFile.FileName);
var restoreFilePath = Path.Combine(_backupOptions.CurrentValue.RestoreFolderPath, zipFile.FileName);
using (var fileStream = File.Create(restoreFilePath))
{
fileStream.Write(zipFile.FileBytes, 0, zipFile.FileBytes.Length);
}
// Release file in memory
zipFile.FileBytes = null;
var folderExtractingPath = Path.Combine(_backupOptions.CurrentValue.RestoreFolderPath, fileNameWithoutExt);
if (Directory.Exists(folderExtractingPath))
{
Directory.Delete(folderExtractingPath, true);
}
ZipFile.ExtractToDirectory(restoreFilePath, folderExtractingPath);
var jsonBackupFilePath = Path.Combine(folderExtractingPath, fileNameWithoutExt + ".json");
var jsonBackupString = File.ReadAllText(jsonBackupFilePath);
var backupFlatternModel = ConvertUtil.DeserializeObject <BackupFlatternFileModel>(jsonBackupString);
foreach (var chainingFile in backupFlatternModel.ChainingFiles)
{
switch (chainingFile)
{
case APP_FILE:
var appFilePath = Path.Combine(folderExtractingPath, APP_FILE);
var appsListString = File.ReadAllText(appFilePath);
var appsList = ConvertUtil.DeserializeObject <IEnumerable <App> >(appsListString);
previewModel.Apps = await _appServiceProvider.CompareEntities(appsList);
break;
case STANDARD_FILE:
var standardFilePath = Path.Combine(folderExtractingPath, STANDARD_FILE);
var standardsString = File.ReadAllText(standardFilePath);
var standarsList = ConvertUtil.DeserializeObject <IEnumerable <StandardComponent> >(standardsString);
previewModel.Standards = await _standardServiceProvider.CompareStandardComponent(standarsList);
break;
case CHART_FILE:
var chartFilePath = Path.Combine(folderExtractingPath, CHART_FILE);
var chartsString = File.ReadAllText(chartFilePath);
var chartsList = ConvertUtil.DeserializeObject <IEnumerable <Chart> >(chartsString);
previewModel.Charts = await _chartServiceProvider.CompareCharts(chartsList);
break;
case DATABASE_FILE:
var databaseFilePath = Path.Combine(folderExtractingPath, DATABASE_FILE);
var databasesString = File.ReadAllText(databaseFilePath);
var databasesList = ConvertUtil.DeserializeObject <IEnumerable <DatabaseConnection> >(databasesString);
previewModel.Databases = await _databaseServiceProvider.CompareDatabases(databasesList);
break;
case PAGE_FILE:
var pageFilePath = Path.Combine(folderExtractingPath, PAGE_FILE);
var pagesString = File.ReadAllText(pageFilePath);
var pagesList = ConvertUtil.DeserializeObject <IEnumerable <Page> >(pagesString);
previewModel.Pages = await _pageServiceProvider.ComparePages(pagesList);
break;
case DYNAMICLIST_FILE:
var dynamicListFilePath = Path.Combine(folderExtractingPath, DYNAMICLIST_FILE);
var dynamicListString = File.ReadAllText(dynamicListFilePath);
var dynamicListsList = ConvertUtil.DeserializeObject <IEnumerable <DynamicList> >(dynamicListString);
previewModel.DynamicLists = await _dynamicListServiceProvider.CompareDynamicLists(dynamicListsList);
break;
default:
break;
}
}
Directory.Delete(folderExtractingPath, true);
File.Delete(restoreFilePath);
previewModel.TotalObjects =
(previewModel.Apps != null ? previewModel.Apps.Count() : 0) +
(previewModel.Charts != null ? previewModel.Charts.Count() : 0) +
(previewModel.Databases != null ? previewModel.Databases.Count() : 0) +
(previewModel.DynamicLists != null ? previewModel.DynamicLists.Count() : 0) +
(previewModel.Pages != null ? previewModel.Pages.Count() : 0) +
(previewModel.Standards != null ? previewModel.Standards.Count() : 0);
previewModel.TotalNewObjects =
(previewModel.Apps != null ? previewModel.Apps.Count(a => a.IsTotallyNew) : 0) +
(previewModel.Charts != null ? previewModel.Charts.Count(a => a.IsTotallyNew) : 0) +
(previewModel.Databases != null ? previewModel.Databases.Count(a => a.IsTotallyNew) : 0) +
(previewModel.DynamicLists != null ? previewModel.DynamicLists.Count(a => a.IsTotallyNew) : 0) +
(previewModel.Pages != null ? previewModel.Pages.Count(a => a.IsTotallyNew) : 0) +
(previewModel.Standards != null ? previewModel.Standards.Count(a => a.IsTotallyNew) : 0);
previewModel.TotalUnchangedObjects =
(previewModel.Apps != null ? previewModel.Apps.Count(a => a.IsUnchanged) : 0) +
(previewModel.Charts != null ? previewModel.Charts.Count(a => a.IsUnchanged) : 0) +
(previewModel.Databases != null ? previewModel.Databases.Count(a => a.IsUnchanged) : 0) +
(previewModel.DynamicLists != null ? previewModel.DynamicLists.Count(a => a.IsUnchanged) : 0) +
(previewModel.Pages != null ? previewModel.Pages.Count(a => a.IsUnchanged) : 0) +
(previewModel.Standards != null ? previewModel.Standards.Count(a => a.IsUnchanged) : 0);
previewModel.TotalChangedObjects =
previewModel.TotalObjects - previewModel.TotalNewObjects - previewModel.TotalUnchangedObjects;
return(previewModel);
}
public async Task <T> LoadAsync <T>(T target, string siteId)
{
var typeOfT = typeof(T);
if (target == null)
{
target = (T)Activator.CreateInstance(typeof(T));
}
if (target is IThemeManifest)
{
var properties = typeOfT.GetProperties();
var list = new List <Tuple <string, object, PropertyInfo> >();
foreach (var prop in properties)
{
// Ensure this prop has Setter method
if (prop.GetSetMethod() != null &&
prop.GetCustomAttribute <NotManifestAttribute>() == null)
{
var key = prop.Name;
var nameAttribute = prop.GetCustomAttribute <ManifestNameAttribute>();
if (nameAttribute != null)
{
key = nameAttribute.GetName();
}
list.Add(new Tuple <string, object, PropertyInfo>(key, null, prop));
}
}
if (list.Count > 0)
{
var siteManifests = await _siteManifestRepository.GetSiteManifestsAsync(list.Select(a => a.Item1), siteId);
foreach (var siteManifest in siteManifests)
{
var propReflector = list.First(a => a.Item1 == siteManifest.Key);
var foundValue = siteManifest.ConfigurableValue;
var prop = propReflector.Item3;
if (foundValue != null)
{
if (prop.PropertyType == typeof(string) ||
prop.PropertyType == typeof(decimal) ||
prop.PropertyType.IsValueType ||
prop.PropertyType.IsEnum)
{
var typeConverter = TypeDescriptor.GetConverter(prop.PropertyType);
var typeConverterObj = typeConverter.ConvertFromString(foundValue);
prop.SetValue(target, typeConverterObj);
}
else
{
var convertingObj = ConvertUtil.DeserializeObject(foundValue, prop.PropertyType);
prop.SetValue(target, convertingObj);
}
}
}
}
return(target);
}
throw new NotImplementedException();
}
private string GenerateFilterColumns(IEnumerable <ChartFilterValue> filterValues, ref List <ChartReportParameter> parameters)
{
var filterStr = string.Empty;
var counter = 0;
foreach (var filter in filterValues)
{
switch (filter.FilterType)
{
case Entities.Components.FilterType.Checkbox:
var tempCheckBoxParam = StringUtil.GenerateUniqueName();
filterStr += string.Format("{0}={1}", GetFieldFormat(filter.Name), GetFieldWithParamSign(tempCheckBoxParam));
// Only for MySQL, bool is 0 or 1
var passValue = 0;
if (filter.Value == "0" || filter.Value == "1")
{
passValue = filter.Value == "0" ? 0 : 1;
}
else
{
passValue = !bool.Parse(filter.Value) ? 0 : 1;
}
parameters.Add(new ChartReportParameter
{
Name = tempCheckBoxParam,
CastedValue = passValue == 1,
ValueType = "bool"
});
break;
case Entities.Components.FilterType.Select:
if (filter.IsMultiple)
{
var isArrayStr = filter.Value.Any(a => a == '\'' || a == '"');
if (isArrayStr)
{
var arrayStr = ConvertUtil.DeserializeObject <List <string> >(filter.Value);
foreach (var str in arrayStr)
{
if (arrayStr.IndexOf(str) == 0)
{
filterStr += "(";
}
var tempSelectParam = StringUtil.GenerateUniqueName();
filterStr += string.Format("{0}={1}", GetFieldFormat(filter.Name), GetFieldWithParamSign(tempSelectParam));
if (arrayStr.IndexOf(str) < arrayStr.Count - 1)
{
filterStr += " OR ";
}
else
{
filterStr += ")";
}
parameters.Add(new ChartReportParameter
{
Name = tempSelectParam,
CastedValue = str,
ValueType = "string"
});
}
}
else
{
var longStr = ConvertUtil.DeserializeObject <List <long> >(filter.Value);
foreach (var longElem in longStr)
{
if (longStr.IndexOf(longElem) == 0)
{
filterStr += "(";
}
var tempSelectParam = StringUtil.GenerateUniqueName();
filterStr += string.Format("{0}={1}", GetFieldFormat(filter.Name), GetFieldWithParamSign(tempSelectParam));
if (longStr.IndexOf(longElem) < longStr.Count - 1)
{
filterStr += " OR ";
}
else
{
filterStr += ")";
}
parameters.Add(new ChartReportParameter
{
Name = tempSelectParam,
CastedValue = longElem,
ValueType = "long"
});
}
}
}
else
{
var tempSelectParam = StringUtil.GenerateUniqueName();
filterStr += string.Format("{0}={1}", GetFieldFormat(filter.Name), GetFieldWithParamSign(tempSelectParam));
// Check value is int or string
long selectValue = 0;
var isLong = false;
if (long.TryParse(filter.Value, out selectValue))
{
isLong = true;
}
ChartReportParameter selectMySqlParameter;
if (isLong)
{
selectMySqlParameter = new ChartReportParameter
{
Name = tempSelectParam,
CastedValue = selectValue,
ValueType = "long"
};
}
else
{
selectMySqlParameter = new ChartReportParameter
{
Name = tempSelectParam,
CastedValue = filter.Value,
ValueType = "string"
};
}
parameters.Add(selectMySqlParameter);
}
break;
case Entities.Components.FilterType.NumberPicker:
var tempNumberRangeParam = StringUtil.GenerateUniqueName();
if (filter.IsMultiple)
{
var arrayStrings = ConvertUtil.DeserializeObject <string[]>(filter.Value);
var containsNumberMinMax = arrayStrings[0].Contains("-");
if (containsNumberMinMax)
{
// Ex: [10-20,20-30]
var compareStr = string.Empty;
var counterTemp = 0;
foreach (var numRange in arrayStrings)
{
var splitted = numRange.Split("-");
var tempStartNumParam = StringUtil.GenerateUniqueName();
var tempEndNumParam = StringUtil.GenerateUniqueName();
if (counterTemp < arrayStrings.Length - 1)
{
compareStr +=
string.Format(options.NumberRangeCompare + " OR ",
GetFieldFormat(filter.Name), GetFieldWithParamSign(tempStartNumParam), GetFieldWithParamSign(tempEndNumParam));
}
else
{
compareStr += string.Format(options.NumberRangeCompare,
GetFieldFormat(filter.Name), GetFieldWithParamSign(tempStartNumParam), GetFieldWithParamSign(tempEndNumParam));
}
counterTemp++;
parameters.Add(new ChartReportParameter
{
Name = tempStartNumParam,
CastedValue = long.Parse(splitted[0]),
ValueType = "long"
});
parameters.Add(new ChartReportParameter
{
Name = tempEndNumParam,
CastedValue = long.Parse(splitted[1]),
ValueType = "long"
});
}
filterStr += string.Format("({0})", compareStr);
}
else
{
var inNumberStr = string.Join(",", arrayStrings);
inNumberStr = string.Format(options.InOperator, GetFieldFormat(filter.Name), inNumberStr);
filterStr += inNumberStr;
}
}
else
{
var containsNumberMinMax = filter.Value.Contains("-");
if (containsNumberMinMax)
{
var splitted = filter.Value.Split("-");
var tempStartNumParam = StringUtil.GenerateUniqueName();
var tempEndNumParam = StringUtil.GenerateUniqueName();
filterStr += string.Format(
options.NumberRangeCompare,
GetFieldFormat(filter.Name),
GetFieldWithParamSign(tempStartNumParam),
GetFieldWithParamSign(tempEndNumParam));
parameters.Add(new ChartReportParameter
{
Name = tempStartNumParam,
CastedValue = long.Parse(splitted[0]),
ValueType = "long"
});
parameters.Add(new ChartReportParameter
{
Name = tempEndNumParam,
CastedValue = long.Parse(splitted[1]),
ValueType = "long"
});
}
else
{
filterStr += string.Format("{0}={1}",
GetFieldFormat(filter.Name),
GetFieldWithParamSign(tempNumberRangeParam));
parameters.Add(new ChartReportParameter
{
Name = tempNumberRangeParam,
CastedValue = long.Parse(filter.Value),
ValueType = "long"
});
}
}
break;
case Entities.Components.FilterType.DatePicker:
if (filter.IsMultiple)
{
// Ex: ['10/10/2019', '11/10/2019']
var tempStartDateParam = StringUtil.GenerateUniqueName();
var tempEndDateParam = StringUtil.GenerateUniqueName();
filterStr +=
string.Format("({0} AND {1})",
string.Format(
options.DateCompare,
GetFieldFormat(filter.Name),
">=",
GetFieldWithParamSign(tempStartDateParam)),
string.Format(
options.DateCompare,
GetFieldFormat(filter.Name),
"<=",
GetFieldWithParamSign(tempEndDateParam)));
var arrayDates = ConvertUtil.DeserializeObject <string[]>(filter.Value);
var startDatePickerDt = DateTime.Parse(arrayDates[0]);
var endDatePickerDt = DateTime.Parse(arrayDates[1]);
parameters.Add(new ChartReportParameter
{
Name = tempStartDateParam,
CastedValue = startDatePickerDt,
ValueType = "date"
});
parameters.Add(new ChartReportParameter
{
Name = tempEndDateParam,
CastedValue = endDatePickerDt,
ValueType = "date"
});
}
else
{
var tempDatePickerParam = StringUtil.GenerateUniqueName();
filterStr += string.Format(
options.DateCompare,
GetFieldFormat(filter.Name),
"=",
GetFieldWithParamSign(tempDatePickerParam));
// Support Date Format: MM/DD/YYYY
var datePickerDt = DateTime.Parse(filter.Value);
parameters.Add(new ChartReportParameter
{
Name = tempDatePickerParam,
CastedValue = datePickerDt,
ValueType = "date"
});
}
break;
case Entities.Components.FilterType.MonthYearPicker:
if (filter.IsMultiple)
{
var tempStartDateParam = StringUtil.GenerateUniqueName();
var tempEndDateParam = StringUtil.GenerateUniqueName();
filterStr +=
string.Format("({0} AND {1})",
string.Format(
options.DateCompare,
GetFieldFormat(filter.Name),
">=",
GetFieldWithParamSign(tempStartDateParam)),
string.Format(
options.DateCompare,
GetFieldFormat(filter.Name),
"<=",
GetFieldWithParamSign(tempEndDateParam)));
var arrayDates = ConvertUtil.DeserializeObject <string[]>(filter.Value);
var startDatePickerDt = DateTime.Parse(arrayDates[0]);
var endDatePickerDt = DateTime.Parse(arrayDates[1]);
parameters.Add(new ChartReportParameter
{
Name = tempStartDateParam,
CastedValue = startDatePickerDt,
ValueType = "date"
});
parameters.Add(new ChartReportParameter
{
Name = tempEndDateParam,
CastedValue = endDatePickerDt,
ValueType = "date"
});
}
else
{
var tempMonthPickerParam = StringUtil.GenerateUniqueName();
var tempYearPickerParam = StringUtil.GenerateUniqueName();
filterStr +=
string.Format("({0} AND {1})",
string.Format(
options.MonthCompare,
GetFieldFormat(filter.Name),
"=",
GetFieldWithParamSign(tempMonthPickerParam)),
string.Format(
options.YearCompare,
GetFieldFormat(filter.Name),
"=",
GetFieldWithParamSign(tempYearPickerParam)));
// Support Date Format: MM/DD/YYYY
var dateMonthPickerDt = DateTime.Parse(filter.Value);
parameters.Add(new ChartReportParameter
{
Name = tempMonthPickerParam,
CastedValue = dateMonthPickerDt,
ValueType = "date"
});
parameters.Add(new ChartReportParameter
{
Name = tempYearPickerParam,
CastedValue = dateMonthPickerDt,
ValueType = "date"
});
}
break;
}
counter++;
if (counter < filterValues.Count())
{
filterStr += " AND ";
}
}
return(filterStr);
}
private BsonDocument GetFilter(ChartFilterValue chartFilterValue)
{
switch (chartFilterValue.FilterType)
{
case Entities.Components.FilterType.Checkbox:
var checkboxDoc = new BsonDocument();
checkboxDoc.Add(new BsonElement(chartFilterValue.Name, new BsonBoolean(bool.Parse(chartFilterValue.Value))));
return(new BsonDocument
{
{ "$match", checkboxDoc }
});
case Entities.Components.FilterType.Select:
var selectDoc = new BsonDocument();
if (decimal.TryParse(chartFilterValue.Value, out var tempDecimal))
{
selectDoc.Add(new BsonElement(chartFilterValue.Name, new BsonDecimal128(tempDecimal)));
}
else if (long.TryParse(chartFilterValue.Value, out var tempLong))
{
selectDoc.Add(new BsonElement(chartFilterValue.Name, new BsonInt64(tempLong)));
}
else if (int.TryParse(chartFilterValue.Value, out var tempInt))
{
selectDoc.Add(new BsonElement(chartFilterValue.Name, new BsonInt32(tempInt)));
}
else
{
selectDoc.Add(new BsonElement(chartFilterValue.Name, new BsonString(chartFilterValue.Value)));
selectDoc.Add(new BsonElement(chartFilterValue.Name, new BsonInt32(tempInt)));
}
return(new BsonDocument
{
{ "$match", selectDoc }
});
case Entities.Components.FilterType.NumberPicker:
if (chartFilterValue.IsMultiple)
{
var orDoc = new BsonArray();
var selectMultiDoc = new BsonDocument();
var isArrayStr = chartFilterValue.Value.Any(a => a == '\'' || a == '"');
if (isArrayStr)
{
var arrayStr = ConvertUtil.DeserializeObject <List <string> >(chartFilterValue.Value);
var containsNumberMinMax = chartFilterValue.Value.Contains("-");
foreach (var elem in arrayStr)
{
var splitted = elem.Split("-");
var beginNum = long.Parse(splitted[0]);
var endNum = long.Parse(splitted[1]);
var andDoc = new BsonDocument
{
{ "$and", new BsonArray(new List <BsonDocument>
{
new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument
{
{ "$gte", new BsonInt64(beginNum) }
} }
},
new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument
{
{ "$lte", new BsonInt64(endNum) }
} }
}
}) }
};
orDoc.Add(andDoc);
}
selectMultiDoc = new BsonDocument
{
{ "$or", orDoc }
};
}
else
{
var arrayStr = ConvertUtil.DeserializeObject <List <long> >(chartFilterValue.Value);
foreach (var elem in arrayStr)
{
orDoc.Add(new BsonDocument
{
new BsonElement(chartFilterValue.Name, new BsonInt64(elem))
});
}
;
selectMultiDoc = new BsonDocument
{
{ "$or", orDoc }
};
}
return(new BsonDocument
{
{ "$match", selectMultiDoc }
});
}
else
{
var containsNumberMinMax = chartFilterValue.Value.Contains("-");
if (containsNumberMinMax)
{
// Ex: 10-30, 30-50
var splitted = chartFilterValue.Value.Split("-");
var beginNum = long.Parse(splitted[0]);
var endNum = long.Parse(splitted[1]);
var andDoc = new BsonDocument
{
{ "$and", new BsonArray(new List <BsonDocument>
{
new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument
{
{ "$gte", new BsonInt64(beginNum) }
} }
},
new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument
{
{ "$lte", new BsonInt64(endNum) }
} }
}
}) }
};
return(new BsonDocument
{
{ "$match", andDoc }
});
}
else
{
var numberDoc = new BsonDocument();
if (long.TryParse(chartFilterValue.Value, out var tempLong))
{
numberDoc.Add(new BsonElement(chartFilterValue.Name, new BsonInt64(tempLong)));
}
else if (int.TryParse(chartFilterValue.Value, out var tempInt))
{
numberDoc.Add(new BsonElement(chartFilterValue.Name, new BsonInt32(tempInt)));
}
return(new BsonDocument
{
{ "$match", numberDoc }
});
}
}
case Entities.Components.FilterType.DatePicker:
if (chartFilterValue.IsMultiple)
{
var arrayDates = ConvertUtil.DeserializeObject <string[]>(chartFilterValue.Value);
var startDatePickerDt = DateTime.Parse(arrayDates[0]);
var endDatePickerDt = DateTime.Parse(arrayDates[1]);
var month = startDatePickerDt.Month;
var day = startDatePickerDt.Day;
var year = startDatePickerDt.Year;
// Support Format MM/DD/YYYY, we can change its in configuration later
var filterStartDate = new DateTime(year, month, day);
var monthEnd = endDatePickerDt.Month;
var dayEnd = endDatePickerDt.Day;
var yearEnd = endDatePickerDt.Year;
// Support Format MM/DD/YYYY, we can change its in configuration later
var filterEndDate = new DateTime(yearEnd, monthEnd, dayEnd);
var gteDoc = new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument(new BsonElement("$gte", new BsonDateTime(filterStartDate))) }
};
var lteDoc = new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument(new BsonElement("$lte", new BsonDateTime(filterEndDate))) }
};
var andDoc = new BsonDocument
{
{
"$and",
new BsonArray(new List <BsonDocument> {
gteDoc, lteDoc
})
}
};
return(new BsonDocument
{
{ "$match", andDoc }
});
}
else
{
var datetime = DateTime.Parse(chartFilterValue.Value);
var month = datetime.Month;
var day = datetime.Day;
var year = datetime.Year;
// Support Format MM/DD/YYYY, we can change its in configuration later
var filterDateGt = new DateTime(year, month, day);
var filterDateLt = new DateTime(year, month, day + 1);
filterDateLt = filterDateLt.Subtract(TimeSpan.FromSeconds(1));
var gteDoc = new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument(new BsonElement("$gte", new BsonDateTime(filterDateGt))) }
};
var lteDoc = new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument(new BsonElement("$lte", new BsonDateTime(filterDateLt))) }
};
var andDoc = new BsonDocument
{
{
"$and",
new BsonArray(new List <BsonDocument> {
gteDoc, lteDoc
})
}
};
return(new BsonDocument
{
{ "$match", andDoc }
});
}
case Entities.Components.FilterType.MonthYearPicker:
if (chartFilterValue.IsMultiple)
{
var arrayDates = ConvertUtil.DeserializeObject <string[]>(chartFilterValue.Value);
var startDatePickerDt = DateTime.Parse(arrayDates[0]);
var endDatePickerDt = DateTime.Parse(arrayDates[1]);
var month = startDatePickerDt.Month;
var day = startDatePickerDt.Day;
var year = startDatePickerDt.Year;
// Support Format MM/DD/YYYY, we can change its in configuration later
var filterStartDate = new DateTime(year, month, 1);
var monthEnd = endDatePickerDt.Month;
var dayEnd = endDatePickerDt.Day;
var yearEnd = endDatePickerDt.Year;
// Support Format MM/DD/YYYY, we can change its in configuration later
var filterEndDate = new DateTime(yearEnd, monthEnd + 1, 1);
filterEndDate = filterEndDate.Subtract(TimeSpan.FromDays(1));
var gteDoc = new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument(new BsonElement("$gte", new BsonDateTime(filterStartDate))) }
};
var lteDoc = new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument(new BsonElement("$lte", new BsonDateTime(filterEndDate))) }
};
var andDoc = new BsonDocument
{
{
"$and",
new BsonArray(new List <BsonDocument> {
gteDoc, lteDoc
})
}
};
return(new BsonDocument
{
{ "$match", andDoc }
});
}
else
{
var datetime = DateTime.Parse(chartFilterValue.Value);
var month = datetime.Month;
var day = datetime.Day;
var year = datetime.Year;
// Support Format MM/DD/YYYY, we can change its in configuration later
var filterDateGt = new DateTime(year, month + 1, 1);
var filterDateLt = new DateTime(year, month + 1, 1);
filterDateLt = filterDateLt.Subtract(TimeSpan.FromDays(1));
var gteDoc = new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument(new BsonElement("$gte", new BsonDateTime(filterDateGt))) }
};
var lteDoc = new BsonDocument
{
{ chartFilterValue.Name, new BsonDocument(new BsonElement("$lte", new BsonDateTime(filterDateLt))) }
};
var andDoc = new BsonDocument
{
{
"$and",
new BsonArray(new List <BsonDocument> {
gteDoc, lteDoc
})
}
};
return(new BsonDocument
{
{ "$match", andDoc }
});
}
default:
return(null);
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var userBuilder = modelBuilder.Entity <User>();
userBuilder.HasKey(a => a.Id);
if (ConnectionType == ConnectionType.MySQL)
{
userBuilder.Property(a => a.IsConfirmedEmail).HasColumnType("BIT");
userBuilder.Property(a => a.IsLockoutEnabled).HasColumnType("BIT");
}
var jsonRolesConverter = new ValueConverter <List <string>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <string> >(v));
var jsonClaimsConverter = new ValueConverter <List <BaseClaim>, string>(
v => ConvertUtil.SerializeObject(v, true),
v => ConvertUtil.DeserializeObject <List <BaseClaim> >(v));
userBuilder.Property(a => a.Roles).HasConversion(jsonRolesConverter);
userBuilder.Property(a => a.Claims).HasConversion(jsonClaimsConverter);
var roleBuilder = modelBuilder.Entity <Role>();
roleBuilder.HasKey(a => a.Id);
roleBuilder.Property(a => a.Claims).HasConversion(jsonClaimsConverter);
var issueTokenBuilder = modelBuilder.Entity <IssuedToken>();
issueTokenBuilder.HasKey(a => a.Id);
if (ConnectionType == ConnectionType.MySQL)
{
issueTokenBuilder.Property(a => a.Deactive).HasColumnType("BIT");
}
var userSessionBuilder = modelBuilder.Entity <UserSession>();
userSessionBuilder.HasKey(a => a.Id);
userSessionBuilder.HasMany(a => a.UserActivities).WithOne().OnDelete(DeleteBehavior.Cascade);
if (ConnectionType == ConnectionType.MySQL)
{
userSessionBuilder.Property(a => a.AlreadySignOut).HasColumnType("BIT");
}
var userActivityBuilder = modelBuilder.Entity <UserActivity>();
userActivityBuilder.HasKey(a => a.Id);
var versionBuilder = modelBuilder.Entity <Version>();
versionBuilder.HasKey(a => a.Id);
foreach (var entity in modelBuilder.Model.GetEntityTypes())
{
foreach (var property in entity.GetProperties())
{
property.SetColumnName(ToCamelCase(property.GetColumnName()));
}
}
}