@Override @Nullable public <E extends Entity> E load(LoadContext<E> context) { return getDataManager().load(context); }
/** * Loads a list of entities. */ public List<E> list() { LoadContext<E> loadContext = createLoadContext(); return dataManager.loadList(loadContext); }
protected Report reloadReport(Report report) { return dataManager.reload(report, ReportingBean.REPORT_EDIT_VIEW_NAME); }
@Override public InputStream downloadFile(FileDescriptor fileDescriptor) throws FileStorageException { FileDescriptor descriptor; try { // FileDescriptor must be available for the current user and be non deleted descriptor = dataManager.secure().reload(fileDescriptor, View.LOCAL); } catch (EntityAccessException e) { throw new FileStorageException(FileStorageException.Type.FILE_NOT_FOUND, fileDescriptor.getName(), e); } return fileStorage.openStream(descriptor); } }
protected void assignRoleUsers(Role role, Collection<User> items) { if (items == null) return; List<Entity> toCommit = new ArrayList<>(); for (User user : items) { LoadContext<UserRole> ctx = LoadContext.create(UserRole.class) .setView("user.edit") .setQuery(new LoadContext.Query("select ur from sec$UserRole ur where ur.user.id = :userId") .setParameter("userId", user.getId()) ); List<UserRole> userRoles = dataManager.loadList(ctx); boolean roleExist = false; for (UserRole userRole : userRoles) { if (role.equals(userRole.getRole())) { roleExist = true; break; } } if (!roleExist) { UserRole ur = metadata.create(UserRole.class); ur.setUser(user); ur.setRole(role); toCommit.add(ur); } } if (!toCommit.isEmpty()) { dataManager.commit(new CommitContext(toCommit)); } showNotification(getMessage("rolesAssigned.msg")); }
@Override public void changeGroupParent(UUID groupId, UUID newParentId) { checkUpdatePermission(Group.class); DataManager dataManager = this.dataManager.secure(); Group group = dataManager.load(LoadContext.create(Group.class) .setId(groupId) .setView(GROUP_COPY_VIEW)); LoadContext<Group> context = LoadContext.create(Group.class) .setId(newParentId) .setView(GROUP_COPY_VIEW); Group newParent = newParentId != null ? dataManager.load(context) : null; if (group != null) { group.setParent(newParent); } dataManager.commit(group); }
public void deleteEntity(String entityName, String entityId, String modelVersion) { entityName = restControllerUtils.transformEntityNameIfRequired(entityName, modelVersion, JsonTransformationDirection.FROM_VERSION); MetaClass metaClass = restControllerUtils.getMetaClass(entityName); checkCanDeleteEntity(metaClass); Object id = getIdFromString(entityId, metaClass); Entity entity = dataManager.load(new LoadContext<>(metaClass).setId(id)); checkEntityIsNotNull(entityName, entityId, entity); dataManager.remove(entity); }
protected List<Entity> loadEntities(List<Object> entityIds, MetaClass metaClass) { MetaProperty primaryKeyForFts = manager.getPrimaryKeyPropertyForFts(metaClass); List<Entity> result = new ArrayList<>(); for (List<Object> partition : Lists.partition(entityIds, ftsConfig.getLoadSize())) { List<Entity<Object>> partitionResult = dataManager.secure() .load(metaClass.getJavaClass()) .view(View.MINIMAL) .query(String.format("select e from %s e where e.%s in :ids", metaClass.getName(), primaryKeyForFts.getName())) .parameter("ids", partition) .list(); result.addAll(partitionResult); } return result; } }
protected List<Entity> loadItemsWithDirectKey(LoadDescriptor ld) { LoadContext.Query query = new LoadContext.Query( String.format("select e from %s e where e.%s in :ids", ld.getMetaClass(), metadataTools.getPrimaryKeyName(ld.getMetaClass()))); List<Object> ids = ld.getSelectedItems().stream() .map(Entity::getId) .collect(Collectors.toList()); query.setParameter("ids", ids); LoadContext<Entity> lc = new LoadContext<>(ld.getMetaClass()); lc.setSoftDeletion(false); lc.setQuery(query); lc.setView(ld.getView()); lc.setLoadDynamicAttributes(ld.isLoadDynamicAttributes()); return dataManager.secure().loadList(lc); } }
@Override public EntitySet commit(CommitContext context) { context.setAuthorizationRequired(true); return dataManager.commit(context); } }
/** * Loads a list of entities. */ public List<KeyValueEntity> list() { ValueLoadContext loadContext = createLoadContext(); return dataManager.loadValues(loadContext); }
@Override public long getCount(LoadContext<? extends Entity> context) { context.setAuthorizationRequired(true); return dataManager.getCount(context); }
@SuppressWarnings("unchecked") @Override public int getCount() { if (loader == null) { return container.getItems().size(); } if (loader instanceof CollectionLoader) { return (int) dataManager.getCount(((CollectionLoader) loader).createLoadContext()); } else if (loader instanceof KeyValueCollectionLoader) { ValueLoadContext context = ((KeyValueCollectionLoader) loader).createLoadContext(); QueryTransformer transformer = QueryTransformerFactory.createTransformer(context.getQuery().getQueryString()); // TODO it doesn't work for query containing scalars in select transformer.replaceWithCount(); context.getQuery().setQueryString(transformer.getResult()); context.setProperties(Collections.singletonList("cnt")); List<KeyValueEntity> list = dataManager.loadValues(context); Number count = list.get(0).getValue("cnt"); return count == null ? 0 : count.intValue(); } else { log.warn("Unsupported loader type: {}", loader.getClass().getName()); return 0; } }
protected void checkGlobalDefaultAndCloseEditor() { List<FilterEntity> otherDefaultFilters = dataManager.loadList(LoadContext.create(FilterEntity.class) .setQuery(LoadContext.createQuery("select f from sec$Filter f where f.globalDefault = true and " + "f.componentId = :componentId and " + "f.id <> :currentId ") .setParameter("componentId", filterEntity.getComponentId()) .setParameter("currentId", filterEntity.getId()))); if (!otherDefaultFilters.isEmpty()) { String otherFilterNamesStr = otherDefaultFilters.stream() .map(FilterEntity::getName) .collect(Collectors.joining(", ")); showOptionDialog(getMessage("filter.editor.anotherGlobalDefaultFilterFound.dialogTitle"), formatMessage("filter.editor.anotherGlobalDefaultFilterFound.dialogMessage", otherFilterNamesStr), MessageType.WARNING, new Action[]{ new DialogAction(DialogAction.Type.YES, Action.Status.PRIMARY).withHandler(e -> { otherDefaultFilters.forEach(otherDefaultFilter -> otherDefaultFilter.setGlobalDefault(false)); modifiedGlobalDefaultFilters = dataManager.commit(new CommitContext(otherDefaultFilters)); close(COMMIT_ACTION_ID, true); }), new DialogAction(DialogAction.Type.NO, Action.Status.NORMAL).withHandler(e -> { filterEntity.setGlobalDefault(false); close(COMMIT_ACTION_ID, true); }), }); } else { close(COMMIT_ACTION_ID, true); } }
@Override public Set<Entity> commit(CommitContext context) { context.setAuthorizationRequired(true); return dataManager.commit(context); }
@Override public List<KeyValueEntity> loadValues(ValueLoadContext context) { context.setAuthorizationRequired(true); return dataManager.loadValues(context); }
@Override public long getCount(LoadContext<? extends Entity> context) { return getDataManager().getCount(context); }
/** * Loads a single instance and wraps it in Optional. */ public Optional<E> optional() { LoadContext<E> loadContext = createLoadContext(); return Optional.ofNullable(loader.dataManager.load(loadContext)); }
@Override public <E extends Entity> List<E> loadList(LoadContext<E> context) { context.setJoinTransaction(true); return dataManager.loadList(context); }
protected void initIsDefaultCheckbox() { isDefault.setValue(BooleanUtils.isTrue(category.getIsDefault())); isDefault.addValueChangeListener(e -> { if (Boolean.TRUE.equals(e.getValue())) { LoadContext<Category> lc = new LoadContext<>(Category.class) .setView("category.defaultEdit"); lc.setQueryString("select c from sys$Category c where c.entityType = :entityType and not c.id = :id") .setParameter("entityType", category.getEntityType()) .setParameter("id", category.getId()); List<Category> result = dataManager.loadList(lc); for (Category cat : result) { cat.setIsDefault(false); } CommitContext commitCtx = new CommitContext(result); dataManager.commit(commitCtx); category.setIsDefault(true); } else if (Boolean.FALSE.equals(e.getValue())) { category.setIsDefault(false); } }); }