bitly 1.1.2 → 2.0.0.beta.1

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "bitly"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/oauth

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "bitly"
+require "envyable"
+
+Envyable.load('./config/env.yml')
+
+oauth = Bitly::OAuth.new(client_id: ENV['CLIENT_ID'], client_secret: ENV['CLIENT_SECRET'])
+puts oauth.authorize_uri('http://example.com/oauth/redirect')

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bitly.gemspec

@@ -1,38 +1,33 @@
-# -*- encoding: utf-8 -*-
-# stub: bitly 1.1.0 ruby lib
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'bitly/version'
+require "bitly/version"
 
 Gem::Specification.new do |spec|
-  spec.name                   = "bitly"
-  spec.version                = Bitly::VERSION
-  spec.authors                = ["Phil Nash"]
-  spec.email                  = "philnash@gmail.com"
-
-  spec.summary                = "Use the bit.ly API to shorten or expand URLs"
-  spec.description            = "Use the bit.ly API to shorten or expand URLs"
-  spec.homepage               = "http://github.com/philnash/bitly"
-  spec.license                = "MIT"
+  spec.name          = "bitly"
+  spec.version       = Bitly::VERSION
+  spec.authors       = ["Phil Nash"]
+  spec.email         = ["philnash@gmail.com"]
 
-  spec.files                  = `git ls-files -z`.split("\x0")
-  spec.executables            = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files             = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths          = ["lib"]
-  spec.required_ruby_version  = '>= 1.8.7'
+  spec.summary       = %q{Use the bit.ly API to shorten or expand URLs}
+  spec.description   = %q{Use the bit.ly API to shorten or expand URLs. Check out the API documentation at https://dev.bitly.com/.}
+  spec.homepage      = "https://github.com/philnash/bitly"
+  spec.license       = "MIT"
 
-  spec.rdoc_options           = ["--line-numbers", "--title", "Bitly", "--main", "README.md"]
-  spec.extra_rdoc_files       = ["LICENSE.md", "README.md"]
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "multi_json", "~> 1.3"
-  spec.add_runtime_dependency "httparty", ">= 0.7.6"
-  spec.add_runtime_dependency "oauth2", "< 2.0", ">= 0.5.0"
-  spec.add_runtime_dependency "rack", "<2" if RUBY_VERSION.to_f < 2.2
+  spec.add_dependency "oauth2", "< 2.0", ">= 0.5.0"
 
-  spec.add_development_dependency "bundler", "~> 1.15"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "shoulda", "~> 3.5.0"
-  spec.add_development_dependency "flexmock"
-  spec.add_development_dependency "webmock"
-  spec.add_development_dependency "minitest", "~> 5.8.3"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov", "~> 0.17.1"
+  spec.add_development_dependency "webmock", "~> 3.7.6"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "envyable"
 end

data/config/env.yml.example

@@ -0,0 +1,5 @@
+CLIENT_ID:
+CLIENT_SECRET:
+OAUTH_CODE:
+USERNAME:
+PASSWORD:

data/docs/authentication.md

@@ -0,0 +1,51 @@
+# Authentication
+
+Bitly requires OAuth access tokens to use the API. You will need to [register your application with the Bitly API](bitly.com/a/oauth_apps), you will get a `client_id` and `client_secret`.
+
+There are 3 methods you can use to get an OAuth access token:
+
+- [Account Generic Access Token](#account-generic-access-token)
+- [OAuth Web Flow](#oauth-web-flow)
+- [Resource Owner Credential Grant Flow](#resource-owner-credential-grant-flow)
+
+## Account Generic Access Token
+
+You can get your own OAuth token for your account from the [Bitly console](https://app.bitly.com/). Click on the account drop down menu, then _Profile Settings_ then _Generic Access Token_. Fill in your password and you can generate an OAuth access token.
+
+## OAuth Web Flow
+
+Redirect the user to the Bitly authorization page using your `client_id` and a `redirect_uri` that Bitly should redirect your user to after authorization. You can get the URL like so:
+
+```ruby
+oauth = Bitly::OAuth.new(client_id: client_id, client_secret: client_secret)
+oauth.authorize_uri("http://myexamplewebapp.com/oauth_page")
+#=> "https://bitly.com/oauth/authorize?client_id=client_id&redirect_uri=http%3A%2F%2Fmyexamplewebapp.com%2Foauth_page"
+```
+
+You can pass an optional `state` parameter that will be included, unchanged, in the redirect.
+
+```ruby
+oauth.authorize_uri("http://myexamplewebapp.com/oauth_page", state: "state")
+#=> "https://bitly.com/oauth/authorize?client_id=client_id&redirect_uri=http%3A%2F%2Fmyexamplewebapp.com%2Foauth_page&state=state"
+```
+
+Once the user has authorized you to use their Bitly account, you will get a
+`code` parameter in the redirect. You can exchange that code, along with the
+redirect_uri, for the access token.
+
+```ruby
+oauth.access_token(redirect_uri: "http://myexamplewebapp.com/oauth_page", code: "code")
+#=> "<ACCESS_TOKEN>"
+```
+
+## Resource Owner Credential Grant Flow
+
+If you cannot perform a web flow, the resource owner credential grant flow allows you to take a user's username and password and exchange it for an OAuth access token. If you use this method you _should_ store only the user's access token and never the password.
+
+To use the resource owner credential grant flow, create an OAuth client object then request the access token with the username and password:
+
+```ruby
+oauth = Bitly::OAuth.new(client_id: client_id, client_secret: client_secret)
+oauth.access_token(username: username, password: password)
+#=> "<ACCESS_TOKEN>"
+```

data/docs/bitlinks.md

@@ -0,0 +1,2 @@
+# Bitlinks
+

data/docs/branded_short_domains.md

@@ -0,0 +1,20 @@
+# Branded Short Domains
+
+BSDs is an acronym for branded short domains. A branded short domain is a custom 15 character or less domain for bitlinks. This allows you to customize the domain to your brand.
+
+See the full [Bitly API documentation for BSDs](https://dev.bitly.com/v4/#tag/BSDs).
+
+## List BSDs
+
+With an API client you can list the BSDs available to the authorized user.
+
+```ruby
+client = Bitly::API::Client.new(token: token)
+bsds = client.bsds
+```
+
+Or with the class method
+
+```ruby
+bsds = Bitly::API::BSD.list(client: client)
+```

data/docs/groups.md

@@ -0,0 +1,80 @@
+# Groups
+
+Groups are a subdivision within an [organization](./organizations.md). A [user](./users.md) belongs to a group within an organization. Most actions in the API are on behalf of a group. For example, when you shorten a link, it will be on behalf of a user and a group.
+
+See the full [Bitly API documentation for Groups](https://dev.bitly.com/v4/#tag/Groups).
+
+## List Groups
+
+With an API client you can list the groups available to the authorized user.
+
+```ruby
+client = Bitly::API::Client.new(token: token)
+groups = client.groups
+```
+
+Or with the class method
+
+```ruby
+groups = Bitly::API::Group.list(client: client)
+```
+
+You can also filter groups by an organization guid or an organization object, using the client.
+
+```ruby
+groups = client.groups(organization: organization_guid)
+groups = client.groups(organization: organization)
+```
+
+Or the class method
+
+```ruby
+groups = Bitly::API::Group.list(client: client, organization: organization_guid)
+groups = Bitly::API::Group.list(client: client, organization: organization)
+```
+
+## Fetch a Group
+
+If you have the guid of an group, you can fetch it directly.
+
+```ruby
+group = client.group(guid)
+```
+
+Or with the class method
+
+```ruby
+group = Bitly::API::Group.fetch(client: client, guid: guid)
+```
+
+## Group attributes
+
+Groups have the following attributes:
+
+* `name`
+* `guid`
+* `is_active`
+* `role`
+* `bsds`
+* `organization_guid`
+* `created`
+* `modified`
+
+### A Group's organization
+
+With the `organization_guid` we can get the group's organization directly from the group object.
+
+```ruby
+organization = group.organization
+```
+
+### Group preferences
+
+You can set one preference for a group, the domain that is used to shorten links. Free accounts can only choose `bit.ly` and pro accounts can use any domains they have set up.
+
+```ruby
+preferences = group.preferences
+puts preferences.domain_preference
+
+preferences.update(domain_preference: 'bit.ly')
+```

data/docs/oauth_apps.md

@@ -0,0 +1,20 @@
+# OAuth Apps
+
+You can fetch the details of an OAuth app you have in your account by the `client_id`.
+
+See the full [Bitly documentation for OAuth apps](https://dev.bitly.com/v4/#operation/getOAuthApp)
+
+## Fetch an OAuth app
+
+With the `client_id` of an OAuth app, you can fetch it directly.
+
+```ruby
+client = Bitly::API::Client.new(token: token)
+oauth_app = client.oauth_app(client_id: client_id)
+```
+
+Or with the class method
+
+```ruby
+oauth_app = Bitly::API::OAuthApp.fetch(client: client, client_id: client_id)
+```

data/docs/organizations.md

@@ -0,0 +1,74 @@
+# Organizations
+
+An organization is the top level of the Bitly user hierarchy. Both [Users](./users.md) and [Groups](./groups.md) live within an organization.
+
+See the full [Bitly API documentation for Organizations](https://dev.bitly.com/v4/#tag/Organizations).
+
+## List Organizations
+
+With an API client you can list the organizations available to the authorized user.
+
+```ruby
+client = Bitly::API::Client.new(token: token)
+organizations = client.organizations
+```
+
+Or with the class method:
+
+```ruby
+organizations = Bitly::API::Organization.list(client: client)
+```
+
+## Fetch an Organization
+
+If you have the guid of an organization, you can fetch it directly.
+
+```ruby
+client = Bitly::API::Client.new(token: token)
+organization = client.organization(guid)
+```
+
+Or with the class method
+
+```ruby
+organization = Bitly::API::Organization.fetch(client: client, organization_guid: guid)
+```
+
+## Organization attributes
+
+Organizations have the following attributes:
+
+* `name`
+* `guid`
+* `is_active`
+* `tier`
+* `tier_family`
+* `tier_display_name`
+* `role`
+* `bsds`
+* `created`
+* `modified`
+
+### Organization groups
+
+With an organization you can fetch its related [groups](./groups.md).
+
+```ruby
+client = Bitly::API::Client.new(token: token)
+organization = client.organization(guid)
+groups = organization.groups
+```
+
+This is the same as fetching groups and filtering by an organization guid.
+
+```ruby
+client = Bitly::API::Client.new(token: token)
+organization = client.organization(guid)
+groups = client.groups(organization: organization)
+```
+
+Or filtering in the class method directly.
+
+```ruby
+groups = Bitly::API::Group.list(client: client, organization: organization)
+```

data/docs/users.md

@@ -0,0 +1 @@
+# Users

data/lib/bitly.rb

@@ -1,8 +1,7 @@
-require 'multi_json'
+# frozen_string_literal: true
 
-require 'bitly/config'
-require 'bitly/utils'
-require 'bitly/client'
-require 'bitly/url'
-require 'bitly/version'
-require 'bitly/v3'
+require "bitly/version"
+require "bitly/error"
+require "bitly/oauth"
+require "bitly/http"
+require "bitly/api"

data/lib/bitly/api.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bitly
+  module API
+    BASE_URL = URI("https://api-ssl.bitly.com/v4")
+  end
+end
+
+require_relative "./api/client"
+require_relative "./api/click_metric"
+require_relative "./api/bitlink"
+require_relative "./api/organization"
+require_relative "./api/group"
+require_relative "./api/user"
+require_relative "./api/bsd"
+require_relative "./api/oauth_app"

data/lib/bitly/api/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Bitly
+  module API
+    module Base
+      attr_reader :response
+
+      def assign_attributes(attributes)
+        if self.class.respond_to?(:attributes)
+          self.class.attributes.each do |attr|
+            instance_variable_set("@#{attr}", attributes[attr.to_s]) if attributes[attr.to_s]
+          end
+        end
+        if self.class.respond_to?(:time_attributes)
+          self.class.time_attributes.each do |attr|
+            instance_variable_set("@#{attr}", Time.parse(attributes[attr.to_s])) if attributes[attr.to_s]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitly/api/bitlink.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+require_relative "./base"
+require_relative "./list"
+require_relative "./bitlink/paginated_list"
+require_relative "./bitlink/deeplink"
+require_relative "./bitlink/clicks_summary"
+require_relative "./bitlink/link_click"
+
+module Bitly
+  module API
+    ##
+    # A Bitlink represents a shortened link within Bitly.
+    class Bitlink
+      include Base
+
+      class List < Bitly::API::List ; end
+
+      ##
+      # Shortens a long url.
+      # [`POST /v4/shorten`](https://dev.bitly.com/v4/#operation/createBitlink)
+      #
+      # @example
+      #     bitlink = Bitly::API::Bitlink.shorten(client: client, long_url: long_url)
+      #
+      # @param client [Bitly::API::Client] An authorized API client
+      # @param long_url [String] A long URL that you want shortened
+      # @param domain [String] The bitly domain you want to shorten, API default
+      #     is "bit.ly"
+      # @param group_guid [String] The GUID of the group for which you want to
+      #     shorten this URL
+      #
+      # @return [Bitly::API::Bitlink]
+      def self.shorten(client:, long_url:, domain: nil, group_guid: nil)
+        response = client.request(
+          path: "/shorten",
+          method: "POST",
+          params: {
+            "long_url" => long_url,
+            "domain" => domain,
+            "group_guid" => group_guid
+          })
+        new(data: response.body, client: client, response: response)
+      end
+
+      ##
+      # Creates a new Bitlink from a long URL. Similar to #shorten but takes
+      # more parameters.
+      # [`POST /v4/bitlinks`](https://dev.bitly.com/v4/#operation/createFullBitlink)
+      #
+      # @example
+      #     bitlink = Bitly::API::Bitlink.create(client: client, long_url: long_url)
+      #
+      # @param client [Bitly::API::Client] An authorized API client
+      # @param long_url [String] A long URL that you want shortened
+      # @param domain [String] The bitly domain you want to shorten, API default
+      #     is "bit.ly"
+      # @param group_guid [String] The GUID of the group for which you want to
+      #     shorten this URL
+      # @param title [String] A descriptive title for the link
+      # @param tags [Array<String>] Some tags for the Bitlink
+      # @param deeplinks [Array<Bitly::API::Bitlink::Deeplink>]
+      #
+      # @return [Bitly::API::Bitlink]
+      def self.create(client:, long_url:, domain: nil, group_guid: nil, title: nil, tags: nil, deeplinks: nil)
+        response = client.request(
+          path: "/bitlinks",
+          method: "POST",
+          params: {
+            "long_url" => long_url,
+            "domain" => domain,
+            "group_guid" => group_guid,
+            "title" => title,
+            "tags" => tags,
+            "deeplinks" => deeplinks
+          }
+        )
+        new(data: response.body, client: client, response: response)
+      end
+
+      ##
+      # Return information about a bitlink
+      # [`GET /v4/bitlink/{bitlink}`](https://dev.bitly.com/v4/#operation/getBitlink)
+      #
+      # @example
+      #     bitlink = Bitly::API::Bitlink.fetch(client: client, bitlink: "bit.ly/example")
+      #
+      # @param client [Bitly::API::Client] An authorized API client
+      # @param bitlink [String] The bitlink you want information about
+      #
+      # @return [Bitly::API::Bitlink]
+      def self.fetch(client:, bitlink:)
+        response = client.request(path: "/bitlinks/#{bitlink}")
+        new(data: response.body, client: client, response: response)
+      end
+
+      ##
+      # Return public information about a bitlink
+      # [`POST /v4/expand`](https://dev.bitly.com/v4/#operation/expandBitlink)
+      #
+      # @example
+      #     bitlink = Bitly::API::Bitlink.expand(client: client, bitlink: "bit.ly/example")
+      #
+      # @param client [Bitly::API::Client] An authorized API client
+      # @param bitlink [String] The bitlink you want information about
+      #
+      # @return [Bitly::API::Bitlink]
+      def self.expand(client:, bitlink:)
+        response = client.request(path: "/expand", method: "POST", params: { "bitlink_id" => bitlink })
+        new(data: response.body, client: client, response: response)
+      end
+
+      ##
+      # Retrieve a list of bitlinks by group
+      # [`GET /v4/groups/{group_guid}/bitlinks`](https://dev.bitly.com/v4/#operation/getBitlinksByGroup)
+      #
+      # @example
+      #     bitlinks = Bitly::API::Bitlink.list(client: client, group_guid: guid)
+      #
+      # @param client [Bitly::API::Client] An authorized API client
+      # @param group_guid [String] The group guid for which you want bitlinks
+      # @param size [Integer] The number of Bitlinks to return, max 100
+      # @param page [Integer] The page of bitlinks to request
+      # @param keyword [String] Custom keyword to filter on history entries
+      # @param query [String] A value to search for Bitlinks
+      # @param created_before [Integer] Timestamp as an integer unix epoch
+      # @param created_after [Integer] Timestamp as an integer unix epoch
+      # @param modified_after [Integer] Timestamp as an integer unix epoch
+      # @param archived [String] Whether or not to include archived Bitlinks.
+      #     One of "on", "off" or "both". Defaults to "off".
+      # @param deeplinks [String] Filter to only Bitlinks that contain
+      #     deeplinks. One of "on", "off" or "both". Defaults to "both".
+      # @param domain_deeplinks [String] Filter to only Bitlinks that contain
+      #     deeplinks configured with a custom domain. One of "on", "off" or
+      #     "both". Defaults to "both".
+      # @param campaign_guid [String] Filter to return only links for the given
+      #     campaign GUID, can be provided
+      # @param channel_guid [String] Filter to return only links for the given
+      #     channel GUID, can be provided, overrides all other parameters
+      # @param custom_bitlink [String] Filter to return only custom Bitlinks.
+      #     One of "on", "off" or "both". Defaults to "both".
+      # @param tags [Array<String>] Filter by the given tags.
+      # @param encoding_login [Array<String>] Filter by the login of the
+      #     authenticated user that created the Bitlink.
+      #
+      # @return [Bitly::API::Bitlink::PaginatedList]
+      def self.list(
+        client:,
+        group_guid:,
+        size: nil,
+        page: nil,
+        keyword: nil,
+        query: nil,
+        created_before: nil,
+        created_after: nil,
+        modified_after: nil,
+        archived: nil,
+        deeplinks: nil,
+        domain_deeplinks: nil,
+        campaign_guid: nil,
+        channel_guid: nil,
+        custom_bitlink: nil,
+        tags: nil,
+        encoding_login: nil
+      )
+        params = {
+          "size" => size,
+          "page" => page,
+          "keyword" => keyword,
+          "query" => query,
+          "created_before" => created_before,
+          "created_after" => created_after,
+          "modified_after" => modified_after,
+          "archived" => archived,
+          "deeplinks" => deeplinks,
+          "domain_deeplinks" => domain_deeplinks,
+          "campaign_guid" => campaign_guid,
+          "channel_guid" => channel_guid,
+          "custom_bitlink" => custom_bitlink,
+          "tags" => tags,
+          "encoding_login" => encoding_login
+        }
+        response = client.request(path: "/groups/#{group_guid}/bitlinks", params: params)
+        bitlinks = response.body["links"].map do |link|
+          new(data: link, client: client)
+        end
+        PaginatedList.new(items: bitlinks, response: response, client: client)
+      end
+
+      ##
+      # Returns a list of Bitlinks sorted by clicks.
+      # [`GET /v4/groups/{group_guid}/bitlinks/{sort}`](https://dev.bitly.com/v4/#operation/getSortedBitlinks)
+      #
+      # The API returns a separate list of the links and the click counts, but
+      # this method assigns the number of clicks for each link to the Bitlink
+      # object and sorts the resulting list in descending order.
+      #
+      # Sorted lists are not paginated, so do not have any pagination detail.
+      #
+      # @example
+      #     links = Bitly::API::Bitlink.sorted_list(client: client, group_guid: guid)
+      #
+      # @param client [Bitly::API::Client] An authorized API client
+      # @param group_guid [String] The group for which you want to return links
+      # @param sort [String] The data to sort on. Default and only option is
+      #     "clicks".
+      # @param unit [String] A unit of time. Default is "day" and can be
+      #     "minute", "hour", "day", "week" or "month"
+      # @param units [Integer] An integer representing the time units to query
+      #     data for. pass -1 to return all units of time. Defaults to -1.
+      # @param unit_reference [String] An ISO-8601 timestamp, indicating the
+      #     most recent time for which to pull metrics. Will default to current
+      #     time.
+      # @param size [Integer] The number of links to be returned. Defaults to 50
+      #
+      # @returns [Bitly::API::Bitlink::List]
+      def self.sorted_list(client:, group_guid:, sort: "clicks", unit: nil, units: nil, unit_reference: nil, size: nil)
+        params = {
+          "unit" => unit,
+          "units" => units,
+          "unit_reference" => unit_reference,
+          "size" => size
+        }
+        response = client.request(path: "/groups/#{group_guid}/bitlinks/#{sort}", params: params)
+        link_clicks = response.body["sorted_links"]
+        bitlinks = response.body["links"].map do |link|
+          clicks = link_clicks.find { |c| c["id"] == link["id"] }["clicks"]
+          new(data: link, client: client, clicks: clicks)
+        end.sort { |a, b| b.clicks <=> a.clicks }
+        List.new(items: bitlinks, response: response)
+      end
+
+      def self.attributes
+        [:archived, :tags, :title, :created_by, :long_url, :client_id, :custom_bitlinks, :link, :id]
+      end
+      def self.time_attributes
+        [:created_at]
+      end
+      attr_reader(*(attributes + time_attributes))
+      attr_reader :deeplinks, :clicks
+
+      def initialize(data:, client:, response: nil, clicks: nil)
+        assign_attributes(data)
+        if data["deeplinks"]
+          @deeplinks = data["deeplinks"].map { |data| Deeplink.new(data: data) }
+        else
+          @deeplinks = []
+        end
+        @clicks = clicks
+        @client = client
+        @response = response
+      end
+
+      ##
+      # Update the Bitlink.
+      # [`PATCH /v4/bitlink/{bitlink}`](https://dev.bitly.com/v4/#operation/updateBitlink)
+      #
+      # The parameters listed below are from the documentation. Some only work
+      # if you have a Bitly Pro account.
+      #
+      # @example
+      #     bitlink.update(title: "New title")
+      #
+      # @param archived [Boolean]
+      # @param tags [Array<String>]
+      # @param created_at [String]
+      # @param title [String]
+      # @param deeplinks [Array<Bitly::API::Bitlink::Deeplink>]
+      # @param created_by [String]
+      # @param long_url [String]
+      # @param client_id [String]
+      # @param custom_bitlinks [Array<String>]
+      # @param link [String]
+      # @param id [String]
+      # @param references [Hash<String, String>]
+      #
+      # @returns [Bitly::API::Bitlink]
+      def update(
+        archived: nil,
+        tags: nil,
+        created_at: nil,
+        title: nil,
+        deeplinks: nil,
+        created_by: nil,
+        long_url: nil,
+        client_id: nil,
+        custom_bitlinks: nil,
+        link: nil,
+        id: nil,
+        references: nil
+      )
+        @response = @client.request(
+          path: "/bitlinks/#{@id}",
+          method: "PATCH",
+          params: {
+            "archived" => archived,
+            "tags" => tags,
+            "created_at" => created_at,
+            "title" => title,
+            "deeplinks" => deeplinks,
+            "created_by" => created_by,
+            "long_url" =>long_url ,
+            "client_id" => client_id,
+            "custom_bitlinks" => custom_bitlinks,
+            "link" => link,
+            "id" => id,
+            "references" => references
+          }
+        )
+        assign_attributes(@response.body)
+        self
+      end
+
+      # [`GET /v4/bitlink/{bitlink}/clicks/summary`](https://dev.bitly.com/v4/#operation/getClicksSummaryForBitlink)
+      #
+      # @return [Bitly::API::Bitlink::ClicksSummary]
+      def clicks_summary(unit: nil, units: nil, unit_reference: nil, size: nil)
+        ClicksSummary.fetch(client: @client, bitlink: id, unit: unit, units: units, unit_reference: unit_reference, size: size)
+      end
+
+      ##
+      # Get the clicks for the bitlink.
+      # [`GET /v4/bitlink/{bitlink}/clicks`](https://dev.bitly.com/v4/#operation/getClicksForBitlink)
+      #
+      # @param sort [String] The data to sort on. Default and only option is
+      #     "clicks".
+      # @param unit [String] A unit of time. Default is "day" and can be
+      #     "minute", "hour", "day", "week" or "month"
+      # @param units [Integer] An integer representing the time units to query
+      #     data for. pass -1 to return all units of time. Defaults to -1.
+      # @param unit_reference [String] An ISO-8601 timestamp, indicating the
+      #     most recent time for which to pull metrics. Will default to current
+      #     time.
+      # @param size [Integer] The number of links to be returned. Defaults to 50
+      #
+      # @return [Bitly::API::Bitlink::LinkClick::List]
+      def link_clicks(unit: nil, units: nil, unit_reference: nil, size: nil)
+        LinkClick.list(client: @client, bitlink: id, unit: unit, units: units, unit_reference: unit_reference, size: size)
+      end
+    end
+  end
+end