protected List<SendingAttachment> getAttachments(SendingMessage message) { return dataSupplier.reload(message, "sendingMessage.loadFromQueue").getAttachments(); }
protected FileDescriptor commitFileDescriptor(FileDescriptor fileDescriptor) { DataSupplier dataSupplier = getDataSupplier(); if (dataSupplier != null) { return dataSupplier.commit(fileDescriptor); } DataManager dataManager = beanLocator.get(DataManager.NAME); return dataManager.commit(fileDescriptor); }
/** * Loads single item by id. * * @param meta item's meta class * @param id item's id * @param view view * @return loaded item if found, null otherwise */ protected Entity loadSingleItem(MetaClass meta, Object id, View view) { String primaryKeyName = metadata.getTools().getPrimaryKeyName(meta); if (primaryKeyName == null) { throw new IllegalStateException(String.format("Entity %s has no primary key", meta.getName())); } LoadContext ctx = new LoadContext(meta); ctx.setLoadDynamicAttributes(true); ctx.setSoftDeletion(false); ctx.setView(view); String query = String.format("select e from %s e where e.%s = :id", meta.getName(), primaryKeyName); LoadContext.Query q = ctx.setQueryString(query); q.setParameter("id", id); return dataSupplier.load(ctx); }
protected void addDefaultRoles(User user) { LoadContext<Role> ctx = new LoadContext<>(Role.class); ctx.setQueryString("select r from sec$Role r where r.defaultRole = true"); List<Role> defaultRoles = dataSupplier.loadList(ctx); List<UserRole> newRoles = new ArrayList<>(); if (user.getUserRoles() != null) { newRoles.addAll(user.getUserRoles()); } MetaClass metaClass = rolesDs.getMetaClass(); for (Role role : defaultRoles) { UserRole userRole = dataSupplier.newInstance(metaClass); userRole.setRole(role); userRole.setUser(user); newRoles.add(userRole); } user.setUserRoles(newRoles); }
&& ((CollectionDatasource) parentDs).containsItem(item.getId()) && !entityStates.isLoadedWithView(item, ds.getView())) { item = dataservice.reload(item, ds.getView(), ds.getMetaClass(), ds.getLoadDynamicAttributes()); if (parentDs instanceof CollectionPropertyDatasourceImpl) { ((CollectionPropertyDatasourceImpl) parentDs).replaceItem(item); handlePreviouslyDeletedCompositionItems(item, parentDs); } else if (!PersistenceHelper.isNew(item)) { item = dataservice.reload(item, ds.getView(), ds.getMetaClass(), ds.getLoadDynamicAttributes()); Entity newItem = ds.getDataSupplier().newInstance(ds.getMetaClass()); MetadataTools metadataTools = getBeanLocator().get(MetadataTools.NAME); metadataTools.copy(item, newItem);
protected void initUserGroup(User user) { LoadContext<Group> ctx = new LoadContext<>(Group.class); ctx.setQueryString("select g from sec$Group g"); ctx.setView(View.MINIMAL); List<Group> groups = dataSupplier.loadList(ctx); if (groups.size() == 1) { user.setGroup(groups.get(0)); } }
@Override public void setItem(Entity item) { Entity newItem = valuesFormatsDs.getDataSupplier().newInstance(valuesFormatsDs.getMetaClass()); metadata.getTools().copy(item, newItem); ((ReportValueFormat) newItem).setId((UUID) item.getId()); super.setItem(newItem); } }
protected void loadData(Map<String, Object> params) { if (ds.needLoading()) { ValueLoadContext context = beforeLoadValues(params); if (context == null) { return; } try { List<KeyValueEntity> entities = ds.dataSupplier.loadValues(context); afterLoadValues(params, context, entities); } catch (Throwable e) { ds.dataLoadError = e; } } }
/** * Return number of rows for the current query set in the datasource. * * @return number of rows. In case of error returns 0 and sets {@link #dataLoadError} field to the exception object */ public int getCount() { LoadContext<Entity> context = new LoadContext<>(metaClass); LoadContext.Query q = (LoadContext.Query) createDataQuery(context, savedParameters == null ? Collections.<String, Object>emptyMap() : savedParameters); context.setSoftDeletion(isSoftDeletion()); if (q == null) return 0; prepareLoadContext(context); dataLoadError = null; try { long res = dataSupplier.getCount(context); if (res > Integer.MAX_VALUE) throw new RuntimeException("Number of records is too big: " + res); return (int) res; } catch (Throwable e) { dataLoadError = e; } return 0; }
/** * For entities with composite keys there will be a value of the 'uuid' property in the {@code entityId} parameter. */ protected Entity reloadEntity(MetaClass metaClass, Object entityId) { String ftsPrimaryKeyName = ftsService.getPrimaryKeyPropertyForFts(metaClass).getName(); String queryStr = String.format("select e from %s e where e.%s = :id", metaClass.getName(), ftsPrimaryKeyName); LoadContext lc = new LoadContext(metaClass) .setView(View.MINIMAL) .setQuery(LoadContext.createQuery(queryStr).setParameter("id", entityId)); List list = getDsContext().getDataSupplier().loadList(lc); return list.isEmpty() ? null : (Entity) list.get(0); } }
UserRole userRole = dataSupplier.newInstance(metaClass); userRole.setRole(role); userRole.setUser(userDs.getItem());
@Override public void refresh() { backgroundWorker.checkUIAccess(); State prevState = state; if (!prevState.equals(State.VALID)) { state = State.VALID; fireStateChanged(prevState); } if (item != null && metadata.getTools().isPersistent(item.getClass())) { T prevItem = item; T reloadedItem = dataSupplier.reload(item, view); __setItem(reloadedItem); fireItemChanged(prevItem); } }
protected void commitBulkChanges() { List<String> fields = new ArrayList<>(); for (Map.Entry<String, Field> fieldEntry : dataFields.entrySet()) { Field field = fieldEntry.getValue(); if (isFieldChanged(field)) { fields.add(managedFields.get(fieldEntry.getKey()).getFqn()); } } for (Map.Entry<String, Field> fieldEntry : dataFields.entrySet()) { Field field = fieldEntry.getValue(); if (!field.isEnabled()) { for (Entity item : items) { ensureEmbeddedPropertyCreated(item, fieldEntry.getKey()); item.setValueEx(fieldEntry.getKey(), null); } } else if (isFieldChanged(field)) { for (Entity item : items) { ensureEmbeddedPropertyCreated(item, fieldEntry.getKey()); item.setValueEx(fieldEntry.getKey(), field.getValue()); } } } Set<Entity> committed = dataSupplier.commit(new CommitContext(items)); Logger logger = LoggerFactory.getLogger(BulkEditorWindow.class); logger.info("Applied bulk editing for {} entries of {}. Changed properties: {}", committed.size(), metaClass, StringUtils.join(fields, ", ")); showNotification(formatMessage("bulk.successMessage", committed.size()), NotificationType.HUMANIZED); close(COMMIT_ACTION_ID); }
/** * Load data from middleware into {@link #data} field. * <p>In case of error sets {@link #dataLoadError} field to the exception object.</p> * @param params datasource parameters, as described in {@link CollectionDatasource#refresh(java.util.Map)} */ protected void loadData(Map<String, Object> params) { Security security = AppBeans.get(Security.NAME); if (!security.isEntityOpPermitted(metaClass, EntityOp.READ)) { return; } String tag = getLoggingTag("CDS"); StopWatch sw = new Slf4JStopWatch(tag, LoggerFactory.getLogger(UIPerformanceLogger.class)); if (needLoading()) { LoadContext context = beforeLoadData(params); if (context == null) { return; } try { Collection<T> entities = dataSupplier.loadList(context); afterLoadData(params, context, entities); } catch (Throwable e) { dataLoadError = e; } } sw.stop(); }
final DataSupplier dataService = datasource.getDataSupplier(); final Entity item = dataService.newInstance(datasource.getMetaClass());
protected Entity reloadInstance(Entity instance) { View reloadView = new View(instance.getMetaClass().getJavaClass(), true); LoadContext loadContext = new LoadContext(instance.getMetaClass()); loadContext.setSoftDeletion(false); loadContext.setId(instance.getId()); loadContext.setView(reloadView); DataSupplier supplier = getDataSupplier(); return supplier.load(loadContext); }
public void changePassword() { final User selectedUser = usersTable.getSingleSelected(); if (selectedUser != null) { Window changePasswordDialog = openWindow("sec$User.changePassword", OpenType.DIALOG, ParamsMap.of("user", selectedUser)); changePasswordDialog.addCloseListener(actionId -> { if (COMMIT_ACTION_ID.equals(actionId)) { usersDs.updateItem(dataSupplier.reload(selectedUser, usersDs.getView())); } usersTable.focus(); }); } }
@Override public boolean commit() { Map<DataSupplier, Collection<Datasource<Entity>>> commitData = collectCommitData(); boolean committed = false; if (!commitData.isEmpty()) { DataSupplier dataservice = getDataSupplier(); Set<DataSupplier> suppliers = commitData.keySet(); if (suppliers.size() == 1 && Objects.equals(suppliers.iterator().next(), dataservice)) { CommitContext context = createCommitContext(dataservice, commitData); fireBeforeCommit(context); Set<Entity> committedEntities = dataservice.commit(context); fireAfterCommit(context, committedEntities); notifyAllDsCommited(dataservice, committedEntities); committed = true; } else { throw new UnsupportedOperationException(); } } for (DsContext childDsContext : children) { boolean c = commitToParent(childDsContext.getAll()); committed = committed || c; } boolean c = commitToParent(datasourceMap.values()); committed = committed || c; return committed; }
@Override protected void postInit() { activeField.setEnabled(!userManagementService.isAnonymousUser(getItem().getLogin())); setCaption(PersistenceHelper.isNew(getItem()) ? getMessage("createCaption") : formatMessage("editCaption", getItem().getLogin())); timeZoneLookup.setEnabled(!Boolean.TRUE.equals(getItem().getTimeZoneAuto())); // Do not show roles which are not allowed by security constraints LoadContext<Role> lc = new LoadContext<>(Role.class); lc.setQueryString("select r from sec$Role r"); lc.setView(View.MINIMAL); List<Role> allowedRoles = dataSupplier.loadList(lc); Collection<UserRole> userRoles = new ArrayList<>(rolesDs.getItems()); for (UserRole userRole : userRoles) { if (!allowedRoles.contains(userRole.getRole())) { rolesDs.excludeItem(userRole); } } if (BooleanUtils.isTrue(initCopy)) { initCopy(); } // if we add default roles, rolesDs becomes modified on setItem ((AbstractDatasource) rolesDs).setModified(false); }
@Override public void actionPerform(Component component) { if (!isEnabled()) { return; } ReportGroup group = (ReportGroup) target.getSingleSelected(); if (group != null) { if (group.getSystemFlag()) { showNotification(getMessage("unableToDeleteSystemReportGroup"), NotificationType.WARNING); } else { LoadContext<Report> loadContext = new LoadContext<>(Report.class); loadContext.setView("report.view"); LoadContext.Query query = new LoadContext.Query("select r from report$Report r where r.group.id = :groupId"); query.setMaxResults(1); query.setParameter("groupId", group.getId()); loadContext.setQuery(query); DataSupplier dataService = getDsContext().getDataSupplier(); Report report = dataService.load(loadContext); if (report != null) { showNotification(getMessage("unableToDeleteNotEmptyReportGroup"), NotificationType.WARNING); } else { super.actionPerform(component); } } } } }