public IEnumerable <Interval> TransformFileWithCustomTransformer(string filename,
                                                                         IEventToIntervalTransformer <Interval> transformer)
        {
            _logger.Info("Loading events from {0} ...", filename);
            var events    = GetAllEventsFromFile(filename);
            var intervals = TransformWithCustomTransformer(events, transformer);

            return(SetUserId(intervals, filename));
        }
Exemplo n.º 2
0
        public void Setup()
        {
            _processedEvents       = new List <IDEEvent>();
            _firstVersionToInclude = 0;
            _fixer = Mock.Of <IEventFixer>();
            Mock.Get(_fixer)
            .Setup(f => f.FixAndFilter(It.IsAny <IEnumerable <IDEEvent> >()))
            .Returns <IEnumerable <IDEEvent> >(es => es);

            _testTransformer = Mock.Of <IEventToIntervalTransformer <Interval> >();
            Mock.Get(_testTransformer)
            .Setup(t => t.ProcessEvent(It.IsAny <IDEEvent>()))
            .Callback <IDEEvent>(_processedEvents.Add);
        }
        public IEnumerable <Interval> TransformWithCustomTransformer(IEnumerable <IDEEvent> events,
                                                                     IEventToIntervalTransformer <Interval> transformer)
        {
            events = _fixer.FixAndFilter(events);

            _logger.Info(@"Transforming event stream with {0} ...", transformer.GetType().Name);

            var currentEventTime = DateTimeOffset.MinValue;
            var i = 0;

            foreach (var e in events)
            {
                i++;
                if (i % 500 == 0)
                {
                    Console.Write('.');
                }
                if (i % 50000 == 0)
                {
                    Console.WriteLine();
                }

                if (TransformerUtils.EventHasNoTimeData(e))
                {
                    continue;
                }

                var version = new KaVEVersion(e.KaVEVersion);
                if (version.ReleaseNumber < _firstVersionToInclude)
                {
                    continue;
                }

                Asserts.IsLessOrEqual(currentEventTime, e.TriggeredAt.GetValueOrDefault());

                currentEventTime = e.TriggeredAt.GetValueOrDefault();

                transformer.ProcessEvent(e);
            }
            Console.WriteLine();
            _logger.Info("--> Done processing {0} events...", i);

            return(transformer.SignalEndOfEventStream());
        }
 public ZeroLengthIntervalFilterTransformer(IEventToIntervalTransformer <Interval> subTransformer)
 {
     _subTransformer = subTransformer;
 }