/**
 * Resolve the object against the application context.
 */
@Override
protected Object getResourcetoInject(Object target,String requestingBeanName) {
    // Resolves to EntityManagerFactory or EntityManager.
    if (this.type != null) {
        return (this.type == PersistenceContextType.EXTENDED ?
                resolveExtendedEntityManager(target,requestingBeanName) :
                resolveEntityManager(requestingBeanName));
    }
    else {
        // OK,so we need an EntityManagerFactory...
        return resolveEntityManagerFactory(requestingBeanName);
    }
}

public EntityManager createEntityManager(Map map) {
    //Todo support discardOnClose,persistencecontexttype?,interceptor,return new EntityManagerImpl(
            this,PersistenceContextType.EXTENDED,transactionType,discardOnClose,sessionInterceptorClass,map
    );
}

/**
 * Resolve the object against the application context.
 */
@Override
protected Object getResourcetoInject(Object target,so we need an EntityManagerFactory...
        return resolveEntityManagerFactory(requestingBeanName);
    }
}

@PersistenceContext(type = PersistenceContextType.EXTENDED)
public void setEntityManager(EntityManager em) {
    if (this.em != null) {
        throw new IllegalStateException("Already called");
    }
    this.em = em;
}

private EntityManager getEntityManager(final ExecutionContext context,final EntityManagerFactory emf) {
    EntityManager em = null;
    if (getPersistenceContextType(context) == PersistenceContextType.EXTENDED) {
        // EntityManager may be already open. If so use it.
        em = (EntityManager) context.getData(Constants.KEY_ENTITY_MANAGER);
    }

    if (em == null) {
        // create EntityManager and inject it
        em = emf.createEntityManager();
    }
    return em;
}

@Override
public void afterTest(final TestInvocation invocation) throws Exception {
    final ExecutionContext context = invocation.getContext();

    final EntityManager em = (EntityManager) context.getData(Constants.KEY_ENTITY_MANAGER);
    if (em != null && getPersistenceContextType(context) != PersistenceContextType.EXTENDED) {
        context.storeData(Constants.KEY_ENTITY_MANAGER,null);
        em.close();
    }
}

@Bean @PersistenceContext(type = PersistenceContextType.EXTENDED)
public SessionFactory sessionFactory() {
    LocalSessionFactoryBuilder builder = new LocalSessionFactoryBuilder(dataSource());
    builder.scanPackages("org.proflr.server.entity").addProperties(getHibernateProperties());

    return builder.buildSessionFactory();
}

/**
 * Resolve the object against the application context.
 */
@Override
protected Object getResourcetoInject(Object target,so we need an EntityManagerFactory...
        return resolveEntityManagerFactory(requestingBeanName);
    }
}

@PersistenceContext(type = PersistenceContextType.EXTENDED)
public void setEntityManager(EntityManager em) {
    if (this.em != null) {
        throw new IllegalStateException("Already called");
    }
    this.em = em;
}

private InjectionPoint persistenceContext(String unitName) {
    final InjectionPoint ip = mock(InjectionPoint.class);
    final Annotated annotated = mock(Annotated.class);
    when(ip.getAnnotated()).thenReturn(annotated);
    final PersistenceContext annotation = new PersistenceContext() {
        @Override
        public Class<? extends Annotation> annotationType() {
            return null;
        }

        @Override
        public String name() {
            return null;
        }

        @Override
        public String unitName() {
            return unitName;
        }

        @Override
        public PersistenceContextType type() {
            return null;
        }

        @Override
        public SynchronizationType synchronization() {
            return null;
        }

        @Override
        public PersistenceProperty[] properties() {
            return new PersistenceProperty[0];
        }
    };
    when(annotated.getAnnotation(PersistenceContext.class)).thenReturn(annotation);
    return ip;
}

@Override
@PersistenceContext(unitName="unit2",type = PersistenceContextType.EXTENDED)
public void setEntityManager(EntityManager em) {
    super.setEntityManager(em);
}

private PersistenceContextType getPersistenceContextType(final ExecutionContext context) {
    final Field field = context.getPersistenceField();
    final PersistenceContext pc = field.getAnnotation(PersistenceContext.class);
    return pc.type();
}

@Override
public PersistenceContextType type()
{
    return PersistenceContextType.TRANSACTION;
}

public EntityManagerImpl(EntityManagerFactoryImpl entityManagerFactory,PersistenceContextType pcType,SynchronizationType synchronizationType,PersistenceUnitTransactionType transactionType,boolean discardOnClose,Class sessionInterceptorClass,Map properties) {
    super(entityManagerFactory,pcType,synchronizationType,properties);
}

@Override
@PersistenceContext(unitName="unit2",type = PersistenceContextType.EXTENDED)
public void setEntityManager(EntityManager em) {
    super.setEntityManager(em);
}

@PersistenceContext(name = "method",unitName = "mu",type = PersistenceContextType.EXTENDED,properties = {
    @PersistenceProperty(name = "method1",value = "m1"),@PersistenceProperty(name = "method2",value = "m2")
})
public void method() {
}

@PersistenceContext(unitName = "mymu",properties = {
    @PersistenceProperty(name = "myMethod1",value = "mym1"),@PersistenceProperty(name = "myMethod2",value = "mym2")
})
public void setMyMethod() {
}