/// <summary>
/// Start finding missing rhthms
/// </summary>
/// <param name="onlyPoemsWithRhymes"></param>
/// <param name="poemsNum"></param>
/// <returns></returns>
public RServiceResult <bool> StartFindingMissingRhythms(bool onlyPoemsWithRhymes, int poemsNum = 1000)
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob($"StartFindingMissingRhythms", "Query data")).Result;
try
{
var poemIds = await context.GanjoorPoems.AsNoTracking()
.Where(p =>
p.GanjoorMetreId == null && (onlyPoemsWithRhymes == false || !string.IsNullOrEmpty(p.RhymeLetters))
&&
false == (context.GanjoorVerses.Where(v => v.PoemId == p.Id && (v.VersePosition == VersePosition.Paragraph || v.VersePosition == VersePosition.Single)).Any())
&&
false == (context.GanjoorPoemProbableMetres.Where(r => r.PoemId == p.Id).Any())
)
.Take(poemsNum)
.Select(p => p.Id)
.ToArrayAsync();
await jobProgressServiceEF.UpdateJob(job.Id, 0, $"Total: {poemIds.Length}");
var metres = await context.GanjoorMetres.OrderBy(m => m.Rhythm).AsNoTracking().Select(m => m.Rhythm).ToArrayAsync();
using (HttpClient httpClient = new HttpClient())
{
for (int i = 0; i < poemIds.Length; i++)
{
var id = poemIds[i];
var res = await _FindPoemRhythm(id, context, httpClient, metres, true);
if (res.Result == null)
{
res.Result = "";
}
GanjoorPoemProbableMetre prometre = new GanjoorPoemProbableMetre()
{
PoemId = id,
Metre = res.Result
};
context.GanjoorPoemProbableMetres.Add(prometre);
await jobProgressServiceEF.UpdateJob(job.Id, i);
}
}
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
});
return(new RServiceResult <bool>(true));
}
private async Task _FindCategoryPoemsRhythmsInternal(int catId, bool retag, string rhythm)
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob($"FindCategoryPoemsRhythms Cat {catId}", "Query data")).Result;
try
{
var metres = await context.GanjoorMetres.OrderBy(m => m.Rhythm).AsNoTracking().ToArrayAsync();
var rhythms = metres.Select(m => m.Rhythm).ToArray();
GanjoorMetre preDeterminedMetre = string.IsNullOrEmpty(rhythm) ? null : metres.Where(m => m.Rhythm == rhythm).Single();
var poems = await context.GanjoorPoems.Where(p => p.CatId == catId).ToListAsync();
int i = 0;
using (HttpClient httpClient = new HttpClient())
{
foreach (var poem in poems)
{
if (retag || poem.GanjoorMetreId == null)
{
await jobProgressServiceEF.UpdateJob(job.Id, i ++);
if (preDeterminedMetre == null)
{
var res = await _FindPoemRhythm(poem.Id, context, httpClient, rhythms);
if (!string.IsNullOrEmpty(res.Result))
{
poem.GanjoorMetreId = metres.Where(m => m.Rhythm == res.Result).Single().Id;
context.GanjoorPoems.Update(poem);
await context.SaveChangesAsync();
}
}
else
{
poem.GanjoorMetreId = preDeterminedMetre.Id;
context.GanjoorPoems.Update(poem);
await context.SaveChangesAsync();
}
if (poem.GanjoorMetreId != null && !string.IsNullOrEmpty(poem.RhymeLetters))
{
await _UpdateRelatedPoems(context, (int)poem.GanjoorMetreId, poem.RhymeLetters);
}
}
}
}
await jobProgressServiceEF.UpdateJob(job.Id, 99);
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
}
private async Task _GeneratingSubCatsTOC(Guid userId, RMuseumDbContext context, LongRunningJobProgressServiceEF jobProgressServiceEF, RLongRunningJobStatus job, int catId)
{
foreach (var cat in await context.GanjoorCategories.AsNoTracking().Where(c => c.ParentId == catId).ToListAsync())
{
await jobProgressServiceEF.UpdateJob(job.Id, cat.Id);
var page = await context.GanjoorPages.Where(p => p.FullUrl == cat.FullUrl).SingleAsync();
context.GanjoorPageSnapshots.Add
(
new GanjoorPageSnapshot()
{
GanjoorPageId = page.Id,
MadeObsoleteByUserId = userId,
HtmlText = page.HtmlText,
Note = "تولید گروهی فهرستهای زیربخشها",
RecordDate = DateTime.Now
}
);
page.HtmlText = (await _GenerateTableOfContents(context, cat.Id, GanjoorTOC.TitlesAndFirstVerse)).Result;
context.GanjoorPages.Update(page);
await context.SaveChangesAsync();
await _GeneratingSubCatsTOC(userId, context, jobProgressServiceEF, job, cat.Id);
}
}
/// <summary>
/// constructor
/// </summary>
/// <param name="context"></param>
/// <param name="backgroundTaskQueue"></param>
/// <param name="ganjoorService"></param>
/// <param name="configuration"></param>
public DonationService(RMuseumDbContext context, IBackgroundTaskQueue backgroundTaskQueue, IGanjoorService ganjoorService, IConfiguration configuration)
{
_context = context;
_backgroundTaskQueue = backgroundTaskQueue;
_ganjoorService = ganjoorService;
_configuration = configuration;
}
/// <summary>
/// parse html of https://ganjoor.net/donate/ and fill the records
/// </summary>
/// <returns></returns>
public async Task <RServiceResult <bool> > InitializeRecords()
{
if (await _context.GanjoorDonations.AnyAsync())
{
return(new RServiceResult <bool>(true));
}
try
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
await DoInitializeRecords(context);
}
}
);
}
catch (Exception exp)
{
return(new RServiceResult <bool>(false, exp.ToString()));
}
return(new RServiceResult <bool>(true));
}
/// <summary>
/// constructor
/// </summary>
/// <param name="context"></param>
/// <param name="configuration"></param>
/// <param name="simpleImageStorage"></param>
/// <param name="memoryCache"></param>
public PictureFileService(RMuseumDbContext context, IConfiguration configuration, IImageFileService simpleImageStorage, IMemoryCache memoryCache)
{
_context = context;
Configuration = configuration;
_simpleImageStorage = simpleImageStorage;
_memoryCache = memoryCache;
}
/// <summary>
/// finalize signup and assign his or him comments to him or her
/// </summary>
/// <param name="email"></param>
/// <param name="secret"></param>
/// <param name="password"></param>
/// <param name="firstName"></param>
/// <param name="sureName"></param>
/// <returns></returns>
public override async Task <RServiceResult <bool> > FinalizeSignUp(string email, string secret, string password, string firstName, string sureName)
{
RServiceResult <bool> res = await base.FinalizeSignUp(email, secret, password, firstName, sureName);
if (res.Result)
{
try
{
RMuseumDbContext context = _context as RMuseumDbContext;
var user = (await FindUserByEmail(email)).Result;
if (user.EmailConfirmed)
{
var comments = await context.GanjoorComments.Where(c => c.AuthorEmail == email.ToLower()).ToListAsync();
if (comments.Count > 0)
{
foreach (var comment in comments)
{
comment.UserId = user.Id;
}
_context.UpdateRange(comments);
await _context.SaveChangesAsync();
}
}
}
catch
{
return(new RServiceResult <bool>(true)); //ignore this error! because signup was succesfull
}
}
return(res);
}
/// <summary>
/// constructor
/// </summary>
/// <param name="context"></param>
/// <param name="pictureFileService"></param>
/// <param name="notificationService"></param>
/// <param name="appUserService"></param>
public PoetPhotoSuggestionService(RMuseumDbContext context, IPictureFileService pictureFileService, IRNotificationService notificationService, IAppUserService appUserService)
{
_context = context;
_pictureFileService = pictureFileService;
_notificationService = notificationService;
_appUserService = appUserService;
}
/// <summary>
/// start filling GanjoorLink table OriginalSource values
/// </summary>
/// <returns></returns>
public RServiceResult <bool> StartFillingGanjoorLinkOriginalSources()
{
try
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob("FillingGanjoorLinkOriginalSources", "Updating")).Result;
try
{
var links = await context.GanjoorLinks.ToListAsync();
for (int i = 0; i < links.Count; i++)
{
var link = links[i];
var itemInfo = await context.Items
.Include(i => i.Tags)
.ThenInclude(t => t.RTag)
.Where(i => i.Id == link.ItemId).SingleAsync();
var sourceTag = itemInfo.Tags.Where(t => t.RTag.FriendlyUrl == "source").FirstOrDefault();
if (sourceTag != null)
{
if (!string.IsNullOrEmpty(sourceTag.ValueSupplement) && (sourceTag.ValueSupplement.IndexOf("http") == 0))
{
link.OriginalSourceUrl = sourceTag.ValueSupplement;
link.LinkToOriginalSource = true;
context.GanjoorLinks.Update(link);
}
}
}
await context.SaveChangesAsync();
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
}
);
return(new RServiceResult <bool>(true));
}
catch (Exception exp)
{
return(new RServiceResult <bool>(false, exp.ToString()));
}
}
/// <summary>
/// start generating related poems info
/// </summary>
/// <param name="regenerate"></param>
/// <returns></returns>
public RServiceResult <bool> StartGeneratingRelatedPoemsInfo(bool regenerate)
{
try
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob("GeneratingRelatedPoemsInfo", "Query")).Result;
try
{
await jobProgressServiceEF.UpdateJob(job.Id, 0, $"Query");
var poemIds = await context.GanjoorPoems.AsNoTracking().Where(p => !string.IsNullOrEmpty(p.RhymeLetters) && p.GanjoorMetreId != null).Select(p => p.Id).ToListAsync();
await jobProgressServiceEF.UpdateJob(job.Id, 0, $"Updating Related Poems");
int percent = 0;
for (int i = 0; i < poemIds.Count; i++)
{
if (!regenerate)
{
if (await context.GanjoorCachedRelatedPoems.AnyAsync(r => r.PoemId == poemIds[i]))
{
continue;
}
}
if (i * 100 / poemIds.Count > percent)
{
percent++;
await jobProgressServiceEF.UpdateJob(job.Id, percent);
}
await _UpdatePoemRelatedPoemsInfoNoSaveChanges(context, poemIds[i]);
}
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
}
);
return(new RServiceResult <bool>(true));
}
catch (Exception exp)
{
return(new RServiceResult <bool>(false, exp.ToString()));
}
}
private async Task _ReOrderPoemRecitationsAsync(RMuseumDbContext context, int poemId, bool update = true)
{
var recitations =
await context.Recitations
.Where(r => r.ReviewStatus == AudioReviewStatus.Approved && r.GanjoorPostId == poemId)
.OrderBy(r => r.Id) //this causes the oldest recirations to become the first one
.ToListAsync();
List <RecitationOrderingViewModel> scores = new List <RecitationOrderingViewModel>();
for (var i = 0; i < recitations.Count; i++)
{
var recitation = recitations[i];
RecitationOrderingViewModel score = new RecitationOrderingViewModel()
{
RecitationId = recitation.Id,
EarlynessAdvantage = recitations.Count - 1 - i,
UpVotes = await context.RecitationUserUpVotes.AsNoTracking().Where(r => r.RecitationId == recitation.Id && r.UserId != recitation.OwnerId)
.CountAsync(),
Mistakes = await context.RecitationApprovedMistakes.AsNoTracking().Where(m => m.RecitationId == recitation.Id).SumAsync(m => m.NumberOfLinesAffected)
};
score.TotalScores = score.EarlynessAdvantage
+ score.UpVotes
- (5 * score.Mistakes);
//audio order is used as a temporary variable in the following line and soon is get replaced by computed value
recitation.AudioOrder = score.TotalScores;
scores.Add(score);
}
recitations.Sort((a, b) => b.AudioOrder.CompareTo(a.AudioOrder));
for (var i = 0; i < recitations.Count; i++)
{
recitations[i].AudioOrder = i + 1;
scores.Where(s => s.RecitationId == recitations[i].Id).Single().ComputedOrder = i + 1;
if (update)
{
context.Update(recitations[i]);
}
}
if (update)
{
await context.SaveChangesAsync();
}
}
/// <summary>
/// examine comments for long links
/// </summary>
/// <returns></returns>
public RServiceResult <bool> FindAndFixLongUrlsInComments()
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob("FindAndFixLongUrlsInComments", "Query data")).Result;
try
{
var comments = await context.GanjoorComments.Where(c => c.HtmlComment.Contains("href=")).ToArrayAsync();
await jobProgressServiceEF.UpdateJob(job.Id, 0, $"Examining {comments.Length} Comments");
int percent = 0;
for (int i = 0; i < comments.Length; i++)
{
if (i * 100 / comments.Length > percent)
{
percent++;
await jobProgressServiceEF.UpdateJob(job.Id, percent);
}
var comment = comments[i];
string commentText = await _ProcessCommentHtml(comment.HtmlComment, context);
if (commentText != comment.HtmlComment)
{
comment.HtmlComment = commentText;
context.Update(comment);
await context.SaveChangesAsync();
}
}
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
}
);
return(new RServiceResult <bool>(true));
}
private async Task <List <GanjoorCat> > _FindTargetCategories(RMuseumDbContext context, GanjoorCat startCat, int?endCatId)
{
if (endCatId == null || startCat.Id == endCatId)
{
List <GanjoorCat> cats = new List <GanjoorCat>();
cats.Add(startCat);
cats.AddRange(await _FindAllSubCategories(context, startCat.Id));
return(cats);
}
else
{
return(await _FindCategoryRanges(context, startCat, (int)endCatId));
}
}
public GanjoorAppUserService(
RMuseumDbContext context,
UserManager <RAppUser> userManager,
SignInManager <RAppUser> signInManager,
RoleManager <RAppRole> roleManager,
ISecretGenerator secretGenerator,
IImageFileService imageFileService,
IUserRoleService userRoleService,
IConfiguration configuration,
IMemoryCache memoryCache
)
: base(context, userManager, signInManager, roleManager, secretGenerator, imageFileService, userRoleService, configuration)
{
_memoryCache = memoryCache;
}
/// <summary>
/// generate missing default numberings and start counting
/// </summary>
/// <returns></returns>
public RServiceResult <bool> GenerateMissingDefaultNumberings()
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob("GenerateMissingDefaultNumberings", "Query")).Result;
try
{
var cats = await context.GanjoorCategories.Where(c => c.ParentId != null).ToListAsync();
foreach (var cat in cats)
{
var numbering = await context.GanjoorNumberings.Where(n => n.StartCatId == cat.Id && n.Name == cat.Title).FirstOrDefaultAsync();
if (numbering == null)
{
await jobProgressServiceEF.UpdateJob(job.Id, 0, cat.FullUrl);
numbering = new GanjoorNumbering()
{
Name = cat.Title,
StartCatId = cat.Id,
EndCatId = cat.Id
};
context.GanjoorNumberings.Add(numbering);
await context.SaveChangesAsync();
Recount(numbering.Id); //start counting
}
}
await context.SaveChangesAsync();
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
}
);
return(new RServiceResult <bool>(true));
}
public async static Task <RTagValue> PrepareAttribute(RMuseumDbContext db, string aName, string aValue, int order)
{
RTag type = await db.Tags.Where(a => a.Name == aName || a.NameInEnglish == aName).SingleOrDefaultAsync();
if (type == null)
{
int maxOrder = await db.Tags.CountAsync() == 0 ? 0 : await db.Tags.MaxAsync(a => a.Order);
type = new RTag()
{
Name = aName,
NameInEnglish = aName,
PluralName = $"{aName}s",
PluralNameInEnglish = $"{aName}s",
Order = maxOrder + 1,
Status = PublishStatus.Published,
GlobalValue = true
};
await db.Tags.AddAsync(type);
await db.SaveChangesAsync();
}
RTagValue tag =
new RTagValue()
{
Order = order,
Value = aValue,
ValueInEnglish = aValue,
ValueSupplement = "",
RTag = type,
Status = PublishStatus.Published
};
if (type.TagType == RTagType.Search || type.TagType == RTagType.LinkSearch)
{
RTagValue similar = await db.TagValues.Where(v => v.RTagId == type.Id && v.ValueInEnglish == aValue && !string.IsNullOrEmpty(v.FriendlyUrl)).FirstOrDefaultAsync();
if (similar != null)
{
tag.Value = similar.Value;
tag.FriendlyUrl = similar.FriendlyUrl;
}
}
return(tag);
}
private async Task _UpdatePageHtmlText(RMuseumDbContext context, Guid userId, GanjoorPage page, string note, string htmlText)
{
context.GanjoorPageSnapshots.Add
(
new GanjoorPageSnapshot()
{
GanjoorPageId = page.Id,
MadeObsoleteByUserId = userId,
HtmlText = page.HtmlText,
Note = note,
RecordDate = DateTime.Now
}
);
page.HtmlText = htmlText;
context.GanjoorPages.Update(page);
await context.SaveChangesAsync();
}
private async Task <List <GanjoorCat> > _FindAllSubCategories(RMuseumDbContext context, int catId)
{
List <GanjoorCat> cats = new List <GanjoorCat>();
foreach (var cat in await context.GanjoorCategories.AsNoTracking().Where(c => c.ParentId == catId).OrderBy(c => c.Id).ToListAsync())
{
cats.Add(cat);
var subCats = await _FindAllSubCategories(context, cat.Id);
if (subCats.Count > 0)
{
cats.AddRange(subCats);
}
}
return(cats);
}
private async Task <List <GanjoorCat> > _FindCategoryRanges(RMuseumDbContext context, GanjoorCat startCat, int endCatId)
{
var parents = await context.GanjoorCategories.AsNoTracking().Where(c => c.ParentId == startCat.ParentId && c.Id >= startCat.Id && c.Id <= endCatId).OrderBy(c => c.Id).ToListAsync();
List <GanjoorCat> cats = new List <GanjoorCat>();
foreach (GanjoorCat parentCat in parents)
{
cats.Add(parentCat);
var subCats = await _FindAllSubCategories(context, parentCat.Id);
if (subCats.Count > 0)
{
cats.AddRange(subCats);
}
}
return(cats);
}
/// <summary>
/// update related poems info (after metreId or rhyme for one of these poems changes)
/// </summary>
/// <param name="context"></param>
/// <param name="metreId"></param>
/// <param name="rhyme"></param>
/// <returns></returns>
private async Task <RServiceResult <bool> > _UpdateRelatedPoems(RMuseumDbContext context, int metreId, string rhyme)
{
try
{
var poemIds = await context.GanjoorPoems.AsNoTracking().Where(p => p.GanjoorMetreId == metreId && p.RhymeLetters == rhyme).Select(p => p.Id).ToListAsync();
foreach (var id in poemIds)
{
await _UpdatePoemRelatedPoemsInfoNoSaveChanges(context, id);
}
await context.SaveChangesAsync();
return(new RServiceResult <bool>(true));
}
catch (Exception exp)
{
return(new RServiceResult <bool>(false, exp.ToString()));
}
}
private async Task <RServiceResult <bool> > _DeleteComment(RMuseumDbContext context, int commentId)
{
GanjoorComment comment = await context.GanjoorComments.Where(c => c.Id == commentId).SingleOrDefaultAsync();
if (comment == null)
{
return(new RServiceResult <bool>(false)); //not found
}
foreach (var reply in await _FindReplies(context, comment))
{
await _DeleteComment(context, reply.Id);
}
context.GanjoorComments.Remove(comment);
await _context.SaveChangesAsync();
return(new RServiceResult <bool>(true));
}
/// <summary>
/// start filling poems couplet indices
/// </summary>
/// <returns></returns>
public RServiceResult <bool> StartFillingPoemsCoupletIndices()
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob("FillingPoemsCoupletIndices", "Query data")).Result;
try
{
var poemIds = await context.GanjoorPoems.AsNoTracking().Select(p => p.Id).ToListAsync();
int percent = 0;
for (int i = 0; i < poemIds.Count; i++)
{
if (i * 100 / poemIds.Count > percent)
{
percent++;
await jobProgressServiceEF.UpdateJob(job.Id, percent);
}
await _FillPoemCoupletIndices(context, poemIds[i]);
}
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
}
);
return(new RServiceResult <bool>(true));
}
/// <summary>
/// start updating stats page
/// </summary>
/// <returns></returns>
public RServiceResult <bool> StartUpdatingMundexPage(Guid editingUserId)
{
try
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob("UpdateMundexPage", "House Keeping")).Result;
try
{
await _PerformMundexHouseKeepingAndPreparation(context, jobProgressServiceEF, job);
await jobProgressServiceEF.UpdateJob(job.Id, 10, "Mundex Page");
await _UpdateMundexPage(editingUserId, context, jobProgressServiceEF, job);
await jobProgressServiceEF.UpdateJob(job.Id, 60, "Mundex by poet page");
await _UpdateMundexByPoetPage(editingUserId, context, jobProgressServiceEF, job);
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
}
);
return(new RServiceResult <bool>(true));
}
catch (Exception exp)
{
return(new RServiceResult <bool>(false, exp.ToString()));
}
}
private async Task ExportCatToSqlite(RMuseumDbContext context, SqliteConnection sqliteConnection, GanjoorCat cat)
{
int parentId = cat.ParentId == null ? 0 : (int)cat.ParentId;
await sqliteConnection.ExecuteAsync($"INSERT INTO cat (id, poet_id, text, parent_id, url) VALUES ({cat.Id}, {cat.PoetId}, '{cat.Title}', {parentId}, 'https://ganjoor.net{cat.FullUrl}');");
var poems = await context.GanjoorPoems.AsNoTracking().Where(p => p.CatId == cat.Id).ToListAsync();
foreach (var poem in poems)
{
await sqliteConnection.ExecuteAsync($"INSERT INTO poem (id, cat_id, title, url) VALUES ({poem.Id}, {poem.CatId}, '{poem.Title}', 'https://ganjoor.net{poem.FullUrl}');");
foreach (var verse in await context.GanjoorVerses.AsNoTracking().Where(v => v.PoemId == poem.Id).OrderBy(v => v.VOrder).ToListAsync())
{
await sqliteConnection.ExecuteAsync($"INSERT INTO verse (poem_id, vorder, position, text) VALUES ({poem.Id}, {verse.VOrder}, {(int)verse.VersePosition}, '{verse.Text}');");
}
}
foreach (var child in await context.GanjoorCategories.AsNoTracking().Where(c => c.ParentId == cat.Id).ToListAsync())
{
await ExportCatToSqlite(context, sqliteConnection, child);
}
}
/// <summary>
/// start generating sub cats TOC
/// </summary>
/// <param name="userId"></param>
/// <param name="catId"></param>
/// <returns></returns>
public RServiceResult <bool> StartGeneratingSubCatsTOC(Guid userId, int catId)
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob($"GeneratingSubCatsTOC {catId}", "Query data")).Result;
try
{
await _GeneratingSubCatsTOC(userId, context, jobProgressServiceEF, job, catId);
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
});
return(new RServiceResult <bool>(true));
}
/// <summary>
/// start counting
/// </summary>
/// <returns></returns>
public RServiceResult <bool> Recount(int numberingId)
{
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
LongRunningJobProgressServiceEF jobProgressServiceEF = new LongRunningJobProgressServiceEF(context);
var job = (await jobProgressServiceEF.NewJob("NumberingService::Count", "Query Cats")).Result;
try
{
var numbering = await context.GanjoorNumberings.Include(n => n.StartCat).Where(n => n.Id == numberingId).SingleOrDefaultAsync();
var cats = await _FindTargetCategories(context, numbering.StartCat, numbering.EndCatId);
await jobProgressServiceEF.UpdateJob(job.Id, 0, "Deleting Old Data");
var oldNumbers = await context.GanjoorVerseNumbers.Where(n => n.NumberingId == numberingId).ToListAsync();
context.GanjoorVerseNumbers.RemoveRange(oldNumbers);
await context.SaveChangesAsync();
await jobProgressServiceEF.UpdateJob(job.Id, 0, "Counting");
int number = 0;
int coupletnumber = 0;
int paragraphnumber = 0;
int totalVerseCount = 0;
foreach (var cat in cats)
{
var poems = await context.GanjoorPoems.AsNoTracking().Where(p => p.CatId == cat.Id).OrderBy(p => p.Id).ToListAsync();
await jobProgressServiceEF.UpdateJob(job.Id, 0, $"Counting:: {cat.Title}");
foreach (var poem in poems)
{
totalVerseCount += await context.GanjoorVerses.Where(v => v.PoemId == poem.Id).CountAsync();
var verses = await context.GanjoorVerses.AsNoTracking()
.Where(v => v.PoemId == poem.Id && v.VersePosition != VersePosition.Left && v.VersePosition != VersePosition.CenteredVerse2 && v.VersePosition != VersePosition.Comment)
.OrderBy(v => v.VOrder)
.ToListAsync();
for (int coupletIndex = 0; coupletIndex < verses.Count; coupletIndex++)
{
number++;
bool isPoemVerse = verses[coupletIndex].VersePosition == VersePosition.Right || verses[coupletIndex].VersePosition == VersePosition.CenteredVerse1;
if (isPoemVerse)
{
coupletnumber++;
}
else
{
paragraphnumber++;
}
GanjoorVerseNumber verseNumber = new GanjoorVerseNumber()
{
NumberingId = numberingId,
PoemId = poem.Id,
CoupletIndex = coupletIndex,
Number = number,
IsPoemVerse = isPoemVerse,
SameTypeNumber = isPoemVerse ? coupletnumber : paragraphnumber
};
context.GanjoorVerseNumbers.Add(verseNumber);
}
}
}
numbering.TotalLines = number;
numbering.TotalVerses = totalVerseCount;
numbering.TotalCouplets = coupletnumber;
numbering.TotalParagraphs = paragraphnumber;
numbering.LastCountingDate = DateTime.Now;
context.GanjoorNumberings.Update(numbering);
await context.SaveChangesAsync();
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", true);
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, 100, "", false, exp.ToString());
}
}
}
);
return(new RServiceResult <bool>(true));
}
/// <summary>
/// constructor
/// </summary>
/// <param name="configuration"></param>
/// <param name="context"></param>
public MusicCatalogueService(IConfiguration configuration, RMuseumDbContext context)
{
Configuration = configuration;
_context = context;
}
/// <summary>
/// import catalogue from ganjoor.net MySql db
/// </summary>
/// <param name="jobName"></param>
/// <param name="jobProgressServiceEF"></param>
/// <param name="job"></param>
/// <returns></returns>
public async Task <RServiceResult <bool> > ImportFromMySql(string jobName, LongRunningJobProgressServiceEF jobProgressServiceEF, RLongRunningJobStatus job)
{
try
{
using (RMuseumDbContext context = new RMuseumDbContext(Configuration)) //this is long running job, so _context might be already been freed/collected by GC
{
using (MySqlConnection connection = new MySqlConnection
(
$"server={Configuration.GetSection("AudioMySqlServer")["Server"]};uid={Configuration.GetSection("AudioMySqlServer")["SongsUsername"]};pwd={Configuration.GetSection("AudioMySqlServer")["SongsPassword"]};database={Configuration.GetSection("AudioMySqlServer")["SongsDatabase"]};charset=utf8;convert zero datetime=True"
))
{
job = (await jobProgressServiceEF.UpdateJob(job.Id, 0, $"{jobName} - import golha data - pre open connection")).Result;
connection.Open();
using (MySqlDataAdapter src = new MySqlDataAdapter(
"SELECT col_id, name FROM golha_collections ORDER BY col_id",
connection))
{
using (DataTable data = new DataTable())
{
await src.FillAsync(data);
foreach (DataRow row in data.Rows)
{
GolhaCollection collection = new GolhaCollection()
{
Id = int.Parse(row["col_id"].ToString()),
Name = row["name"].ToString(),
Programs = new List <GolhaProgram>()
};
job = (await jobProgressServiceEF.UpdateJob(job.Id, 0, $"{jobName} - import golha data - golha_collections: {collection.Id}")).Result;
using (MySqlDataAdapter srcPrograms = new MySqlDataAdapter(
$"SELECT program_id, title, progarm_order, url, mp3 FROM golha_programs WHERE col_id = {collection.Id} ORDER BY program_id",
connection))
{
using (DataTable programData = new DataTable())
{
await srcPrograms.FillAsync(programData);
foreach (DataRow golhaProgram in programData.Rows)
{
GolhaProgram program = new GolhaProgram()
{
Id = int.Parse(golhaProgram["program_id"].ToString()),
Title = golhaProgram["title"].ToString(),
ProgramOrder = int.Parse(golhaProgram["progarm_order"].ToString()),
Url = golhaProgram["url"].ToString(),
Mp3 = golhaProgram["mp3"].ToString(),
Tracks = new List <GolhaTrack>()
};
using (MySqlDataAdapter srcTracks = new MySqlDataAdapter(
$"SELECT track_id, track_no, timing, title FROM golha_tracks WHERE program_id = {program.Id} ORDER BY track_no",
connection))
{
using (DataTable trackData = new DataTable())
{
await srcTracks.FillAsync(trackData);
foreach (DataRow golhaTrack in trackData.Rows)
{
program.Tracks.Add
(
new GolhaTrack()
{
Id = int.Parse(golhaTrack["track_id"].ToString()),
TrackNo = int.Parse(golhaTrack["track_no"].ToString()),
Timing = golhaTrack["timing"].ToString(),
Title = golhaTrack["title"].ToString(),
Blocked = false,
}
);
}
}
}
collection.Programs.Add(program);
}
}
}
context.GolhaCollections.Add(collection);
await context.SaveChangesAsync();
}
}
}
job = (await jobProgressServiceEF.UpdateJob(job.Id, 0, $"{jobName} - import singers data")).Result;
using (MySqlDataAdapter src = new MySqlDataAdapter(
"SELECT artist_id, artist_name, artist_beeptunesurl FROM ganja_artists ORDER BY artist_id",
connection))
{
using (DataTable data = new DataTable())
{
await src.FillAsync(data);
foreach (DataRow row in data.Rows)
{
int artistId = int.Parse(row["artist_id"].ToString());
GanjoorSinger singer = new GanjoorSinger()
{
Name = row["artist_name"].ToString(),
Url = row["artist_beeptunesurl"].ToString(),
Albums = new List <GanjoorAlbum>()
};
using (MySqlDataAdapter srcAlbums = new MySqlDataAdapter(
$"SELECT album_id, album_name, album_beeptunesurl FROM ganja_albums WHERE album_artistid = {artistId} ORDER BY album_id",
connection))
{
using (DataTable dataAlbums = new DataTable())
{
await srcAlbums.FillAsync(dataAlbums);
foreach (DataRow rowAlbum in dataAlbums.Rows)
{
int albumId = int.Parse(rowAlbum["album_id"].ToString());
GanjoorAlbum album = new GanjoorAlbum()
{
Name = rowAlbum["album_name"].ToString(),
Url = rowAlbum["album_beeptunesurl"].ToString(),
Tracks = new List <GanjoorTrack>()
};
using (MySqlDataAdapter srcTracks = new MySqlDataAdapter(
$"SELECT track_name, track_beeptunesurl FROM ganja_tracks WHERE album_id = {albumId} ORDER BY track_id",
connection))
{
using (DataTable dataTracks = new DataTable())
{
await srcTracks.FillAsync(dataTracks);
foreach (DataRow rowTrack in dataTracks.Rows)
{
album.Tracks.Add
(
new GanjoorTrack()
{
Name = rowTrack["track_name"].ToString(),
Url = rowTrack["track_beeptunesurl"].ToString(),
Blocked = false
}
);
}
}
}
singer.Albums.Add(album);
}
}
}
context.GanjoorSingers.Add(singer);
job = (await jobProgressServiceEF.UpdateJob(job.Id, 0, $"{jobName} - import singers data - {singer.Name}")).Result;
}
}
}
job = (await jobProgressServiceEF.UpdateJob(job.Id, 0, $"{jobName} - finalizing singers data")).Result;
await context.SaveChangesAsync();
}
}
return(new RServiceResult <bool>(true));
}
catch (Exception exp)
{
await jobProgressServiceEF.UpdateJob(job.Id, job.Progress, "", false, exp.ToString());
return(new RServiceResult <bool>(false, exp.ToString()));
}
}
/// <summary>
/// constructor
/// </summary>
/// <param name="context"></param>
/// <param name="backgroundTaskQueue"></param>
public GanjoorNumberingService(RMuseumDbContext context, IBackgroundTaskQueue backgroundTaskQueue)
{
_context = context;
_backgroundTaskQueue = backgroundTaskQueue;
}
/// <summary>
/// save ganjoor poem probable metre
/// </summary>
/// <param name="id">problable metre id</param>
/// <param name="metre"></param>
/// <returns></returns>
public async Task <RServiceResult <bool> > SaveGanjoorPoemProbableMetre(int id, string metre)
{
try
{
var item = await _context.GanjoorPoemProbableMetres.Where(p => p.Id == id).SingleAsync();
metre = metre.Trim();
if (string.IsNullOrEmpty(metre))
{
metre = "dismissed";
}
if (metre == "dismissed")
{
item.Metre = "dismissed";
_context.Update(item);
await _context.SaveChangesAsync();
return(new RServiceResult <bool>(true));
}
var rhythm = await _context.GanjoorMetres.AsNoTracking().Where(m => m.Rhythm == metre).SingleOrDefaultAsync();
if (rhythm == null)
{
rhythm = new GanjoorMetre()
{
Rhythm = metre,
VerseCount = 0
};
_context.GanjoorMetres.Add(rhythm);
await _context.SaveChangesAsync();
}
var poem = await _context.GanjoorPoems.Where(p => p.Id == item.PoemId).SingleAsync();
int?oldMetreId = poem.GanjoorMetreId;
poem.GanjoorMetreId = rhythm.Id;
_context.Update(poem);
_context.Remove(item);
await _context.SaveChangesAsync();
_backgroundTaskQueue.QueueBackgroundWorkItem
(
async token =>
{
using (RMuseumDbContext context = new RMuseumDbContext(new DbContextOptions <RMuseumDbContext>())) //this is long running job, so _context might be already been freed/collected by GC
{
if (oldMetreId != null && !string.IsNullOrEmpty(poem.RhymeLetters))
{
await _UpdateRelatedPoems(context, (int)oldMetreId, poem.RhymeLetters);
await context.SaveChangesAsync();
}
if (poem.GanjoorMetreId != null && !string.IsNullOrEmpty(poem.RhymeLetters))
{
await _UpdateRelatedPoems(context, (int)poem.GanjoorMetreId, poem.RhymeLetters);
await context.SaveChangesAsync();
}
}
});
return(new RServiceResult <bool>(true));
}
catch (Exception exp)
{
return(new RServiceResult <bool>(false, exp.ToString()));
}
}
