tbf/Config/FluentCommon.cs

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

namespace Config
{
    public static class FluentCommon
    {
		/// <summary>
		/// Session factories for regular sessions.
		/// </summary>
		public static ISessionFactory[] SessionFactories = new ISessionFactory[(int)Users.Entities.DBKind.Count];

        /// <summary>
        /// NHibernate session factory (to create the database session 'SessionFactory')
        /// </summary>
        /// <returns>A database session</returns>
        static ISessionFactory CreateSessionFactory(Users.Entities.DBKind database)
        {
            Users.Entities.DBType dbType;
            string connectionString;

			switch (database)
			{
                default:
                case Users.Entities.DBKind.Config:
					dbType = Data.CurrentBench.ProceduresDBSettings.DbType;
					connectionString = Data.CurrentBench.ProceduresDBSettings.ConnectionString;
                    break;
                case Users.Entities.DBKind.Results:
					dbType = Data.CurrentBench.WaterMetersDBSettings.DbType;
					connectionString = Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
                    break;
                case Users.Entities.DBKind.RemoteConfig:
                    dbType = Data.CurrentBench.UsersDBSettings.DbType;
                    connectionString = Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
                    break;
            }

            return CreateSessionFactory(database, dbType, connectionString, false);
		}

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

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

                switch (database)
                {
                    default:
					case Users.Entities.DBKind.Config:
                    case Users.Entities.DBKind.RemoteConfig:
                        cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Data>());
                        break;
                    case Users.Entities.DBKind.Results:
                        cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Data>());
                        break;
                }

                if (createDB)
                {
                    return cfg.ExposeConfiguration(BuildSchemaCreate).BuildSessionFactory();
                }
                else
                {
                    return cfg.ExposeConfiguration(BuildSchema).BuildSessionFactory();
                }
			}
			catch (Exception exc)
			{
				MessageBox.Show(string.Format(Strings.Cannot_open_DB_Cause_0, exc.Message),
								Strings.Error,
								MessageBoxButtons.OK,
								MessageBoxIcon.Error);
				return null;
			}
        }

        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(Users.Entities.DBKind database)
		{
			int ix = (int)database;
			if (ix < 0 || ix >= (int)Users.Entities.DBKind.Count) return null;

			if (SessionFactories[ix] == null) SessionFactories[ix] = CreateSessionFactory(database);

			return SessionFactories[ix].OpenSession();
		}

		public static void SaveToDb(Users.Entities.DBKind database, object obj)
		{
			SaveToDb(CreateSession(database), obj);
		}

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

		public static void DeleteFromDb(Users.Entities.DBKind database, object obj)
		{
			DeleteFromDb(CreateSession(database), obj);
		}

		public static void DeleteFromDb(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 CreateEmptyConfigDB(Users.Entities.DBType dbType, string connectionString)
		{
			ISessionFactory sessionFactory = CreateSessionFactory(Users.Entities.DBKind.Config, dbType, connectionString, true);
			if (sessionFactory == null) return false;

            /// Populate the database
            using (var session = sessionFactory.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    ///
                    /// Prepare all groups
                    ///
					var testers					= new Config.Entities.Group((int)Users.Grp.GID.Testers, Strings.Tester);
					var testingSpecialists		= new Config.Entities.Group((int)Users.Grp.GID.TestingSpecialists, Strings.Testing_Specialist);
					var headOfLab				= new Config.Entities.Group((int)Users.Grp.GID.HeadOfLab, Strings.Head_of_Lab);
					var maintenanceSpecialists	= new Config.Entities.Group((int)Users.Grp.GID.MaintenanceSpecialists, Strings.Maintenance_Specialist);
					var metrologists			= new Config.Entities.Group((int)Users.Grp.GID.Metrologists, Strings.Metrologist);
					var calibrationSpecialists	= new Config.Entities.Group((int)Users.Grp.GID.CalibrationSpecialists, Strings.Calibration_Specialist);
					var administrators			= new Config.Entities.Group((int)Users.Grp.GID.Administrators, Strings.Administrator);

					/// Create the user 'admin' add his groups
                    var admin = new Config.Entities.User
                    {
						UserName = Data.AdminUsername,
                        FullName = Strings.Administrator,
                        LastPwChange = DateTime.Now
                    };
					admin.SetPassword(Data.AdminPassword);
                    admin.AddGroup(testers);
                    admin.AddGroup(testingSpecialists);
                    admin.AddGroup(headOfLab);
                    admin.AddGroup(maintenanceSpecialists);
                    admin.AddGroup(metrologists);
                    admin.AddGroup(calibrationSpecialists);
                    admin.AddGroup(administrators);

                    session.SaveOrUpdate(admin);

					///// Create the control board component
					//var cmpnt = (new BenchControl.Elde.ControlBoardCfg(new BenchControl.Elde.ControlBoardFactory())).CreateDbEntity();
					//session.SaveOrUpdate(cmpnt);

                    transaction.Commit();
                }
            }

            return true;
        }

        /// <summary>
        /// Create an empty water meters database
        /// </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(Users.Entities.DBType dbType, string connectionString)
        {
			ISessionFactory sessionFactory = CreateSessionFactory(Users.Entities.DBKind.Results, dbType, connectionString, true);
            if (sessionFactory == null) return false;

            /// Populate the database
            //using (var session = sessionFactory.OpenSession())
            //{
            //    using (var transaction = session.BeginTransaction())
            //    {
            //        /// Create one component
            //        var cmpnt = (new BenchControl.Elde.ControlBoardCfg("CB", 1)).CreateDbEntity();
            //        session.SaveOrUpdate(cmpnt);
            //        transaction.Commit();
            //    }
            //}
            return true;
        }
    }
}