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)); }