public void Feed(IEvent @event, EventOrigin origin)
            {
                var indexId = new EventStoreIndexEventTypeId(@event.GetType().GetContractId());
                var commit  = new ProjectionCommit(indexId, indexVersion, @event, 1, origin, DateTime.FromFileTimeUtc(origin.Timestamp));

                store.Save(commit);
            }
        public void Save(Type projectionType, CronusMessage cronusMessage)
        {
            var projection = FastActivator.CreateInstance(projectionType) as IProjectionDefinition;

            if (projection != null)
            {
                var    projectionIds = projection.GetProjectionIds(cronusMessage.Payload as IEvent);
                string contractId    = projectionType.GetContractId();

                foreach (var projectionId in projectionIds)
                {
                    foreach (var version in GetProjectionVersions(contractId))
                    {
                        ISnapshot        snapshot         = snapshotStore.Load(contractId, projectionId, version);
                        ProjectionStream projectionStream = LoadProjectionStream(projectionType, version, projectionId, snapshot);
                        int snapshotMarker = snapshotStrategy.GetSnapshotMarker(projectionStream.Commits, snapshot.Revision);

                        EventOrigin eventOrigin = cronusMessage.GetEventOrigin();
                        DateTime    timestamp   = DateTime.UtcNow;
                        IEvent      @event      = cronusMessage.Payload as IEvent;

                        var commit = new ProjectionCommit(projectionId, version, @event, snapshotMarker, eventOrigin, timestamp);
                        projectionStore.Save(commit);
                    }
                }
            }
        }
        public void Save(Type projectionType, IEvent @event, EventOrigin eventOrigin)
        {
            string contractId = projectionType.GetContractId();
            var    instance   = FastActivator.CreateInstance(projectionType);

            var statefullProjection = instance as IProjectionDefinition;

            if (statefullProjection != null)
            {
                var projectionIds = statefullProjection.GetProjectionIds(@event);

                foreach (var version in GetProjectionVersions(contractId))
                {
                    foreach (var projectionId in projectionIds)
                    {
                        ISnapshot        snapshot         = snapshotStore.Load(contractId, projectionId, version);
                        ProjectionStream projectionStream = LoadProjectionStream(projectionType, version, projectionId, snapshot);
                        int snapshotMarker = snapshotStrategy.GetSnapshotMarker(projectionStream.Commits, snapshot.Revision);

                        var commit = new ProjectionCommit(projectionId, version, @event, snapshotMarker, eventOrigin, DateTime.UtcNow);
                        projectionStore.Save(commit);
                    }
                }
            }
        }
        public void Rebuild(Type projectionType, ProjectionVersion version)
        {
            projectionStore.InitializeProjectionStore(version);

            IEnumerable <IEventStorePlayer> eventStorePlayers = eventStoreFactory.GetEventStorePlayers();

            foreach (var eventStorePlayer in eventStorePlayers)
            {
                foreach (var aggregateCommit in eventStorePlayer.LoadAggregateCommits())
                {
                    foreach (var @event in aggregateCommit.Events)
                    {
                        try
                        {
                            var unwrapedEvent = @event.Unwrap();
                            var rootId        = System.Text.Encoding.UTF8.GetString(aggregateCommit.AggregateRootId);
                            var eventOrigin   = new EventOrigin(rootId, aggregateCommit.Revision, aggregateCommit.Events.IndexOf(@event), aggregateCommit.Timestamp);

                            projectionRepository.Save(projectionType, @event, eventOrigin);
                        }
                        catch (Exception ex)
                        {
                            log.ErrorException(ex.Message, ex);
                        }
                    }
                }
            }
        }
Exemple #5
0
 public SMEvent(IElement element, string content, EventOrigin eventOrigin)
 {
     this.element       = element;
     this.content       = content;
     this.ChildrenCount = element.ChildrenCount;
     this.eventOrigin   = eventOrigin;
 }
        public void Save <T>(string id, T state)
        {
            var origin  = new EventOrigin("StupidProjectionStore", 1, 1, 1);
            var version = new ProjectionVersion(state.GetType().GetContractId(), ProjectionStatus.Live, 1, "1");
            var commit  = new ProjectionCommit(new StupidId(id), version, new StupidEvent(state), 1, origin, DateTime.UtcNow);

            store.Save(commit);
        }
        private SuperMemoEvent CreateSuperMemoEvent(EventOrigin Origin, bool IncludeContent)
        {
            var    el      = Svc.SM.UI.ElementWdw.CurrentElement;
            string Content = string.Empty;

            if ((DateTime.Now - LastUpdatedContent).TotalSeconds > 1 || IncludeContent)
            {
                Content = ContentFuncs.GetCurrentElContent();
            }
            return(new SuperMemoEvent(el.Id, Origin, Content));
        }
Exemple #8
0
        public static DiscordEmbedBuilder FormEmbedBuilder(EventOrigin origin, string title, string desc = null)
        {
            var emb = new DiscordEmbedBuilder()
            {
                Title = title
            };

            if (desc != null)
            {
                emb.WithDescription(desc);
            }

            switch (origin)
            {
            case EventOrigin.Channel:
                emb.WithColor(DiscordColor.Turquoise);
                break;

            case EventOrigin.Emoji:
                emb.WithColor(DiscordColor.Orange);
                break;

            case EventOrigin.Guild:
                emb.WithColor(DiscordColor.DarkGreen);
                break;

            case EventOrigin.KickOrBan:
                emb.WithColor(DiscordColor.Red);
                break;

            case EventOrigin.Linkfilter:
                emb.WithColor(DiscordColor.DarkRed);
                break;

            case EventOrigin.Member:
                emb.WithColor(DiscordColor.Sienna);
                break;

            case EventOrigin.Message:
                emb.WithColor(DiscordColor.Azure);
                break;

            case EventOrigin.Role:
                emb.WithColor(DiscordColor.Lilac);
                break;

            default:
                break;
            }

            return(emb);
        }