unifi_protect 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c9f531ea3f45970257279878bed41050c57a9bfbf78ae14c4362bee0bf9dcad8
+  data.tar.gz: 0da6092519243113650c727c33939043489ff1bfc441696d9b5b03adeccba6d3
+SHA512:
+  metadata.gz: 3a1e445d5190bf05f1e6435880dd2d8a68a019487f3ee09ddb853e1119bc9210e926f4394e03861686ba0b67c7dd1675c9a323ac2876bd73176333e499217c0d
+  data.tar.gz: 834f56311e33ac98adedbdf8837e9ad4a82b42b171775ec4eede72a9369fce7b00b2f36e9389abef21ac4448869bba8faaef41299c943278ca9af2aa665c5b52

data/.gitignore

@@ -0,0 +1,21 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/out/
+
+/*.mp4
+/*.jpg
+
+/*.gem
+
+# rspec failure tracking
+.rspec_status
+
+# RubyMine files
+.rakeTasks
+.idea

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,32 @@
+AllCops:
+  TargetRubyVersion: 2.6
+Lint/AmbiguousOperator:
+  Enabled: false
+Layout/LineLength:
+  Max: 120
+Metrics/BlockLength:
+  Max: 400
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+Style/FormatString:
+  Enabled: false
+Style/FormatStringToken:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+Style/SymbolArray:
+  MinSize: 1
+Style/EmptyCaseCondition:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.6
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in unifi_protect.gemspec
+gemspec
+
+gem 'rake', '~> 12.0'
+gem 'rspec', '~> 3.0'

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    unifi_protect (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (12.3.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  unifi_protect!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Jeremy Cole
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+# An unofficial UniFi Protect API in Ruby
+
+![Build Status for jeremycole/unifi_protect](https://travis-ci.org/jeremycole/unifi_protect.svg?branch=master)
+
+This is an implementation of (parts of) [UniFi Protect](https://unifi-network.ui.com/building-security) API, which is primarily designed to support the local web interface. The API allows access to camera configuration, status, and of course the ability to collect real-time snapshots and export recorded video from the NVR.
+
+Currently the API implemented in this Gem is read-only, but I do hope to allow setting at least some configuration such as camera parameters via the API. (For example, enabling or disabling IR modes, or zoom levels for cameras supporting optical zoom.)
+
+_**Note**_: The details of the UniFi Protect API are unpublished and potentially unstable, so this is an unofficial and potentially equally unstable implementation of that API. This implementation is partly based on the Python [`unifi-protect-video-downloader`](https://github.com/unifi-toolbox/unifi-protect-video-downloader) script, as well as inspection of the actual API interactions through the UniFi Protect web interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'unifi_protect'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install unifi_protect
+```
+
+## Usage of the library
+
+Once installed, a `UnifiProtect` module is provided and its usage is fairly straightforward:
+
+```ruby
+require 'unifi_protect'
+
+# Connect to the UniFi Protect API using HTTPS and basic authentication
+u = UnifiProtect::Client.new(host: '1.2.3.4', username: 'bob', password: 'secret')
+
+# Fetch all cameras as a CameraCollection:
+u.cameras 
+
+# Return a CameraCollection for all cameras matching a Regexp:
+u.cameras.match(name: /house/i) 
+
+# Some attributes can be filtered more simply, for example currently-connected cameras:
+u.cameras.connected
+
+# Filters can be chained together as they return new CameraCollection objects:
+u.cameras.connected.recording.match(name: /^barn/i)
+
+# If a single match is expected, #fetch will return #first from the collection directly:
+c = u.cameras.fetch(name: 'Front Door')
+
+# Once a Camera object is obtained, the current snapshot (in practice, one from within the past few
+# seconds, cached by the NVR) can be retrieved from it using #snapshot, which returns a DownloadedFile
+# object with #file and #size attributes:
+d = c.snapshot
+
+# => #<struct UnifiProtect::API::DownloadedFile file="5f33454c00d21103e701d84f_1598726026000.jpg", size=236855>
+
+# Recorded video can be exported from the NVR as well, given a start_time and end_time; this returns
+# a DownloadedFile object as well:
+d = c.video_export(start_time: Time.now - 10, end_time: Time.now)
+
+# => #<struct UnifiProtect::API::DownloadedFile file="5f33454c00d21103e701d84f_1598725975000_1598725985000.mp4", size=1019346>
+```
+
+## Usage of the command-line tool
+
+A simple command-line tool is provided to make it especially easy to download snapshots and video from one or more cameras without doing any Ruby programming.
+
+Listing cameras is simple using `--list-cameras` and supports a number of filters, such as `id`, `name`, `connected`, `recording`, etc.:
+
+```
+$ unifi_protect -H 1.2.3.4 -u bob -p secret --connected --name 'House' --list-cameras
+ID                            Name                                    Type                State               
+xxxxxxxxxxxxxxxxxxxxxxxx      Back of House Looking West              UVC G3 Flex         CONNECTED           
+yyyyyyyyyyyyyyyyyyyyyyyy      Barn towards House                      UVC G3 Pro          CONNECTED           
+zzzzzzzzzzzzzzzzzzzzzzzz      Back of House Looking South             UVC G3 Flex         CONNECTED           
+```
+
+More advanced filtering can be done using `--match`, `--match-i` and `--exact` arguments:
+
+```
+$ unifi_protect -H 1.2.3.4 -u bob -p secret --connected --match-i type=doorbell --list-cameras
+
+ID                            Name                                    Type                State
+xxxxxxxxxxxxxxxxxxxxxxxx      Front Door                              UVC G4 Doorbell     CONNECTED
+```
+
+More information about each camera can be obtained with `--describe-cameras`:
+
+```
+$ unifi_protect -H 1.2.3.4 -u bob -p secret --id yyyyyyyyyyyyyyyyyyyyyyyy --describe-cameras
+
+Id                  : yyyyyyyyyyyyyyyyyyyyyyyy
+Name                : Barn towards House
+Type                : UVC G3 Pro
+Mac                 : AABBCCDDEEFF
+State               : CONNECTED
+Hardware Revision   : 16
+Firmware Version    : 4.26.13
+Firmware Build      : 8a76001.200825.1028
+Up Since            : 2020-08-25 06:15:04 -0700
+Connected Since     : 2020-08-25 06:15:35 -0700
+Last Motion         : 2020-08-28 05:22:26 -0700
+Last Ring           : (none)
+Last Seen           : 2020-08-29 11:37:59 -0700
+```
+
+A current snapshot can be downloaded from each matched camera using `--snapshot`:
+
+```
+$ unifi_protect -H 1.2.3.4 -u bob -p secret --id yyyyyyyyyyyyyyyyyyyyyyyy --snapshot
+
+Downloading snapshot from yyyyyyyyyyyyyyyyyyyyyyyy, Barn towards House... OK, 427 KiB.
+```
+
+Recorded video can be exported from each matched camera using `--video-export` with appropriate `--start-time` and either `--end-time` or `--duration` parameters:
+
+```
+$ unifi_protect -H 1.2.3.4 -u bob -p secret --name '^Barn' --video-export --start-time '2020-08-29 11:00:00 PDT' --duration 30s
+
+Exporting video for 2 cameras from 2020-08-29 11:00:00 -0700 to 2020-08-29 11:00:30 -0700.
+
+Downloading video from xxxxxxxxxxxxxxxxxxxxxxxx, Barn Driveway... OK, 3256 KiB.
+Downloading video from yyyyyyyyyyyyyyyyyyyyyyyy, Barn towards House... OK, 3364 KiB.
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome [through GitHub](https://github.com/jeremycole/unifi_protect).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'unifi_protect'
+
+# 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/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/exe/unifi_protect

@@ -0,0 +1,317 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require 'ostruct'
+require 'time'
+require 'unifi_protect'
+
+class UnifiProtectCommand
+  class BadOptionError < StandardError; end
+
+  NVR_FIELDS = %i[
+    id
+    name
+    type
+    mac
+    host
+    version
+    hardwareId
+    hardwarePlatform
+    hardwareRevision
+    firmwareVersion
+    upSince
+  ].freeze
+
+  CAMERA_FIELDS = %i[
+    id
+    name
+    type
+    mac
+    state
+    hardwareRevision
+    firmwareVersion
+    firmwareBuild
+    upSince
+    connectedSince
+    lastMotion
+    lastRing
+    lastSeen
+  ].freeze
+
+  attr_reader :options
+  attr_reader :option_parser
+
+  def initialize
+    initialize_options
+  end
+
+  def initialize_options
+    @options = OpenStruct.new(
+      host: nil,
+      port: 7443,
+      username: nil,
+      password: nil,
+      mode: [],
+      match: OpenStruct.new
+    )
+  end
+
+  DURATIONS = { 'd' => 24 * 60 * 60, 'h' => 60 * 60, 'm' => 60, 's' => 1 }.freeze
+
+  def parse_duration(str)
+    str.split(/([dhms])/).map { |t| DURATIONS[t] || t.to_i }.each_slice(2).map { |t, m| t * (m || 1) }.sum
+  end
+
+  def match_value(value)
+    return true if value == 'true'
+    return false if value == 'false'
+
+    value
+  end
+
+  def add_matcher(field, matcher)
+    options.match[field] ||= []
+    options.match[field] << match_value(matcher)
+  end
+
+  def parse_options(args)
+    @option_parser = OptionParser.new do |opts|
+      opts.on('-h', '--help', 'Show this help.') do
+        puts opts
+        exit 0
+      end
+
+      opts.on('-H', '--host=HOST', 'Hostname of the UniFi Protect controller.') { |o| options.host = o }
+      opts.on('-P', '--port=PORT', 'TCP Port of the UniFi Protect controller.') { |o| options.port = o.to_i }
+      opts.on('-u', '--username=USERNAME', 'Username for HTTP basic authentication.') { |o| options.username = o }
+      opts.on('-p', '--password=PASSWORD', 'Password for HTTP basic authentication.') { |o| options.password = o }
+
+      opts.on('--describe-nvr', 'Describe NVR in detail.') { options.mode << :describe_nvr }
+
+      opts.on('--list-cameras', 'List all matched cameras.') { options.mode << :list_cameras }
+      opts.on('--describe-cameras', 'Describe all matched cameras in detail.') { options.mode << :describe_cameras }
+
+      opts.on('-o', '--output-path=PATH', 'Specify a local path to save downloaded files to.') do |o|
+        options.output_path = o
+      end
+
+      opts.on('--snapshot', 'Download a recent snapshot from each matched camera.') { options.mode << :snapshot }
+
+      opts.on('--video-export', 'Download saved video for each matched camera.') { options.mode << :video_export }
+
+      opts.on('-s', '--start-time=TIME', "Start time for video, e.g. '2020-08-29 01:02:00 PDT'.") do |o|
+        options.start_time = Time.parse(o)
+      end
+
+      opts.on('-e', '--end-time=TIME', "End time for video, e.g. '2020-08-29 01:02:30 PDT'.") do |o|
+        options.end_time = Time.parse(o)
+      end
+
+      opts.on('-d', '--duration=DURATION', "Duration of video with units, e.g. '10s', '2m30s', or '1h10m'.") do |o|
+        options.end_time = options.start_time + parse_duration(o)
+      end
+
+      opts.on('--match=MATCH', 'Match cameras by field=value case-sensitively using a regular expression.') do |o|
+        o.split(',').each do |arg|
+          field, value = arg.split('=')
+          add_matcher(field, Regexp.new(value))
+        end
+      end
+
+      opts.on('--match-i=MATCH', 'Match cameras by field=value case-insensitively using a regular expression.') do |o|
+        o.split(',').each do |arg|
+          field, value = arg.split('=')
+          add_matcher(field, Regexp.new(value, Regexp::IGNORECASE))
+        end
+      end
+
+      opts.on('--exact=MATCH', 'Match cameras by field=value using an exact string match.') do |o|
+        o.split(',').each do |arg|
+          field, value = arg.split('=')
+          add_matcher(field, value)
+        end
+      end
+
+      opts.on('--id=ID', 'Match cameras by exact camera ID.') do |o|
+        o.split(',').each { |id| add_matcher(:id, id) }
+      end
+
+      opts.on('--name=NAME', 'Match cameras by name using a case-insensitive regular expression.') do |o|
+        o.split(',').each { |name| add_matcher(:name, Regexp.new(name, Regexp::IGNORECASE)) }
+      end
+
+      opts.on('--[no-]connected', 'Match cameras currently connected.') do |o|
+        options.match.connected = o
+      end
+
+      opts.on('--[no-]recording', 'Match cameras currently recording.') do |o|
+        options.match.recording = o
+      end
+
+      opts.on('--[no-]dark', 'Match cameras currently detecting darkness.') do |o|
+        options.match.dark = o
+      end
+
+      opts.on('--[no-]motion-detected', 'Match cameras recently detecting motion.') do |o|
+        options.match.motion_detected = o
+      end
+    end
+
+    option_parser.parse!(args)
+
+    validate_options
+
+    self
+  end
+
+  def validate_options
+    raise BadOptionError, 'Missing required --host option' unless options.host
+    raise BadOptionError, 'Missing required --username option' unless options.username
+    raise BadOptionError, 'Missing required --password option' unless options.password
+
+    if options.mode.include?(:video_export) && !(options.start_time && options.end_time)
+      raise BadOptionError, 'The --video-export option requires --start-time and either --end-time or --duration'
+    end
+
+    true
+  end
+
+  def match_cameras
+    cameras = @client.cameras
+
+    options.match.to_h.each do |field, value|
+      # puts "Adding camera match filter on #{field} = #{value}"
+      case value
+      when TrueClass, FalseClass
+        cameras = cameras.filter(field, value)
+      else
+        cameras = cameras.match(field => value)
+      end
+    end
+
+    cameras
+  end
+
+  def to_name(field)
+    field.to_s.gsub(/([A-Z])/, ' \1').sub(/^[a-z]/, &:upcase)
+  end
+
+  def nvr
+    @client.nvr
+  end
+
+  def human_size(size)
+    format('%0.2f GiB', size / (1024.0 ** 3))
+  end
+
+  def describe_nvr
+    NVR_FIELDS.each do |field|
+      puts format('%-20s: %s', to_name(field), nvr.send(field) || '(none)')
+    end
+
+    puts format('%-20s:', 'Storage Info')
+    %i[totalSize totalSpaceUsed].each do |field|
+      puts format('  %-18s: %s', to_name(field), human_size(nvr.storageInfo.send(field)))
+    end
+
+    puts format('  %-18s:', 'Hard Drives')
+    nvr.storageInfo.hardDrives.each_with_index do |hd, i|
+      puts format(
+        '    %-16s: %s',
+        format('Hard Drive %d', i),
+        format(
+          '%s (size=%s, serial=%s, health=%s)',
+          hd.name,
+          human_size(hd.size),
+          hd.serial,
+          hd.health
+        )
+      )
+    end
+  end
+
+  def cameras
+    @cameras ||= match_cameras
+  end
+
+  def list_cameras
+    return if cameras.empty?
+
+    puts format('%-30s%-40s%-20s%-20s', 'ID', 'Name', 'Type', 'State')
+    cameras.each do |camera|
+      puts format('%-30s%-40s%-20s%-20s', camera.id, camera.name, camera.type, camera.state)
+    end
+  end
+
+  def describe_cameras
+    cameras.each do |camera|
+      CAMERA_FIELDS.each do |field|
+        puts format('%-20s: %s', to_name(field), camera.send(field) || '(none)')
+      end
+      puts
+    end
+  end
+
+  def snapshot
+    cameras.each do |camera|
+      print "Downloading snapshot from #{camera.id}, #{camera.name}... "
+
+      begin
+        file = camera.snapshot
+        puts format('OK, %.0f KiB.', file.size / 1024.0)
+      rescue UnifiProtect::Camera::SnapshotError => e
+        puts "Failed: #{e}"
+      end
+    end
+  end
+
+  def video_export
+    puts "Exporting video for #{cameras.count} cameras from #{options.start_time} to #{options.end_time}."
+    puts
+
+    cameras.each do |camera|
+      print "Downloading video from #{camera.id}, #{camera.name}... "
+
+      begin
+        file = camera.video_export(start_time: options.start_time, end_time: options.end_time)
+        puts format('OK, %.0f KiB.', file.size / 1024.0)
+      rescue UnifiProtect::Camera::VideoExportError => e
+        puts "Failed: #{e}"
+      end
+    end
+  end
+
+  def run
+    if options.output_path
+      raise "output path #{options.output_path} does not exist" unless File.exist?(options.output_path)
+    end
+
+    @client = UnifiProtect::Client.new(
+      host: options.host,
+      port: options.port,
+      username: options.username,
+      password: options.password,
+      download_path: options.output_path
+    )
+
+    options.mode.each do |mode|
+      case mode
+      when :describe_nvr
+        describe_nvr
+      when :list_cameras
+        list_cameras
+      when :describe_cameras
+        describe_cameras
+      when :snapshot
+        snapshot
+      when :video_export
+        video_export
+      end
+
+      puts
+    end
+  end
+end
+
+UnifiProtectCommand.new.parse_options(ARGV).run

data/lib/unifi_protect.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'unifi_protect/version'
+require 'unifi_protect/api'
+require 'unifi_protect/client'
+require 'unifi_protect/nvr'
+require 'unifi_protect/camera'
+require 'unifi_protect/camera_collection'
+
+module UnifiProtect
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/unifi_protect/api.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module UnifiProtect
+  class API
+    class RefreshBearerTokenError < StandardError; end
+    class RequestError < StandardError; end
+
+    DownloadedFile = Struct.new(:file, :size, keyword_init: true)
+
+    def initialize(host: nil, port: 7443, username: nil, password: nil, download_path: nil)
+      @host = host
+      @port = port
+      @username = username
+      @password = password
+      @download_path = download_path
+    end
+
+    def to_s
+      "#<#{self.class.name} base_uri=#{base_uri.to_s.inspect} username=#{@username.inspect}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def base_uri
+      URI::HTTPS.build(host: @host, port: @port, path: '/api/')
+    end
+
+    def uri(path:, query: nil)
+      uri = URI.join(base_uri, path)
+      uri.query = query if query
+
+      uri
+    end
+
+    def new_http_client
+      http_client = Net::HTTP.new(base_uri.host, base_uri.port)
+      http_client.use_ssl = true
+      http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      http_client
+    end
+
+    def http_client
+      @http_client ||= new_http_client
+    end
+
+    def http_post_with_username_password(uri)
+      headers = {
+        'Content-Type' => 'application/json',
+      }
+      request = Net::HTTP::Post.new(uri.request_uri, headers)
+      request.body = { username: @username, password: @password }.to_json
+
+      request
+    end
+
+    def http_post_with_bearer_token(uri, body: nil)
+      headers = {
+        'Content-Type' => 'application/json',
+        'Authorization' => 'Bearer ' + bearer_token,
+      }
+      request = Net::HTTP::Post.new(uri.request_uri, headers)
+      request.body = body
+
+      request
+    end
+
+    def http_get_with_bearer_token(uri)
+      headers = {
+        'Authorization' => 'Bearer ' + bearer_token,
+      }
+      Net::HTTP::Get.new(uri.request_uri, headers)
+    end
+
+    def http_request_with_bearer_token(uri, method: :get, body: nil)
+      return http_get_with_bearer_token(uri) if method == :get
+      return http_post_with_bearer_token(uri, body: body) if method == :post
+
+      nil
+    end
+
+    def refresh_bearer_token
+      response = http_client.request(http_post_with_username_password(uri(path: 'auth')))
+
+      raise RefreshBearerTokenError, "#{response.code} #{response.msg}: #{response.body}" unless response.code == '200'
+
+      @bearer_token = response['Authorization']
+    end
+
+    def bearer_token
+      @bearer_token ||= refresh_bearer_token
+    end
+
+    def request_with_raw_response(uri, method: :get, body: nil, exception_class: RequestError)
+      response = http_client.request(http_request_with_bearer_token(uri, method: method, body: body))
+
+      raise exception_class, "#{response.code} #{response.msg}: #{response.body}" unless response.code == '200'
+
+      response.body
+    end
+
+    def request_with_json_response(uri, method: :get, body: nil, exception_class: RequestError)
+      response = http_client.request(http_request_with_bearer_token(uri, method: method, body: body))
+
+      raise exception_class, "#{response.code} #{response.msg}: #{response.body}" unless response.code == '200'
+
+      JSON.parse(response.body, object_class: OpenStruct)
+    end
+
+    def request_with_chunked_response(uri, method: :get, body: nil, exception_class: RequestError)
+      raise 'no block provided' unless block_given?
+
+      http_client.request(http_request_with_bearer_token(uri, method: method, body: body)) do |response|
+        raise exception_class, "#{response.code} #{response.msg}: #{response.body}" unless response.code == '200'
+
+        chunk_total = 0
+        response.read_body do |chunk|
+          chunk_total += chunk.size
+          yield chunk, chunk_total, response.content_length
+        end
+
+        response
+      end
+    end
+
+    def download_file(uri, method: :get, body: nil, local_file:)
+      file = local_file
+      file = File.join(@download_path, file) if @download_path
+
+      File.open(file, 'wb') do |f|
+        r = request_with_chunked_response(uri, method: method, body: body) do |chunk, _total, _length|
+          f.write(chunk)
+        end
+
+        DownloadedFile.new(file: file, size: r.content_length)
+      end
+    end
+
+    def bootstrap_json
+      request_with_raw_response(uri(path: 'bootstrap'))
+    end
+
+    def bootstrap
+      request_with_json_response(uri(path: 'bootstrap'))
+    end
+
+    def camera_snapshot(camera:, local_file: nil, time: Time.now)
+      ts = time.utc.to_i * 1000
+      local_file ||= "#{camera}_#{ts}.jpg"
+
+      query = URI.encode_www_form(force: true, ts: ts)
+      download_file(uri(path: "cameras/#{camera}/snapshot", query: query), local_file: local_file)
+    end
+
+    def video_export(camera:, start_time:, end_time:, local_file: nil)
+      start_ts = start_time.utc.to_i * 1000
+      end_ts = end_time.utc.to_i * 1000
+      local_file ||= "#{camera}_#{start_ts}_#{end_ts}.mp4"
+
+      query = URI.encode_www_form(camera: camera, start: start_ts, end: end_ts)
+      download_file(uri(path: 'video/export', query: query), local_file: local_file)
+    end
+  end
+end

data/lib/unifi_protect/camera.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module UnifiProtect
+  class Camera
+    class SnapshotError < StandardError; end
+    class VideoExportError < StandardError; end
+
+    TIME_FIELDS = %i[upSince connectedSince lastSeen lastMotion lastRing].freeze
+
+    attr_reader :camera
+
+    def initialize(client:, camera:)
+      @client = client
+      @camera = camera
+    end
+
+    def to_s
+      "#<#{self.class.name} id=#{@camera.id.inspect} name=#{@camera.name.inspect}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @camera.respond_to?(method_name) || super
+    end
+
+    def method_missing(method_name, *args)
+      value = @camera.send(method_name, *args)
+      return Time.at(value / 1000) if value && TIME_FIELDS.include?(method_name)
+
+      value
+    end
+
+    def match(name, matcher)
+      return matcher.match(send(name)) if matcher.is_a?(Regexp)
+      return send(name) == matcher if matcher.is_a?(String) || [true, false].include?(matcher)
+      return matcher.any? { |item| match(name, item) } if matcher.is_a?(Array)
+
+      if matcher.is_a?(Hash)
+        value = send(name).send(matcher.first[0])
+        pattern = matcher.first[1]
+        return pattern.match(value)
+      end
+
+      false
+    end
+
+    def snapshot(local_file: nil)
+      @client.api.camera_snapshot(camera: id, local_file: local_file)
+    rescue UnifiProtect::API::RequestError => e
+      raise SnapshotError, e
+    end
+
+    def video_export(start_time:, end_time:, local_file: nil)
+      @client.api.video_export(camera: id, start_time: start_time, end_time: end_time, local_file: local_file)
+    rescue UnifiProtect::API::RequestError => e
+      raise VideoExportError, e
+    end
+  end
+end

data/lib/unifi_protect/camera_collection.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module UnifiProtect
+  class CameraCollection
+    extend Forwardable
+
+    attr_reader :cameras
+
+    FILTERS = {
+      adopting: :isAdopting,
+      adopted: :isAdopted,
+      provisioned: :isProvisioned,
+      attempting_to_connect: :isAttemptingToConnect,
+      managed: :isManaged,
+      updating: :isUpdating,
+      connected: :isConnected,
+      recording: :isRecording,
+      rebooting: :isRebooting,
+      deleting: :isDeleting,
+
+      # Real-world status
+      dark: :isDark,
+      motion_detected: :isMotionDetected,
+    }.freeze
+
+    def initialize(cameras = [])
+      @cameras = cameras
+    end
+
+    def_delegator :@cameras, :to_a
+    def_delegator :@cameras, :count
+    def_delegator :@cameras, :empty?
+    def_delegator :@cameras, :first
+    def_delegator :@cameras, :last
+    def_delegator :@cameras, :[]
+    def_delegator :@cameras, :each
+    def_delegator :@cameras, :each_index
+    def_delegator :@cameras, :each_slice
+    def_delegator :@cameras, :each_with_index
+    def_delegator :@cameras, :each_with_object
+    def_delegator :@cameras, :map
+
+    def respond_to_missing?(method_name, include_private = false)
+      return true if FILTERS.include?(method_name)
+
+      super
+    end
+
+    def method_missing(method_name, *args)
+      return filter(method_name, *args) if FILTERS.include?(method_name)
+
+      super
+    end
+
+    def match(**attrs)
+      return CameraCollection.new(cameras) if attrs.empty?
+
+      CameraCollection.new(
+        @cameras.select do |camera|
+          attrs.any? { |name, matcher| camera.match(name, matcher) }
+        end
+      )
+    end
+
+    def fetch(**attrs)
+      match(**attrs).first
+    end
+
+    def filter(name, value = true)
+      return CameraCollection.new if @cameras.empty?
+      raise 'unknown filter' unless FILTERS.include?(name.to_sym)
+
+      CameraCollection.new(@cameras.select { |c| c.send(FILTERS.fetch(name.to_sym)) == value })
+    end
+  end
+end

data/lib/unifi_protect/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module UnifiProtect
+  class Client
+    attr_reader :api
+
+    def initialize(api: nil, **args)
+      @api = api || API.new(**args)
+    end
+
+    def bootstrap
+      @bootstrap ||= api.bootstrap
+    end
+
+    def nvr
+      @nvr ||= NVR.new(client: self, nvr: bootstrap.nvr)
+    end
+
+    def create_camera_objects
+      bootstrap.cameras.map { |camera| Camera.new(client: self, camera: camera) }
+    end
+
+    def cameras
+      @cameras ||= CameraCollection.new(create_camera_objects)
+    end
+  end
+end

data/lib/unifi_protect/nvr.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module UnifiProtect
+  class NVR
+    TIME_FIELDS = %i[upSince].freeze
+
+    attr_reader :nvr
+
+    def initialize(client:, nvr:)
+      @client = client
+      @nvr = nvr
+    end
+
+    def to_s
+      "#<#{self.class.name} id=#{@nvr.id.inspect} name=#{@nvr.name.inspect}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @nvr.respond_to?(method_name) || super
+    end
+
+    def method_missing(method_name, *args)
+      value = @nvr.send(method_name, *args)
+      return Time.at(value / 1000) if value && TIME_FIELDS.include?(method_name)
+
+      value
+    end
+  end
+end

data/lib/unifi_protect/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module UnifiProtect
+  VERSION = '0.1.0'
+end

data/unifi_protect.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/unifi_protect/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'unifi_protect'
+  spec.version       = UnifiProtect::VERSION
+  spec.authors       = ['Jeremy Cole']
+  spec.email         = ['jeremy@jcole.us']
+
+  spec.summary       = 'UniFi Protect API'
+  spec.description   = 'An unofficial implementation of the Ubiquiti UniFi Protect API in Ruby'
+  spec.homepage      = 'http://github.com/jeremycole/unifi_protect'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  # spec.metadata['changelog_uri'] = ''
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |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']
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: unifi_protect
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jeremy Cole
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-30 00:00:00.000000000 Z
+dependencies: []
+description: An unofficial implementation of the Ubiquiti UniFi Protect API in Ruby
+email:
+- jeremy@jcole.us
+executables:
+- unifi_protect
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rakeTasks"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/unifi_protect
+- lib/unifi_protect.rb
+- lib/unifi_protect/api.rb
+- lib/unifi_protect/camera.rb
+- lib/unifi_protect/camera_collection.rb
+- lib/unifi_protect/client.rb
+- lib/unifi_protect/nvr.rb
+- lib/unifi_protect/version.rb
+- unifi_protect.gemspec
+homepage: http://github.com/jeremycole/unifi_protect
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://github.com/jeremycole/unifi_protect
+  source_code_uri: http://github.com/jeremycole/unifi_protect
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: UniFi Protect API
+test_files: []