tbf/Results/DB.cs

///
/// Copyright (c) 2013-2015 Sensus Metering Systems
///
using System;
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;

namespace Results
{
    /// <summary>
    /// Identifies the type of a database
    /// </summary>
    public enum DBType
    {
        SQLite,             /// SQLite
        MySql,              /// MySQL database
        DbTypesCount,
    }


    public static class DB
    {
		/// <summary> Session factory for all regular sessions, not for CreateEmptyResultsDB(). </summary>
		public static ISessionFactory SessionFactory;

		/// <summary> Connection string for all sessions </summary>
		private static string connectionString;
		/// 
		public static string ConnectionString
		{
			get { return connectionString; }
			set
			{
				connectionString = value;
				SessionFactory = null;
			}
		}

        /// <summary>
        /// NHibernate session factory (to create the database session 'SessionFactory')
        /// </summary>
        /// <returns>A database session</returns>
		static ISessionFactory CreateSessionFactory(DBType dbType)
        {
			return CreateSessionFactory(dbType, false);
		}

        /// <summary>
        /// NHibernate session factory (to create the database session 'SessionFactory')
        /// </summary>
        /// <returns>A database session</returns>
		public static ISessionFactory CreateSessionFactory(DBType dbType, bool createDB)
        {
            FluentConfiguration cfg = Fluently.Configure();

			switch (dbType)
			{
				default:
				case DBType.SQLite:
					cfg = cfg.Database(SQLiteConfiguration.Standard.UsingFile(connectionString));
                    break;
				case DBType.MySql:
                    cfg = cfg.Database(MySQLConfiguration.Standard.ConnectionString(connectionString));
                    break;
			}

            cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<DataDeposit>());

            if (createDB)
            {
                return cfg.ExposeConfiguration(BuildSchemaCreate).BuildSessionFactory();
            }
            else
            {
                return cfg.ExposeConfiguration(BuildSchema).BuildSessionFactory();
            }
        }

        public delegate void BuildSchemaDlgt(Configuration config);

        static void BuildSchema(Configuration config)
        {
            /// This NHibernate tool takes a configuration (with mapping info in)
            /// and exports a database schema from it
            new SchemaExport(config).SetOutputFile("db_schema");
        }

        static void BuildSchemaCreate(Configuration config)
        {
            /// This NHibernate tool takes a configuration (with mapping info in)
            /// and exports a database schema from it
            new SchemaExport(config).Create(true, true);
        }

		/// Create a NHibernate session for the given database
		public static ISession CreateSession()
		{
			if (string.IsNullOrEmpty(connectionString))
			{
				throw new Exception("Connection string was not specified");
			}

			if (SessionFactory == null)
			{
				SessionFactory = CreateSessionFactory(DBType.MySql);
			}

			return SessionFactory.OpenSession();
		}

		public static void SaveObject(object obj)
		{
			SaveObject(CreateSession(), obj);
		}

		public static void SaveObject(ISession session, object obj)
		{
            using (var transaction = session.BeginTransaction())
            {
                session.SaveOrUpdate(obj);
                try { transaction.Commit(); }
                catch { }
            }
        }

		public static void DeleteObject(object obj)
		{
			DeleteObject(CreateSession(), obj);
		}

		public static void DeleteObject(ISession session, object obj)
        {
            using (var transaction = session.BeginTransaction())
            {
                session.Delete(obj);
                transaction.Commit();
            }
        }

        /// <summary>
        /// Create an empty users database.
		/// Database contains only the user 'admin' and the control board component 'CB'.
        /// </summary>
        /// <param name="dbType">DBType.SQLite or DBType.MySql</param>
        /// <param name="connectionString">Connection string</param>
        /// <returns>true=success, false=error</returns>
        public static bool CreateEmptyResultsDB(DBType dbType)
        {
			ISessionFactory sessionFactory = CreateSessionFactory(dbType, true);
            if (sessionFactory == null) return false;

            /// Populate the database
            using (var session = sessionFactory.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    transaction.Commit();
                }
            }

            return true;
        }
    }
}