java类javax.persistence.Query的实例源码

public static List<Object> countNbCardsByRejets(String userType, Date date) {
    EntityManager em = Card.entityManager();
    String sql = "SELECT nb_rejets, count(*) FROM card WHERE request_date>=:date GROUP BY nb_rejets";
    if (!userType.isEmpty()) {
        sql = "SELECT nb_rejets, count(*) FROM card, user_account WHERE card.user_account= user_account.id " + "AND request_date>=:date  AND user_type = :userType GROUP BY nb_rejets";
    }
    Query q = em.createNativeQuery(sql);
    q.setParameter("date", date);
    if (!userType.isEmpty()) {
        q.setParameter("userType", userType);
    }
    return q.getResultList();
}

@Before
public void setup() throws Exception {
    query = mock(Query.class);
    service = spy(new PartnerServiceBean());
    service.localizer = mock(LocalizerServiceLocal.class);
    sps = mock(ServiceProvisioningServiceBean.class);
    service.sps = sps;
    service.spsLocal = mock(ServiceProvisioningServiceLocal.class);
    service.ds = mock(DataService.class);
    doReturn(query).when(service.ds).createNamedQuery(
            "Product.getSpecificCustomerProduct");
    service.spsLocalizer = mock(ServiceProvisioningServiceLocalizationLocal.class);
    service.sessionCtx = mock(SessionContext.class);
    service.slService = mock(SubscriptionListServiceLocal.class);
    when(service.ds.getCurrentUser()).thenReturn(new PlatformUser());
    product = new Product();
    product.setStatus(ServiceStatus.INACTIVE);
    doReturn(product).when(service.ds).getReference(eq(Product.class),
            anyLong());

    PlatformUser u = new PlatformUser();
    u.setLocale("locale");
    doReturn(u).when(service.ds).getCurrentUser();
    doReturn(Boolean.FALSE).when(service.slService)
            .isUsableSubscriptionExistForTemplate(any(PlatformUser.class),
                    eq(Subscription.ASSIGNABLE_SUBSCRIPTION_STATUS),
                    any(Product.class));
}

/**
 * retrieves the list of user emails registered.
 * 
 * @return users the list of user emails
 * 
 */
public static List<String> listUsers() {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("userData");
    EntityManager em = emf.createEntityManager();
    Query query = em.createQuery("SELECT username FROM User");
    @SuppressWarnings("unchecked")
    List<String> users = query.getResultList();
    em.close();
    return users;
}

@Override
public JpaWebServerConfigTemplate getWebServerResource(final String resourceName, final String webServerName) {
    final Query q = em.createNamedQuery(JpaWebServerConfigTemplate.QUERY_GET_WEBSERVER_RESOURCE);
    q.setParameter(JpaWebServerConfigTemplate.QUERY_PARAM_TEMPLATE_NAME, resourceName);
    q.setParameter(JpaWebServerConfigTemplate.QUERY_PARAM_WEBSERVER_NAME, webServerName);
    return (JpaWebServerConfigTemplate) q.getSingleResult();
}

/**
 * Verifies if the specified service was already scheduled and is still
 * pending to be activated or de-activated. Throws an
 * <code>IllegalArgumentException</code> if the specified service is
 * <code>null</code> or its key is smaller than or equals <code>0</code>.
 * 
 * @param service
 *            The service to be checked.
 * @return <code>true</code> if the service was already scheduled and
 *         pending, otherwise <code>false</code>.
 */
public boolean isActivateOrDeactivateServicePending(VOService service) {
    ArgumentValidator.notNull("service", service);
    TriggerProcessIdentifiers.validateObjectKey(service);
    Query query = ds
            .createNamedQuery("TriggerProcessIdentifier.isActivateDeactivateServicePending");
    query.setParameter("pendingStates",
            TriggerProcess.getUnfinishedStatus());
    query.setParameter("triggerTypes", Arrays.asList(
            TriggerType.ACTIVATE_SERVICE, TriggerType.DEACTIVATE_SERVICE));
    query.setParameter("serviceKeyName",
            TriggerProcessIdentifierName.SERVICE_KEY);
    query.setParameter("serviceKey", String.valueOf(service.getKey()));
    return ((Long) query.getSingleResult()).longValue() > 0;
}

private void setMarketplaceReferencesOfSubscriptionsToNull(Marketplace mp) {
    Query query = dm.createNamedQuery("Subscription.getForMarketplace");
    query.setParameter("marketplace", mp);
    List<Subscription> subscriptions = ParameterizedTypes
            .list(query.getResultList(), Subscription.class);
    if (subscriptions != null && !subscriptions.isEmpty()) {
        for (Subscription subscription : subscriptions) {
            subscription.setMarketplace(null);
        }
    }
}

@Override
@TransactionAttribute(TransactionAttributeType.MANDATORY)
public List<Marketplace> getAllAccessibleMarketplacesForOrganization(
        long organizationKey) {

    Query query = ds.createNamedQuery("Marketplace.getAllAccessible");
    query.setParameter("organization_tkey", organizationKey);
    List<Marketplace> marketplaceList = ParameterizedTypes
            .list(query.getResultList(), Marketplace.class);

    return marketplaceList;
}

/**
 * Helper method for event reading.
 * 
 * @param actor
 *            User saving event.
 * @param occurrenceTime
 *            Occurance time.
 * @param subKey
 *            Key of subscription.
 * @param eventType
 *            The type of the event to read
 * @return Event.
 * @throws Exception
 */
private GatheredEvent readEvent(final String actor,
        final long occurrenceTime, final long subKey,
        final EventType eventType) throws Exception {
    GatheredEvent eventLocal = runTX(new Callable<GatheredEvent>() {
        @Override
        public GatheredEvent call() throws Exception {
            long key = -1;
            Query query = mgr.createQuery(
                    "select c from GatheredEvent c where c.dataContainer.actor=:actor and "
                            + "c.dataContainer.occurrenceTime=:occurrencetime and "
                            + "c.dataContainer.subscriptionTKey=:subscriptionTKey and "
                            + "c.dataContainer.type=:type");
            query.setParameter("actor", actor);
            query.setParameter("occurrencetime",
                    Long.valueOf(occurrenceTime));
            query.setParameter("subscriptionTKey", Long.valueOf(subKey));
            query.setParameter("type", eventType);
            Iterator<GatheredEvent> gatheredEventIterator = ParameterizedTypes
                    .iterator(query.getResultList(), GatheredEvent.class);
            if (gatheredEventIterator.hasNext()) {
                key = gatheredEventIterator.next().getKey();
            }
            return mgr.find(GatheredEvent.class, key);
        }
    });
    return eventLocal;
}

public void addAccessibleServices(String unitId,
        List<String> accessibleServices) {
    List<Long> existingInvisibleProductKeys = getExistingInvisibleProductKeys(unitId);

    for (String product : accessibleServices) {
        if (existingInvisibleProductKeys.contains(Long.valueOf(product))) {
            String queryString = "DELETE FROM UserGroupToInvisibleProduct as ug2ip "
                    + "WHERE ug2ip.usergroup_tkey=:unitId AND ug2ip.product_tkey=:productId";
            Query query = dm.createNativeQuery(queryString);
            query.setParameter("productId", Long.valueOf(product));
            query.setParameter("unitId", Long.valueOf(unitId));
            query.executeUpdate();
        }
    }
}

/**
 * @return Map the subscriptionId with the latest valid one
 * */
public Map<String, String> retrieveLastValidSubscriptionIdMap() {
    HashMap<String, String> result = new HashMap<String, String>();
    Query query = ds.createNativeQuery(QUERY_LAST_VALID_SUBID_MAP);
    query.setParameter("status", SubscriptionStatus.DEACTIVATED.name());
    @SuppressWarnings("unchecked")
    List<Object[]> querymap = query.getResultList();
    for (Object[] objs : querymap) {
        result.put((String) objs[0], (String) objs[1]);
    }
    return result;
}