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); } }
protected EntityStatistics getEntityStatisticsInstance(String name, EntityManager em) { TypedQuery<EntityStatistics> q = em.createQuery("select s from sys$EntityStatistics s where s.name = ?1", EntityStatistics.class); q.setParameter(1, name); List<EntityStatistics> list = q.getResultList(); EntityStatistics es; if (list.isEmpty()) { es = metadata.create(EntityStatistics.class); es.setName(name); em.persist(es); } else { es = list.get(0); } return es; }
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(); }); }
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 void compileConstraints(UserSession session, Group group) { EntityManager em = persistence.getEntityManager(); TypedQuery<Constraint> q = em.createQuery("select c from sec$GroupHierarchy h join h.parent.constraints c " + "where h.group.id = ?1", Constraint.class); q.setParameter(1, group.getId()); List<Constraint> constraints = q.getResultList(); List<Constraint> list = new ArrayList<>(constraints); list.addAll(group.getConstraints()); for (Constraint constraint : list) { if (Boolean.TRUE.equals(constraint.getIsActive())) { session.addConstraint(constraint); } } }
protected Set<String> getAccessTokenValuesByUserLoginFromDatabase(String userLogin) { try (Transaction tx = persistence.createTransaction()) { EntityManager em = persistence.getEntityManager(); List<String> result = em.createQuery("select e.tokenValue from sys$AccessToken e where e.userLogin = :userLogin", String.class) .setParameter("userLogin", userLogin) .getResultList(); tx.commit(); return new HashSet<>(result); } }
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(); } }
protected User loadSubstitutedUser(User substitutedUser, UserSession currentSession, EntityManager em) { TypedQuery<User> query = em.createQuery( "select su from sec$User su where " + "su in (select s.substitutedUser from sec$User u join u.substitutions s " + "where u.id = ?1 and s.substitutedUser.id = ?2)", User.class ); query.setParameter(1, currentSession.getUser().getId()); query.setParameter(2, substitutedUser.getId()); List<User> list = query.getResultList(); if (list.isEmpty()) { throw new NoResultException("User not found"); } return list.get(0); }
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 void addDefaultRoles(User user, EntityManager entityManager) { List<Role> defaultRoles = entityManager.createQuery( "select r from sec$Role r where r.defaultRole = true", Role.class) .getResultList(); if (user.getUserRoles() == null) user.setUserRoles(new ArrayList<>()); for (Role defaultRole : defaultRoles) { if (user.getUserRoles().stream().noneMatch(userRole -> userRole.getRole().equals(defaultRole))) { UserRole userRole = metadata.create(UserRole.class); userRole.setUser(user); userRole.setRole(defaultRole); entityManager.persist(userRole); user.getUserRoles().add(userRole); } } }
private Map<String, LockDescriptor> getConfig() { if (this.config == null) { synchronized (this) { if (this.config == null) { Map<String, LockDescriptor> config = new ConcurrentHashMap<>(); Transaction tx = persistence.createTransaction(); try { EntityManager em = persistence.getEntityManager(); TypedQuery<LockDescriptor> q = em.createQuery( "select d from sys$LockDescriptor d", LockDescriptor.class); List<LockDescriptor> list = q.getResultList(); for (LockDescriptor ld : list) { config.put(ld.getName(), ld); } tx.commit(); } finally { tx.end(); } this.config = config; } } } return config; }
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(); }
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(); } }
protected void compileSessionAttributes(UserSession session, Group group) { List<SessionAttribute> list = new ArrayList<>(group.getSessionAttributes()); EntityManager em = persistence.getEntityManager(); TypedQuery<SessionAttribute> q = em.createQuery("select a from sec$GroupHierarchy h join h.parent.sessionAttributes a " + "where h.group.id = ?1 order by h.level desc", SessionAttribute.class); q.setParameter(1, group.getId()); List<SessionAttribute> attributes = q.getResultList(); list.addAll(attributes); for (SessionAttribute attribute : list) { Datatype datatype = Datatypes.get(attribute.getDatatype()); try { if (session.getAttributeNames().contains(attribute.getName())) { log.warn("Duplicate definition of '{}' session attribute in the group hierarchy", attribute.getName()); } Serializable value = (Serializable) datatype.parse(attribute.getStringValue()); if (value != null) session.setAttribute(attribute.getName(), value); else session.removeAttribute(attribute.getName()); } catch (ParseException e) { throw new RuntimeException("Unable to set session attribute " + attribute.getName(), e); } } }
@Override public void deleteScreenSettings(ClientType clientType, Set<String> screens) { try (Transaction tx = persistence.createTransaction()) { EntityManager em = persistence.getEntityManager(); TypedQuery<UserSetting> selectQuery = em.createQuery( "select e from sec$UserSetting e where e.user.id = ?1 and e.clientType=?2", UserSetting.class); selectQuery.setParameter(1, userSessionSource.getUserSession().getUser().getId()); selectQuery.setParameter(2, clientType.getId()); List<UserSetting> userSettings = selectQuery.getResultList(); for (UserSetting userSetting : userSettings) { if (screens.contains(userSetting.getName())) { em.remove(userSetting); } } tx.commit(); } }
protected void copyUserFolders(User fromUser, User toUser, Map<UUID, Presentation> presentationsMap) { try (Transaction tx = persistence.createTransaction()) { MetaClass effectiveMetaClass = metadata.getExtendedEntities().getEffectiveMetaClass(SearchFolder.class); EntityManager em = persistence.getEntityManager(); try { em.setSoftDeletion(false); Query deleteSettingsQuery = em.createQuery( String.format("delete from %s s where s.user.id = ?1", effectiveMetaClass.getName()) ); deleteSettingsQuery.setParameter(1, toUser.getId()); deleteSettingsQuery.executeUpdate(); } finally { em.setSoftDeletion(true); } TypedQuery<SearchFolder> q = em.createQuery( String.format("select s from %s s where s.user.id = ?1", effectiveMetaClass.getName()), SearchFolder.class); q.setParameter(1, fromUser.getId()); List<SearchFolder> fromUserFolders = q.getResultList(); Map<SearchFolder, SearchFolder> copiedFolders = new HashMap<>(); for (SearchFolder searchFolder : fromUserFolders) { copyFolder(searchFolder, toUser, copiedFolders, presentationsMap); } tx.commit(); } }
@Override public List<SearchFolder> loadSearchFolders() { log.debug("Loading SearchFolders"); StopWatch stopWatch = new Slf4JStopWatch("SearchFolders"); stopWatch.start(); Transaction tx = persistence.createTransaction(); try { EntityManager em = persistence.getEntityManager(); MetaClass effectiveMetaClass = metadata.getExtendedEntities().getEffectiveMetaClass(SearchFolder.class); TypedQuery<SearchFolder> q = em.createQuery("select f from "+ effectiveMetaClass.getName() +" f " + "left join f.user u on u.id = ?1 " + "where (u.id = ?1 or u is null) " + "order by f.sortOrder, f.name", SearchFolder.class); q.setViewName("searchFolders"); q.setParameter(1, userSessionSource.currentOrSubstitutedUserId()); List<SearchFolder> list = q.getResultList(); tx.commit(); return list; } finally { tx.end(); stopWatch.stop(); } }
@Override public void onBeforeUpdate(Group entity, EntityManager entityManager) { if (!persistence.getTools().getDirtyFields(entity).contains("parent")) return; EntityManager em = persistence.getEntityManager(); for (GroupHierarchy oldHierarchy : entity.getHierarchyList()) { em.remove(oldHierarchy); } createNewHierarchy(entity, entity.getParent()); TypedQuery<GroupHierarchy> q = em.createQuery( "select h from sec$GroupHierarchy h join fetch h.group " + "where h.parent.id = ?1", GroupHierarchy.class); q.setParameter(1, entity.getId()); List<GroupHierarchy> list = q.getResultList(); for (GroupHierarchy hierarchy : list) { Group dependentGroup = hierarchy.getGroup(); for (GroupHierarchy depHierarchy : dependentGroup.getHierarchyList()) { em.remove(depHierarchy); } em.remove(hierarchy); createNewHierarchy(dependentGroup, dependentGroup.getParent()); } } }
protected Map<UUID, Presentation> copyPresentations(User fromUser, User toUser) { Map<UUID, Presentation> presentationMap = new HashMap<>(); try (Transaction tx = persistence.createTransaction()) { EntityManager em = persistence.getEntityManager(); // delete existing Query delete = em.createQuery("delete from sec$Presentation p where p.user.id = ?1"); delete.setParameter(1, toUser.getId()); delete.executeUpdate(); // copy settings TypedQuery<Presentation> selectQuery = em.createQuery( "select p from sec$Presentation p where p.user.id = ?1", Presentation.class); selectQuery.setParameter(1, fromUser.getId()); List<Presentation> presentations = selectQuery.getResultList(); for (Presentation presentation : presentations) { Presentation newPresentation = metadata.create(Presentation.class); newPresentation.setUser(toUser); newPresentation.setComponentId(presentation.getComponentId()); newPresentation.setAutoSave(presentation.getAutoSave()); newPresentation.setName(presentation.getName()); newPresentation.setXml(presentation.getXml()); presentationMap.put(presentation.getId(), newPresentation); em.persist(newPresentation); } tx.commit(); return presentationMap; } }
@Override public List<EntitySnapshot> getSnapshots(MetaClass metaClass, Object id) { metaClass = extendedEntities.getOriginalOrThisMetaClass(metaClass); Entity entity = dataManager.load(new LoadContext<>(metaClass).setId(id).setView(View.LOCAL)); checkCompositePrimaryKey(entity); List<EntitySnapshot> resultList = null; 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 s from sys$EntitySnapshot s where s.entity.%s = :entityId and s.entityMetaClass = :metaClass " + "order by s.snapshotDate desc", referenceToEntitySupport.getReferenceIdPropertyName(metaClass)), EntitySnapshot.class); query.setParameter("entityId", referenceToEntitySupport.getReferenceId(entity)); query.setParameter("metaClass", metaClass.getName()); query.setView(view); resultList = query.getResultList(); tx.commit(); } finally { tx.end(); } return resultList; }