public CommentDao(IDbConnectionProvider conn,
ICommentTreeBuilder commentTreeBuilder)
: base(conn)
{
_conn = conn;
_commentTreeBuilder = commentTreeBuilder;
}
/// <summary>
/// Constructs the storage using the specified connection provider and table to store its subscriptions. If the subscription
/// storage is shared by all subscribers and publishers, the <paramref name="isCentralized"/> parameter can be set to true
/// in order to subscribe/unsubscribe directly instead of sending subscription/unsubscription requests
/// </summary>
public SqlServerSubscriptionStorage(IDbConnectionProvider connectionProvider, string tableName, bool isCentralized, IRebusLoggerFactory rebusLoggerFactory)
{
IsCentralized = isCentralized;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_connectionProvider = connectionProvider;
_tableName = tableName;
}
public SQLMessageQueue(IDbConnectionProvider connectionProvider, ISQLDialect dialect, QueueName queueName,
IQueueListener listener, QueueOptions options = default(QueueOptions))
{
if (connectionProvider == null) throw new ArgumentNullException("connectionProvider");
if (dialect == null) throw new ArgumentNullException("dialect");
if (queueName == null) throw new ArgumentNullException("queueName");
if (listener == null) throw new ArgumentNullException("listener");
_connectionProvider = connectionProvider;
_dialect = dialect;
_queueName = queueName;
_listener = listener;
_autoAcknowledge = options.AutoAcknowledge;
_maxAttempts = options.MaxAttempts <= 0 ? 10 : options.MaxAttempts;
_retryDelay = options.RetryDelay < TimeSpan.Zero ? TimeSpan.Zero : options.RetryDelay;
var concurrencyLimit = options.ConcurrencyLimit <= 0
? QueueOptions.DefaultConcurrencyLimit
: options.ConcurrencyLimit;
_concurrentMessageProcessingSlot = new SemaphoreSlim(concurrencyLimit);
_cancellationTokenSource = new CancellationTokenSource();
_queuedMessages = new BufferBlock<SQLQueuedMessage>(new DataflowBlockOptions
{
CancellationToken = _cancellationTokenSource.Token
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="connectionProvider">A <see cref="IDbConnection"/> to obtain a database connection</param>
/// <param name="tableName">Name of the table to store messages in</param>
/// <param name="inputQueueName">Name of the queue this transport is servicing</param>
/// <param name="rebusLoggerFactory">A <seealso cref="IRebusLoggerFactory"/> for building loggers</param>
/// <param name="asyncTaskFactory">A <seealso cref="IAsyncTaskFactory"/> for creating periodic tasks</param>
/// <param name="leaseInterval">Interval of time messages are leased for</param>
/// <param name="leaseTolerance">Buffer to allow lease overruns by</param>
/// <param name="leasedByFactory">Factory for generating a string which identifies who has leased a message (eg. A hostname)</param>
/// <param name="automaticLeaseRenewalInterval">If non-<c>null</c> messages will be automatically re-leased after this time period has elapsed</param>
public SqlServerLeaseTransport(
IDbConnectionProvider connectionProvider,
string tableName,
string inputQueueName,
IRebusLoggerFactory rebusLoggerFactory,
IAsyncTaskFactory asyncTaskFactory,
TimeSpan leaseInterval,
TimeSpan?leaseTolerance,
Func <string> leasedByFactory,
TimeSpan?automaticLeaseRenewalInterval = null
) : base(connectionProvider, tableName, inputQueueName, rebusLoggerFactory, asyncTaskFactory)
{
_leasedByFactory = leasedByFactory;
_leaseIntervalMilliseconds = (long)Math.Ceiling(leaseInterval.TotalMilliseconds);
_leaseToleranceMilliseconds = (long)Math.Ceiling((leaseTolerance ?? TimeSpan.FromSeconds(15)).TotalMilliseconds);
if (automaticLeaseRenewalInterval.HasValue == false)
{
_automaticLeaseRenewal = false;
}
else
{
_automaticLeaseRenewal = true;
_automaticLeaseRenewalIntervalMilliseconds = (long)Math.Ceiling(automaticLeaseRenewalInterval.Value.TotalMilliseconds);
}
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE subs ADD COLUMN created_by uuid NULL;");
});
}
protected DataTestBase()
: base(new Skimur.App.Registrar(),
new Skimur.App.Handlers.Registrar(),
new Skimur.Markdown.Registrar(),
new Skimur.Scraper.Registrar())
{
Monitor.Enter(_sync);
_conn = _serviceProvider.GetService<IDbConnectionProvider>();
// recreate the entire postgres database
_conn.Perform(conn =>
{
conn.ExecuteSql("drop schema public cascade;create schema public;");
});
// recreate the entire cassandra keyspace
using (var cassandraCluster = Cluster.Builder()
.AddContactPoint(_serviceProvider.GetService<ICassandraConnectionStringProvider>().ConnectionString)
.Build())
{
using (var cassandraConnection = cassandraCluster.Connect())
{
cassandraConnection.DeleteKeyspaceIfExists("skimur");
cassandraConnection.CreateKeyspace("skimur");
}
}
Cassandra.Migrations.Migrations.Run(_serviceProvider);
Postgres.Migrations.Migrations.Run(_serviceProvider);
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN number_of_comments integer NOT NULL DEFAULT 0;");
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="connectionProvider">A <see cref="IDbConnection"/> to obtain a database connection</param>
/// <param name="lockTableName">Name of the queue this transport is servicing</param>
/// <param name="rebusLoggerFactory">A <seealso cref="IRebusLoggerFactory"/> for building loggers</param>
/// <param name="asyncTaskFactory">A <seealso cref="IAsyncTaskFactory"/> for creating periodic tasks</param>
/// <param name="rebusTime">A <seealso cref="IRebusTime"/> to provide the current time</param>
/// <param name="options">Additional options</param>
public MySqlExclusiveAccessLock(
IDbConnectionProvider connectionProvider,
string lockTableName,
IRebusLoggerFactory rebusLoggerFactory,
IAsyncTaskFactory asyncTaskFactory,
IRebusTime rebusTime,
MySqlExclusiveAccessLockOptions options)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime));
_connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_lockTableName = lockTableName != null?TableName.Parse(lockTableName) : null;
_log = rebusLoggerFactory.GetLogger <MySqlExclusiveAccessLock>();
_lockExpirationTimeout = options.LockExpirationTimeout ?? DefaultLockExpirationTimeout;
var cleanupInterval = options.ExpiredLocksCleanupInterval ?? DefaultExpiredLocksCleanupInterval;
var intervalSeconds = (int)cleanupInterval.TotalSeconds;
_expiredLocksCleanupTask = asyncTaskFactory.Create("ExpiredLocksCleanup", PerformExpiredLocksCleanupCycle, intervalSeconds: intervalSeconds);
_autoDeleteTable = options.AutoDeleteTable;
}
/// <summary>
/// Constructs the saga storage, using the specified connection provider and tables for persistence.
/// </summary>
public SqlServerSagaStorage(IDbConnectionProvider connectionProvider, string dataTableName, string indexTableName, IRebusLoggerFactory rebusLoggerFactory)
{
_log = rebusLoggerFactory.GetCurrentClassLogger();
_connectionProvider = connectionProvider;
_dataTableName = dataTableName;
_indexTableName = indexTableName;
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN thumb text NULL;");
});
}
public HomeModule(IDbConnectionProvider connectionProvider)
{
Get["/"] = _ =>
{
using (var conn = connectionProvider.GetConnection())
{
return(conn.Query <User>("select * from users"));
}
};
Get["/complicatedquery"] = _ =>
{
//What if we need to build up a big view model and need to execute a couple of queries?
//We could create some methods in this class and separate those queries out and build the view model up.
//What if we have 3-4 endpoints that need to do the same? We then have a large module class which in my
//opinion should be anaemic and have its single responsibility be for return http specific things.
return(200);
};
Post["/"] = _ =>
{
//So we could inject a dbconnection and return data from this module but I dont like that due to the comments above.
//What about POST/PUT? We need somewhere to do business logic etc which I think should be a service or command layer
return(201);
};
}
public SQLSubscriptionTrackingService(IDbConnectionProvider connectionProvider, ISQLDialect dialect)
{
if (connectionProvider == null) throw new ArgumentNullException("connectionProvider");
if (dialect == null) throw new ArgumentNullException("dialect");
_connectionProvider = connectionProvider;
_dialect = dialect;
}
public DbProvider(string databaseName, SqliteSettings settings)
{
DatabaseName = databaseName;
_enforceForeignKeys = settings.EnforceForeignKeys;
_sqliteDatabasePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), databaseName);
_connectionProvider = new DbConnectionProvider(_sqliteDatabasePath, settings);
}
/// <summary>
/// Constructs the storage using the specified connection provider and table to store its subscriptions. If the subscription
/// storage is shared by all subscribers and publishers, the <paramref name="isCentralized"/> parameter can be set to true
/// in order to subscribe/unsubscribe directly instead of sending subscription/unsubscription requests
/// </summary>
public SqlServerSubscriptionStorage(IDbConnectionProvider connectionProvider, string tableName, bool isCentralized, IRebusLoggerFactory rebusLoggerFactory)
{
IsCentralized = isCentralized;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_connectionProvider = connectionProvider;
_tableName = tableName;
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN number_of_comments integer NOT NULL DEFAULT 0;");
});
}
public CaseService(IDbConnectionProvider connectionProvider, IEventBus eventBus
, ISmtpProvider smtpProvider)
: base(connectionProvider)
{
_eventBus = eventBus;
_smtpProvider = smtpProvider;
}
public SQLSubscriptionTrackingService(ConnectionStringSettings connectionStringSettings,
ISQLDialect dialect = null)
{
if (connectionStringSettings == null) throw new ArgumentNullException("connectionStringSettings");
_connectionProvider = new DefaultConnectionProvider(connectionStringSettings);
_dialect = dialect ?? connectionStringSettings.GetSQLDialect();
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN sticky boolean NOT NULL DEFAULT false;");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN number_of_reports integer NOT NULL DEFAULT 0;");
x.Execute("ALTER TABLE comments ADD COLUMN number_of_reports integer NOT NULL DEFAULT 0;");
x.Execute("ALTER TABLE posts ADD COLUMN ignore_reports boolean NOT NULL DEFAULT false;");
x.Execute("ALTER TABLE comments ADD COLUMN ignore_reports boolean NOT NULL DEFAULT false;");
x.Execute(@"
CREATE TABLE reported_comments
(
id uuid NOT NULL,
created_date timestamp with time zone NOT NULL,
reported_by uuid NOT NULL,
reason text,
comment uuid,
CONSTRAINT reported_comments_pkey PRIMARY KEY (id)
);");
x.Execute(@"
CREATE TABLE reported_posts
(
id uuid NOT NULL,
created_date timestamp with time zone NOT NULL,
reported_by uuid NOT NULL,
reason text,
post uuid,
CONSTRAINT reported_posts_pkey PRIMARY KEY (id)
);");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute(@"
CREATE TABLE messages
(
id uuid NOT NULL,
date_created timestamp with time zone NOT NULL,
type integer,
parent_id uuid,
first_message uuid,
deleted boolean,
author_id uuid NOT NULL,
author_ip text,
is_new boolean,
to_user uuid,
to_sub uuid,
from_sub uuid,
subject text,
body text,
body_formatted text,
CONSTRAINT messages_pkey PRIMARY KEY (id)
);");
x.Execute(@"
CREATE INDEX messages_datecreated_index ON messages(date_created);
");
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="connectionProvider">A <see cref="IDbConnection"/> to obtain a database connection</param>
/// <param name="inputQueueName">Name of the queue this transport is servicing</param>
/// <param name="rebusLoggerFactory">A <seealso cref="IRebusLoggerFactory"/> for building loggers</param>
/// <param name="asyncTaskFactory">A <seealso cref="IAsyncTaskFactory"/> for creating periodic tasks</param>
/// <param name="rebusTime">A <seealso cref="IRebusTime"/> to provide the current time</param>
/// <param name="leaseInterval">Interval of time messages are leased for</param>
/// <param name="leaseTolerance">Buffer to allow lease overruns by</param>
/// <param name="leasedByFactory">Factory for generating a string which identifies who has leased a message (eg. A hostname)</param>
/// <param name="options">Additional options</param>
public SqlServerLeaseTransport(
IDbConnectionProvider connectionProvider,
string inputQueueName,
IRebusLoggerFactory rebusLoggerFactory,
IAsyncTaskFactory asyncTaskFactory,
IRebusTime rebusTime,
TimeSpan leaseInterval,
TimeSpan?leaseTolerance,
Func <string> leasedByFactory,
SqlServerLeaseTransportOptions options
) : base(connectionProvider, inputQueueName, rebusLoggerFactory, asyncTaskFactory, rebusTime, options)
{
_leasedByFactory = leasedByFactory;
_leaseInterval = leaseInterval;
_leaseTolerance = leaseTolerance ?? TimeSpan.FromSeconds(15);
var automaticLeaseRenewalInterval = options.LeaseAutoRenewInterval;
if (!automaticLeaseRenewalInterval.HasValue)
{
_automaticLeaseRenewal = false;
}
else
{
_automaticLeaseRenewal = true;
_automaticLeaseRenewalInterval = automaticLeaseRenewalInterval.Value;
}
}
/// <summary>
/// Constructs the storage using the specified connection provider and table to store its subscriptions. If the subscription
/// storage is shared by all subscribers and publishers, the <paramref name="isCentralized"/> parameter can be set to true
/// in order to subscribe/unsubscribe directly instead of sending subscription/unsubscription requests
/// </summary>
public SqlServerSubscriptionStorage(IDbConnectionProvider connectionProvider, string tableName, bool isCentralized)
{
IsCentralized = isCentralized;
_connectionProvider = connectionProvider;
_tableName = tableName;
}
public PeriodicInspectionService(IDbConnectionProvider connectionProvider, IEventBus eventBus,
ISettingsService settingsService)
: base(connectionProvider)
{
_eventBus = eventBus;
_settingsService = settingsService;
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN thumb text NULL;");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN deleted boolean NOT NULL default false;");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE users ADD COLUMN is_admin boolean NOT NULL default false;");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN number_of_reports integer NOT NULL DEFAULT 0;");
x.Execute("ALTER TABLE comments ADD COLUMN number_of_reports integer NOT NULL DEFAULT 0;");
x.Execute("ALTER TABLE posts ADD COLUMN ignore_reports boolean NOT NULL DEFAULT false;");
x.Execute("ALTER TABLE comments ADD COLUMN ignore_reports boolean NOT NULL DEFAULT false;");
x.Execute(@"
CREATE TABLE reported_comments
(
id uuid NOT NULL,
created_date timestamp with time zone NOT NULL,
reported_by uuid NOT NULL,
reason text,
comment uuid,
CONSTRAINT reported_comments_pkey PRIMARY KEY (id)
);");
x.Execute(@"
CREATE TABLE reported_posts
(
id uuid NOT NULL,
created_date timestamp with time zone NOT NULL,
reported_by uuid NOT NULL,
reason text,
post uuid,
CONSTRAINT reported_posts_pkey PRIMARY KEY (id)
);");
});
}
public CommentDao(IDbConnectionProvider conn,
ICommentTreeBuilder commentTreeBuilder)
: base(conn)
{
_conn = conn;
_commentTreeBuilder = commentTreeBuilder;
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE subs ADD COLUMN created_by uuid NULL;");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
CreateFunctions(x);
CreateTables(x);
});
}
public QueryResultContext(ISqlExcuter excutor, DbDataReader reader, DbConnection connection, IDbConnectionProvider provider)
{
Reader = reader;
ResultTable = QueryResultTableMetaData.Create(reader);
ConnectionProvider = provider;
Connection = connection;
Excutor = excutor;
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE messages ADD COLUMN post uuid NULL;");
x.Execute("ALTER TABLE messages ADD COLUMN comment uuid NULL;");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE messages ADD COLUMN post uuid NULL;");
x.Execute("ALTER TABLE messages ADD COLUMN comment uuid NULL;");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE subs ADD COLUMN in_all boolean NOT NULL default TRUE;");
x.Execute("ALTER TABLE posts ADD COLUMN in_all boolean NOT NULL default TRUE;");
});
}
/// <summary>
/// Initializes a new instance of the <see cref="PaymentTermRepository" /> class.
/// </summary>
/// <param name="provider">The provider.</param>
public PaymentTermRepository(IDbConnectionProvider provider)
{
this._provider = provider;
if (this._provider == null)
{
throw new ArgumentNullException("PaymentTermRepository.IDbConnectionProvider");
}
}
/// <summary>
/// Initializes a new <see cref="SQLMessageJournal"/> with the specified connection
/// provider and dialect
/// </summary>
/// <param name="connectionProvider">The connection provider to use to connect to
/// the SQL database</param>
/// <param name="commandBuilders">A set of commands that conform to the SQL syntax
/// required by the underlying connection provider</param>
/// <param name="diagnosticService">(Optional) The service through which diagnostic events
/// are reported and processed</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="connectionProvider"/>
/// or <paramref name="commandBuilders"/> is <c>null</c></exception>
public SQLMessageJournal(IDbConnectionProvider connectionProvider,
IMessageJournalingCommandBuilders commandBuilders,
IDiagnosticService diagnosticService = null)
{
DiagnosticService = diagnosticService ?? Diagnostics.DiagnosticService.DefaultInstance;
ConnectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
CommandBuilders = commandBuilders ?? throw new ArgumentNullException(nameof(commandBuilders));
}
public Versioner(IDbConnectionProvider connectionProvider, ILogger<Version> logger)
{
_conn = connectionProvider;
_logger = logger;
_logger.Debug("Create mapper and table instances");
_conn.Perform(conn => conn.CreateTableIfNotExists<DatabaseVersion>());
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN nsfw boolean NOT NULL default false;");
x.Execute("ALTER TABLE subs ADD COLUMN nsfw boolean NOT NULL default false;");
});
}
/// <summary>
/// Initializes a new instance of the <see cref="CurrencyRepository" /> class.
/// </summary>
/// <param name="provider">The provider.</param>
public CurrencyRepository(IDbConnectionProvider provider)
{
this._provider = provider;
if (this._provider == null)
{
throw new ArgumentNullException("CurrencyRepository.IDbConnectionProvider");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EmailServerRepository" /> class.
/// </summary>
/// <param name="provider">The provider.</param>
public EmailServerRepository(IDbConnectionProvider provider)
{
this._provider = provider;
if (this._provider == null)
{
throw new ArgumentNullException("EmailServerRepository.IDbConnectionProvider");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlDbPingHealthCheckStrategy"/> class.
/// </summary>
/// <param name="dbConnectionProvider">The database connection provider.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <seealso cref="IDbConnectionProvider" />
public SqlDbPingHealthCheckStrategy(IDbConnectionProvider dbConnectionProvider)
{
if (dbConnectionProvider == null)
{
throw new ArgumentNullException(nameof(dbConnectionProvider));
}
_dbConnectionProvider = dbConnectionProvider;
}
/// <summary>
/// Initializes a new <see cref="SQLSubscriptionTrackingService"/> with the specified connection
/// provider and dialect
/// </summary>
/// <param name="connectionProvider">The connection provider to use to connect to
/// the SQL database</param>
/// <param name="commandBuilders">A collection of factories capable of
/// generating database commands for manipulating subscriptions that conform to the SQL
/// syntax required by the underlying connection provider</param>
/// <param name="diagnosticService">(Optional) The service through which diagnostic events
/// are reported and processed</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="connectionProvider"/>
/// or <paramref name="commandBuilders"/> is <c>null</c></exception>
public SQLSubscriptionTrackingService(IDbConnectionProvider connectionProvider,
ISubscriptionTrackingCommandBuilders commandBuilders,
IDiagnosticService diagnosticService = null)
{
DiagnosticService = diagnosticService ?? Diagnostics.DiagnosticService.DefaultInstance;
ConnectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_commandBuilders = commandBuilders ?? throw new ArgumentNullException(nameof(commandBuilders));
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
CreateFunctions(x);
CreateTables(x);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ActivityLogRepository" /> class.
/// </summary>
/// <param name="provider">The provider.</param>
public ActivityLogRepository(IDbConnectionProvider provider)
{
this._provider = provider;
if (this._provider == null)
{
throw new ArgumentNullException("ActivityLogRepository.IDbConnectionProvider");
}
}
/// <summary>
/// Creates the options with the given <paramref name="connectionProvider"/>
/// </summary>
public SqlServerSagaSnapshotStorageOptions(IDbConnectionProvider connectionProvider)
{
if (connectionProvider == null)
{
throw new ArgumentNullException(nameof(connectionProvider));
}
ConnectionProviderFactory = context => connectionProvider;
}
/// <summary>
/// Creates the options with the given <paramref name="connectionProvider"/>
/// </summary>
public SqlServerTimeoutManagerOptions(IDbConnectionProvider connectionProvider)
{
if (connectionProvider == null)
{
throw new ArgumentNullException(nameof(connectionProvider));
}
ConnectionProviderFactory = context => connectionProvider;
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE sub_admins RENAME TO moderators");
// "1" is "All" permission
x.Execute("ALTER TABLE moderators ADD COLUMN permissions integer DEFAULT 1");
});
}
public IdentityService(IDbConnectionProvider connectionProvider, ICacheProvider cacheProvider,
ISmtpProvider smtpProvider, IEventBus eventBus)
: base(connectionProvider)
{
_cacheProvider = cacheProvider;
_smtpProvider = smtpProvider;
_eventBus = eventBus;
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE subs ADD COLUMN sidebar_text_formatted text NULL;");
x.Execute("ALTER TABLE subs ADD COLUMN submission_text text NULL;");
x.Execute("ALTER TABLE subs ADD COLUMN submission_text_formatted text NULL;");
});
}
public SqlDbContextObjectsProvider(IDbConnectionProvider dbConnectionProvider)
{
if (dbConnectionProvider == null)
{
throw new ArgumentNullException(nameof(dbConnectionProvider));
}
_dbConnectionProvider = dbConnectionProvider;
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE sub_admins RENAME TO moderators");
// "1" is "All" permission
x.Execute("ALTER TABLE moderators ADD COLUMN permissions integer DEFAULT 1");
});
}
public override void Execute(IDbConnectionProvider conn)
{
conn.Perform(x =>
{
x.Execute("ALTER TABLE posts ADD COLUMN verdict integer NOT NULL DEFAULT 0;");
x.Execute("ALTER TABLE posts ADD COLUMN approved_by uuid NULL;");
x.Execute("ALTER TABLE posts ADD COLUMN removed_by uuid NULL;");
x.Execute("ALTER TABLE posts ADD COLUMN verdict_message text NULL;");
});
}
/// <summary>
/// Creates the data storage
/// </summary>
public SqlServerDataBusStorage(IDbConnectionProvider connectionProvider, string tableName, bool ensureTableIsCreated, IRebusLoggerFactory rebusLoggerFactory)
{
if (connectionProvider == null) throw new ArgumentNullException(nameof(connectionProvider));
if (tableName == null) throw new ArgumentNullException(nameof(tableName));
if (rebusLoggerFactory == null) throw new ArgumentNullException(nameof(rebusLoggerFactory));
_connectionProvider = connectionProvider;
_tableName = tableName;
_ensureTableIsCreated = ensureTableIsCreated;
_log = rebusLoggerFactory.GetCurrentClassLogger();
}
public TrackableSetValueTest(IDbConnectionProvider dbConnectionProvider, ISqlProvider sqlProvider)
: base(useDuplicateCheck: true)
{
_db = dbConnectionProvider;
_mapper = new TrackableSetSqlMapper<int>(
sqlProvider,
nameof(TrackableSetValueTest),
new ColumnDefinition("Value", typeof(int)),
null);
_mapper.ResetTableAsync(_db.Connection).Wait();
}
/// <summary>
/// Constructs the transport with the given <see cref="IDbConnectionProvider"/>, using the specified <paramref name="tableName"/> to send/receive messages,
/// querying for messages with recipient = <paramref name="inputQueueName"/>
/// </summary>
public SqlServerTransport(IDbConnectionProvider connectionProvider, string tableName, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
_connectionProvider = connectionProvider;
_tableName = tableName;
_inputQueueName = inputQueueName;
_log = rebusLoggerFactory.GetCurrentClassLogger();
ExpiredMessagesCleanupInterval = DefaultExpiredMessagesCleanupInterval;
_expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, intervalSeconds: 60);
}
public bool Execute(IDbConnectionProvider conn, MigrationResources resources)
{
_logger.Debug("Initialize database versioner");
var versioner = new Versioner(conn, new Logger<Version>());
_logger.Debug("Initialize executor");
var executor = new Executor(conn, versioner, new Logger<Executor>());
_logger.Debug("Execute migrations");
return executor.Execute(resources);
}
/// <summary>
/// Constructs the saga storage, using the specified connection provider and tables for persistence.
/// </summary>
public SqlServerSagaStorage(IDbConnectionProvider connectionProvider, string dataTableName, string indexTableName, IRebusLoggerFactory rebusLoggerFactory)
{
if (connectionProvider == null) throw new ArgumentNullException(nameof(connectionProvider));
if (dataTableName == null) throw new ArgumentNullException(nameof(dataTableName));
if (indexTableName == null) throw new ArgumentNullException(nameof(indexTableName));
if (rebusLoggerFactory == null) throw new ArgumentNullException(nameof(rebusLoggerFactory));
_log = rebusLoggerFactory.GetCurrentClassLogger();
_connectionProvider = connectionProvider;
_dataTableName = dataTableName;
_indexTableName = indexTableName;
}
/// <summary>
/// Constructs the transport with the given <see cref="IDbConnectionProvider"/>, using the specified <paramref name="tableName"/> to send/receive messages,
/// querying for messages with recipient = <paramref name="inputQueueName"/>
/// </summary>
public SqlServerTransport(IDbConnectionProvider connectionProvider, string tableName, string inputQueueName)
{
_connectionProvider = connectionProvider;
_tableName = tableName;
_inputQueueName = inputQueueName;
ExpiredMessagesCleanupInterval = DefaultExpiredMessagesCleanupInterval;
_expiredMessagesCleanupTask = new AsyncTask("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle)
{
Interval = TimeSpan.FromMinutes(1)
};
}
/// <summary>
/// Constructs the transport with the given <see cref="IDbConnectionProvider"/>, using the specified <paramref name="tableName"/> to send/receive messages,
/// querying for messages with recipient = <paramref name="inputQueueName"/>
/// </summary>
public SqlServerTransport(IDbConnectionProvider connectionProvider, string tableName, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory)
{
_connectionProvider = connectionProvider;
_tableName = tableName;
_inputQueueName = inputQueueName;
_log = rebusLoggerFactory.GetCurrentClassLogger();
ExpiredMessagesCleanupInterval = DefaultExpiredMessagesCleanupInterval;
_expiredMessagesCleanupTask = new AsyncTask("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, rebusLoggerFactory)
{
Interval = TimeSpan.FromMinutes(1)
};
}
protected override void Setup()
{
base.Setup();
Cassandra.Migrations.Migrations.Run(_serviceProvider);
Postgres.Migrations.Migrations.Run(_serviceProvider);
_conn = _serviceProvider.GetService<IDbConnectionProvider>();
_conn.Perform(conn =>
{
conn.ExecuteProcedure(new ClearDatabaseFunction());
conn.ExecuteProcedure(new EnsureDefaultUserFunction());
});
}