public RepositoryProxy(IDbConnectionFactory dbConnectionFactory, IRedisClientsManager redisClientsManager)
 {
     DbConnectionFactory= dbConnectionFactory;
     RedisClientsManager= redisClientsManager;
     CreateCommand();
     CreateRedisClient();
 }

        protected DbRepository(IDbConnectionFactory dbConnectionFactory)
        {
            if(dbConnectionFactory == null)
                throw new ArgumentNullException("dbConnectionFactory");

            this._dbConnectionFactory = dbConnectionFactory;
        }

        private void RecreateTables(IDbConnectionFactory factory)
        {
            factory.Run(x =>
            {
                using (var transaction = x.BeginTransaction())
                {
                    try
                    {
                        //core tables
                        x.DropAndCreateTables(typeof(VCALENDAR), typeof(VEVENT), typeof(VTODO), typeof(VFREEBUSY), typeof(FREEBUSY), typeof(VJOURNAL), typeof(VTIMEZONE), typeof(STANDARD), typeof(DAYLIGHT), typeof(AUDIO_ALARM), typeof(DISPLAY_ALARM), typeof(EMAIL_ALARM), typeof(ORGANIZER), typeof(ATTENDEE), typeof(COMMENT), typeof(RELATEDTO), typeof(ATTACH_BINARY), typeof(ATTACH_URI), typeof(CONTACT), typeof(RDATE), typeof(EXDATE), typeof(RECUR), typeof(RECURRENCE_ID), typeof(REQUEST_STATUS), typeof(RESOURCES), typeof(TZNAME));

                        //3NF relational tables
                        x.DropAndCreateTables(typeof(REL_CALENDARS_EVENTS), typeof(REL_CALENDARS_TODOS), typeof(REL_CALENDARS_FREEBUSIES), typeof(REL_CALENDARS_JOURNALS), typeof(REL_CALENDARS_TIMEZONES),  typeof(REL_EVENTS_ATTACHBINS), typeof(REL_EVENTS_ATTACHURIS), typeof(REL_EVENTS_ATTENDEES), typeof(REL_EVENTS_AUDIO_ALARMS), typeof(REL_EVENTS_COMMENTS), typeof(REL_EVENTS_CONTACTS), typeof(REL_EVENTS_DISPLAY_ALARMS), typeof(REL_EVENTS_EMAIL_ALARMS), typeof(REL_EVENTS_EXDATES), typeof(REL_EVENTS_RDATES), typeof(REL_EVENTS_RELATEDTOS), typeof(REL_EVENTS_REQSTATS), typeof(REL_EVENTS_RESOURCES), typeof(REL_TODOS_ATTACHBINS), typeof(REL_TODOS_ATTACHURIS), typeof(REL_TODOS_ATTENDEES), typeof(REL_TODOS_AUDIO_ALARMS), typeof(REL_TODOS_COMMENTS), typeof(REL_TODOS_CONTACTS), typeof(REL_TODOS_DISPLAY_ALARMS), typeof(REL_TODOS_EMAIL_ALARMS), typeof(REL_TODOS_EXDATES), typeof(REL_TODOS_RDATES), typeof(REL_TODOS_RELATEDTOS), typeof(REL_TODOS_REQSTATS), typeof(REL_TODOS_RESOURCES), typeof(REL_FREEBUSIES_ATTACHBINS), typeof(REL_FREEBUSIES_ATTACHURIS), typeof(REL_FREEBUSIES_ATTENDEES), typeof(REL_FREEBUSIES_COMMENTS), typeof(REL_FREEBUSIES_REQSTATS), typeof(REL_FREEBUSIES_VFREEBUSIES), typeof(REL_JOURNALS_ATTACHBINS), typeof(REL_JOURNALS_ATTACHURIS), typeof(REL_JOURNALS_ATTENDEES), typeof(REL_JOURNALS_COMMENTS), typeof(REL_JOURNALS_CONTACTS), typeof(REL_JOURNALS_EXDATES), typeof(REL_JOURNALS_RDATES), typeof(REL_JOURNALS_RELATEDTOS), typeof(REL_JOURNALS_REQSTATS), typeof(REL_JOURNALS_RESOURCES), typeof(REL_EALARMS_ATTACHBINS), typeof(REL_EALARMS_ATTACHURIS), typeof(REL_EALARMS_ATTENDEES), typeof(REL_TIMEZONES_STANDARDS), typeof(REL_TIMEZONES_DAYLIGHT), typeof(REL_STANDARDS_COMMENTS), typeof(REL_STANDARDS_RDATES), typeof(REL_STANDARDS_TZNAMES), typeof(REL_DAYLIGHTS_COMMENTS), typeof(REL_DAYLIGHTS_RDATES), typeof(REL_DAYLIGHTS_TZNAMES));

                        transaction.Commit();
                    }
                    catch (ApplicationException)
                    {
                        transaction.Rollback();
                        throw;
                    }
                    catch (InvalidOperationException)
                    {
                        transaction.Rollback();
                        throw;
                    }
                }
            });
        }

 public SqlContextTransactionManager(IDbConnectionFactory connectionFactory, IContextTransactionLifetimeManager contextTransactionLifetimeManager, ILoggerFactory loggerFactory)
 {
     _connectionFactory = connectionFactory;
     _contextTransactionLifetimeManager = contextTransactionLifetimeManager;
     _loggerFactory = loggerFactory;
     _logger = loggerFactory.Create("EventSourcing.SqlContextTransactionManager");
 }

        private void CreateSqliteInMemoryTables(IDbConnectionFactory dbFactory)
        {
            try
            {
                using (IDbConnection db = dbFactory.OpenDbConnection())
                {
                    db.CreateTable<Todo>(true);
                    db.CreateTable<Account>(false);
                    db.CreateTable<Service>(false);
                    db.CreateTable<Tag>(false);
                    db.CreateTable<Content>(false);
                    db.CreateTable<ContentTag>(false);

                    Guid accountId = Guid.NewGuid();
                    Guid serviceId = Guid.NewGuid();

                    db.Insert<Todo>(new Todo { Id = Guid.NewGuid(), Content = "bla", Done = false, Order = 1 });
                    db.Insert<Account>(new Account { Id = accountId, FullName = "Metaintellect" });
                    db.Insert<Service>(new Service { Id = serviceId, Name = "content" });
                    db.Insert<Content>(new Content { Id = Guid.NewGuid(), Title = "New Title", CreatedAt = DateTime.Now, AccountId = accountId, ServiceId = serviceId });
                    db.Insert<Tag>(GetTags(accountId).ToArray());
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.StackTrace);
                throw;
            }
        }

        public static IBlogManager CreateManager(IBlogRepository repository = null,
            IDbConnectionFactory connectionFactory = null)
        {
            if (repository == null)
                repository = new BlogRepository();

            if (connectionFactory == null && repository.DbFactory == null)
            {
                if (ConfigurationManager.ConnectionStrings["BlogDB"] == null)
                {
                    connectionFactory =
                        new OrmLiteConnectionFactory(
                            ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString,
                            SqlServerOrmLiteDialectProvider.Instance);
                    repository.DbFactory = connectionFactory;
                }
                else
                {
                    connectionFactory =
                        new OrmLiteConnectionFactory(
                            ConfigurationManager.ConnectionStrings["BlogDB"].ConnectionString,
                            SqlServerOrmLiteDialectProvider.Instance);

                    repository.DbFactory = connectionFactory;
                }
            }

            return new BlogManager
            {
                BlogRepo = repository
            };
        }

        public static LogViewerManager CreateManager(ILogViewerRepository repository = null, IDbConnectionFactory connectionFactory = null, string connectionStringMapping = null)
        {
            if (repository == null)
                repository = new LogViewerRepository();

            if (connectionStringMapping == null)
                connectionStringMapping = "LoggingConnection1";

            if (connectionFactory == null && repository.DbFactory == null)
            {
                if (ConfigurationManager.ConnectionStrings[connectionStringMapping] == null)
                {
                    connectionFactory =
                        new OrmLiteConnectionFactory(
                            ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString,
                            SqlServerOrmLiteDialectProvider.Instance);
                    repository.DbFactory = connectionFactory;
                }
                else
                {
                    connectionFactory =
                        new OrmLiteConnectionFactory(
                            ConfigurationManager.ConnectionStrings[connectionStringMapping].ConnectionString,
                            SqlServerOrmLiteDialectProvider.Instance);

                    repository.DbFactory = connectionFactory;
                }
            }

            return new LogViewerManager
            {
                LogViewerRepo = repository
            };
        }

        public Bootstrapper(IDbConnectionFactory connectionFactory)
        {
            _connectionFactory = connectionFactory;

            StaticConfiguration.DisableErrorTraces = false;
            StaticConfiguration.EnableRequestTracing = true;

            //Cross origin resource sharing
            ApplicationPipelines.AfterRequest.AddItemToEndOfPipeline(x => x.Response.WithHeader("Access-Control-Allow-Origin", "*"));
            ApplicationPipelines.AfterRequest.AddItemToEndOfPipeline(x => x.Response.WithHeader("Access-Control-Allow-Methods", "DELETE, GET, HEAD, POST, PUT, OPTIONS, PATCH"));
            ApplicationPipelines.AfterRequest.AddItemToEndOfPipeline(x => x.Response.WithHeader("Access-Control-Allow-Headers", "Content-Type"));
            ApplicationPipelines.AfterRequest.AddItemToEndOfPipeline(x => x.Response.WithHeader("Accept", "application/json"));

            //Default format to JSON (very low priority)
            ApplicationPipelines.BeforeRequest.AddItemToStartOfPipeline(x => {
                x.Request.Headers.Accept = x.Request.Headers.Accept.Concat(new Tuple<string, decimal>("application/json", 0.01m));
                return null;
            });

            //Make sure this is being accessed over a secure connection
            var httpsRedirect = SecurityHooks.RequiresHttps(redirect: false);
            ApplicationPipelines.BeforeRequest.AddItemToEndOfPipeline(x => {
                if (!IsSecure(x))
                    return httpsRedirect(x);
                return null;
            });
        }

        public DbAuthenticator(IDbConnectionFactory factory)
        {
            if (factory == null)
                throw new ArgumentNullException ("factory");

            connFactory = factory;
        }

        /// <summary>
        ///     Initializes a new instance of the <see cref="AudioAlarmOrmRepository" /> class.
        /// </summary>
        public AudioAlarmOrmRepository(IKeyGenerator<Guid> keygenerator, IDbConnectionFactory factory)
        {
            if (keygenerator == null) throw new ArgumentNullException(nameof(keygenerator));
            if (factory == null) throw new ArgumentNullException(nameof(factory));

            this.keygenerator = keygenerator;
            DbConnectionFactory = factory;
        }

 public MigrationStep(IMigration migration, IScheduledMigrationMetadata metadata, ConnectionInfo connectionInfo, IProvider provider, IProviderMetadata providerMetadata, IDbConnectionFactory connectionFactory, ISqlDispatcher sqlDispatcher)
     : base(migration, provider, providerMetadata)
 {
     _metadata = metadata;
     _connectionInfo = connectionInfo;
     _connectionFactory = connectionFactory;
     _sqlDispatcher = sqlDispatcher;
 }

 public static void Seed(IDbConnectionFactory dbFactory)
 {
     dbFactory.Run(db =>
     {
         CategorySeeder.Seed(db);
         PrioritySeeder.Seed(db);
         StatusSeeder.Seed(db);
     });
 }

		public static List<Person> GetByJobCityId(this Person request, 
		                                           IDbConnectionFactory DbFactory){
			
			
			return DbFactory.Exec(dbCmd=> dbCmd.Select<Person>
			                      (q=> q.JobCityId ==request.JobCityId)).
			                      OrderBy( q=> q.Name).ToList();
			
		}

		public static List<UserAuth> GetByUserName(this UserAuth request, 
		                                           IDbConnectionFactory DbFactory){
			var un= request.UserName;
			
			return DbFactory.Exec(dbCmd=> dbCmd.Select<UserAuth>
			                      (q=> q.UserName.Contains(un))).
			                      OrderBy( q=> q.UserName).ToList();
			
		}

		public static List<City> GetByCountryId(this City request, 
		                                           IDbConnectionFactory DbFactory){
			
			
			return DbFactory.Exec(dbCmd=> dbCmd.Select<City>
			                      (q=> q.CountryId ==request.CountryId )).
			                      OrderBy( q=> q.Name).ToList();
			
		}

 /// <summary>Parameterized constructor.
 /// </summary>
 public SqlServerEventStore(string connectionString, string eventTable, string commitIndexName, string versionIndexName)
 {
     _connectionString = connectionString;
     _eventTable = eventTable;
     _commitIndexName = commitIndexName;
     _versionIndexName = versionIndexName;
     _binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
     _connectionFactory = ObjectContainer.Resolve<IDbConnectionFactory>();
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProductLoader"/> class.
        /// </summary>
        /// <param name="targetFactory">Target connection factory.</param>
        public ProductLoader(IDbConnectionFactory targetFactory)
        {
            if (targetFactory == null)
            {
                throw new ArgumentNullException("targetFactory");
            }

            this.targetFactory = targetFactory;
        }

        public DatabaseBackend(IDbConnectionFactory conn_factory, IDbStorageFactory storage_factory, IAuthenticator auth,
		                        OAuthHandler handler)
            : base(conn_factory)
        {
            oauthHandler = handler;
            storageFactory = storage_factory;

            // TODO move this into (Encrypted)DbStorageFactory implementation
            CreateSchema (conn_factory);
        }

        public CalendarDapperRepository(IDbConnectionFactory factory, IKeyGenerator<Guid> keygenerator, IEventRepository eventrepository)
        {
            dbconnection.ThrowIfNull("factory");
            keygenerator.ThrowIfNull("keygenerator");
            eventrepository.ThrowIfNull("eventrepository");

            this.factory = factory;
            this.keygenerator = keygenerator;
            this.eventrepository = eventrepository;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CalendarOrmRepository"/> class.
        /// </summary>
        /// <param name="keygenerator">The generator for generating keys</param>
        /// <param name="eventrepository">The repository for calendar events</param>
        /// <param name="factory">The database connection factory</param>
        public CalendarOrmRepository(IKeyGenerator<Guid> keygenerator, IEventRepository eventrepository, IDbConnectionFactory factory)
        {
            if (keygenerator == null) throw new ArgumentNullException(nameof(keygenerator));
            if (eventrepository == null) throw new ArgumentNullException(nameof(eventrepository));
            if (factory == null) throw new ArgumentNullException(nameof(factory));

            this.keygenerator = keygenerator;
            this.eventrepository = eventrepository;
            this.factory = factory;
        }