/// <summary>
/// Speichere die Daten des übergebenen Moderator-Objekt in der Datenbank ab.
/// </summary>
/// <param name="moderator">Das Objekt mit den Daten des Moderators.</param>
/// <exception cref="DatabaseException">Wirft DatabaseException, wenn Speicherung fehlschlägt.</exception>
public void StoreModerator(Moderator moderator)
{
if(moderator == null)
{
Debug.WriteLine("No valid moderator object is passed to the StoreModerator method.");
return;
}
// Frage das Mutex Objekt ab.
Mutex mutex = DatabaseManager.GetDatabaseAccessMutexObject();
// Fordere Zugriff auf die Datenbank an.
if (mutex.WaitOne(DatabaseManager.MutexTimeoutValue))
{
using (SQLiteConnection conn = DatabaseManager.GetConnection())
{
try
{
using (var insertStmt = conn.Prepare(@"INSERT INTO Moderator (Id, FirstName, LastName, Email)
VALUES (?,?,?,?);"))
{
insertStmt.Bind(1, moderator.Id);
insertStmt.Bind(2, moderator.FirstName);
insertStmt.Bind(3, moderator.LastName);
insertStmt.Bind(4, moderator.Email);
insertStmt.Step();
}
}
catch (SQLiteException sqlEx)
{
Debug.WriteLine("SQLiteException occurred in StoreModerator. The message is: {0}.", sqlEx.Message);
throw new DatabaseException("Moderator could not be stored.");
}
catch (Exception ex)
{
Debug.WriteLine("Exception occurred in StoreModerator. The message is: {0} and the stack trace is {1}.",
ex.Message,
ex.StackTrace);
throw new DatabaseException("Moderator could not be stored.");
}
finally
{
mutex.ReleaseMutex();
}
} // Ende des using Block.
}
else
{
Debug.WriteLine("Couldn't get access to database. Time out.");
throw new DatabaseException("Could not get access to the database.");
}
}
/// <summary>
/// Liefert eine Liste an Moderatoren, die in der Datenbank als aktive Verantwortliche des Kanals
/// eingetragen sind.
/// </summary>
/// <param name="channelId">Die Id des Kanals, zu dem die verantwortlichen Moderatoren abgefragt werden sollen.</param>
/// <returns>Eine Liste von Moderator Objekten.</returns>
/// <exception cref="DatabaseException">Wirft eine DatabaseException, wenn die Ausführung fehlschlägt.</exception>
public List<Moderator> GetResponsibleModeratorsForChannel(int channelId)
{
List<Moderator> responsibleModerators = new List<Moderator>();
// Frage das Mutex Objekt ab.
Mutex mutex = DatabaseManager.GetDatabaseAccessMutexObject();
// Fordere Zugriff auf die Datenbank an.
if (mutex.WaitOne(DatabaseManager.MutexTimeoutValue))
{
using (SQLiteConnection conn = DatabaseManager.GetConnection())
{
try
{
using (var stmt = conn.Prepare(@"SELECT *
FROM Moderator AS m JOIN ModeratorChannel AS mc ON m.Id=mc.Moderator_Id
WHERE mc.Channel_Id=? AND mc.Active=?;"))
{
stmt.Bind(1, channelId);
stmt.Bind(2, 1);
while (stmt.Step() == SQLiteResult.ROW)
{
int id = Convert.ToInt32(stmt["Id"]);
string firstName = (string)stmt["FirstName"];
string lastName = (string)stmt["LastName"];
string email = (string)stmt["Email"];
Moderator moderator = new Moderator()
{
Id = id,
FirstName = firstName,
LastName = lastName,
Email = email
};
responsibleModerators.Add(moderator);
}
}
}
catch (SQLiteException sqlEx)
{
Debug.WriteLine("SQLiteException has occurred in GetResponsibleModeratorsForChannel. The message is: {0}.", sqlEx.Message);
throw new DatabaseException("GetResponsibleModeratorsForChannel channel has failed.");
}
catch (Exception ex)
{
Debug.WriteLine("Exception has occurred in GetResponsibleModeratorsForChannel. The message is: {0}, " +
"and the stack trace: {1}.", ex.Message, ex.StackTrace);
throw new DatabaseException("GetResponsibleModeratorsForChannel channel has failed.");
}
finally
{
mutex.ReleaseMutex();
}
}
}
else
{
Debug.WriteLine("Couldn't get access to database. Time out.");
throw new DatabaseException("Could not get access to the database.");
}
return responsibleModerators;
}
/// <summary>
/// Aktualisiert den Datensatz des Moderators, der durch das übergebene Moderatorenobjekt
/// identifiziert wird. Das übergebene Moderatorenobjekt enthält die neuen Daten des Moderators.
/// </summary>
/// <param name="newModerator">Das Moderator Objekt mit den neuen Daten.</param>
/// <exception cref="DatabaseException">Wirft eine DatabaseException, wenn die Aktualisierung fehlschlägt.</exception>
public void UpdateModerator(Moderator newModerator)
{
if (newModerator == null)
return;
// Frage das Mutex Objekt ab.
Mutex mutex = DatabaseManager.GetDatabaseAccessMutexObject();
// Fordere Zugriff auf die Datenbank an.
if (mutex.WaitOne(DatabaseManager.MutexTimeoutValue))
{
using (SQLiteConnection conn = DatabaseManager.GetConnection())
{
try
{
string sql = @"UPDATE Moderator
SET FirstName=?, LastName=?, Email=?
WHERE Id=?;";
using (var stmt = conn.Prepare(sql))
{
stmt.Bind(1, newModerator.FirstName);
stmt.Bind(2, newModerator.LastName);
stmt.Bind(3, newModerator.Email);
stmt.Bind(4, newModerator.Id);
if (stmt.Step() == SQLiteResult.DONE)
Debug.WriteLine("Updated moderator with id {0}.", newModerator.Id);
}
}
catch (SQLiteException sqlEx)
{
Debug.WriteLine("SQLiteException occurred in UpdateModerator. The message is: {0}.", sqlEx.Message);
throw new DatabaseException("Could not update Moderator. Msg is: " + sqlEx.Message);
}
catch (Exception ex)
{
Debug.WriteLine("Exception occurred in UpdateModerator. The message is: {0} and the stack trace is {1}.",
ex.Message,
ex.StackTrace);
throw new DatabaseException("Could not update Moderator. Msg is: " + ex.Message);
}
finally
{
mutex.ReleaseMutex();
}
}
}
else
{
Debug.WriteLine("Couldn't get access to database. Time out.");
throw new DatabaseException("Could not get access to the database.");
}
}
/// <summary>
/// Fügt das übergebene Moderatorenobjekt dem durch die Singleton Klasse repräsentierten
/// Cache hinzu.
/// </summary>
/// <param name="moderator">Das zu speichernde Moderatorenobjekt.</param>
public void CacheModeratorObject(Moderator moderator)
{
this.moderator = moderator;
}
/// <summary>
/// Holt die Daten des Moderators mit der angegebenen Id aus der Datenbank und gibt sie zurück.
/// </summary>
/// <param name="channelId">Die Id des Moderators, der abgerufen werden soll.</param>
/// <returns>Ein Objekt der Klasse Moderator, oder null falls der Eintrag nicht in der Datenbank ist.</returns>
/// <exception cref="DatabaseException">Wirft DatabaseException, wenn Abruf des Datensatzes fehlschlägt.</exception>
public Moderator GetModerator(int moderatorId)
{
Moderator moderator = null;
// Frage das Mutex Objekt ab.
Mutex mutex = DatabaseManager.GetDatabaseAccessMutexObject();
// Fordere Zugriff auf die Datenbank an.
if (mutex.WaitOne(DatabaseManager.MutexTimeoutValue))
{
using (SQLiteConnection conn = DatabaseManager.GetConnection())
{
try
{
using (var stmt = conn.Prepare(@"SELECT * FROM Moderator WHERE Id=?;"))
{
stmt.Bind(1, moderatorId);
if (stmt.Step() == SQLiteResult.ROW)
{
int id = Convert.ToInt32(stmt["Id"]);
string firstName = (string)stmt["FirstName"];
string lastName = (string)stmt["LastName"];
string email = (string)stmt["Email"];
moderator = new Moderator()
{
Id = id,
FirstName = firstName,
LastName = lastName,
Email = email
};
}
}
}
catch (SQLiteException sqlEx)
{
Debug.WriteLine("SQLiteException occurred in GetModerator. The message is: {0}.", sqlEx.Message);
throw new DatabaseException("Could not retrieve Moderator.");
}
catch (Exception ex)
{
Debug.WriteLine("Exception occurred in GetModerator. The message is: {0} and the stack trace is {1}.",
ex.Message,
ex.StackTrace);
throw new DatabaseException("Could not retrieve Moderator.");
}
finally
{
mutex.ReleaseMutex();
}
} // Ende des using Block.
}
else
{
Debug.WriteLine("Couldn't get access to database. Time out.");
throw new DatabaseException("Could not get access to the database.");
}
return moderator;
}
/// <summary>
/// Hilfsmethode zur Unterstützung der Synchronistation der verwalteten Kanäle.
/// Ruft Daten zu dem Kanal mit der angegebenen Id vom Server ab. Dazu gehören
/// die verantwortlichen Moderatoren und die Reminder. Speichert die Daten für den
/// Kanal in der lokalen Datenbank ab. Ruft jedoch nicht die eigentlichen Kanaldaten ab.
/// </summary>
/// <param name="activeModerator">Der Moderator, der für den Kanal als Verantwortlicher eingetragen ist.
/// Ist der lokal eingeloggte Moderator.</param>
/// <param name="channelId">Die Id des Kanals, für den die Daten abgerufen werden sollen.</param>
private async Task retrieveAndStoreManagedChannelInfoAsync(Moderator activeModerator, int channelId)
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Started method.");
if (activeModerator == null)
return;
// Rufe alle Moderatoren zu dem Kanal ab.
try
{
List<Moderator> moderators = await GetResponsibleModeratorsAsync(channelId);
if (moderators == null)
return;
foreach (Moderator moderator in moderators)
{
if (!moderatorDatabaseManager.IsModeratorStored(moderator.Id))
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Need to store the " +
"moderator with id {0} in local DB.", moderator.Id);
moderatorDatabaseManager.StoreModerator(moderator);
}
if (!channelDatabaseManager.IsResponsibleForChannel(channelId, moderator.Id))
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Add moderator with id {0} to " +
"channel with id {1}.", channelId, moderator.Id);
channelDatabaseManager.AddModeratorToChannel(channelId, moderator.Id, moderator.IsActive);
}
}
}
catch (DatabaseException ex)
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Storing of the responsible moderators has failed.");
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Message is: {0}.", ex.Message);
}
catch (ClientException ex)
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Retrieval of the responsible moderators has failed.");
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: " +
"Message is: {0} and error code is {1}.", ex.Message, ex.ErrorCode);
}
// Rufe Reminder zu dem Kanal ab.
try
{
List<Reminder> reminders = await GetRemindersOfChannelAsync(channelId, false);
channelDatabaseManager.BulkInsertReminder(reminders);
}
catch (DatabaseException ex)
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Storing of the reminders has failed.");
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Message is: {0}.", ex.Message);
}
catch (ClientException ex)
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Retrieval of the reminders has failed.");
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: " +
"Message is: {0} and error code is {1}.", ex.Message, ex.ErrorCode);
}
// Rufe Announcements zu dem Kanal ab.
try
{
int msgNr = GetHighestMsgNrForChannel(channelId);
List<Announcement> announcements = await GetAnnouncementsOfChannelAsync(channelId, msgNr, false);
channelDatabaseManager.BulkInsertOfAnnouncements(announcements);
}
catch (DatabaseException ex)
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Storing of the announcements has failed.");
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Message is: {0}.", ex.Message);
}
catch (ClientException ex)
{
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Retrieval of the announcements has failed.");
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: " +
"Message is: {0} and error code is {1}.", ex.Message, ex.ErrorCode);
}
Debug.WriteLine("retrieveAndStoreManagedChannelInfoAsync: Finished method.");
}
/// <summary>
/// Fügt einen Moderator dem Kanal mit der angegebenen Id hinzu.
/// </summary>
/// <param name="channelId">Die Id des Kanals, zu dem der Moderator hinzugefügt werden soll.</param>
/// <param name="newModerator">Der Moderator, der dem Kanal hinzugefügt werden soll.</param>
/// <exception cref="ClientException">Wirft ClientException, wenn Moderator nicht zum Kanal hinzugefügt werden konnte.</exception>
public void AddModeratorToChannel(int channelId, Moderator newModerator)
{
if (newModerator == null)
return;
try
{
channelDatabaseManager.AddModeratorToChannel(channelId,
newModerator.Id,
newModerator.IsActive);
}
catch (ClientException ex)
{
Debug.WriteLine("AddModeratorToChannel: Failed to add moderator to channel with id {0}.", channelId);
throw new ClientException(ErrorCodes.LocalDatabaseException, ex.Message);
}
}
/// <summary>
/// Prüft, ob alle Beziehungen zwischen Kanalressourcen und dem aktuell eingeloggten
/// Moderator aktuell sind und aktualisiert diese falls notwendig.
/// </summary>
/// <param name="managedChannels">Liste von aktuell verwalteten Kanälen des Moderators.</param>
/// <exception cref="ClientException">Wirft ClientException, wenn Aktualisierung fehlschlägt.</exception>
//public void UpdateManagedChannelsRelationships(List<Channel> managedChannels)
//{
// Moderator activeModerator = GetLocalModerator();
// if (activeModerator == null)
// return;
// try
// {
// // Prüfe, ob der aktuell eingeloggte Moderator schon in der Datenbank enthalten ist.
// if (!moderatorDatabaseManager.IsModeratorStored(activeModerator.Id))
// {
// Debug.WriteLine("Need to store the moderator with id {0} in local DB.", activeModerator.Id);
// moderatorDatabaseManager.StoreModerator(activeModerator);
// }
// // Prüfe, ob Moderator auch lokal als Verantwortlicher für Kanäle eingetragen ist.
// foreach (Channel channel in managedChannels)
// {
// if (!channelDatabaseManager.IsResponsibleForChannel(channel.Id, activeModerator.Id))
// {
// // Kanal gefunden, der vorher noch nicht von diesem Moderator verwaltet wurde.
// // Trage Moderator ein.
// Debug.WriteLine("Need to add the moderator with id {0} as a responsible moderator " +
// "for the channel with id {1}.", activeModerator.Id, channel.Id);
// channelDatabaseManager.AddModeratorToChannel(channel.Id, activeModerator.Id, true);
// // Stoße das Herunterladen der für den neu hinzugekommenen Kanal relevanten Daten an.
// // Bemerkung: Falls das fehlschlägt wird kein Fehler geworfen. Die Daten können auch im Fehlerfall später nachgeladen werden.
// Task.Run(() => retrieveAndStoreManagedChannelInfoAsync(activeModerator, channel.Id));
// }
// }
// // Frage verwaltete Kanäle aus der DB ab.
// List<Channel> managedChannelsFromDB = channelDatabaseManager.GetManagedChannels(activeModerator.Id);
// // Prüfe, ob es darin noch einen Kanal gibt, der nicht mehr in der aktuellen Liste von Kanälen steht.
// for (int i = 0; i < managedChannelsFromDB.Count; i++)
// {
// bool isContained = false;
// foreach (Channel channel in managedChannels)
// {
// if (channel.Id == managedChannelsFromDB[i].Id)
// {
// isContained = true;
// }
// }
// if (!isContained)
// {
// RemoveChannelFromManagedChannels(activeModerator, managedChannelsFromDB[i]);
// }
// }
// }
// catch (DatabaseException ex)
// {
// Debug.WriteLine("Database exception occurred in UpdateManagedChannelsRelationships. Msg is {0}.", ex.Message);
// throw new ClientException(ErrorCodes.LocalDatabaseException, "Failed to update managed channels relationships.");
// }
//}
/// <summary>
/// Nimmt einen Kanal aus der Liste der verwalteten Kanäle raus und räumt
/// mit diesem Kanal in Verbindung stehende Ressourcen weg, die dann nicht mehr
/// benötigt werden.
/// </summary>
/// <param name="activeModerator">Der gerade aktive Moderator, für den der Kanal aus der Liste der
/// verwalteten Kanäle ausgetragen wird.</param>
/// <param name="channel">Der Kanal, der aus der Liste genommen wird.</param>
public void RemoveChannelFromManagedChannels(Moderator activeModerator, Channel channel)
{
try
{
// Setzte Verantwortlichkeit auf inaktiv für diesen Kanal.
Debug.WriteLine("Need to set moderator isActive to false for channel with id {0}.", channel.Id);
channelDatabaseManager.AddModeratorToChannel(
channel.Id,
activeModerator.Id,
false);
// Prüfe, ob der Kanal abonniert ist.
bool isSubscribed = channelDatabaseManager.IsChannelSubscribed(channel.Id);
if (!isSubscribed)
{
// Kanal nicht noch vom lokalen Nutzer abonniert. Lösche Announcements und Moderator-Info.
Debug.WriteLine("Channel with id {0} not subscribed. Delete announcements and moderator info.", channel.Id);
channelDatabaseManager.DeleteAllAnnouncementsOfChannel(channel.Id);
channelDatabaseManager.RemoveAllModeratorsFromChannel(channel.Id);
}
// Lösche in jedem Fall die Reminder.
Debug.WriteLine("Deleting reminders for channel with id {0}.", channel.Id);
channelDatabaseManager.DeleteRemindersForChannel(channel.Id);
}
catch (DatabaseException ex)
{
// Keine weitere Aktion, da diese Funktionalität im Hintergrund abläuft und
// nicht vom Nutzer aktiv ausgelöst wird.
Debug.WriteLine("Error during removal of managed channel. No further action is taken." +
"Error message is: {0}.", ex.Message);
}
}
/// <summary>
/// Führe eine Synchronisation der lokalen Menge an Kanälen, für die der übergebene
/// Moderator als Verantwortlicher eingetragen ist, mit der übergebenen Liste an Kanalressourcen
/// durch. Die Methode prüft, ob die übergebene Menge an Kanalressourcen noch mit den aktuell lokal
/// gehaltenen Kanalressourcen übereinstimmt und fügt der lokal verwalteten Liste fehlende Kanäle
/// hinzu. Es können auch Kanäle aus der Liste rausgenommen werden, wenn diese nicht mehr vom übergebenen
/// Moderator verwaltet werden. Bereits lokal vorhanden Kanäle werden falls notwendig mit den aktuelleren
/// Daten der Referenzliste aktualisiert.
/// </summary>
/// <param name="activeModerator">Der Moderator, der für die zu synchronisierenden Kanäle als Verantwortlicher eingetragen ist.</param>
/// <param name="referenceList">Die Liste an Kanalressourcen, gegen die die lokal verwaltete Liste synchronisiert wird.</param>
public void SynchronizeLocalManagedChannels(Moderator activeModerator, List<Channel> referenceList)
{
if (activeModerator == null)
return;
try
{
// Prüfe, ob der aktuell eingeloggte Moderator schon in der Datenbank enthalten ist.
// Falls nicht, speichere ihn ab.
if (!moderatorDatabaseManager.IsModeratorStored(activeModerator.Id))
{
Debug.WriteLine("SynchronizeLocalManagedChannels: Need to store the moderator with id {0} in local DB.",
activeModerator.Id);
moderatorDatabaseManager.StoreModerator(activeModerator);
}
// Frage verwaltete Kanäle aus der DB ab.
List<Channel> managedChannelsFromDB = channelDatabaseManager.GetManagedChannels(activeModerator.Id);
// Vergleiche beide Listen. Wenn Kanal in der Referenzliste ist, der noch nicht in den lokalen
// Datensätzen vorhanden ist, dann füge ihn hinzu. Wenn ein Kanal schon lokal vorhanden ist, dann prüfe,
// ob eine Aktualisierung des lokalen Datensatzes notwendig ist.
foreach (Channel referenceChannel in referenceList)
{
bool isContained = false;
for (int i = 0; i < managedChannelsFromDB.Count; i++)
{
Channel localChannel = managedChannelsFromDB[i];
// Prüfe Ids.
if (referenceChannel.Id == localChannel.Id)
{
isContained = true;
// Prüfe, ob Aktualisierung erforderlich.
if (DateTimeOffset.Compare(localChannel.ModificationDate, referenceChannel.ModificationDate) < 0)
{
Debug.WriteLine("SynchronizeLocalManagedChannels: Need to update channel with id {0}.",
localChannel.Id);
// Übernehme NotificationSettings von lokalem Kanal.
referenceChannel.AnnouncementNotificationSetting = localChannel.AnnouncementNotificationSetting;
// Ersetze lokalen Datensatz durch neuen Datensatz.
ReplaceLocalChannel(referenceChannel);
}
// Beende Schleife, wenn Treffer gefunden.
break;
}
}
if (!isContained)
{
// Füge Kanal hinzu.
Debug.WriteLine("SynchronizeLocalManagedChannels: Need to add channel with id {0} to managed channels.",
referenceChannel.Id);
AddToLocalChannels(referenceChannel);
// Füge den Moderator als Verantwortlichen für den Kanal hinzu.
channelDatabaseManager.AddModeratorToChannel(referenceChannel.Id, activeModerator.Id, true);
// Stoße das Herunterladen der für den neu hinzugekommenen Kanal relevanten Daten an.
// Bemerkung: Falls das fehlschlägt wird kein Fehler geworfen. Die Daten können auch im Fehlerfall später nachgeladen werden.
Task.Run(() => retrieveAndStoreManagedChannelInfoAsync(activeModerator, referenceChannel.Id));
}
}
// Prüfe, ob ein Kanal nicht mehr vom Moderator verwaltet wird.
// Prüfe hierzu, ob in der Liste der lokalen verwalteten Kanäle einer steht,
// der nicht mehr in der Referenz-Liste von Kanälen steht.
for (int i = 0; i < managedChannelsFromDB.Count; i++)
{
bool isContained = false;
foreach (Channel referenceChannel in referenceList)
{
if (referenceChannel.Id == managedChannelsFromDB[i].Id)
{
isContained = true;
}
}
if (!isContained)
{
RemoveChannelFromManagedChannels(activeModerator, managedChannelsFromDB[i]);
}
}
}
catch (DatabaseException ex)
{
Debug.WriteLine("SynchronizeLocalManagedChannels: Database exception occurred in " +
"SynchronizeLocalManagedChannels. Msg is {0}.", ex.Message);
throw new ClientException(ErrorCodes.LocalDatabaseException, "Failed to update managed channels relationships.");
}
}
/// <summary>
/// Fügt den übergebenen Kanal der Liste der verwalteten Kanäle hinzu für den übergebenen
/// Moderator. Trägt dabei den übergebenen Moderator als Verantwortlichen für den übergebenen Kanal
/// ein und schaut ob der lokale Datensatz des Kanals hinzugefügt oder aktualisiert werden muss.
/// </summary>
/// <param name="moderator">Der Moderator, für den der Kanal zur Liste der verwalteten Kanäle hinzukommt.</param>
/// <param name="newManagedChannel">Der hinzuzufügende Kanal.</param>
public void AddChannelToLocalManagedChannels(Moderator moderator, Channel newManagedChannel)
{
if (moderator == null || newManagedChannel == null)
return;
try
{
// Prüfe, ob der aktuell eingeloggte Moderator schon in der Datenbank enthalten ist.
// Falls nicht, speichere ihn ab.
if (!moderatorDatabaseManager.IsModeratorStored(moderator.Id))
{
Debug.WriteLine("SynchronizeLocalManagedChannels: Need to store the moderator with id {0} in local DB.",
moderator.Id);
moderatorDatabaseManager.StoreModerator(moderator);
}
// Prüfe ob Kanal schon in lokalen Datensätzen vorhanden ist.
if (!channelDatabaseManager.IsChannelContained(newManagedChannel.Id))
{
Debug.WriteLine("AddChannelToLocalManagedChannels: Adding channel with id {0} to local channels.",
newManagedChannel.Id);
// Wenn nicht, füge Kanal hinzu.
AddToLocalChannels(newManagedChannel);
}
else
{
// Frage lokale Version ab und prüfe, ob diese aktualisiert werden muss.
Channel localChannel = GetChannel(newManagedChannel.Id);
if (DateTimeOffset.Compare(localChannel.ModificationDate, newManagedChannel.ModificationDate) < 0)
{
Debug.WriteLine("SynchronizeLocalManagedChannels: Need to update channel with id {0}.",
localChannel.Id);
// Übernehme NotificationSettings von lokalem Kanal.
newManagedChannel.AnnouncementNotificationSetting = localChannel.AnnouncementNotificationSetting;
// Ersetze lokalen Datensatz durch neuen Datensatz.
ReplaceLocalChannel(newManagedChannel);
}
}
// Füge den Moderator als Verantwortlichen für den Kanal hinzu.
channelDatabaseManager.AddModeratorToChannel(newManagedChannel.Id, moderator.Id, true);
// Stoße das Herunterladen der für den neu hinzugekommenen Kanal relevanten Daten an.
// Bemerkung: Falls das fehlschlägt wird kein Fehler geworfen. Die Daten können auch im Fehlerfall später nachgeladen werden.
Task.Run(() => retrieveAndStoreManagedChannelInfoAsync(moderator, newManagedChannel.Id));
}
catch (DatabaseException ex)
{
Debug.WriteLine("Couldn't add channel to local managed channels. Msg is {0}.",
ex.Message);
throw new ClientException(ErrorCodes.LocalDatabaseException, ex.Message);
}
}
/// <summary>
/// Wandelt ein Objekt vom Typ Moderator in eine JSON Repräsentation um.
/// </summary>
/// <param name="moderator">Das umzuwandelnde Objekt.</param>
/// <returns>Ein JSON-Dokument, welches das übergebene Objekt repräsentiert. Null falls Umwandlung fehlschlägt.</returns>
public string ParseModeratorToJson(Moderator moderator)
{
string jsonContent = null;
try
{
jsonContent = JsonConvert.SerializeObject(moderator);
}
catch (Exception ex)
{
Debug.WriteLine("JsonParsingManager: Exception occurred during json parsing of moderator. " +
"Msg is {0}.", ex.Message);
}
return jsonContent;
}
/// <summary>
/// Speichert den Moderator in den lokalen Datensätzen ab.
/// </summary>
/// <param name="moderator">Der zu speichernde Datensatz in Form eines Moderator Objekts.</param>
/// <exception cref="ClientException">Wirft ClientException, wenn Speicherung fehlschlägt.</exception>
public void StoreModerator(Moderator moderator)
{
if (moderator == null)
return;
try
{
moderatorDatabaseManager.StoreModerator(moderator);
}
catch (ClientException ex)
{
Debug.WriteLine("IsModeratorStored: Database failure. Couldn't store moderator. " +
"Message is: {0}", ex.Message);
throw new ClientException(ErrorCodes.LocalDatabaseException, ex.Message);
}
}
