Example usage for org.apache.wicket.request.resource ResourceReference getResource

List of usage examples for org.apache.wicket.request.resource ResourceReference getResource

Introduction

In this page you can find the example usage for org.apache.wicket.request.resource ResourceReference getResource.

Prototype

public abstract IResource getResource();

Source Link

Document

Returns the resource.

Usage

From source file:fiftyfive.wicket.resource.MergedResourceMapper.java

License:Apache License

protected String applyCachingStrategy(String fileName, PageParameters parameters) {
    ResourceUrl resourceUrl = new ResourceUrl(fileName, parameters);
    ResourceReference lastMod = getLastModifiedReference();
    IResource res = lastMod.getResource();
    if (res instanceof IStaticCacheableResource) {
        this.cachingStrategy.get().decorateUrl(resourceUrl, (IStaticCacheableResource) res);
    }// ww  w .  j a  va2s .co  m
    return resourceUrl.getFileName();
}

From source file:fiftyfive.wicket.resource.MergedResourceMapper.java

License:Apache License

/**
 * De-reference the resource and open its stream to determine the last modified time.
 *///from ww  w .  jav a2 s  . co m
protected Time getLastModifiedTime(ResourceReference ref) {
    Time modified = null;
    IResource res = ref.getResource();
    if (res instanceof IStaticCacheableResource) {
        IResourceStream stream = ((IStaticCacheableResource) res).getCacheableResourceStream();
        modified = stream.lastModifiedTime();
    }
    return modified;
}

From source file:fiftyfive.wicket.resource.MergedResourceRequestHandler.java

License:Apache License

public void respond(IRequestCycle requestCycle) {
    WebRequest origRequest = (WebRequest) requestCycle.getRequest();

    // Explicitly set the last modified header of the response based on the last modified
    // time of the aggregate. Do this on the original response because our wrapped response
    // ignores the last modified headers contributed by each individual resource.
    WebResponse origResponse = (WebResponse) requestCycle.getResponse();
    if (this.lastModified != null) {
        origResponse.setLastModifiedTime(this.lastModified);
    }// w w w .  j  a va  2  s.c  o  m

    try {
        // Make a special response object that merges the contributions of each resource,
        // but maintains a single set of headers.
        MergedResponse merged = new MergedResponse(origResponse);
        requestCycle.setResponse(merged);

        // Make a special request object that tweaks the If-Modified-Since header to ensure
        // we don't end up in a situation where some resources respond 200 and others 304.
        // Yes, calling RequestCycle#setRequest() is frowned upon so this is a bit of a hack.
        ((RequestCycle) requestCycle).setRequest(new MergedRequest(origRequest));

        for (ResourceReference ref : this.resources) {
            ResourceRequestHandler handler = new ResourceRequestHandler(ref.getResource(), this.pageParameters);
            handler.respond(requestCycle);

            // If first resource sent 304 Not Modified that means all will.
            // We can therefore skip the rest.
            if (304 == merged.status) {
                break;
            }
        }
    } finally {
        // Restore the original request once we're done. We don't need to restore the
        // original response because Wicket takes care of that automatically.
        ((RequestCycle) requestCycle).setRequest(origRequest);
    }
}

From source file:org.hippoecm.frontend.plugins.standardworkflow.FolderWorkflowPlugin.java

License:Apache License

public FolderWorkflowPlugin(IPluginContext context, final IPluginConfig config) {
    super(context, config);

    add(new Label("new"));

    try {/*from  w  w  w . java2 s.  c  o  m*/
        WorkflowDescriptorModel model = getModel();
        List<StdWorkflow> list = new LinkedList<>();
        WorkflowDescriptor descriptor = model.getObject();
        WorkflowManager manager = UserSession.get().getWorkflowManager();
        Workflow workflow = manager.getWorkflow(descriptor);
        final Map<String, Serializable> hints = workflow.hints();

        if (isActionAvailable("rename", hints)) {
            add(new StdWorkflow("rename", new StringResourceModel("rename-title", this, null), context,
                    getModel()) {
                private RenameDocumentArguments renameDocumentArguments = new RenameDocumentArguments();

                @Override
                protected Component getIcon(final String id) {
                    return HippoIcon.fromSprite(id, Icon.TYPE);
                }

                @Override
                protected Dialog createRequestDialog() {

                    try {
                        HippoNode node = (HippoNode) ((WorkflowDescriptorModel) getDefaultModel()).getNode();
                        renameDocumentArguments.setUriName(node.getName());
                        renameDocumentArguments.setTargetName(node.getDisplayName());
                        renameDocumentArguments.setNodeType(node.getPrimaryNodeType().getName());
                    } catch (RepositoryException ex) {
                        log.error("Could not retrieve workflow document", ex);
                        renameDocumentArguments.setUriName(StringUtils.EMPTY);
                        renameDocumentArguments.setTargetName(StringUtils.EMPTY);
                        renameDocumentArguments.setNodeType(null);
                    }

                    return newRenameDocumentDialog(renameDocumentArguments, this);
                }

                @Override
                protected void execute(WorkflowDescriptorModel model) throws Exception {
                    // FIXME: this assumes that folders are always embedded in other folders
                    // and there is some logic here to look up the parent.  The real solution is
                    // in the visual component to merge two workflows.
                    HippoNode node = (HippoNode) model.getNode();
                    String nodeName = getNodeNameCodec(node).encode(renameDocumentArguments.getUriName());
                    String localName = getLocalizeCodec().encode(renameDocumentArguments.getTargetName());
                    WorkflowManager manager = UserSession.get().getWorkflowManager();
                    DefaultWorkflow defaultWorkflow = (DefaultWorkflow) manager.getWorkflow("core", node);
                    FolderWorkflow folderWorkflow = (FolderWorkflow) manager.getWorkflow("embedded",
                            node.getParent());
                    if (!((WorkflowDescriptorModel) getDefaultModel()).getNode().getName().equals(nodeName)) {
                        folderWorkflow.rename(
                                node.getName() + (node.getIndex() > 1 ? "[" + node.getIndex() + "]" : ""),
                                nodeName);
                    }
                    if (!node.getDisplayName().equals(localName)) {
                        defaultWorkflow.setDisplayName(localName);
                    }
                }
            });
        }

        if (isActionAvailable("reorder", hints)) {
            add(new StdWorkflow("reorder", new StringResourceModel("reorder-folder", this, null), context,
                    getModel()) {
                public List<String> order = new LinkedList<>();

                @Override
                protected Component getIcon(final String id) {
                    return HippoIcon.fromSprite(id, Icon.SORT);
                }

                @Override
                protected Dialog createRequestDialog() {
                    return new ReorderDialog(this, config, getModel(), order);
                }

                @Override
                protected void execute(WorkflowDescriptorModel model) throws Exception {
                    WorkflowManager manager = UserSession.get().getWorkflowManager();
                    FolderWorkflow workflow = (FolderWorkflow) manager.getWorkflow(model.getObject());
                    workflow.reorder(order);
                }
            });
        }

        if (isActionAvailable("delete", hints)) {
            add(new StdWorkflow("delete", new StringResourceModel("delete-title", this, null), context,
                    getModel()) {

                @Override
                protected Component getIcon(final String id) {
                    return HippoIcon.fromSprite(id, Icon.TIMES);
                }

                @Override
                protected Dialog createRequestDialog() {
                    Node folderNode = null;
                    try {
                        folderNode = getModel().getNode();
                    } catch (RepositoryException e) {
                        log.error(
                                "Unable to retrieve node from WorkflowDescriptorModel, folder delete cancelled",
                                e);
                    }

                    if (folderNode != null) {
                        try {
                            final IModel<String> folderName = new NodeNameModel(new JcrNodeModel(folderNode));
                            boolean deleteAllowed = true;
                            for (NodeIterator iter = folderNode.getNodes(); iter.hasNext();) {
                                Node child = iter.nextNode();
                                NodeDefinition nd = child.getDefinition();
                                if (nd.getDeclaringNodeType().isMixin()) {
                                    continue;
                                }
                                deleteAllowed = false;
                                break;
                            }
                            StringResourceModel messageModel = new StringResourceModel(
                                    deleteAllowed ? "delete-message-extended" : "delete-message-denied",
                                    FolderWorkflowPlugin.this, null, folderName);
                            return new DeleteDialog(this, messageModel, deleteAllowed);

                        } catch (RepositoryException e) {
                            log.error(
                                    "Unable to retrieve number of child nodes from node, folder delete cancelled",
                                    e);
                        }
                    }

                    final StringResourceModel notificationModel = new StringResourceModel(
                            "delete-message-error", FolderWorkflowPlugin.this, null);
                    return new DeleteDialog(this, notificationModel, false);
                }

                class DeleteDialog extends WorkflowDialog<Void> {

                    public DeleteDialog(IWorkflowInvoker invoker, IModel<String> notification,
                            boolean deleteAllowed) {
                        super(invoker);

                        setSize(DialogConstants.SMALL_AUTO);
                        setNotification(notification);

                        if (deleteAllowed) {
                            setFocusOnOk();
                        } else {
                            setOkEnabled(false);
                            setFocusOnCancel();
                        }
                    }

                    @Override
                    public IModel<String> getTitle() {
                        return new StringResourceModel("delete-title", FolderWorkflowPlugin.this, null);
                    }
                }

                @Override
                public void execute(WorkflowDescriptorModel model) throws Exception {
                    // FIXME: this assumes that folders are always embedded in other folders
                    // and there is some logic here to look up the parent.  The real solution is
                    // in the visual component to merge two workflows.
                    Node node = model.getNode();
                    WorkflowManager manager = UserSession.get().getWorkflowManager();
                    FolderWorkflow workflow = (FolderWorkflow) manager.getWorkflow("embedded",
                            node.getParent());
                    workflow.delete(node.getName() + (node.getIndex() > 1 ? "[" + node.getIndex() + "]" : ""));
                }
            });
        }

        final Set<String> translated = new TreeSet<>();
        if (getPluginConfig().containsKey("workflow.translated")) {
            Collections.addAll(translated, getPluginConfig().getStringArray("workflow.translated"));
        }

        if (isActionAvailable("add", hints) && hints.containsKey("prototypes")) {
            final Map<String, Set<String>> prototypes = (Map<String, Set<String>>) hints.get("prototypes");
            for (final String category : prototypes.keySet()) {
                IModel<String> categoryLabel = new StringResourceModel("add-category", this, null,
                        new ResourceBundleModel(HIPPO_TEMPLATES_BUNDLE_NAME, category));

                final StdWorkflow<FolderWorkflow> stdWorkflow = new StdWorkflow<FolderWorkflow>("id",
                        categoryLabel, getPluginContext(), model) {

                    AddDocumentArguments addDocumentModel = new AddDocumentArguments();

                    @Override
                    protected Dialog createRequestDialog() {
                        return createAddDocumentDialog(addDocumentModel, category, prototypes.get(category),
                                translated.contains(category), this);
                    }

                    @Override
                    protected Component getIcon(final String id) {
                        final String pngName = category + "-16";
                        final String svgName = category + "-" + IconSize.M.name().toLowerCase();

                        // Override using inline SVG icon
                        ResourceReference iconResource = new PackageResourceReference(getClass(),
                                svgName + ".svg");
                        if (!resourceExists(iconResource)) {
                            // Override using PNG icon
                            iconResource = new PackageResourceReference(getClass(), pngName + ".png");
                        }

                        if (resourceExists(iconResource)) {
                            // Return override icon
                            return HippoIcon.fromResource(id, iconResource);
                        }

                        // Try to match svgName with a built-in Icon
                        final String iconName = StringUtils.replace(svgName, "-", "_").toUpperCase();
                        for (Icon icon : Icon.values()) {
                            if (icon.name().equals(iconName)) {
                                return HippoIcon.fromSprite(id, icon);
                            }
                        }

                        // Fallback to default icon
                        HippoIconStack defaultIcon = new HippoIconStack(id, IconSize.M);
                        defaultIcon.addFromSprite(category.endsWith("-folder") ? Icon.FOLDER : Icon.FILE);
                        defaultIcon.addFromCms(CmsIcon.OVERLAY_PLUS, IconSize.M, Position.TOP_LEFT);
                        return defaultIcon;
                    }

                    private boolean resourceExists(final ResourceReference reference) {
                        return !(reference.getResource() == null || (reference
                                .getResource() instanceof PackageResource
                                && ((PackageResource) reference.getResource()).getResourceStream() == null));
                    }

                    @Override
                    protected String execute(FolderWorkflow workflow) throws Exception {
                        if (addDocumentModel.getPrototype() == null) {
                            throw new IllegalArgumentException("You need to select a type");
                        }
                        if (addDocumentModel.getTargetName() == null
                                || "".equals(addDocumentModel.getTargetName())) {
                            throw new IllegalArgumentException("You need to enter a name");
                        }
                        if (addDocumentModel.getUriName() == null || "".equals(addDocumentModel.getUriName())) {
                            throw new IllegalArgumentException("You need to enter a URL name");
                        }
                        if (workflow != null) {
                            if (!prototypes.get(category).contains(addDocumentModel.getPrototype())) {
                                log.error("unknown folder type " + addDocumentModel.getPrototype());
                                return "Unknown folder type " + addDocumentModel.getPrototype();
                            }
                            String nodeName = getNodeNameCodec(getModel().getNode())
                                    .encode(addDocumentModel.getUriName());
                            String localName = getLocalizeCodec().encode(addDocumentModel.getTargetName());
                            if ("".equals(nodeName)) {
                                throw new IllegalArgumentException("You need to enter a name");
                            }

                            TreeMap<String, String> arguments = new TreeMap<>();
                            arguments.put("name", nodeName);
                            arguments.put("localName", localName);
                            if (StringUtils.isNotBlank(addDocumentModel.getLanguage())) {
                                arguments.put(HippoTranslationNodeType.LOCALE, addDocumentModel.getLanguage());
                            }
                            String path = workflow.add(category, addDocumentModel.getPrototype(), arguments);
                            onWorkflowAdded(path);
                            JcrNodeModel nodeModel = new JcrNodeModel(path);
                            if (!nodeName.equals(localName)) {
                                WorkflowManager workflowMgr = UserSession.get().getWorkflowManager();
                                DefaultWorkflow defaultWorkflow = (DefaultWorkflow) workflowMgr
                                        .getWorkflow("core", nodeModel.getNode());
                                defaultWorkflow.setDisplayName(localName);
                            }
                            select(nodeModel);
                        } else {
                            log.error("no workflow defined on model for selected node");
                        }
                        return null;
                    }
                };
                list.add(stdWorkflow);
            }
        }
        AbstractView add;
        replace(add = new AbstractView<StdWorkflow>("new", createListDataProvider(list)) {

            @Override
            protected void populateItem(Item<StdWorkflow> item) {
                item.add(item.getModelObject());
            }
        });
        add.populate();
    } catch (RepositoryException | RemoteException | WorkflowException ex) {
        log.error(ex.getClass().getName() + ": " + ex.getMessage());
    }
}

From source file:org.hippoecm.frontend.translation.LocaleImageService.java

License:Apache License

@Override
public void onRequest() {
    if (provider == null) {
        throw new WicketRuntimeException("No locale provider available");
    }// www.ja va  2s  .  co  m
    RequestCycle rc = RequestCycle.get();
    StringValue language = rc.getRequest().getRequestParameters().getParameterValue("lang");
    ResourceReference resourceRef = provider.getLocale(language.toString()).getIcon(IconSize.M,
            LocaleState.EXISTS);
    rc.scheduleRequestHandlerAfterCurrent(new ResourceRequestHandler(resourceRef.getResource(), null));
}

From source file:org.wicketTutorial.resmounting.WicketApplication.java

License:Apache License

/**
 * @see org.apache.wicket.Application#init()
 *//*from ww w.  ja  v  a 2  s  .c  o m*/
@Override
public void init() {
    super.init();
    ResourceReference resourceReference = new ResourceReference("rssProducer") {
        RSSProducerResource deviceMetaResource = new RSSProducerResource();

        @Override
        public IResource getResource() {
            return deviceMetaResource;
        }
    };

    mountResource("/foo/bar", resourceReference);
    mountResource("/bar/${baz}", resourceReference);
    getSharedResources().add("globalRSSProducer", resourceReference.getResource());

}