/// <summary>
/// Get IDatabase Instance
/// </summary>
/// <param name="databaseDescriptor">DatabaseDescriptor Object</param>
/// <returns>IDatabase Object</returns>
/// <exception cref="Siminov.Core.Exception.DatabaseException">If not able to create IDatabase instance</exception>
public DatabaseBundle GetDatabaseBundle(DatabaseDescriptor databaseDescriptor)
{
if (databaseBundles.ContainsKey(databaseDescriptor.GetDatabaseName()))
{
return(databaseBundles[databaseDescriptor.GetDatabaseName()]);
}
String type = databaseDescriptor.GetType();
String packageName = DATABASE_PACKAGE_NAME + "." + type;
DatabaseBundle databaseBundle = GetDatabaseBundle(packageName);
databaseBundles.Add(databaseDescriptor.GetDatabaseName(), databaseBundle);
return(databaseBundle);
}
/// <summary>
/// It is used to check whether database exists or not.
/// </summary>
protected static void DoesDatabaseExists()
{
ApplicationDescriptor applicationDescriptor = coreResourceManager.GetApplicationDescriptor();
IEnumerator <DatabaseDescriptor> databaseDescriptors = applicationDescriptor.GetDatabaseDescriptors();
bool databaseExists = true;
while (databaseDescriptors.MoveNext())
{
DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current;
String databasePath = new DatabaseUtils().GetDatabasePath(databaseDescriptor);
String databaseName = databaseDescriptor.GetDatabaseName();
if (!databaseName.EndsWith(".db"))
{
databaseName = databaseName + ".db";
}
bool fileExists = FileUtils.DoesFileExists(databasePath, databaseName, FileUtils.LOCAL_FOLDER);
if (!fileExists)
{
databaseExists = false;
}
}
if (!databaseExists)
{
firstTimeProcessed = true;
}
else
{
firstTimeProcessed = false;
}
}
/// <summary>
/// Get internal memory database path
/// </summary>
/// <param name="databaseDescriptor">Database Descriptor Object</param>
/// <returns></returns>
public String InternalMemoryDatabasePath(DatabaseDescriptor databaseDescriptor)
{
#if XAMARIN
var rootFolder = FileSystem.Current.LocalStorage;
return(rootFolder.Path);
#elif WINDOWS
ResourceManager resourceManager = ResourceManager.GetInstance();
ApplicationDescriptor applicationDescriptor = resourceManager.GetApplicationDescriptor();
String databaseDirName = databaseDescriptor.GetDatabaseName();
String databaseDirPath = applicationDescriptor.GetName() + FileUtils.Separator + Constants.DATABASE_PATH_DATABASE + FileUtils.Separator + databaseDirName + FileUtils.Separator;
return(databaseDirPath);
#endif
}
public void OpenOrCreate(DatabaseDescriptor databaseDescriptor)
{
String databasePath = new DatabaseUtils().GetDatabasePath(databaseDescriptor);
if (!FileUtils.DoesFolderExists(databasePath, FileUtils.LOCAL_FOLDER))
{
try
{
FileUtils.CreateFolder(databasePath, FileUtils.LOCAL_FOLDER);
}
catch (System.Exception exception)
{
Log.Log.Error(typeof(DatabaseImpl).FullName, "OpenOrCreate", "Exception caught while creating database directories, DATABASE-PATH: " + databasePath + ", DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName() + ", " + exception.Message);
throw new DeploymentException(typeof(DatabaseImpl).FullName, "OpenOrCreate", "Exception caught while creating database directories, DATABASE-PATH: " + databasePath + ", DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName() + ", " + exception.Message);
}
}
String databaseName = databaseDescriptor.GetDatabaseName();
if (databaseName == null || databaseName.Length <= 0)
{
Log.Log.Error(typeof(DatabaseImpl).FullName, "OpenOrCreate", "DATABASE-NAME IS MANDATORY FIELD - DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName());
throw new DatabaseException(typeof(DatabaseImpl).FullName, "OpenOrCreate", "DATABASE-NAME IS MANDATORY FIELD - DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName());
}
if (!databaseName.EndsWith(".db"))
{
databaseName = databaseName + ".db";
}
try
{
#if XAMARIN
String databaseURI = Path.Combine(databasePath, databaseName);
sqliteDatabase = new SQLiteConnection(databaseURI);
#elif WINDOWS
sqliteDatabase = new SQLiteConnection(databasePath + databaseName);
#endif
}
catch (SQLiteException sqliteException)
{
Log.Log.Error(typeof(DatabaseImpl).FullName, "OpenOrCreate", "SQLiteException caught while opening database, " + sqliteException.Message);
throw new DatabaseException(typeof(DatabaseImpl).FullName, "OpenOrCreate", "SQLiteException caught while opening database, " + sqliteException.Message);
}
}
/// <summary>
/// It process all LibraryDescriptor.xml files defined by application, and stores in Resource Manager.
/// </summary>
protected static void ProcessLibraries()
{
ApplicationDescriptor applicationDescriptor = coreResourceManager.GetApplicationDescriptor();
IEnumerator <String> libraries = applicationDescriptor.GetLibraryDescriptorPaths();
while (libraries.MoveNext())
{
String library = libraries.Current;
/*
* Parse LibraryDescriptor.
*/
LibraryDescriptorReader libraryDescriptorReader = new LibraryDescriptorReader(library);
LibraryDescriptor libraryDescriptor = libraryDescriptorReader.GetLibraryDescriptor();
/*
* Map Entity Descriptors
*/
IEnumerator <String> entityDescriptors = libraryDescriptor.GetEntityDescriptorPaths();
while (entityDescriptors.MoveNext())
{
String libraryEntityDescriptorPath = entityDescriptors.Current;
String databaseDescriptorName = libraryEntityDescriptorPath.Substring(0, libraryEntityDescriptorPath.IndexOf(Constants.LIBRARY_DESCRIPTOR_ENTITY_DESCRIPTOR_SEPRATOR));
String entityDescriptor = libraryEntityDescriptorPath.Substring(libraryEntityDescriptorPath.IndexOf(Constants.LIBRARY_DESCRIPTOR_ENTITY_DESCRIPTOR_SEPRATOR) + 1, ((libraryEntityDescriptorPath.Length - libraryEntityDescriptorPath.IndexOf(Constants.LIBRARY_DESCRIPTOR_ENTITY_DESCRIPTOR_SEPRATOR)) - 1));
IEnumerator <DatabaseDescriptor> databaseDescriptors = applicationDescriptor.GetDatabaseDescriptors();
while (databaseDescriptors.MoveNext())
{
DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current;
if (databaseDescriptor.GetDatabaseName().Equals(databaseDescriptorName, StringComparison.OrdinalIgnoreCase))
{
databaseDescriptor.AddEntityDescriptorPath(library.Replace(".", "/") + FileUtils.Separator + entityDescriptor);
}
}
}
}
}
/// <summary>
/// Get database descriptor name based on table name
/// </summary>
/// <param name="tableName">Name of Table</param>
/// <returns>Database Descriptor Name</returns>
public String GetDatabaseDescriptorNameBasedOnTableName(String tableName)
{
if (this.applicationDescriptor == null)
{
throw new DeploymentException(typeof(ResourceManager).FullName, "GetDatabaseDescriptorNameBasedOnTableName", "Siminov Not Active, INVALID APPLICATION-DESCRIPTOR FOUND");
}
IEnumerator <DatabaseDescriptor> databaseDescriptors = this.applicationDescriptor.GetDatabaseDescriptors();
while (databaseDescriptors.MoveNext())
{
DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current;
bool containsEntityDescriptorInDatabaseDescriptor = databaseDescriptor.ContainsEntityDescriptorBasedOnTableName(tableName);
if (containsEntityDescriptorInDatabaseDescriptor)
{
return(databaseDescriptor.GetDatabaseName());
}
}
return(null);
}
/// <summary>
/// Removes database bundle instance
/// </summary>
/// <param name="databaseDescriptor">Database descriptor instance object</param>
public void RemoveDatabaseBundle(DatabaseDescriptor databaseDescriptor)
{
this.databaseBundles.Remove(databaseDescriptor.GetDatabaseName());
}
/// <summary>
/// It process all DatabaseDescriptor.xml and initialize Database and stores in Resource Manager.
/// </summary>
protected static void ProcessDatabase()
{
ApplicationDescriptor applicationDescriptor = coreResourceManager.GetApplicationDescriptor();
IEnumerator <DatabaseDescriptor> databaseDescriptors = applicationDescriptor.GetDatabaseDescriptors();
while (databaseDescriptors.MoveNext())
{
DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current;
String databasePath = new DatabaseUtils().GetDatabasePath(databaseDescriptor);
DatabaseBundle databaseBundle = null;
try
{
databaseBundle = DatabaseHelper.CreateDatabase(databaseDescriptor);
}
catch (DatabaseException databaseException)
{
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while getting database instance from database factory, DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName() + ", " + databaseException.GetMessage());
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
}
IDatabaseImpl database = databaseBundle.GetDatabase();
IQueryBuilder queryBuilder = databaseBundle.GetQueryBuilder();
/*
* If Database exists then open and return.
* If Database does not exists create the database.
*/
String databaseName = databaseDescriptor.GetDatabaseName();
if (!databaseName.EndsWith(".db"))
{
databaseName = databaseName + ".db";
}
bool fileExists = FileUtils.DoesFileExists(databasePath, databaseName, FileUtils.LOCAL_FOLDER);
if (fileExists)
{
/*
* Open Database
*/
try
{
database.OpenOrCreate(databaseDescriptor);
}
catch (DatabaseException databaseException)
{
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while opening database, " + databaseException.GetMessage());
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
}
/*
* Enable Foreign Key Constraints
*/
try
{
database.ExecuteQuery(databaseDescriptor, null, Constants.SQLITE_DATABASE_QUERY_TO_ENABLE_FOREIGN_KEYS_MAPPING);
}
catch (DatabaseException databaseException)
{
FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER);
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while executing query to enable foreign keys, " + databaseException.GetMessage());
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
}
/*
* Safe MultiThread Transaction
*/
/*try
* {
* database.ExecuteMethod(Constants.SQLITE_DATABASE_ENABLE_LOCKING, databaseDescriptor.IsTransactionSafe());
* }
* catch (DatabaseException databaseException)
* {
* FileUtils.DoesFileExists(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER);
*
* Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while enabling locking on database, " + databaseException.GetMessage());
* throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
* }*/
/*
* Upgrade Database
*/
try
{
DatabaseHelper.UpgradeDatabase(databaseDescriptor);
}
catch (DatabaseException databaseException)
{
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while upgrading database, " + databaseException.GetMessage());
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
}
}
else
{
/*
* Create Database Directory
*/
try
{
FileUtils.GetFolder(databasePath, FileUtils.LOCAL_FOLDER);
}
catch (System.Exception exception)
{
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "Exception caught while creating database directories, DATABASE-PATH: " + databasePath + ", DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName() + ", " + exception.Message);
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", exception.Message);
}
/*
* Create Database File.
*/
try
{
database.OpenOrCreate(databaseDescriptor);
}
catch (DatabaseException databaseException)
{
FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER);
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while creating database, " + databaseException.GetMessage());
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
}
/*
* Set Database Version
*/
IDictionary <String, Object> parameters = new Dictionary <String, Object>();
parameters.Add(IQueryBuilder.FORM_UPDATE_DATABASE_VERSION_QUERY_DATABASE_VERSION_PARAMETER, databaseDescriptor.GetVersion());
try
{
String updateDatabaseVersionQuery = queryBuilder.FormUpdateDatabaseVersionQuery(parameters);
database.ExecuteQuery(databaseDescriptor, null, updateDatabaseVersionQuery);
}
catch (DatabaseException databaseException)
{
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "Database Exception caught while updating database version, " + databaseException.GetMessage());
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
}
IDatabaseEvents databaseEventHandler = coreResourceManager.GetDatabaseEventHandler();
if (databaseEventHandler != null)
{
databaseEventHandler.OnDatabaseCreated(databaseDescriptor);
}
/*
* Enable Foreign Key Constraints
*/
try
{
database.ExecuteQuery(databaseDescriptor, null, Constants.SQLITE_DATABASE_QUERY_TO_ENABLE_FOREIGN_KEYS_MAPPING);
}
catch (DatabaseException databaseException)
{
FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER);
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while executing query to enable foreign keys, " + databaseException.GetMessage());
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
}
/*
* Safe MultiThread Transaction
*/
/*try
* {
* database.ExecuteMethod(Constants.SQLITE_DATABASE_ENABLE_LOCKING, databaseDescriptor.IsTransactionSafe());
* }
* catch (DatabaseException databaseException)
* {
* FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER);
*
* Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while enabling locking on database, " + databaseException.GetMessage());
* throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
* }*/
/*
* Create Tables
*/
try
{
DatabaseHelper.CreateTables(databaseDescriptor.OrderedEntityDescriptors());
}
catch (DatabaseException databaseException)
{
FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER);
Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while creating tables, " + databaseException.GetMessage());
throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage());
}
}
}
}
/// <summary>
/// It is used to stop all service started by SIMINOV.
/// When application shutdown they should call this. It do following services:
///
/// <list type="bullet">
/// <item>
/// <description>Close all database's opened by SIMINOV.</description>
/// </item>
/// <item>
/// <description>Deallocate all resources held by SIMINOV.</description>
/// </item>
/// </list>
/// </summary>
public static void Shutdown()
{
IsActive();
IEnumerator <DatabaseDescriptor> databaseDescriptors = coreResourceManager.GetDatabaseDescriptors();
bool failed = false;
while (databaseDescriptors.MoveNext())
{
DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current;
DatabaseBundle databaseBundle = coreResourceManager.GetDatabaseBundle(databaseDescriptor.GetDatabaseName());
IDatabaseImpl database = databaseBundle.GetDatabase();
try
{
database.Close(databaseDescriptor);
}
catch (DatabaseException databaseException)
{
failed = true;
Log.Log.Error(typeof(Siminov).FullName, "Shutdown", "DatabaseException caught while closing database, " + databaseException.GetMessage());
continue;
}
}
if (failed)
{
throw new SiminovCriticalException(typeof(Siminov).FullName, "Shutdown", "DatabaseException caught while closing database.");
}
ISiminovEvents coreEventHandler = coreResourceManager.GetSiminovEventHandler();
if (coreResourceManager.GetSiminovEventHandler() != null)
{
coreEventHandler.OnSiminovStopped();
}
}
