film_on 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6daa5c3826eabbbc14f6fbdbbd2c5b188a76725
-  data.tar.gz: 74858705d1db4df5dd193a8afe35a321d5f45134
+  metadata.gz: e337a6f5e24579677972f39b52b2cd3214a6ab43
+  data.tar.gz: 0637963eabb1d25c451be26e2db024b7b6808f0e
 SHA512:
-  metadata.gz: 3d38f63ee5436ff621c56564fc2d75a647257298e4421616489c8819470e6f0f1db07fe43133a777a7a262d30bcfc9656463c6d4f77ba1324679e99f80549046
-  data.tar.gz: 356205369ac03fd4fed40cd60ddb692b6e047c0933b6c2470b42f026cb4027a841d71df1df5fe7ad21b3ebd40fe2852ad11c17abb0915b5b436a49d745638aee
+  metadata.gz: a4904487a19a2e9e4f27f4c04f9045ad0a132e638fa9c62cae1f211f155e172b208030fa354ddc4835c98c6af71769d51a8081a6306e0f13834ab247a5aa2830
+  data.tar.gz: 6d5c99daef0888fb10f81f26130faec795c58f28b521dfd5be40c172e6f61a435ca05e35aab9756ce3fdab17f48a8120fec55f95f8cebe308736a588c41dba3a

data/README.md

@@ -2,9 +2,8 @@
 
 A Ruby wrapper for the FilmOn API: http://www.filmon.com/page/api
 
-This is currently at version 0.0.1 and only handles channels, channel
-and groups methods
-
+This is currently at version < 0.1. It handles TV Streams: channels and groups methods
+and the Video On Demand: movie search  
 
 ## Installation
 
@@ -28,15 +27,27 @@ Refer to FilmOn Api (http://www.filmon.com/page/api):
 
 Obtain your app_key and app_secret from FilmOn 
 
-app_key = "foo"
-app_secret = "bar"
+`app_key = "foo"`
+
+`app_secret = "bar"`
+
+`film_on = FilmOn::Base.new(app_key, app_secret)`
+
+### TV Streaming examples
+
+`film_on.channels` => returns list of all channels as ruby objects
+
+`flim_on.groups` => returns list of all groups as ruby objects
+
+`film_on.channel(id)` => returns info for given channel as a ruby object
+
+`film_on.find_group(id)` => returns the information for a given group id
+
+### Video On Demand examples
 
-film_on = FilmOn::Base.new(app_key, app_secret)
+`film_on.movies(genre: "horror")` => returns all movies within the horror genre
 
-film_on.channels => returns list of all channels as ruby objects
-flim_on.groups => returns list of all groups as ruby objects
-film_on.channel(id) => returns info for given channel as a ruby object
-film_on.find_group(id) => returns the information for a given group id
+`film_on.movie(id)` => returns information on the movie with the given id
 
 ## Development
 

data/VERSION

@@ -1 +1 @@
-0.0.11
+0.0.12

data/lib/film_on/base.rb

@@ -4,11 +4,12 @@ module FilmOn
 
   class Base
 
-    include Services
-    include ChannelHelper
-    include GroupHelper
+    include Services::Channels
+    include Services::Groups
+    include Services::VideoOnDemand
 
-    URI = "www.filmon.com/tv/api/"
+    TV_URI = "www.filmon.com/tv/api/"
+    VOD_URI = "www.filmon.com/api/vod/"
 
     attr_reader :app_key, :app_secret, :session_key
 
@@ -27,6 +28,8 @@ module FilmOn
       @app_key = app_key
       @app_secret = app_secret
       @channel = {}
+      @movie = {}
+      @vod_search = {}
       init_request
     end
 
@@ -47,8 +50,7 @@ module FilmOn
     def post(service, query={}, protocol="http://")
       query["format"] = "json"
       query["session_key"] = @session_key unless service == "init"
-      full_service_url = "#{protocol}#{URI}#{service}"
-      response = HTTParty.post(full_service_url, {body: query, headers: {'Content-Type' => 'application/json'}})
+      response = HTTParty.post("#{protocol}#{TV_URI}#{service}", {body: query, headers: {'Content-Type' => 'application/json'}})
       if response && response.code == 200
         return response.body
       else
@@ -61,8 +63,18 @@ module FilmOn
     def get(service, query={}, protocol="http://")
       query["format"] = "json"
       query["session_key"] = @session_key unless service == "init"
-      full_service_url = "#{protocol}#{URI}#{service}?#{query.map{|k,v| "#{k}=#{v}"}.join("&")}"
-      response = HTTParty.get(full_service_url)
+      query_string = query.map{|k,v| "#{k}=#{v}"}.join("&")
+      response = HTTParty.get("#{protocol}#{TV_URI}#{service}?#{query_string}")
+      if response && response.code == 200
+        return response.body
+      else
+        raise ApiError
+      end
+    end
+
+    def get_vod(service, query={}, protocol="http://")
+      query_string = query.map{|k,v| "#{k}=#{v}"}.join("&")
+      response = HTTParty.get("#{protocol}#{VOD_URI}#{service}?#{query_string}")
       if response && response.code == 200
         return response.body
       else

data/lib/film_on/models/channel.rb

@@ -16,7 +16,6 @@ module FilmOn
     attr_reader :preload_message, :preload_timeout, :is_local, :preload_intro, :images, :schedule, :now_playing, :next_playing, :tvguide
 
     def initialize(hash)
-      @hash = hash
       @id = hash["id"]
       @title = hash["title"]
       @alias = hash["alias"]

data/lib/film_on/models/group.rb

@@ -7,12 +7,10 @@ module FilmOn
 
   class Group
 
-    attr_reader :hash
     attr_reader :group_id, :id, :title, :group, :original_name, :alias, :description
     attr_reader :weight, :logo_uri, :logo_148x148_uri, :logos, :channels, :channels_count
 
     def initialize(hash)
-      @hash = hash
       @group_id = hash["group_id"]
       @id = hash["id"]
       @title = hash["title"]

data/lib/film_on/models/movie.rb

@@ -0,0 +1,47 @@
+module FilmOn
+
+  # FilmOn::Movie
+  # Movie can have either a basic set of data or a more verbose set
+  # depending on whether it is called as part of a vod_search or
+  # as in individual call from #movie, takes a raw hash and converts
+  # it into a nice ruby object
+
+  class Movie
+
+    attr_reader :id, :title, :slug, :description, :type_id, :series_number, :episodes_count, :vendor_id, :vendorka_id
+    attr_reader :content_host, :low_quality_file_id, :high_quality_file_id, :parent_id, :exists_on_edgecast
+    attr_reader :is_featured, :is_enabled, :deleted_at, :genres, :cast, :crew, :artwork, :poster, :georule, :type
+    attr_reader :streams, :content_blocked
+
+    def initialize(hash)
+      @id = hash["id"]
+      @title = hash["title"]
+      @slug = hash["slug"]
+      @description = hash["description"]
+      @type_id = hash["type_id"]
+      @series_number = hash["series_number"]
+      @episodes_count = hash["episodes_count"]
+      @vendor_id = hash["vendor_id"]
+      @vendorka_id = hash["vendorka_id"]
+      @content_host = hash["content_host"]
+      @low_quality_file_id = hash["low_quality_file_id"]
+      @high_quality_file_id = hash["high_quality_file_id"]
+      @parent_id = hash["parent_id"]
+      @exists_on_edgecast = hash["exists_on_edgecast"]
+      @is_featured = hash["is_featured"]
+      @is_enabled = hash["is_enabled"]
+      @deleted_at = hash["deleted_at"]
+      @genres = hash["genres"]
+      @cast = hash["cast"]
+      @crew = hash["crew"]
+      @artwork = hash["artwork"] #TODO convert to image structs
+      @poster = hash["poster"] #TODO convert to image structs
+      @georule = hash["georule"]
+      @type = hash["type"]
+      @streams = hash["streams"]
+      @content_blocked = hash["content_blocked"]
+    end
+
+  end
+
+end

data/lib/film_on/models/programme.rb

@@ -7,12 +7,10 @@ module FilmOn
 
     Image = Struct.new(:id, :type, :size, :width, :height, :url, :copyright)
 
-    attr_reader :hash
     attr_reader :programme, :startdatetime, :enddatetime, :duration, :length, :programme_description, :programme_name, :allow_dvr
     attr_reader :allow_reminder, :channel_id, :images, :provider, :vendor_id, :series_number, :episode_number, :series_id, :is_series
 
     def initialize(hash)
-      @hash = hash
       @programme = hash["programme"]
       @startdatetime = hash["startdatetime"]
       @enddatetime = hash["enddatetime"]

data/lib/film_on/services/channels.rb

@@ -0,0 +1,52 @@
+module FilmOn
+  module Services
+    module Channels
+
+      # channel: will get the verbose details for a channel with
+      # the given id
+      #
+      def channel(id, opts={})
+        id = id.to_s
+        return @channel[id] if @channel[id] && !opts[:json]
+        json = get("channel/#{id}")
+        if opts[:json]
+          return json
+        end
+        @channel[id] = convert_channel(json)
+      end
+
+      # channels: will get the entire current list of channels for
+      # FilmOn, each channels has a small amount of useful data,
+      # refer to #channel for additional channel information.
+      #
+      def channels(opts={})
+        return @channels if @channels && !opts[:json]
+        json = get("channels")
+        if opts[:json]
+          return json
+        end
+        @channels = convert_channels(json)
+      end
+
+      # convert_channel: takes the raw JSON
+      # and coverts it into a nice ruby object
+      # normal for use after storing the JSON in
+      # a caching mechanism
+      #
+      def convert_channel(json)
+        hash = JSON.parse(json)
+        FilmOn::Channel.new(hash)
+      end
+
+      # convert_channels: takes the raw JSON
+      # and coverts it into a nice ruby array of
+      # objects
+      #
+      def convert_channels(json)
+        hash = JSON.parse(json)
+        hash.map{|ch| FilmOn::Channel.new(ch)}
+      end
+
+    end
+  end
+end

data/lib/film_on/services/groups.rb

@@ -0,0 +1,35 @@
+module FilmOn
+  module Services
+    module Groups
+
+      # groups: will get the entire current list of groups for
+      # FilmOn, each group holds an array of ids of associated channels
+      #
+      def groups(opts={})
+        return @groups if @groups && !opts[:json]
+        json = get("groups")
+        if opts[:json]
+          return json
+        end
+        @groups = convert_groups(json)
+      end
+
+      # convert_groups: takes the raw JSON
+      # and converts it into a nice ruby array of objects
+      #
+      def convert_groups(json)
+        hash = JSON.parse(json)
+        hash.map{|gr| FilmOn::Group.new(gr)}
+      end
+
+      # find_group: a convenience method to
+      # find the full detail of any given group
+      #
+      def find_group(id)
+        id = id.to_s
+        groups.select{|gr| gr.id == id}.first
+      end
+
+    end
+  end
+end

data/lib/film_on/services/video_on_demand.rb

@@ -0,0 +1,55 @@
+module FilmOn
+  module Services
+    module VideoOnDemand
+
+      # movies: calls the vod/search and returns
+      # a list of movies filtered by the params
+      # i.e. film_on.movies(genre: "horror") will
+      # return all horror movies
+      #
+      def movies(params={}, opts={})
+        key = Digest::MD5.hexdigest(params.to_s)
+        return @vod_search[key] if @vod_search[key] && !opts[:json]
+        json = get_vod("search", params)
+        if opts[:json]
+          return json
+        end
+        @vod_search[key] = convert_movies(json)
+      end
+
+      # movie: retrieve a specific movie with a given id
+      #
+      def movie(id, opts={})
+        id = id.to_s
+        return @movie[id] if @movie[id] && !opts[:json]
+        json = get_vod("movie", {id: id})
+        if opts[:json]
+          return json
+        end
+        @movie[id] = convert_movie(json)
+      end
+
+      # convert_movies: takes the raw JSON
+      # and coverts it into a nice array of ruby objects
+      # normal for use after storing the JSON in
+      # a caching mechanism
+      #
+      def convert_movies(json)
+        hash = JSON.parse(json)["response"]
+        hash.map{|movie| FilmOn::Movie.new(movie) }
+      end
+
+      # convert_movie: takes the raw JSON
+      # and coverts it into a nice ruby object
+      # normal for use after storing the JSON in
+      # a caching mechanism
+      #
+      def convert_movie(json)
+        hash = JSON.parse(json)["response"]
+        FilmOn::Movie.new(hash)
+      end
+
+    end
+  end
+end
+

data/lib/film_on.rb

@@ -1,11 +1,12 @@
 require "film_on/version"
-require "film_on/services"
-require "film_on/helpers/channel_helper"
-require "film_on/helpers/group_helper"
+require "film_on/services/channels"
+require "film_on/services/groups"
+require "film_on/services/video_on_demand"
 require "film_on/base"
 require "film_on/models/channel"
 require "film_on/models/group"
 require "film_on/models/programme"
+require "film_on/models/movie"
 
 module FilmOn
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: film_on
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Stuart Hanscombe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2015-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,12 +114,13 @@ files:
 - film_on.gemspec
 - lib/film_on.rb
 - lib/film_on/base.rb
-- lib/film_on/helpers/channel_helper.rb
-- lib/film_on/helpers/group_helper.rb
 - lib/film_on/models/channel.rb
 - lib/film_on/models/group.rb
+- lib/film_on/models/movie.rb
 - lib/film_on/models/programme.rb
-- lib/film_on/services.rb
+- lib/film_on/services/channels.rb
+- lib/film_on/services/groups.rb
+- lib/film_on/services/video_on_demand.rb
 - lib/film_on/version.rb
 homepage: https://github.com/thelazycamel/film_on
 licenses:

data/lib/film_on/helpers/channel_helper.rb

@@ -1,25 +0,0 @@
-module FilmOn
-
-  module ChannelHelper
-
-    # #convert_channel takes the raw JSON
-    # and coverts it into a nice ruby object
-    # normal for use after storing the JSON in
-    # a caching mechanism
-    #
-    def convert_channel(json)
-      hash = JSON.parse(json)
-      FilmOn::Channel.new(hash)
-    end
-
-    # #convert_channel takes the raw JSON
-    # and coverts it into a nice ruby array of
-    # objects
-    #
-    def convert_channels(json)
-      hash = JSON.parse(json)
-      hash.map{|ch| FilmOn::Channel.new(ch)}
-    end
-
-  end
-end

data/lib/film_on/helpers/group_helper.rb

@@ -1,21 +0,0 @@
-module FilmOn
-  module GroupHelper
-
-    # #convert_groups takes the raw JSON
-    # and converts it into a nice ruby array of objects
-    #
-    def convert_groups(json)
-      hash = JSON.parse(json)
-      hash.map{|gr| FilmOn::Group.new(gr)}
-    end
-
-    # #find_group, a convenience method to
-    # find the full detail of any given group
-    #
-    def find_group(id)
-      id = id.to_s
-      groups.select{|gr| gr.id == id}.first
-    end
-
-  end
-end

data/lib/film_on/services.rb

@@ -1,51 +0,0 @@
-module FilmOn
-
-  # Services: calls to the actual services of the API
-  # each call is memoized to save calling the API multiple times
-  # except when json requested:
-  # pass {json: true} to get the raw JSON representation
-  # of the channel, normally for self storage in memcache/redis cache
-  #
-  module Services
-
-    # #channel will get the verbose details for a channel with
-    # the given id
-    #
-    def channel(id, opts={})
-      id = id.to_s
-      return @channel[id] if @channel[id] && !opts[:json]
-      json = get("channel/#{id}")
-      if opts[:json]
-        return json
-      end
-      @channel[id] = convert_channel(json)
-    end
-
-    # #channels will get the entire current list of channels for
-    # FilmOn, each channels has a small amount of useful data,
-    # refer to #channel for additional channel information.
-    #
-    def channels(opts={})
-      return @channels if @channels && !opts[:json]
-      json = get("channels")
-      if opts[:json]
-        return json
-      end
-      @channels = convert_channels(json)
-    end
-
-    # #groups will get the entire current list of groups for
-    # FilmOn, each group holds an array of ids of associated channels
-    #
-    def groups(opts={})
-      return @groups if @groups && !opts[:json]
-      json = get("groups")
-      if opts[:json]
-        return json
-      end
-      @groups = convert_groups(json)
-    end
-
-  end
-
-end