public static IAsyncActionWithProgress <double> ClearCachedGalleriesAsync()
{
return(Run <double>(async(token, progress) =>
{
using (var db = new GalleryDb())
{
var folder = GalleryImage.ImageFolder ?? await GalleryImage.GetImageFolderAsync();
var todelete = await db.ImageSet
.Where(im => !db.SavedSet.Any(sm => im.UsingBy.Any(gi => gi.GalleryId == sm.GalleryId)))
.ToListAsync(token);
double count = todelete.Count;
var i = 0;
foreach (var item in todelete)
{
var file = await folder.TryGetFileAsync(item.FileName);
if (file != null)
{
await file.DeleteAsync();
}
progress.Report(++i / count);
}
db.ImageSet.RemoveRange(todelete);
await db.SaveChangesAsync();
}
}));
}
/// <summary>
/// Operations to be performed during the downgrade process.
/// </summary>
public override void Down()
{
using (var ctx = new GalleryDb())
{
var asDataSchema = ctx.AppSettings.First(a => a.SettingName == "DataSchemaVersion");
asDataSchema.SettingValue = "3.0.0";
ctx.SaveChanges();
}
}
/// <summary>
/// Operations to be performed during the downgrade process.
/// </summary>
public override void Down()
{
using (var ctx = new GalleryDb())
{
var asDataSchema = ctx.AppSettings.First(a => a.SettingName == "DataSchemaVersion");
asDataSchema.SettingValue = "3.0.1";
ctx.SaveChanges();
}
}
public virtual IAsyncActionWithProgress <SaveGalleryProgress> SaveAsync(ConnectionStrategy strategy)
{
return(Run <SaveGalleryProgress>(async(token, progress) =>
{
if (this.HasMoreItems)
{
progress.Report(new SaveGalleryProgress(-1, this.RecordCount));
while (this.HasMoreItems)
{
await this.LoadMoreItemsAsync((uint)PageSize);
token.ThrowIfCancellationRequested();
}
}
await Task.Delay(0).ConfigureAwait(false);
var loadedCount = 0;
progress.Report(new SaveGalleryProgress(loadedCount, this.RecordCount));
using (var semaphore = new SemaphoreSlim(16, 16))
{
var loadTasks = this.Select(image => Task.Run(async() =>
{
await semaphore.WaitAsync();
try
{
token.ThrowIfCancellationRequested();
await image.LoadImageAsync(false, strategy, true);
Interlocked.Increment(ref loadedCount);
progress.Report(new SaveGalleryProgress(loadedCount, this.RecordCount));
}
finally
{
semaphore.Release();
}
})).ToArray();
await Task.WhenAll(loadTasks).ConfigureAwait(false);
}
using (var db = new GalleryDb())
{
var gid = this.ID;
var myModel = db.SavedSet.SingleOrDefault(model => model.GalleryId == gid);
if (myModel == null)
{
db.SavedSet.Add(new SavedGalleryModel().Update(this));
}
else
{
myModel.Update(this);
}
await db.SaveChangesAsync();
}
}));
}
public override IAsyncAction DeleteAsync()
{
return(Task.Run(async() =>
{
using (var db = new GalleryDb())
{
var gid = this.ID;
db.SavedSet.Remove(db.SavedSet.Single(c => c.GalleryId == gid));
await db.SaveChangesAsync();
}
await base.DeleteAsync();
}).AsAsyncAction());
}
/// <summary>
/// Get thumb image of a gallery with local cache.
/// </summary>
/// <param name="exact"><see langword="true"/> if thumb of first image of the gallery must be used, otherwise, first cached image in the galley will be used.</param>
/// <param name="bitmap">Bitmap to write thumb data into.</param>
/// <returns>Local thumb found.</returns>
private static async Task <bool> getThumbLocalilyAsync(Gallery gallery, bool exact, BitmapImage bitmap)
{
GalleryImageModel getImageModel(long gId, bool ex)
{
using (var db = new GalleryDb())
{
db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
if (ex)
{
return(db.GalleryImageSet
.Include(gi => gi.Image)
.Where(gi => gi.GalleryId == gId && gi.PageId == 1)
.FirstOrDefault());
}
else
{
return(db.GalleryImageSet
.Include(gi => gi.Image)
.Where(gi => gi.GalleryId == gId)
.OrderBy(gi => gi.PageId)
.FirstOrDefault());
}
}
}
var imageModel = getImageModel(gallery.Id, exact);
if (imageModel is null)
{
return(false);
}
var file = await StorageHelper.ImageFolder.TryGetFileAsync(imageModel.Image.FileName);
if (file is null)
{
return(false);
}
try
{
using (var stream = await file.GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.SingleItem))
{
await bitmap.SetSourceAsync(stream);
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public override void Down()
{
DropIndex("gsp.Metadata", "UC_Metadata_MetaName_MetadataId");
AlterColumn("gsp.Metadata", "RawValue", c => c.String(maxLength: 1000));
using (var ctx = new GalleryDb())
{
var asDataSchema = ctx.AppSettings.First(a => a.SettingName == "DataSchemaVersion");
asDataSchema.SettingValue = "3.1.0";
ctx.SaveChanges();
}
}
public static IAsyncOperation <ObservableList <Gallery> > LoadList()
{
return(Task.Run <ObservableList <Gallery> >(() =>
{
using (var db = new GalleryDb())
{
db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
var query = db.SavedSet
.OrderByDescending(s => s.saved)
.Select(s => s.Gallery);
return new SavedGalleryList(query.ToList());
}
}).AsAsyncOperation());
}
public override void Down()
{
DropIndex("gsp.Metadata", "UC_Metadata_MetaName_MetadataId");
AlterColumn("gsp.Metadata", "RawValue", c => c.String(maxLength: 1000));
using (var ctx = new GalleryDb())
{
var asDataSchema = ctx.AppSettings.First(a => a.SettingName == "DataSchemaVersion");
asDataSchema.SettingValue = "3.1.0";
ctx.SaveChanges();
}
}
/// <summary>
/// Verify there are gallery settings for the current gallery that match every template gallery setting, creating any
/// if necessary.
/// </summary>
/// <returns><c>true</c> if data was changed that necessitates reloading data from the data store, <c>false</c> otherwise.</returns>
private bool ConfigureGallerySettingsTable()
{
var foundTmplGallerySettings = false;
var needToClearCache = false;
using (var repo = new GallerySettingRepository())
{
//repo.Load();
var gallerySettingNamesInGallery = repo.Where(gs => gs.FKGalleryId == GalleryId).Select(gs => gs.SettingName).ToList();
// Loop through each template gallery setting.
foreach (var gsTmpl in repo.Where(g => g.Gallery.IsTemplate))
{
foundTmplGallerySettings = true;
//if (!repo.Local.Any(gs => gs.SettingName == gsTmpl.SettingName && gs.FKGalleryId == GalleryId))
//if (!repo.Where(gs => gs.SettingName == gsTmpl.SettingName && gs.FKGalleryId == GalleryId).Any())
if (!gallerySettingNamesInGallery.Contains(gsTmpl.SettingName))
{
// This gallery is missing an entry for a gallery setting. Create one by copying it from the template gallery.
repo.Add(new GallerySettingDto()
{
FKGalleryId = GalleryId,
SettingName = gsTmpl.SettingName,
SettingValue = gsTmpl.SettingValue
});
needToClearCache = true;
}
}
repo.Save();
}
if (!foundTmplGallerySettings)
{
// If there weren't *any* template gallery settings, insert the seed data. Generally this won't be necessary, but it
// can help recover from certain conditions, such as when a SQL Server connection is accidentally specified without
// the MultipleActiveResultSets keyword (or it was false). In this situation the galleries are inserted but an error
// prevents the remaining data from being inserted. Once the user corrects this and tries again, this code can run to
// finish inserting the seed data.
using (var ctx = new GalleryDb())
{
SeedController.InsertSeedData(ctx);
}
Factory.ValidateGalleries();
}
return(needToClearCache);
}
public static IAsyncOperation <ObservableList <Gallery> > LoadList()
{
return(Task.Run <ObservableList <Gallery> >(() =>
{
using (var db = new GalleryDb())
{
db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
var query = from gm in db.GallerySet
where gm.Images.Count != 0
where !db.SavedSet.Any(sm => sm.GalleryId == gm.GalleryModelId)
orderby gm.posted descending
select gm;
return new CachedGalleryList(query.ToList());
}
}).AsAsyncOperation());
}
public override void Down()
{
DropColumn("gsp.Metadata", "RawValue");
DropColumn("gsp.MediaQueue", "ConversionType");
DropColumn("gsp.MediaQueue", "RotationAmount");
AddColumn("gsp.MediaObject", "HashKey", c => c.String(nullable: false, maxLength: 47));
using (var ctx = new GalleryDb())
{
var asDataSchema = ctx.AppSettings.First(a => a.SettingName == "DataSchemaVersion");
asDataSchema.SettingValue = "3.0.3";
ctx.SaveChanges();
}
}
public override void Down()
{
DropColumn("gsp.Metadata", "RawValue");
DropColumn("gsp.MediaQueue", "ConversionType");
DropColumn("gsp.MediaQueue", "RotationAmount");
AddColumn("gsp.MediaObject", "HashKey", c => c.String(nullable: false, maxLength: 47));
using (var ctx = new GalleryDb())
{
var asDataSchema = ctx.AppSettings.First(a => a.SettingName == "DataSchemaVersion");
asDataSchema.SettingValue = "3.0.3";
ctx.SaveChanges();
}
}
/// <summary>
/// Operations to be performed during the downgrade process.
/// </summary>
public override void Down()
{
AddColumn("gsp.Album", "DateEnd", c => c.DateTime());
AddColumn("gsp.Album", "DateStart", c => c.DateTime());
// Don't actually reduce column length to 10 chars, since we'll lose data
//DropIndex("gsp.MimeType", "UC_MimeType_FileExtension");
//AlterColumn("gsp.MimeType", "FileExtension", c => c.String(nullable: false, maxLength: 10));
//CreateIndex("gsp.MimeType", "FileExtension", true, "UC_MimeType_FileExtension");
using (var ctx = new GalleryDb())
{
var asDataSchema = ctx.AppSettings.First(a => a.SettingName == "DataSchemaVersion");
asDataSchema.SettingValue = "3.2.1";
ctx.SaveChanges();
}
}
protected override IAsyncAction InitOverrideAsync()
{
return(Task.Run(async() =>
{
using (var db = new GalleryDb())
{
db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
var gid = this.ID;
var models = db.GalleryImageSet
.Include(gi => gi.Image)
.Where(gi => gi.GalleryId == gid);
foreach (var item in models)
{
await this[item.PageId - 1].PopulateCachedImageAsync(item, item.Image);
this.LoadedItems[item.PageId - 1] = true;
}
}
}).AsAsyncAction());
}
protected virtual IAsyncAction InitOverrideAsync()
{
return(Task.Run(() =>
{
using (var db = new GalleryDb())
{
var gid = Id;
var myModel = db.GallerySet.SingleOrDefault(model => model.GalleryModelId == gid);
if (myModel is null)
{
db.GallerySet.Add(new GalleryModel().Update(this));
}
else
{
myModel.Update(this);
}
db.SaveChanges();
}
}).AsAsyncAction());
}
internal void LoadImageModels()
{
if (this.GalleryImageModels != null)
{
return;
}
this.GalleryImageModels = new GalleryImageModel[this.RecordCount];
using (var db = new GalleryDb())
{
db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
var gid = this.ID;
var models = db.GalleryImageSet
.Include(gi => gi.Image)
.Where(gi => gi.GalleryId == gid);
foreach (var item in models)
{
this.GalleryImageModels[item.PageId - 1] = item;
}
}
}
public static IAsyncOperation <Gallery> TryLoadGalleryAsync(long galleryId)
{
return(Task.Run(async() =>
{
using (var db = new GalleryDb())
{
db.ChangeTracker.QueryTrackingBehavior = Microsoft.EntityFrameworkCore.QueryTrackingBehavior.NoTracking;
var cm = db.SavedSet.SingleOrDefault(c => c.GalleryId == galleryId);
var gm = db.GallerySet.SingleOrDefault(g => g.GalleryModelId == galleryId);
if (gm == null)
{
return null;
}
var r = (cm == null) ?
new Gallery(gm) :
new SavedGallery(gm);
await r.InitAsync();
return r;
}
}).AsAsyncOperation());
}
protected IAsyncOperation <ImageSource> GetThumbLocalilyAsync()
{
return(Run <ImageSource>(async token =>
{
using (var db = new GalleryDb())
{
db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
var gId = this.ID;
var imageModel = db.GalleryImageSet
.Include(gi => gi.Image)
.Where(gi => gi.GalleryId == gId)
.OrderBy(gi => gi.PageId)
.FirstOrDefault();
if (imageModel is null)
{
return null;
}
var folder = GalleryImage.ImageFolder ?? await GalleryImage.GetImageFolderAsync();
var file = await folder.TryGetFileAsync(imageModel.Image.FileName);
if (file is null)
{
return null;
}
try
{
using (var stream = await file.GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.SingleItem))
{
await CoreApplication.MainView.Dispatcher.Yield();
var image = new BitmapImage();
await image.SetSourceAsync(stream);
return image;
}
}
catch (Exception)
{
return null;
}
}
}));
}
public static IAsyncActionWithProgress <double> ClearAllGalleriesAsync()
{
return(Run <double>(async(token, progress) =>
{
progress.Report(double.NaN);
var getFiles = StorageHelper.ImageFolder.GetFilesAsync();
using (var db = new GalleryDb())
{
db.SavedSet.RemoveRange(db.SavedSet);
db.ImageSet.RemoveRange(db.ImageSet);
await db.SaveChangesAsync();
}
var files = await getFiles;
double c = files.Count;
var i = 0;
foreach (var item in files)
{
await item.DeleteAsync();
progress.Report(++i / c);
}
}));
}
protected IAsyncOperation <SoftwareBitmap> GetThumbLocalilyAsync()
{
return(Run(async token =>
{
using (var db = new GalleryDb())
{
db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
var gId = this.ID;
var imageModel = db.GalleryImageSet
.Include(gi => gi.Image)
.Where(gi => gi.GalleryId == gId)
.OrderBy(gi => gi.PageId)
.FirstOrDefault();
if (imageModel == null)
{
return null;
}
var folder = GalleryImage.ImageFolder ?? await GalleryImage.GetImageFolderAsync();
var file = await folder.TryGetFileAsync(imageModel.Image.FileName);
if (file == null)
{
return null;
}
try
{
using (var stream = await file.GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.SingleItem))
{
var decoder = await BitmapDecoder.CreateAsync(stream);
return await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
}
}
catch (Exception)
{
return null;
}
}
}));
}
public virtual IAsyncActionWithProgress <SaveGalleryProgress> SaveAsync(ConnectionStrategy strategy)
{
return(Run <SaveGalleryProgress>((token, progress) => Task.Run(async() =>
{
await Task.Yield();
progress.Report(new SaveGalleryProgress(-1, Count));
var loadOP = LoadItemsAsync(0, Count);
token.Register(loadOP.Cancel);
await loadOP;
token.ThrowIfCancellationRequested();
var loadedCount = 0;
progress.Report(new SaveGalleryProgress(loadedCount, Count));
using (var semaphore = new SemaphoreSlim(10, 10))
{
async Task loadSingleImage(GalleryImage i)
{
try
{
Debug.WriteLine($"Start {i.PageId}");
token.ThrowIfCancellationRequested();
var firstFailed = false;
try
{
var firstChance = i.LoadImageAsync(false, strategy, true);
var firstTask = firstChance.AsTask(token);
var c = await Task.WhenAny(Task.Delay(30_000), firstTask);
if (c != firstTask)
{
Debug.WriteLine($"Timeout 1st {i.PageId}");
firstFailed = true;
firstChance.Cancel();
}
}
catch (Exception)
{
Debug.WriteLine($"Fail 1st {i.PageId}");
firstFailed = true;
}
if (firstFailed)
{
Debug.WriteLine($"Retry {i.PageId}");
token.ThrowIfCancellationRequested();
await i.LoadImageAsync(true, strategy, true).AsTask(token);
}
progress.Report(new SaveGalleryProgress(Interlocked.Increment(ref loadedCount), Count));
Debug.WriteLine($"Success {i.PageId}");
}
finally
{
semaphore.Release();
Debug.WriteLine($"End {i.PageId}");
}
}
var pendingTasks = new List <Task>(Count);
await Task.Run(async() =>
{
foreach (var item in this)
{
await semaphore.WaitAsync().ConfigureAwait(false);
pendingTasks.Add(loadSingleImage(item));
}
}, token).ConfigureAwait(false);
await Task.WhenAll(pendingTasks).ConfigureAwait(false);
}
using (var db = new GalleryDb())
{
var gid = Id;
var myModel = db.SavedSet.SingleOrDefault(model => model.GalleryId == gid);
if (myModel is null)
{
db.SavedSet.Add(new SavedGalleryModel().Update(this));
}
else
{
myModel.Update(this);
}
await db.SaveChangesAsync();
}
})));
}
public virtual IAsyncActionWithProgress <SaveGalleryProgress> SaveAsync(ConnectionStrategy strategy)
{
return(Run <SaveGalleryProgress>((token, progress) => Task.Run(async() =>
{
await Task.Yield();
progress.Report(new SaveGalleryProgress(-1, this.Count));
var loadOP = LoadItemsAsync(0, this.Count);
token.Register(loadOP.Cancel);
await loadOP;
token.ThrowIfCancellationRequested();
var loadedCount = 0;
progress.Report(new SaveGalleryProgress(loadedCount, this.Count));
using (var semaphore = new SemaphoreSlim(16, 16))
{
var loadTasks = this.Select(image => Task.Run(async() =>
{
await semaphore.WaitAsync();
try
{
token.ThrowIfCancellationRequested();
var firstFailed = false;
try
{
var firstChance = image.LoadImageAsync(false, strategy, true);
var firstTask = firstChance.AsTask(token);
var c = await Task.WhenAny(Task.Delay(30_000), firstTask);
if (c != firstTask)
{
firstFailed = true;
firstChance.Cancel();
}
}
catch (Exception)
{
firstFailed = true;
}
if (firstFailed)
{
token.ThrowIfCancellationRequested();
await image.LoadImageAsync(false, strategy, true).AsTask(token);
}
progress.Report(new SaveGalleryProgress(Interlocked.Increment(ref loadedCount), this.Count));
}
finally
{
semaphore.Release();
}
})).ToArray();
await Task.WhenAll(loadTasks).ConfigureAwait(false);
}
using (var db = new GalleryDb())
{
var gid = this.ID;
var myModel = db.SavedSet.SingleOrDefault(model => model.GalleryId == gid);
if (myModel is null)
{
db.SavedSet.Add(new SavedGalleryModel().Update(this));
}
else
{
myModel.Update(this);
}
await db.SaveChangesAsync();
}
})));
}
