thingspeak/app/controllers/feed_controller.rb

class FeedController < ApplicationController
	require 'csv'
	layout 'application', :except => :index

	def index
		channel = Channel.find(params[:channel_id])
		api_key = ApiKey.find_by_api_key(get_userkey)
		@success = channel_permission?(channel, api_key)

		# set timezone correctly
		set_time_zone(params)

		# set limits
		limit = params[:results].to_i if params[:results]

		# check for access
		if @success

			# create options hash
			channel_options = { :only => channel_select_data(channel) }
			select_options = feed_select_data(channel)

			# get feed based on conditions
			feeds = Feed.find(
				:all,
				:conditions => { :channel_id => channel.id, :created_at => get_date_range(params) },
				:select => select_options,
				:order => 'created_at desc',
				:limit => limit
			)

      # keep track of whether data has been rounded already
      rounded = false

			# if a feed has data
			if !feeds.empty?
				# convert to timescales if necessary
				if timeparam_valid?(params[:timescale])
					feeds = feeds_into_timescales(feeds)
				# convert to sums if necessary
				elsif timeparam_valid?(params[:sum])
					feeds = feeds_into_sums(feeds)
          rounded = true
				# convert to averages if necessary
				elsif timeparam_valid?(params[:average])
					feeds = feeds_into_averages(feeds)
          rounded = true
				# convert to medians if necessary
				elsif timeparam_valid?(params[:median])
					feeds = feeds_into_medians(feeds)
          rounded = true
				end
			end

      # if a feed needs to be rounded
      if params[:round] and !rounded
        feeds = object_round(feeds, params[:round].to_i)
      end

			# set output correctly
			if params[:format] == 'xml'
				@channel_output = channel.to_xml(channel_options).sub('</channel>', '').strip
				@feed_output = feeds.to_xml(:skip_instruct => true).gsub(/\n/, "\n  ").chop.chop
			elsif params[:format] == 'csv'
				@feed_output = feeds
			else
				@channel_output = channel.to_json(channel_options).chop
				@feed_output = feeds.to_json
			end

		# else no access, set error code
		else
			if params[:format] == 'xml'
				@channel_output = bad_channel_xml
			else
				@channel_output = '-1'.to_json
			end
		end

		# set callback for jsonp
		@callback = params[:callback] if params[:callback]

		# set csv headers if necessary
		@csv_headers = select_options if params[:format] == 'csv'

		# output proper http response if error
		render :text => '-1', :status => 400 and return if !@success

		# output data in proper format
		respond_to do |format|
			format.html
			format.json
			format.xml
			format.csv
		end
	end

	def show
		@channel = Channel.find(params[:channel_id])
		@api_key = ApiKey.find_by_api_key(get_userkey)
		output = '-1'

		# get most recent entry if necessary
		params[:id] = @channel.last_entry_id if params[:id] == 'last'

		# set timezone correctly
		set_time_zone(params)

		@feed = Feed.find(
			:first,
			:conditions => { :channel_id => @channel.id, :entry_id => params[:id] },
			:select => feed_select_data(@channel)
		)
		@success = channel_permission?(@channel, @api_key)

    # if a feed needs to be rounded
    if params[:round]
      @feed = item_round(@feed, params[:round].to_i)
    end

		# check for access
		if @success
			# set output correctly
			if params[:format] == 'xml'
				output = @feed.to_xml
			elsif params[:format] == 'csv'
				@csv_headers = feed_select_data(@channel)
			elsif (params[:format] == 'txt' or params[:format] == 'text')
				output = add_prepend_append(@feed["field#{params[:field_id]}"])
			else
				output = @feed.to_json
			end
		# else set error code
		else
			if params[:format] == 'xml'
				output = bad_feed_xml
			else
				output = '-1'.to_json
			end
		end

		# output data in proper format
		respond_to do |format|
			format.html { render :json => output }
			format.json { render :json => output, :callback => params[:callback] }
			format.xml { render :xml => output }
			format.csv
			format.text { render :text => output }
		end
	end

	private

		# only output these fields for channel
		def channel_select_data(channel)
			only = [:name, :created_at, :updated_at, :id, :last_entry_id]
			only += [:description] unless channel.description.blank?
			only += [:latitude] unless channel.latitude.blank?
			only += [:longitude] unless channel.longitude.blank?
			only += [:elevation] unless channel.elevation.blank?
			only += [:field1] unless channel.field1.blank?
			only += [:field2] unless channel.field2.blank?
			only += [:field3] unless channel.field3.blank?
			only += [:field4] unless channel.field4.blank?
			only += [:field5] unless channel.field5.blank?
			only += [:field6] unless channel.field6.blank?
			only += [:field7] unless channel.field7.blank?
			only += [:field8] unless channel.field8.blank?
	
			return only
		end
	
		# only output these fields for feed
		def feed_select_data(channel)
			only = [:created_at]
			only += [:entry_id] unless timeparam_valid?(params[:timescale]) or timeparam_valid?(params[:average]) or timeparam_valid?(params[:median]) or timeparam_valid?(params[:sum])
			only += [:field1] unless channel.field1.blank? or (params[:field_id] and params[:field_id] != '1')
			only += [:field2] unless channel.field2.blank? or (params[:field_id] and params[:field_id] != '2')
			only += [:field3] unless channel.field3.blank? or (params[:field_id] and params[:field_id] != '3')
			only += [:field4] unless channel.field4.blank? or (params[:field_id] and params[:field_id] != '4')
			only += [:field5] unless channel.field5.blank? or (params[:field_id] and params[:field_id] != '5')
			only += [:field6] unless channel.field6.blank? or (params[:field_id] and params[:field_id] != '6')
			only += [:field7] unless channel.field7.blank? or (params[:field_id] and params[:field_id] != '7')
			only += [:field8] unless channel.field8.blank? or (params[:field_id] and params[:field_id] != '8')

			# add geolocation data if necessary
			if params[:location] and params[:location].upcase == 'TRUE'
				only += [:latitude]
				only += [:longitude]
				only += [:elevation]
			end
	
			# add status if necessary
			only += [:status] if params[:status] and params[:status].upcase == 'TRUE'

			return only
		end

		# checks for valid timescale
		def timeparam_valid?(timeparam)
			valid_minutes = [10, 15, 20, 30, 60, 240, 720, 1440]
			if timeparam and valid_minutes.include?(timeparam.to_i)
				return true
			else
				return false
			end
		end

    # applies rounding to an enumerable object
    def object_round(object, round=nil, match='field')
      object.each_with_index do |o, index|
        object[index] = item_round(o, round, match)
      end

      return object
    end

    # applies rounding to a single item's attributes if necessary
    def item_round(item, round=nil, match='field')
      # for each attribute
      item.attribute_names.each do |attr|
        # only add non-null numeric fields
        if attr.index(match) and !item[attr].nil? and is_a_number?(item[attr])
          # keep track of whether the value contains commas
          comma_flag = (item[attr].to_s.index(',')) ? true : false

          # replace commas with decimals if appropriate
          item[attr] = item[attr].to_s.gsub(/,/, '.') if comma_flag

          # do the actual rounding
		      item[attr] = sprintf "%.#{round}f", item[attr]

          # replace decimals with commas if appropriate
          item[attr] = item[attr].to_s.gsub(/\./, ',') if comma_flag
        end
      end

      # output new item
      return item
    end

		# slice feed into timescales
		def feeds_into_timescales(feeds)
			# convert timescale (minutes) into seconds
			seconds = params[:timescale].to_i * 60
			# get floored time ranges
			start_time = get_floored_time(feeds.first.created_at, seconds)
			end_time = get_floored_time(feeds.last.created_at, seconds)

			# create empty array with appropriate size
			timeslices = Array.new(((end_time - start_time) / seconds).floor)

			# create a blank clone of the first feed so that we only get the necessary attributes
			empty_feed = create_empty_clone(feeds.first)

			# add feeds to array
			feeds.each do |f|
				i = ((f.created_at - start_time) / seconds).floor
				f.created_at = start_time + i * seconds
				timeslices[i] = f if timeslices[i].nil?
			end

			# fill in empty array elements
			timeslices.each_index do |i|
				if timeslices[i].nil?
					current_feed = empty_feed.clone
					current_feed.created_at = (start_time + (i * seconds))
					timeslices[i] = current_feed
				end
			end

			return timeslices
		end

		# slice feed into averages
		def feeds_into_averages(feeds)
			# convert timescale (minutes) into seconds
			seconds = params[:average].to_i * 60
			# get floored time ranges
			start_time = get_floored_time(feeds.first.created_at, seconds)
			end_time = get_floored_time(feeds.last.created_at, seconds)

			# create empty array with appropriate size
			timeslices = Array.new(((end_time - start_time) / seconds).floor)

			# create a blank clone of the first feed so that we only get the necessary attributes
			empty_feed = create_empty_clone(feeds.first)

			# add feeds to array
			feeds.each do |f|
				i = ((f.created_at - start_time) / seconds).floor
				f.created_at = start_time + i * seconds
				# create multidimensional array
				timeslices[i] = [] if timeslices[i].nil?
				timeslices[i].push(f)
			end		

			# keep track of whether numbers use commas as decimals
			comma_flag = false

			# fill in array
			timeslices.each_index do |i|
				# insert empty values
				if timeslices[i].nil?
					current_feed = empty_feed.clone
					current_feed.created_at = (start_time + (i * seconds))
					timeslices[i] = current_feed
				# else average the inner array
				else
					sum_feed = empty_feed.clone
					sum_feed.created_at = timeslices[i].first.created_at
					# for each feed
					timeslices[i].each do |f|
						# for each attribute, add to sum_feed so that we have the total
						sum_feed.attribute_names.each do |attr|

							# only add non-null integer fields
							if attr.index('field') and !f[attr].nil? and is_a_number?(f[attr])
								# set comma_flag once if we find a number with a comma
								comma_flag = true if !comma_flag and f[attr].to_s.index(',')

								# set initial data
								if sum_feed[attr].nil?
									sum_feed[attr] = parsefloat(f[attr])
								# add data
								elsif f[attr]
									sum_feed[attr] = parsefloat(sum_feed[attr]) + parsefloat(f[attr])
								end
							end

						end
					end

					# set to the averaged feed
					timeslices[i] = object_average(sum_feed, timeslices[i].length, comma_flag, params[:round])
				end
			end

			return timeslices
		end

		# slice feed into medians
		def feeds_into_medians(feeds)
			# convert timescale (minutes) into seconds
			seconds = params[:median].to_i * 60
			# get floored time ranges
			start_time = get_floored_time(feeds.first.created_at, seconds)
			end_time = get_floored_time(feeds.last.created_at, seconds)

			# create empty array with appropriate size
			timeslices = Array.new(((end_time - start_time) / seconds).floor)

			# create a blank clone of the first feed so that we only get the necessary attributes
			empty_feed = create_empty_clone(feeds.first)

			# add feeds to array
			feeds.each do |f|
				i = ((f.created_at - start_time) / seconds).floor
				f.created_at = start_time + i * seconds
				# create multidimensional array
				timeslices[i] = [] if timeslices[i].nil?
				timeslices[i].push(f)
			end		

			# keep track of whether numbers use commas as decimals
			comma_flag = false

			# fill in array
			timeslices.each_index do |i|
				# insert empty values
				if timeslices[i].nil?
					current_feed = empty_feed.clone
					current_feed.created_at = (start_time + (i * seconds))
					timeslices[i] = current_feed
				# else get median values for the inner array
				else

					# create blank hash called 'fields' to hold data
					fields = {}

					# for each feed
					timeslices[i].each do |f|

						# for each attribute
						f.attribute_names.each do |attr|
							if attr.index('field')

								# create blank array for each field
								fields["#{attr}"] = [] if fields["#{attr}"].nil?

								# push numeric field data onto its array
								if is_a_number?(f[attr])
									# set comma_flag once if we find a number with a comma
									comma_flag = true if !comma_flag and f[attr].to_s.index(',')

									fields["#{attr}"].push(parsefloat(f[attr]))
								end

							end
						end

					end

					# sort fields arrays
					fields.each_key do |key|
						fields[key] = fields[key].compact.sort
					end

					# get the median
					median_feed = empty_feed.clone
					median_feed.created_at = timeslices[i].first.created_at
					median_feed.attribute_names.each do |attr|
						median_feed[attr] = object_median(fields[attr], comma_flag, params[:round]) if attr.index('field')
					end

					timeslices[i] = median_feed

				end
			end

			return timeslices
		end

		# slice feed into sums
		def feeds_into_sums(feeds)
			# convert timescale (minutes) into seconds
			seconds = params[:sum].to_i * 60
			# get floored time ranges
			start_time = get_floored_time(feeds.first.created_at, seconds)
			end_time = get_floored_time(feeds.last.created_at, seconds)

			# create empty array with appropriate size
			timeslices = Array.new(((end_time - start_time) / seconds).floor)

			# create a blank clone of the first feed so that we only get the necessary attributes
			empty_feed = create_empty_clone(feeds.first)

			# add feeds to array
			feeds.each do |f|
				i = ((f.created_at - start_time) / seconds).floor
				f.created_at = start_time + i * seconds
				# create multidimensional array
				timeslices[i] = [] if timeslices[i].nil?
				timeslices[i].push(f)
			end		

			# keep track of whether numbers use commas as decimals
			comma_flag = false

			# fill in array
			timeslices.each_index do |i|
				# insert empty values
				if timeslices[i].nil?
					current_feed = empty_feed.clone
					current_feed.created_at = (start_time + (i * seconds))
					timeslices[i] = current_feed
				# else sum the inner array
				else
					sum_feed = empty_feed.clone
					sum_feed.created_at = timeslices[i].first.created_at
					# for each feed
					timeslices[i].each do |f|
						# for each attribute, add to sum_feed so that we have the total
						sum_feed.attribute_names.each do |attr|
							# only add non-null integer fields
							if attr.index('field') and !f[attr].nil? and is_a_number?(f[attr])

								# set comma_flag once if we find a number with a comma
								comma_flag = true if !comma_flag and f[attr].to_s.index(',')

								# set initial data
								if sum_feed[attr].nil?
									sum_feed[attr] = parsefloat(f[attr])
								# add data
								elsif f[attr]
									sum_feed[attr] = parsefloat(sum_feed[attr]) + parsefloat(f[attr])
								end

							end
						end
					end

					# set to the summed feed
					timeslices[i] = object_sum(sum_feed, comma_flag, params[:round])
				end
			end

			return timeslices
		end

		def is_a_number?(s)
			s.to_s.gsub(/,/, '.').match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true
		end

		def parsefloat(number)
			return number.to_s.gsub(/,/, '.').to_f
		end

		# gets the median for an object
		def object_median(object, comma_flag=false, round=nil)
			return nil if object.nil?
			length = object.length
			return nil if length == 0
			output = ''

			# do the calculation
			if length % 2 == 0
				output = (object[(length - 1) / 2] + object[length / 2]) / 2
			else
				output = object[(length - 1) / 2]
			end

			output = sprintf "%.#{round}f", output if round and is_a_number?(output)

			# replace decimals with commas if appropriate
			output = output.to_s.gsub(/\./, ',') if comma_flag

			return output.to_s
		end

		# averages a summed object over length
		def object_average(object, length, comma_flag=false, round=nil)
			object.attribute_names.each do |attr|
				# only average non-null integer fields
				if !object[attr].nil? and is_a_number?(object[attr])
					if round
						object[attr] = sprintf "%.#{round}f", (parsefloat(object[attr]) / length)
					else
						object[attr] = (parsefloat(object[attr]) / length).to_s
					end
					# replace decimals with commas if appropriate
					object[attr] = object[attr].gsub(/\./, ',') if comma_flag
				end
			end

			return object
		end

		# formats a summed object correctly
		def object_sum(object, comma_flag=false, round=nil)
			object.attribute_names.each do |attr|
				# only average non-null integer fields
				if !object[attr].nil? and is_a_number?(object[attr])
					if round
						object[attr] = sprintf "%.#{round}f", parsefloat(object[attr])
					else
						object[attr] = parsefloat(object[attr]).to_s
					end
					# replace decimals with commas if appropriate
					object[attr] = object[attr].gsub(/\./, ',') if comma_flag
				end
			end

			return object
		end

		# creates an empty clone of an object
		def create_empty_clone(object)
			empty_clone = object.dup
			empty_clone.attribute_names.each { |attr| empty_clone[attr] = nil }
			return empty_clone
		end

		# gets time floored to proper interval
		def get_floored_time(input_time, seconds)
 			return Time.zone.at((input_time.to_f / seconds).floor * seconds)
		end

end