Page Comparison

public interface IPortletTypeDao {
    /**
     * RemovesCreates, theinitializes specified {@link IPortletType} from the persistent store.
     * 
     * @param type The type to remove.
     * @throws IllegalArgumentException if type is null.
     */
    public void deletePortletType(IPortletType type);
   and persists a new {@link IPortletType} based on the specified parameters
     * 
     * @param name The name of the channel type
     /** @param cpdUri The URI to the *CPD Getfile aused {@linkwhen IPortletType}publishing forchannels theof specifiedthis id.type
     * 
     * @param@return idA Thenewly idcreated, toinitialized getand thepersisted type for.{@link IPortletType}
     * @return The channel type@throws org.springframework.dao.DataIntegrityViolationException If a IChannelType already exists for the id, null if no type exists for the id.provide arguments
     * @throws IllegalArgumentException If any of the parameters are null
     */
    public IPortletType getPortletType(int idcreatePortletType(String name, String cpdUri);
    
    /**
     * GetPersists changes to a {@link IPortletType}.
for the specified name      * 
     * @param name The name to get the type for.
     * @return The channel type for the name, null if no type exists forto store the fname.changes for
     * @throws IllegalArgumentException if nametype is null.
     */
    public IPortletType getPortletTypeupdatePortletType(StringIPortletType nametype);
    
    /**
     * Removes the specified {@link IPortletType} from the persistent store.
     * 
     * @param type The type to remove.
  * @return A {@link* List}@throws ofIllegalArgumentException allif persistedtype {@link IPortletType}sis null.
     */
    public List<IPortletType>void getPortletTypesdeletePortletType(IPortletType type);
 } 

@Repository
public class JpaPortletTypeDao extends BasePortalJpaDao implements IPortletTypeDao {
    private CriteriaQuery<PortletTypeImpl> findAllTypesQuery;
    @Override
    public void afterPropertiesSet() throws Exception {
        this.findAllTypesQuery = this.createCriteriaQuery(new Function<CriteriaBuilder, CriteriaQuery<PortletTypeImpl>>() {
            @Override
            public CriteriaQuery<PortletTypeImpl> apply(CriteriaBuilder cb) {
                final CriteriaQuery<PortletTypeImpl> criteriaQuery = cb.createQuery(PortletTypeImpl.class);
                criteriaQuery.from(PortletTypeImpl.class);
                return criteriaQuery;
            }
        });
    }
    
    
    @Override
    @PortalTransactional
    public void deletePortletType(IPortletType type) {
        Validate.notNull(type, "definition can not be null");
        
        final IPortletType persistentChanneltype;
        final EntityManager entityManager = this.getEntityManager();
        if (entityManager.contains(type)) {
            persistentChanneltype = type;
        }
        else {
            persistentChanneltype = entityManager.merge(type);
        }
        entityManager.remove(persistentChanneltype);
    }
    @Override
    @PortalTransactional
    public IPortletType createPortletType(String name, String cpdUri) {
        Validate.notEmpty(name, "name can not be null");
        Validate.notEmpty(cpdUri, "cpdUri can not be null");
        
        final PortletTypeImpl channelType = new PortletTypeImpl(name, cpdUri);
        
        this.getEntityManager().persist(channelType);
        
        return channelType;
    }
    @Override
    public IPortletType getPortletType(int id) {
        return this.getEntityManager().find(PortletTypeImpl.class, id);
    }
    @OpenEntityManager(unitName = PERSISTENCE_UNIT_NAME)
    @Override
    public IPortletType getPortletType(String name) {
        final NaturalIdQuery<PortletTypeImpl> query = this.createNaturalIdQuery(PortletTypeImpl.class);
        query.using(PortletTypeImpl_.name, name);
        return query.load();
    }
    @Override
    public List<IPortletType> getPortletTypes() {
        final TypedQuery<PortletTypeImpl> query = this.createCachedQuery(this.findAllTypesQuery);
        final List<PortletTypeImpl> portletTypes = query.getResultList();
        return new ArrayList<IPortletType>(portletTypes);
    }
    @Override
    @PortalTransactional
    public IPortletType updatePortletType(IPortletType type) {
        Validate.notNull(type, "type can not be null");
        
        this.getEntityManager().persist(type);
        
        return type;
    }
}