edm_train 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bd174d7c3a05ddadf9d188db700de939f99c040a1e66b7434ec67e1504cce2db
+  data.tar.gz: 6341fd037b6289af39265e2c98ac825aca768d9094632e986d14ea6e9a2b6112
+SHA512:
+  metadata.gz: 6d2be861aa799fda6f3390f3babb36634c86fe573ff0045fc28f53bec19baaae9d803117309bc6019db4dfb47b2fdc3f753272e5d878b444570ea6944beb472f
+  data.tar.gz: 38e36b693c9bc8a82f39dbfffcf12147a5d6f8d4408d53f82270a4659c149d45050eb6f2bc6eff9e7b5ed927dad686d376fb68292dc0d315e7c679356478087c

data/lib/edm_train/artist.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module EdmTrain
+  class Artist
+    attr_reader :id, :name, :link, :b2b_ind
+
+    def initialize(raw_artist)
+      @id = raw_artist['id']
+      @name = raw_artist['name']
+      @link = raw_artist['link']
+      @b2b_ind = raw_artist['b2bInd']
+    end
+  end
+end

data/lib/edm_train/client.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+require 'json'
+
+# An API Client for EdmTrain.com
+module EdmTrain
+  # Helper method to return the client. 
+  # @return [EdmTrain::Client] the base client
+  def self.client
+    @client ||= Client.new
+  end
+
+  # EdmTrain API key getter
+  # @return [String] the API key
+  def self.api_key
+    @api_key
+  end
+
+  # EdmTrain API key setter
+  # @param [String] key the API key
+  # @return [String] the API key
+  def self.api_key=(key)
+    @api_key = key
+  end
+
+  # Error for API errors
+  # @return [StandardError] the API error
+  class APIError < StandardError; end
+
+  # Error for missing API key
+  # @return [StandardError] the missing API key error
+  class MissingKeyError < StandardError
+    def initialize
+      super 'Must set EdmTrain.api_key before making requests'
+    end
+  end
+
+  # Client for the EdmTrain API
+  class Client
+    # Perform a GET request to the EdmTrain API
+    # @param [String] path the path to the API endpoint
+    # @param [Hash] params the query parameters
+    # @raise [MissingKeyError] if the API key is not set
+    # @return [Hash] the response from the API
+    def get(path, params = {})
+      raise MissingKeyError unless EdmTrain.api_key
+
+      params[:client] = EdmTrain.api_key
+      result = JSON.parse(URI.open("https://edmtrain.com/api/#{path}?#{to_query(params)}").read)
+      raise APIError, result['message'] unless result['success']
+
+      result['data']
+    end
+
+    private
+    # Helper method to convert a hash to a query string
+    # @param [Hash] params the query parameters
+    # @return [String] the query string
+    def to_query(params)
+      URI.encode_www_form(params)
+    end
+  end
+end

data/lib/edm_train/events.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module EdmTrain
+  # Events API
+  class Events
+    # Returns all known events
+    # @return [Array<Event>]
+    def self.all
+      EdmTrain.client.get('/events').map { |raw_event| Event.new(raw_event) }
+    end
+
+    # Search for events matching the given paramaters
+    # @param [Hash] params All fields are optional
+    # @option params [String] :eventName The name of the event, such as the name of a festival. Most events do not have names. If an event has no artists, then it will have a name.
+    # @option params [String] :artistIds One or more artist ids to retrieve events for. Artist ids can be determined by looking at an existing event where they are performing.
+    # @option params [String] :venueIds One or more venue ids to retrieve events for. Venue ids can be determined by looking at an existing event for that location.
+    # @option params [String] :locationIds One or more location ids to retrieve events for. Location ids can be determined by using the Locations API below. All live streams will be included unless livestreamInd is set to false.
+    # @option params [String] :startDate  Retrieve events occurring at or after this local date (only future events will be returned).
+    # @option params [String] :endDate  Retrieve events occurring at or before this local date.
+    # @option params [String] :createdStartDate  Retrieve events added to Edmtrain at or after this UTC date (only future events will be returned).
+    # @option params [String] :createdEndDate  Retrieve events added to Edmtrain at or before this UTC date.
+    # @option params [String] :festivalInd  Set to true to return only festivals (default is not set). Set to false to exclude festivals.
+    # @option params [String] :livestreamInd  Set to true to return only live streams (default is not set). Set to false to exclude live streams.
+    # @return [Array<Event>]
+    # @example
+    #   EdmTrain::Events.find(locationIds: 102) # Find events near location 102 (Detroit, Michigan)
+    def self.find(params)
+      EdmTrain.client.get('/events', params).map { |raw_event| Event.new(raw_event) }
+    end
+  end
+
+  # Event object
+  # @attr_reader [Integer] id the event ID
+  # @attr_reader [String] link the link to the event on EdmTrain
+  # @attr_reader [Date] date the date of the event
+  # @attr_reader [Array<Artist>] artists the artists performing at the event
+  # @attr_reader [Venue] venue the venue of the event
+  class Event
+    attr_reader :id, :link, :ages, :date, :venue, :ages
+    # @param [Hash] raw_event the raw event from the API
+    # @note This is not intended to be called directly
+    def initialize(raw_event)
+      @id = raw_event['id']
+      @link = raw_event['link']
+      @date = Date.parse(raw_event['date'])
+      @start_time = raw_event['startTime']
+      @end_time = raw_event['endTime']
+      @artists = raw_event['artistList'].map {|artist| EdmTrain::Artist.new(artist)}
+      @venue = EdmTrain::Venue.new(raw_event['venue'])
+      @created_at = raw_event['createdDate']
+      @festival = raw_event['festivalInd']
+      @electronic = raw_event['electronicMusicInd']
+      @other_genre = raw_event['otherGenreInd']
+      @live_stream = raw_event['liveStreamInd']
+      @ages = raw_event['ages'] || ''
+      @name = raw_event['name']
+      @festival = raw_event['festivalInd']
+      @electronic = raw_event['electronicMusicInd']
+      @other_genre = raw_event['otherGenreInd']
+    end
+
+    # Returns a string representation of the event for event searching
+    # @return [DateTime]
+    def created_at
+      @created_at ? DateTime.parse(raw_event['createdDate']) : nil
+    end
+    
+    # Returns an array of artists performing at the event
+    # @return [Array<Artist>]
+    def artists
+      @artists || []
+    end
+
+    # Returns the name of the event
+    # @return [String]
+    def name
+      @name || @artists.map(&:name).join(', ')
+    end
+
+    # Returns the start time of the event. This only applies to livestreams
+    # @return [DateTime]
+    def start_time
+      @start_time ? DateTime.parse(@start_time) : date
+    end
+
+    # Returns the end time of the event. This only applies to livestreams
+    # @return [DateTime]
+    def end_time
+      @end_time ? DateTime.parse(@end_time) : date
+    end
+
+    # Returns true if the event is an electronic music event
+    # @return [Boolean]
+    def electronic?
+      @electronic
+    end
+
+    # Returns true if the event is an other genre event
+    # @return [Boolean]
+    def other_genre?
+      @other_genre
+    end
+
+    # Returns true if the event is a festival
+    # @return [Boolean]
+    def festival?
+      @festival
+    end
+
+    # Returns true if the event is a livestream
+    # @return [Boolean]
+    def live_stream?
+      @live_stream
+    end
+    
+    # Returns an array of artist names performing at the event
+    # @return [Array<String>]
+    def artist_names
+      return "Unknown" unless @artists
+      @artists.map(&:name)
+    end
+
+    # Returns a string representation of the event.
+    # @return [String]
+    def to_s
+      "#{name} - #{artist_names.join(', ')} at #{venue.name}"
+    end
+  end
+end

data/lib/edm_train/locations.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module EdmTrain
+  # Locations API Calls
+  class Locations
+    # Returns all known locations
+    # @return [Array<Location>]
+    def self.all
+      EdmTrain.client.get('/locations').map do |raw_location|
+        Location.new(raw_location)
+      end
+    end
+
+    # Returns a location based on city and state
+    # @param [Hash] params
+    # @option params [String] :city the city
+    # @option params [String] :state the state
+    # @example
+    #   EdmTrain::Locations.find(city: 'Detroit', state: 'Michigan')
+    # @return [Location]
+    def self.find(params = {})
+      Location.new(EdmTrain.client.get('/locations', city: params[:city], state: params[:state]).first)
+    end
+  end
+
+  # Location object
+  # @attr_reader [Integer] id the location ID
+  # @attr_reader [String] city the city (e.g. 'Detroit')
+  # @attr_reader [String] state the state (e.g. 'Michigan')
+  # @attr_reader [String] state_code the state code (e.g. 'MI')
+  # @attr_reader [Float] latitude the latitude
+  # @attr_reader [Float] longitude the longitude
+  # @attr_reader [String] link the link to the location on EdmTrain
+  class Location
+    attr_reader :id, :city, :state, :state_code, :latitude, :longitude, :link
+
+    # @param [Hash] raw_location the raw location from the API
+    # @note This is not intended to be called directly
+    def initialize(raw_location)
+      @id = raw_location['id']
+      @city = raw_location['city']
+      @state = raw_location['state']
+      @state_code = raw_location['stateCode']
+      @latitude = raw_location['latitude']
+      @longitude = raw_location['longitude']
+      @link = raw_location['link']
+    end
+    
+    # Returns all events for this location
+    # @return [Array<Event>]  
+    def events
+      EdmTrain::Events.find(to_h)
+    end
+
+    # Returns a string representation of the location for event searching
+    # @return [Hash]
+    def to_h
+      {
+        city: @city,
+        state: @state,
+        latitude: @latitude,
+        longitude: @longitude
+      }
+    end
+  end
+end

data/lib/edm_train/venue.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EdmTrain
+  # Venue object
+  class Venue
+    attr_reader :id, :name, :location, :address, :state, :latitude, :longitude
+
+    def initialize(raw_venue)
+      @id = raw_venue['id']
+      @name = raw_venue['name']
+      @location = raw_venue['location']
+      @address = raw_venue['address']
+      @state = raw_venue['state']
+      @latitude = raw_venue['latitude']
+      @longitude = raw_venue['longitude']
+    end
+  end
+end

data/lib/edm_train.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'edm_train/client'
+require 'edm_train/events'
+require 'edm_train/locations'
+require 'edm_train/venue'
+require 'edm_train/artist'
+
+# An API Client for EdmTrain.com
+# Search and discover EDM events near you.
+# @example
+#   EdmTrain.api_key = 'YOUR_API_KEY'
+#   all_locations = EdmTrain::Locations.all
+#   detroit = EdmTrain::Locations.find(city: 'Detroit', state: 'Michigan')
+#   detroit_events = detroit.events
+module EdmTrain
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: edm_train
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- James Paterni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-11-25 00:00:00.000000000 Z
+dependencies: []
+description: Pulls events from EdmTrain.com
+email: james@ruby-code.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/edm_train.rb
+- lib/edm_train/artist.rb
+- lib/edm_train/client.rb
+- lib/edm_train/events.rb
+- lib/edm_train/locations.rb
+- lib/edm_train/venue.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.22
+signing_key: 
+specification_version: 4
+summary: Pulls events from EdmTrain.com
+test_files: []