How to use

ViewRepository

in

com.haulmont.cuba.core.global

@Override
public View getView(Class<? extends Entity> entityClass, String name) {
  try {
    return viewRepository.getView(entityClass, name);
  } catch (ViewNotFoundException e) {
    return null;
  }
}

public String getView(String entityName, String viewName) {
  MetaClass metaClass = restControllersUtils.getMetaClass(entityName);
  View view = viewRepository.findView(metaClass, viewName);
  if (view == null) {
    throw new RestAPIException("View not found",
        String.format("View %s for metaClass %s not found", viewName, entityName),
        HttpStatus.NOT_FOUND);
  }
  return viewSerializationAPI.toJson(view);
}

  public String getAllViewsForMetaClass(String entityName) {
    MetaClass metaClass = restControllersUtils.getMetaClass(entityName);
    StringBuilder sb = new StringBuilder();
    sb.append("[");
    List<String> jsonViews = new ArrayList<>();
    for (String viewName : viewRepository.getViewNames(metaClass)) {
      View view = viewRepository.getView(metaClass, viewName);
      jsonViews.add(viewSerializationAPI.toJson(view));
    }
    sb.append(Joiner.on(",").join(jsonViews));
    sb.append("]");
    return sb.toString();
  }
}

protected void loadViewNames(MetaClass metaClass) {
  List<String> viewNames = new ArrayList<>(metadata.getViewRepository().getViewNames(metaClass));
  viewLookup.setOptionsList(viewNames);
}

  protected void setEntityViewsLookup() {
    List<String> views = new LinkedList<>();
    views.add(View.MINIMAL);
    views.add(View.LOCAL);
    views.addAll(metadata.getViewRepository().getViewNames((MetaClass) entitiesMetaClasses.getValue()));

    entityViews.setOptionsList(views);
    entityViews.setValue(View.LOCAL);
  }
}

protected void loadView(Element element, Class<Entity> entityClass, InstanceContainer<Entity> container) {
  String viewName = element.attributeValue("view");
  if (viewName != null) {
    container.setView(viewRepository.getView(entityClass, viewName));
  }
}

protected Entity loadEntityInstance(EntityLoadInfo info) {
  if (info.isNewEntity()) {
    return metadata.create(info.getMetaClass());
  }
  //noinspection unchecked
  LoadContext<Entity> ctx = new LoadContext(info.getMetaClass()).setId(info.getId());
  if (info.getViewName() != null) {
    View view = viewRepository.findView(info.getMetaClass(), info.getViewName());
    if (view != null) {
      ctx.setView(view);
    } else {
      log.warn("Unable to find view \"{}\" for entity \"{}\"", info.getViewName(), info.getMetaClass());
    }
  }
  Entity entity;
  try {
    entity = dataService.load(ctx);
  } catch (Exception e) {
    log.warn("Unable to load item: {}", info, e);
    return null;
  }
  return entity;
}

protected void refreshViewNames(@Nullable ReportInputParameter reportInputParameter) {
  if (reportInputParameter != null) {
    if (StringUtils.isNotBlank(reportInputParameter.getEntityMetaClass())) {
      MetaClass parameterMetaClass = metadata.getClass(reportInputParameter.getEntityMetaClass());
      Collection<String> viewNames = metadata.getViewRepository().getViewNames(parameterMetaClass);
      Map<String, Object> views = new HashMap<>();
      for (String viewName : viewNames) {
        views.put(viewName, viewName);
      }
      views.put(View.LOCAL, View.LOCAL);
      views.put(View.MINIMAL, View.MINIMAL);
      viewNameLookup.setOptionsMap(views);
      return;
    }
  }
  viewNameLookup.setOptionsMap(new HashMap<>());
}

/**
 * Fetch instance by view name.
 */
public void fetch(Entity instance, String viewName) {
  if (viewName == null)
    return;
  View view = viewRepository.getView(instance.getClass(), viewName);
  fetch(instance, view, new HashMap<>(), false);
}

  );
view = metadata.getViewRepository().findView(getMetaClass(), property.getView().getName());

public void setView(String viewName) {
  this.view = metadata.getViewRepository().getView(metaClass, viewName);
}

View reportEditView = viewRepository.findView(savedReport.getMetaClass(), "report.edit");
return dataManager.reload(savedReport, reportEditView, savedReport.getMetaClass(), true);

/**
 * Fetch instance by view name.
 *
 * @param optimizeForDetached if true, detached objects encountered in the graph will be first checked whether all
 *                            required attributes are already loaded, and reloaded only when needed.
 *                            If the argument is false, all detached objects are reloaded anyway.
 */
public void fetch(Entity instance, String viewName, boolean optimizeForDetached) {
  if (viewName == null)
    return;
  View view = viewRepository.getView(instance.getClass(), viewName);
  fetch(instance, view, new HashMap<>(), optimizeForDetached);
}

@Override
public <E extends Entity> E reload(E entity, String viewName) {
  Objects.requireNonNull(viewName, "viewName is null");
  return reload(entity, metadata.getViewRepository().getView(entity.getClass(), viewName));
}

@Override
public TypedQuery<T> addViewName(String viewName) {
  if (resultClass == null)
    throw new IllegalStateException("resultClass is null");
  addView(metadata.getViewRepository().getView(resultClass, viewName));
  return this;
}

@Override
public TypedQuery<T> setViewName(String viewName) {
  if (resultClass == null)
    throw new IllegalStateException("resultClass is null");
  setView(metadata.getViewRepository().getView(resultClass, viewName));
  return this;
}

/**
 * Finds a view for a given metaClass. Throws a RestAPIException if view not found
 */
public View getView(MetaClass metaClass, String viewName) {
  try {
    return viewRepository.getView(metaClass, viewName);
  } catch (ViewNotFoundException e) {
    throw new RestAPIException("View not found",
        String.format("View %s for entity %s not found", viewName, metaClass.getName()),
        HttpStatus.BAD_REQUEST);
  }
}

@Override
public <E extends Entity> E reload(E entity, String viewName) {
  Objects.requireNonNull(viewName, "viewName is null");
  return reload(entity, metadata.getViewRepository().getView(entity.getClass(), viewName));
}

@Nullable
@Override
public <T extends Entity<K>, K> T find(Class<T> entityClass, K id, String... viewNames) {
  View[] viewArray = new View[viewNames.length];
  for (int i = 0; i < viewNames.length; i++) {
    viewArray[i] = metadata.getViewRepository().getView(entityClass, viewNames[i]);
  }
  return find(entityClass, id, viewArray);
}

protected View getViewFromContext(CommitContext context, Entity entity) {
  View view = context.getViews().get(entity);
  if (view == null) {
    view = viewRepository.getView(entity.getClass(), View.LOCAL);
  }
  return isAuthorizationRequired(context) ? attributeSecurity.createRestrictedView(view) : view;
}