Many resources support a common set of request query parameters. For example, when retrieving a collection of entities, it is common to change the shape of the results set by limiting the quantity or details of the results. The REST framework uses the following request parameters to scope results and provide security:

• startIndex - Specifies the index of the first matching result that should be included in the result set (0-n ... zero based). This is used for pagination.

• itemsPerPage - Specifies the maximum number of results to return in the response (1-n). This is used for pagination.

• q - Specifies implementation-specific searching. Searches may be specified using the following format (square brackets [] denote optional values):

  [[field1:[operand]][:]value1[;field2:operand:value2]]
  

  For example:

  &q=login:equals:monty
  &q=title:contains:issues
  &q=creator:equals:monty;description:contains:Urgent
  

  While each resource uses the same format for the q parameter, the way search is implemented is different depending on the resource being searched. For more information about how each resource implements search, see the topic for the specific service.

• projection - Reserved for implementation-specific projection of model representations, such as variable recursion depth, field or attribute filtering. Valid values are summary or details.

  For example, requesting a projection of summary for a collection of lists, returns only the title, description, and hypermedia links. Requesting a projection of details results in the server sending back a collection of lists that includes all the column metadata for each list. This may require additional processing time or database queries on the server.

  The following example request results in the response entity containing a deeper object graph.

  http://host:port/...lists&projection=details
  

• data - This parameter accepts a comma separated list of data sets and items. This parameter lets clients specify what data they would like to receive. For example, a mobile device application might use this parameter to limit the amount of XML data returned. If both the projection and data query string parameters are present, the data parameter will be used to determine which data to return. If you specify the constant 'data' as the data parameter, all the standard information will be returned for the resource.

For information about how these parameters are supported by specific resources, see the topic for the appropriate service.

The owner of a message board can mark any message as private. When a message is marked as private, that message is not visible to anyone other than the owner of the message. By default, all messages are public.

Messages can also be sent as private messages. If Mike, for example, is viewing Carl's message board, only public messages (including those sent or received as private) will be visible to user Mike.

The owner of a message board can mark any message as hidden. When a message is marked as hidden, that message will not be visible to the message board's owner, but will remain visible to anyone else viewing that person's message board.

The following examples show how to retrieve,

Example: Retrieving Filtered Messages (GET)

• me

     all
       rest/api/messageBoards/person/@me 
     private
       rest/api/messageBoards/person/@me/private
     public
       rest/api/messageBoards/person/@me/public
     hidden and public
       rest/api/messageBoards/person/@me/hidden 
     private and hidden
       rest/api/messageBoards/person/@me/private_hidden
  

• person

     rest/api/messageBoards/person/<GUID> 
  

  Note that the GUID of the logged in user for whom to retrieve messages is required.

• space-guid

     rest/api/messageBoards/space/<GUID>
  

  Note that visibility-based filtering is not available for space-guid.

Example: Using Filtering for New Messages (POST)

• me

     all
       rest/api/messageBoards/person/@me 
     private
       {"body" : "<BODY_CONTENT>","visibilityType" : "private"}
     public
       {"body" : "<BODY_CONTENT>","visibilityType" : "public"}
     hidden and public
      {"body" : "<BODY_CONTENT>","visibilityType" : "hidden"}
     private and hidden
       {"body" : "<BODY_CONTENT>","visibilityType" : "private_hidden"}
  

• person

     rest/api/messageBoards/person/<GUID> 
  

  For a GUID other than that of "me":

     public 
       {"body" : "<BODY_CONTENT>","visibilityType" : "public"}
     private
       {"body" : "<BODY_CONTENT>","visibilityType" : "private"}
  

• space-guid

     rest/api/messageBoards/space/<GUID>
  

  Note that visibility-based filtering is not available for space-guid.

Example: Using Filtering for Modified Messages (PUT)

• me

     all
       rest/api/messageBoards/person/@me/messages/<msg guid>
     private
       {"body" : "<BODY_CONTENT>","visibilityType" : "private"}
     public
       {"body" : "<BODY_CONTENT>","visibilityType" : "public"}
     hidden and public
      {"body" : "<BODY_CONTENT>","visibilityType" : "hidden"}
     private and hidden
       {"body" : "<BODY_CONTENT>","visibilityType" : "private_hidden"}
  

• person

     rest/api/messageBoards/person/<GUID>/messages/<msg guid>
  

  For a GUID other than that of "me":

     public 
       {"body" : "<BODY_CONTENT>","visibilityType" : "public"}
     private
       {"body" : "<BODY_CONTENT>","visibilityType" : "private"}
  

• space-guid

     rest/api/messageBoards/space/<GUID>/messages/<msg guid>
  

  Note that visibility-based filtering is not available for space-guid.

The stream response contains URIs for use in retrieving activities from the Activity Stream.

You can retrieve the activities from a user's stream or activities from a user's connections' streams. To have even greater control over which activities to retrieve, use the activity stream query filter. With the query filter, you can:

• Specify the user to query

• Include the user's connections' activities in the results

• Include activities from portals, including the Home portal, in the results

• Restrict the results to activities from specific services

The options available to you depend on the path you take to get to the stream resource and the rel of the link that you use. For example, the activity stream query filter is available only from links with a rel attribute of urn:oracle:webcenter:activities:stream. If you access the activity stream query filter from the person resource, the personGuid parameter is prefilled.

Table C-4 shows the activities returned depending on the rel element of the link.

^Footnote 1

GUID can be any valid user GUID or @me.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceIndex
   stream (rel="urn:oracle:webcenter:activities:stream:person" or
               "urn:oracle:webcenter:activities:stream")

resourceIndex
   person
      stream (rel="urn:oracle:webcenter:activities:stream:person" or
                  "urn:oracle:webcenter:activities:stream:connections" or
                  "urn:oracle:webcenter:activities:stream")

resourceIndex
   person
      list
         stream

resourceIndex
   space
      stream

stream
   activity
      param
         stream (rel="urn:oracle:webcenter:activities:stream:space")

personReference
   stream

The following method is supported by the stream resource:

• GET

  • request—Parameters:

    • startIndex, itemsPerPage

    See Also:

    For information about REST API parameters, such as startIndex and itemsPerPage, see Common Request Query Parameters.

    The following additional parameters are available for the query filter URI:

    • fromDate – Specifies activities start date (yyyy-mm-dd).

    • toDate – Specifies activities end date, (yyyy-mm-dd).

    • data – Returns specified data only (for more information, see Common Request Query Parameters). For the stream resource, if you specify the constant 'data' as the data parameter, all of the basic information about the resource is returned except "comments" and "likes" summaries. If you want to return comments or likes, specify the data parameter value 'commentsSummary' or 'likesSummary'.

      Note:

      You can specify multiple data values as a comma separated list. For example, data=data, commentsSummary.

    • personGuid – (Required) Retrieves activities from the stream for the specified user. Valid values: any valid user GUID or @me.

    • serviceIds – Retrieves activities only for the specified services. Valid values: An asterisk (*) returns all services. If null or empty, uses the user preference settings for service filters (from the settings link in the top bar).

    • personal – Includes the specified user's activities in the Home portal. Valid values: true or false. Default value: false.

    • connections – Includes activities from the streams of the specified user's connections. Valid values: true or false. Default value: false.

    • groupSpaces – Includes activities from all portals of which the specified user is a member. Valid values: true or false. Default value: false.

    • connectionListIds – A comma separated list of connection list names that specifies the connection lists used to show activities.

    • groupSpaceGuids – A comma separated list of portal GUIDs used to show activities.

    • userGroupSpaceActivities – Specifies whether or not to show the user's activities in their portal. Valid values: true or false. Default value: false.

    • followedObjects – Specifies whether or not to show all activities for followed objects that both the current user and the specified user follow. Valid values: true or false. Default value: false.

    • followedObjectsUserActivities – Specifies whether or not to show the specified user's activities for followed objects that both the current user and the specified user follow. Valid values: true or false. Default value: false.

    • advancedQuery – Specifies filters against streamed activities. Create filters for user names, service IDs, and object details, such as a document's display name.

      Note:

      You must plug actual values into the advancedQuery parameter. You cannot pass EL expressions directly into the parameter. Typically, the REST API client handles an EL transformation manually and inserts the actual object data value into the REST URL. See the example below.

    For example, the following URI returns activities from the current user's activity stream, for all services that the user has configured in their personal preference settings for service filters. It returns activities from the user's Home portal and from the streams of the user's connections:

    http://host:port/rest/api/activities?personal=true&connections=true&personGuid=@me&token=utoken
    

    The following URI returns only the user's personal profile and connections activities:

    http://host:port/rest/api/activities?serviceIds=oracle.webcenter.peopleconn
    ections.profile,oracle.webcenter.peopleconnections.connections&personal=
    true&personGuid=@me&token=utoken
    

    This next example illustrates how to use the advancedQuery parameter. As explained previously, you cannot pass an EL expression to advancedQuery. The REST API client must first obtain the actual data object value, and that value can then be passed to advancedQuery. For example, to filter activities for a particular portal, you can pass the GUID of the portal's scope to advancedQuery:

    http://host:port/rest/api/activities?personGuid=@me&advancedQuery=AE.SCOPE_ID%20%3D%20\%27s8bba98ff_4cbb_40b8_beee_296c916a23ed\%27&ttoken=token
    

    where s8bba98ff_4cbb_40b8_beee_296c916a23ed is the GUID of the portal. Note that the query string must be encoded with the appropriate escape codes.

  • response—Body: 0 or more activities

    Note:

    Because the stream resource includes activity items, the response may also return resource links for the objects referenced in the activity.

Table C-5 lists the resource types that the client can link to from the stream resource.

The activity response contains the data for activities and URIs for use in retrieving all the data you need from an activity that is included in an Activity Stream.

This section shows how the client can navigate through the hypermedia to access the activity resource:

resourceIndex
   stream
      activity

resourceIndex
   person
      stream
         activity

resourceIndex
   space
      stream
         activity

No methods are supported for activity. Activities are currently available only from the stream resource type.

Table C-6 lists the resource types that the client can link to from this resource.

Table C-7 lists the read-only elements for the activity resource.

s8bba98ff_4cbb_40b8_beee_296c916a23ed

<param resourceType="urn:oracle:webcenter:activities:parameter">
<links>
<link href="http://www.google.com" />
</links>
<displayName>http://www.google.com</displayName>
<key>_sharedLink_url</key>
<type>custom</type>
</param> "

^Footnote 2

Data types, such as DATE and BOOLEAN, are stored in the API as STRING. The DATE data type returns a Java standard date format, for example, 2009-08-21T14:43:11.0013-0700, with 0700 representing the time zone.

Suppose you want to display the most recent messages for a user named Carl. You want to display information like this: "Carl created the portal Customer Feedback". The templateParams element helps you solve this problem.

The templateParams element is returned in objects of type oracle:webcenter:activities:activity. This element captures a lot of data related to an activity. For example, if a user creates a new portal, the templateParams element for that activity captures information about the user and about the portal. Keys are provided that allow you to perform string substitutions in a parameterized message string related to the activity.

For example, if the user creates a portal, the returned activity object contains a <message> item that is parameterized like this:

<message>{actor[0]} has created the portal {object[0]}</message>

By parsing the templateParams element for the activity, you can find the available keys that allow you to perform string substitutions as well as appropriate data to display, like the name of the user and the activity.

The templateParams element also provides links to comments, likes, commentsSummary, and likesSummary objects, if they are requested using the data parameter. These links let you query for all the comments or likes for an object or post a new comment or like. The summary links returns the comments or likes count and several recent comments or likes. See also Understanding Comments and Likes.

The links returned with the templateParams element vary depending on what kind of object is returned, like a user, document, portal, or custom object. For more information, see urn:oracle:webcenter:activities:parameter.

If a rel link is marked "via," this means it is a link to the underlying REST object–for instance, the document not the parameter. If a rel link is marked "alternate" and type "text/html," it is a link to the HTML page for that object. Portal objects include an activity stream link for portals. Users have icon and activity stream links. Other objects can have an alt link to the tagged item, as well as the related tagged items list, if tagging is enabled for that object. If a regular object supports comments or likes, it can include the comments/commentsSummary and likes/likesSummary, as explained previously.

Hyperlinks to comments, commentsSummary, likes and likesSummary are included by default (you can expand the commentsSummary and likesSummary by specifying data=data,commentsSummary,likesSummary). Comments and likes can be associated with the object referenced by the activity or the activity itself. For example, if you edit a document, then the comments will be associated with the document. If you add comments on an edit document activity on the activity stream page, then comments will be associated with the edit document activity.

The links associated with comments and likes are:

• comments – The comments link lets you query for all the comments for an object. This link also lets you POST a new comment. For a comments POST, the text field is required. For example, for body data you would use:

  JSON:

             {
               "text" : "REST Comment"
             }
  

  XML:

             <text>REST Comment</text> 
  

• commentsSummary – The commentsSummary link returns the comments count and several recent comments.

• likes – The likes link lets you query for all the likes for an object. This link also lets you POST a new like. There are no required fields for a likes POST.

• likesSummary – The likesSummary link returns the likes count and the current user's like (if available).

The following URLs show examples of GET requests for comments, commentSummary, likes and likesSummary for a document object:

"http://example.com:8892/rest/api/activities/services/oracle.webcenter.doclib/objectTypes/document/objects/(<document_object_id>)/comments?startIndex=0&amp;itemsPerPage=10&amp;utoken=FCvY3qQSBh0eAByLdxugV-lUgFO3_w**"

"http://example.com:8892/rest/api/activities/services/oracle.webcenter.doclib/objectTypes/document/objects/(<document_object_id>)/commentsSummary?utoken=FCvY3qQSBh0eAByLdxugV-lUgFO3_w**"

"http://example.com:8892/rest/api/activities/services/oracle.webcenter.doclib/objectTypes/document/objects/(<document_object_id>)/likes?startIndex=0&amp;itemsPerPage=10&amp;utoken=FCvY3qQSBh0eAByLdxugV-lUgFO3_w**"

"http://example.com:8892/rest/api/activities/services/oracle.webcenter.doclib/objectTypes/document/objects/(<document_object_id>)/likesSummary?utoken=FCvY3qQSBh0eAByLdxugV-lUgFO3_w**"

Where <document_object_id> is the document object ID.

The following URLs show examples of GET requests for comments, commentSummary, likes and likesSummary for a create document activity:

"http://example.com:8892/rest/api/activities/ffa9a9f0-d02f-4e30-8c58-8a41b7a6e8a3/comments?startIndex=0&itemsPerPage=10&utoken=FCvY3qQSBh0eAByLdxugV-lUgFO3_w**"

"http://example.com:8892/rest/api/activities/ffa9a9f0-d02f-4e30-8c58-8a41b7a6e8a3/commentsSummary?utoken=FCvY3qQSBh0eAByLdxugV-lUgFO3_w**"

"http://example.com:8892/rest/api/activities/ffa9a9f0-d02f-4e30-8c58-8a41b7a6e8a3/likes?startIndex=0&itemsPerPage=10&utoken=FCvY3qQSBh0eAByLdxugV-lUgFO3_w**"
                  "http://example.com:8892/rest/api/activities/ffa9a9f0-d02f-4e30-8c58-8a41b7a6e8a3/likesSummary?utoken=FCvY3qQSBh0eAByLdxugV-lUgFO3_w**"

The templateParams element returns a set of param elements. The param elements return data specific to the type of activity object returned. The possible types of param elements include:

• user – Returns the displayName, guid, id, key, primaryId, and type.

• document – Returns the displayName, iconUrl, id, key, primaryId, and type.

• custom – Returns displayName, key, and type, and may or may not have a URL.

A param can also be a variable reference or key of the general form {prefix[index].variable}.

Use this resource type to get the icon of the activity, if available (GET).

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   activities
      activity
         icon

The following methods are supported by this resource:

• GET – Returns the icon used for the named activity.

Table C-8 lists the resource types that the client can link to from this resource.

The people response contains URIs for use in retrieving the profile of one or more users.

This section shows how the client can navigate through the hypermedia to access the people resource:

resourceIndex
   people

The following method is supported by the people resource:

• GET

  • request—Parameters:

    • startIndex – See Common Request Query Parameters.

    • itemsPerPage – See Common Request Query Parameters.

    • projection – See Common Request Query Parameters.

    • data – The data parameter is a comma separated list that controls which data will be returned in the response. The predefined set basic is equivalent to data=guid,id,displayName. The predefined set data is a standard set that returns all the data for the user, but does not include status, manager, reportees, or photos. The full list of possible values includes the predefined sets basic and data, as well as the following individual data values: guid, id, displayName, birthday, language, timeZone, name, addresses, organizations, workEmail, phoneNumbers, manager, reportees, photos, and status.

      If you specify the constant 'data' as the data parameter, all the basic information will be returned for the resource. If both the projection and data query string parameters are present, the data parameter will be used to determine which data to return.

      The data parameter can also take any of the following values comma-separated values to return the corresponding data:  guid, id, displayName, birthday, language, timeZone, name, addresses, organizations, workEmail, phoneNumbers, manager, reportees, photos, and/or status.

      Note:

      The data parameter can accept a predefined set, a collection of values, or a mix of sets and values. For example, to get the basic data plus the user's birthday, you can specify data=basic,birthday.

    • links – The links parameter is a comma-separated list that controls which links will be returned in the response. This parameter can accept predefined sets, individual data values, or a combination of predefined sets and individual data values. The predefined sets are basic, data, activitiesSet, connectionsSet, and feedbackSet. These predefined sets are described in Predefined Sets for the links Parameter.

      The individual values for the links parameter are: person, profile, icon, status, messageBoard, activities, personActivities, connectionActivities, connections, listNames, invitation, givenFeedback, receivedFeedback, userGivenFeedback, manager, reportees, member.

      If both the projection and links query string parameters are present, the links parameter will be used to determine which links to return.

  • response—Body: One or more person objects.

The following items are predefined sets that can be returned in the links parameter. For example, if you specify links=basic, it is the equivalent of specifying data=person,profile,icon. You can also specify additional parameters as needed. For example, you could specify data=basic,birthday.

• basic – A standard set that returns the basic information for the profile and includes person, profile, and icon.

• data – A standard set that returns all the basic links for the response plus the connections list, status, and activity stream template.

• activitiesSet – Includes activities, personActivities, and connectionActivities.

• connectionsSet – Includes connections, listNames, and invitation.

• feedbackSet – Includes givenFeedback, receivedFeedback, and userGivenFeedback.

Table C-9 lists the resource types that the client can link to from the people resource.

Use this resource type to get the icon used for the named profile (GET).

Navigation Paths to people:icon

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   people
      icon

The following methods are supported by this resource:

• GET – Returns the icon used for the named profile.

  Note:

  This resource includes a template that lets you choose the size of the profile icon to use. The size template parameter can be set to small, medium, or large.

Table C-10 lists the resource types that the client can link to from this resource.

The person response contains profile data and the URIs for use in retrieving a user profile.

This section shows how the client can navigate through the hypermedia to access the person resource:

resourceIndex
   people

resourceIndex
   people
      person

resourceIndex
   person

author
   person

resourceIndex
   activities:stream
      person

The following method is supported by the person resource:

• GET

  • request—Parameters: q

    To retrieve a specified person, the format of q is:

    q=[loginid:equals:username]
    Or
    q=[guid:equals:guid]
    Or
    q=[email:equals:email]

    Note:

    The parameter q is only on the resourceIndex template for person.

  • response—Body: message

    See Also:

    For information about the response message, see Read-only Elements for person.

Table C-11 lists the read-only elements for the person resource.

^Footnote 3

Data types, such as DATE and BOOLEAN, are stored in the API as STRING.

Table C-12 lists the resource types that the client can link to from the person resource.

This section shows how the client can navigate through the hypermedia to access the list resource:

resourceIndex
   person
      listNames
         list

resourceIndex
   person
      list (rel="urn:oracle:webcenter:people:person:list:connections")

The following methods are supported by the list resource:

• GET

  • request—Parameters: startIndex, itemsPerPage, projection

    See Also:

    For information about REST API parameters, such as startIndex and itemsPerPage, see Common Request Query Parameters.

  • response—Body: 0 or more person items

• POST

  • request—Body: member

  • response—Body: member

  See Also:

  For information about member in the request and response elements, see urn:oracle:webcenter:people:person:list:member.

• DELETE

  • request

Table C-13 lists the resource types that the client can link to from the list resource.

^Footnote 4

self rel currently includes "urn:oracle:webcenter:people:person:list:list" instead of the correct "urn:oracle:webcenter:people:person:list". For the @connections default list, it currently includes "urn:oracle:webcenter:people:person:list:connections".

The listNames response contains the names of existing connections lists as well as the URIs for use in retrieving the lists (GET) and creating connections lists (POST).

This section shows how the client can navigate through the hypermedia to access the listNames resource:

resourceIndex
   person
      listNames

The following methods are supported by the listNames resource:

• GET

  • request

  • response: Body: 0 or more listName items

• POST

  • request—Body: listName

  • response—Body: listName

Table C-14 lists the resource types that the client can link to from the listNames resource.

The listName response contains the names of connections lists and URIs for use in accessing the connections lists. See also urn:oracle:webcenter:people:person:listName.

This section shows how the client can navigate through the hypermedia to access the listName resource:

resourceIndex
   person
      listNames
         listName

The following method is supported by the listName resource:

• DELETE

  • request

Table C-15 lists the writable elements for the listName resource.

Table C-16 lists the resource types that the client can link to from the listName resource.

The member response contains URIs for use in deleting a connection from a connections list.

This section shows how the client can navigate through the hypermedia to access the member resource:

resourceIndex
   person
      list
         member

The following method is supported by the member resource:

• DELETE

  • request

Table C-17 lists the writable elements for the member resource. Writable elements for member are used when you add a connection to a list or invite a user to be a connection. The member resource itself is for deleting connections, and does not use writable elements.

The status response contains URIs for use in retrieving (GET) and updating (PUT) the profile status message of a specified user.

This section shows how the client can navigate through the hypermedia to access the status resource:

resourceIndex
   people
      person
         status

The following methods are supported by the status resource:

• GET

  • request

  • response—Body: status

• PUT

  • request—Body: status

  • response—Body: status

Table C-18 lists the writable elements for the status resource.

Table C-19 lists the resource types that the client can link to from the status resource.

The invitations response contains URIs for use in retrieving invitations (GET). You can also send an invitation (POST) to another user.

This section shows how the client can navigate through the hypermedia to access the invitations resource:

resourceIndex
   invitations

If you are not already connected to a user, you can also navigate to the invitations resource from that user's profile in order to invite them to connect. This path is only used for POSTing.

resourceIndex
   person
      invitations

The following methods are supported by the invitations resource:

• GET

  • Request—Parameters: q

    To retrieve invitations sent to the current user, the format of q is:

    q=[invitee:equals:@me]
    

    To retrieve invitations sent from the current user, the format of q is:

    q=[invitor:equals:@me]
    

  • Response—Body: 1 or more invitations

• POST

  • Request—Body: invitation

  • Response—Body: invitation

Table C-20 lists the writable elements for the invitations resource.

Table C-21 lists the resource types that the client can link to from the invitations resource:

The invitation response contains URIs for use in deleting (DELETE) invitations you have sent, or deleting (DELETE) or updating (PUT) invitations you have received.

This section shows how the client can navigate through the hypermedia to access the invitation resource:

resourceIndex
   invitations
      invitation

The following methods are supported by the invitation resource:

• PUT

  • Request—Body: invitation

  • Response—Body: invitation

• DELETE

  • Request

Table C-22 lists the writable elements for the invitation resource.

Table C-23 lists the read-only elements for the invitation resource.

^Footnote 5

Data types, such as DATE and BOOLEAN, are stored in the API as STRING.

Table C-24 lists the resource types that the client can link to from the invitation response.

This section shows how the client can navigate through the hypermedia to access the feedback resource:

resourceIndex
   feedback

resourceIndex
   person
      feedback

The following methods are supported by the feedback resource:

• GET

  • request—Parameters: startIndex, itemsPerPage

    See Also:

    For information about REST API parameters, such as startIndex and itemsPerPage, see Common Request Query Parameters.

  • response—Body: message

    See Also:

    For information about message, see urn:oracle:webcenter:feedback:message.

• POST – If permitted, lets you add feedback for a target user. This method is only available if the current user is connected to and has permission to add feedback for the target user.

  • request - body: feedback

  <message resourceType="urn:oracle:webcenter:feedback:message">
      <body>test from REST API</body>
      <receivedUser>
      <guid>4F16DD80393611DFBF895F177662C511</guid>
      </receivedUser>
  </message>

Table C-25 lists the resource types that the client can link to from the feedback resource.

This section shows how the client can navigate through the hypermedia to access the message resource:

resourceIndex
   feedback
      message

resourceIndex
   person
      feedback
         message

The following method is supported by the message resource:

• DELETE

  • request

Table C-26 lists the read-only elements for the message resource.

^Footnote 6

Data types, such as DATE and BOOLEAN, are stored in the API as STRING.

Table C-27 lists the resource types that the client can link to from the feedback resource.

The messageBoard response contains URIs for use in reading (GET) and posting (POST) portal and individual user Message Board messages.

This section shows how the client can navigate through the hypermedia to access the messageBoard resource:

resourceIndex
   messageBoard

resourceIndex
   person
      messageBoard

resourceIndex
   spaces
      space
         messageBoard

The following methods are supported by the messageBoard resource:

• GET

  • request—Parameters: startIndex, itemsPerPage

    See Also:

    For information about REST API parameters, such as startIndex and itemsPerPage, see Common Request Query Parameters.

  • response—Body: message

  Note:

  The REST GET command for reading (retrieving) messages retrieves all shown messages by default. You can also retrieve messages that are private or hidden through the application user interface as described in Filtering Messages Based on Visibility. For information about hiding and showing messages, see "Adding Messages and Feedback to a Portal" in Building Portals with Oracle WebCenter Portal.

• POST

  • request—Body: message

    The POST for messages supports including a link URL in the message.

    See Also:

    For information about message, see urn:oracle:webcenter:messageBoard:message.

Table C-28 lists the read-only elements for the messageBoard resource.

Table C-29 lists the resource types that the client can link to from the messageBoard resource.

The message response contains the Message Board message data and URIs for use in reading (GET), revising (PUT), and deleting (DELETE) a portal or individual user Message Board message.

This section shows how the client can navigate through the hypermedia to access the message resource:

resourceIndex
   messageBoard
      message

resourceIndex
   person
      messageBoard
         message

resourceIndex
   spaces
      space
         messageBoard
            message

The following methods are supported by the message resource:

• GET

  • request

  • response—Body: message

• PUT

  • request—Body: message

  • response—Body: message

• DELETE

  • request

Table C-30 lists the writable elements for the message resource.

Table C-31 lists the read-only elements for the message resource.

^Footnote 7

Data types, such as DATE and BOOLEAN, are stored in the API as STRING.

Table C-32 lists the resource types that the client can link to from the message resource.

A person owning a message board can mark any message as private. When a message is marked as private, that message will not be visible to anyone other than the owner of the message unless the owner chooses to send a private message to someone else. Otherwise, other people viewing a message board with private messages will see only public messages.

A person owning a message board can mark any message as hidden. When a message is marked as hidden, that message will not be visible to the owner of the message board, but will remain visible to other people viewing the message board.

The context for message board URL filters is:

rest/api/messageBoards/<BOARD-TYPE>/<GUID>/<FILTER-TYPE>

Where:

• <BOARD-TYPE> is either person or space

• <GUID > is either @me, the person <GUID> (if <BOARD-TYPE> is person) or the space <GUID> (if <BOARD-TYPE> is portal)

• <FILTER-TYPE> is applicable only for the person <BOARD-TYPE> and can be one of:

  • null - (default) shows all messages

  • private - shows private messages

  • public - shows public messages

  • hidden - shows hidden and public messages

  • private_hidden - shows private and hidden messages

Available filters in the context of the applicable HTML methods are shown below.

GET

• @me

  • all rest/api/messageBoards/person/@me

  • private rest/api/messageBoards/person/@me/private

  • public rest/api/messageBoards/person/@me/public

  • hidden and public rest/api/messageBoards/person/@me/hidden

  • private and hidden rest/api/messageBoards/person/@me/private_hidden

• person

  rest/api/messageBoards/person/<GUID>

  If the GUID matches that of the logged in user then the same filtering as for @me applies. If the GUID is different, then no filtering is available.

• space

  rest/api/messageBoards/space/<GUID>

  No filtering based on visibility is available.

POST

• @me

  • all rest/api/messageBoards/person/@me

  • private

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "private"}
    

  • public

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "public"}
    

  • hidden and public

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "hidden"}
    

  • private and hidden

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "private_hidden"}

• person rest/api/messageBoards/person/<GUID> If the GUID is the same as the logged in user, then the filters for GET apply. If the users are different, then the following filters apply:

  • public

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "public"}
    

  • private

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "private"}
    

• space

  rest/api/messageBoards/space/<GUID>

  No filtering based on visibility is available.

PUT

• @me

  • all est/api/messageBoards/person/@me/messages/<msg guid>

  • private

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "private"}
    

  • public

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "public"}
    

  • hidden and public

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "hidden"}
    

  • private and hidden

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "private_hidden"}

• person rest/api/messageBoards/person/<GUID>/messages/<msg guid> If the GUID is the same as the logged in user, then the filters for GET apply. If the users are different, then the following filters apply:

  • public

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "public"}
    

  • private

    {"body" : "<BODY_CONTENT>",
     "visibilityType" : "private"}
    

• space

  rest/api/messageBoards/space/<GUID>/messages/<msg guid>

  No filtering based on visibility is available.

For this release, some of the optional capabilities listed in section 2.1.1 have not been implemented. Versioning, ACL, Policies, Relationships, Change Log, Folder Descendants/Tree, and Renditions will be considered for future releases.

Specifically, the Content Management Interoperability Services implementation has the following optional capabilities:

capabilityGetDescendants = true
capabilityGetFolderTree = false 
capabilityContentStreamUpdatability = anytime 
capabilityChanges = none
capabilityRenditions = none 
capabilityMultifiling = false 
capabilityUnfiling = false 
capabilityVersionSpecificFiling = false 
capabilityPWCUpdateable = false 
capabilityPWCSearchable = false 
capabilityAllVersionsSearchable = false 
capabilityJoin = none	
capabilityACL = none
capabilityQuery = none, metadataonly, or both combined

The Content Management Interoperability Services supports document and folder objects. In CMIS the cmis:baseTypeId for a Node will be cmis:folder or cmis:document. Also, the cmis:baseId for a Type will be cmis:folder or cmis:document.

A CMIS Object-Type contains fields mapped from the Oracle WebCenter Content: Content Server metadata field definitions and Oracle WebCenter Content's Site Studio region definitions.

The mapping from Oracle WebCenter Content metadata fields to CMIS property definitions is as follows:

The mapping from Site Studio region definition fields to CMIS property definitions is as follows:

Document Objects are the elementary information entities managed by the repository. As defined by the CMIS specification, Document Objects may be version-able, file-able, query-able, control-able and ACLControl-able. As stated earlier, the Content Management Interoperability Services does not support versioning, multi-filing, Policies or ACL for this release.

If a Node is determined to be a Document (not a Folder) then any children it has will not be exposed through CMIS. In CMIS, each Document Object is associated with a single content stream, and for WebCenter CMIS REST, this stream is the Oracle WebCenter Content: Content Server binary associated with the document.

The CMIS specification states that Folder Objects do not have a content-stream and are not version-able. If a Node is determined to be a Folder, then the Content Management Interoperability Services exposes it in this manner. (In Oracle WebCenter Content, folders do not have a content stream and are not versionable).

Section 2.1.6: Relationship Object in the CMIS specification is not applicable; the Content Management Interoperability Services does not support Relationships for this release.

Section 2.1.7: Policy Object in the CMIS specification is not applicable; the Content Management Interoperability Services does not support Policies for this release.

Most of Section 2.1.8: Access Control in the CMIS specification is not applicable; the Content Management Interoperability Services does not support ACL for this release. See the next section for details on allowable actions.

Section 2.1.9: Versioning in the CMIS specification is not applicable; the Content Management Interoperability Services does not support versioning for this release.

CMIS queries return a Result Set where each Entry object will contain only the properties that were specified in the query. The Content Management Interoperability Services does not support JOINs in queries, so each result entry will represent properties from a single node. Common searches use a query like "SELECT * FROM …".

• The FROM clause specifies a content-type to be searched.

  • FROM cmis:document ==> any Oracle WebCenter Content document (for example, IDC:GlobalProfile)

  • FROM cmis:folder ==> any Oracle WebCenter Content folder (for example, IDC:Folder)

  • FROM typeQueryName ==> type's cmis queryName, as long as the type is queryable (for example, ora:t:IDC!;GlobalProfile)

• The cmis:document and cmis:folder types are always queryable. Other types will be queryable if they are searchable in the repository.

• The IN_FOLDER predicate is implemented as the folder ID specified, being the parent of the results.

• The IN_TREE predicate is implemented as the folder ID specified, being a parent in the folder structure of the results.

• The CONTAINS() predicate is a full-text query expression operator.

• Properties of cmis:document and cmis:folder will be queryable and orderable if their corresponding Oracle WebCenter Content system property is searchable and sortable. The system property mappings are:

  • cmis:createdBy ==> dDocAuthor

  • cmis:lastModifiedBy ==> dDocCreator

  • cmis:creationDate ==> dCreateDate

  • cmis:lastModificationDate ==> dLastModifiedDate (for 10g, folders map to dLastModifiedDate and documents map to dCreateDate)

  • cmis:name ==> dOriginalName (for a document) or dCollectionName (for a folder)

  • cmis:contentStreamFileName ==> dOriginalName

  • cmis:contentStreamLength ==> VaultFileSize

  • cmis:contentStreamMimeType ==> dFormat

  • cmis:objectId ==> dDocName

  • cmis:objectTypeId ==> Oracle WebCenter Content profile name or SiteStudio Region Definition name

    Note:

    cmis:objectTypeId is never orderable.

  • cmis:path ==> use IN_FOLDER or IN_TREE predicate

  Note:

  Some repositories may have capabilities that are not representable in a CMIS query, and some repositories may have restrictions which will limit the CMIS-query predicates (or combinations of predicates) that can be used in a query. Use the mappings above to translate repository capabilities and restrictions into corresponding considerations for CMIS queries.

• Nested properties are not queryable or orderable.

• The Content Management Interoperability Services implementation reports as orderable any properties which Oracle WebCenter Content specifies as sortable. This list can include properties which Oracle WebCenter Content cannot actually sort on. To allow ordering on a field for which Oracle WebCenter Content reports a sort error, follow the steps below to make the specified Oracle WebCenter Content field sortable:

  1. Go to Administration and open Admin Applets.

  2. Open the Configuration Manager applet and click Advanced Search Design.

  3. Edit the field you wish to make orderable and select Is sortable.

  4. Save your changes and exit Administration.

Table C-35 lists specific search considerations and recommendations. For example queries, see Content Management Interoperability Services Best Practices and Examples.

The specification defines the following CMIS services:

• GET: getChildren

• POST: createDocument or createFolder or createPolicy or moveObject or addObjectToFolder

The Content Management Interoperability Services provides the following additional services:

• POST: create This service has five query parameters: uid, fileName, contentId, comments, simpleResponse, and one header parameter: Slug. This service is meant to be used as a simple binary request upload. A new document is created with this service. Slug and fileName are used to name the binary that is attached to the request (using both parameters is optional; only one needs to be defined and fileName is checked first). The comments parameter is optional and contentId is optional if Oracle WebCenter Content is set up to auto-generate the dDocName.

• POST: create Content-Type: multipart/form-data This service has a single query parameter: uid, which is the uid of the folder in which the document is to be created. The boolean query parameter simpleResponse will return a response of media type: application/atom+xml;type=entry, if set to false. If set to true, a response of media type: text/html will be returned with a URI pointing to the newly created document. The comments and simpleResponse parameters are both optional, contentId is optional if Oracle WebCenter Content is set up to auto-generate the dDocName, and the name "fileUpload" is required.

  <html>
  <head>
      <title>simple post</title>
  </head>
  <body>
  <form action="http://<host>:<port>/rest/api/cmis/children/StellentRepository?uid=IDC:Folder/2"
        method="POST"
        enctype="multipart/form-data">
      Select a document to upload: <input type="file" name="fileUpload"/><br>
       <input type="hidden" name="comments" value="this is just a comment"/>
       <input type="hidden" name="contentId" value="uniqueID1"/>
       <input type="hidden" name="simpleResponse" value="true"/> 
      <input type="submit" value="Submit"/>
  </form>
  </body>
  </html>

The specification defines the following CMIS services:

• GET: getObject, getObjectOfLatestVersion (getObject)

• PUT: updateProperties

• DELETE: deleteObject

The Content Management Interoperability Services provides the following additional services:

• POST: postToDelete This service has two query parameters: uid and _method, and allows a document to be deleted through POST.

  http://<host>:<port>/rest/api/cmis/document/repoName?uid=ABC&_method="delete"

The specification defines the following CMIS services:

• GET: getContentStream

• PUT: setContentStream

• DELETE: deleteContentStream

The Content Management Interoperability Services provides the following additional services:

• POST: postTunnelContentStream This service has five query parameters: uid, overwriteFlag, fileName, comments, _method, and one header parameter: Slug. This service is meant to be used as a simple binary request upload or delete through POST. A document must already exist for this service. Slug and fileName are used to name the binary that is attached to the request (using both parameters is optional; only one needs to be defined and fileName is checked first). The overwriteFlag parameter defaults to true, the comments parameter is optional and valid values for _method are "delete" or "put" (not case sensitive).

  http://<host>:<port>/rest/api/cmis/stream/repoName?uid=ABC&_method="delete"
  

• POST: postTunnelContentStream Content-Type: multipart/form-data This service has a single query parameter: uid and is meant to be used as a simple html multipart/form-data upload or delete through POST. A document must already exist for this service. The attribute name="fileUpload" is required, "comments" is optional, and valid values for "_method" are "delete" or "put" (not case sensitive).

  <form action="http://<host>:<port>/rest/api/cmis/stream/repoName?uid=WDOC019113"
        method="POST"
        enctype="multipart/form-data">
      Select a document to upload: <input type="file" name="fileUpload"/><br>
       <input type="hidden" name="comments" value="this is just a comment"/>
       <input type="hidden" name="_method" value="PUT"/>
      <input type="submit" value="Submit"/>
  </form>

This section shows how the client can navigate through the hypermedia to access this resource:

resourceIndex
   spaces
      gsEvents

The following methods are supported by this resource:

• GET

  • request - body: <gsCategory>, Parameters: startIndex, itemsPerPage, utoken

    For information about these common parameters, see Common Request Query Parameters.

    The following additional parameters are available:

    • startDate—the date from which to start listing portal events

    • endDate—the date at which to stop listing portal events

    For the start and end dates, use the format YYYY-MM-DD, for example 2011-09-01. You can also specify a time (for example, 2011-09-01T09:00:00) and a timezone sign (for example, for UTC, 2011-09-01T09:00:00Z).

  • response - body: 0 or more events

• POST

  • request - body: event

  • response - body: event

Table C-36 lists the resource types that the client can link to from this resource.

resourceIndex
   spaces
      gsEvents
         gsEvent

The following methods are supported by this resource:

• GET

  • request - body: none

  • response - body: event

• PUT

  • request - body: event

  • response - body: event

• DELETE

  • request - body: none

  • response - body: none

Table C-37 lists the writable elements for this resource.

Table C-38 lists the read-only elements for this resource.

Table C-39 lists the resource types that the client can link to from this resource.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceIndex
   spaces
      gsCategories

The following methods are supported by this resource:

• GET

  • request - body: category

  • response - body: 0 or more categories

• POST

  • request - body: category

  • response - body: category

Table C-40 lists the resource types that the client can link to from this resource.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   tags 

resourceindex
   spaces
      spaces:resourceindex
         spaces:tags 

The following methods are supported by this resource:

• GET

  • request - body: none, Parameters: startIndex, itemsPerPage, keyword, serviceId, relatedTag, userId, scopeGuid, shared, tags, users

  • response - body: tag

  where:

  • startIndex—Specifies the index of the first matching result that should be included in the result set (0-n ... zero based). This is used for pagination.

  • itemsPerPage—Specifies the maximum number of results to return in the response (1-n). This is used for pagination.

  • keyword—Specifies a keyword for substring matches.

  • serviceId—Specifies the service ID for which you want to find tags (null for all).

  • relatedTag—Specifies a tag that is related to the list of tags. For example, if you have tagged item1 as "webcenter help" and item2 as "webcenter document" and you set relatedTag=webcenter, then you would get both tags (for help and document) returned.

  • userId—Specifies a single user ID to find tags for (null for all). Uses logged-in user if null and not looking for shared tags.

  • scopeGuid—Specifies the GUID of the portal. When set to the Home portal, it shows all (unfiltered) tags.

  • shared—Specify true to return personal resources only (that is, resources tagged privately only by that same user); false to return system resources (that is, resources with at least one public tag).

  • tags—Specifies to filter by this list of tags separated by URL-encoded spaces ('+'); for example, an item tagged with "webcenter" and "help" could be searched with tags=webcenter+help.

  • users—Specifies to filter by this list of users separated by URL-encoded spaces ('+'); for example, users=monty+vicki+pat.

Table C-41 shows the available parameter combinations for each operation. For example, the tags parameter cannot be specified with the serviceId parameter.

The resourceType link attribute indicates the type of resource to which the link points. Clients should use the resourceType to determine the expected response bodies for GET and POST and allowable request bodies for POST and PUT.

Table C-42 lists the resource types that the client can link to from this resource. Tags have a reference link to themselves and to the next page or previous page of results.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   tags
      tag

resourceindex
   spaces
      spaces:resourceindex
         spaces:tags
            spaces:tag

The following methods are supported by this resource:

• GET

  • request - body: none, Parameters: none

  • response - body: tag

• PUT

  • request - body: tag

  • response - body: tag

• DELETE

  • request - body: none

  • response - body: none

Example: Body of the PUT command for Renaming a Tag

<tag>
<name>newId</name>
</tag>

The resourceType link attribute indicates the type of resource to which the link points. Clients should use the resourceType to determine the expected response bodies for GET and POST and allowable request bodies for POST and PUT.

Table C-43 lists the resource types that the client can link to from this resource. A tag has a reference link to itself, to related taggedItems, to related users, and to related tags.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   taggedItems

resourceindex
   spaces
      spaces:resourceindex
         spaces:taggedItems

The following methods are supported by this resource:

• POST

  • request - body: taggedItem

  • response - body: taggedItem

  <taggeditem>
     <serviceId>oracle.webcenter.page</serviceId>
    
  <resourceId>/oracle/webcenter/page/somepath/someotherpath/a.jspx</resourceId>
     <tagWords>foo bar boo far</tagWords>
     <resourceTitle>This is renamed by me to be foofoo</resourceTitle>
     <scopeGuid>(optional) scope for the item</scopeGuid>
     <shared>(optional) make the item private </shared>
   </taggeditem> 
  

• GET

  • request - body: none, Parameters: serviceId, keyword, relatedRID, tags, users, dt, scopeGuid, shared, itemsPerPage

  • response - body: tagged items

  where:

  • serviceId—Specifies the service ID of the item.

  • keyword—Specifies a keyword in the resource title.

  • relatedRID—Specifies a related tag. For example, if you tagged item1 as "webcenter help" and item2 as "fusionapps documents" and item3 as "webcenter documents" and set relatedRID=item3, then you would get back item1 and item2, because they share tags in common with item3.

  • tags—Specifies to filter by this list of tags separated by URL-encoded spaces ('+'); for example, an item tagged with "webcenter" and "help" could be searched with tags=webcenter+help.

  • users—Specifies to filter by these users, separated by URL-encoded spaces ('+'); for example, {USER}+{USER}+...+{USER}.

  • dt—Specifies to filter bookmarks by this date, which defaults to the most recent date on which bookmarks were saved {DD-MM-CCYY}.

  • scopeGuid—Specifies the GUID of the portal. When set to the Home portal, it shows all (unfiltered) tags.

  • shared—Specify true to return personal resources only (that is, resources tagged privately only by that same user); false to return system resources (that is, resources with at least one public tag).

  • itemsPerPage—Specifies the maximum number of results to return in the response (1-n). This is used for pagination.

Table C-44 shows the available parameter combinations for each operation. For example, the tags parameter cannot be specified with the serviceId parameter.

The resourceType link attribute indicates the type of resource to which the link points. Clients should use the resourceType to determine the expected response bodies for GET and POST and allowable request bodies for POST and PUT.

Table C-45 lists the resource types that the client can link to from this resource. Tagged items have a reference link to themselves and to the next page or previous page of results.

The following methods are supported by this resource:

• GET

  • request - body: none, Parameters: serviceId, keyword, tags, users, dt, shared, itemsPerPage

  • response - body: tagged item

  where:

  • serviceId—Specifies the service ID of the item.

  • keyword—Specifies a keyword in the resource title.

  • tags—Specifies to filter by this list of tags separated by URL-encoded spaces ('+'); for example, an item tagged with "webcenter" and "help" could be searched with tags=webcenter+help.

  • users—Specifies to filter by this list of users separated by URL-encoded spaces ('+'); for example, users=monty+vicki+pat.

  • dt—Specifies to filter bookmarks by this date, which defaults to the most recent date on which bookmarks were saved {DD-MM-CCYY}.

  • shared—Specify true to return personal resources only (that is, resources tagged privately only by that same user); false to return system resources (that is, resources with at least one public tag).

  • itemsPerPage—Specifies the maximum number of results to return in the response (1-n). This is used for pagination.

• PUT

  • request - body: taggedItem

  • response - body: taggedItem

  <taggeditem>
  <tagWords>foo bar boo far</tagWords>
  </taggeditem>
  

• DELETE

  • request - body: none

  • response - body: none

The resourceType link attribute indicates the type of resource to which the link points. Clients should use the resourceType to determine the expected response bodies for GET and POST and allowable request bodies for POST and PUT.

Table C-46 lists the resource types that the client can link to from this resource. A tagged item has a reference link to itself, related tagged items, and an external link.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   taggingusers

resourceindex
   spaces
      spaces:resourceindex
         spaces:taggingusers

The following methods are supported by this resource:

• GET

  • request - body: none, Parameters: startIndex, itemsPerPage, tags, users

  • response - body: people profile

  where:

  • startIndex—Specifies the index of the first matching result that should be included in the result set (0-n ... zero based). This is used for pagination.

  • itemsPerPage—Specifies the maximum number of results to return in the response (1-n). This is used for pagination.

  • tags—Specifies to filter by this list of tags separated by URL-encoded spaces ('+'); for example, an item tagged with "webcenter" and "help" could be searched with tags=webcenter+help.

  • users—Specifies to filter by this list of users separated by URL-encoded spaces ('+'); for example, users=monty+vicki+pat.

The resourceType link attribute indicates the type of resource to which the link points. Clients should use the resourceType to determine the expected response bodies for GET and POST and allowable request bodies for POST and PUT.

Table C-47 lists the resource types that individual users can link to from this resource. Users have a reference link to themselves and to the next page or previous page of results.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   forums

resourceindex
   spaces
      spaces:resourceindex
         spaces:forums

The following methods are supported by this resource:

• GET

  • request - body: none, Parameters: startIndex, itemsPerPage (pagination)

  • response - body: forums

• POST

  • request - body: forum

  • response - body: forum

Note that the number of forums displayed per page defaults to 10. For more information, see Templates.

Table C-48 lists the resource types that the client can link to from this resource.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   forums
      forum

resourceindex
   spaces
      spaces:resourceindex
         spaces:forums
            forum

resourceindex
   activities
      forum

The following methods are supported by this resource:

• GET

  • request - body: none

  • response - body: forum

• PUT

  • request - body: forum

  • response - body: forum

• DELETE

  • request - body: none

  • response - body: none

Table C-49 lists the writable elements for this resource.

Table C-50 lists the read-only elements for this resource.

Table C-51 lists the resource types that the client can link to from this resource.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   forums
      topics

resourceindex
   spaces
      spaces:resourceindex
         spaces:forums
            topics

The following methods are supported by this resource:

• GET

  • request - body: none, Parameters: startIndex, itemsPerPage (pagination)

  • response - body: topics

• POST

  • request - body: topic

  • response - body: topic

For more information, see Templates.

Table C-52 lists the resource types that the client can link to from this resource.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   forums
      topics
         topic

resourceindex
   spaces
      spaces:resourceindex
         spaces:forums
            topics
               topic

resourceindex
   activities
      topicT

The following methods are supported by this resource type:

• GET

  • Request—Body: none

  • Response—Body: topic

• PUT

  • Request—Body: topic

  • Response—Body: topic

• DELETE

  • Request—Body: none

  • Response—Body: none

Table C-53 lists the writable elements for this resource type.

Table C-54 lists the read-only elements for this resource type.

Table C-55 lists the resource types that the client can link to from this resource.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   forums
      topics
         messages

resourceindex
   spaces
      spaces:resourceindex
         spaces:forums
            topics
               messages

The following methods are supported by this resource:

• GET

  • request - body: none, Parameters: startIndex, itemsPerPage (pagination)

  • response - body: messages

• POST

  • request - body: message

  • response - body: message

For more information, see Templates.

Table C-56 lists the resource types that the client can link to from this resource.

This section shows how the client can navigate through the hypermedia to access this resource:

resourceindex
   forums
      topics
         messages
            message
 

resourceindex
   spaces
      spaces:resourceindex
         spaces:forums
            topics
               messages
                  message

The following methods are supported by this resource:

• GET

  • request - body: none

  • response - body: message

• PUT

  • request - body: message

  • response - body: message

• DELETE

  • request - body: none

  • response - body: none

Table C-57 lists the writable elements for this resource.

Table C-58 lists the read-only elements for this resource.