public DatabaseAccessTests()
{
_conn = SQLitePortability.CreateConnection();
_conn.Open();
_db = new DatabaseAccess(_conn, new SQLiteDetails());
}
public DatabaseAccessTests()
{
_conn = SQLitePortability.CreateConnection();
_conn.Open();
_db = new DatabaseAccess(_conn, new SQLiteDetails());
}
public static void FixLongToDoubleUpgrade(IDatabaseDetails details, IDatabaseAccess db, string tableName, IDictionary <string, int> oldColumns, IDictionary <string, int> changedColumns, int longRank, int doubleRank, int safeRank)
{
var names = new List <string>(changedColumns.Keys);
var quotedTableName = details.QuoteName(tableName);
foreach (var name in names)
{
var oldRank = oldColumns[name];
var newRank = changedColumns[name];
if (oldRank != longRank || newRank != doubleRank)
{
continue;
}
var quotedName = details.QuoteName(name);
var min = db.Cell <long>(false, "SELECT MIN(" + quotedName + ") FROM " + quotedTableName);
var max = db.Cell <long>(false, "SELECT MAX(" + quotedName + ") FROM " + quotedTableName);
if (!min.IsInt53Range() || !max.IsInt53Range())
{
changedColumns[name] = safeRank;
}
}
}
public SendService(IDatabaseAccess databaseAccess)
{
_deliveryRepository = databaseAccess.Repository<Delivery>();
_sendGridMessage = new SendGridMessage();
_sendGridMessage.From = new MailAddress(ConfigurationManager.AppSettings["SendFrom"]);
_transport = new Web(ConfigurationManager.AppSettings["SendGridkey"]);
}
public MusicPageViewModel(IFolderDialogService folderDialogService, IDatabaseAccess db)
{
this.folderDialogService = folderDialogService;
this.db = db;
defaultTracks = this.db.ReadMusic().ToList();
Tracks = defaultTracks;
Albums = defaultTracks.ToAlbums().ToList();
downloadedTracks = DownloadedTrackAccess.Get();
OrderComboBoxItems = new ConditionsComboBoxItemList()
{
new OrderConditionsComboBoxItem("追加された日付", x => x.UploadedDate),
new OrderConditionsComboBoxItem("名前順", x => x.Title, x => x.Album),
new OrderConditionsComboBoxItem("リリース年", x => x.Date),
new OrderConditionsComboBoxItem("アーティスト", x => x.Artist, x => x.AlbumArtist),
};
SelectedOrderComboBoxItem = OrderComboBoxItems.First() as OrderConditionsComboBoxItem;
FilterComboBoxItems = new ConditionsComboBoxItemList()
{
new FilterConditionsComboBoxItem("すべて", x => true),
new FilterConditionsComboBoxItem("ダウンロード済み", x => downloadedTracks.Any(y => y.TrackId == x.ID)),
new FilterConditionsComboBoxItem("未ダウンロード", x => !downloadedTracks.Any(y => y.TrackId == x.ID)),
};
SelectedFilterComboBoxItem = FilterComboBoxItems.First() as FilterConditionsComboBoxItem;
}
public AdoNetCourseServices(ILogger <AdoNetCourseServices> logger, IDatabaseAccess db, IImagePersister imagePersister, IOptionsMonitor <CoursesOptions> coursesOptions)
{
this.imagePersister = imagePersister;
this.coursesOptions = coursesOptions;
this.logger = logger;
this.db = db;
}
public ApiKeyController(
IDatabaseAccess _database,
IApiKeyHashingService _hasher)
{
database = _database;
hasher = _hasher;
}
public StoreAnalyzedSentenceService(IDatabaseAccess databaseAccess, ILogger <StoreAnalyzedSentenceService> logger,
IPipeline pipeline)
{
_databaseAccess = databaseAccess;
_logger = logger;
_pipeline = pipeline;
}
public FinanceService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
ExaminationsQueryExpressionBuilder examinationQueryBuilder)
: base(databaseAccess, connectionSettings)
{
_examinationQueryBuilder = examinationQueryBuilder;
}
/// <summary>
/// Initialise a new instance of <see cref="ExaminationsDashboardService"/>.
/// </summary>
/// <param name="databaseAccess">Database Access.</param>
/// <param name="connectionSettings">Connection Settings.</param>
/// <param name="baseQueryBuilder">Base Query Builder.</param>
public ExaminationsDashboardService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
ExaminationsQueryExpressionBuilder baseQueryBuilder)
: base(databaseAccess, connectionSettings)
{
_baseQueryBuilder = baseQueryBuilder;
}
public UserInfoProvider(IUserStore userStore,
IDiscordAccess discordAccess,
IDatabaseAccess databaseAccess)
{
_userStore = userStore;
_discordAccess = discordAccess;
_databaseAccess = databaseAccess;
}
public void ExecInitCommands(IDatabaseAccess db)
{
_charset = db.Cell <string>(false, "SHOW CHARSET LIKE 'utf8mb4'") != null
? "utf8mb4"
: "utf8";
db.Exec("SET NAMES " + _charset);
}
/// <summary>
/// Initialise a new instance of <see cref="UserUpdateService"/>.
/// </summary>
/// <param name="databaseAccess">Database Access.</param>
/// <param name="connectionSettings">User Connection Settings.</param>
/// <param name="mapper">Mapper</param>
public UserUpdateService(
IDatabaseAccess databaseAccess,
IUserConnectionSettings connectionSettings,
IMapper mapper)
: base(databaseAccess, connectionSettings)
{
_mapper = mapper;
}
public BusinessLogic(IDatabaseAccess db, IPrinterModule pm)
{
this._db = db;
this._currentInvoice = null;
this.pm = pm;
this.currentCashDrawer = null;
this._isOrderStarted = false;
}
public ConfirmationOfScrutinyService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
IOptions <UrgencySettings> urgencySettings)
: base(databaseAccess, connectionSettings)
{
_urgencySettings = urgencySettings.Value;
}
/// <summary>
/// Initialise a new instance of <see cref="UpdateExaminationUrgencySortService"/>.
/// </summary>
/// <param name="databaseAccess">Database access.</param>
/// <param name="connectionSettings">Connection settings.</param>
/// <param name="urgencySettings">Urgency settings.</param>
public UpdateExaminationUrgencySortService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
IOptions <UrgencySettings> urgencySettings)
: base(databaseAccess, connectionSettings)
{
_urgencySettings = urgencySettings.Value;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors
public UserStore(IDatabaseAccess databaseAccess,
ILogger <IUserStore> logger)
{
_databaseAccess = databaseAccess;
_logger = logger;
_semaphore = new SemaphoreSlim(1, 1);
_store = new List <User>();
}
public DatabaseQuery(IDatabaseAccess owner)
{
_owner = owner;
_query = owner.QueryDef;
if (_query != null)
{
_query.ForReadOnly = true;
}
}
public MovieRepository()
{
_className = this.GetType().Name;
_databaseAccess = new DatabaseAccess();
_connection = _databaseAccess.GetConnection();
_connection.CreateTable <Movie>();
}
public AuthorizationRequired(
IAccessTokenHandler _accessTokenHandler,
IDatabaseAccess _database,
ICacheProvider _cache)
{
accessTokenhandler = _accessTokenHandler;
database = _database;
cache = _cache;
}
public RequiresAuth(
IAuthorizationService _authorization,
IDatabaseAccess _database,
IApiKeyHashingService _hasher)
{
authorization = _authorization;
database = _database;
hasher = _hasher;
}
public ImagesController(
IDatabaseAccess _database,
IStorageProvider _storage,
ICacheWrapper _cache)
{
database = _database;
storage = _storage;
cache = _cache;
}
public CloseCaseService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
IOptions <UrgencySettings> urgencySettings)
{
_connectionSettings = connectionSettings;
_databaseAccess = databaseAccess;
_urgencySettings = urgencySettings.Value;
}
/// <summary>
/// Import a given list of climate data into the database
/// </summary>
/// <param name="dataAccess">Database Access object (e.g. SqliteDataAccess)</param>
/// <param name="climateData">List of ClimateData objects</param>
private static void ImportClimateDataIntoDatabase(IDatabaseAccess dataAccess, List <ClimateData> climateData)
{
if (!dataAccess.ClimateDataDbExists())
{
dataAccess.CreateClimateDataDb();
}
dataAccess.SaveClimateData(climateData);
}
public LinksController(
IDatabaseAccess _database,
ICacheAccess _cache,
IPasswordHashingService _hasher)
{
database = _database;
cache = _cache;
hasher = _hasher;
}
public SaveOutstandingCaseItemsService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
IOptions <UrgencySettings> urgencySettings)
{
_connectionSettings = connectionSettings;
_databaseAccess = databaseAccess;
_urgencySettings = urgencySettings.Value;
}
/// <summary>
/// Initialise a new instance of <see cref="ExaminationsRetrievalService"/>.
/// </summary>
/// <param name="databaseAccess">Database Access.</param>
/// <param name="connectionSettings">Connection Settings.</param>
/// <param name="examinationQueryBuilder">Examination Query Builder.</param>
/// <param name="store">Cosmos Store for paging.</param>
public ExaminationsRetrievalService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
ExaminationsQueryExpressionBuilder examinationQueryBuilder,
ICosmosStore <Models.Examination> store)
: base(databaseAccess, connectionSettings)
{
_examinationQueryBuilder = examinationQueryBuilder;
_store = store;
}
/// <summary>
/// Create instance of class for selected file and register UserLogChanged
/// </summary>
/// <param name="dbAccess">Database Access object for working with database</param>
/// <param name="moduleItemType"></param>
/// <param name="moduleName"></param>
public AtomicItemManager(IDatabaseAccess dbAccess, Type moduleItemType, string moduleName)
{
this.dbAccess = dbAccess;
this.moduleName = moduleName;
this.moduleItemType = moduleItemType;
dbAccess.RegisterModule(moduleItemType, moduleName);
CustomSettings.UserLogChanged += CustomSettings_UserLogChanged;
}
public RecentPageViewModel(IDatabaseAccess db)
{
var log = DownloadedTrackAccess.Get();
DownloadedTracks = log.Join(db.ReadMusic(), l => l.TrackId, m => m.ID, (l, m) => new
{
DateTime = l.DownloadedDateTime,
Track = m
}).OrderByDescending(x => x.DateTime).Select(x => x.Track).ToList();
}
public static void CheckLongToDouble(IDatabaseAccess db, DatabaseStorage storage)
{
storage.EnterFluidMode();
var bigLong = Int64.MinValue + 12345;
var longID = storage.Store("foo", MakeRow("p", bigLong));
storage.Store("foo", MakeRow("p", Math.PI));
Assert.Equal(bigLong, db.Cell <long>(false, "select p from foo where id = {0}", longID));
}
public MailConfirmController(
IDatabaseAccess _database, ICacheProvider _cache, IMailService _mailService,
IConfiguration _config, IHasher _hasher)
{
database = _database;
cache = _cache;
mailService = _mailService;
hasher = _hasher;
publicAddress = _config.GetValue <string>("WebServer:PublicURL", null);
}
public PrivacyProvider(IDatabaseAccess databaseAccess)
{
_databaseAccess = databaseAccess;
_timer = new Timer
{
AutoReset = true,
Interval = 86_400_000 // 1 day
};
_timer.Elapsed += Timer_Elapsed;
}
public DatabaseStorage(IDatabaseDetails details, IDatabaseAccess db, IKeyAccess keys)
{
_details = details;
_db = db;
_keyAccess = keys;
TrimStrings = true;
ConvertEmptyStringToNull = true;
RecognizeIntegers = true;
_details.ExecInitCommands(_db);
}
public static void Initialize(IDatabaseAccess access)
{
DatabaseAccess = access;
Account = new Account();
Character = new Character();
Clan = new Clan();
Convoy = new Convoy();
Item = new Item();
Realmlist = new Realmlist();
Social = new Social();
Vehicle = new Vehicle();
}
public object ExecInsert(IDatabaseAccess db, string tableName, string autoIncrementName, IDictionary<string, object> data)
{
db.Exec(
CommonDatabaseDetails.FormatInsertCommand(this, tableName, data.Keys, defaultsExpr: "values ()"),
data.Values.ToArray()
);
if(String.IsNullOrEmpty(autoIncrementName))
return null;
// per-connection, http://stackoverflow.com/q/21185666
// robust to triggers, http://dba.stackexchange.com/a/25141
return db.Cell<object>(false, "select last_insert_id()");
}
public object ExecInsert(IDatabaseAccess db, string tableName, string autoIncrementName, IDictionary<string, object> data)
{
db.Exec(
CommonDatabaseDetails.FormatInsertCommand(this, tableName, data.Keys),
data.Values.ToArray()
);
if(String.IsNullOrEmpty(autoIncrementName))
return null;
// per-connection, robust to triggers
// http://www.sqlite.org/c3ref/last_insert_rowid.html
return db.Cell<long>(false, "select last_insert_rowid()");
}
public object ExecInsert(IDatabaseAccess db, string tableName, string autoIncrementName, IDictionary<string, object> data)
{
var hasAutoIncrement = !String.IsNullOrEmpty(autoIncrementName);
var valuesPrefix = hasAutoIncrement
? "output inserted." + QuoteName(autoIncrementName)
: null;
var sql = CommonDatabaseDetails.FormatInsertCommand(this, tableName, data.Keys, valuesPrefix: valuesPrefix);
var values = data.Values.ToArray();
if(hasAutoIncrement)
return db.Cell<object>(false, sql, values);
db.Exec(sql, values);
return null;
}
public static void CheckCustomRank_MissingColumn(IDatabaseAccess db, DatabaseStorage storage)
{
storage.EnterFluidMode();
var row = MakeRow("a", new object());
// Try create table
AssertCannotAddColumn(Record.Exception(delegate() {
storage.Store("foo1", row);
}));
storage.Store("foo2", MakeRow("b", 1));
// Try add column
AssertCannotAddColumn(Record.Exception(delegate() {
storage.Store("foo2", row);
}));
}
public static void CheckDateTimeQueries(IDatabaseAccess db, DatabaseStorage storage)
{
storage.EnterFluidMode();
var dateTime = SAMPLE_DATETIME;
var date = SAMPLE_DATETIME.Date;
storage.Store("foo", MakeRow("d", date));
storage.Store("foo", MakeRow("d", dateTime));
Assert.Equal(2, db.Cell<int>(false, "select count(*) from foo where d = {0} or d = {1}", date, dateTime));
db.Exec("delete from foo");
for(var i = -2; i <= 2; i++)
storage.Store("foo", MakeRow("d", date.AddDays(i)));
Assert.Equal(3, db.Cell<int>(false, "select count(*) from foo where d between {0} and {1}", date.AddDays(-1), date.AddDays(1)));
Assert.Equal(date, db.Cell<DateTime>(false, "select d from foo where d = {0}", date));
}
public DatabaseBeanFinderTests()
{
_conn = SQLitePortability.CreateConnection();
_conn.Open();
IDatabaseDetails details = new SQLiteDetails();
IDatabaseAccess db = new DatabaseAccess(_conn, details);
IKeyAccess keys = new KeyUtil();
IStorage storage = new DatabaseStorage(details, db, keys);
IBeanCrud crud = new BeanCrud(storage, db, keys);
IBeanFinder finder = new DatabaseBeanFinder(details, db, crud);
db.Exec("create table foo(x)");
db.Exec("insert into foo(x) values(1)");
db.Exec("insert into foo(x) values(2)");
db.Exec("insert into foo(x) values(3)");
_db = db;
_finder = finder;
}
public IDictionary<string, object>[] GetColumns(IDatabaseAccess db, string tableName)
{
return db.Rows(false, "pragma table_info(" + QuoteName(tableName) + ")");
}
public void UpdateSchema(IDatabaseAccess db, string tableName, string autoIncrementName, IDictionary<string, int> oldColumns, IDictionary<string, int> changedColumns, IDictionary<string, int> addedColumns)
{
if(changedColumns.Count > 0)
throw new NotSupportedException();
foreach(var entry in addedColumns)
db.Exec("alter table " + QuoteName(tableName) + " add " + QuoteName(entry.Key) + " " + GetSqlTypeFromRank(entry.Value));
}
public string[] GetTableNames(IDatabaseAccess db)
{
return db.Col<string>(false, "select name from sqlite_master where type = 'table' and name <> 'sqlite_sequence'");
}
public void ExecInitCommands(IDatabaseAccess db)
{
// set names?
}
public IDictionary<string, object>[] GetColumns(IDatabaseAccess db, string tableName)
{
return db.Rows(false, "select * from information_schema.columns where table_name = {0}", tableName);
}
public static void CheckSchemaReadingKeepsCache(IDatabaseAccess db, DatabaseStorage storage)
{
db.Exec("create table foo(bar int)");
db.Exec("insert into foo(bar) values(1)");
var queryCount = 0;
db.QueryExecuting += cmd => queryCount++;
db.Cell<int>(true, "Select * from foo");
storage.GetSchema();
var savedQueryCount = queryCount;
db.Cell<int>(true, "Select * from foo");
Assert.Equal(savedQueryCount, queryCount);
}
public UsersService(IDatabaseAccess databaseAccess)
{
_usersRepository = databaseAccess.Repository<User>();
}
public static void CheckReadUncommitted(IDatabaseAccess db1, IDatabaseAccess db2)
{
db1.Exec("create table foo(f text)");
db1.Exec("insert into foo(f) values('initial')");
db1.Transaction(delegate() {
db1.Exec("update foo set f='dirty'");
db2.TransactionIsolation = IsolationLevel.ReadUncommitted;
db2.Transaction(delegate() {
Assert.Equal("dirty", db2.Cell<string>(false, "select f from foo"));
return true;
});
return true;
});
}
public static void CheckGuidQuery(IDatabaseAccess db, DatabaseStorage storage)
{
storage.EnterFluidMode();
storage.Store("foo", MakeRow("g", SAMPLE_GUID));
Assert.Equal(SAMPLE_GUID, db.Cell<Guid>(false, "select g from foo where g = {0}", SAMPLE_GUID));
}
public RoundtripChecker(IDatabaseAccess db, DatabaseStorage storage)
{
_db = db;
_storage = storage;
}
public void ExecInitCommands(IDatabaseAccess db)
{
}
public string[] GetTableNames(IDatabaseAccess db)
{
return db.Col<string>(false, "select name from sys.objects where type='U'");
}
public IDictionary<string, object>[] GetColumns(IDatabaseAccess db, string tableName)
{
return db.Rows(false, "select name, system_type_id, max_length, is_nullable, object_definition(default_object_id) [default] from sys.columns where object_id = object_id({0})", tableName);
}
public IDictionary<string, object>[] GetColumns(IDatabaseAccess db, string tableName)
{
return db.Rows(false, "show columns from " + QuoteName(tableName));
}
public void UpdateSchema(IDatabaseAccess db, string tableName, string autoIncrementName, IDictionary<string, int> oldColumns, IDictionary<string, int> changedColumns, IDictionary<string, int> addedColumns)
{
CommonDatabaseDetails.FixLongToDoubleUpgrade(this, db, tableName, oldColumns, changedColumns, RANK_INT64, RANK_DOUBLE, RANK_TEXT_32);
tableName = QuoteName(tableName);
foreach(var entry in changedColumns)
db.Exec(String.Format("alter table {0} alter column {1} {2}", tableName, QuoteName(entry.Key), GetSqlTypeFromRank(entry.Value)));
foreach(var entry in addedColumns)
db.Exec(String.Format("alter table {0} add {1} {2}", tableName, QuoteName(entry.Key), GetSqlTypeFromRank(entry.Value)));
}
public string[] GetTableNames(IDatabaseAccess db)
{
return db.Col<string>(false, "show tables");
}
public void UpdateSchema(IDatabaseAccess db, string tableName, string autoIncrementName, IDictionary<string, int> oldColumns, IDictionary<string, int> changedColumns, IDictionary<string, int> addedColumns)
{
var operations = new List<string>();
CommonDatabaseDetails.FixLongToDoubleUpgrade(this, db, tableName, oldColumns, changedColumns, RANK_INT64, RANK_DOUBLE, RANK_TEXT_36);
foreach(var entry in changedColumns)
operations.Add(String.Format("change {0} {0} {1}", QuoteName(entry.Key), GetSqlTypeFromRank(entry.Value)));
foreach(var entry in addedColumns)
operations.Add(String.Format("add {0} {1}", QuoteName(entry.Key), GetSqlTypeFromRank(entry.Value)));
db.Exec("alter table " + QuoteName(tableName) + " " + String.Join(", ", operations));
}
public void ExecInitCommands(IDatabaseAccess db)
{
_charset = db.Cell<string>(false, "show charset like 'utf8mb4'") != null ? "utf8mb4" : "utf8";
db.Exec("set names " + _charset);
}
public string[] GetTableNames(IDatabaseAccess db)
{
return db.Col<string>(false, "select table_name from information_schema.tables where table_schema = 'public'");
}
public static void CheckLongToDouble(IDatabaseAccess db, DatabaseStorage storage)
{
storage.EnterFluidMode();
var bigLong = Int64.MinValue + 12345;
var longID = storage.Store("foo", MakeRow("p", bigLong));
storage.Store("foo", MakeRow("p", Math.PI));
Assert.Equal(bigLong, db.Cell<long>(false, "select p from foo where id = {0}", longID));
}
