@Override
 public Iterator<EntityReference> listData() {
   try {
     List<Object[]> data = this.docStore.search(DATA_REFERENCE_QUERY, 0, 0, this.context.get());
     return new ReferenceIterator(data);
   } catch (XWikiException ex) {
     this.logger.warn("Failed to list the database deleted attachments: {}", ex.getMessage());
     return Collections.emptyIterator();
   }
 }
예제 #2
0
 /**
  * Trigger a BaseObject job (execute it now).
  *
  * @param object the BaseObject Job to be triggered
  * @return true on success, false on failure.
  */
 public boolean triggerJob(BaseObject object) {
   try {
     getProtectedPlugin().triggerJob(object, this.context);
     LOGGER.debug("Trigger Job: [{}]", object.getStringValue("jobName"));
     return true;
   } catch (XWikiException e) {
     this.context.put("error", e.getMessage());
     return false;
   }
 }
 @Override
 public boolean hasData() {
   try {
     return !this.docStore.search(DATA_RETRIEVE_QUERY, 1, 0, this.context.get()).isEmpty();
   } catch (XWikiException ex) {
     this.logger.warn(
         "Failed to search for deleted attachments in the database trash: {}", ex.getMessage());
     return false;
   }
 }
 public void addWriter(String spaceName, String userName, boolean allowDowngrade) {
   if (hasProgrammingRights()) {
     try {
       getWorkspacesManager().addWriter(spaceName, userName, allowDowngrade, context);
     } catch (XWikiException e) {
       context.put("haserror", "1");
       context.put("lasterror", e.getMessage());
     }
   }
 }
 /** Remove a reader from a workspace, removing him as a member too */
 public void removeReader(String spaceName, String userName) {
   if (hasProgrammingRights()) {
     try {
       getWorkspacesManager().removeReader(spaceName, userName, context);
     } catch (XWikiException e) {
       context.put("haserror", "1");
       context.put("lasterror", e.getMessage());
     }
   }
 }
 @Override
 public Iterator<DeletedAttachment> getData() {
   try {
     List<Long> data = this.docStore.search(DATA_RETRIEVE_QUERY, 0, 0, this.context.get());
     this.logger.debug("Found [{}] deleted attachments in the database trash", data.size());
     return new DeletedAttachmentIterator(data);
   } catch (XWikiException ex) {
     this.logger.warn(
         "Failed to get the list of database deleted attachments: {}", ex.getMessage());
     return Collections.emptyIterator();
   }
 }
 /**
  * Loops over the {@code rightsCombinations} and attaches a new rights object for each combination
  * to the document.
  *
  * @param rightsCombinations the string array containing all the combinations for which there
  *     should be an object created
  * @param rightsObjects the map of existing rights objects
  * @param doc XWikiDocument
  * @param context XWikiContext
  */
 private void createRights(
     List<String> rightsCombinations,
     Map<String, BaseObject> rightsObjects,
     XWikiDocument doc,
     XWikiContext context) {
   for (String rights : rightsCombinations) {
     try {
       BaseObject newRightObject = doc.newXObject(RIGHTS_CLASS, context);
       newRightObject.setStringValue("levels", rights);
       newRightObject.setIntValue("allow", 1);
       rightsObjects.put(rights, newRightObject);
     } catch (XWikiException ex) {
       this.logger.error("Failed to create rights: {}", ex.getMessage(), ex);
     }
   }
 }
 @Override
 public boolean discardAllData() {
   boolean transaction = false;
   try {
     transaction = ((XWikiHibernateBaseStore) this.store).beginTransaction(this.context.get());
     Session session = ((XWikiHibernateBaseStore) this.store).getSession(this.context.get());
     session.createQuery("delete from DeletedAttachment").executeUpdate();
   } catch (XWikiException ex) {
     this.logger.warn(
         "Failed to cleanup all attachments from the database trash: {}", ex.getMessage());
     return false;
   } finally {
     if (transaction) {
       ((XWikiHibernateBaseStore) this.store).endTransaction(this.context.get(), transaction);
     }
   }
   return true;
 }
 @Override
 public boolean discardEntity(DeletedAttachment entity) {
   boolean transaction = false;
   try {
     transaction = ((XWikiHibernateBaseStore) this.store).beginTransaction(this.context.get());
     Session session = ((XWikiHibernateBaseStore) this.store).getSession(this.context.get());
     session.delete(entity);
     this.logger.debug(
         "Deleted deleted attachment [{}@{}#{}] from the database trash",
         entity.getDocName(),
         entity.getFilename(),
         entity.getId());
   } catch (XWikiException ex) {
     this.logger.warn("Failed to cleanup attachment from the database trash: {}", ex.getMessage());
     return false;
   } finally {
     if (transaction) {
       ((XWikiHibernateBaseStore) this.store).endTransaction(this.context.get(), transaction);
     }
   }
   return true;
 }
  @Override
  public Representation represent(Variant variant) throws ResourceException {
    setupXWiki();

    Request request = getRequest();
    String assetName = (String) request.getAttributes().get("assetName");
    String textId = (String) request.getAttributes().get("textId");
    // if (!textId.equals("0")) {
    //    throw error(Status.CLIENT_ERROR_NOT_FOUND, "An asset may only have one viditalk movie");
    // }

    TextAsset asset = null;
    try {
      asset = (TextAsset) plugin.fetchAssetAs(assetName, TextAsset.class);
    } catch (XWikiException e) {
      throw error(Status.CLIENT_ERROR_NOT_FOUND, e.getMessage());
    }
    if (asset == null) {
      throw error(Status.CLIENT_ERROR_NOT_FOUND, "Asset " + assetName + " not found.");
    }

    String content = null;
    String syntax = null;
    try {
      content = asset.getText();
      syntax = asset.getTextSyntax();
    } catch (XWikiException e) {
      throw error(Status.CLIENT_ERROR_NOT_FOUND, "No texts found for " + assetName);
    }

    JSONObject json = new JSONObject();
    json.put("text", content);
    json.put("syntax", syntax);

    return formatJSON(json, variant);
  }
예제 #11
0
 public void update() {
   if (!stopUpdate) {
     if (updateInProgress == false) {
       updateInProgress = true;
       nbLoadedFeeds = 0;
       nbLoadedFeedsErrors = 0;
       exception = null;
       nbLoadedArticles = 0;
       endDate = null;
       startDate = new Date();
       XWikiContext context = getXWikiContext();
       try {
         // Make sure store sessions are cleaned up
         context.getWiki().getStore().cleanUp(context);
         // update the feeds
         nbLoadedArticles =
             feedPlugin.updateFeedsInSpace(space, fullContent, true, false, context);
       } catch (XWikiException e) {
         exception = e;
         e.printStackTrace();
       } finally {
         updateInProgress = false;
         endDate = new Date();
         context.getWiki().getStore().cleanUp(context);
       }
       // an update has been schedule..
       if ((forceUpdate == true) && (stopUpdate == false)) {
         forceUpdate = false;
         update();
       }
     } else {
       // let's schedule an update at the end of the current update
       forceUpdate = true;
     }
   }
 }
예제 #12
0
  public ActionForward execute(XWikiContext context) throws Exception {
    MonitorPlugin monitor = null;
    FileUploadPlugin fileupload = null;
    String docName = "";

    try {
      String action = context.getAction();

      // Initialize context.getWiki() with the main wiki
      XWiki xwiki;

      // Verify that the requested wiki exists
      try {
        xwiki = XWiki.getXWiki(this.waitForXWikiInitialization, context);

        // If XWiki is still initializing display initialization template
        if (xwiki == null) {
          // Display initialization template
          renderInit(context);

          // Initialization template has been displayed, stop here.
          return null;
        }
      } catch (XWikiException e) {
        // If the wiki asked by the user doesn't exist, then we first attempt to use any existing
        // global
        // redirects. If there are none, then we display the specific error template.
        if (e.getCode() == XWikiException.ERROR_XWIKI_DOES_NOT_EXIST) {
          xwiki = XWiki.getMainXWiki(context);

          // Initialize the url factory
          XWikiURLFactory urlf =
              xwiki.getURLFactoryService().createURLFactory(context.getMode(), context);
          context.setURLFactory(urlf);

          // Initialize the velocity context and its bindings so that it may be used in the velocity
          // templates
          // that we
          // are parsing below.
          VelocityManager velocityManager = Utils.getComponent(VelocityManager.class);
          VelocityContext vcontext = velocityManager.getVelocityContext();

          if (!sendGlobalRedirect(context.getResponse(), context.getURL().toString(), context)) {
            // Starting XWiki 5.0M2, 'xwiki.virtual.redirect' was removed. Warn users still using
            // it.
            if (!StringUtils.isEmpty(context.getWiki().Param("xwiki.virtual.redirect"))) {
              LOGGER.warn(
                  String.format(
                      "%s %s",
                      "'xwiki.virtual.redirect' is no longer supported.",
                      "Please update your configuration and/or see XWIKI-8914 for more details."));
            }

            // Display the error template only for actions that are not ignored
            if (!ACTIONS_IGNORED_WHEN_WIKI_DOES_NOT_EXIST.contains(action)) {

              // Add localization resources to the context
              xwiki.prepareResources(context);

              // Set the main home page in the main space of the main wiki as the current requested
              // entity
              // since we cannot set the non existing one as it would generate errors obviously...
              EntityReferenceValueProvider valueProvider =
                  Utils.getComponent(EntityReferenceValueProvider.class);
              xwiki.setPhonyDocument(
                  new DocumentReference(
                      valueProvider.getDefaultValue(EntityType.WIKI),
                      valueProvider.getDefaultValue(EntityType.SPACE),
                      valueProvider.getDefaultValue(EntityType.DOCUMENT)),
                  context,
                  vcontext);

              // Parse the error template
              Utils.parseTemplate(
                  context.getWiki().Param("xwiki.wiki_exception", "wikidoesnotexist"), context);

              // Error template was displayed, stop here.
              return null;
            }

            // At this point, we allow regular execution of the ignored action because even if the
            // wiki
            // does not exist, we still need to allow UI resources to be retrieved (from the
            // filesystem
            // and the main wiki) or our error template will not be rendered properly.

            // Proceed with serving the main wiki

          } else {
            // Global redirect was executed, stop here.
            return null;
          }
        } else {
          LOGGER.error("Uncaught exception during XWiki initialisation:", e);
          throw e;
        }
      }

      // Send global redirection (if any)
      if (sendGlobalRedirect(context.getResponse(), context.getURL().toString(), context)) {
        return null;
      }

      XWikiURLFactory urlf =
          xwiki.getURLFactoryService().createURLFactory(context.getMode(), context);
      context.setURLFactory(urlf);

      String sajax = context.getRequest().get("ajax");
      boolean ajax = false;
      if (sajax != null && !sajax.trim().equals("") && !sajax.equals("0")) {
        ajax = true;
      }
      context.put("ajax", ajax);

      // Any error before this will be treated using a redirection to an error page

      if (monitor != null) {
        monitor.startTimer("request");
      }

      VelocityManager velocityManager = Utils.getComponent(VelocityManager.class);
      VelocityContext vcontext = velocityManager.getVelocityContext();

      boolean eventSent = false;
      try {
        // Prepare documents and put them in the context
        if (!xwiki.prepareDocuments(context.getRequest(), context, vcontext)) {
          return null;
        }

        // Start monitoring timer
        monitor = (MonitorPlugin) xwiki.getPlugin("monitor", context);
        if (monitor != null) {
          monitor.startRequest("", context.getAction(), context.getURL());
          monitor.startTimer("multipart");
        }

        // Parses multipart so that params in multipart are available for all actions
        fileupload = Utils.handleMultipart(context.getRequest().getHttpServletRequest(), context);
        if (monitor != null) {
          monitor.endTimer("multipart");
        }

        if (monitor != null) {
          monitor.setWikiPage(context.getDoc().getFullName());
        }

        // Let's handle the notification and make sure it never fails
        if (monitor != null) {
          monitor.startTimer("prenotify");
        }

        // For the moment we're sending the XWiki context as the data, but this will be
        // changed in the future, when the whole platform will be written using components
        // and there won't be a need for the context.
        try {
          ObservationManager om = Utils.getComponent(ObservationManager.class);
          ActionExecutingEvent event = new ActionExecutingEvent(context.getAction());
          om.notify(event, context.getDoc(), context);
          eventSent = true;
          if (event.isCanceled()) {
            // Action has been canceled
            // TODO: do something special ?
            return null;
          }
        } catch (Throwable ex) {
          LOGGER.error(
              "Cannot send action notifications for document ["
                  + context.getDoc()
                  + " using action ["
                  + context.getAction()
                  + "]",
              ex);
        }

        if (monitor != null) {
          monitor.endTimer("prenotify");
        }

        // Call the Actions

        // Call the new Entity Resource Reference Handler.
        ResourceReferenceHandler entityResourceReferenceHandler =
            Utils.getComponent(
                new DefaultParameterizedType(
                    null, ResourceReferenceHandler.class, ResourceType.class),
                "bin");
        ResourceReference resourceReference =
            Utils.getComponent(ResourceReferenceManager.class).getResourceReference();
        try {
          entityResourceReferenceHandler.handle(
              resourceReference,
              new DefaultResourceReferenceHandlerChain(
                  Collections.<ResourceReferenceHandler>emptyList()));
          // Don't let the old actions kick in!
          return null;
        } catch (NotFoundResourceHandlerException e) {
          // No Entity Resource Action has been found. Don't do anything and let it go through
          // so that the old Action system kicks in...
        } catch (Throwable e) {
          // Some real failure, log it since it's a problem but still allow the old Action system a
          // chance
          // to do something...
          LOGGER.error("Failed to handle Action for Resource [{}]", resourceReference, e);
        }

        // Then call the old Actions for backward compatibility (and because a lot of them have not
        // been
        // migrated to new Actions yet).
        String renderResult = null;
        XWikiDocument doc = context.getDoc();
        docName = doc.getFullName();
        if (action(context)) {
          renderResult = render(context);
        }

        if (renderResult != null) {
          if (doc.isNew()
              && "view".equals(context.getAction())
              && !"recyclebin".equals(context.getRequest().get("viewer"))) {
            String page = Utils.getPage(context.getRequest(), "docdoesnotexist");
            Utils.parseTemplate(page, context);
          } else {
            String page = Utils.getPage(context.getRequest(), renderResult);
            Utils.parseTemplate(page, !page.equals("direct"), context);
          }
        }
        return null;
      } catch (Throwable e) {
        if (e instanceof IOException) {
          e =
              new XWikiException(
                  XWikiException.MODULE_XWIKI_APP,
                  XWikiException.ERROR_XWIKI_APP_SEND_RESPONSE_EXCEPTION,
                  "Exception while sending response",
                  e);
        }

        if (!(e instanceof XWikiException)) {
          e =
              new XWikiException(
                  XWikiException.MODULE_XWIKI_APP,
                  XWikiException.ERROR_XWIKI_UNKNOWN,
                  "Uncaught exception",
                  e);
        }

        try {
          XWikiException xex = (XWikiException) e;
          if (xex.getCode() == XWikiException.ERROR_XWIKI_APP_SEND_RESPONSE_EXCEPTION) {
            // Connection aborted from the client side, there's not much we can do on the server
            // side. We
            // simply ignore it.
            LOGGER.debug("Connection aborted", e);
            // We don't write any other message to the response, as the connection is broken,
            // anyway.
            return null;
          } else if (xex.getCode() == XWikiException.ERROR_XWIKI_ACCESS_DENIED) {
            Utils.parseTemplate(
                context.getWiki().Param("xwiki.access_exception", "accessdenied"), context);
            return null;
          } else if (xex.getCode() == XWikiException.ERROR_XWIKI_USER_INACTIVE) {
            Utils.parseTemplate(
                context.getWiki().Param("xwiki.user_exception", "userinactive"), context);
            return null;
          } else if (xex.getCode() == XWikiException.ERROR_XWIKI_APP_ATTACHMENT_NOT_FOUND) {
            context.put("message", "attachmentdoesnotexist");
            Utils.parseTemplate(
                context.getWiki().Param("xwiki.attachment_exception", "attachmentdoesnotexist"),
                context);
            return null;
          } else if (xex.getCode() == XWikiException.ERROR_XWIKI_APP_URL_EXCEPTION) {
            vcontext.put("message", context.getMessageTool().get("platform.core.invalidUrl"));
            xwiki.setPhonyDocument(
                xwiki.getDefaultSpace(context) + "." + xwiki.getDefaultPage(context),
                context,
                vcontext);
            context.getResponse().setStatus(HttpServletResponse.SC_BAD_REQUEST);
            Utils.parseTemplate(
                context.getWiki().Param("xwiki.invalid_url_exception", "error"), context);
            return null;
          }
          vcontext.put("exp", e);
          if (LOGGER.isWarnEnabled()) {
            // Don't log "Broken Pipe" exceptions since they're not real errors and we don't want to
            // pollute
            // the logs with unnecessary stack traces. It just means the client side has cancelled
            // the
            // connection.
            if (ExceptionUtils.getRootCauseMessage(e).equals("IOException: Broken pipe")) {
              return null;
            }
            LOGGER.warn("Uncaught exception: " + e.getMessage(), e);
          }
          // If the request is an AJAX request, we don't return a whole HTML page, but just the
          // exception
          // inline.
          String exceptionTemplate = ajax ? "exceptioninline" : "exception";
          Utils.parseTemplate(Utils.getPage(context.getRequest(), exceptionTemplate), context);
          return null;
        } catch (XWikiException ex) {
          if (ex.getCode() == XWikiException.ERROR_XWIKI_APP_SEND_RESPONSE_EXCEPTION) {
            LOGGER.error("Connection aborted");
          }
        } catch (Exception e2) {
          // I hope this never happens
          LOGGER.error("Uncaught exceptions (inner): ", e);
          LOGGER.error("Uncaught exceptions (outer): ", e2);
        }
        return null;
      } finally {
        // Let's make sure we have flushed content and closed
        try {
          context.getResponse().getWriter().flush();
        } catch (Throwable e) {
          // This might happen if the connection was closed, for example.
          // If we can't flush, then there's nothing more we can send to the client.
        }

        if (monitor != null) {
          monitor.endTimer("request");
          monitor.startTimer("notify");
        }

        if (eventSent) {
          // For the moment we're sending the XWiki context as the data, but this will be
          // changed in the future, when the whole platform will be written using components
          // and there won't be a need for the context.
          try {
            ObservationManager om = Utils.getComponent(ObservationManager.class);
            om.notify(new ActionExecutedEvent(context.getAction()), context.getDoc(), context);
          } catch (Throwable ex) {
            LOGGER.error(
                "Cannot send action notifications for document ["
                    + docName
                    + " using action ["
                    + context.getAction()
                    + "]",
                ex);
          }
        }

        if (monitor != null) {
          monitor.endTimer("notify");
        }

        // Make sure we cleanup database connections
        // There could be cases where we have some
        if ((context != null) && (xwiki != null)) {
          xwiki.getStore().cleanUp(context);
        }
      }
    } finally {
      // End request
      if (monitor != null) {
        monitor.endRequest();
      }

      if (context != null) {

        if (fileupload != null) {
          fileupload.cleanFileList(context);
        }
      }
    }
  }