anas/divan
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects Releases Wiki Activity
78cea13652
divan/RMuseum/Services/Implementation/ArtifactService.cs
Hamid Reza Mohammadi 9c5d5213c9 bug fix (null user)
2021-02-18 15:42:32 +03:30

3410 lines
144 KiB
C#
Raw Blame History

using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json.Linq;
using RMuseum.DbContext;
using RMuseum.Models.Artifact;
using RMuseum.Models.Artifact.ViewModels;
using RMuseum.Models.Bookmark;
using RMuseum.Models.Bookmark.ViewModels;
using RMuseum.Models.GanjoorIntegration;
using RMuseum.Models.GanjoorIntegration.ViewModels;
using RMuseum.Models.ImportJob;
using RMuseum.Models.Note;
using RMuseum.Models.Note.ViewModels;
using RSecurityBackend.Models.Auth.Db;
using RSecurityBackend.Models.Auth.ViewModels;
using RSecurityBackend.Models.Generic;
using RSecurityBackend.Services;
using RSecurityBackend.Services.Implementation;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
namespace RMuseum.Services.Implementation
{
/// <summary>
/// IArtifactService implementation
/// </summary>
public partial class ArtifactService : IArtifactService
{
/// <summary>
/// get all artifacts (including CoverImage info but not items or tagibutes info)
/// </summary>
/// <param name="paging"></param>
/// <param name="statusArray"></param>
/// <returns></returns>
public async Task<RServiceResult<(PaginationMetadata PagingMeta, RArtifactMasterRecord[] Items)>> GetAll(PagingParameterModel paging, PublishStatus[] statusArray)
{
try
{
var source =
_context.Artifacts
.Include(a => a.CoverImage)
.Where(a => statusArray.Contains(a.Status))
.OrderByDescending(t => t.DateTime)
.AsQueryable();
(PaginationMetadata PagingMeta, RArtifactMasterRecord[] Items) paginatedResult =
await QueryablePaginator<RArtifactMasterRecord>.Paginate(source, paging);
return new RServiceResult<(PaginationMetadata PagingMeta, RArtifactMasterRecord[] Items)>(paginatedResult);
}
catch (Exception exp)
{
return new RServiceResult<(PaginationMetadata PagingMeta, RArtifactMasterRecord[] Items)>((PagingMeta: null, Items: null), exp.ToString());
}
}
/// <summary>
/// get tagged publish artifacts (including CoverImage info but not items or tagibutes info)
/// </summary>
/// <param name="tagUrl"></param>
/// <param name="valueUrl"></param>
/// <param name="statusArray"></param>
/// <returns></returns>
public async Task<RServiceResult<RArtifactMasterRecord[]>> GetByTagValue(string tagUrl, string valueUrl, PublishStatus[] statusArray)
{
try
{
RTag tag =
await _context.Tags
.Where(a => a.FriendlyUrl == tagUrl)
.SingleOrDefaultAsync();
if(tag == null)
return new RServiceResult<RArtifactMasterRecord[]>(new RArtifactMasterRecord[] { });
RArtifactMasterRecord[] taggedItems =
await _context.Artifacts.Include(a => a.Tags)
.Include(a => a.CoverImage)
.Where(a => statusArray.Contains(a.Status) && a.Tags != null && a.Tags.Any(v => v.RTagId == tag.Id && v.FriendlyUrl == valueUrl))
.OrderByDescending(t => t.DateTime)
.AsNoTracking()
.ToArrayAsync();
foreach (RArtifactMasterRecord taggedItem in taggedItems)
taggedItem.Tags = null;
return new RServiceResult<RArtifactMasterRecord[]>(taggedItems);
}
catch (Exception exp)
{
return new RServiceResult<RArtifactMasterRecord[]>(null, exp.ToString());
}
}
/// <summary>
/// gets specified artifact info (including CoverImage + images + tagibutes)
/// </summary>
/// <param name="friendlyUrl"></param>
/// <param name="statusArray"></param>
/// <returns></returns>
public async Task<RServiceResult<RArtifactMasterRecordViewModel>> GetByFriendlyUrl(string friendlyUrl, PublishStatus[] statusArray)
{
try
{
RArtifactMasterRecord artifact =
await _context.Artifacts
.Include(a => a.CoverImage)
.Include(a => a.Items).ThenInclude(i => i.Images)
.Include(a => a.Items).ThenInclude(i => i.Tags).ThenInclude(t => t.RTag)
.Include(a => a.Tags).ThenInclude(t => t.RTag)
.Where(a => statusArray.Contains(a.Status) && a.FriendlyUrl == friendlyUrl)
.AsNoTracking()
.SingleOrDefaultAsync();
if(artifact != null)
{
return new RServiceResult<RArtifactMasterRecordViewModel>(RArtifactMasterRecord.ToViewModel(artifact));
}
return new RServiceResult<RArtifactMasterRecordViewModel>(null);
}
catch (Exception exp)
{
return new RServiceResult<RArtifactMasterRecordViewModel>(null, exp.ToString());
}
}
/// <summary>
/// gets specified artifact info (including CoverImage + images + tagibutes)
/// </summary>
/// <param name="friendlyUrl"></param>
/// <param name="statusArray"></param>
/// <param name="tagFriendlyUrl"></param>
/// <param name="tagValueFriendlyUrl"></param>
/// <returns></returns>
public async Task<RServiceResult<RArtifactMasterRecordViewModel>> GetByFriendlyUrlFilterItemsByTag(string friendlyUrl, PublishStatus[] statusArray, string tagFriendlyUrl, string tagValueFriendlyUrl)
{
try
{
RTag rTag = await _context.Tags.Where(t => t.FriendlyUrl == tagFriendlyUrl).SingleOrDefaultAsync();
if (rTag == null)
return new RServiceResult<RArtifactMasterRecordViewModel>(null, "Tag not found!");
RArtifactMasterRecord artifact =
await _context.Artifacts
.Include(a => a.CoverImage)
.Include(a => a.Items).ThenInclude(i => i.Images)
.Include(a => a.Items).ThenInclude(i => i.Tags)
.Include(a => a.Tags).ThenInclude(t => t.RTag)
.Where(a => statusArray.Contains(a.Status) && a.FriendlyUrl == friendlyUrl)
.AsNoTracking()
.SingleOrDefaultAsync();
if (artifact != null)
{
List<RArtifactItemRecord> filteredItems = new List<RArtifactItemRecord>();
foreach(RArtifactItemRecord item in artifact.Items)
{
if(item.Tags.Any(v => v.RTagId == rTag.Id && (string.IsNullOrEmpty(tagValueFriendlyUrl) || v.FriendlyUrl == tagValueFriendlyUrl) ))
{
item.Tags = null;
filteredItems.Add(item);
}
}
artifact.Items = filteredItems;
return new RServiceResult<RArtifactMasterRecordViewModel>(RArtifactMasterRecord.ToViewModel(artifact));
}
return new RServiceResult<RArtifactMasterRecordViewModel>(null);
}
catch (Exception exp)
{
return new RServiceResult<RArtifactMasterRecordViewModel>(null, exp.ToString());
}
}
/// <summary>
/// edit master record
/// </summary>
/// <param name="edited"></param>
/// <param name="canChangeStatusToAwaiting"></param>
/// <param name="canPublish"></param>
/// <returns></returns>
public async Task<RServiceResult<RArtifactMasterRecord>> EditMasterRecord(RArtifactMasterRecord edited, bool canChangeStatusToAwaiting, bool canPublish)
{
try
{
if(string.IsNullOrEmpty(edited.Name))
{
return new RServiceResult<RArtifactMasterRecord>(null, "Name could not be empty.");
}
RArtifactMasterRecord item =
await _context.Artifacts
.Where(a => a.Id == edited.Id)
.SingleOrDefaultAsync();
if (item != null)
{
if(item.Status != edited.Status)
{
if(!canChangeStatusToAwaiting)
{
return new RServiceResult<RArtifactMasterRecord>(null, "User should be able to change status to Awaiting to complete this operation.");
}
if(
!
(
(item.Status == PublishStatus.Draft && edited.Status == PublishStatus.Awaiting)
||
(item.Status == PublishStatus.Awaiting && edited.Status == PublishStatus.Draft)
)
)
{
if(!canPublish)
{
return new RServiceResult<RArtifactMasterRecord>(null, "User should have Publish permission to complete this operation.");
}
}
}
item.FriendlyUrl = edited.FriendlyUrl;
item.Status = edited.Status;
item.Name = edited.Name;
item.NameInEnglish = edited.Name;
item.Description = edited.Description;
item.DescriptionInEnglish = edited.DescriptionInEnglish;
item.LastModified = DateTime.Now;
_context.Update(item);
await _context.SaveChangesAsync();
}
return new RServiceResult<RArtifactMasterRecord>(item);
}
catch (Exception exp)
{
return new RServiceResult<RArtifactMasterRecord>(null, exp.ToString());
}
}
/// <summary>
/// Set Artifact Cover Item Index
/// </summary>
/// <param name="artifactId"></param>
/// <param name="itemIndex"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> SetArtifactCoverItemIndex(Guid artifactId, int itemIndex)
{
try
{
RArtifactMasterRecord artifact = await _context
.Artifacts.Where(a => a.Id == artifactId)
.Include(a => a.Items).ThenInclude(i => i.Images)
.SingleOrDefaultAsync();
if(artifact == null)
return new RServiceResult<bool>(false, "Artifact not found.");
if (itemIndex == artifact.CoverItemIndex)
return new RServiceResult<bool>(true);
if(itemIndex < 0 || itemIndex >= artifact.Items.Count())
return new RServiceResult<bool>(false, "Item not found.");
artifact.CoverItemIndex = itemIndex;
artifact.CoverImage = RPictureFile.Duplicate(artifact.Items.ToArray()[itemIndex].Images.First());
artifact.LastModified = DateTime.Now;
_context.Artifacts.Update(artifact);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch(Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// get tag bundle by frindly url
/// </summary>
/// <param name="friendlyUrl"></param>
/// <returns></returns>
public async Task<RServiceResult<RTagBundleViewModel>> GetTagBundleByFiendlyUrl(string friendlyUrl)
{
try
{
RTag tag =
await _context.Tags
.Where(a => a.FriendlyUrl == friendlyUrl)
.AsNoTracking()
.SingleOrDefaultAsync();
if (tag != null)
{
RTagBundleViewModel viewModel = new RTagBundleViewModel()
{
Id = tag.Id,
Name = tag.Name,
PluralName = tag.PluralName,
FriendlyUrl = friendlyUrl
};
List<RTagBundleValueViewModel>
values = new List<RTagBundleValueViewModel>(
await _context.TagValues
.Where(value => value.RTagId == tag.Id && !string.IsNullOrEmpty(value.FriendlyUrl))
.GroupBy(value => new { value.Value, value.FriendlyUrl, value.RTagId })
.Select
(
g =>
new RTagBundleValueViewModel()
{
FriendlyUrl = g.Key.FriendlyUrl,
Name = g.Key.Value,
Count = g.Count(),
ImageId = _context.Artifacts.Include(a => a.Tags).Where(a => a.Status == PublishStatus.Published && a.Tags.Any(t => t.RTagId == g.Key.RTagId && t.Value == g.Key.Value)).FirstOrDefault().CoverImageId
}
)
.OrderByDescending(g => g.Count)
.ToArrayAsync()
);
viewModel.Values = values.ToArray();
return new RServiceResult<RTagBundleViewModel>(viewModel);
}
return new RServiceResult<RTagBundleViewModel>(null);
}
catch (Exception exp)
{
return new RServiceResult<RTagBundleViewModel>(null, exp.ToString());
}
}
/// <summary>
/// get max lastmodified artifact date for caching purposes
/// </summary>
/// <returns></returns>
public async Task<RServiceResult<DateTime>> GetMaxArtifactLastModified()
{
try
{
return new RServiceResult<DateTime>(await _context.Artifacts.MaxAsync(a => a.LastModified));
}
catch(Exception exp)
{
return new RServiceResult<DateTime>(DateTime.Now, exp.ToString());
}
}
/// <summary>
/// get all tags
/// </summary>
/// <param name="paging"></param>
/// <returns></returns>
public async Task<RServiceResult<(PaginationMetadata PagingMeta, RTag[] Items)>> GetAllTags(PagingParameterModel paging)
{
try
{
var source =
_context.Tags
.OrderByDescending(t => t.Order)
.AsQueryable();
(PaginationMetadata PagingMeta, RTag[] Items) paginatedResult =
await QueryablePaginator<RTag>.Paginate(source, paging);
return new RServiceResult<(PaginationMetadata PagingMeta, RTag[] Items)>(paginatedResult);
}
catch (Exception exp)
{
return new RServiceResult<(PaginationMetadata PagingMeta, RTag[] Items)>((PagingMeta: null, Items: null), exp.ToString());
}
}
/// <summary>
/// get tag bu friendly url
/// </summary>
/// <param name="friendlyUrl"></param>
/// <returns></returns>
public async Task<RServiceResult<RTag>> GetTagByFriendlyUrl(string friendlyUrl)
{
try
{
return new RServiceResult<RTag>(await _context.Tags.Where(t => t.FriendlyUrl == friendlyUrl).SingleOrDefaultAsync());
}
catch (Exception exp)
{
return new RServiceResult<RTag>(null, exp.ToString());
}
}
/// <summary>
/// get tag value by frindly url
/// </summary>
/// <param name="tagId"></param>
/// <param name="friendlyUrl"></param>
/// <returns></returns>
public async Task<RServiceResult<RTagValue>> GetTagValueByFriendlyUrl(Guid tagId, string friendlyUrl)
{
try
{
RTagValue value = await _context.TagValues.Where(t => t.RTagId == tagId && t.FriendlyUrl == friendlyUrl).FirstOrDefaultAsync();
if (value != null)
return new RServiceResult<RTagValue>(value);
return new RServiceResult<RTagValue>(null, "Tag value not found");
}
catch (Exception exp)
{
return new RServiceResult<RTagValue>(null, exp.ToString());
}
}
/// <summary>
/// add tag
/// </summary>
/// <returns></returns>
public async Task<RServiceResult<RTag>> AddTag(string tagName)
{
try
{
if (string.IsNullOrEmpty(tagName))
{
return new RServiceResult<RTag>(null, "Name could not be empty.");
}
RTag existingTag =
await _context.Tags
.Where(a => a.Name == tagName || a.NameInEnglish == tagName)
.SingleOrDefaultAsync();
if(existingTag != null)
{
return new RServiceResult<RTag>(null, "Duplicated Name or English Name for tag.");
}
int maxOrder = await _context.Tags.CountAsync() == 0 ? 0 : await _context.Tags.MaxAsync(a => a.Order);
RTag type = new RTag()
{
Name = tagName,
NameInEnglish = tagName,
PluralName = $"{tagName}s",
PluralNameInEnglish = $"{tagName}s",
Order = maxOrder + 1,
Status = PublishStatus.Published,
GlobalValue = true
};
await _context.Tags.AddAsync(type);
await _context.SaveChangesAsync();
return new RServiceResult<RTag>(type);
}
catch (Exception exp)
{
return new RServiceResult<RTag>(null, exp.ToString());
}
}
/// <summary>
/// edit tag
/// </summary>
/// <param name="edited"></param>
/// <returns></returns>
public async Task<RServiceResult<RTag>> EditTag(RTag edited)
{
try
{
if (string.IsNullOrEmpty(edited.Name))
{
return new RServiceResult<RTag>(null, "Name could not be empty.");
}
RTag tag =
await _context.Tags
.Where(a => a.Id == edited.Id)
.SingleOrDefaultAsync();
if (tag != null)
{
tag.Name = edited.Name;
tag.Order = edited.Order;
tag.FriendlyUrl = edited.FriendlyUrl;
tag.TagType = edited.TagType;
tag.Status = edited.Status;
tag.NameInEnglish = edited.NameInEnglish;
tag.GlobalValue = edited.GlobalValue;
tag.PluralName = edited.PluralName;
tag.PluralNameInEnglish = edited.PluralNameInEnglish;
_context.Update(tag);
RArtifactMasterRecord[] taggedItems =
await _context.Artifacts.Include(a => a.Tags)
.Where(a => a.Tags != null && a.Tags.Any(v => v.RTagId == tag.Id))
.ToArrayAsync();
foreach(RArtifactMasterRecord taggedItem in taggedItems)
{
taggedItem.LastModified = DateTime.Now;
_context.Update(taggedItem);
}
RArtifactItemRecord[] taggedPages =
await _context.Items.Include(a => a.Tags)
.Where(a => a.Tags != null && a.Tags.Any(v => v.RTagId == tag.Id))
.ToArrayAsync();
foreach (RArtifactItemRecord taggedItem in taggedPages)
{
taggedItem.LastModified = DateTime.Now;
_context.Update(taggedItem);
}
await UpdateTaggedItems(tag);
await _context.SaveChangesAsync();
}
return new RServiceResult<RTag>(tag);
}
catch (Exception exp)
{
return new RServiceResult<RTag>(null, exp.ToString());
}
}
/// <summary>
/// changes LastModified field value for tagged artifacts and items
/// </summary>
/// <param name="tag"></param>
/// <returns></returns>
private async Task UpdateTaggedItems(RTag tag)
{
RArtifactMasterRecord[] taggedItems =
await _context.Artifacts.Include(a => a.Tags)
.Where(a => a.Tags != null && a.Tags.Any(v => v.RTagId == tag.Id))
.ToArrayAsync();
foreach (RArtifactMasterRecord taggedItem in taggedItems)
{
taggedItem.LastModified = DateTime.Now;
_context.Update(taggedItem);
}
RArtifactItemRecord[] taggedPages =
await _context.Items.Include(a => a.Tags)
.Where(a => a.Tags != null && a.Tags.Any(v => v.RTagId == tag.Id))
.ToArrayAsync();
foreach (RArtifactItemRecord taggedItem in taggedPages)
{
taggedItem.LastModified = DateTime.Now;
_context.Update(taggedItem);
}
}
/// <summary>
/// changes order of tags based on their position in artifacts
/// </summary>
/// <param name="tagId"></param>
/// <param name="artifactId"></param>
/// <param name="up">true => up, false => down</param>
/// <returns>the other tag which its Order has been changed</returns>
public async Task<RServiceResult<Guid?>> EditTagOrderBasedOnArtifact(Guid tagId, Guid artifactId, bool up)
{
try
{
RArtifactMasterRecord artifact =
await _context.Artifacts
.Include(a => a.Tags).ThenInclude(t => t.RTag)
.Where(a => a.Id == artifactId)
.AsNoTracking()
.SingleOrDefaultAsync();
if (artifact == null)
{
return new RServiceResult<Guid?>(null, "artifact not found");
}
RArtifactMasterRecordViewModel viewModel = RArtifactMasterRecord.ToViewModel(artifact); //tags are sorted in this method
int tagOrder = viewModel.ArtifactTags.Where(tag => tag.Id == tagId).FirstOrDefault().Order;
RArtifactTagViewModel otherTagViewModel;
if(up)
{
otherTagViewModel = viewModel.ArtifactTags.Where(tag => tag.Order < tagOrder).OrderByDescending(tag => tag.Order).FirstOrDefault();
}
else
{
otherTagViewModel = viewModel.ArtifactTags.Where(tag => tag.Order > tagOrder).OrderBy(tag => tag.Order).FirstOrDefault();
}
if(otherTagViewModel == null)
{
return new RServiceResult<Guid?>(null, "Invalid movement");
}
RTag rTag1 = await _context.Tags.Where(tag => tag.Id == tagId).FirstOrDefaultAsync();
RTag rTag2 = await _context.Tags.Where(tag => tag.Id == otherTagViewModel.Id ).FirstOrDefaultAsync();
rTag1.Order = otherTagViewModel.Order;
rTag2.Order = tagOrder;
_context.Tags.UpdateRange(new RTag[] { rTag1, rTag2 });
await UpdateTaggedItems(rTag1);
await UpdateTaggedItems(rTag2);
await _context.SaveChangesAsync();
return new RServiceResult<Guid?>((Guid?)rTag2.Id);
}
catch(Exception exp)
{
return new RServiceResult<Guid?>(null, exp.ToString());
}
}
/// <summary>
/// changes order of tags based on their position in artifact items
/// </summary>
/// <param name="tagId"></param>
/// <param name="itemId"></param>
/// <param name="up">true => up, false => down</param>
/// <returns>the other tag which its Order has been changed</returns>
public async Task<RServiceResult<Guid?>> EditTagOrderBasedOnItem(Guid tagId, Guid itemId, bool up)
{
try
{
RArtifactItemRecord item =
await _context.Items
.Include(a => a.Tags).ThenInclude(t => t.RTag)
.Where(a => a.Id == itemId)
.AsNoTracking()
.SingleOrDefaultAsync();
if (item == null)
{
return new RServiceResult<Guid?>(null, "item not found");
}
RArtifactItemRecordViewModel viewModel = new RArtifactItemRecordViewModel(); //tags are sorted in this method
viewModel.Item = item;
int tagOrder = viewModel.FormattedTags.Where(tag => tag.Id == tagId).FirstOrDefault().Order;
RArtifactTagViewModel otherTagViewModel;
if (up)
{
otherTagViewModel = viewModel.FormattedTags.Where(tag => tag.Order < tagOrder).OrderByDescending(tag => tag.Order).FirstOrDefault();
}
else
{
otherTagViewModel = viewModel.FormattedTags.Where(tag => tag.Order > tagOrder).OrderBy(tag => tag.Order).FirstOrDefault();
}
if (otherTagViewModel == null)
{
return new RServiceResult<Guid?>(null, "Invalid movement");
}
RTag rTag1 = await _context.Tags.Where(tag => tag.Id == tagId).FirstOrDefaultAsync();
RTag rTag2 = await _context.Tags.Where(tag => tag.Id == otherTagViewModel.Id).FirstOrDefaultAsync();
rTag1.Order = otherTagViewModel.Order;
rTag2.Order = tagOrder;
_context.Tags.UpdateRange(new RTag[] { rTag1, rTag2 });
await UpdateTaggedItems(rTag1);
await UpdateTaggedItems(rTag2);
await _context.SaveChangesAsync();
return new RServiceResult<Guid?>((Guid?)rTag2.Id);
}
catch (Exception exp)
{
return new RServiceResult<Guid?>(null, exp.ToString());
}
}
/// <summary>
/// get tag value bundle by frindly url
/// </summary>
/// <param name="friendlyUrl"></param>
/// <param name="valueUrl"></param>
/// <returns></returns>
public async Task<RServiceResult<RArtifactTagViewModel>> GetTagValueBundleByFiendlyUrl(string friendlyUrl, string valueUrl)
{
try
{
RTag tag =
await _context.Tags
.Where(a => a.FriendlyUrl == friendlyUrl)
.AsNoTracking()
.SingleOrDefaultAsync();
if (tag != null)
{
RArtifactTagViewModel viewModel
= new RArtifactTagViewModel()
{
Id = tag.Id,
Order = tag.Order,
TagType = tag.TagType,
FriendlyUrl = tag.FriendlyUrl,
Status = tag.Status,
Name = tag.Name,
NameInEnglish = tag.NameInEnglish,
GlobalValue = tag.GlobalValue,
PluralName = tag.PluralName,
PluralNameInEnglish = tag.PluralNameInEnglish
};
viewModel.Values =
new RTagValue[]
{
await _context.TagValues
.Where(value => value.RTagId == tag.Id && value.FriendlyUrl == valueUrl)
.FirstOrDefaultAsync()
};
return new RServiceResult<RArtifactTagViewModel>(viewModel);
}
return new RServiceResult<RArtifactTagViewModel>(null);
}
catch (Exception exp)
{
return new RServiceResult<RArtifactTagViewModel>(null, exp.ToString());
}
}
/// <summary>
/// add artifact tag value
/// </summary>
/// <param name="artifactId"></param>
/// <param name="rTag"></param>
/// <returns></returns>
public async Task<RServiceResult<RTagValue>> TagArtifact(Guid artifactId, RTag rTag)
{
try
{
RTag type = await _context.Tags.Where(a => a.Id == rTag.Id).SingleOrDefaultAsync();
RArtifactMasterRecord item = await _context.Artifacts.Include(i => i.Tags).Where(i => i.Id == artifactId).SingleOrDefaultAsync();
int order = item.Tags.Where(t => t.RTagId == type.Id).Count() == 0 ? 1 : item.Tags.Where(t => t.RTagId == type.Id).OrderByDescending(t => t.Order).FirstOrDefault().Order + 1;
RTagValue tag =
new RTagValue()
{
Order = order,
Value = "",
ValueInEnglish = "",
ValueSupplement = "",
RTag = type,
Status = PublishStatus.Published
};
item.Tags.Add(tag);
item.LastModified = DateTime.Now;
_context.Artifacts.Update(item);
await _context.SaveChangesAsync();
return new RServiceResult<RTagValue>(tag);
}
catch (Exception exp)
{
return new RServiceResult<RTagValue>(null, exp.ToString());
}
}
/// <summary>
/// remove artfiact tag value
/// </summary>
/// <param name="artifactId"></param>
/// <param name="tagValueId"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> UnTagArtifact(Guid artifactId, Guid tagValueId)
{
try
{
RArtifactMasterRecord item = await _context.Artifacts.Include(i => i.Tags).Where(i => i.Id == artifactId).SingleOrDefaultAsync();
item.Tags.Remove(item.Tags.Where(t => t.Id == tagValueId).SingleOrDefault());
item.LastModified = DateTime.Now;
_context.Artifacts.Update(item);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// edit artifact tag value
/// </summary>
/// <param name="artifactId"></param>
/// <param name="edited"></param>
/// <param name="global">apply on all same value tags</param>
/// <returns></returns>
public async Task<RServiceResult<RTagValue>> EditTagValue(Guid artifactId, RTagValue edited, bool global)
{
try
{
if (string.IsNullOrEmpty(edited.Value))
{
return new RServiceResult<RTagValue>(null, "Value could not be empty.");
}
RArtifactMasterRecord artifact =
await _context.Artifacts
.Include(a => a.Tags)
.Where(a => a.Id == artifactId)
.SingleOrDefaultAsync();
if(artifact == null)
return new RServiceResult<RTagValue>(null);
RTagValue tag =
artifact.Tags.Where(a => a.Id == edited.Id)
.SingleOrDefault();
if (tag != null)
{
tag.Order = edited.Order;
tag.ValueSupplement = edited.ValueSupplement;
_context.Update(tag);
if (global)
{
RTagValue[] sameValueTags = await _context.TagValues.Where(v => v.Value == tag.Value && v.RTagId == tag.RTagId).ToArrayAsync();
foreach(RTagValue sameValueTag in sameValueTags)
{
sameValueTag.Value = edited.Value;
sameValueTag.ValueInEnglish = edited.ValueInEnglish;
sameValueTag.Status = edited.Status;
sameValueTag.FriendlyUrl = edited.FriendlyUrl;
_context.Update(sameValueTag);
RArtifactMasterRecord correspondingArtifact =
await _context.Artifacts.Include(a => a.Tags).Where(a => a.Tags.Contains(sameValueTag)).SingleOrDefaultAsync();
if(correspondingArtifact != null)
{
correspondingArtifact.LastModified = DateTime.Now;
_context.Update(correspondingArtifact);
}
RArtifactItemRecord correspondingItem =
await _context.Items.Include(a => a.Tags).Where(a => a.Tags.Contains(sameValueTag)).SingleOrDefaultAsync();
if(correspondingItem != null)
{
correspondingItem.LastModified = DateTime.Now;
_context.Update(correspondingItem);
}
}
await _context.SaveChangesAsync();
}
else
{
tag.Value = edited.Value;
tag.ValueInEnglish = edited.ValueInEnglish;
tag.Order = edited.Order;
tag.FriendlyUrl = edited.FriendlyUrl;
tag.Status = edited.Status;
tag.ValueSupplement = edited.ValueSupplement;
_context.Update(tag);
artifact.LastModified = DateTime.Now;
_context.Update(artifact);
await _context.SaveChangesAsync();
}
}
return new RServiceResult<RTagValue>(tag);
}
catch (Exception exp)
{
return new RServiceResult<RTagValue>(null, exp.ToString());
}
}
/// <summary>
/// add item tag value
/// </summary>
/// <param name="itemId"></param>
/// <param name="rTag"></param>
/// <returns></returns>
public async Task<RServiceResult<RTagValue>> TagItem(Guid itemId, RTag rTag)
{
try
{
RTag type = await _context.Tags.Where(a => a.Id == rTag.Id).SingleOrDefaultAsync();
RArtifactItemRecord item = await _context.Items.Include(i => i.Tags).Where(i=> i.Id == itemId).SingleOrDefaultAsync();
int order = item.Tags.Where(t => t.RTagId == type.Id).Count() == 0 ? 1 : item.Tags.Where(t => t.RTagId == type.Id).OrderByDescending(t => t.Order).FirstOrDefault().Order + 1;
RTagValue tag =
new RTagValue()
{
Order = order,
Value = "",
ValueInEnglish = "",
ValueSupplement = "",
RTag = type,
Status = PublishStatus.Published
};
item.Tags.Add(tag);
item.LastModified = DateTime.Now;
_context.Items.Update(item);
await _context.SaveChangesAsync();
return new RServiceResult<RTagValue>(tag);
}
catch (Exception exp)
{
return new RServiceResult<RTagValue>(null, exp.ToString());
}
}
/// <summary>
/// remove item tag value
/// </summary>
/// <param name="itemId"></param>
/// <param name="tagValueId"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> UnTagItem(Guid itemId, Guid tagValueId)
{
try
{
RArtifactItemRecord item = await _context.Items.Include(i => i.Tags).Where(i => i.Id == itemId).SingleOrDefaultAsync();
item.Tags.Remove(item.Tags.Where(t => t.Id == tagValueId).SingleOrDefault());
item.LastModified = DateTime.Now;
_context.Items.Update(item);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// edit item tagibute value
/// </summary>
/// <param name="itemtId"></param>
/// <param name="edited"></param>
/// <param name="global">apply on all same value tags</param>
/// <returns></returns>
public async Task<RServiceResult<RTagValue>> EditItemTagValue(Guid itemtId, RTagValue edited, bool global)
{
try
{
if (string.IsNullOrEmpty(edited.Value))
{
return new RServiceResult<RTagValue>(null, "Value could not be empty.");
}
RArtifactItemRecord item =
await _context.Items
.Include(a => a.Tags)
.Where(a => a.Id == itemtId)
.SingleOrDefaultAsync();
if (item == null)
return new RServiceResult<RTagValue>(null);
RTagValue tag =
item.Tags.Where(a => a.Id == edited.Id)
.SingleOrDefault();
if (tag != null)
{
tag.Order = edited.Order;
tag.ValueSupplement = edited.ValueSupplement;
_context.Update(tag);
if (global)
{
RTagValue[] sameValueTags = await _context.TagValues.Where(v => v.Value == tag.Value && v.RTagId == tag.RTagId).ToArrayAsync();
foreach (RTagValue sameValueTag in sameValueTags)
{
sameValueTag.Value = edited.Value;
sameValueTag.ValueInEnglish = edited.ValueInEnglish;
sameValueTag.Status = edited.Status;
sameValueTag.FriendlyUrl = edited.FriendlyUrl;
_context.Update(sameValueTag);
RArtifactMasterRecord correspondingArtifact =
await _context.Artifacts.Include(a => a.Tags).Where(a => a.Tags.Contains(sameValueTag)).SingleOrDefaultAsync();
if (correspondingArtifact != null)
{
correspondingArtifact.LastModified = DateTime.Now;
_context.Update(correspondingArtifact);
}
RArtifactItemRecord correspondingItem =
await _context.Items.Include(a => a.Tags).Where(a => a.Tags.Contains(sameValueTag)).SingleOrDefaultAsync();
if (correspondingItem != null)
{
correspondingItem.LastModified = DateTime.Now;
_context.Update(correspondingItem);
}
}
await _context.SaveChangesAsync();
}
else
{
tag.Value = edited.Value;
tag.ValueInEnglish = edited.ValueInEnglish;
tag.Order = edited.Order;
tag.FriendlyUrl = edited.FriendlyUrl;
tag.Status = edited.Status;
tag.ValueSupplement = edited.ValueSupplement;
_context.Update(tag);
item.LastModified = DateTime.Now;
_context.Update(item);
await _context.SaveChangesAsync();
}
}
return new RServiceResult<RTagValue>(tag);
}
catch (Exception exp)
{
return new RServiceResult<RTagValue>(null, exp.ToString());
}
}
/// <summary>
/// changes order of tag values based on their position in an artifact
/// </summary>
/// <param name="artifactId"></param>
/// <param name="tagId"></param>
/// <param name="valueId"></param>
/// <param name="up">true => up, false => down</param>
/// <returns>the other tag value which its Order has been changed</returns>
public async Task<RServiceResult<Guid?>> EditTagValueOrder(Guid artifactId, Guid tagId, Guid valueId, bool up)
{
try
{
RArtifactMasterRecord artifact =
await _context.Artifacts
.Include(a => a.Tags).ThenInclude(t => t.RTag)
.Where(a => a.Id == artifactId)
.SingleOrDefaultAsync();
if (artifact == null)
{
return new RServiceResult<Guid?>(null, "artifact not found");
}
RArtifactMasterRecordViewModel viewModel = RArtifactMasterRecord.ToViewModel(artifact); //tags are sorted in this method
RArtifactTagViewModel tag = viewModel.ArtifactTags.Where(t => t.Id == tagId).FirstOrDefault();
RTagValue value1 = tag.Values.Where(v => v.Id == valueId).FirstOrDefault();
RTagValue value2;
if (up)
{
value2 = tag.Values.Where(v => v.Order < value1.Order).OrderByDescending(v => v.Order).FirstOrDefault();
}
else
{
value2 = tag.Values.Where(v => v.Order > value1.Order).OrderBy(v => v.Order).FirstOrDefault();
}
if (value2 == null)
{
return new RServiceResult<Guid?>(null, "Invalid movement");
}
int nOrder = value1.Order;
value1.Order = value2.Order;
value2.Order = nOrder;
_context.TagValues.UpdateRange(new RTagValue[] { value1, value2 });
artifact.LastModified = DateTime.Now;
_context.Artifacts.Update(artifact);
await _context.SaveChangesAsync();
return new RServiceResult<Guid?>((Guid?)value2.Id);
}
catch (Exception exp)
{
return new RServiceResult<Guid?>(null, exp.ToString());
}
}
/// <summary>
/// changes order of tag values based on their position in an item
/// </summary>
/// <param name="itemId"></param>
/// <param name="tagId"></param>
/// <param name="valueId"></param>
/// <param name="up">true => up, false => down</param>
/// <returns>the other tag value which its Order has been changed</returns>
public async Task<RServiceResult<Guid?>> EditItemTagValueOrder(Guid itemId, Guid tagId, Guid valueId, bool up)
{
try
{
RArtifactItemRecord item =
await _context.Items
.Include(a => a.Tags).ThenInclude(t => t.RTag)
.Where(a => a.Id == itemId)
.SingleOrDefaultAsync();
if (item == null)
{
return new RServiceResult<Guid?>(null, "item not found");
}
RArtifactItemRecordViewModel viewModel = new RArtifactItemRecordViewModel(); //tags are sorted in this method
viewModel.Item = item;
RArtifactTagViewModel tag = viewModel.FormattedTags.Where(t => t.Id == tagId).FirstOrDefault();
RTagValue value1 = tag.Values.Where(v => v.Id == valueId).FirstOrDefault();
RTagValue value2;
if (up)
{
value2 = tag.Values.Where(v => v.Order < value1.Order).OrderByDescending(v => v.Order).FirstOrDefault();
}
else
{
value2 = tag.Values.Where(v => v.Order > value1.Order).OrderBy(v => v.Order).FirstOrDefault();
}
if (value2 == null)
{
return new RServiceResult<Guid?>(null, "Invalid movement");
}
int nOrder = value1.Order;
value1.Order = value2.Order;
value2.Order = nOrder;
_context.TagValues.UpdateRange(new RTagValue[] { value1, value2 });
item.LastModified = DateTime.Now;
_context.Items.Update(item);
await _context.SaveChangesAsync();
return new RServiceResult<Guid?>((Guid?)value2.Id);
}
catch (Exception exp)
{
return new RServiceResult<Guid?>(null, exp.ToString());
}
}
/// <summary>
/// gets specified artifact item info (including images + tagibutes)
/// </summary>
/// <param name="artifactUrl"></param>
/// <param name="itemUrl"></param>
/// <param name="statusArray"></param>
/// <returns></returns>
public async Task<RServiceResult<RArtifactItemRecordViewModel>> GetArtifactItemByFrienlyUrl(string artifactUrl, string itemUrl, PublishStatus[] statusArray)
{
try
{
RArtifactMasterRecord parent =
await _context.Artifacts
.Include(a => a.CoverImage)
.Include(a => a.Items).ThenInclude(i => i.Images)
.Include(a => a.Items).ThenInclude(i => i.Tags).ThenInclude(t => t.RTag)
.Where(a => statusArray.Contains(a.Status) && a.FriendlyUrl == artifactUrl)
.AsNoTracking()
.SingleOrDefaultAsync();
if (parent == null)
return new RServiceResult<RArtifactItemRecordViewModel>(null);
if(parent.Items != null)
parent.Items = parent.Items.OrderBy(i => i.Order).ToArray();
if(parent.Tags != null)
parent.Tags = parent.Tags.OrderBy(a => a.RTag.Order).ToArray();
RArtifactItemRecord item =
parent.Items
.Where(i => i.FriendlyUrl == itemUrl)
.SingleOrDefault();
if (item == null)
return new RServiceResult<RArtifactItemRecordViewModel>(null);
if (item.Images != null)
item.Images = item.Images.OrderBy(i => i.Order).ToArray();
if (item.Tags != null)
item.Tags = item.Tags.OrderBy(a => a.RTag.Order).ToArray();
RArtifactItemRecord nextItem = parent.Items.Where(i => i.Order > item.Order).OrderBy(i => i.Order).FirstOrDefault();
RArtifactItemRecord prevItem = parent.Items.Where(i => i.Order < item.Order).OrderByDescending(i => i.Order).FirstOrDefault();
RArtifactItemRecordViewModel res = new RArtifactItemRecordViewModel()
{
Item = item,
ParentFriendlyUrl = parent.FriendlyUrl,
ParentName = parent.Name,
ParentImageId = parent.CoverImage.Id,
ParentItemCount = parent.Items.Count(),
NextItemFriendlyUrl = nextItem == null ? "" : nextItem.FriendlyUrl,
NextItemImageId = nextItem == null ? (Guid?)null : nextItem.Images.First().Id,
PreviousItemFriendlyUrl = prevItem == null ? "" : prevItem.FriendlyUrl,
PrevItemImageId = prevItem == null ? (Guid?)null : prevItem.Images.First().Id,
};
return new RServiceResult<RArtifactItemRecordViewModel>(res);
}
catch (Exception exp)
{
return new RServiceResult<RArtifactItemRecordViewModel>(null, exp.ToString());
}
}
/// <summary>
/// add new artifact
/// </summary>
/// <param name="name"></param>
/// <param name="description"></param>
/// <param name="srcurl"></param>
/// <param name="pictitle"></param>
/// <param name="picdescription"></param>
/// <param name="file"></param>
/// <param name="picsrcurl"></param>
/// <param name="stream"></param>
/// <returns></returns>
public async Task<RServiceResult<RArtifactMasterRecord>> Add
(
string name, string description, string srcurl,
string pictitle, string picdescription, IFormFile file, string picsrcurl, Stream stream
)
{
try
{
RServiceResult<RPictureFile> picture = await _pictureFileService.Add(pictitle, picdescription, 1, file, picsrcurl, stream, "", "");
if (picture.Result == null)
{
return new RServiceResult<RArtifactMasterRecord>(null, $"_pictureFileService.Add : {picture.ExceptionString}");
}
RArtifactItemRecord item = new RArtifactItemRecord()
{
Order = 1,
CoverImageIndex = 0,
Images = new RPictureFile[] { picture.Result }
};
RArtifactMasterRecord artifact = new RArtifactMasterRecord(name, description)
{
Name = name,
NameInEnglish = name,
Description = description,
DescriptionInEnglish = description,
Status = PublishStatus.Draft,
DateTime = DateTime.Now,
LastModified = DateTime.Now,
CoverItemIndex = 0,
Items = new RArtifactItemRecord[] { item },
ItemCount = 1,
CoverImage = picture.Result
};
await _context.Artifacts.AddAsync(artifact);
await _context.SaveChangesAsync();
return new RServiceResult<RArtifactMasterRecord>(artifact);
}
catch(Exception exp)
{
return new RServiceResult<RArtifactMasterRecord>(null, exp.ToString());
}
}
/// <summary>
/// import from external resources
/// </summary>
/// <param name="srcType">loc/princeton/harvard/qajarwomen/hathitrust/penn/cam/bl/folder/walters/cbl</param>
/// <param name="resourceNumber">119</param>
/// <param name="friendlyUrl">golestan-baysonghori</param>
/// <param name="resourcePrefix"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> Import(string srcType, string resourceNumber, string friendlyUrl, string resourcePrefix)
{
return
srcType == "princeton" ?
await StartImportingFromPrinceton(resourceNumber, friendlyUrl)
:
srcType == "harvard" ?
await StartImportingFromHarvard(resourceNumber, friendlyUrl)
:
srcType == "qajarwomen" ?
await StartImportingFromHarvardDirectly(resourceNumber, friendlyUrl, resourcePrefix)
:
srcType == "hathitrust" ?
await StartImportingFromHathiTrust(resourceNumber, friendlyUrl)
:
srcType == "penn" ?
await StartImportingFromPenLibraries(resourceNumber, friendlyUrl)
:
srcType == "cam" ?
await StartImportingFromCambridge(resourceNumber, friendlyUrl)
:
srcType == "bl" ?
await StartImportingFromBritishLibrary(resourceNumber, friendlyUrl)
:
srcType == "folder" ?
await StartImportingFromServerFolder(resourceNumber, friendlyUrl, resourcePrefix)
:
srcType == "walters" ?
await StartImportingFromWalters(resourceNumber, friendlyUrl)
:
srcType == "cbl" ?
await StartImportingFromChesterBeatty(resourceNumber, friendlyUrl)
:
await StartImportingFromTheLibraryOfCongress(resourceNumber, friendlyUrl, resourcePrefix);
}
/// <summary>
/// reschedule jobs
/// </summary>
/// <returns></returns>
public async Task<RServiceResult<bool>> RescheduleJobs()
{
try
{
ImportJob[] jobs = await _context.ImportJobs.Where(j => j.Status != ImportJobStatus.Succeeded && j.JobType == JobType.ChesterBeatty).OrderByDescending(j => j.ProgressPercent).ToArrayAsync();
List<string> scheduled = new List<string>();
foreach(ImportJob job in jobs)
{
if(job.Status != ImportJobStatus.Failed)
{
job.Status = ImportJobStatus.Aborted;
job.EndTime = DateTime.Now;
job.Exception = "Aborted by RescheduleJobs";
_context.Update(job);
await _context.SaveChangesAsync();
}
if (
await _context.ImportJobs.Where(j => j.ResourceNumber == job.ResourceNumber && j.Status == ImportJobStatus.Succeeded).SingleOrDefaultAsync()
!=
null
)
continue;
if (scheduled.IndexOf(job.ResourceNumber) == -1)
{
scheduled.Add(job.ResourceNumber);
RServiceResult<bool> rescheduled = await StartImportingFromChesterBeatty(job.ResourceNumber, job.FriendlyUrl);
if(rescheduled.Result)
{
_context.ImportJobs.Remove(job);
await _context.SaveChangesAsync();
}
}
}
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(true, exp.ToString());
}
}
/// <summary>
/// an incomplete prototype for removing artifacts
/// </summary>
/// <param name="artifactId"></param>
/// <param name="checkJobs"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> RemoveArtifactHavingNoNoteAndBookmarks(Guid artifactId, bool checkJobs)
{
try
{
RArtifactMasterRecord record = await _context.Artifacts
.Include(a => a.Items).ThenInclude(i => i.Images)
.Include(a => a.Items).ThenInclude(i => i.Tags)
.Include(a => a.Tags)
.Where(a => a.Id == artifactId)
.SingleOrDefaultAsync();
if (record == null)
{
return new RServiceResult<bool>(false, "Artifact not found.");
}
if (record.Status == PublishStatus.Published)
{
return new RServiceResult<bool>(false, "Can not delete published artifact");
}
if(checkJobs)
{
var jobs = await _context.ImportJobs.Where(j => j.ArtifactId == artifactId).ToArrayAsync();
if (jobs.Length > 0)
{
_context.ImportJobs.RemoveRange(jobs);
}
}
var pins = await _context.PinterestLinks.Where(j => j.ArtifactId == artifactId).ToArrayAsync();
if (pins.Length > 0)
{
_context.PinterestLinks.RemoveRange(pins);
}
foreach (RArtifactItemRecord item in record.Items)
{
_context.PictureFiles.RemoveRange(item.Images);
_context.TagValues.RemoveRange(item.Tags);
}
_context.Items.RemoveRange(record.Items);
_context.TagValues.RemoveRange(record.Tags);
_context.Artifacts.Remove(record);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch(Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// due to a bug in loc json outputs some artifacts with more than 1000 pages were downloaded incompletely
/// </summary>
/// <returns></returns>
public async Task<RServiceResult<string[]>> ReExamineLocDownloads()
{
try
{
ImportJob[] jobs = await _context.ImportJobs
.Include(j => j.Artifact)
.Where(j => j.Status == ImportJobStatus.Succeeded && j.JobType == JobType.Loc).ToArrayAsync();
List<string> scheduled = new List<string>();
List<ImportJob> rescheduledJobs = new List<ImportJob>();
foreach (ImportJob job in jobs)
{
int pageCount = 0;
//اول یک صفحه را می‌خوانیم تا تعداد صفحات را مشخص کنیم
using (var client = new HttpClient())
{
if (job.Artifact == null)
continue;
string url = $"https://www.loc.gov/resource/rbc0001.{job.ResourceNumber}/?fo=json&st=gallery"; //plmp
var result = await client.GetAsync(url);
//using (var result = await client.GetAsync(url))
{
int _ImportRetryCount = 5;
int _ImportRetryInitialSleep = 500;
int retryCount = 0;
while (retryCount < _ImportRetryCount && !result.IsSuccessStatusCode && result.StatusCode == HttpStatusCode.ServiceUnavailable)
{
result.Dispose();
Thread.Sleep(_ImportRetryInitialSleep * (retryCount + 1));
result = await client.GetAsync(url);
retryCount++;
}
if (result.IsSuccessStatusCode)
{
string json = await result.Content.ReadAsStringAsync();
var parsed = JObject.Parse(json);
pageCount = parsed.SelectToken("resource.segment_count").Value<int>();
}
else
{
return new RServiceResult<string[]>(null, $"{job.ResourceNumber}: Http result is not ok ({result.StatusCode}) for {url}");
}
if(pageCount != job.Artifact.ItemCount)
{
if (scheduled.IndexOf(job.ResourceNumber) == -1)
{
scheduled.Add(job.ResourceNumber);
rescheduledJobs.Add(job);
}
}
result.Dispose();
}
}
}
scheduled = new List<string>();
foreach (ImportJob job in rescheduledJobs)
{
await RemoveArtifactHavingNoNoteAndBookmarks((Guid)job.ArtifactId, false);
_context.ImportJobs.Remove(job);
await _context.SaveChangesAsync();
RServiceResult<bool> rescheduled = await StartImportingFromTheLibraryOfCongress(job.ResourceNumber, job.FriendlyUrl, "rbc0001");//plmp
if (rescheduled.Result)
{
scheduled.Add(job.ResourceNumber);
}
}
return new RServiceResult<string[]>(scheduled.ToArray());
}
catch (Exception exp)
{
return new RServiceResult<string[]>(null, exp.ToString());
}
}
private async Task<string> HandleSimpleValue(RMuseumDbContext context, JObject parsed, List<RTagValue> meta, string path, string aName)
{
try
{
string string_value = parsed.SelectToken(path).Value<string>();
if (!string.IsNullOrWhiteSpace(string_value))
{
meta.Add
(
await TagHandler.PrepareAttribute(context, aName, string_value, 1)
);
}
return string_value;
}
catch
{
return "";
}
}
private async Task<string> HandleListValue(RMuseumDbContext context, JObject parsed, List<RTagValue> meta, string path, string aName)
{
try
{
string value = "";
List<string> list = parsed.SelectToken(path).ToObject<List<string>>();
if (list != null && list.Count > 0)
{
value = list[0];
meta.Add
(
await TagHandler.PrepareAttribute(context, aName, list[0], 1)
);
for (int i = 1; i < list.Count; i++)
{
value += $"<br/>{Environment.NewLine}{list[i]}";
meta.Add
(
await TagHandler.PrepareAttribute(context, aName, list[i], i + 1)
);
}
}
return value;
}
catch
{
return "";
}
}
private async Task<string> HandleChildrenValue(RMuseumDbContext context, JObject parsed, List<RTagValue> meta, string path, string aName)
{
try
{
string value = "";
var children = parsed.SelectToken(path).Children<JToken>().ToList();
if (children.Count > 0)
{
value = children[0].First.Path.Replace($"{path}[0].", "").Replace($"{path}[0]", "");
meta.Add
(
await TagHandler.PrepareAttribute(context, aName, value, 1)
);
for (int i = 1; i < children.Count; i++)
{
value += $"<br/>{Environment.NewLine}{children[0].First.Path.Replace($"{path}[{i}].", "")}";
meta.Add
(
await TagHandler.PrepareAttribute(context, aName, children[0].First.Path.Replace($"{path}[{i}].", ""), i + 1)
);
}
}
return value;
}
catch
{
return "";
}
}
/// <summary>
/// import jobs
/// </summary>
/// <param name="paging"></param>
/// <returns></returns>
public async Task<RServiceResult<(PaginationMetadata PagingMeta, ImportJob[] Jobs)>> GetImportJobs(PagingParameterModel paging)
{
try
{
var source =
_context.ImportJobs
.Select(j => new ImportJob() { Id = j.Id, Artifact = j.Artifact, ArtifactId = j.ArtifactId, EndTime = j.EndTime, Exception = j.Exception, ProgressPercent = j.ProgressPercent, QueueTime = j.QueueTime, FriendlyUrl = j.FriendlyUrl, JobType = j.JobType, ResourceNumber = j.ResourceNumber, SrcContent = "--omitted--", SrcUrl = j.SrcUrl, StartTime = j.StartTime, Status = j.Status })
.OrderByDescending(t => t.QueueTime)
.AsQueryable();
(PaginationMetadata PagingMeta, ImportJob[] Items) paginatedResult =
await QueryablePaginator<ImportJob>.Paginate(source, paging);
return new RServiceResult<(PaginationMetadata PagingMeta, ImportJob[] Items)>(paginatedResult);
}
catch (Exception exp)
{
return new RServiceResult<(PaginationMetadata PagingMeta, ImportJob[] Items)>((PagingMeta: null, Items: null), exp.ToString());
}
}
/// <summary>
/// Bookmark Artifact
/// </summary>
/// <param name="artifactId"></param>
/// <param name="userId"></param>
/// <param name="type"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserBookmark>> BookmarkArtifact(Guid artifactId, Guid userId, RBookmarkType type)
{
try
{
if ((await _context.UserBookmarks.Where(b => b.RAppUserId == userId && b.RArtifactMasterRecordId == artifactId && b.RBookmarkType == type).SingleOrDefaultAsync()) != null)
{
return new RServiceResult<RUserBookmark>(null, "Artifact is already bookmarked/faved.");
}
RUserBookmark bookmark =
new RUserBookmark()
{
RAppUserId = userId,
RArtifactMasterRecordId = artifactId,
RBookmarkType = type,
DateTime = DateTime.Now,
Note = ""
};
_context.UserBookmarks.Add(bookmark);
await _context.SaveChangesAsync();
return new RServiceResult<RUserBookmark>(bookmark);
}
catch (Exception exp)
{
return new RServiceResult<RUserBookmark>(null, exp.ToString());
}
}
/// <summary>
/// get artifact user bookmarks
/// </summary>
/// <param name="artifactId"></param>
/// <param name="userId"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserBookmark[]>> GetArtifactUserBookmarks(Guid artifactId, Guid userId)
{
try
{
RUserBookmark[] bookmarks = await _context.UserBookmarks.Where(b => b.RArtifactMasterRecordId == artifactId && b.RAppUserId == userId).ToArrayAsync();
return new RServiceResult<RUserBookmark[]>(bookmarks);
}
catch (Exception exp)
{
return new RServiceResult<RUserBookmark[]>(null, exp.ToString());
}
}
/// <summary>
/// Bookmark Item
/// </summary>
/// <param name="itemId"></param>
/// <param name="userId"></param>
/// <param name="type"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserBookmark>> BookmarkItem(Guid itemId, Guid userId, RBookmarkType type)
{
try
{
if((await _context.UserBookmarks.Where(b => b.RAppUserId == userId && b.RArtifactItemRecordId == itemId && b.RBookmarkType == type).SingleOrDefaultAsync()) != null)
{
return new RServiceResult<RUserBookmark>(null, "Item is already bookmarked/faved.");
}
RUserBookmark bookmark =
new RUserBookmark()
{
RAppUserId = userId,
RArtifactItemRecordId = itemId,
RBookmarkType = type,
DateTime = DateTime.Now,
Note = ""
};
_context.UserBookmarks.Add(bookmark);
await _context.SaveChangesAsync();
return new RServiceResult<RUserBookmark>(bookmark);
}
catch (Exception exp)
{
return new RServiceResult<RUserBookmark>(null, exp.ToString());
}
}
/// <summary>
/// get item user bookmarks
/// </summary>
/// <param name="itemId"></param>
/// <param name="userId"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserBookmark[]>> GeItemUserBookmarks(Guid itemId, Guid userId)
{
try
{
RUserBookmark[] bookmarks = await _context.UserBookmarks.Where(b => b.RArtifactItemRecordId == itemId && b.RAppUserId == userId).ToArrayAsync();
return new RServiceResult<RUserBookmark[]>(bookmarks);
}
catch (Exception exp)
{
return new RServiceResult<RUserBookmark[]>(null, exp.ToString());
}
}
/// <summary>
/// update bookmark note
/// </summary>
/// <param name="bookmarkId"></param>
/// <param name="note"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> UpdateUserBookmark(Guid bookmarkId, string note)
{
try
{
RUserBookmark bookmark = await _context.UserBookmarks.Where(b => b.Id == bookmarkId).SingleOrDefaultAsync();
if(bookmark == null)
{
return new RServiceResult<bool>(false, "bookmark not found");
}
bookmark.Note = note;
_context.UserBookmarks.Update(bookmark);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// delete user bookmark
/// /// </summary>
/// <param name="bookmarkId"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> DeleteUserBookmark(Guid bookmarkId)
{
try
{
RUserBookmark bookmark = await _context.UserBookmarks.Where(b => b.Id == bookmarkId).SingleOrDefaultAsync();
if (bookmark == null)
{
return new RServiceResult<bool>(false, "bookmark not found");
}
_context.UserBookmarks.Remove(bookmark);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// get user bookmarks (artifacts and items)
/// </summary>
/// <param name="paging"></param>
/// <param name="userId"></param>
/// <param name="type"></param>
/// <param name="statusArray"></param>
/// <returns></returns>
public async Task<RServiceResult<(PaginationMetadata PagingMeta, RUserBookmarkViewModel[] Bookmarks)>> GetBookmarks(PagingParameterModel paging, Guid userId, RBookmarkType type, PublishStatus[] statusArray)
{
try
{
var source =
_context.UserBookmarks
.Include(b => b.RArtifactMasterRecord).ThenInclude(a => a.CoverImage)
.Include(b => b.RArtifactItemRecord).ThenInclude(b => b.Images)
.Where(b => b.RAppUserId == userId && b.RBookmarkType == type)
.OrderByDescending(b => b.DateTime)
.AsQueryable();
(PaginationMetadata PagingMeta, RUserBookmark[] Bookmarks) paginatedResult1 =
await QueryablePaginator<RUserBookmark>.Paginate(source, paging);
List<RUserBookmarkViewModel> finalList = new List<RUserBookmarkViewModel>();
foreach(RUserBookmark bookmark in paginatedResult1.Bookmarks)
{
RUserBookmarkViewModel model = new RUserBookmarkViewModel()
{
Id = bookmark.Id,
RAppUserId = bookmark.RAppUserId,
RArtifactMasterRecord = bookmark.RArtifactMasterRecord,
RArtifactItemRecord = null,//this should be filled by an external call
DateTime = bookmark.DateTime,
RBookmarkType = bookmark.RBookmarkType,
Note = bookmark.Note
};
if(bookmark.RArtifactMasterRecord != null)
{
if (!statusArray.Contains(bookmark.RArtifactMasterRecord.Status))
continue; //this may result in paging bugs
}
if(bookmark.RArtifactItemRecord != null)
{
RArtifactMasterRecord parent =
await _context.Artifacts
.Where(a => statusArray.Contains(a.Status) && a.Id == bookmark.RArtifactItemRecord.RArtifactMasterRecordId)
.AsNoTracking()
.SingleOrDefaultAsync();
if (parent == null)
continue;
model.RArtifactItemRecord = new RArtifactItemRecordViewModel()
{
Item = bookmark.RArtifactItemRecord
};
model.RArtifactItemRecord.ParentFriendlyUrl = parent.FriendlyUrl;
model.RArtifactItemRecord.ParentName = parent.Name;
}
finalList.Add(model);
}
return new RServiceResult<(PaginationMetadata PagingMeta, RUserBookmarkViewModel[] Bookmarks)>((paginatedResult1.PagingMeta, finalList.ToArray()));
}
catch (Exception exp)
{
return new RServiceResult<(PaginationMetadata PagingMeta, RUserBookmarkViewModel[] Bookmarks)>((PagingMeta: null, Bookmarks: null), exp.ToString());
}
}
/// <summary>
/// Add Note to Artifact
/// </summary>
/// <param name="artifactId"></param>
/// <param name="userId"></param>
/// <param name="type"></param>
/// <param name="noteContents"></param>
/// <param name="referenceNoteId"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserNoteViewModel>> AddUserNoteToArtifact(Guid artifactId, Guid userId, RNoteType type, string noteContents, Guid? referenceNoteId)
{
try
{
RServiceResult<PublicRAppUser> userInfo = await _userService.GetUserInformation(userId);
if (!string.IsNullOrEmpty(userInfo.ExceptionString))
return new RServiceResult<RUserNoteViewModel>(null, userInfo.ExceptionString);
RUserNote note =
new RUserNote()
{
RAppUserId = userId,
RArtifactMasterRecordId = artifactId,
NoteType = type,
HtmlContent = noteContents,
DateTime = DateTime.Now,
LastModified = DateTime.Now,
Modified = false,
Status = PublishStatus.Published,
ReferenceNoteId = referenceNoteId
};
_context.UserNotes.Add(note);
await _context.SaveChangesAsync(); //we need note.Id for the next step
if (referenceNoteId != null)
{
RUserNote referenceNote = await _context.UserNotes.Where(n => n.Id == referenceNoteId).SingleOrDefaultAsync();
if(referenceNote == null)
{
return new RServiceResult<RUserNoteViewModel>(null, "Reference note not found!");
}
if(referenceNote.RAppUserId != userId)
{
RArtifactMasterRecord artificat = await _context.Artifacts.Where(a => a.Id == artifactId).SingleOrDefaultAsync();
await _notificationService.PushNotification
(
referenceNote.RAppUserId,
$"پاسخگویی {userInfo.Result.FirstName} {userInfo.Result.SureName} به یادداشت شما دربارهٔ {artificat.Name}",
$"برای مشاهدهٔ پاسخ ارائه شده <a href=\"/items/{artificat.FriendlyUrl}#{note.Id}\">اینجا</a> را ببینید.<br />" +
$"پاسخ داده شده: <br />" +
$"<blockquote cite=\"/item/{artificat.FriendlyUrl}#{note.Id}\">{note.HtmlContent}</blockquote><br />" +
$"یادداشت شما: <br />" +
$"<blockquote cite=\"/item/{artificat.FriendlyUrl}#{referenceNote.Id}\">{referenceNote.HtmlContent}</blockquote>"
);
}
}
return new RServiceResult<RUserNoteViewModel>
(
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = userInfo.Result.FirstName + " " + userInfo.Result.SureName,
RUserImageId = userInfo.Result.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
}
);
}
catch (Exception exp)
{
return new RServiceResult<RUserNoteViewModel>(null, exp.ToString());
}
}
/// <summary>
/// Add Note to Artifact Item
/// </summary>
/// <param name="itemId"></param>
/// <param name="userId"></param>
/// <param name="type"></param>
/// <param name="noteContents"></param>
/// <param name="referenceNoteId"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserNoteViewModel>> AddUserNoteToArtifactItem(Guid itemId, Guid userId, RNoteType type, string noteContents, Guid? referenceNoteId)
{
try
{
RServiceResult<PublicRAppUser> userInfo = await _userService.GetUserInformation(userId);
if (!string.IsNullOrEmpty(userInfo.ExceptionString))
return new RServiceResult<RUserNoteViewModel>(null, userInfo.ExceptionString);
RUserNote note =
new RUserNote()
{
RAppUserId = userId,
RArtifactItemRecordId = itemId,
NoteType = type,
HtmlContent = noteContents,
DateTime = DateTime.Now,
LastModified = DateTime.Now,
Modified = false,
Status = PublishStatus.Published,
ReferenceNoteId = referenceNoteId
};
_context.UserNotes.Add(note);
await _context.SaveChangesAsync();//we need note.Id for the next step
if (referenceNoteId != null)
{
RUserNote referenceNote = await _context.UserNotes.Where(n => n.Id == referenceNoteId).SingleOrDefaultAsync();
if (referenceNote == null)
{
return new RServiceResult<RUserNoteViewModel>(null, "Reference note not found!");
}
if (referenceNote.RAppUserId != userId)
{
RArtifactItemRecord item = await _context.Items.Where(a => a.Id == itemId).SingleOrDefaultAsync();
RArtifactMasterRecord artificat = await _context.Artifacts.Where(a => a.Id == item.RArtifactMasterRecordId).SingleOrDefaultAsync();
await _notificationService.PushNotification
(
referenceNote.RAppUserId,
$"پاسخگویی {userInfo.Result.FirstName} {userInfo.Result.SureName} به یادداشت شما دربارهٔ {artificat.Name} « {item.Name}",
$"برای مشاهدهٔ پاسخ ارائه شده <a href=\"/items/{artificat.FriendlyUrl}/{item.FriendlyUrl}#{note.Id}\">اینجا</a> را ببینید.<br />" +
$"پاسخ داده شده: <br />" +
$"<blockquote cite=\"/item/{artificat.FriendlyUrl}/{item.FriendlyUrl}#{note.Id}\">{note.HtmlContent}</blockquote><br />" +
$"یادداشت شما: <br />" +
$"<blockquote cite=\"/item/{artificat.FriendlyUrl}/{item.FriendlyUrl}#{referenceNote.Id}\">{referenceNote.HtmlContent}</blockquote>"
);
}
}
return new RServiceResult<RUserNoteViewModel>
(
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = userInfo.Result.FirstName + " " + userInfo.Result.SureName,
RUserImageId = userInfo.Result.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
}
);
}
catch (Exception exp)
{
return new RServiceResult<RUserNoteViewModel>(null, exp.ToString());
}
}
/// <summary>
/// Edit Note
/// </summary>
/// <param name="noteId"></param>
/// <param name="userId"></param>
/// <param name="noteContents"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserNoteViewModel>> EditUserNote(Guid noteId, Guid? userId, string noteContents)
{
try
{
RUserNote note = await _context.UserNotes.
Where(n => n.Id == noteId).
SingleOrDefaultAsync();
if (note == null)
{
return new RServiceResult<RUserNoteViewModel>(null, "Note not found.");
}
if(userId != null) //sending null here means user is a moderator
{
if (userId != note.RAppUserId)
{
return new RServiceResult<RUserNoteViewModel>(null, "Note only can be edited by its owner");
}
}
RServiceResult<PublicRAppUser> userInfo = await _userService.GetUserInformation(note.RAppUserId);
if (!string.IsNullOrEmpty(userInfo.ExceptionString))
return new RServiceResult<RUserNoteViewModel>(null, userInfo.ExceptionString);
note.HtmlContent = noteContents;
note.LastModified = DateTime.Now;
_context.UserNotes.Update(note);
await _context.SaveChangesAsync();
return new RServiceResult<RUserNoteViewModel>
(
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = userInfo.Result.FirstName + " " + userInfo.Result.SureName,
RUserImageId = userInfo.Result.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
}
);
}
catch (Exception exp)
{
return new RServiceResult<RUserNoteViewModel>(null, exp.ToString());
}
}
/// <summary>
/// delete note
/// </summary>
/// <param name="noteId"></param>
/// <param name="userId">sending null here means user is a moderator or the note is being deleted in a recursive delete of referenced notes</param>
/// <returns>list of notes deleted</returns>
public async Task<RServiceResult<Guid[]>> DeleteUserNote(Guid noteId, Guid? userId)
{
try
{
RUserNote note = await _context.UserNotes.
Where(n => n.Id == noteId).
SingleOrDefaultAsync();
if (note == null)
{
return new RServiceResult<Guid[]>(null, "Note not found.");
}
if (userId != null) //sending null here means user is a moderator or the note is being deleted in a recursive delete of referenced notes
{
if (userId != note.RAppUserId)
{
return new RServiceResult<Guid[]>(null, "Note only can be deleted by its owner");
}
}
List<Guid> deletedNotesIdSet = new List<Guid>();
RUserNote[] relatedNotes = await _context.UserNotes.Where(n => n.ReferenceNoteId == noteId).ToArrayAsync();
foreach(RUserNote relatedNote in relatedNotes)
{
deletedNotesIdSet.Add(relatedNote.Id);
RServiceResult<Guid[]> refDel = await DeleteUserNote(relatedNote.Id, null);
if (!string.IsNullOrEmpty(refDel.ExceptionString))
return new RServiceResult<Guid[]>(null, refDel.ExceptionString);
}
deletedNotesIdSet.Add(noteId);
_context.UserNotes.Remove(note);
await _context.SaveChangesAsync();
return new RServiceResult<Guid[]>(deletedNotesIdSet.ToArray());
}
catch (Exception exp)
{
return new RServiceResult<Guid[]>(null, exp.ToString());
}
}
/// <summary>
/// get artifact private user notes
/// </summary>
/// <param name="artifactId"></param>
/// <param name="userId"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserNoteViewModel[]>> GetArtifactUserNotes(Guid artifactId, Guid userId)
{
try
{
RUserNote[] notes = await _context.UserNotes.
Where(b => b.RArtifactMasterRecordId == artifactId && b.RAppUserId == userId && b.NoteType == RNoteType.Private).
OrderBy(n => n.DateTime).ToArrayAsync();
RServiceResult<PublicRAppUser> userInfo = await _userService.GetUserInformation(userId);
if (!string.IsNullOrEmpty(userInfo.ExceptionString))
return new RServiceResult<RUserNoteViewModel[]>(null, userInfo.ExceptionString);
List<RUserNoteViewModel> res = new List<RUserNoteViewModel>();
foreach (RUserNote note in notes)
res.Add
(
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = userInfo.Result.FirstName + " " + userInfo.Result.SureName,
RUserImageId = userInfo.Result.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
}
);
return new RServiceResult<RUserNoteViewModel[]>(res.ToArray());
}
catch (Exception exp)
{
return new RServiceResult<RUserNoteViewModel[]>(null, exp.ToString());
}
}
/// <summary>
/// recursvie call to build notes tree
/// </summary>
/// <param name="artifactId"></param>
/// <param name="parentNoteId"></param>
/// <returns></returns>
private async Task<RUserNoteViewModel[]> _GetArtifactPublicNotes(Guid artifactId, Guid? parentNoteId)
{
RUserNote[] notes = await _context.UserNotes.
Where(b => b.RArtifactMasterRecordId == artifactId && b.NoteType == RNoteType.Public && b.ReferenceNoteId == parentNoteId)
.Include(n => n.RAppUser)
.OrderBy(n => n.DateTime).ToArrayAsync();
List<RUserNoteViewModel> res = new List<RUserNoteViewModel>();
foreach (RUserNote note in notes)
{
RAppUser appUser = note.RAppUser;
var user =
new PublicRAppUser()
{
Id = appUser.Id,
Username = appUser.UserName,
Email = appUser.Email,
FirstName = appUser.FirstName,
SureName = appUser.SureName,
PhoneNumber = appUser.PhoneNumber,
RImageId = appUser.RImageId,
Status = appUser.Status
};
RUserNoteViewModel viewModel
=
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = user.FirstName + " " + user.SureName,
RUserImageId = user.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
};
viewModel.Notes = await _GetArtifactPublicNotes(artifactId, note.Id);
res.Add(viewModel);
}
return res.ToArray();
}
/// <summary>
/// get artifact public user notes
/// </summary>
/// <param name="artifactId"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserNoteViewModel[]>> GetArtifactPublicNotes(Guid artifactId)
{
try
{
return new RServiceResult<RUserNoteViewModel[]>(await _GetArtifactPublicNotes(artifactId, null));
}
catch (Exception exp)
{
return new RServiceResult<RUserNoteViewModel[]>(null, exp.ToString());
}
}
/// <summary>
/// get item artifact private user notes
/// </summary>
/// <param name="itemId"></param>
/// <param name="userId"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserNoteViewModel[]>> GetArtifactItemUserNotes(Guid itemId, Guid userId)
{
try
{
RUserNote[] notes = await _context.UserNotes.
Where(b => b.RArtifactItemRecordId == itemId && b.RAppUserId == userId && b.NoteType == RNoteType.Private).
OrderBy(n => n.DateTime).ToArrayAsync();
RServiceResult<PublicRAppUser> userInfo = await _userService.GetUserInformation(userId);
if (!string.IsNullOrEmpty(userInfo.ExceptionString))
return new RServiceResult<RUserNoteViewModel[]>(null, userInfo.ExceptionString);
List<RUserNoteViewModel> res = new List<RUserNoteViewModel>();
foreach (RUserNote note in notes)
res.Add
(
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = userInfo.Result.FirstName + " " + userInfo.Result.SureName,
RUserImageId = userInfo.Result.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
}
);
return new RServiceResult<RUserNoteViewModel[]>(res.ToArray());
}
catch (Exception exp)
{
return new RServiceResult<RUserNoteViewModel[]>(null, exp.ToString());
}
}
/// <summary>
/// recursvie call to build notes tree for iten
/// </summary>
/// <param name="itemId"></param>
/// <param name="parentNoteId"></param>
/// <returns></returns>
private async Task<RUserNoteViewModel[]> _GetArtifactItemPublicNotes(Guid itemId, Guid? parentNoteId)
{
RUserNote[] notes = await _context.UserNotes.
Where(b => b.RArtifactItemRecordId == itemId && b.NoteType == RNoteType.Public && b.ReferenceNoteId == parentNoteId)
.Include(n => n.RAppUser)
.OrderBy(n => n.DateTime).ToArrayAsync();
List<RUserNoteViewModel> res = new List<RUserNoteViewModel>();
foreach (RUserNote note in notes)
{
RAppUser appUser = note.RAppUser;
var user =
new PublicRAppUser()
{
Id = appUser.Id,
Username = appUser.UserName,
Email = appUser.Email,
FirstName = appUser.FirstName,
SureName = appUser.SureName,
PhoneNumber = appUser.PhoneNumber,
RImageId = appUser.RImageId,
Status = appUser.Status
};
RUserNoteViewModel viewModel
=
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = user.FirstName + " " + user.SureName,
RUserImageId = user.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
};
viewModel.Notes = await _GetArtifactItemPublicNotes(itemId, note.Id);
res.Add(viewModel);
}
return res.ToArray();
}
/// <summary>
/// get item artifact item public user notes
/// </summary>
/// <param name="itemId"></param>
/// <returns></returns>
public async Task<RServiceResult<RUserNoteViewModel[]>> GetArtifactItemPublicNotes(Guid itemId)
{
try
{
return new RServiceResult<RUserNoteViewModel[]>(await _GetArtifactItemPublicNotes(itemId, null));
}
catch (Exception exp)
{
return new RServiceResult<RUserNoteViewModel[]>(null, exp.ToString());
}
}
/// <summary>
/// Get All USer Notes
/// </summary>
/// <param name="userId"></param>
/// <param name="paging"></param>
/// <param name="type"></param>
/// <param name="statusArray"></param>
/// <returns></returns>
public async Task<RServiceResult<(PaginationMetadata PagingMeta, RUserNoteViewModel[] Notes)>> GetUserNotes(Guid userId, PagingParameterModel paging, RNoteType type, PublishStatus[] statusArray)
{
try
{
var source =
_context.UserNotes
.Include(b => b.RArtifactMasterRecord).ThenInclude(a => a.CoverImage)
.Include(b => b.RArtifactItemRecord).ThenInclude(b => b.Images)
.Where(b => b.RAppUserId == userId && b.NoteType == type)
.OrderByDescending(b => b.DateTime)
.AsQueryable();
(PaginationMetadata PagingMeta, RUserNote[] Notes) paginatedResult1 =
await QueryablePaginator<RUserNote>.Paginate(source, paging);
RServiceResult<PublicRAppUser> userInfo = await _userService.GetUserInformation(userId);
if (!string.IsNullOrEmpty(userInfo.ExceptionString))
return new RServiceResult<(PaginationMetadata PagingMeta, RUserNoteViewModel[] Notes)>((PagingMeta: null, Notes: null), userInfo.ExceptionString);
PublicRAppUser user = userInfo.Result;
List<RUserNoteViewModel> finalList = new List<RUserNoteViewModel>();
foreach (RUserNote note in paginatedResult1.Notes)
{
RUserNoteViewModel model =
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = user.FirstName + " " + user.SureName,
RUserImageId = user.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
};
if (note.RArtifactMasterRecord != null)
{
if (!statusArray.Contains(note.RArtifactMasterRecord.Status))
continue; //this may result in paging bugs
}
if (note.RArtifactItemRecord != null)
{
RArtifactMasterRecord parent =
await _context.Artifacts
.Where(a => statusArray.Contains(a.Status) && a.Id == note.RArtifactItemRecord.RArtifactMasterRecordId)
.AsNoTracking()
.SingleOrDefaultAsync();
if (parent == null)
continue;
model.RelatedEntityName = note.RArtifactItemRecord.Name;
model.RelatedEntityImageId = note.RArtifactItemRecord.Images.FirstOrDefault().Id;
model.RelatedEntityFriendlyUrl = parent.FriendlyUrl + "/" + note.RArtifactItemRecord.FriendlyUrl;
model.RelatedItemParentName = parent.Name;
}
if(note.RArtifactMasterRecord != null)
{
model.RelatedEntityName = note.RArtifactMasterRecord.Name;
model.RelatedEntityImageId = note.RArtifactMasterRecord.CoverImage.Id;
model.RelatedEntityFriendlyUrl = note.RArtifactMasterRecord.FriendlyUrl;
}
finalList.Add(model);
}
return new RServiceResult<(PaginationMetadata PagingMeta, RUserNoteViewModel[] Notes)>((paginatedResult1.PagingMeta, finalList.ToArray()));
}
catch (Exception exp)
{
return new RServiceResult<(PaginationMetadata PagingMeta, RUserNoteViewModel[] Notes)>((PagingMeta: null, Notes: null), exp.ToString());
}
}
/// <summary>
/// Get All Public Notes
/// </summary>
/// <param name="paging"></param>
/// <returns></returns>
public async Task<RServiceResult<(PaginationMetadata PagingMeta, RUserNoteViewModel[] Notes)>> GetAllPublicNotes(PagingParameterModel paging)
{
try
{
var source =
_context.UserNotes
.Include(b => b.RArtifactMasterRecord).ThenInclude(a => a.CoverImage)
.Include(b => b.RArtifactItemRecord).ThenInclude(b => b.Images)
.Include(n => n.RAppUser)
.Where(b => b.NoteType == RNoteType.Public)
.OrderByDescending(b => b.DateTime)
.AsQueryable();
(PaginationMetadata PagingMeta, RUserNote[] Notes) paginatedResult1 =
await QueryablePaginator<RUserNote>.Paginate(source, paging);
List<RUserNoteViewModel> finalList = new List<RUserNoteViewModel>();
foreach (RUserNote note in paginatedResult1.Notes)
{
RAppUser appUser = note.RAppUser;
var user =
new PublicRAppUser()
{
Id = appUser.Id,
Username = appUser.UserName,
Email = appUser.Email,
FirstName = appUser.FirstName,
SureName = appUser.SureName,
PhoneNumber = appUser.PhoneNumber,
RImageId = appUser.RImageId,
Status = appUser.Status
};
RUserNoteViewModel model
=
new RUserNoteViewModel()
{
Id = note.Id,
RAppUserId = note.RAppUserId,
UserName = user.FirstName + " " + user.SureName,
RUserImageId = user.RImageId,
Modified = note.Modified,
NoteType = note.NoteType,
HtmlContent = note.HtmlContent,
ReferenceNoteId = note.ReferenceNoteId,
Status = note.Status,
Notes = new RUserNoteViewModel[] { },
DateTime = RUserNoteViewModel.PrepareNoteDateTime(note.DateTime),
LastModified = RUserNoteViewModel.PrepareNoteDateTime(note.LastModified)
};
if (note.RArtifactMasterRecord != null)
{
if (note.RArtifactMasterRecord.Status != PublishStatus.Published)
continue; //this may result in paging bugs
}
if (note.RArtifactItemRecord != null)
{
RArtifactMasterRecord parent =
await _context.Artifacts
.Where(a => a.Status == PublishStatus.Published && a.Id == note.RArtifactItemRecord.RArtifactMasterRecordId)
.AsNoTracking()
.SingleOrDefaultAsync();
if (parent == null)
continue;
model.RelatedEntityName = note.RArtifactItemRecord.Name;
model.RelatedEntityImageId = note.RArtifactItemRecord.Images.FirstOrDefault().Id;
model.RelatedEntityFriendlyUrl = parent.FriendlyUrl + "/" + note.RArtifactItemRecord.FriendlyUrl;
model.RelatedItemParentName = parent.Name;
}
if (note.RArtifactMasterRecord != null)
{
model.RelatedEntityName = note.RArtifactMasterRecord.Name;
model.RelatedEntityImageId = note.RArtifactMasterRecord.CoverImage.Id;
model.RelatedEntityFriendlyUrl = note.RArtifactMasterRecord.FriendlyUrl;
}
finalList.Add(model);
}
return new RServiceResult<(PaginationMetadata PagingMeta, RUserNoteViewModel[] Notes)>((paginatedResult1.PagingMeta, finalList.ToArray()));
}
catch (Exception exp)
{
return new RServiceResult<(PaginationMetadata PagingMeta, RUserNoteViewModel[] Notes)>((PagingMeta: null, Notes: null), exp.ToString());
}
}
/// <summary>
/// suggest ganjoor link
/// </summary>
/// <param name="userId"></param>
/// <param name="link"></param>
/// <returns></returns>
public async Task<RServiceResult<GanjoorLinkViewModel>> SuggestGanjoorLink(Guid userId, LinkSuggestion link)
{
try
{
RArtifactMasterRecord artifact = await _context.Artifacts.Where(a => a.FriendlyUrl == link.ArtifactFriendlyUrl).SingleOrDefaultAsync();
GanjoorLink alreaySuggest =
await _context.GanjoorLinks.
Where(l => l.GanjoorPostId == link.GanjoorPostId && l.ArtifactId == artifact.Id && l.ItemId == link.ItemId && l.ReviewResult != ReviewResult.Rejected)
.SingleOrDefaultAsync();
if (alreaySuggest != null)
return new RServiceResult<GanjoorLinkViewModel>(null, "این مورد پیشتر پیشنهاد شده است.");
GanjoorLink suggestion =
new GanjoorLink()
{
GanjoorPostId = link.GanjoorPostId,
GanjoorTitle = link.GanjoorTitle,
GanjoorUrl = link.GanjoorUrl,
ArtifactId = artifact.Id,
ItemId = link.ItemId,
SuggestedById = userId,
SuggestionDate = DateTime.Now,
ReviewResult = ReviewResult.Awaiting
};
_context.GanjoorLinks.Add(suggestion);
await _context.SaveChangesAsync();
string entityName, entityFriendlyUrl;
Guid entityImageId;
if (suggestion.ItemId == null)
{
entityName = artifact.Name;
entityFriendlyUrl = $"/items/{artifact.FriendlyUrl}";
entityImageId = artifact.CoverImageId;
}
else
{
RArtifactItemRecord item = await _context.Items.Include(i => i.Images).Where(i => i.Id == suggestion.ItemId).SingleOrDefaultAsync();
entityName = artifact.Name + " » " + item.Name;
entityFriendlyUrl = $"/items/{artifact.FriendlyUrl}/{item.FriendlyUrl}";
entityImageId = item.Images.First().Id;
}
var user = (await _userService.GetUserInformation(userId)).Result;
GanjoorLinkViewModel viewModel
= new GanjoorLinkViewModel()
{
Id = suggestion.Id,
GanjoorPostId = suggestion.GanjoorPostId,
GanjoorUrl = suggestion.GanjoorUrl,
GanjoorTitle = suggestion.GanjoorTitle,
EntityName = entityName,
EntityFriendlyUrl = entityFriendlyUrl,
EntityImageId = entityImageId,
ReviewResult = suggestion.ReviewResult,
Synchronized = suggestion.Synchronized,
SuggestedBy = new PublicRAppUser()
{
Id = user.Id,
Username = user.Username,
Email = user.Email,
FirstName = user.FirstName,
SureName = user.SureName,
PhoneNumber = user.PhoneNumber,
RImageId = user.RImageId,
Status = user.Status
}
};
return new RServiceResult<GanjoorLinkViewModel>(viewModel);
}
catch(Exception exp)
{
return new RServiceResult<GanjoorLinkViewModel>(null, exp.ToString());
}
}
/// <summary>
/// get suggested ganjoor links
/// </summary>
/// <param name="status"></param>
/// <param name="notSynced"></param>
/// <returns></returns>
public async Task<RServiceResult<GanjoorLinkViewModel[]>> GetSuggestedLinks(ReviewResult status, bool notSynced)
{
try
{
GanjoorLink[] links =
await _context.GanjoorLinks
.Include(l => l.SuggestedBy)
.Include(l => l.Artifact)
.Include(l => l.Item).ThenInclude(i => i.Images)
.Where(l => l.ReviewResult == status && (notSynced == false || !l.Synchronized))
.OrderBy( l => l.SuggestionDate)
.ToArrayAsync();
List<GanjoorLinkViewModel> result = new List<GanjoorLinkViewModel>();
foreach(GanjoorLink link in links)
{
result.Add
(
new GanjoorLinkViewModel()
{
Id = link.Id,
GanjoorPostId = link.GanjoorPostId,
GanjoorUrl = link.GanjoorUrl,
GanjoorTitle = link.GanjoorTitle,
EntityName = link.Item == null ? link.Artifact.Name : link.Artifact.Name + " » " + link.Item.Name,
EntityFriendlyUrl = link.Item == null ? $"/items/{link.Artifact.FriendlyUrl}" : $"/items/{link.Artifact.FriendlyUrl}/{link.Item.FriendlyUrl}",
EntityImageId = link.Item == null ? link.Artifact.CoverImageId : link.Item.Images.First().Id,
ReviewResult = link.ReviewResult,
Synchronized = link.Synchronized,
SuggestedBy = new PublicRAppUser()
{
Id = link.SuggestedBy.Id,
Username = link.SuggestedBy.UserName,
Email = link.SuggestedBy.Email,
FirstName = link.SuggestedBy.FirstName,
SureName = link.SuggestedBy.SureName,
PhoneNumber = link.SuggestedBy.PhoneNumber,
RImageId = link.SuggestedBy.RImageId,
Status = link.SuggestedBy.Status
}
}
);
}
return new RServiceResult<GanjoorLinkViewModel[]>(result.ToArray());
}
catch (Exception exp)
{
return new RServiceResult<GanjoorLinkViewModel[]>(null, exp.ToString());
}
}
/// <summary>
/// Review Suggested Link
/// </summary>
/// <param name="linkId"></param>
/// <param name="userId"></param>
/// <param name="result"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> ReviewSuggestedLink(Guid linkId, Guid userId, ReviewResult result)
{
try
{
GanjoorLink link =
await _context.GanjoorLinks
.Include(l => l.Artifact).ThenInclude(a => a.Tags).ThenInclude(t => t.RTag)
.Include(l => l.Item).ThenInclude(i => i.Tags).ThenInclude(t => t.RTag)
.Where(l => l.Id == linkId)
.SingleOrDefaultAsync();
link.ReviewResult = result;
link.ReviewerId = userId;
link.ReviewDate = DateTime.Now;
_context.GanjoorLinks.Update(link);
if(link.ReviewResult == ReviewResult.Approved)
{
RTagValue tag = await TagHandler.PrepareAttribute(_context, "Ganjoor Link", link.GanjoorTitle, 1);
tag.ValueSupplement = link.GanjoorUrl;
if(link.Item == null)
{
link.Artifact.Tags.Add(tag);
_context.Artifacts.Update(link.Artifact);
}
else
{
link.Item.Tags.Add(tag);
_context.Items.Update(link.Item);
}
//add TOC:
using (var client = new HttpClient())
{
using (var httpResult = await client.GetAsync(link.GanjoorUrl))
{
if (httpResult.IsSuccessStatusCode)
{
string html = await httpResult.Content.ReadAsStringAsync();
int nIndexFirstParagraphOpenning = html.IndexOf("<p>");
if (nIndexFirstParagraphOpenning != -1)
{
int nIndexFirstParagraphClosing = html.IndexOf("</p>");
if (nIndexFirstParagraphClosing > nIndexFirstParagraphOpenning)
{
string paragraphContent = html.Substring(nIndexFirstParagraphOpenning + "<p>".Length, 1 + nIndexFirstParagraphClosing - (nIndexFirstParagraphOpenning + "</p>".Length));
if (paragraphContent.Length != 0)
{
int openIndex = paragraphContent.IndexOf('<');
while (paragraphContent.Length > 0 && (openIndex != -1))
{
string afterClosing = "";
int closeIndex = paragraphContent.IndexOf('>', openIndex);
if (closeIndex != -1)
afterClosing = paragraphContent.Substring(closeIndex + 1);
paragraphContent = paragraphContent.Substring(0, openIndex) + afterClosing;
openIndex = paragraphContent.IndexOf('<');
}
paragraphContent = paragraphContent.Replace("<", "").Replace(">", "");
if (paragraphContent.Length > 100)
paragraphContent = paragraphContent.Substring(0, 100) + " ...";
RTagValue toc = await TagHandler.PrepareAttribute(_context, "Title in TOC", paragraphContent, 1);
toc.ValueSupplement = "1";//font size
if (link.Item == null)
{
if (link.Artifact.Tags.Where(t => t.RTag.Name == "Title in TOC" && t.Value == toc.Value).Count() == 0)
{
toc.Order = 1 + link.Artifact.Tags.Where(t => t.RTag.NameInEnglish == "Title in TOC").Count();
link.Artifact.Tags.Add(toc);
_context.Artifacts.Update(link.Artifact);
}
}
else
{
if (link.Item.Tags.Where(t => t.RTag.Name == "Title in TOC" && t.Value == toc.Value).Count() == 0)
{
toc.Order = 1 + link.Item.Tags.Where(t => t.RTag.NameInEnglish == "Title in TOC").Count();
link.Item.Tags.Add(toc);
_context.Items.Update(link.Item);
}
}
}
}
}
}
}
}
}
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// Temporary api
/// </summary>
/// <returns></returns>
public async Task<RServiceResult<string[]>> AddTOCForSuggestedLinks()
{
try
{
GanjoorLink[] links =
await _context.GanjoorLinks
.Include(l => l.Artifact).ThenInclude(a => a.Tags).ThenInclude(t => t.RTag)
.Include(l => l.Item).ThenInclude(i => i.Tags).ThenInclude(t => t.RTag)
.Where(l => l.ReviewResult == ReviewResult.Approved)
.ToArrayAsync();
List<string> lst = new List<string>();
foreach(GanjoorLink link in links)
{
using(var client = new HttpClient())
{
using (var result = await client.GetAsync(link.GanjoorUrl))
{
if (result.IsSuccessStatusCode)
{
string html = await result.Content.ReadAsStringAsync();
int nIndexFirstParagraphOpenning = html.IndexOf("<p>");
if(nIndexFirstParagraphOpenning != -1)
{
int nIndexFirstParagraphClosing = html.IndexOf("</p>");
if(nIndexFirstParagraphClosing > nIndexFirstParagraphOpenning)
{
string paragraphContent = html.Substring(nIndexFirstParagraphOpenning + "<p>".Length, 1 + nIndexFirstParagraphClosing - (nIndexFirstParagraphOpenning + "</p>".Length));
if (paragraphContent.Length == 0)
continue;
if (paragraphContent.Length > 100)
paragraphContent = paragraphContent.Substring(0, 100) + " ...";
lst.Add(paragraphContent);
RTagValue tag = await TagHandler.PrepareAttribute(_context, "Title in TOC", paragraphContent, 1);
tag.ValueSupplement = "1";//font size
if (link.Item == null)
{
if(link.Artifact.Tags.Where(t => t.RTag.Name == "Title in TOC" && t.Value == tag.Value).Count() == 0)
{
tag.Order = 1 + link.Artifact.Tags.Where(t => t.RTag.NameInEnglish == "Title in TOC").Count();
link.Artifact.Tags.Add(tag);
_context.Artifacts.Update(link.Artifact);
}
}
else
{
if (link.Item.Tags.Where(t => t.RTag.Name == "Title in TOC" && t.Value == tag.Value).Count() == 0)
{
tag.Order = 1 + link.Item.Tags.Where(t => t.RTag.NameInEnglish == "Title in TOC").Count();
link.Item.Tags.Add(tag);
_context.Items.Update(link.Item);
}
}
}
}
}
}
}
}
await _context.SaveChangesAsync();
return new RServiceResult<string[]>(lst.ToArray());
}
catch (Exception exp)
{
return new RServiceResult<string[]>(null, exp.ToString());
}
}
/// <summary>
/// Synchronize suggested link
/// </summary>
/// <param name="linkId"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> SynchronizeSuggestedLink(Guid linkId)
{
try
{
GanjoorLink link =
await _context.GanjoorLinks
.Where(l => l.Id == linkId)
.SingleOrDefaultAsync();
link.Synchronized = true;
_context.GanjoorLinks.Update(link);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// get suggested pinterest links
/// </summary>
/// <param name="status"></param>
/// <param name="notSynced"></param>
/// <returns></returns>
public async Task<RServiceResult<PinterestLinkViewModel[]>> GetSuggestedPinterestLinks(ReviewResult status, bool notSynced)
{
try
{
PinterestLink[] links =
await _context.PinterestLinks
.Include(l => l.Artifact)
.Include(l => l.Item).ThenInclude(i => i.Images)
.Where(l => l.ReviewResult == status && (notSynced == false || !l.Synchronized))
.OrderBy(l => l.SuggestionDate)
.ToArrayAsync();
List<PinterestLinkViewModel> result = new List<PinterestLinkViewModel>();
foreach (PinterestLink link in links)
{
result.Add
(
new PinterestLinkViewModel()
{
Id = link.Id,
GanjoorPostId = link.GanjoorPostId,
GanjoorUrl = link.GanjoorUrl,
GanjoorTitle = link.GanjoorTitle,
AltText = link.AltText,
LinkType = link.LinkType,
PinterestImageUrl = link.PinterestImageUrl,
PinterestUrl = link.PinterestUrl,
SuggestionDate = link.SuggestionDate,
ReviewerId = link.ReviewerId,
ReviewDate = link.ReviewDate,
ReviewResult = link.ReviewResult,
ReviewDesc = link.ReviewDesc,
ArtifactId = link.ArtifactId,
ItemId = link.ItemId,
Synchronized = link.Synchronized,
EntityName = link.Artifact == null ? null : link.Artifact.Name + " » " + link.Item.Name,
EntityFriendlyUrl = link.Artifact == null ? null : $"/items/{link.Artifact.FriendlyUrl}/{link.Item.FriendlyUrl}",
EntityImageId = link.Item == null ? Guid.Empty : link.Item.Images.First().Id
}
);
}
return new RServiceResult<PinterestLinkViewModel[]>(result.ToArray());
}
catch (Exception exp)
{
return new RServiceResult<PinterestLinkViewModel[]>(null, exp.ToString());
}
}
/// <summary>
/// suggest pinterest link
/// </summary>
/// <param name="userId"></param>
/// <param name="suggestion"></param>
/// <returns></returns>
public async Task<RServiceResult<PinterestLinkViewModel>> SuggestPinterestLink(Guid userId, PinterestSuggestion suggestion)
{
try
{
PinterestLink existingLink =
await _context.PinterestLinks.Where
(
p =>
p.GanjoorPostId == suggestion.GanjoorPostId
&&
p.PinterestUrl == suggestion.PinterestUrl
&&
(p.ReviewResult == ReviewResult.Approved || p.ReviewResult == ReviewResult.Awaiting)
).FirstOrDefaultAsync();
if (existingLink != null)
return new RServiceResult<PinterestLinkViewModel>(null, "این مورد پیشتر پیشنهاد شده است.");
PinterestLink link = new PinterestLink()
{
GanjoorPostId = suggestion.GanjoorPostId,
GanjoorTitle = suggestion.GanjoorTitle,
GanjoorUrl = suggestion.GanjoorUrl,
AltText = suggestion.AltText,
LinkType = suggestion.LinkType,
PinterestUrl = suggestion.PinterestUrl,
PinterestImageUrl = suggestion.PinterestImageUrl,
ReviewResult = ReviewResult.Awaiting,
SuggestionDate = DateTime.Now,
SuggestedById = userId,
Synchronized = false
};
_context.PinterestLinks.Add(link);
await _context.SaveChangesAsync();
return new RServiceResult<PinterestLinkViewModel>
(
new PinterestLinkViewModel()
{
Id = link.Id,
GanjoorPostId = link.GanjoorPostId,
GanjoorUrl = link.GanjoorUrl,
GanjoorTitle = link.GanjoorTitle,
AltText = link.AltText,
LinkType = link.LinkType,
PinterestImageUrl = link.PinterestImageUrl,
PinterestUrl = link.PinterestUrl,
SuggestionDate = link.SuggestionDate,
ReviewerId = link.ReviewerId,
ReviewDate = link.ReviewDate,
ReviewResult = link.ReviewResult,
ReviewDesc = link.ReviewDesc,
ArtifactId = link.ArtifactId,
ItemId = link.ItemId,
Synchronized = link.Synchronized,
EntityName = null,
EntityFriendlyUrl = null,
EntityImageId = Guid.Empty
}
);
}
catch (Exception exp)
{
return new RServiceResult<PinterestLinkViewModel>(null, exp.ToString());
}
}
/// <summary>
/// Review Suggested Pinterest Link
/// </summary>
/// <param name="linkId"></param>
/// <param name="userId"></param>
/// <param name="altText"></param>
/// <param name="result"></param>
/// <param name="reviewDesc"></param>
/// <param name="imageUrl"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> ReviewSuggestedPinterestLink(Guid linkId, Guid userId, string altText, ReviewResult result, string reviewDesc, string imageUrl)
{
try
{
PinterestLink link =
await _context.PinterestLinks
.Where(l => l.Id == linkId)
.SingleOrDefaultAsync();
link.ReviewResult = result;
link.ReviewerId = userId;
link.ReviewDate = DateTime.Now;
if(!string.IsNullOrEmpty(altText))
link.AltText = altText;
if (!string.IsNullOrEmpty(imageUrl))
link.PinterestImageUrl = imageUrl;
link.ReviewDesc = reviewDesc;
if (link.ReviewResult == ReviewResult.Approved)
{
PinterestLink relatedArtifactLink =
await _context.PinterestLinks
.Where(p => p.PinterestUrl == link.PinterestUrl && p.PinterestImageUrl == link.PinterestImageUrl
&& link.Id != p.Id
&& p.ReviewResult == ReviewResult.Approved)
.FirstOrDefaultAsync();
string titleInToc = link.AltText;
if (titleInToc.IndexOfAny(new char[] { '\n', '\r' }) != -1)
{
string[] lines = titleInToc.Replace('\n', '\r').Split('\r', StringSplitOptions.RemoveEmptyEntries);
titleInToc = lines[0];
}
if (relatedArtifactLink != null)
{
link.ArtifactId = relatedArtifactLink.ArtifactId;
link.ItemId = relatedArtifactLink.ItemId;
//TODO: append tags to this existing artifact and its items
}
else
{
using (var client = new HttpClient())
{
var imageResult = await client.GetAsync(link.PinterestImageUrl);
int _ImportRetryCount = 5;
int _ImportRetryInitialSleep = 500;
int retryCount = 0;
while (retryCount < _ImportRetryCount && !imageResult.IsSuccessStatusCode && imageResult.StatusCode == HttpStatusCode.ServiceUnavailable)
{
imageResult.Dispose();
Thread.Sleep(_ImportRetryInitialSleep * (retryCount + 1));
imageResult = await client.GetAsync(link.PinterestImageUrl);
retryCount++;
}
if (imageResult.IsSuccessStatusCode)
{
using (Stream imageStream = await imageResult.Content.ReadAsStreamAsync())
{
string friendlyUrl = Guid.NewGuid().ToString();
string fileName = friendlyUrl + ".jpg";
while((await _context.PictureFiles.Where(p => p.OriginalFileName == fileName).FirstOrDefaultAsync()) != null)
{
fileName = Guid.NewGuid() + "-" + friendlyUrl + ".jpg";
}
RServiceResult<RPictureFile> picture = await _pictureFileService.Add(link.GanjoorTitle, link.AltText, 1, null, link.PinterestUrl, imageStream, fileName, "Pinterest");
if (picture.Result == null)
{
return new RServiceResult<bool>(false, $"_pictureFileService.Add : {picture.ExceptionString}");
}
RArtifactMasterRecord book = new RArtifactMasterRecord(titleInToc, titleInToc)
{
Status = PublishStatus.Published,
DateTime = DateTime.Now,
LastModified = DateTime.Now,
CoverItemIndex = 0,
FriendlyUrl = friendlyUrl
};
List<RTagValue> meta = new List<RTagValue>();
RTagValue tag = await TagHandler.PrepareAttribute(_context, "Title", titleInToc, 1);
meta.Add(tag);
tag = await TagHandler.PrepareAttribute(_context, "Description", link.AltText, 1);
meta.Add(tag);
tag = await TagHandler.PrepareAttribute(_context, "Source", link.LinkType == LinkType.Pinterest ? "Pinterest" : link.LinkType == LinkType.Instagram ? "Instagram" : link.PinterestUrl, 1);
tag.ValueSupplement = link.PinterestUrl;
meta.Add(tag);
tag = await TagHandler.PrepareAttribute(_context, "Ganjoor Link", link.GanjoorTitle, 1);
tag.ValueSupplement = link.GanjoorUrl;
meta.Add(tag);
tag = await TagHandler.PrepareAttribute(_context, "Title in TOC", titleInToc, 1);
tag.ValueSupplement = "1";//font size
meta.Add(tag);
book.Tags = meta.ToArray();
List<RArtifactItemRecord> pages = new List<RArtifactItemRecord>();
int order = 1;
RArtifactItemRecord page = new RArtifactItemRecord()
{
Name = titleInToc,
NameInEnglish = titleInToc,
Description = link.AltText,
DescriptionInEnglish = link.AltText,
Order = order,
FriendlyUrl = $"p{$"{order}".PadLeft(4, '0')}",
LastModified = DateTime.Now
};
page.Images = new RPictureFile[] { picture.Result };
page.CoverImageIndex = 0;
page.Tags = meta.ToArray();
book.CoverImage = RPictureFile.Duplicate(picture.Result);
pages.Add(page);
book.Items = pages.ToArray();
book.ItemCount = pages.Count;
await _context.Artifacts.AddAsync(book);
await _context.SaveChangesAsync();
link.ArtifactId = book.Id;
link.ItemId = (await _context.Items.Where(i => i.RArtifactMasterRecordId == link.ArtifactId).FirstOrDefaultAsync()).Id;
}
}
else
{
return new RServiceResult<bool>(false, $"Http result is not ok (url {link.PinterestImageUrl}");
}
}
}
}
_context.PinterestLinks.Update(link);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// Synchronize suggested pinterest link
/// </summary>
/// <param name="linkId"></param>
/// <returns></returns>
public async Task<RServiceResult<bool>> SynchronizeSuggestedPinterestLink(Guid linkId)
{
try
{
PinterestLink link =
await _context.PinterestLinks
.Where(l => l.Id == linkId)
.SingleOrDefaultAsync();
link.Synchronized = true;
_context.PinterestLinks.Update(link);
await _context.SaveChangesAsync();
return new RServiceResult<bool>(true);
}
catch (Exception exp)
{
return new RServiceResult<bool>(false, exp.ToString());
}
}
/// <summary>
/// Database Contetxt
/// </summary>
protected readonly RMuseumDbContext _context;
/// <summary>
/// Picture File Service
/// </summary>
protected readonly IPictureFileService _pictureFileService;
/// <summary>
/// Configuration
/// </summary>
protected IConfiguration Configuration { get; }
/// <summary>
/// Background Task Queue Instance
/// </summary>
protected readonly IBackgroundTaskQueue _backgroundTaskQueue;
/// <summary>
/// User Service
/// </summary>
protected readonly IAppUserService _userService;
/// <summary>
/// Messaging service
/// </summary>
protected readonly IRNotificationService _notificationService;
/// <summary>
/// constructor
/// </summary>
/// <param name="context"></param>
/// <param name="configuration"></param>
/// <param name="pictureFileService"></param>
/// <param name="backgroundTaskQueue"></param>
/// <param name="userService"></param>
/// <param name="notificationService"></param>
public ArtifactService(RMuseumDbContext context, IConfiguration configuration, IPictureFileService pictureFileService, IBackgroundTaskQueue backgroundTaskQueue, IAppUserService userService, IRNotificationService notificationService)
{
_context = context;
_pictureFileService = pictureFileService;
Configuration = configuration;
_backgroundTaskQueue = backgroundTaskQueue;
_userService = userService;
_notificationService = notificationService;
}
}
}
Reference in New Issue View Git Blame Copy Permalink