private async Task <IActionResult> ViewCollection(ActivityStreamFilter filter, string emptyMessage)
{
var currentUser = await GetCurrentUserAsync();
filter.viewerId = currentUser.PublicId.IsLocal ? currentUser.UserId : null;
var user = await _publicProfiles.GetUser(filter.id, currentUser?.UserId);
if (user != null)
{
var items = await _activityStreams.GetAll(filter);
if (IsActivityStreamRequest)
{
return(ActivityStream(items));
}
else
{
var lvm = ListViewModel.Regular(items);
lvm.EmptyViewModel = emptyMessage;
return(View(nameof(Index), new IndexViewModel()
{
MyProfile = currentUser,
Profile = user,
Items = lvm,
ItemNav = ProfileNav,
}));
}
}
return(NotFound());
}
public BaseActivityStreamBox(ActivityStreamFilter filter, IActivityStreamRepository ctx)
{
this.filter = filter;
this.ctx = ctx;
//Writers.Add(new ObjectStreamWriter(File.Open(PathOf(null), FileMode.Append, FileAccess.Write, FileShare.Read), _serializer, ctx));
Writers.Add(new ObjectIdStreamWriter(OpenWrite(filter.ToPath(null)), ctx));
}
public override async Task <BaseObject> Set(ActivityObject item, ActivityStreamFilter filter)
{
var box = GetBox(filter);
var ctx = new ActivityDeliveryContext {
context = this, box = box, item = item, Filter = filter
};
var ret = await OnBeforeDelivery(ctx);
if (ret == null)
{
ret = await box.Write(item);
if (ret == null)
{
throw new Exception("Box returned null");
}
else if (ret is Error err)
{
return(ret);
}
else if (ret is ActivityObject activity)
{
ctx.item = activity;
ret = await OnAfterDelivery(ctx);
}
else
{
throw new ArgumentException($"Box returned invalid type {ret.type ?? ret.GetType().FullName}");
}
}
return(ret);
}
public void CreateIndexOn(ActivityStreamFilter filter)
{
filter = this.filter.Extend(filter);
var path = filter.ToUri(null);
Writers.Add(new FilteredObjectIdStreamWriter(filter, OpenWrite(path), ctx));
Indexes.Add(filter);
}
public override async Task <BaseObject> Post(string index, ActivityObject item)
{
var publisher = item.actor?.items?.FirstOrDefault();
var filter = new ActivityStreamFilter(index)
{
id = publisher.PublicId
};
return(await Set(item, filter));
}
public async Task <CollectionObject> Get(ActivityStreamFilter filter)
{
var ret = new List <BaseObject>();
var pipe = this.ctx.GetPipe();
var ctx = new ActivityDeliveryContext
{
IsReading = true,
context = this.ctx, box = this, Filter = filter
};
var tryCount = 0;
using (var reader = await OpenReader(filter))
{
while (true)
{
var item = await reader.Read();
if (item == null)
{
if (tryCount == 0)
{
return(null);
}
break;
}
else if (item is Error err)
{
ret.Add(item);
}
else if (item is ActivityObject activity)
{
if (filter.IsMatch(activity))
{
ctx.item = activity;
var res = await pipe.Pipe(ctx) ?? ctx.item;
if (res != null)
{
ret.Add(res);
}
}
}
else
{
throw new Exception($"Invalid type {item.type}");
}
tryCount++;
}
}
if (ctx.Undos.Count > 0)
{
ret = ret.Where(r => !ctx.Undos.Contains(r.id)).ToList();
}
return(ret.ToCollection());
}
public static async Task SyncObjects(IServiceProvider s)
{
var filter = new ActivityStreamFilter("outbox")
{
sinceLastUpdated = LastTimeSyncedObjects
}.FixObjType("Actor");
using (var scope = Services.CreateScope())
{
var elastic = scope.ServiceProvider.GetRequiredService <IElasticService>();
var peerService = scope.ServiceProvider.GetRequiredService <IPeerService>();
var authService = scope.ServiceProvider.GetRequiredService <IAuthService>();
var peers = await peerService.GetPeers();
if (peers.Count > 0)
{
foreach (var peer in peers)
{
if (peer != null)
{
// await authService.GetKeyPair(peer.PublicKey)
var client = await peerService.Open(peer.Address, peer.AddressPort);
try
{
var profiles = await client.Get(filter);
if (profiles is OrderedCollectionObject orderedCollection)
{
await elastic.SyncProfiles(peer.PublicKey.Id, orderedCollection);
}
}
catch (Exception e)
{
Console.WriteLine($"Error: {e.Message}");
Console.WriteLine(e);
}
}
}
}
else
{
Console.WriteLine("No peers");
}
var locals = await scope.ServiceProvider.GetRequiredService <IActivityStreamRepository>().Get(filter);
if (locals is CollectionObject collection)
{
await elastic.SyncObjects(0, collection);
}
}
LastTimeSyncedObjects = DateTime.UtcNow;
}
public IActivityStreamBox Resolve(ActivityStreamFilter filter, IActivityStreamRepository ctx)
{
if (filter.id.Id.HasValue)
{
switch (filter.index)
{
case "notifications": // forward items from inbox to list that should be listened to based on settings
return(new ActivityStreamInbox(filter, ctx));
}
}
return(null);
}
public IActivityStreamBox Resolve(ActivityStreamFilter filter, IActivityStreamRepository ctx)
{
if (filter.id.Id.HasValue && filter.id.PeerId.HasValue)
{
switch (filter.index)
{
case "inbox":
return(new ActivityStreamInbox(filter, ctx));
case "outbox":
{
var ret = new ActivityStreamOutbox(filter, ctx);
if (filter.types == null)
{
foreach (var activityToIndexOn in new string[] { "Create", "Announce", "Like", "Dislike" })
{
ret.CreateIndexOn(new ActivityStreamFilter(filter.index)
{
types = new string[] { activityToIndexOn }
});
}
}
return(ret);
}
case "shares":
return(new ActivityStreamOutbox(filter.FixType("Share"), ctx));
case "liked":
return(new ActivityStreamOutbox(filter.FixType("Like"), ctx));
case "disliked":
return(new ActivityStreamOutbox(filter.FixType("Dislike"), ctx));
case "blocked":
return(new ActivityStreamOutbox(filter.FixType("Block"), ctx));
case "reported":
return(new ActivityStreamOutbox(filter.FixType("Report"), ctx));
case "followers":
return(new BaseActivityStreamBox(filter.FixType("Add", "Remove").FixObjType("Actor"), ctx));
case "following":
return(new BaseActivityStreamBox(filter.FixType("Add", "Remove").FixObjType("Actor"), ctx));
}
}
return(null);
}
private async Task BindSqlExtra(ActivityDeliveryContext ctx, BaseObject bindTo)
{
if (bindTo.ViewerId.HasValue)
{
var viewerId = new PublicId(bindTo?.ViewerId.Value, 0);
viewerId.Type = "Person";
var reactionsFilter = new ActivityStreamFilter("outbox")
{
id = viewerId, viewerId = bindTo?.ViewerId.Value, targetId = bindTo.PublicId,
includeReplies = false,
}.ReactionsOnly();
var reactionsBox = ctx.context.GetBox(reactionsFilter);
bindTo.Reactions = await reactionsBox.Get(reactionsFilter);
if (bindTo.Reactions.items.Count > 0)
{
var reactionTypes = bindTo.Reactions.items.Select(r => r.type).ToHashSet();
if (reactionTypes.Count > 0)
{
bindTo.HasLiked = reactionTypes.Contains(nameof(ReactionType.Like));
bindTo.HasDisliked = reactionTypes.Contains(nameof(ReactionType.Dislike));
bindTo.HasUpvoted = reactionTypes.Contains(nameof(ReactionType.Upvote));
bindTo.HasDownvoted = reactionTypes.Contains(nameof(ReactionType.Downvote));
bindTo.HasFollowed = reactionTypes.Contains(nameof(ReactionType.Follow));
bindTo.HasIgnored = reactionTypes.Contains(nameof(ReactionType.Ignore));
bindTo.HasBlocked = reactionTypes.Contains(nameof(ReactionType.Block));
bindTo.HasReported = reactionTypes.Contains(nameof(ReactionType.Report));
bindTo.HasBeenBlockedOrReportedByViewer = bindTo.HasReported || bindTo.HasBlocked;
}
}
}
var reactionsSummary = await _redis.Get <ReactionsSummaryModel>(bindTo.id);
if (reactionsSummary != null)
{
bindTo.LikeCount = reactionsSummary.LikeCount;
bindTo.DislikeCount = reactionsSummary.DislikeCount;
bindTo.UpvoteCount = reactionsSummary.UpvoteCount;
bindTo.DownvoteCount = reactionsSummary.DownvoteCount;
bindTo.FollowCount = reactionsSummary.FollowCount;
bindTo.IgnoreCount = reactionsSummary.IgnoreCount;
bindTo.BlockCount = reactionsSummary.BlockCount;
bindTo.ReportCount = reactionsSummary.ReportCount;
}
}
public async Task <BaseObject> Undo(ActivityStreamFilter filter)
{
var ret = new List <BaseObject>();
var what = await GetAll(filter);
if (what != null && (what.totalItems > 0 || what.items.Count > 0))
{
foreach (var w in what.items)
{
var undo = new Undo
{
};
ret.Add(await this.Post("outbox", undo));
}
}
else
{
// could also return not found
throw new FilterReturnedEmptyResultsException();
}
return(ret.ToCollection());
}
public IActivityStreamBox Resolve(ActivityStreamFilter filter, IActivityStreamRepository ctx)
{
switch (filter.index)
{
case "sharedInbox":
return(new ActivityStreamSharedInbox(filter, ctx));
case "sharedOutbox":
return(new ActivityStreamSharedOutbox(filter, ctx));
case "globalInbox":
return(new ActivityStreamSharedInbox(filter, ctx));
case "globalOutbox":
return(new ActivityStreamSharedOutbox(filter, ctx));
}
// if (filter.index.Contains('/'))
// {
// return new ObjectActivityStream(filter, ctx);
// }
return(null);
}
public override IActivityStreamBox GetBox(ActivityStreamFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
if (string.IsNullOrWhiteSpace(filter.index))
{
throw new ArgumentNullException(nameof(filter.index));
}
else
{
foreach (var boxProvider in _boxes)
{
var box = boxProvider.Resolve(filter, this);
if (box != null)
{
return(box);
}
}
var boxes = typeof(ActorObject).GetProperties().Where(p => p.PropertyType.IsSubclassOf(typeof(CollectionObject))).Select(p => p.Name).ToList();
throw new ArgumentOutOfRangeException($"Invalid index {filter.index} (must be one of {string.Join(", ", boxes)})");
}
}
// public Task<CollectionObject> GetInventories(ActivityStreamFilter filter)
// {
// filter.types = new string[] { "Inventory" };
// return GetAll(filter);
// }
// public Task<BaseObject> GetInventory(ActivityStreamFilter filter) => GetFirstOrError(GetInventories(filter));
//public Task<BaseObject> GetMedia(ActivityStreamFilter filter) => GetFirstOrError(GetMedias(filter));
public Task <CollectionObject> GetMedias(ActivityStreamFilter filter)
{
filter.types = new string[] { "Document" };
return(GetAll(filter));
}
public Task <List <ReactionsSummaryModel> > GetMostReported(ActivityStreamFilter filter, int?viewerId)
{
throw new NotImplementedException();
}
protected virtual Task <BaseObjectStreamReader> OpenReader(ActivityStreamFilter filter)
{
BaseObjectStreamReader ret = null;
string path = null;
foreach (var index in Indexes)
{
if (index.Contains(filter))
{
path = Localize(index.ToUri(null));
if (System.IO.File.Exists(path))
{
break;
}
else
{
path = null;
}
}
}
if (path == null)
{
path = Localize(filter.ToUri(null));
if (!System.IO.File.Exists(path))
{
path = Localize(filter.ToPath(null));
}
}
if (System.IO.File.Exists(path))
{
switch (System.IO.Path.GetExtension(path))
{
case ".index":
{
var s = System.IO.File.OpenRead(path);
if (filter.reverse)
{
ret = new ReverseObjectIdStreamReader(s, id =>
{
var p = Localize(filter.ToPath(id));
if (System.IO.File.Exists(p))
{
return(System.IO.File.OpenRead(p));
}
else
{
return(null);
}
}, _serializer);
}
else
{
ret = new ObjectIdStreamReader(s, id => System.IO.File.OpenRead(Localize(filter.ToPath(id))), _serializer);
}
}
break;
case ".json":
ret = new ObjectStreamReader(System.IO.File.OpenRead(path), _serializer);
break;
default:
throw new Exception($"Invalid activity stream type: {path}");
}
}
else
{
ret = new EmptyObjectStreamReader();
}
return(Task.FromResult(ret));
}
public FilteredObjectIdStreamWriter(ActivityStreamFilter filter, Stream stream, IActivityStreamRepository ctx) : base(stream, ctx)
{
_filter = filter ?? throw new ArgumentNullException(nameof(filter));
}
public Task <BaseObject> GetShop(ActivityStreamFilter filter) => GetFirstOrError(GetShops(filter));
public Task <CollectionObject> GetShops(ActivityStreamFilter filter)
{
filter.types = new string[] { "Organization" };
return(GetAll(filter));
}
public Task <BaseObject> GetResource(ActivityStreamFilter filter) => GetFirstOrError(GetResources(filter));
public Task <CollectionObject> GetResources(ActivityStreamFilter filter)
{
filter.types = new string[] { "Resource" };
return(GetAll(filter));
}
public Task <CollectionObject> GetReplies(ActivityStreamFilter filter)
{
throw new System.NotImplementedException();
}
public abstract IActivityStreamBox GetBox(ActivityStreamFilter filter);
public abstract Task <BaseObject> Set(ActivityObject item, ActivityStreamFilter filter);
public Task <BaseObject> Get(ActivityStreamFilter filter)
{
return(GetFirstOrError(GetAll(filter)));
}
public abstract Task <CollectionObject> GetAll(ActivityStreamFilter filter);
public Task <IActionResult> ViewBox(string id, string box)
{
id = Uri.UnescapeDataString(id);
ViewData["Controller"] = "Person";
var pid = new PublicId(id);
pid.Type = "Person";
var filter = new ActivityStreamFilter("outbox")
{
id = pid,
};
string emptyMessage = null;
if (string.IsNullOrWhiteSpace(box))
{
ViewData["Action"] = nameof(Index);
filter = new ActivityStreamFilter("outbox")
{
id = pid, includeReplies = false
}.FixType(nameof(Create));
emptyMessage = "This user has not posted anything.";
}
else
{
ViewData["Action"] = box;
switch (box.Trim().ToLower())
{
case "shares":
ViewData["Action"] = "Shares";
emptyMessage = "This user has not shared anything.";
filter.FixType(nameof(Announce));
break;
case "replies":
ViewData["Action"] = "Replies";
emptyMessage = "This user has not replied to anything.";
filter.includeReplies = true;
break;
case "notes":
ViewData["Action"] = nameof(Notes);
emptyMessage = "This user has not made any notes.";
filter.FixType(nameof(Create)).FixObjType(nameof(Note));
break;
case "articles":
ViewData["Action"] = nameof(Articles);
emptyMessage = "This user has not written any articles.";
filter.FixType(nameof(Create)).FixObjType(nameof(Article));
break;
case "photos":
ViewData["Action"] = nameof(Photos);
emptyMessage = "This user has not uploaded any photos.";
filter.FixType(nameof(Create)).FixObjType(nameof(Image));
break;
case "videos":
ViewData["Action"] = nameof(Videos);
emptyMessage = "This user has not uploaded any videos.";
filter.FixType(nameof(Create)).FixObjType(nameof(Video));
break;
case "archivedmedia":
ViewData["Action"] = nameof(ArchivedMedia);
emptyMessage = "This user has not uploaded any media.";
filter.FixType(nameof(Create)).FixObjType(nameof(Document));
break;
// case "mentions":
// ViewData["Action"] = nameof(Mentions);
// emptyMessage = "This user has not been mentioned.";
// filter = new ActivityStreamFilter("outbox")
// {
// id = pid,
// }.FixType(nameof(Mention));
// break;
case "shops":
ViewData["Action"] = nameof(Shops);
emptyMessage = "This user has no shops.";
filter.FixObjType(nameof(Organization));
break;
case "following":
ViewData["Action"] = nameof(Following);
emptyMessage = "This user is not following anyone.";
filter = new ActivityStreamFilter("following")
{
id = pid,
}.FixObjType(nameof(Person));
break;
case "followers":
ViewData["Action"] = nameof(Followers);
emptyMessage = "This user has no followers.";
filter = new ActivityStreamFilter("followers")
{
id = pid,
}.FixObjType(nameof(Person));
break;
case "likes":
ViewData["Action"] = nameof(Likes);
emptyMessage = "This user has no likes.";
filter.FixType(nameof(Like));
break;
case "dislikes":
ViewData["Action"] = nameof(Dislikes);
emptyMessage = "This user has no dislikes.";
filter.FixType(nameof(Dislike));
break;
case "upvotes":
ViewData["Action"] = nameof(Upvotes);
emptyMessage = "This user has no upvotes.";
filter.FixType(nameof(Upvote));
break;
case "downvotes":
ViewData["Action"] = nameof(Downvotes);
emptyMessage = "This user has no downvotes.";
filter.FixType(nameof(Downvote));
break;
case "ignored":
ViewData["Action"] = nameof(Ignored);
emptyMessage = "This user has not ignored anything or anyone.";
filter.FixType(nameof(Ignore));
break;
case "blocked":
ViewData["Action"] = nameof(Blocked);
emptyMessage = "This user has not blocked anything or anyone.";
filter.FixType(nameof(Block));
break;
case "reported":
ViewData["Action"] = nameof(Reported);
emptyMessage = "This user has not reported anything or anyone.";
filter.FixType(nameof(Report));
break;
case "activity":
ViewData["Action"] = nameof(Activity);
emptyMessage = "This user has no activity.";
filter.FixType(nameof(Like), nameof(Dislike), nameof(Upvote), nameof(Downvote), nameof(Block), nameof(Report));
break;
}
}
return(ViewCollection(filter, emptyMessage));
}
public Task <CollectionObject> GetPeers(ActivityStreamFilter filter)
{
filter.types = new string[] { "Peer" };
return(GetAll(filter));
}
public ActivityStreamInbox(ActivityStreamFilter filter, IActivityStreamRepository ctx) : base(filter, ctx)
{
}
//public Task<BaseObject> GetPost(ActivityStreamFilter filter) => GetFirstOrError(GetPosts(filter));
public Task <CollectionObject> GetPosts(ActivityStreamFilter filter)
{
//filter.objectTypes = new string[] { "Note", "Article", "Document" };
return(GetAll(filter));
}
