kakaxi_parse 0.2.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82ea4d2a2843181038c22a3258ec3fb1c25756f5870f65a18d0522aece359bd2
+  data.tar.gz: ec38f39676503896860892afc69f1fb2a4079dff1fc7e2ebf5e0b443bcf3ca98
+SHA512:
+  metadata.gz: 6eed0c2644e8b9fa366e9715975b73060c7c1308fe6f5662dd774ac91a07f12c8b2198ad9e67baac149cbbbcf19c8c69671123f5b1a019444319616e8ba88152
+  data.tar.gz: 0cbdef90d74a0807b7dfe8818e78079fea1e567adaa7a6be67e6be5cbff295612eee1eb6e183d38056fe115dd6e6bca6fb23a2c5abc982a7b6dc529a386f7f2d

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    kakaxi_parse (0.1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  kakaxi_parse!
+
+BUNDLED WITH
+   1.15.4

data/kakaxi_parse.gemspec

@@ -0,0 +1,14 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name        = 'kakaxi_parse'
+  s.version     = '0.2.4'
+  s.licenses    = ['MIT']
+  s.summary     = 'Kakaxi Parse SDK'
+  s.description = 'Make it easy to controll Parse in ruby'
+  s.authors     = ['Naggi Goishi']
+  s.email       = 'naggi@kakaxi.jp'
+  s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|pkg)/}) }
+  s.homepage    = 'https://github.com/kakaxi-inc/kakaxi-parse-ruby.git'
+end

data/lib/kakaxi_parse.rb

@@ -0,0 +1,5 @@
+require 'net/http'
+require 'date'
+require 'json'
+require 'kakaxi_parse/datatypes/datatype'
+require 'kakaxi_parse/model'

data/lib/kakaxi_parse/api.rb

@@ -0,0 +1,51 @@
+module KakaxiParse
+  class API
+    BASE_URL = 'https://parseapi.back4app.com/'
+
+    def initialize(endpoint, params: {})
+      @uri = URI.parse(BASE_URL + endpoint)
+      @params = params
+    end
+
+    def get
+      @uri.query = URI.encode_www_form(@params)
+      request = Net::HTTP::Get.new(@uri)
+      set_auth_header!(request)
+      request(request)
+    end
+
+    def put
+      request = Net::HTTP::Put.new(@uri)
+      request.body = @params.to_json
+      set_auth_header!(request)
+      request['Content-Type'] = 'application/json'
+      request(request)
+    end
+
+    def post
+      request = Net::HTTP::Post.new(@uri)
+      request.body = @params.to_json
+      set_auth_header!(request)
+      request['Content-Type'] = 'application/json'
+      request(request)
+    end
+
+    def delete
+      request = Net::HTTP::Delete.new(@uri)
+      set_auth_header!(request)
+      request(request)
+    end
+
+    private
+    def set_auth_header!(request)
+      request['X-Parse-Application-Id'] = ENV['PARSE_ID']
+      request['X-Parse-Master-Key'] = ENV['PARSE_MASTER_KEY']
+    end
+
+    def request(request)
+      Net::HTTP.start(@uri.host, @uri.port, use_ssl: true) do |https|
+        JSON.parse(https.request(request).body)
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/base_model.rb

@@ -0,0 +1,126 @@
+require 'kakaxi_parse/api'
+
+module KakaxiParse
+  class BaseModel
+    DEFUALT_LIMIT = 1000
+    attr_accessor :id, :name, :updated_at, :created_at
+
+    def initialize(id, name, updated_at, created_at)
+       @id = id
+       @name = name if name
+       @updated_at = DateTime.strptime(updated_at, '%Y-%m-%dT%H:%M:%S.%LZ') if updated_at
+       @created_at =  DateTime.strptime(created_at, '%Y-%m-%dT%H:%M:%S.%LZ') if created_at
+    end
+
+    def self.all(limit: DEFUALT_LIMIT)
+      to_objects(API.new("classes/#{ self.demodulize }", params: { limit: limit }).get['results'])
+    end
+
+    def self.where(model, hash, limit, belongs_to = [], related_to = [])
+      params = { limit: limit }.merge(where: format(hash, belongs_to, related_to).to_json)
+      API.new("classes/#{ model.demodulize }", params: params).get['results']
+    end
+
+    def self.order(order='created_at', limit=DEFUALT_LIMIT)
+      params = { limit: limit }.merge(order: camelize(order))
+      to_objects(API.new("classes/#{ self.demodulize }", params: params).get['results'])
+    end
+
+    def self.short_name
+      raise NotImplementedError
+    end
+
+    def self.find(id)
+      where(id: id).first
+    end
+
+    def save(record, params, belongs_to = [], related_to = [])
+      result = API.new("classes/#{record.class.demodulize}", params: BaseModel.format(params, belongs_to, related_to)).post
+      if result.has_key? 'objectId'
+        self.created_at = DateTime.strptime(result['createdAt'], '%Y-%m-%dT%H:%M:%S.%LZ')
+        self.id = result['objectId']
+        true
+      else
+        false
+      end
+    end
+
+    def update(record, params, belongs_to = [], related_to = [])
+      result = API.new("classes/#{record.class.demodulize}/#{record.id}", params: BaseModel.format(params, belongs_to, related_to)).put
+      if result.has_key? 'updatedAt'
+        self.updated_at = DateTime.strptime(result['updatedAt'], '%Y-%m-%dT%H:%M:%S.%LZ')
+        true
+      else
+        false
+      end
+    end
+
+    def delete
+      API.new("classes/#{self.class.demodulize}/#{self.id}").delete
+    end
+
+    def self.demodulize
+      self.name.split('::').last
+    end
+
+    private
+    def self.replace_key(hash, old_key, new_key)
+      hash[new_key] = hash.delete(old_key) if hash.has_key? old_key
+      hash
+    end
+
+    def self.keys_to_camel(hash)
+      hash.keys.each { |key, _| replace_key(hash, key, camelize(key.to_s)) }
+      hash
+    end  
+
+    def self.camelize(string)
+      if ['imsi', 'imei', 'iccid'].include?(string)
+        return string.upcase
+      end
+      string.split('_').map(&:capitalize).join.tap { |e| e[0] = e[0].downcase }
+    end
+
+    def self.to_reference_key(reference_name)
+      (reference_name.to_s + '_id').to_sym
+    end
+
+    def self.to_reference_key_array(reference_names)
+      reference_names.map { |name| to_reference_key(name) }
+    end
+
+    def self.validate_relation(hash, belongs_to, related_to)
+      belongs_to.each do |klass|
+        short_name = klass.short_name
+        reference = to_reference_key(short_name)
+        if hash.has_key? reference
+          replace_key(hash, reference, short_name)
+          hash[short_name] = Datatype::Pointer.new(klass, hash[short_name]).to_hash
+        end
+      end
+
+      related_to.each do |klass|
+        short_name = klass.short_name
+        reference = to_reference_key(short_name)
+        if hash.has_key? reference
+          replace_key(hash, reference, '$related_to')
+          hash['$related_to'] = { object: Datatype::Pointer.new(klass, hash['$related_to']).to_hash, key: self.reference_name }
+        end
+      end
+      hash
+    end
+
+    def self.format(hash, belongs_to, related_to)
+      hash = validate_relation(hash, belongs_to, related_to)
+      replace_key(hash, :id, :object_id)
+      keys_to_camel(hash)
+    end
+
+    def build_original_params(params)
+      original_params = {}
+      params.each { |key, value| original_params[key] = value }
+      original_params
+    end
+  end
+end
+

data/lib/kakaxi_parse/climate.rb

@@ -0,0 +1,63 @@
+module KakaxiParse
+  class Climate < BaseModel
+    @@belongs_to = [KakaxiDevice]
+    @@attributes = %i(solar_radiation recorded_at rain_amount rainfall humidity temperature weather device_id power_feeding interpolation)
+    attr_accessor *@@attributes
+
+    def initialize(
+          id: nil,
+          updated_at: nil,
+          created_at: nil,
+          solar_radiation: nil,
+          recorded_at: nil,
+          rain_amount: nil,
+          rainfall: nil,
+          humidity: nil,
+          temperature: nil,
+          weather: nil,
+          device_id: nil,
+          power_feeding: nil,
+          interpolation: nil
+        )
+      @solar_radiation = solar_radiation
+      @recorded_at = DateTime.strptime(recorded_at, '%Y-%m-%dT%H:%M:%S.%LZ')
+      @rain_amount = rain_amount
+      @humidity = humidity
+      @temperature = temperature
+      @weather = weather
+      @device_id = device_id
+      @power_feeding = power_feeding
+      @interpolation = interpolation
+      super(id, nil, updated_at, created_at)
+    end
+
+    def self.where(hash, limit: DEFUALT_LIMIT)
+      to_objects(super(self, hash, limit, @@belongs_to)) if valid_key?(hash)
+    end
+
+    private
+    def self.to_objects(climates)
+      climates.map do |climate|
+        new(
+          id: climate['objectId'],
+          updated_at: climate['updatedAt'],
+          created_at: climate['createdAt'],
+          solar_radiation: climate['solarRadiation'],
+          recorded_at: climate['recordedAt']['iso'],
+          rain_amount: climate['rainAmount'],
+          rainfall: climate['rainfall'],
+          humidity: climate['humidity'],
+          temperature: climate['temperature'],
+          weather: climate['weather'],
+          device_id: climate['device']['objectId'],
+          power_feeding: climate['powerFeeding'],
+          interpolation: climate['interpolation']
+          )
+      end
+    end
+
+    def self.valid_key?(hash)
+      hash.keys.all? { |key| %i(id updated_at created_at solar_radiation recorded_at rain_amount rainfall humidity temperature weather device_id power_feeding interpolation).include? key }
+    end
+  end
+end

data/lib/kakaxi_parse/datatypes/add_relation.rb

@@ -0,0 +1,19 @@
+module KakaxiParse
+  module Datatype
+    class AddRelation
+      def initialize(klass, ids)
+        @klass = klass
+        @ids = ids
+      end
+
+      def to_hash
+        {
+          @klass.reference_name.to_sym => {
+            __op: "AddRelation",
+            objects: @ids.map { |id| Datatype::Pointer.new(@klass, id).to_hash }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/datatypes/base_datatype.rb

@@ -0,0 +1,6 @@
+module KakaxiParse
+  module Datatype
+    class Base
+    end
+  end
+end

data/lib/kakaxi_parse/datatypes/datatype.rb

@@ -0,0 +1,6 @@
+require 'kakaxi_parse/datatypes/base_datatype'
+require 'kakaxi_parse/datatypes/pointer'
+require 'kakaxi_parse/datatypes/geopoint'
+require 'kakaxi_parse/datatypes/datetime'
+require 'kakaxi_parse/datatypes/add_relation'
+require 'kakaxi_parse/datatypes/remove_relation'

data/lib/kakaxi_parse/datatypes/datetime.rb

@@ -0,0 +1,26 @@
+module KakaxiParse
+  module Datatype
+    class DateTime
+      attr_accessor :year, :month, :day, :hour, :minute, :second
+
+      def initialize(*args)
+        if args.length == 1 && args[0].class == String
+          datetime = DateTime.strptime(args[0], '%Y-%m-%dT%H:%M:%S.%LZ')
+          @year = datetime.year
+          @month = datetime.month
+          @day = datetime.day
+          @hour = datetime.hour
+          @minute = datetime.minute
+          @second = datetime.second
+        else
+          @year = args[0] || nil
+          @month = args[1] || nil
+          @day = args[2] || nil
+          @hour = args[3] || nil
+          @minute = args[4] || nil
+          @second = args[5] || nil
+        end
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/datatypes/geopoint.rb

@@ -0,0 +1,16 @@
+module KakaxiParse
+  module Datatype
+    class GeoPoint
+      attr_accessor :lat, :lon
+
+      def initialize(lat=nil, lon=nil)
+        @lat = lat.to_f
+        @lon = lon.to_f
+      end
+
+      def to_hash
+        { __type: 'GeoPoint', latitude: @lat, longitude: @lon }
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/datatypes/pointer.rb

@@ -0,0 +1,16 @@
+module KakaxiParse
+  module Datatype 
+    class Pointer < Base
+      attr_accessor :id
+
+      def initialize(klass, id)
+        @id = id
+        @klass = klass
+      end
+
+      def to_hash
+        { __type: 'Pointer', className: @klass.demodulize, objectId: @id }
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/datatypes/remove_relation.rb

@@ -0,0 +1,19 @@
+module KakaxiParse
+  module Datatype
+    class RemoveRelation
+      def initialize(klass, ids)
+        @klass = klass
+        @ids = ids
+      end
+
+      def to_hash
+        {
+          @klass.reference_name.to_sym => {
+            __op: "RemoveRelation",
+            objects: @ids.map { |id| Datatype::Pointer.new(@klass, id).to_hash }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/datatypes/timelapse.rb

@@ -0,0 +1,2 @@
+class Timelapse
+end

data/lib/kakaxi_parse/farm.rb

@@ -0,0 +1,67 @@
+module KakaxiParse
+  class Farm < BaseModel
+    attr_accessor :farmer_id, :location
+    @@belongs_to = [User]
+
+    def initialize(
+          id: nil,
+          name: nil,
+          farmer_id: nil,
+          location:  nil,
+          updated_at: nil,
+          created_at: nil
+        )
+      @farmer_id = farmer_id
+      @location  = location
+      super(id, name, updated_at, created_at)
+    end
+
+    def self.where(hash, limit: DEFUALT_LIMIT)
+      to_objects(super(self, hash, limit, @@belongs_to)) if valid_key?(hash)
+    end
+
+    def self.short_name
+      'farm'
+    end
+
+    def save
+      id ? false : super(self, { name: name, farmer_id: farmer_id }, @@belongs_to)
+    end
+
+    def update(params)
+      original_params = build_original_params(params)
+      if super(self, params, @@belongs_to)
+        original_params.each { |key, value| self.send("#{key}=", value) }
+        true
+      else
+        false
+      end
+    end
+
+    def farmer
+      User.find(farmer_id)
+    end
+
+    def devices
+      KakaxiDevice.where(farm_id: id)
+    end
+
+    private
+    def self.valid_key?(hash)
+      hash.keys.all? { |key| %i(id name farmer_id updated_at created_at).include? key }
+    end
+
+    def self.to_objects(farms)
+      farms.map do |farm|
+        new(
+          id: farm['objectId'],
+          name: farm['name'],
+          farmer_id: farm['farmer'] && farm['farmer']['objectId'],
+          location:  farm['location'],
+          updated_at: farm['updatedAt'],
+          created_at: farm['createdAt']
+        )
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/farm_manager_user.rb

@@ -0,0 +1,63 @@
+module KakaxiParse
+  class FarmManagerUser < BaseModel
+    def initialize(id: nil, devices: nil, updated_at: nil, created_at: nil)
+      @devices = devices
+      super(id, nil, updated_at, created_at)
+    end
+
+    def self.short_name
+      'farm_manager_user'
+    end
+
+    def self.all(limit: DEFUALT_LIMIT)
+      to_objects(API.new("classes/#{self.demodulize}", params: { limit: limit }).get)
+    end
+
+    def self.where(hash, limit: DEFUALT_LIMIT)
+      to_objects(super(self, hash, limit)) if valid_key?(hash)
+    end
+
+    def save
+      params = {}
+      params = Datatype::AddRelation.new(KakaxiDevice, @devices.map(&:id)).to_hash if @devices
+      id ? false : super(self, params)
+    end
+
+    def add_device(id)
+      params = Datatype::AddRelation.new(KakaxiDevice, [id]).to_hash
+      result = API.new("classes/#{ self.class.demodulize }/#{ self.id }", params: params).put
+      if result.has_key? 'updatedAt'
+        self.updated_at = DateTime.strptime(result['updatedAt'], '%Y-%m-%dT%H:%M:%S.%LZ')
+        true
+      else
+        false
+      end
+    end
+
+    def remove_device(id)
+      params = Datatype::RemoveRelation.new(KakaxiDevice, [id]).to_hash
+      result = API.new("classes/#{ self.class.demodulize }/#{ self.id }", params: params).put
+      if result.has_key? 'updatedAt'
+        self.updated_at = DateTime.strptime(result['updatedAt'], '%Y-%m-%dT%H:%M:%S.%LZ')
+        true
+      else
+        false
+      end
+    end
+
+    private
+    def self.valid_key?(hash)
+      hash.keys.all? { |key| %i(id devices updated_at created_at).include? key }
+    end
+
+    def self.to_objects(farm_manager_users)
+      farm_manager_users.map do |user|
+        new(
+          id: user['objectId'],
+          updated_at: user['updatedAt'],
+          created_at: user['createdAt']
+        )
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/interval_photo.rb

@@ -0,0 +1,65 @@
+# String id
+# String name
+# String url
+# String device_id
+# Datetime taken_at
+# Datetime updated_at
+# Datetime created_at
+
+module KakaxiParse
+  class IntervalPhoto < BaseModel
+    attr_accessor :url, :taken_at, :device_id
+    @@belongs_to = [KakaxiDevice]
+
+    def initialize(
+          id: nil,
+          name: nil,
+          url: nil,
+          device_id: nil,
+          taken_at: nil,
+          updated_at: nil,
+          created_at: nil
+        )
+      @url = url
+      @device_id = Datatype::Pointer.new(KakaxiDevice, device_id)
+      @taken_at = DateTime.strptime(taken_at, '%Y-%m-%dT%H:%M:%S.%LZ')
+      super(id, name, updated_at, created_at)
+    end
+
+    def self.where(hash, limit: DEFUALT_LIMIT)
+      to_objects(super(self, hash, limit, @@belongs_to)) if valid_key?(hash)
+    end
+
+    def self.short_name
+      'photo'
+    end
+
+    def device_id
+      @device_id.id
+    end
+
+    def device_id=(id)
+      @device_id.id = id
+    end
+
+    private
+    def self.valid_key?(hash)
+      hash.keys.all? { |key| %i(id name url device_id taken_at updated_at created_at).include? key }
+    end
+
+    def self.to_objects(photos)
+      photos.map do |photo|
+        new(
+          id: photo['objectId'],
+          name: photo['photo'] && photo['photo']['name'],
+          url: photo['photo'] && photo['photo']['url'],
+          device_id: photo['device'] && photo['device']['objectId'],
+          taken_at: photo['takenAt']['iso'],
+          updated_at: photo['updatedAt'],
+          created_at: photo['createdAt']
+        )
+      end
+    end
+  end
+end
+

data/lib/kakaxi_parse/kakaxi_device.rb

@@ -0,0 +1,150 @@
+module KakaxiParse
+  class KakaxiDevice < BaseModel
+    COLUMNS = %i(carrier_name iccid camera_finish_hour camera_start_hour imei
+      camera_interval udid battery upload_start_hour beacon_minor scfg
+      status avatar_type auto_post_interval beacon_major coordinates
+      tzoffset camera_quality imsi tel serial_number farm_id farm_manager_user_id)
+    attr_accessor *COLUMNS
+
+    @@belongs_to = [Farm]
+    @@related_to = [FarmManagerUser]
+
+    def initialize(
+          id: nil,
+          name: nil,
+          carrier_name: nil,
+          iccid: nil,
+          camera_finish_hour: nil,
+          camera_start_hour: nil,
+          imei: nil,
+          camera_interval: nil,
+          udid: nil,
+          battery: nil,
+          upload_start_hour: nil,
+          beacon_minor: nil,
+          scfg: nil,
+          status: nil,
+          avatar_type: nil,
+          auto_post_interval: nil,
+          beacon_major: nil,
+          coordinates: nil,
+          tzoffset: nil,
+          camera_quality: nil,
+          imsi: nil,
+          tel: nil,
+          serial_number: nil,
+          farm_id: nil,
+          updated_at: nil,
+          created_at: nil
+        )
+       @carrier_name = carrier_name
+       @iccid = iccid
+       @camera_finish_hour = camera_finish_hour
+       @camera_start_hour = camera_start_hour
+       @imei = imei
+       @camera_interval = camera_interval
+       @udid = udid
+       @battery = battery
+       @upload_start_hour = upload_start_hour
+       @beacon_minor = beacon_minor
+       @scfg = scfg
+       @status = status
+       @avatar_type = avatar_type
+       @auto_post_interval = auto_post_interval
+       @beacon_major = beacon_major
+       @coordinates = coordinates
+       @tzoffset = tzoffset
+       @camera_quality = camera_quality
+       @imsi = imsi
+       @tel = tel
+       @serial_number = serial_number
+       @farm_id = farm_id
+       super(id, name, updated_at, created_at)
+    end
+
+    def self.where(hash, limit: DEFUALT_LIMIT)
+      to_objects(super(self, validate_params(hash), limit, @@belongs_to, @@related_to)) if valid_key?(hash)
+    end
+
+    def self.short_name
+      'device'
+    end
+
+    def self.reference_name
+      'devices'
+    end
+
+    def farm
+      Farm.find(farm_id: farm_id)
+    end
+
+    def save
+      params = COLUMNS.push(:name).each_with_object({}) do |column, params|
+        params[column] = self.send(column) unless self.send(column).nil?
+      end
+      id ? false : super(self, params, @@belongs_to)
+    end
+
+    def update(params)
+      original_params = build_original_params(params)
+      if super(self, KakaxiDevice.validate_params(params), @@belongs_to)
+        original_params.each { |key, value| self.send("#{key}=", value) }
+        true
+      else
+        false
+      end
+    end
+
+    private
+    def self.hour_to_time(params)
+      %i(camera_finish_hour camera_start_hour upload_start_hour).each { |hour| BaseModel.replace_key(params, hour, hour.to_s.gsub(/hour/, 'time').to_sym) }
+      params
+    end
+
+    def self.validate_params(params)
+      params = hour_to_time(params)
+      if params.has_key? :coordinates
+        params = replace_key(params, :coordinates, :coordinate)
+        params[:coordinate] = params[:coordinate].to_hash
+      end
+      params
+    end
+
+    def self.valid_key?(hash)
+      hash.keys.all? { |key| COLUMNS.push(*%i(id name updated_at created_at)).include? key }
+    end
+
+    def self.to_objects(devices)
+      devices.map do |device|
+        new(
+          id: device['objectId'],
+          name: device['name'],
+          updated_at: device['updatedAt'],
+          created_at: device['createdAt'],
+          farm_id: device['farm'] && device['farm']['objectId'],
+          carrier_name: device['carrierName'],
+          iccid: device['ICCID'],
+          camera_finish_hour: device['cameraFinishTime'],
+          camera_start_hour: device['cameraStartTime'],
+          imei: device['IMEI'],
+          camera_interval: device['cameraInterval'],
+          udid: device['udid'],
+          battery: device['battery'],
+          upload_start_hour: device['uploadStartTime'],
+          beacon_minor: device['beaconMinor'],
+          scfg: device['scfg'],
+          status: device['status'],
+          avatar_type: device['avatarType'],
+          auto_post_interval: device['autoPostInterval'],
+          beacon_major: device['beaconMajor'],
+          coordinates: device['coordinate'] && Datatype::GeoPoint.new(device['coordinate']['latitude'], device['coordinate']['longitude']),
+          tzoffset: device['tzoffset'],
+          camera_quality: device['cameraQuality'],
+          imsi: device['IMSI'],
+          tel: device['tel'],
+          serial_number: device['serialNumber'] || device['serialnumber'],
+        )
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/model.rb

@@ -0,0 +1,9 @@
+require 'kakaxi_parse/base_model'
+require 'kakaxi_parse/role'
+require 'kakaxi_parse/user'
+require 'kakaxi_parse/farm'
+require 'kakaxi_parse/farm_manager_user'
+require 'kakaxi_parse/kakaxi_device'
+require 'kakaxi_parse/interval_photo'
+require 'kakaxi_parse/timelapse'
+require 'kakaxi_parse/climate'

data/lib/kakaxi_parse/role.rb

@@ -0,0 +1,51 @@
+module KakaxiParse
+  class Role < BaseModel
+    def initialize(
+          id: nil,
+          name: nil,
+          updated_at: nil,
+          created_at: nil
+        )
+      super(id, name, updated_at, created_at)
+    end
+
+    def self.where(hash, limit: DEFUALT_LIMIT)
+      to_objects(super(self, hash, limit)) if valid_key?(hash)
+    end
+
+    def self.name
+      '_Role'
+    end
+
+    def self.short_name
+      'role'
+    end
+
+    def add_user(id)
+      params = Datatype::AddRelation.new(User, [id]).to_hash
+      result = API.new("classes/#{self.class.demodulize}/#{ self.id }", params: params).put
+      if result.has_key? 'updatedAt'
+        self.updated_at = DateTime.strptime(result['updatedAt'], '%Y-%m-%dT%H:%M:%S.%LZ')
+        true
+      else
+        false
+      end
+    end
+
+    private
+    def self.valid_key?(hash)
+      hash.keys.all? { |key| %i(id name farmer_id updated_at created_at).include? key }
+    end
+
+    def self.to_objects(roles)
+      roles.map do |role|
+        new(
+          id: role['objectId'],
+          name: role['name'],
+          updated_at: role['updatedAt'],
+          created_at: role['createdAt']
+        )
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/timelapse.rb

@@ -0,0 +1,57 @@
+module KakaxiParse
+  class Timelapse < BaseModel
+    COLUMNS = [:start_datetime, :end_datetime, :thumbnail_url, :url, :device_id]
+    attr_accessor *COLUMNS
+
+    @@belongs_to = [KakaxiDevice]
+
+    def initialize(
+      id: nil,
+      name: nil,
+      created_at: nil,
+      updated_at: nil,
+      start_datetime: nil,
+      end_datetime: nil,
+      thumbnail_url: nil,
+      url: nil,
+      device_id: nil
+      )
+
+      @start_datetime = DateTime.iso8601(start_datetime)
+      @end_datetime   = DateTime.iso8601(end_datetime)
+      @thumbnail_url  = thumbnail_url
+      @url            = url
+      @device_id      = device_id
+
+      super(id, name, updated_at, created_at)
+    end
+
+    def self.where(hash, limit: DEFUALT_LIMIT)
+      to_objects(super(self, hash, limit, @@belongs_to)) if valid_key?(hash)
+    end
+
+    def self.short_name
+      'timelapse'
+    end
+
+    private
+    def self.valid_key?(hash)
+      hash.keys.all? { |key| COLUMNS.push(*%i(id name updated_at created_at)).include? key }
+    end
+
+    def self.to_objects(timelapses)
+      timelapses.map do |timelapse|
+        new(
+          id: timelapse['objectId'],
+          url: timelapse['videoURL'],
+          thumbnail_url: timelapse['thumbnail'] && timelapse['thumbnail']['url'],
+          device_id: timelapse['device'] && timelapse['device']['objectId'],
+          start_datetime: timelapse['beginningTime'] && timelapse['beginningTime']['iso'],
+          end_datetime: timelapse['endTime'] && timelapse['endTime']['iso'],
+          updated_at: timelapse['updatedAt'],
+          created_at: timelapse['createdAt']
+        )
+      end
+    end
+  end
+end

data/lib/kakaxi_parse/user.rb

@@ -0,0 +1,78 @@
+module KakaxiParse
+  class User < BaseModel
+    attr_accessor :email, :password
+    @@related_to = [Role]
+
+    def initialize(
+          id: nil,
+          name: nil,
+          email: nil,
+          password: nil,
+          updated_at: nil,
+          created_at: nil
+          )
+      @email = email
+      @password = password
+      super(id, name, updated_at, created_at)
+    end
+
+    def self.where(hash, limit: DEFUALT_LIMIT)
+      to_objects(super(self, name_to_nickname(hash), limit, [], @@related_to)) if valid_key?(hash)
+    end
+
+    def self.name
+      '_User'
+    end
+
+    def self.short_name
+      'farmer'
+    end
+
+    def self.reference_name
+      'users'
+    end
+
+    def sign_in
+      API.new('login', params: {username: email, password: password}).get
+    end
+
+    def save
+      id ? false : super(self, { nickname: name, email: email, password: password, username: email })
+    end
+
+    def update(params)
+      original_params = build_original_params(params)
+      if super(self, User.name_to_nickname(params))
+        original_params.each { |key, value| self.send("#{key}=", value) }
+        true
+      else
+        false
+      end
+    end
+
+    def farms
+      Farm.where(farmer_id: id)
+    end
+
+    private
+    def self.name_to_nickname(params)
+      replace_key(params, :name, :nickname)
+    end
+
+    def self.valid_key?(hash)
+      hash.keys.all? { |key| %i(id name email password updated_at created_at role_id).include? key }
+    end
+
+    def self.to_objects(users)
+      users.map do |user|
+        new(
+          id: user['objectId'],
+          name: user['nickname'],
+          email: user['email'],
+          updated_at: user['updatedAt'],
+          created_at: user['createdAt']
+        )
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: kakaxi_parse
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+platform: ruby
+authors:
+- Naggi Goishi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-24 00:00:00.000000000 Z
+dependencies: []
+description: Make it easy to controll Parse in ruby
+email: naggi@kakaxi.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- kakaxi_parse.gemspec
+- lib/kakaxi_parse.rb
+- lib/kakaxi_parse/api.rb
+- lib/kakaxi_parse/base_model.rb
+- lib/kakaxi_parse/climate.rb
+- lib/kakaxi_parse/datatypes/add_relation.rb
+- lib/kakaxi_parse/datatypes/base_datatype.rb
+- lib/kakaxi_parse/datatypes/datatype.rb
+- lib/kakaxi_parse/datatypes/datetime.rb
+- lib/kakaxi_parse/datatypes/geopoint.rb
+- lib/kakaxi_parse/datatypes/pointer.rb
+- lib/kakaxi_parse/datatypes/remove_relation.rb
+- lib/kakaxi_parse/datatypes/timelapse.rb
+- lib/kakaxi_parse/farm.rb
+- lib/kakaxi_parse/farm_manager_user.rb
+- lib/kakaxi_parse/interval_photo.rb
+- lib/kakaxi_parse/kakaxi_device.rb
+- lib/kakaxi_parse/model.rb
+- lib/kakaxi_parse/role.rb
+- lib/kakaxi_parse/timelapse.rb
+- lib/kakaxi_parse/user.rb
+homepage: https://github.com/kakaxi-inc/kakaxi-parse-ruby.git
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.4
+signing_key: 
+specification_version: 4
+summary: Kakaxi Parse SDK
+test_files: []