protected IEnumerable <(Guid Id, string Name, DateTime Date)> GetMiaTypes(bool useBackupTable = false)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
using (ITransaction transaction = database.BeginTransaction())
{
List <(Guid Id, string Name, DateTime Date)> miams = new List <(Guid Id, string Name, DateTime Date)>();
int idIndex;
int nameIndex;
int dateIndex;
IDbCommand command;
if (useBackupTable)
{
command = SelectAllBackupMediaItemAspectMetadataNameAndCreationDatesCommand(transaction, out idIndex, out nameIndex, out dateIndex);
}
else
{
command = MediaLibrary_SubSchema.SelectAllMediaItemAspectMetadataNameAndCreationDatesCommand(transaction, out idIndex, out nameIndex, out dateIndex);
}
using (command)
using (IDataReader reader = command.ExecuteReader())
{
ICollection <string> result = new List <string>();
while (reader.Read())
{
miams.Add((reader.GetGuid(idIndex), reader.GetString(nameIndex), reader.GetDateTime(dateIndex)));
}
}
return(miams);
}
}
public void DeleteSubSchema(string subSchemaName, int currentVersionMajor, int currentVersionMinor, string deleteScriptFilePath)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
using (ITransaction transaction = database.BeginTransaction(IsolationLevel.Serializable))
{
int versionMajor;
int versionMinor;
bool schemaPresent = GetSubSchemaVersion(subSchemaName, out versionMajor, out versionMinor);
if (!schemaPresent)
{
return;
}
if (currentVersionMajor == versionMajor && currentVersionMinor == versionMinor)
{
using (TextReader reader = new SqlScriptPreprocessor(deleteScriptFilePath))
ExecuteBatch(transaction, new InstructionList(reader));
}
else
{
throw new ArgumentException(string.Format("The current version of sub schema '{0}' is {1}.{2}, but the schema deletion script works for version {3}.{4}",
subSchemaName, versionMajor, versionMinor, currentVersionMajor, currentVersionMajor));
}
using (IDbCommand command = MediaPortal_Basis_Schema.DeleteSubSchemaCommand(transaction, subSchemaName))
command.ExecuteNonQuery();
transaction.Commit();
}
}
protected ICollection <UserProfile> GetProfiles(Guid?profileId, string name)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
int profileIdIndex;
int nameIndex;
using (IDbCommand command = UserProfileDataManagement_SubSchema.SelectUserProfilesCommand(transaction, profileId, name,
out profileIdIndex, out nameIndex))
{
ICollection <UserProfile> result = new List <UserProfile>();
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
Guid profileId_ = database.ReadDBValue <Guid>(reader, profileIdIndex);
string name_ = database.ReadDBValue <string>(reader, nameIndex);
result.Add(new UserProfile(profileId_, name_));
}
}
return(result);
}
}
finally
{
transaction.Dispose();
}
}
public async Task <Guid> CreateProfileAsync(string profileName)
{
//Profile might already exist.
var result = await GetProfileByNameAsync(profileName);
if (result.Success)
{
return(result.Result.ProfileId);
}
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
Guid profileId = Guid.NewGuid();
try
{
using (IDbCommand command = UserProfileDataManagement_SubSchema.CreateUserProfileCommand(transaction, profileId, profileName))
command.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("UserProfileDataManagement: Error creating user profile '{0}')", e, profileName);
transaction.Rollback();
throw;
}
return(profileId);
}
public Task <bool> SetUserMediaItemDataAsync(Guid profileId, Guid mediaItemId, string key, string data)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
bool result;
using (IDbCommand command = UserProfileDataManagement_SubSchema.DeleteUserMediaItemDataCommand(transaction, profileId, mediaItemId, key))
command.ExecuteNonQuery();
// Allow "delete only", if new data is null. This is used to delete no longer required data.
if (!string.IsNullOrEmpty(data))
{
using (IDbCommand command = UserProfileDataManagement_SubSchema.CreateUserMediaItemDataCommand(transaction, profileId, mediaItemId, key, data))
result = command.ExecuteNonQuery() > 0;
}
else
{
result = true;
}
transaction.Commit();
return(Task.FromResult(result));
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("UserProfileDataManagement: Error setting media item data '{0}' for media item '{1}' in profile '{2}'", e, key, mediaItemId, profileId);
transaction.Rollback();
throw;
}
}
public bool GetUserAdditionalData(Guid profileId, string key, out string data)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
int dataIndex;
using (IDbCommand command = UserProfileDataManagement_SubSchema.SelectUserAdditionalDataCommand(transaction, profileId,
key, out dataIndex))
{
using (IDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
data = database.ReadDBValue <string>(reader, dataIndex);
return(true);
}
}
}
data = null;
return(false);
}
finally
{
transaction.Dispose();
}
}
public void AttachClient(string clientSystemId)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
using (IDbCommand command = ClientManager_SubSchema.InsertAttachedClientCommand(transaction, clientSystemId, null, null))
command.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("ClientManager: Error attaching client '{0}'", e, clientSystemId);
transaction.Rollback();
throw;
}
ServiceRegistration.Get <ILogger>().Info("ClientManager: Client with system ID '{0}' attached", clientSystemId);
// Establish the UPnP connection to the client, if available in the network
IDictionary <string, MPClientMetadata> attachedClients = ReadAttachedClientsFromDB();
lock (_syncObj)
_attachedClients = attachedClients;
_controlPoint.AddAttachedClient(clientSystemId);
ClientManagerMessaging.SendClientAttachmentChangeMessage(ClientManagerMessaging.MessageType.ClientAttached, clientSystemId);
}
public void DetachClientAndRemoveShares(string clientSystemId)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
using (IDbCommand command = ClientManager_SubSchema.DeleteAttachedClientCommand(transaction, clientSystemId))
command.ExecuteNonQuery();
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>();
mediaLibrary.DeleteMediaItemOrPath(clientSystemId, null, true);
mediaLibrary.RemoveSharesOfSystem(clientSystemId);
transaction.Commit();
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("ClientManager: Error detaching client '{0}'", e, clientSystemId);
transaction.Rollback();
throw;
}
ServiceRegistration.Get <ILogger>().Info("ClientManager: Client with system ID '{0}' detached", clientSystemId);
// Last action: Remove the client from the collection of attached clients and disconnect the client connection, if connected
_attachedClients = ReadAttachedClientsFromDB();
_controlPoint.RemoveAttachedClient(clientSystemId);
ClientManagerMessaging.SendClientAttachmentChangeMessage(ClientManagerMessaging.MessageType.ClientDetached, clientSystemId);
}
public Task <AsyncResult <string> > GetUserAdditionalDataAsync(Guid profileId, string key, int dataNo = 0)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
int dataIndex;
using (IDbCommand command = UserProfileDataManagement_SubSchema.SelectUserAdditionalDataCommand(transaction, profileId,
key, dataNo, out dataIndex))
{
using (IDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
var data = database.ReadDBValue <string>(reader, dataIndex);
return(Task.FromResult(new AsyncResult <string>(true, data)));
}
}
}
return(Task.FromResult(new AsyncResult <string>(false, null)));
}
finally
{
transaction.Dispose();
}
}
/// <summary>
/// Returns a dictionary which maps the system ids of all attached clients to their last hostname.
/// </summary>
/// <returns>Dictionary with system ids mapped to host names.</returns>
protected IDictionary <string, MPClientMetadata> ReadAttachedClientsFromDB()
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
int systemIdIndex;
int lastHostNameIndex;
int lastClientNameIndex;
IDictionary <string, MPClientMetadata> result = new Dictionary <string, MPClientMetadata>();
using (IDbCommand command = ClientManager_SubSchema.SelectAttachedClientsCommand(transaction, out systemIdIndex,
out lastHostNameIndex, out lastClientNameIndex))
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
string clientSystemId = database.ReadDBValue <string>(reader, systemIdIndex);
string lastClientHostName = database.ReadDBValue <string>(reader, lastHostNameIndex);
SystemName lastHostName = lastClientHostName == null ? null : new SystemName(lastClientHostName);
string lastClientName = database.ReadDBValue <string>(reader, lastClientNameIndex);
result.Add(clientSystemId, new MPClientMetadata(clientSystemId, lastHostName, lastClientName));
}
}
return(result);
}
finally
{
transaction.Dispose();
}
}
private static ICollection <Share> GetMediaSources(ISQLDatabase database)
{
IList <Share> sources = new List <Share>();
ITransaction transaction = database.BeginTransaction();
IDbCommand sourcesCommand = transaction.CreateCommand();
sourcesCommand.CommandText = "select share_id,base_resource_path,name from shares s";
IDataReader sourcesReader = sourcesCommand.ExecuteReader();
while (sourcesReader.Read())
{
Guid sourceId = sourcesReader.GetGuid(sourcesReader.GetOrdinal("share_id"));
ResourcePath resourcePath = ResourcePath.Deserialize(sourcesReader.GetString(sourcesReader.GetOrdinal("base_resource_path")));
IList <string> categories = new List <string>();
IDbCommand categoriesCommand = transaction.CreateCommand();
categoriesCommand.CommandText = "select categoryname from shares_categories where share_id=@share_id";
database.AddParameter(categoriesCommand, "share_id", sourceId, typeof(Guid));
IDataReader categoriesReader = categoriesCommand.ExecuteReader();
while (categoriesReader.Read())
{
categories.Add(categoriesReader.GetString(categoriesReader.GetOrdinal("categoryname")));
}
categoriesReader.Close();
string name = sourcesReader.GetString(sourcesReader.GetOrdinal("name"));
sources.Add(new Share(sourceId, null, resourcePath, name, true, categories));
}
sourcesReader.Close();
return(sources);
}
public Guid CreateProfile(string profileName)
{
//Profile might already exist.
UserProfile existingProfile;
if (GetProfileByName(profileName, out existingProfile))
{
return(existingProfile.ProfileId);
}
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
Guid profileId = Guid.NewGuid();
try
{
using (IDbCommand command = UserProfileDataManagement_SubSchema.CreateUserProfileCommand(transaction, profileId, profileName))
command.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("UserProfileDataManagement: Error creating user profile '{0}')", e, profileName);
transaction.Rollback();
throw;
}
return(profileId);
}
public bool GetSubSchemaVersion(string subSchemaName, out int versionMajor, out int versionMinor)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
versionMajor = 0;
versionMinor = 0;
int versionMajorParameterIndex;
int versionMinorParameterIndex;
using (ITransaction transaction = database.BeginTransaction())
{
using (IDbCommand command = MediaPortal_Basis_Schema.SelectVersionBySubschemaCommand(transaction, subSchemaName,
out versionMajorParameterIndex, out versionMinorParameterIndex))
using (IDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow))
{
if (reader.Read())
{
// Versions are marked NOT NULL, so it is safe not to check for DBNull
versionMajor = reader.GetInt32(versionMajorParameterIndex);
versionMinor = reader.GetInt32(versionMinorParameterIndex);
return(true);
}
return(false);
}
}
}
public int Execute()
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
using (IDbCommand command = transaction.CreateCommand())
{
string countAlias;
string statementStr;
IList <BindVar> bindVars;
MainQueryBuilder builder = new MainQueryBuilder(_miaManagement, new QueryAttribute[] {}, null,
_necessaryRequestedMIATypes, new MediaItemAspectMetadata[] {}, _filter, null);
IDictionary <QueryAttribute, string> qa2a;
builder.GenerateSqlGroupByStatement(out countAlias, out qa2a, out statementStr, out bindVars);
command.CommandText = statementStr;
foreach (BindVar bindVar in bindVars)
{
database.AddParameter(command, bindVar.Name, bindVar.Value, bindVar.VariableType);
}
return(Convert.ToInt32(command.ExecuteScalar()));
}
}
finally
{
transaction.Dispose();
}
}
private void InitAsync()
{
ServiceRegistration.Get <ILogger>().Info("SlimTvService: Initialising");
Task.Delay(MAX_INIT_MS).ContinueWith((t) =>
{
if (_initComplete.Task.Status != TaskStatus.RanToCompletion)
{
_initComplete.TrySetResult(false);
ServiceRegistration.Get <ILogger>().Error("SlimTvService: Initialization timed out.");
}
});
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
if (database == null)
{
ServiceRegistration.Get <ILogger>().Error("SlimTvService: Database not available.");
_initComplete.TrySetResult(false);
return;
}
using (var transaction = database.BeginTransaction())
{
// Prepare TV database if required.
PrepareTvDatabase(transaction);
PrepareConnection(transaction);
}
// Initialize integration into host system (MP2-Server)
PrepareIntegrationProvider();
// Needs to be done after the IntegrationProvider is registered, so the TVCORE folder is defined.
PrepareProgramData();
// Register required filters
PrepareFilterRegistrations();
// Get all current connected clients, so we can later detect disconnections
UpdateClientList();
// Run the actual TV core thread(s)
InitTvCore();
if (_abortInit)
{
ServiceRegistration.Get <ILogger>().Error("SlimTvService: Initialization aborted.");
_initComplete.TrySetResult(false);
DeInit();
return;
}
// Prepare the MP2 integration
PrepareMediaSources();
ServiceRegistration.Get <ILogger>().Info("SlimTvService: Initialised");
_initComplete.TrySetResult(true);
}
public HomogenousMap Execute()
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
using (IDbCommand command = transaction.CreateCommand())
{
string valueAlias;
string groupSizeAlias;
string statementStr;
IList <BindVar> bindVars;
if (_selectAttribute.Cardinality == Cardinality.Inline || _selectAttribute.Cardinality == Cardinality.ManyToOne)
{
QueryAttribute selectAttributeQA = new QueryAttribute(_selectAttribute);
MainQueryBuilder builder = new MainQueryBuilder(_miaManagement,
new QueryAttribute[] { selectAttributeQA }, _selectProjectionFunction,
_necessaryRequestedMIATypes, new MediaItemAspectMetadata[] {}, _filter, null);
IDictionary <QueryAttribute, string> qa2a;
builder.GenerateSqlGroupByStatement(out groupSizeAlias, out qa2a, out statementStr, out bindVars);
valueAlias = qa2a[selectAttributeQA];
}
else
{
ComplexAttributeQueryBuilder builder = new ComplexAttributeQueryBuilder(_miaManagement, _selectAttribute,
_selectProjectionFunction, _necessaryRequestedMIATypes, _filter);
builder.GenerateSqlGroupByStatement(_selectAttributeFilter, out valueAlias, out groupSizeAlias,
out statementStr, out bindVars);
}
command.CommandText = statementStr;
foreach (BindVar bindVar in bindVars)
{
database.AddParameter(command, bindVar.Name, bindVar.Value, bindVar.VariableType);
}
Type valueType = _projectionValueType ?? _selectAttribute.AttributeType;
HomogenousMap result = new HomogenousMap(valueType, typeof(int));
using (IDataReader reader = command.ExecuteReader())
{
int valueCol = reader.GetOrdinal(valueAlias);
int groupSizeCol = reader.GetOrdinal(groupSizeAlias);
while (reader.Read())
{
result.Add(database.ReadDBValue(valueType, reader, valueCol),
database.ReadDBValue <int>(reader, groupSizeCol));
}
}
return(result);
}
}
finally
{
transaction.Dispose();
}
}
public IList <MediaItem> Query(bool singleMode)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
return(Query(database, transaction, singleMode));
}
finally
{
transaction.Dispose();
}
}
public void ExecuteBatch(ISQLDatabase database, InstructionList instructions)
{
using (ITransaction transaction = database.BeginTransaction())
{
foreach (string instr in instructions)
{
using (IDbCommand cmd = transaction.CreateCommand())
{
cmd.CommandText = instr;
cmd.ExecuteNonQuery();
}
}
transaction.Commit();
}
}
public Task <bool> ChangeProfileIdAsync(Guid profileId, Guid newProfileId)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
bool result;
int nameIndex;
string profileName;
using (IDbCommand command = UserProfileDataManagement_SubSchema.SelectUserProfileNameCommand(transaction, profileId, out nameIndex))
{
using (IDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
profileName = database.ReadDBValue <string>(reader, nameIndex);
}
else
{
transaction.Rollback();
return(Task.FromResult(false));
}
}
}
using (IDbCommand command = UserProfileDataManagement_SubSchema.UpdateUserProfileNameCommand(transaction, profileId, profileName + "_old"))
command.ExecuteNonQuery();
using (IDbCommand command = UserProfileDataManagement_SubSchema.CopyUserProfileCommand(transaction, profileId, newProfileId, profileName))
result = command.ExecuteNonQuery() > 0;
using (IDbCommand command = UserProfileDataManagement_SubSchema.CopyUserMediaItemDataCommand(transaction, profileId, newProfileId))
command.ExecuteNonQuery();
using (IDbCommand command = UserProfileDataManagement_SubSchema.CopyUserPlaylistDataCommand(transaction, profileId, newProfileId))
command.ExecuteNonQuery();
using (IDbCommand command = UserProfileDataManagement_SubSchema.CopyUserAdditionalDataCommand(transaction, profileId, newProfileId))
command.ExecuteNonQuery();
using (IDbCommand command = UserProfileDataManagement_SubSchema.DeleteUserProfileCommand(transaction, profileId))
command.ExecuteNonQuery();
transaction.Commit();
return(Task.FromResult(result));
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("UserProfileDataManagement: Error changing profile Id '{0}'", e, profileId);
transaction.Rollback();
throw;
}
}
/// <summary>
/// Gets all media item ids from the database.
/// </summary>
/// <returns></returns>
protected ICollection <Guid> GetAllMediaItemIds()
{
HashSet <Guid> mediaItemIds = new HashSet <Guid>();
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
using (ITransaction transaction = database.BeginTransaction())
using (IDbCommand command = MediaLibrary_SubSchema.SelectAllMediaItemIdsCommand(transaction))
using (var reader = command.ExecuteReader())
while (reader.Read())
{
mediaItemIds.Add(database.ReadDBValue <Guid>(reader, 0));
}
return(mediaItemIds);
}
public bool UpgradeDatabase()
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
int curVersionMajor;
int curVersionMinor;
if (GetDatabaseVersion(out curVersionMajor, out curVersionMinor) &&
(curVersionMajor < DATABASE_VERSION_MAJOR ||
(curVersionMajor == DATABASE_VERSION_MAJOR && curVersionMinor < DATABASE_VERSION_MINOR)))
{
//Database was not migratable before version 2.1
if (curVersionMajor == 2 && curVersionMinor == 0)
{
curVersionMinor = GuessMiniorVersion();
}
_upgradeInProgress = true;
SendUpgradeProgress(0, 100);
ServiceRegistration.Get <ILogger>().Info("DatabaseManager: Initiating update to database version {0}.{1}", DATABASE_VERSION_MAJOR, DATABASE_VERSION_MINOR);
Version currrentVersion = new Version(curVersionMajor, curVersionMinor);
if (database.BackupDatabase(currrentVersion.ToString(2)))
{
SendUpgradeProgress(5, 100);
if (database.BackupTables(BACKUP_TABLE_SUFFIX))
{
SendUpgradeProgress(10, 100);
using (ITransaction transaction = database.BeginTransaction(IsolationLevel.Serializable))
{
ServiceRegistration.Get <ILogger>().Info("DatabaseManager: Creating subschema '{0}'", MediaPortal_Basis_Schema.SUBSCHEMA_NAME);
using (TextReader reader = new SqlScriptPreprocessor(MediaPortal_Basis_Schema.SubSchemaCreateScriptPath))
ExecuteBatch(transaction, new InstructionList(reader));
transaction.Commit();
}
//A newly created database will always be of the latest version
SetDatabaseVersion(DATABASE_VERSION_MAJOR, DATABASE_VERSION_MINOR);
//Set MediaLibrary in maintenance mode
if (ServiceRegistration.Get <IMediaLibrary>() is MediaLibrary.MediaLibrary mediaLibrary)
{
mediaLibrary.MaintenanceMode = true;
}
return(true);
}
}
}
return(false);
}
public Task <AsyncResult <IEnumerable <Tuple <string, int, string> > > > GetUserSelectedAdditionalDataListAsync(Guid profileId, string[] keys, bool sortByKey = false, SortDirection sortDirection = SortDirection.Ascending,
uint?offset = null, uint?limit = null)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
int dataNoIndex;
int dataIndex;
int keyIndex;
List <Tuple <string, int, string> > list = new List <Tuple <string, int, string> >();
using (IDbCommand command = UserProfileDataManagement_SubSchema.SelectUserAdditionalDataListCommand(transaction, profileId,
keys, sortByKey, sortDirection, out keyIndex, out dataNoIndex, out dataIndex))
{
using (IDataReader reader = command.ExecuteReader())
{
var records = reader.AsEnumerable();
if (offset.HasValue)
{
records = records.Skip((int)offset.Value);
}
if (limit.HasValue)
{
records = records.Take((int)limit.Value);
}
foreach (var record in records)
{
list.Add(new Tuple <string, int, string>(database.ReadDBValue <string>(record, keyIndex), database.ReadDBValue <int>(record, dataNoIndex),
database.ReadDBValue <string>(record, dataIndex)));
}
}
}
IEnumerable <Tuple <string, int, string> > data = null;
if (list.Count > 0)
{
data = list;
}
return(Task.FromResult(new AsyncResult <IEnumerable <Tuple <string, int, string> > >(data != null, data)));
}
finally
{
transaction.Dispose();
}
}
protected bool GetDatabaseVersion(out int versionMajor, out int versionMinor, bool useBackupTable = false)
{
versionMajor = 0;
versionMinor = 0;
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
if (!database.TableExists(MediaPortal_Basis_Schema.DATABASE_VERSION_TABLE_NAME + (useBackupTable ? BACKUP_TABLE_SUFFIX : "")))
{
return(false);
}
ITransaction transaction = database.BeginTransaction();
try
{
int versionIndex;
IDbCommand command;
if (useBackupTable)
{
command = SelectBackupDatabaseVersionByCommand(transaction, out versionIndex);
}
else
{
command = MediaPortal_Basis_Schema.SelectDatabaseVersionByCommand(transaction, out versionIndex);
}
using (command)
using (IDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow))
{
if (reader.Read())
{
if (Version.TryParse(reader.GetString(versionIndex), out Version version))
{
versionMajor = version.Major;
versionMinor = version.Minor;
}
return(true);
}
return(false);
}
}
finally
{
transaction.Dispose();
}
}
public Task <bool> ClearUserMediaItemDataKeyAsync(Guid profileId, string key)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
using (IDbCommand command = UserProfileDataManagement_SubSchema.DeleteUserMediaItemDataCommand(transaction, profileId, null, key))
command.ExecuteNonQuery();
transaction.Commit();
return(Task.FromResult(true));
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("UserProfileDataManagement: Error clearing user media item data for profile '{0}'", e, profileId);
transaction.Rollback();
throw;
}
}
private Guid CreateProfileInternal(Guid profileId, string profileName, UserProfileType profileType, string profilePassword)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
using (IDbCommand command = UserProfileDataManagement_SubSchema.CreateUserProfileCommand(transaction, profileId, profileName, profileType, profilePassword))
command.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("UserProfileDataManagement: Error creating user profile '{0}')", e, profileName);
transaction.Rollback();
throw;
}
return(profileId);
}
public ICollection <string> GetDatabaseSubSchemas()
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
using (ITransaction transaction = database.BeginTransaction())
{
int nameIndex;
using (IDbCommand command = MediaPortal_Basis_Schema.SelectAllSubSchemaNames(transaction, out nameIndex))
using (IDataReader reader = command.ExecuteReader())
{
ICollection <string> result = new List <string>();
while (reader.Read())
{
result.Add(database.ReadDBValue <string>(reader, nameIndex));
}
return(result);
}
}
}
public void Startup()
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
if (database == null)
{
throw new IllegalCallException("There is no database present in the system");
}
if (!_migrationScriptPlaceholders.ContainsKey(SQL_CONCAT_PLACEHOLDER))
{
_migrationScriptPlaceholders.Add(SQL_CONCAT_PLACEHOLDER, database.ConcatOperator);
}
if (!_migrationScriptPlaceholders.ContainsKey(SQL_LEN_PLACEHOLDER))
{
_migrationScriptPlaceholders.Add(SQL_LEN_PLACEHOLDER, database.LengthFunction);
}
// Prepare schema
if (!database.TableExists(MediaPortal_Basis_Schema.MEDIAPORTAL_BASIS_TABLE_NAME))
{
ServiceRegistration.Get <ILogger>().Info("DatabaseManager: Creating subschema '{0}'", MediaPortal_Basis_Schema.SUBSCHEMA_NAME);
using (ITransaction transaction = database.BeginTransaction(IsolationLevel.Serializable))
{
using (TextReader reader = new SqlScriptPreprocessor(MediaPortal_Basis_Schema.SubSchemaCreateScriptPath))
ExecuteBatch(transaction, new InstructionList(reader));
transaction.Commit();
}
//A newly created database will be of the latest version
SetDatabaseVersion(DATABASE_VERSION_MAJOR, DATABASE_VERSION_MINOR);
}
// Hint: Table MEDIAPORTAL_BASIS contains a sub schema entry for "MEDIAPORTAL_BASIS" with version number 1.0
int versionMajor;
int versionMinor;
if (!GetSubSchemaVersion(MediaPortal_Basis_Schema.SUBSCHEMA_NAME, out versionMajor, out versionMinor))
{
throw new UnexpectedStateException("{0} schema is not present or corrupted", MediaPortal_Basis_Schema.SUBSCHEMA_NAME);
}
ServiceRegistration.Get <ILogger>().Info("DatabaseManager: Subschema '{0}' present in version {1}.{2}",
MediaPortal_Basis_Schema.SUBSCHEMA_NAME, versionMajor, versionMinor);
}
public bool DeleteProfile(Guid profileId)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
bool result;
using (IDbCommand command = UserProfileDataManagement_SubSchema.DeleteUserProfileCommand(transaction, profileId))
result = command.ExecuteNonQuery() > 0;
transaction.Commit();
return(result);
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("UserProfileDataManagement: Error deleting profile '{0}'", e, profileId);
transaction.Rollback();
throw;
}
}
private void InitAsync()
{
ServiceRegistration.Get <ILogger>().Info("SlimTvService: Initialising");
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(false);
if (database == null)
{
ServiceRegistration.Get <ILogger>().Error("SlimTvService: Database not available.");
return;
}
using (var transaction = database.BeginTransaction())
{
// Prepare TV database if required.
PrepareTvDatabase(transaction);
PrepareConnection(transaction);
}
// Initialize integration into host system (MP2-Server)
PrepareIntegrationProvider();
// Needs to be done after the IntegrationProvider is registered, so the TVCORE folder is defined.
PrepareProgramData();
// Register required filters
PrepareFilterRegistrations();
// Run the actual TV core thread(s)
InitTvCore();
if (_abortInit)
{
DeInit();
return;
}
// Prepare the MP2 integration
PrepareMediaSources();
ServiceRegistration.Get <ILogger>().Info("SlimTvService: Initialised");
}
public Task <bool> LoginProfileAsync(Guid profileId)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
bool result;
using (IDbCommand command = UserProfileDataManagement_SubSchema.LoginUserProfileCommand(transaction, profileId))
result = command.ExecuteNonQuery() > 0;
transaction.Commit();
return(Task.FromResult(result));
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("UserProfileDataManagement: Error logging in profile '{0}'", e, profileId);
transaction.Rollback();
throw;
}
}
public void ExecuteBatch(ISQLDatabase database, InstructionList instructions)
{
using (ITransaction transaction = database.BeginTransaction())
{
foreach (string instr in instructions)
using (IDbCommand cmd = transaction.CreateCommand())
{
cmd.CommandText = instr;
cmd.ExecuteNonQuery();
}
transaction.Commit();
}
}
