private void build()
{
this.PackStart(new Label {
Markup = "<b><big>" + m_Category + "</big></b>", UseMarkup = true
}, false, false, 35);
int buttonCount = 0;
using (var connection = new HyenaSqliteConnection(QuestionProvider.dbPath)) {
var provider = new QuestionProvider(connection);
var levels = provider.FetchAll().Where(q => q.HowOftenAsk == 0 && q.Category == m_Category).Select(q => q.DifficultyLevel).Distinct().ToList();
levels.Sort();
foreach (var level in levels)
{
var questions = provider.FetchAll().Where(q => q.HowOftenAsk == 0 && q.DifficultyLevel == level && q.Category == m_Category);
if (generateButton(questions))
{
buttonCount++;
}
}
}
}
void HandleCreateDbButtonClicked(object sender, EventArgs e)
{
string file = newDbButton.Filename;
if (string.IsNullOrEmpty(file))
{
dbLoadLabel.Text = "richtigen Pfad angeben";
this.ShowAll();
return;
}
try {
QuizParser qp = new QuizParser(file);
using (var connection = new HyenaSqliteConnection(QuestionProvider.dbPath)) {
var provider = new QuestionProvider(connection);
var questions = qp.Questions.ToList();
foreach (var quest in questions)
{
provider.Save(quest);
}
}
dbLoadLabel.Text = "erstellen erfolgreich";
this.ShowAll();
} catch (Exception exc) {
dbLoadLabel.Text = exc.Message;
this.ShowAll();
}
dbInfoLabel.Text = string.Format("Exestiert die Datenbank: {0}", System.IO.File.Exists(QuestionProvider.dbPath));
}
public BansheeModelCache(HyenaSqliteConnection connection,
string uuid,
ICacheableDatabaseModel model,
SqliteModelProvider <T> provider)
: base(connection, uuid, model, provider)
{
}
void HowOftenAskFill()
{
using (var connection = new HyenaSqliteConnection(QuestionProvider.dbPath)) {
var provider = new QuestionProvider(connection);
var cmd = new HyenaSqliteCommand("UPDATE ? SET HowOftenAsk = 1 WHERE Id = ?;", provider.TableName, bus.CurrentQuestion.Id);
connection.Execute(cmd);
}
}
void ButtonAddClicked(object sender, EventArgs e)
{
using (var connection = new HyenaSqliteConnection(QuestionProvider.dbPath)) {
var provider = new QuestionProvider(connection);
Question question = new Question("Frage", "Antwort", "Nothing", 0, 0);
provider.Save(question);
qnv.QuestionNodeView.NodeStore.AddNode(new QuestionNode(question));
}
}
private static IDataReader FindExistingArtists(string name)
{
HyenaSqliteConnection db = ServiceManager.DbConnection;
if (name == null)
{
return(db.Query(null_select_command));
}
return(db.Query(default_select_command, name));
}
private static IDataReader FindExistingArtists(int artist_id, string title)
{
HyenaSqliteConnection db = ServiceManager.DbConnection;
if (title == null)
{
return(db.Query(null_select_command, artist_id));
}
return(db.Query(default_select_command, artist_id, title));
}
public DatabaseQueryFilterModel(Banshee.Sources.DatabaseSource source, DatabaseTrackListModel trackModel,
HyenaSqliteConnection connection, string select_all_fmt, string uuid, QueryField field, string filter_column)
: base(field.Name, field.Label, source, trackModel, connection, QueryFilterInfo <T> .CreateProvider(filter_column, field), new QueryFilterInfo <T> (), String.Format("{0}-{1}", uuid, field.Name))
{
this.field = field;
this.select_all_fmt = select_all_fmt;
ReloadFragmentFormat = @"
FROM CoreTracks, CoreCache{0}
WHERE CoreCache.ModelID = {1} AND CoreCache.ItemID = {2} {3}
ORDER BY Value";
}
public DatabaseFilterListModel(string name, string label, Banshee.Sources.DatabaseSource source,
DatabaseTrackListModel trackModel, HyenaSqliteConnection connection, SqliteModelProvider <T> provider, U selectAllItem, string uuid)
: base(trackModel)
{
this.source = source;
FilterName = name;
FilterLabel = label;
select_all_item = selectAllItem;
this.connection = connection;
cache = new BansheeModelCache <T> (connection, uuid, this, provider);
HasSelectAllItem = true;
}
public void Execute(HyenaSqliteConnection db, Version db_version)
{
code();
if (!silent)
{
Log.DebugFormat("Updated database from version {0} to {1}",
db_version.ToString(),
Version.ToString());
}
db_version = Version;
db.Execute(new HyenaSqliteCommand("UPDATE meta SET data = ? WHERE name = ?", db_version.ToString(), meta_db_version_string));
}
public FilterModelProvider(HyenaSqliteConnection conn, string table_name, string pk_column, PropertyInfo pk_info, string value_column, PropertyInfo value_info) : base(conn)
{
this.table_name = table_name;
PrimaryKey = pk_column;
DatabaseColumnAttribute pk_attr = new DatabaseColumnAttribute();
pk_attr.Constraints = DatabaseColumnConstraints.PrimaryKey;
AddColumn(new DatabaseColumn(pk_info, pk_attr), true);
AddColumn(new DatabaseColumn(value_info, new DatabaseColumnAttribute()), true);
select = String.Format("{0} as Value", value_column);
}
void ButtonRemoveClicked(object sender, EventArgs e)
{
if (qnv.QuestionNodeView.NodeSelection.SelectedNode == null)
{
return;
}
var questionNode = (QuestionNode)qnv.QuestionNodeView.NodeSelection.SelectedNode;
var question = questionNode.GetQuestion();
qnv.QuestionNodeView.NodeStore.RemoveNode(questionNode);
using (var connection = new HyenaSqliteConnection(QuestionProvider.dbPath)) {
var provider = new QuestionProvider(connection);
provider.Delete(question);
}
}
public void ExecuteMustDisposeSqliteCommand()
{
using (var connection = new HyenaSqliteConnection(":memory:")) {
bool disposed = false;
connection.Executing += delegate(object sender, ExecutingEventArgs args) {
args.Command.Disposed += delegate {
disposed = true;
};
};
connection.Query <int> ("SELECT 42");
Assert.IsTrue(disposed);
}
}
/* many thinks not implement
* public void CreateDB ()
* {
* var db = new QuestionTable (connectionString);
* if (db.DatabaseExists ()) {
* //Console.WriteLine ("Deleting old database...");
* db.DeleteDatabase ();
* }
* db.CreateDatabase ();
* }
*/
public void CreateProvider()
{
using (var conn = new HyenaSqliteConnection(path)) {
var qp = new QuestionProvider(conn);
/*
* dbConn.Open ();
*
* using (var dbCommand = dbConn.CreateCommand ()) {
* dbCommand.CommandText = @"CREATE TABLE question (id INTEGER PRIMARY KEY, question TEXT, answer TEXT, category TEXT, howOftenAsk INTEGER);";
* dbCommand.ExecuteNonQuery ();
* }
*/
}
}
public FeedsManager(HyenaSqliteConnection connection, DownloadManager downloadManager, string podcast_base_dir)
{
// Hack to work around Feeds being needy and having to call all our internal methods, instead
// of us just listening for their events.
Instance = this;
this.connection = connection;
this.podcast_base_dir = podcast_base_dir;
feed_manager = new FeedManager ();
enclosure_manager = new EnclosureManager (downloadManager);
Feed.Init ();
FeedItem.Init ();
FeedEnclosure.Init ();
command_queue = new AsyncCommandQueue ();
}
public FeedsManager(HyenaSqliteConnection connection, DownloadManager downloadManager, string podcast_base_dir)
{
// Hack to work around Feeds being needy and having to call all our internal methods, instead
// of us just listening for their events.
Instance = this;
this.connection = connection;
this.podcast_base_dir = podcast_base_dir;
feed_manager = new FeedManager();
enclosure_manager = new EnclosureManager(downloadManager);
Feed.Init();
FeedItem.Init();
FeedEnclosure.Init();
command_queue = new AsyncCommandQueue();
}
void build()
{
using (var connection = new HyenaSqliteConnection(QuestionProvider.dbPath)) {
var provider = new QuestionProvider(connection);
var questions = provider.FetchAll();
var questCategories = questions.Where(q => q.HowOftenAsk == 0).Select(q => q.Category).Distinct().ToList();
int questCategoriesCount = questCategories.Count();
var categories = new List <string> ();
if (questCategoriesCount > 3)
{
do
{
var rand = new Random(DateTime.Now.Millisecond);
int r = 0;
if (questCategoriesCount > 1)
{
r = rand.Next(0, questCategoriesCount);
}
categories.Add(questCategories [r]);
categories = categories.Distinct().ToList();
} while (categories.Count < 3);
}
else
{
categories = questCategories.ToList();
}
foreach (var cat in categories)
{
this.Add(new DifficultLevelButtons(cat));
}
if (questCategoriesCount == 0)
{
this.Add(new Label("Keine Fragen mehr vorhanden"));
}
}
}
private void OnTubeManagerTracksDownloaded(object sender, EventArgs args)
{
DownloadedTracksEventArgs track_args = args as DownloadedTracksEventArgs;
IDictionary <string, object> [] chunk = track_args.tracks as IDictionary <string, object> [];
if (chunk == null)
{
return;
}
LibraryDownload d = track_args.download as LibraryDownload;
ThreadAssist.ProxyToMain(delegate {
SetStatus(String.Format(AddinManager.CurrentLocalizer.GetString("Loading {0} of {1}"),
CalculateLoadingTracks(chunk.Length, d.TotalExpected),
d.TotalExpected), false);
});
HyenaSqliteConnection conn = ServiceManager.DbConnection;
conn.BeginTransaction();
for (int i = 0; i < chunk.Length; i++)
{
IDictionary <string, object> track = chunk[i];
ContactTrackInfo contact_track = new ContactTrackInfo(track, this);
// notify once per chunk
if (i == chunk.Length - 1)
{
conn.CommitTransaction();
contact_track.Save(true);
}
else
{
contact_track.Save(false);
}
}
}
protected override void OnEdited(string path, string new_text)
{
using (var connection = new HyenaSqliteConnection(QuestionProvider.dbPath)) {
var node = (QuestionNode)m_Store.GetNode(new TreePath(path));
var quest = node.GetQuestion();
switch (m_Column)
{
case Question.Constants.Quest:
quest.Quest = new_text;
break;
case Question.Constants.Answer:
quest.Answer = new_text;
break;
case Question.Constants.Category:
quest.Category = new_text;
break;
case Question.Constants.HowOftenAsk:
quest.HowOftenAsk = Convert.ToInt32(new_text);
break;
case Question.Constants.DifficultyLevel:
quest.DifficultyLevel = Convert.ToInt32(new_text);
break;
default:
throw new ApplicationException("falscher Spaltenname");
}
var provider = new QuestionProvider(connection);
var cmd = new HyenaSqliteCommand("UPDATE ? SET ? = ? WHERE Id = ?;", provider.TableName, m_Column, new_text, quest.Id);
connection.Execute(cmd);
}
base.OnEdited(path, new_text);
}
/// <summary>
/// Compress banshee database if it is not already compressed.
/// </summary>
/// This won't do anything if last compression is not more than _DB_CACHED_COMPRESSION
/// senconds ago. To avoid that you can reset _dbCompressTime to 0.
///
/// See https://github.com/Knickedi/banshee-remote for more.
public static void CompressDatabase()
{
if (Timestamp() - _dbCompressTime < _DB_CACHED_COMPRESSION)
{
return;
}
try {
_dbCompressTime = Timestamp();
File.Delete(DatabasePath(true));
File.Delete(DatabasePath(true) + "-journal");
File.Copy(DatabasePath(false), DatabasePath(true));
// database was in use, unlock it or queries will just fail
HyenaSqliteConnection db = new HyenaSqliteConnection(DatabasePath(true));
db.BeginTransaction();
db.CommitTransaction();
db.Dispose();
db = new HyenaSqliteConnection(DatabasePath(true));
db.BeginTransaction();
IDataReader cursor = db.Query(
"SELECT tbl_name FROM sqlite_master WHERE "
+ "type='table' AND tbl_name NOT IN "
+ "('CoreTracks', 'CoreArtists', 'CoreAlbums', 'sqlite_stat1', 'sqlite_stat2');");
// drop unnecessary tables
while (cursor.Read())
{
db.Execute("DROP TABLE " + cursor.Get(0, typeof(string)) + ";");
}
// clear analytic data (if available)
if (db.TableExists("sqlite_stat1"))
{
db.Execute("DELETE FROM sqlite_stat1;");
}
if (db.TableExists("sqlite_stat2"))
{
db.Execute("DELETE FROM sqlite_stat2;");
}
cursor.Dispose();
// remove unecessary columns from tracks table
db.Execute("CREATE TABLE tracks (\n"
+ " _id INTEGER PRIMARY KEY,\n"
+ " artistId INTEGER,\n"
+ " albumId INTEGER,\n"
+ " title TEXT,\n"
+ " trackNumber INTEGER,\n"
+ " duration INTEGER,\n"
+ " year INTEGER,\n"
+ " genre TEXT,\n"
+ " rating INTEGER\n"
+ ");");
db.Execute("INSERT INTO tracks(_id, artistId, albumId, "
+ "title, trackNumber, duration, year, genre, rating) "
+ "SELECT TrackID, ArtistID, AlbumId, "
+ "Title, TrackNumber, Duration, Year, Genre, Rating "
+ "FROM CoreTracks;");
// remove unecessary columns from artist table
db.Execute("CREATE TABLE artists (\n"
+ " _id INTEGER PRIMARY KEY,\n"
+ " name TEXT\n"
+ ");");
db.Execute("INSERT INTO artists(_id, name) "
+ "SELECT ArtistID, Name FROM CoreArtists;");
// remove unecessary columns from album table
db.Execute("CREATE TABLE albums (\n"
+ " _id INTEGER PRIMARY KEY,\n"
+ " artistId INTEGER,\n"
+ " title TEXT,\n"
+ " artId TEXT\n"
+ ");");
if (db.ColumnExists("CoreAlbums", "ArtworkID"))
{
db.Execute("INSERT INTO albums(_id, artistId, title, artId) "
+ "SELECT AlbumID, ArtistID, Title, ArtworkID FROM CoreAlbums;");
}
else
{
// old banshee versions don't cache the cover ID - fix that manually
Dictionary <int, string> artists = new Dictionary <int, string>();
IDataReader r = db.Query("SELECT ArtistId, Name FROM CoreArtists;");
while (r.Read())
{
artists.Add(r.Get <int>(0), r.Get <string>(1));
}
r.Dispose();
r = db.Query("SELECT AlbumID, ArtistID, Title FROM CoreAlbums;");
while (r.Read())
{
int artistId = r.Get <int>(1);
string album = r.Get <string>(2);
string artId = "";
string artist = null;
if (artists.TryGetValue(artistId, out artist))
{
artId = CoverArtSpec.CreateArtistAlbumId(artist ?? "", album ?? "").Replace("'", "''");
}
db.Execute("INSERT INTO albums(_id, artistId, title, artId) VALUES ("
+ r.Get <int>(0) + "," + artistId + ","
+ "'" + (album ?? "").Replace("'", "''") + "', "
+ "'" + artId + "');");
}
r.Dispose();
}
db.Execute("DROP TABLE CoreTracks;");
db.Execute("DROP TABLE CoreArtists;");
db.Execute("DROP TABLE CoreAlbums;");
db.CommitTransaction();
db.Execute("VACUUM;");
db.Dispose();
SetDbCompressTimeFromFile();
} catch (Exception e) {
Log.Error("remote listener failed to compress database: " + e.Message);
File.Delete(DatabasePath(true));
}
}
internal void Execute (HyenaSqliteConnection hconnection, Connection connection)
{
if (finished) {
throw new Exception ("Command is already set to finished; result needs to be claimed before command can be rerun");
}
execution_exception = null;
result = null;
int execution_ms = 0;
string command_text = null;
try {
command_text = CurrentSqlText;
ticks = System.Environment.TickCount;
switch (CommandType) {
case HyenaCommandType.Reader:
using (var reader = connection.Query (command_text)) {
result = new ArrayDataReader (reader, command_text);
}
break;
case HyenaCommandType.Scalar:
result = connection.Query<object> (command_text);
break;
case HyenaCommandType.Execute:
default:
connection.Execute (command_text);
result = connection.LastInsertRowId;
break;
}
execution_ms = System.Environment.TickCount - ticks;
if (log_all) {
Log.DebugFormat ("Executed in {0}ms {1}", execution_ms, command_text);
} else if (Log.Debugging && execution_ms > 500) {
Log.WarningFormat ("Executed in {0}ms {1}", execution_ms, command_text);
}
} catch (Exception e) {
Log.DebugFormat ("Exception executing command: {0}", command_text ?? command);
Log.Exception (e);
execution_exception = e;
}
// capture the text
string raise_text = null;
if (raise_command_executed && execution_ms >= raise_command_executed_threshold_ms) {
raise_text = Text;
}
finished_event.Reset ();
finished = true;
if (raise_command_executed && execution_ms >= raise_command_executed_threshold_ms) {
var handler = CommandExecuted;
if (handler != null) {
// Don't raise this on this thread; this thread is dedicated for use by the db connection
ThreadAssist.ProxyToMain (delegate {
handler (this, new CommandExecutedArgs (raise_text, execution_ms));
});
}
}
}
internal object WaitForResult (HyenaSqliteConnection conn)
{
while (!finished) {
conn.ResultReadySignal.WaitOne ();
}
// Reference the results since they could be overwritten
object ret = result;
var exception = execution_exception;
// Reset to false in case run again
finished = false;
conn.ClaimResult ();
finished_event.Set ();
if (exception != null) {
throw exception;
}
return ret;
}
public BansheeDbFormatMigrator(HyenaSqliteConnection connection)
{
this.connection = connection;
}
public BansheeDbFormatMigrator (HyenaSqliteConnection connection)
{
this.connection = connection;
}
public QuestionProvider(HyenaSqliteConnection connection) : base(connection)
{
Init();
}
public FeedProvider(HyenaSqliteConnection connection) : base(connection, "PodcastSyndications")
{
}
public FeedItemProvider(HyenaSqliteConnection connection) : base(connection, "PodcastItems")
{
}
public void Init()
{
connection = new HyenaSqliteConnection("test.db");
provider = new ModelProvider(connection);
}
internal void Execute (HyenaSqliteConnection hconnection, SqliteConnection connection)
{
if (finished) {
throw new Exception ("Command is already set to finished; result needs to be claimed before command can be rerun");
}
execution_exception = null;
result = null;
int execution_ms = 0;
using (SqliteCommand sql_command = new SqliteCommand (CurrentSqlText)) {
sql_command.Connection = connection;
hconnection.OnExecuting (sql_command);
try {
ticks = System.Environment.TickCount;
switch (CommandType) {
case HyenaCommandType.Reader:
using (SqliteDataReader reader = sql_command.ExecuteReader ()) {
result = new HyenaSqliteArrayDataReader (reader);
}
break;
case HyenaCommandType.Scalar:
result = sql_command.ExecuteScalar ();
break;
case HyenaCommandType.Execute:
default:
sql_command.ExecuteNonQuery ();
result = sql_command.LastInsertRowID ();
break;
}
execution_ms = System.Environment.TickCount - ticks;
if (log_all) {
Log.DebugFormat ("Executed in {0}ms {1}", execution_ms, sql_command.CommandText);
}
} catch (Exception e) {
Log.DebugFormat ("Exception executing command: {0}", sql_command.CommandText);
execution_exception = e;
}
}
// capture the text
string raise_text = null;
if (raise_command_executed && execution_ms >= raise_command_executed_threshold_ms) {
raise_text = Text;
}
finished_event.Reset ();
finished = true;
if (raise_command_executed && execution_ms >= raise_command_executed_threshold_ms) {
var handler = CommandExecuted;
if (handler != null) {
// Don't raise this on this thread; this thread is dedicated for use by the db connection
ThreadAssist.ProxyToMain (delegate {
handler (this, new CommandExecutedArgs (raise_text, execution_ms));
});
}
}
}
public ModelProvider(HyenaSqliteConnection connection) : base(connection)
{
Init();
}
public DbSampleStore(HyenaSqliteConnection conn, string tableName) : base(conn, tableName, true)
{
this.conn = conn;
}
public void Init ()
{
connection = new HyenaSqliteConnection ("test.db");
provider = new ModelProvider (connection);
}
protected override void ImportCore()
{
LibraryImportManager import_manager = ServiceManager.Get <LibraryImportManager> ();
HyenaSqliteConnection conn;
try {
conn = new HyenaSqliteConnection(amarok_db_path);
} catch (Exception e) {
LogError(amarok_db_path, String.Format(
"Unable to open Amarok database: {0}", e.Message));
return;
}
int count = 0;
try {
count = conn.Query <int> ("SELECT COUNT(*) FROM tags");
} catch (Exception) {}
try {
HyenaSqliteCommand cmd = new HyenaSqliteCommand(@"
SELECT DISTINCT NULL,
tags.url,
tags.title,
artist.name,
genre.name,
album.name,
year.name,
tags.track,
tags.length
FROM tags,
artist,
album,
genre,
year
WHERE tags.deviceid = -1
AND tags.artist = artist.id
AND tags.album = album.id
AND tags.genre = genre.id
AND tags.year = year.id"
);
HyenaSqliteCommand stats_cmd = new HyenaSqliteCommand(@"
SELECT DISTINCT (rating+rating%2)/2, playcounter, createdate, accessdate
FROM statistics
WHERE url = ? AND deviceid = -1");
int processed = 0;
IDataReader reader = conn.Query(cmd);
while (reader.Read())
{
if (CheckForCanceled())
{
break;
}
processed++;
try {
string path = (string)reader[1];
SafeUri uri = null;
if (path.StartsWith("./"))
{
uri = new SafeUri(path.Substring(1));
}
else if (path.StartsWith("/"))
{
uri = new SafeUri(path);
}
else
{
continue;
}
string title = (string)reader[2];
string artist = (string)reader[3];
//Console.WriteLine ("Amarok import has {0}/{1} - {2}", artist, title, uri);
// the following fields are not critical and can be skipped if something goes wrong
int rating = 0, playcount = 0;
long created = 0, accessed = 0;
// Try to read stats
try {
IDataReader stats_reader = conn.Query(stats_cmd, path);
while (stats_reader.Read())
{
rating = Convert.ToInt32(stats_reader[0]);
playcount = Convert.ToInt32(stats_reader[1]);
created = Convert.ToInt64(stats_reader[2]);
accessed = Convert.ToInt64(stats_reader[3]);
}
stats_reader.Dispose();
} catch (Exception) {}
UpdateUserJob(processed, count, artist, title);
try {
DatabaseTrackInfo track = import_manager.ImportTrack(uri);
if (track == null)
{
throw new Exception(String.Format(Catalog.GetString("Unable to import track: {0}"), uri.AbsoluteUri));
}
if (rating > 0 || playcount > 0 || created > 0 || accessed > 0)
{
track.Rating = rating;
track.PlayCount = playcount;
if (created > 0)
{
track.DateAdded = Hyena.DateTimeUtil.FromTimeT(created);
}
if (accessed > 0)
{
track.LastPlayed = Hyena.DateTimeUtil.FromTimeT(accessed);
}
track.Save(false);
}
} catch (Exception e) {
LogError(SafeUri.UriToFilename(uri), e);
}
} catch (Exception e) {
Hyena.Log.Exception(e);
// something went wrong, skip entry
}
}
reader.Dispose();
import_manager.NotifyAllSources();
// TODO migrating more than the podcast subscriptions (eg whether to auto sync them etc) means 1) we need to have those features
// and 2) we need to depend on Migo and/or the Podcast extension
DBusCommandService cmd_service = ServiceManager.Get <DBusCommandService> ();
if (cmd_service != null && ServiceManager.DbConnection.TableExists("PodcastSyndications"))
{
foreach (string podcast_url in conn.QueryEnumerable <string> ("SELECT url FROM podcastchannels"))
{
cmd_service.PushFile(podcast_url.Replace("http:", "feed:"));
}
}
} catch (Exception e) {
Hyena.Log.Exception(e);
LogError(amarok_db_path, Catalog.GetString("Importing from Amarok failed"));
} finally {
conn.Dispose();
}
}
public MigoModelProvider(HyenaSqliteConnection connection, string table_name) : base(connection, table_name)
{
}
protected override void ImportCore ()
{
LibraryImportManager import_manager = ServiceManager.Get<LibraryImportManager> ();
HyenaSqliteConnection conn;
try {
conn = new HyenaSqliteConnection (amarok_db_path);
} catch (Exception e) {
LogError (amarok_db_path, String.Format (
"Unable to open Amarok database: {0}", e.Message));
return;
}
int count = 0;
try {
count = conn.Query<int> ("SELECT COUNT(*) FROM tags");
} catch (Exception) {}
try {
HyenaSqliteCommand cmd = new HyenaSqliteCommand (@"
SELECT DISTINCT NULL,
tags.url,
tags.title,
artist.name,
genre.name,
album.name,
year.name,
tags.track,
tags.length
FROM tags,
artist,
album,
genre,
year
WHERE tags.deviceid = -1
AND tags.artist = artist.id
AND tags.album = album.id
AND tags.genre = genre.id
AND tags.year = year.id"
);
HyenaSqliteCommand stats_cmd = new HyenaSqliteCommand (@"
SELECT DISTINCT (rating+rating%2)/2, playcounter, createdate, accessdate
FROM statistics
WHERE url = ? AND deviceid = -1");
int processed = 0;
IDataReader reader = conn.Query (cmd);
while (reader.Read ()) {
if (CheckForCanceled ())
break;
processed++;
try {
string path = (string) reader[1];
SafeUri uri = null;
if (path.StartsWith ("./")) {
uri = new SafeUri (path.Substring (1));
} else if (path.StartsWith ("/")) {
uri = new SafeUri (path);
} else {
continue;
}
string title = (string) reader[2];
string artist = (string) reader[3];
//Console.WriteLine ("Amarok import has {0}/{1} - {2}", artist, title, uri);
// the following fields are not critical and can be skipped if something goes wrong
int rating = 0, playcount = 0;
long created = 0, accessed = 0;
// Try to read stats
try {
IDataReader stats_reader = conn.Query (stats_cmd, path);
while (stats_reader.Read ()) {
rating = Convert.ToInt32 (stats_reader[0]);
playcount = Convert.ToInt32 (stats_reader[1]);
created = Convert.ToInt64 (stats_reader[2]);
accessed = Convert.ToInt64 (stats_reader[3]);
}
stats_reader.Dispose ();
} catch (Exception) {}
UpdateUserJob (processed, count, artist, title);
try {
DatabaseTrackInfo track = import_manager.ImportTrack (uri);
if (track == null) {
throw new Exception (String.Format (Catalog.GetString ("Unable to import track: {0}"), uri.AbsoluteUri));
}
if (rating > 0 || playcount > 0 || created > 0 || accessed > 0) {
track.Rating = rating;
track.PlayCount = playcount;
if (created > 0)
track.DateAdded = Hyena.DateTimeUtil.FromTimeT (created);
if (accessed > 0)
track.LastPlayed = Hyena.DateTimeUtil.FromTimeT (accessed);
track.Save (false);
}
} catch (Exception e) {
LogError (SafeUri.UriToFilename (uri), e);
}
} catch (Exception e) {
Hyena.Log.Exception (e);
// something went wrong, skip entry
}
}
reader.Dispose ();
import_manager.NotifyAllSources ();
// TODO migrating more than the podcast subscriptions (eg whether to auto sync them etc) means 1) we need to have those features
// and 2) we need to depend on Migo and/or the Podcast extension
DBusCommandService cmd_service = ServiceManager.Get<DBusCommandService> ();
if (cmd_service != null && ServiceManager.DbConnection.TableExists ("PodcastSyndications")) {
foreach (string podcast_url in conn.QueryEnumerable<string> ("SELECT url FROM podcastchannels")) {
cmd_service.PushFile (podcast_url.Replace ("http:", "feed:"));
}
}
} catch (Exception e) {
Hyena.Log.Exception (e);
LogError (amarok_db_path, Catalog.GetString ("Importing from Amarok failed"));
} finally {
conn.Dispose ();
}
}
public void ExecuteMustDisposeSqliteCommand ()
{
using(var connection = new HyenaSqliteConnection (":memory:")) {
bool disposed = false;
connection.Executing += delegate (object sender, ExecutingEventArgs args) {
args.Command.Disposed += delegate {
disposed = true;
};
};
connection.Query<int> ("SELECT 42");
Assert.IsTrue (disposed);
}
}
private void OnClientUpdated(object o, EventArgs args)
{
try {
if (database == null && client.Databases.Count > 0)
{
database = client.Databases[0];
DaapService.ProxyServer.RegisterDatabase(database);
database.TrackAdded += OnDatabaseTrackAdded;
database.TrackRemoved += OnDatabaseTrackRemoved;
SetStatus(String.Format(Catalog.GetPluralString(
"Loading {0} track", "Loading {0} tracks", database.TrackCount),
database.TrackCount), false
);
// Notify (eg reload the source before sync is done) at most 5 times
int notify_every = Math.Max(250, (database.Tracks.Count / 4));
notify_every -= notify_every % 250;
int count = 0;
DaapTrackInfo daap_track = null;
HyenaSqliteConnection conn = ServiceManager.DbConnection;
conn.BeginTransaction();
foreach (DAAP.Track track in database.Tracks)
{
daap_track = new DaapTrackInfo(track, this);
// Only notify once in a while because otherwise the source Reloading slows things way down
if (++count % notify_every == 0)
{
conn.CommitTransaction();
daap_track.Save(true);
conn.BeginTransaction();
}
else
{
daap_track.Save(false);
}
}
conn.CommitTransaction();
// Save the last track once more to trigger the NotifyTrackAdded
if (daap_track != null)
{
daap_track.Save();
}
SetStatus(Catalog.GetString("Loading playlists"), false);
AddPlaylistSources();
connected = true;
Reload();
HideStatus();
}
Name = client.Name;
UpdateIcon();
OnUpdated();
} catch (Exception e) {
Hyena.Log.Exception("Caught exception while loading daap share", e);
ThreadAssist.ProxyToMain(delegate {
HideStatus();
ShowErrorView(DaapErrorType.UserDisconnect);
});
}
}
public void Execute(HyenaSqliteConnection db, Version db_version)
{
code ();
if (!silent) {
Log.DebugFormat ("Updated database from version {0} to {1}",
db_version.ToString (),
Version.ToString ());
}
db_version = Version;
db.Execute (new HyenaSqliteCommand ("UPDATE meta SET data = ? WHERE name = ?", db_version.ToString (), meta_db_version_string));
}
