tablo_connect 0.0.2

data/app/controllers/tablo_connect/application_controller.rb

@@ -0,0 +1,4 @@
+module TabloConnect
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/tablo_connect/copy_controller.rb

@@ -0,0 +1,75 @@
+module TabloConnect
+  class CopyController < ApplicationController
+    before_action :set_item
+
+    def index
+      pid = spawn(ffmpeg_copy)
+      Process.detach(pid)
+
+      @item.copy_status = :in_progress
+      @item.save
+
+      render json: {pid: pid, destination: destination_path}, status: :ok
+    end
+
+    def status
+      file_copy_status
+      render json: {copy_status: @item.copy_status}
+    end
+
+    private
+
+    def set_item
+      model = case params[:type]
+                when 'movie'
+                  TabloConnect::Movie
+                when 'show'
+                  TabloConnect::Show
+                else
+                  return head :not_found if @item.nil?
+              end
+
+      @item = model.find_by_tablo_id(params[:tablo_id])
+      head :not_found if @item.nil?
+    end
+
+    def source_path
+      "#{TabloConnect.tablo_base_url}/pvr/#{@item.tablo_id}/pl/playlist.m3u8"
+    end
+
+    def destination_path
+      "#{TabloConnect.output_directory}/#{file_name}"
+    end
+
+    def ffmpeg_copy
+      "#{TabloConnect.ffmpeg_path} -i \"#{source_path}\" -bsf:a aac_adtstoasc -vcodec copy -c copy #{destination_path}"
+    end
+
+    def file_name
+      if params[:type] == 'movie'
+        "#{@item.title.gsub(/[^\w\.]/, ' ').squish.gsub(' ', '_')}.mp4"
+      elsif params[:type] == 'show'
+        "#{@item.show.gsub(/[^\w\.]/, ' ').squish.gsub(' ', '_')}.s#{@item.season.to_s.rjust(2, '0')}e#{@item.episode.to_s.rjust(2, '0')}_#{@item.tablo_id}.mp4"
+      end
+    end
+
+    def file_copy_status
+      update_copy_status(new_status) if new_status.to_s != @item.copy_status
+    end
+
+    def new_status
+      return :idle unless File.exists?(destination_path)
+      return :complete if file_unlocked?
+      :in_progress
+    end
+
+    def update_copy_status(new_status)
+      @item.copy_status = new_status
+      @item.save
+    end
+
+    def file_unlocked?
+      %x[lsof -F n].split("\n").grep(/#{destination_path}/).empty?
+    end
+  end
+end

data/app/controllers/tablo_connect/home_controller.rb

@@ -0,0 +1,6 @@
+module TabloConnect
+  class HomeController < ApplicationController
+    def index
+    end
+  end
+end

data/app/controllers/tablo_connect/movies_controller.rb

@@ -0,0 +1,9 @@
+module TabloConnect
+  class MoviesController < ApplicationController
+    def index
+      movies = Movie.all_order_title
+
+      render json: {movies: movies}
+    end
+  end
+end

data/app/controllers/tablo_connect/shows_controller.rb

@@ -0,0 +1,11 @@
+module TabloConnect
+  class ShowsController < ApplicationController
+    def index
+      render json: {shows: Show.shows_with_image_id}
+    end
+
+    def episodes
+      render json: {episodes: Show.show_episodes(params.require(:show))}
+    end
+  end
+end

data/app/controllers/tablo_connect/sync_controller.rb

@@ -0,0 +1,73 @@
+require 'open-uri'
+require 'rest-client'
+
+module TabloConnect
+  class SyncController < ApplicationController
+    def index
+      begin
+        item_ids = parse_items
+        delete_removed item_ids
+        update_items(item_ids)
+        head :ok
+      rescue => e
+        render json: {error: e.to_s}, status: :internal_server_error
+      end
+    end
+
+    private
+
+    def parse_items
+      page = Nokogiri::HTML(open("#{TabloConnect.tablo_base_url}/pvr/"))
+      page.css('tbody a').map { |row|
+        row[:href].gsub('/', '').to_i if row[:href].gsub('/', '') =~ /\A\d+\z/
+      }.compact
+    end
+
+    def delete_removed(new_ids)
+      old_ids = TabloConnect::Movie.select(:tablo_id).all + TabloConnect::Show.select(:tablo_id).all
+      delete_ids = old_ids.map {|i| i.tablo_id } - new_ids
+
+      TabloConnect::Movie.delete_by_tablo_id(delete_ids)
+      TabloConnect::Show.delete_by_tablo_id(delete_ids)
+    end
+
+    def update_items(tablo_ids)
+      tablo_ids.each do |tablo_id|
+        details = recording_details tablo_id
+
+        if details[:recMovie].present?
+          update_movie(tablo_id, details)
+        elsif details[:recEpisode].present?
+          update_show(tablo_id, details)
+        end
+      end
+    end
+
+    def update_movie(tablo_id, details)
+      item = TabloConnect::Movie.find_or_create_by(tablo_id: tablo_id)
+      item.title = details.try(:[], :recMovie).try(:[], :jsonForClient).try(:[], :title)
+      item.description = details.try(:[], :recMovie).try(:[], :jsonForClient).try(:[], :plot)
+      item.release_year = details.try(:[], :recMovie).try(:[], :jsonForClient).try(:[], :releaseYear)
+      item.air_date = details.try(:[], :recMovieAiring).try(:[], :jsonForClient).try(:[], :airDate)
+      item.image_id = details.try(:[], :recMovie).try(:[], :imageJson).try(:[], :images).try(:[], 0).try(:[], :imageID)
+      item.save!
+    end
+
+    def update_show(tablo_id, details)
+      item = TabloConnect::Show.find_or_create_by(tablo_id: tablo_id)
+      item.show = details.try(:[], :recEpisode).try(:[], :jsonFromTribune).try(:[], :program).try(:[], :title)
+      item.title = details.try(:[], :recEpisode).try(:[], :jsonFromTribune).try(:[], :program).try(:[], :episodeTitle)
+      item.description = details.try(:[], :recEpisode).try(:[], :jsonFromTribune).try(:[], :program).try(:[], :longDescription)
+      item.episode = details.try(:[], :recEpisode).try(:[], :jsonFromTribune).try(:[], :program).try(:[], :episodeNum)
+      item.season = details.try(:[], :recEpisode).try(:[], :jsonFromTribune).try(:[], :program).try(:[], :seasonNum)
+      item.rec_date = details.try(:[], :recEpisode).try(:[], :jsonForClient).try(:[], :airDate)
+      item.air_date = details.try(:[], :recSeries).try(:[], :jsonForClient).try(:[], :originalAirDate)
+      item.image_id = details.try(:[], :recSeries).try(:[], :imageJson).try(:[], :images).try(:[], 0).try(:[], :imageID)
+      item.save!
+    end
+
+    def recording_details(tablo_id)
+      JSON.parse(RestClient.get("#{TabloConnect.tablo_base_url}/pvr/#{tablo_id}/meta.txt")).with_indifferent_access
+    end
+  end
+end

data/app/helpers/tablo_connect/application_helper.rb

@@ -0,0 +1,4 @@
+module TabloConnect
+  module ApplicationHelper
+  end
+end

data/app/helpers/tablo_connect/movies_helper.rb

@@ -0,0 +1,4 @@
+module TabloConnect
+  module MoviesHelper
+  end
+end

data/app/helpers/tablo_connect/shows_helper.rb

@@ -0,0 +1,4 @@
+module TabloConnect
+  module ShowsHelper
+  end
+end

data/app/models/tablo_connect/movie.rb

@@ -0,0 +1,14 @@
+module TabloConnect
+  class Movie < ActiveRecord::Base
+    validates_presence_of :tablo_id
+    validates_uniqueness_of :tablo_id
+
+    enum copy_status: [:idle, :in_progress, :complete]
+
+    scope :all_order_title, -> { self.all.order(:title) }
+
+    def self.delete_by_tablo_id(delete_ids)
+      self.where(tablo_id: delete_ids).delete_all
+    end
+  end
+end

data/app/models/tablo_connect/show.rb

@@ -0,0 +1,23 @@
+module TabloConnect
+  class Show < ActiveRecord::Base
+    validates_presence_of :tablo_id
+    validates_uniqueness_of :tablo_id
+
+    enum copy_status: [:idle, :in_progress, :complete]
+
+    scope :shows, -> { group(:show).order(:show).count }
+    scope :show_episodes, ->(show) { where(show: show).order(:season, :episode, :rec_date, :title) }
+
+    def self.shows_with_image_id
+      self.shows.map { |show|
+        image_id = self.select(:image_id).distinct(:image_id).where({show: show[0]}).order(image_id: :desc).limit(1)[0].try(:[], :image_id)
+
+        {show: show[0], count: show[1], image_id: image_id}
+      }
+    end
+
+    def self.delete_by_tablo_id(delete_ids)
+      self.where(tablo_id: delete_ids).delete_all
+    end
+  end
+end

data/app/views/layouts/tablo_connect/_header.html.erb

@@ -0,0 +1,20 @@
+<nav class="navbar navbar-default">
+  <div class="container-fluid">
+    <div class="navbar-header">
+      <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-nav-collapse" aria-expanded="false">
+        <span class="sr-only">Toggle navigation</span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+      </button>
+      <a class="navbar-brand" href="#/">Tablo Connect</a>
+    </div>
+
+    <div class="collapse navbar-collapse" id="bs-nav-collapse">
+      <ul class="nav navbar-nav">
+        <li><a ui-sref="movies">Movies</a></li>
+        <li><a ui-sref="shows">Shows</a></li>
+      </ul>
+    </div>
+  </div>
+</nav>

data/app/views/layouts/tablo_connect/application.html.erb

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html ng-app="ac.tabloConnectApp">
+<head>
+  <title>TabloConnect</title>
+  <%= stylesheet_link_tag "tablo_connect/application", media: "all" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+<%= render 'layouts/tablo_connect/header' %>
+<div class="container-fluid">
+  <%= yield %>
+</div>
+
+<%= javascript_include_tag "tablo_connect/application" %>
+<script>
+  angular.module('ac.tabloConnectApp').constant('tabloBaseUrl', '<%= "http://#{TabloConnect.tablo_ip}:#{TabloConnect.tablo_port}" %>')
+</script>
+</body>
+</html>

data/app/views/tablo_connect/home/index.html.erb

@@ -0,0 +1 @@
+<ui-view></ui-view>

data/config/routes.rb

@@ -0,0 +1,10 @@
+TabloConnect::Engine.routes.draw do
+  root to: "home#index"
+
+  get 'sync', to: 'sync#index'
+  get 'movies', to: 'movies#index'
+  get 'shows', to: 'shows#index'
+  get 'episodes/:show', to: 'shows#episodes'
+  get 'copy/:tablo_id/:type', to: 'copy#index'
+  get 'copy/:tablo_id/:type/status', to: 'copy#status'
+end

data/db/migrate/20151101164611_create_tablo_connect_movies.rb

@@ -0,0 +1,18 @@
+class CreateTabloConnectMovies < ActiveRecord::Migration
+  def change
+    create_table :tablo_connect_movies do |t|
+      t.integer :tablo_id
+      t.string :title
+      t.text :description
+      t.integer :release_year
+      t.datetime :air_date
+      t.integer :image_id
+      t.integer :copy_status, default: 0
+
+      t.timestamps null: false
+    end
+
+    add_index :tablo_connect_movies, :tablo_id, :unique => true
+    add_index :tablo_connect_movies, :title
+  end
+end

data/db/migrate/20151101165020_create_tablo_connect_shows.rb

@@ -0,0 +1,21 @@
+class CreateTabloConnectShows < ActiveRecord::Migration
+  def change
+    create_table :tablo_connect_shows do |t|
+      t.integer :tablo_id
+      t.string :show
+      t.string :title
+      t.text :description
+      t.integer :episode
+      t.integer :season
+      t.date :air_date
+      t.datetime :rec_date
+      t.integer :image_id
+      t.integer :copy_status, default: 0
+
+      t.timestamps null: false
+    end
+
+    add_index :tablo_connect_shows, :tablo_id, :unique => true
+    add_index :tablo_connect_shows, :show
+  end
+end

data/lib/tablo_connect.rb

@@ -0,0 +1,7 @@
+require "tablo_connect/engine"
+
+module TabloConnect
+  def self.tablo_base_url
+    "http://#{TabloConnect.tablo_ip}:#{TabloConnect.tablo_port}"
+  end
+end

data/lib/tablo_connect/engine.rb

@@ -0,0 +1,28 @@
+module TabloConnect
+  class Engine < ::Rails::Engine
+    isolate_namespace TabloConnect
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+    end
+  end
+
+  class << self
+    mattr_accessor :tablo_ip
+    self.tablo_ip = '192.168.1.99'
+
+    mattr_accessor :tablo_port
+    self.tablo_port = '180809'
+
+    mattr_accessor :ffmpeg_path
+    self.ffmpeg_path = '/usr/local/bin/ffmpeg'
+
+    mattr_accessor :output_directory
+    self.output_directory = '/tmp'
+  end
+
+  def self.setup(&block)
+    yield self
+  end
+end

data/lib/tablo_connect/version.rb

@@ -0,0 +1,3 @@
+module TabloConnect
+  VERSION = "0.0.2"
+end

data/lib/tasks/tablo_connect_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :tablo_connect do
+#   # Task goes here
+# end

data/spec/controllers/tablo_connect/copy_controller_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+
+module TabloConnect
+  describe CopyController, type: :controller do
+    routes { TabloConnect::Engine.routes }
+
+    let!(:show) { FactoryGirl.create(:tablo_connect_show, show: 'Angle of Attack') }
+
+    describe "GET index" do
+      before do
+        allow(controller).to receive(:spawn).and_return(1234)
+        allow(controller).to receive(:destination_path).and_return('/tmp/output.mp4')
+        allow(Process).to receive(:detach)
+      end
+
+      context "when the item is not found" do
+        it "returns a 404" do
+          get :index, {tablo_id: 99999, type: 'some_type'}
+          expect(response.status).to eq 404
+        end
+      end
+
+      context "when the item is found" do
+        it "returns a 200" do
+          get :index, {tablo_id: show.tablo_id, type: 'show'}
+          expect(response.status).to eq 200
+        end
+
+        it "calls spawn" do
+          expect(controller).to receive(:spawn)
+          get :index, {tablo_id: show.tablo_id, type: 'show'}
+        end
+
+        it "sets the copy_status to in_progress" do
+          item = TabloConnect::Show.find_by_tablo_id show.tablo_id
+          expect(item.copy_status).to eq('idle')
+          get :index, {tablo_id: show.tablo_id, type: 'show'}
+          item.reload
+          expect(item.copy_status).to eq('in_progress')
+        end
+
+        it "returns an object with a shows array" do
+          get :index, {tablo_id: show.tablo_id, type: 'show'}
+          json_body = JSON.parse(response.body).with_indifferent_access
+          expect(json_body).to match({pid: 1234, destination: '/tmp/output.mp4'})
+        end
+      end
+    end
+
+    describe "GET status" do
+      it "calls file_copy_status" do
+        expect(controller).to receive(:file_copy_status)
+        get :status, {tablo_id: show.tablo_id, type: 'show'}
+      end
+
+      it "returns a 200 status code" do
+        get :status, {tablo_id: show.tablo_id, type: 'show'}
+        expect(response.status).to eq 200
+      end
+
+      it "returns a JSON object with the copy_status" do
+        get :status, {tablo_id: show.tablo_id, type: 'show'}
+        json_body = JSON.parse(response.body).with_indifferent_access
+        expect(json_body[:copy_status]).to eq show.copy_status
+      end
+    end
+
+    describe ".set_item" do
+      before do
+        allow(controller).to receive(:head).and_return(double.as_null_object)
+      end
+
+      context "when the type is not show or movie" do
+        it "returns a 404" do
+          allow(controller).to receive(:params).and_return({tablo_id: show.tablo_id, type: 'invalid_type'})
+          expect(controller).to receive(:head).with(:not_found)
+          controller.send(:set_item)
+        end
+      end
+
+      context "when the type is 'show' or 'movie'" do
+        context "when the type is 'movie'" do
+          it "uses the Movie model" do
+            allow(controller).to receive(:params).and_return({tablo_id: show.tablo_id, type: 'movie'})
+            expect(TabloConnect::Movie).to receive(:find_by_tablo_id).with(show.tablo_id)
+            controller.send(:set_item)
+          end
+        end
+
+        context "when the type is 'show'" do
+          it "uses the Show model" do
+            allow(controller).to receive(:params).and_return({tablo_id: show.tablo_id, type: 'show'})
+            expect(TabloConnect::Show).to receive(:find_by_tablo_id).with(show.tablo_id)
+            controller.send(:set_item)
+          end
+        end
+
+        context "when the item is not found" do
+          it "returns a 404" do
+            allow(controller).to receive(:params).and_return({tablo_id: 99999, type: 'show'})
+            controller.send(:set_item)
+          end
+        end
+
+        context "when the item is found" do
+          it "sets the @item instance variable" do
+            allow(controller).to receive(:params).and_return({tablo_id: show.tablo_id, type: 'show'})
+            controller.send(:set_item)
+            item = controller.instance_variable_get(:@item)
+            expect(item).to match(show)
+          end
+        end
+      end
+    end
+
+    describe ".source_path" do
+      it "builds the source_path with the tablo_id" do
+        controller.instance_variable_set(:@item, show)
+        path = controller.send(:source_path)
+        expect(path).to eq "#{TabloConnect.tablo_base_url}/pvr/#{show.tablo_id}/pl/playlist.m3u8"
+      end
+    end
+
+    describe ".destination_path" do
+      it "builds the destination path with the file_name method" do
+        controller.instance_variable_set(:@item, show)
+        allow(controller).to receive(:file_name).and_return('output.mp4')
+        path = controller.send(:destination_path)
+        expect(path).to eq "#{TabloConnect.output_directory}/output.mp4"
+      end
+    end
+
+    describe ".ffmpeg_copy" do
+      it "returns the ffmpeg copy command string" do
+        allow(controller).to receive(:source_path).and_return('/source/path/input.mp4')
+        allow(controller).to receive(:destination_path).and_return('/destination/path/output.mp4')
+        expect(controller.send(:ffmpeg_copy)).to eq "#{TabloConnect.ffmpeg_path} -i \"/source/path/input.mp4\" -bsf:a aac_adtstoasc -vcodec copy -c copy /destination/path/output.mp4"
+      end
+    end
+
+    describe ".file_name" do
+      before do
+        controller.instance_variable_set(:@item, show)
+      end
+
+      context "when type is 'movie'" do
+        it "returns the unix safe movie file name" do
+          allow(controller).to receive(:params).and_return({type: 'movie'})
+          expect(controller.send(:file_name)).to eq('The_Harder_They_Fall.mp4')
+        end
+      end
+
+      context "when type is 'show'" do
+        it "returns the unix safe show file name" do
+          allow(controller).to receive(:params).and_return({type: 'show'})
+          expect(controller.send(:file_name)).to eq("Angle_of_Attack.s01e01_#{show.tablo_id}.mp4")
+        end
+      end
+    end
+
+    describe ".file_copy_status" do
+      before do
+        controller.instance_variable_set(:@item, show)
+      end
+
+      context "when the file exists" do
+        before do
+          allow(controller).to receive(:destination_path).and_return(Rails.root.join('public', '404.html').to_s)
+        end
+
+        context "when the file is in use" do
+          it "updates the copy_status to :in_progress" do
+            allow(controller).to receive(:file_unlocked?).and_return(false)
+            controller.send(:file_copy_status)
+            expect(show.copy_status).to eq 'in_progress'
+          end
+        end
+
+        context "when the file is not in use" do
+          it "updates the copy_status to :complete" do
+            allow(controller).to receive(:file_unlocked?).and_return(true)
+            controller.send(:file_copy_status)
+            expect(show.copy_status).to eq 'complete'
+          end
+        end
+
+        context "when the new_status is equal to the current status" do
+          it "does not update the copy_status" do
+            allow(controller).to receive(:file_unlocked?).and_return(true)
+            show.copy_status = :complete
+            show.save
+            expect(show.copy_status).to eq 'complete'
+            expect(controller).to_not receive(:update_copy_status).with(:complete)
+            controller.send(:file_copy_status)
+            expect(show.copy_status).to eq 'complete'
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        before do
+          allow(controller).to receive(:destination_path).and_return(Rails.root.join('public', 'non_existent.html').to_s)
+        end
+
+        it "updates the copy_status to :idle" do
+          show.copy_status = :in_progress
+          show.save!
+          expect(show.copy_status).to eq 'in_progress'
+          controller.send(:file_copy_status)
+          expect(show.copy_status).to eq 'idle'
+        end
+      end
+    end
+
+    describe ".new_status" do
+      context "when file does not exist" do
+        it "returns :idle" do
+          allow(File).to receive(:exists?).and_return(false)
+          expect(controller.send(:new_status)).to eq :idle
+        end
+      end
+
+      context "when file exists" do
+        before do
+          allow(File).to receive(:exists?).and_return(true)
+        end
+
+        context "when file is not in use" do
+          it "returns :complete" do
+            allow(controller).to receive(:file_unlocked?).and_return(true)
+            expect(controller.send(:new_status)).to eq :complete
+          end
+        end
+
+        context "when file is in use" do
+          it "returns :in_progress" do
+            allow(controller).to receive(:file_unlocked?).and_return(false)
+            expect(controller.send(:new_status)).to eq :in_progress
+          end
+        end
+      end
+    end
+  end
+end