| /** |
| * |
| * 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.qi4j.library.eventsourcing.domain.replay; |
| |
| import java.lang.reflect.Method; |
| import java.text.ParseException; |
| import java.text.SimpleDateFormat; |
| import java.util.Date; |
| import org.json.JSONObject; |
| import org.json.JSONTokener; |
| import org.qi4j.api.entity.EntityComposite; |
| import org.qi4j.api.injection.scope.Structure; |
| import org.qi4j.api.mixin.Mixins; |
| import org.qi4j.api.service.ServiceComposite; |
| import org.qi4j.api.structure.Module; |
| import org.qi4j.api.unitofwork.NoSuchEntityException; |
| import org.qi4j.api.unitofwork.UnitOfWork; |
| import org.qi4j.api.unitofwork.UnitOfWorkFactory; |
| import org.qi4j.api.usecase.UsecaseBuilder; |
| import org.qi4j.api.value.ValueComposite; |
| import org.qi4j.library.eventsourcing.domain.api.DomainEventValue; |
| import org.qi4j.library.eventsourcing.domain.api.UnitOfWorkDomainEventsValue; |
| import org.qi4j.spi.Qi4jSPI; |
| import org.qi4j.spi.entity.EntityState; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * DomainEventValue player |
| */ |
| @Mixins(DomainEventPlayerService.Mixin.class) |
| public interface DomainEventPlayerService |
| extends DomainEventPlayer, ServiceComposite |
| { |
| class Mixin |
| implements DomainEventPlayer |
| { |
| final Logger logger = LoggerFactory.getLogger( DomainEventPlayer.class ); |
| |
| @Structure |
| UnitOfWorkFactory uowf; |
| |
| @Structure |
| Module module; |
| |
| @Structure |
| Qi4jSPI spi; |
| |
| SimpleDateFormat dateFormat = new SimpleDateFormat( "EEE MMM dd HH:mm:ss zzz yyyy" ); |
| |
| @Override |
| public void playTransaction( UnitOfWorkDomainEventsValue unitOfWorkDomainValue ) |
| throws EventReplayException |
| { |
| UnitOfWork uow = uowf.newUnitOfWork( UsecaseBuilder.newUsecase( "Event replay" ) ); |
| DomainEventValue currentEventValue = null; |
| try |
| { |
| for (DomainEventValue domainEventValue : unitOfWorkDomainValue.events().get()) |
| { |
| currentEventValue = domainEventValue; |
| // Get the entity |
| Class entityType = module.classLoader().loadClass( domainEventValue.entityType().get() ); |
| String id = domainEventValue.entityId().get(); |
| Object entity = null; |
| try |
| { |
| entity = uow.get( entityType, id ); |
| } catch( NoSuchEntityException e ) |
| { |
| // Event to play for an entity that doesn't yet exist - create a default instance |
| entity = uow.newEntity( entityType, id ); |
| } |
| |
| // check if the event has already occured |
| EntityState state = spi.entityStateOf( (EntityComposite) entity ); |
| if (state.lastModified() > unitOfWorkDomainValue.timestamp().get()) |
| { |
| break; // don't rerun event in this unitOfWorkDomainValue |
| } |
| |
| playEvent( domainEventValue, entity ); |
| } |
| uow.complete(); |
| } catch (Exception e) |
| { |
| uow.discard(); |
| if (e instanceof EventReplayException) |
| throw ((EventReplayException) e); |
| else |
| throw new EventReplayException( currentEventValue, e ); |
| } |
| } |
| |
| @Override |
| public void playEvent( DomainEventValue domainEventValue, Object object ) |
| throws EventReplayException |
| { |
| UnitOfWork uow = uowf.currentUnitOfWork(); |
| Class entityType = object.getClass(); |
| |
| // Get method |
| Method eventMethod = getEventMethod( entityType, domainEventValue.name().get() ); |
| |
| if (eventMethod == null) |
| { |
| logger.warn( "Could not find event method " + domainEventValue.name().get() + " in entity of type " + entityType.getName() ); |
| return; |
| } |
| |
| // Build parameters |
| try |
| { |
| String jsonParameters = domainEventValue.parameters().get(); |
| JSONObject parameters = (JSONObject) new JSONTokener( jsonParameters ).nextValue(); |
| Object[] args = new Object[eventMethod.getParameterTypes().length]; |
| for (int i = 1; i < eventMethod.getParameterTypes().length; i++) |
| { |
| Class<?> parameterType = eventMethod.getParameterTypes()[i]; |
| |
| String paramName = "param" + i; |
| |
| Object value = parameters.get( paramName ); |
| |
| args[i] = getParameterArgument( parameterType, value, uow ); |
| } |
| |
| args[0] = domainEventValue; |
| |
| // Invoke method |
| logger.debug( "Replay:" + domainEventValue + " on:" + object ); |
| |
| eventMethod.invoke( object, args ); |
| } catch (Exception e) |
| { |
| throw new EventReplayException( domainEventValue, e ); |
| } |
| } |
| |
| private Object getParameterArgument( Class<?> parameterType, Object value, UnitOfWork uow ) throws ParseException |
| { |
| if (value.equals( JSONObject.NULL )) |
| return null; |
| |
| if (parameterType.equals( String.class )) |
| { |
| return (String) value; |
| } else if (parameterType.equals( Boolean.class ) || parameterType.equals( Boolean.TYPE )) |
| { |
| return (Boolean) value; |
| } else if (parameterType.equals( Long.class ) || parameterType.equals( Long.TYPE )) |
| { |
| return ((Number) value).longValue(); |
| } else if (parameterType.equals( Integer.class ) || parameterType.equals( Integer.TYPE )) |
| { |
| return ((Number) value).intValue(); |
| } else if (parameterType.equals( Date.class )) |
| { |
| return dateFormat.parse( (String) value ); |
| } else if (ValueComposite.class.isAssignableFrom( parameterType )) |
| { |
| return module.newValueFromSerializedState( parameterType, (String) value ); |
| } else if (parameterType.isInterface()) |
| { |
| return uow.get( parameterType, (String) value ); |
| } else if (parameterType.isEnum()) |
| { |
| return Enum.valueOf( (Class<? extends Enum>) parameterType, value.toString() ); |
| } else |
| { |
| throw new IllegalArgumentException( "Unknown parameter type:" + parameterType.getName() ); |
| } |
| } |
| |
| private Method getEventMethod( Class<?> aClass, String eventName ) |
| { |
| for (Method method : aClass.getMethods()) |
| { |
| if (method.getName().equals( eventName )) |
| { |
| Class[] parameterTypes = method.getParameterTypes(); |
| if (parameterTypes.length > 0 && parameterTypes[0].equals( DomainEventValue.class )) |
| return method; |
| } |
| } |
| return null; |
| } |
| } |
| } |