Skip to content

Latest commit

 

History

History
843 lines (603 loc) · 14.8 KB

README.adoc

File metadata and controls

843 lines (603 loc) · 14.8 KB
Raw

Ribose

Build Status Code Climate Gem Version

The Ruby Interface to the Ribose API.

Installation

Add this line to your application’s Gemfile:

gem "ribose"

And then execute:

$ bundle install

Or install it yourself as:

$ gem install ribose

Configure

We need to setup Ribose API configuration before we can perform any request throughout this client

First, obtain an API token as per this Github wiki. Using the token, configure the client by adding an initializer with the following code:

Ribose.configure do |config|
  config.user_email    = "your-email@example.com"
  config.user_password = "your-password"

  # INFRA_ID is a 7-digit id, which can be found from the network requests
  # e.g. ed6af7b for current production environment.
  # Note: add the host without the protocols eq: http, https
  config.api_host      = "app-INFRA_ID.ribose.com"

  # There are also some default configurations. Normally you do not need to
  # change those unless you have some very specific use cases.
  #
  # config.debug_mode = false
  # config.api_host = "www.ribose.com"

  # Deprecated
  # config.api_token     = "SECRET_API_TOKEN"
  # config.api_email     = "your-email@example.com"
end

Or:

Ribose.configuration.api_host = "app-INFRA_ID.ribose.com"
Ribose.configuration.user_email = "your-email@example.com"
Ribose.configuration.user_password = "your-password"
```
=======

Usage

App Data

List app data

App data can be retrieved using the AppData.all interface.

Ribose::AppData.all

App Relation

List app relations

To retrieve the list of app relations, we can use the AppRelation.all interface.

Ribose::AppRelation.all

Fetch an app relation

To retrieve the details for a specific app relation, we can use the following interface.

Ribose::AppRelation.fetch(app_relation_id)

Profile

Fetch user profile

Ribose::Profile.fetch

Update user profile

Ribose::Profile.update(first_name: "John", last_name: "Doe")

Set user login

Ribose::Profile.set_login(login_name)

Settings

List user’s settings

To list user’s settings we can use the Setting.all interface, and it will return all of the user’s settings.

Ribose::Setting.all

Fetch a setting

To fetch the details for any specific settings we can use the Setting.fetch interface with the specific Setting ID, and it will return the details for that setting.

Ribose::Setting.fetch(setting_id)

Update a setting

Ribose::Setting.update(setting_id, **new_updated_attributes_hash)

Spaces

List user’s Spaces

To list a user’s Spaces we can use the Space.all interface, and it will retrieve all of the Spaces for the currently configured user.

Ribose::Space.all

Fetch a user Space

To retrieve the details for a Space we can use the Space.fetch(space_id).

Ribose::Space.fetch(space_id)

Create a user Space

To create a new user Space,

Ribose::Space.create(
  access:            "private",
  space_category_id: 12,
  name:              "The amazing Ribose Space",
  description:       "Description about your Space"
)

Update a user Space

Ribose::Space.update("space_uuid", name: "New updated name", **other_attributes)

Remove a user Space

To remove an existing Space,

Ribose::Space.remove(space_uuid, confirmation: true)

Members

The members endpoint are Space-specific.

To retrieve the member details under any specific Space, we can use this interface.

List space members

To retrieve the list of members,

Ribose::Member.all(space_id, options)

Delete a space member

Ribose::Member.delete(space_id, member_id, options)

Fetch Member Role

Ribose::MemberRole.fetch(space_id, member_id, options)

Assign a role to member

Ribose::MemberRole.assign(space_id, member_id, role_id)

Files

List of Files

To retrieve the list of files for any specific Space,

Ribose::SpaceFile.all(space_id, options)

Fetch a file details

Ribose::SpaceFile.fetch(space_id, file_id, options = {})

Fetch a file icon

Ribose::SpaceFile.fetch_icon(space_id, file_id, options = {})

Create a file upload

Ribose::SpaceFile.create(space_id, file: "The complete file path", **attributes)

Update a space file

Ribose::SpaceFile.update(space_id, file_id, new_file_attributes = {})

Remove a space file

Ribose::SpaceFile.delete(space_id, file_id)

File Version

Fetch file version

Ribose::FileVersion.fetch(
  space_id: space_id, file_id: file_id, version_id: version_id
)

Create a new file version

Ribose::FileVersion.create(
  space_id: your_space_id,
  file_id: existing_file_id_in_space,
  file: file_path_for_the_new_version,

  **any_other_additional_attributes
)

Conversations

Listing Space Conversations

Ribose::Conversation.all(space_id, options = {})

Retrieve a conversation details

Ribose::Conversation.fetch(space_id, conversation_id)

Create A New Conversation

Ribose::Conversation.create(
  space_id, name: "Sample conversation", tag_list: "sample, conversation"
)

Update a conversation

Ribose::Conversation.update(space_id, conversation_id, new_attributes_hash)

Remove A Conversation

Ribose::Conversation.destroy(space_id: "space_id", conversation_id: "12345")

Mark a conversation as favorite

Ribose::Conversation.mark_as_favorite(space_id, conversation_id)

Message

List Conversation Messages

Ribose::Message.all(space_id: space_uuid, conversation_id: conversation_uuid)

Create a new message

Ribose::Message.create(
  space_id:        space_uuid,
  conversation_id: conversation_uuid,
  contents:        "Provide your message body here",
)

Update an existing message

Ribose::Message.update(
  space_id:        space_uuid,
  message_id:      message_uuid,
  conversation_id: conversation_uuid,
  contents:        "The new content for message",
)

Remove a message

Ribose::Message.remove(
  space_id:        space_uuid,
  message_id:      message_uuid,
  conversation_id: conversation_uuid,
)

Feeds

List user feeds

To retrieve the list of user feeds,

Ribose::Feed.all

Widgets

List widgets

To retrieve the list of widgets,

Ribose::Widget.all

Stream

List of stream notifications

To retrieve the list of notifications,

Ribose::Stream.all

Leaderboard

Retrieve the current leadership board

To retrieve the current leadership board,

Ribose::Leaderboard.all

Connections

List of connections

To retrieve the list of connections, we can use the Connection.all interface and it will return the connection as Sawyer::Resource.

Ribose::Connection.all

Disconnect a connection

To disconnect with an existing connection, we can use Connection.disconnect interface as following. This expect us to provide the connection id, and it also support an additional options hash to provide custom options.

Ribose::Connection.disconnect(connection_id, options)

Connection suggestions

To retrieve the list of user connection suggestions,

Ribose::Connection.suggestions

Invitations

List connection invitations

Ribose::ConnectionInvitation.all

List Space invitations

Ribose::SpaceInvitation.all

Fetch a connection invitation

Ribose::ConnectionInvitation.fetch(invitation_id)

Create mass connection invitations

Ribose::ConnectionInvitation.create(
  emails: ["email-one@example.com", "email-two@example.com"],
  body: "This contains the details message about the invitation",
)

Accept a connection invitation

Ribose::ConnectionInvitation.accept(invitation_id)

Reject a connection invitation

Ribose::ConnectionInvitation.reject(invitation_id)

Cancel a connection invitation

Ribose::ConnectionInvitation.cancel(invitation_id)

Invite user to a Space

Ribose::SpaceInvitation.create(
  state:      "0",
  space_id:   "123_456_789",
  invitee_id: "456_789_012",
  type:       "Invitation::ToSpace",
  body:       "Please join to this amazing Space",
)

Create Space invitation - Mass

Ribose::SpaceInvitation.mass_create(
  space_id,
  emails:   ["email-one@example.com"],
  role_ids: ["role-for-email-address-in-sequance"],
  body:     "The complete message body for the invitation",
)

Update a Space invitation

Ribose::SpaceInvitation.update(invitation_id, new_attributes_hash)

Accept a Space invitation

Ribose::SpaceInvitation.accept(invitation_id)

Resend a Space invitation

Ribose::SpaceInvitation.resend(invitation_id)

Reject a Space invitation

Ribose::SpaceInvitation.reject(invitation_id)

Cancel a Space invitation

Ribose::SpaceInvitation.cancel(invitation_id)

Join Space Request

List Join Space Requests

Ribose::JoinSpaceRequest.all

Fetch a join space request

Ribose::JoinSpaceRequest.fetch(request_id)

Create a Join Space Request

Ribose::JoinSpaceRequest.create(
  state:    0,
  Space_id: 123_456_789,
  type:     "Invitation::JoinSpaceRequest",
  body:     "Hi, I would like to join to your Space",
)

Accept a Join Space Request

Ribose::JoinSpaceRequest.accept(invitation_id)

Reject a Join Space Requests

Ribose::JoinSpaceRequest.reject(invitation_id)

Update an Join Space Requests

Ribose::JoinSpaceRequest.update(invitation_id, new_attributes_hash)

Calendar

List user calendars

To retrieve the list of calendars accessible to the current user,

Ribose::Calendar.all

Fetch a calendar events

Ribose::Calendar.fetch(calendar_ids, start: Data.today, length: 7)

Create a calendar

Ribose::Calendar.create(
  owner_type: "User",
  owner_id:   "The Owner UUID",
  name:       "The name for the calendar",
)

Delete a calendar

Ribose::Calendar.delete(calendar_id)

Event

List calendar events

Ribose::Event.all(calendar_id)

Fetch a calendar event

Ribose::Event.fetch(calendar_id, event_id)

Create a calendar event

Ribose::Event.create(
  calendar_id,
  name: "Sample Event",
  date_start: "04/04/2018",
  time_start: "4:30pm",
  date_finish: "04/04/2018",
  time_finish: "5:30pm",
  recurring_type: "not_repeat",
  until: "never",
  repeat_every: "1",
  where: "Skype",
  description: "Sample event",
  all_day: false,
)

Update a calendar event

Ribose::Event.update(
  calendar_id, event_id, new_attributes_hash, options_params
)

Delete a calendar event

Ribose::Event.delete(calendar_id, event_id)

User

Create a signup request

Ribose::User.create(email: "user@example.com", **other_attributes)

Activate a signup request

Ribose::User.activate(
  email:    "user@example.com",
  password: "ASecureUserPassword",
  otp:      "OTP Recived via the Email",
)

Wikis

List wiki pages

Ribose::Wiki.all(space_id, options = {})

Fetch a wiki page

Ribose::Wiki.fetch(space_id, wiki_id, options = {})

Create a wiki page

Ribose::Wiki.create(
  space_id, name: "Wiki Name", tag_list: "sample", **other_attributes_hash
)

Update a wiki page

Ribose::Wiki.update(
  space_id, wiki_id, **updated_attributes_hash
)

Remove a wiki page

Ribose::Wiki.delete(space_id, wiki_id)

Space categories

List space categories

Ribose::SpaceCategory.all

Development

We are following Sandi Metz’s Rules for this gem, you can read the description of the rules here All new code should follow these rules. If you make changes in a pre-existing file that violates these rules you should fix the violations as part of your contribution.

Setup

Clone the repository.

git clone https://github.com/riboseinc/ribose-ruby

Setup your environment.

bin/setup

Run the test suite

bin/rspec

Contributing

First, thank you for contributing! We love pull requests from everyone. By participating in this project, you hereby grant Ribose Inc. the right to grant or transfer an unlimited number of non exclusive licenses or sub-licenses to third parties, under the copyright covering the contribution to use the contribution by all means.

Here are a few technical guidelines to follow:

  1. Open an issue to discuss a new feature.

  2. Write tests to support your new feature.

  3. Make sure the entire test suite passes locally and on CI.

  4. Open a Pull Request.

  5. Squash your commits after receiving feedback.

  6. Party!

Credits

This gem is developed, maintained and funded by Ribose Inc.

License

The gem is available as open source under the terms of the MIT License.