libraries/eventsourcing/src/main/java/org/apache/zest/library/eventsourcing/application/source/helper/ApplicationEvents.java

/*
 * Copyright 2009-2010 Rickard Öberg AB
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.zest.library.eventsourcing.application.source.helper;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.zest.api.util.Methods;
import org.apache.zest.functional.Function;
import org.apache.zest.functional.Iterables;
import org.apache.zest.functional.Specification;
import org.apache.zest.io.Output;
import org.apache.zest.io.Receiver;
import org.apache.zest.io.Sender;
import org.apache.zest.library.eventsourcing.application.api.ApplicationEvent;
import org.apache.zest.library.eventsourcing.application.api.TransactionApplicationEvents;
import org.apache.zest.library.eventsourcing.application.replay.ApplicationEventPlayer;
import org.apache.zest.library.eventsourcing.application.replay.ApplicationEventReplayException;

/**
 * Helper methods for working with Iterables of DomainEvents and UnitOfWorkDomainEventsValue.
 */
public class ApplicationEvents
{
    public static Iterable<ApplicationEvent> events( Iterable<TransactionApplicationEvents> transactions )
    {
        List<Iterable<ApplicationEvent>> events = new ArrayList<Iterable<ApplicationEvent>>();
        for (TransactionApplicationEvents transactionDomain : transactions)
        {
            events.add( transactionDomain.events().get() );
        }

        Iterable<ApplicationEvent>[] iterables = (Iterable<ApplicationEvent>[]) new Iterable[events.size()];
        return Iterables.flatten( events.<Iterable<ApplicationEvent>>toArray( iterables ) );
    }

    public static Iterable<ApplicationEvent> events( TransactionApplicationEvents... transactionDomains )
    {
        List<Iterable<ApplicationEvent>> events = new ArrayList<Iterable<ApplicationEvent>>();
        for (TransactionApplicationEvents transactionDomain : transactionDomains)
        {
            events.add( transactionDomain.events().get() );
        }

        Iterable<ApplicationEvent>[] iterables = (Iterable<ApplicationEvent>[]) new Iterable[events.size()];
        return Iterables.flatten( events.<Iterable<ApplicationEvent>>toArray( iterables ) );
    }

    public static boolean matches( Specification<ApplicationEvent> specification, Iterable<TransactionApplicationEvents> transactions )
    {
        return Iterables.filter( specification, events( transactions ) ).iterator().hasNext();
    }

    // Common specifications

    public static Specification<ApplicationEvent> withNames( final Iterable<String> names )
    {
        return new Specification<ApplicationEvent>()
        {
            @Override
            public boolean satisfiedBy( ApplicationEvent event )
            {
                for (String name : names)
                {
                    if (event.name().get().equals( name ))
                        return true;
                }
                return false;
            }
        };
    }

    public static Specification<ApplicationEvent> withNames( final String... names )
    {
        return new Specification<ApplicationEvent>()
        {
            @Override
            public boolean satisfiedBy( ApplicationEvent event )
            {
                for (String name : names)
                {
                    if (event.name().get().equals( name ))
                        return true;
                }
                return false;
            }
        };
    }

    public static Specification<ApplicationEvent> withNames( final Class eventClass )
    {
        return ApplicationEvents.withNames( Iterables.map( new Function<Method, String>()
        {
            @Override
            public String map( Method method )
            {
                return method.getName();
            }
        }, Iterables.toList( Methods.METHODS_OF.map( eventClass ) ) ));
    }

    public static Specification<ApplicationEvent> afterDate( final Date afterDate )
    {
        return new Specification<ApplicationEvent>()
        {
            @Override
            public boolean satisfiedBy( ApplicationEvent event )
            {
                return event.on().get().after( afterDate );
            }
        };
    }

    public static Specification<ApplicationEvent> beforeDate( final Date beforeDate )
    {
        return new Specification<ApplicationEvent>()
        {
            @Override
            public boolean satisfiedBy( ApplicationEvent event )
            {
                return event.on().get().before( beforeDate );
            }
        };
    }

    public static Specification<ApplicationEvent> withUsecases( final String... names )
    {
        return new Specification<ApplicationEvent>()
        {
            @Override
            public boolean satisfiedBy( ApplicationEvent event )
            {
                for (String name : names)
                {
                    if (event.usecase().get().equals( name ))
                        return true;
                }
                return false;
            }
        };
    }

    public static Specification<ApplicationEvent> paramIs( final String name, final String value )
    {
        return new Specification<ApplicationEvent>()
        {
            @Override
            public boolean satisfiedBy( ApplicationEvent event )
            {
                return ApplicationEventParameters.getParameter( event, name ).equals( value );
            }
        };
    }

    public static Output<TransactionApplicationEvents, ApplicationEventReplayException> playEvents( final ApplicationEventPlayer player, final Object eventHandler )
    {
        final Specification<ApplicationEvent> specification = ApplicationEvents.withNames( eventHandler.getClass() );

        return new Output<TransactionApplicationEvents, ApplicationEventReplayException>()
        {
           @Override
           public <SenderThrowableType extends Throwable> void receiveFrom(Sender<? extends TransactionApplicationEvents, SenderThrowableType> sender) throws ApplicationEventReplayException, SenderThrowableType
           {
                sender.sendTo( new Receiver<TransactionApplicationEvents, ApplicationEventReplayException>()
                {
                    @Override
                    public void receive( TransactionApplicationEvents item ) throws ApplicationEventReplayException
                    {
                        for (ApplicationEvent applicationEvent : events( item ))
                        {
                            if (specification.satisfiedBy( applicationEvent ))
                                player.playEvent( applicationEvent, eventHandler );
                        }
                    }
                } );
            }
        };
    }
}