protected Set<String> getRefreshTokenValuesByUserLoginFromDatabase(String userLogin) { try (Transaction tx = persistence.createTransaction()) { EntityManager em = persistence.getEntityManager(); List<String> result = em.createQuery("select e.tokenValue from sys$RefreshToken e where e.userLogin = :userLogin", String.class) .setParameter("userLogin", userLogin) .getResultList(); tx.commit(); return new HashSet<>(result); } }
protected List<FtsQueue> loadQueuedItems() { boolean useServerId = !ftsConfig.getIndexingHosts().isEmpty(); int maxSize = ftsConfig.getIndexingBatchSize(); return persistence.callInTransaction(em -> { String queryString = format("select q from sys$FtsQueue q where q.fake = false and %s order by q.createTs", (useServerId ? "q.indexingHost = ?1" : "q.indexingHost is null")); TypedQuery<FtsQueue> query = em.createQuery(queryString, FtsQueue.class); if (useServerId) query.setParameter(1, serverId); query.setMaxResults(maxSize); return query.getResultList(); }); }
@Override public EntitySnapshot getLastEntitySnapshot(MetaClass metaClass, Object referenceId) { if (referenceId instanceof Entity) { throw new IllegalArgumentException(format("Reference id can not be an entity: %s", referenceId.getClass())); } MetaClass originalMetaClass = extendedEntities.getOriginalOrThisMetaClass(metaClass); View view = metadata.getViewRepository().getView(EntitySnapshot.class, "entitySnapshot.browse"); Transaction tx = persistence.createTransaction(); try { EntityManager em = persistence.getEntityManager(); TypedQuery<EntitySnapshot> query = em.createQuery( format("select e from sys$EntitySnapshot e where e.entityMetaClass = :metaClass and" + " e.entity.%s = :entityId order by e.snapshotDate desc", referenceToEntitySupport.getReferenceIdPropertyName(originalMetaClass)), EntitySnapshot.class) .setParameter("metaClass", originalMetaClass.getName()) .setParameter("entityId", referenceId) .setMaxResults(1) .setView(view); return query.getFirstResult(); } finally { tx.close(); } }
private Config getConfigInstance(String name) { EntityManager em = persistence.getEntityManager(); TypedQuery<Config> query = em.createQuery("select c from sys$Config c where c.name = ?1", Config.class); query.setParameter(1, name); query.setView(null); List<Config> list = query.getResultList(); if (list.isEmpty()) return null; else return list.get(0); } }
@Nullable protected RememberMeToken loadRememberMeToken(User user, String rememberMeToken) { EntityManager em = persistence.getEntityManager(); TypedQuery<RememberMeToken> query = em.createQuery( "select rt from sec$RememberMeToken rt where rt.token = :token and rt.user.id = :userId", RememberMeToken.class); query.setParameter("token", rememberMeToken); query.setParameter("userId", user.getId()); return query.getFirstResult(); }
query.setParameter("userIds", userIds); query.setViewName(MOVE_USER_TO_GROUP_VIEW); List<User> users = query.getResultList(); if (users == null || users.size() != userIds.size()) throw new IllegalStateException("Not all users found in database");
SendingMessage.class ); query.setParameter("statusQueue", SendingStatus.QUEUE.getId()); query.setParameter("time", sendTimeoutTime); query.setParameter("statusSending", SendingStatus.SENDING.getId()); query.setView(view); query.setMaxResults(config.getMessageQueueCapacity()); List<SendingMessage> resList = query.getResultList();
protected int migrateMessagesBatch() { List<SendingMessage> resultList; Transaction tx = persistence.createTransaction(); try { EntityManager em = persistence.getEntityManager(); String qstr = "select m from sys$SendingMessage m where m.contentText is not null"; TypedQuery<SendingMessage> query = em.createQuery(qstr, SendingMessage.class); query.setMaxResults(50); query.setViewName(View.MINIMAL); resultList = query.getResultList(); tx.commit(); } finally { tx.end(); } if (!resultList.isEmpty()) { emailer.migrateEmailsToFileStorage(resultList); } return resultList.size(); }
@Nullable protected AccessToken getAccessTokenByTokenValueFromDatabase(String accessTokenValue) { AccessToken accessToken; try (Transaction tx = persistence.createTransaction()) { EntityManager em = persistence.getEntityManager(); accessToken = em.createQuery("select e from sys$AccessToken e where e.tokenValue = :tokenValue", AccessToken.class) .setParameter("tokenValue", accessTokenValue) .setViewName(View.LOCAL) .getFirstResult(); tx.commit(); return accessToken; } }
EntityManager em = persistence.getEntityManager(); TypedQuery<FileDescriptor> query = em.createQuery("select fd from sys$FileDescriptor fd", FileDescriptor.class); fileDescriptors = query.getResultList(); tx.commit(); } catch (Exception e) {
public void internalDeleteForInactiveSessions() { log.debug("Delete query results for inactive user sessions"); List<Object[]> rows; try (Transaction tx = persistence.createTransaction()) { TypedQuery<Object[]> query = persistence.getEntityManager().createQuery( "select e.id, e.sessionId from sys$QueryResult e", Object[].class); query.setMaxResults(INACTIVE_DELETION_MAX); rows = query.getResultList(); } if (rows.size() == INACTIVE_DELETION_MAX) { log.debug("Processing " + INACTIVE_DELETION_MAX + " records, run again for the rest"); } Set<UUID> sessionIds = userSessions.getUserSessionsStream().map(UserSession::getId).collect(Collectors.toSet()); List<Long> ids = new ArrayList<>(); int i = 0; for (Object[] row : rows) { if (!sessionIds.contains((UUID) row[1])) { ids.add((Long) row[0]); } i++; if (i % DELETE_BATCH_SIZE == 0) { if (!ids.isEmpty()) delete(ids); ids.clear(); } } if (!ids.isEmpty()) delete(ids); }
query.setViewName("for.cache"); List<Category> resultList = query.getResultList();
@Override public <T extends Entity> TypedQuery<T> createNativeQuery(String sql, Class<T> resultClass) { TypedQuery<T> query = createQueryInstance(true, resultClass); query.setQueryString(sql); return query; }
protected List<CategoryAttributeValue> reloadCategoryAttributeValuesWithChildren(List<CategoryAttributeValue> categoryAttributeValues) { EntityManager em = persistence.getEntityManager(); View categoryAttributeValueLocalView = viewRepository.getView(CategoryAttributeValue.class, View.LOCAL); View categoryAttributeLocalView = viewRepository.getView(CategoryAttribute.class, View.LOCAL); View view = new View(categoryAttributeValueLocalView, null, false) .addProperty("categoryAttribute", new View(categoryAttributeLocalView, null, false).addProperty("category")) .addProperty("childValues", categoryAttributeValueLocalView); List<UUID> ids = categoryAttributeValues.stream() .map(BaseUuidEntity::getId) .collect(Collectors.toList()); return em.createQuery("select cav from sys$CategoryAttributeValue cav where cav.id in :ids", CategoryAttributeValue.class) .setParameter("ids", ids) .setView(view) .getResultList(); }
protected Map<User, String> updateUserPasswords(List<UUID> userIds, boolean generatePassword) { Map<User, String> modifiedUsers = new LinkedHashMap<>(); Transaction tx = persistence.getTransaction(); try { EntityManager em = persistence.getEntityManager(); TypedQuery<User> query = em.createQuery("select u from sec$User u where u.id in :userIds", User.class); query.setParameter("userIds", userIds); query.setViewName(RESET_PASSWORD_VIEW); List<User> users = query.getResultList(); if (users == null || users.size() != userIds.size()) throw new IllegalStateException("Not all users found in database"); for (User user : users) { String password = null; if (generatePassword) { password = passwordEncryption.generateRandomPassword(); user.setPasswordEncryption(passwordEncryption.getHashMethod()); String passwordHash = passwordEncryption.getPasswordHash(user.getId(), password); user.setPassword(passwordHash); } user.setChangePasswordAtNextLogon(true); modifiedUsers.put(user, password); } resetRememberMeTokens(userIds); tx.commit(); } finally { tx.end(); } return modifiedUsers; }
protected int migrateAttachmentsBatch() { List<SendingAttachment> resultList; Transaction tx = persistence.createTransaction(); try { EntityManager em = persistence.getEntityManager(); String qstr = "select a from sys$SendingAttachment a where a.content is not null"; TypedQuery<SendingAttachment> query = em.createQuery(qstr, SendingAttachment.class); query.setMaxResults(50); query.setViewName(View.MINIMAL); resultList = query.getResultList(); tx.commit(); } finally { tx.end(); } if (!resultList.isEmpty()) { emailer.migrateAttachmentsToFileStorage(resultList); } return resultList.size(); } }
@Nullable protected RefreshToken getRefreshTokenByTokenValueFromDatabase(String refreshTokenValue) { RefreshToken refreshToken; try (Transaction tx = persistence.createTransaction()) { EntityManager em = persistence.getEntityManager(); refreshToken = em.createQuery("select e from sys$RefreshToken e where e.tokenValue = :tokenValue", RefreshToken.class) .setParameter("tokenValue", refreshTokenValue) .setViewName(View.LOCAL) .getFirstResult(); tx.commit(); return refreshToken; } }
@Nullable protected UserSetting findUserSettings(ClientType clientType, String name) { EntityManager em = persistence.getEntityManager(); TypedQuery<UserSetting> q = em.createQuery( "select s from sec$UserSetting s where s.user.id = ?1 and s.name =?2 and s.clientType = ?3", UserSetting.class); q.setParameter(1, userSessionSource.getUserSession().getUser().getId()); q.setParameter(2, name); q.setParameter(3, clientType == null ? null : clientType.getId()); return q.getFirstResult(); }
protected void internalLoadStatisticsCache() { log.info("Loading statistics cache"); Transaction tx = persistence.createTransaction(); try { EntityManager em = persistence.getEntityManager(); TypedQuery<EntityStatistics> q = em.createQuery("select s from sys$EntityStatistics s", EntityStatistics.class); List<EntityStatistics> list = q.getResultList(); for (EntityStatistics es : list) { statisticsCache.put(es.getName(), es); } tx.commit(); } finally { tx.end(); } }
@Override public <T> TypedQuery<T> createQuery(String qlString, Class<T> resultClass) { TypedQuery<T> query = createQueryInstance(false, resultClass); query.setQueryString(qlString); return query; }