git-fit 0.6.1 → 0.7.1

data/lib/git_fit/sync/xingzhe.rb

@@ -0,0 +1,262 @@
+require_relative "base"
+require "fileutils"
+require "openssl"
+require "tzinfo"
+
+module GitFit
+  module Sync
+    class XingZhe < Base
+      BASE_HOST = "www.imxingzhe.com"
+      LOGIN_PATH = "/api/v1/user/login/"
+      WORKOUTS_PATH = "/api/v1/pgworkout/"
+      STREAM_PATH = "/api/v1/pgworkout/"
+      DETAIL_PATH = "/api/v1/pgworkout/"
+      RSA_PUBKEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDmuQkBbijudDAJgfffDeeIButqWHZvUwcRuvWdg89393FSdz3IJUHc0rgI/S3WuU8N0VePJLmVAZtCOK4qe4FY/eKmWpJmn7JfXB4HTMWjPVoyRZmSYjW4L8GrWmh51Qj7DwpTADadF3aq04o+s1b8LXJa8r6+TIqqL5WUHtRqmQIDAQAB"
+
+      SPORT_MAP = {
+        3 => "ride", 1 => "run", 2 => "hike",
+        5 => "swim", 6 => "walk", 11 => "ski", 13 => "workout"
+      }.freeze
+
+      RAW_EXT = "json"
+
+      register_adapter
+      register_config :email, :password
+
+      def initialize(...)
+        super
+        @email = @config["email"]
+        @password = @config["password"]
+      end
+
+      def before_call
+        return false if @email.nil? || @password.nil?
+        super
+      end
+
+      def authenticate
+        login
+      end
+
+      def pending_ids
+        existing = existing_run_ids
+        ids = []
+        offset = 0
+        limit = 50
+        loop do
+          acts = fetch_page(offset, limit)
+          break if acts.nil? || acts.empty?
+          acts.each do |act|
+            aid = act["id"].to_s
+            next if existing.include?(aid) && raw_file_exists?(aid)
+            type = map_sport(act["sport"])
+            next if skip_type?(type)
+            ids << { id: aid, type: type, summary: act }
+          end
+          offset += limit
+        end
+        ids
+      end
+
+      def process_one(pending)
+        process_activity(pending[:summary], pending[:type])
+      end
+
+      private
+
+      def http_request(method, path, body: nil, params: nil, headers: {})
+        uri = URI("https://#{BASE_HOST}#{path}")
+        uri.query = URI.encode_www_form(params) if params
+
+        req = case method
+              when :get then Net::HTTP::Get.new(uri)
+              when :post then Net::HTTP::Post.new(uri)
+              end
+
+        headers.each { |k, v| req[k] = v }
+        req.body = body if body
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.open_timeout = 30
+        http.read_timeout = 60
+        http.start { |h| h.request(req) }
+      end
+
+      def login
+        encrypted = rsa_encrypt(@password)
+        resp = http_request(:post, LOGIN_PATH,
+          body: JSON.generate({ account: @email, password: encrypted }),
+          headers: { "Content-Type" => "application/json" }
+        )
+        return false unless resp.code.to_i == 200
+
+        data = JSON.parse(resp.body)
+        return false unless data["code"] == 0
+
+        cookie = extract_cookie(resp)
+        return false unless cookie
+
+        @headers = { "Cookie" => cookie, "Accept" => "application/json" }
+        true
+      end
+
+      def rsa_encrypt(password)
+        pem = "-----BEGIN PUBLIC KEY-----\n#{RSA_PUBKEY}\n-----END PUBLIC KEY-----"
+        key = OpenSSL::PKey::RSA.new(pem)
+        Base64.strict_encode64(key.public_encrypt(password, OpenSSL::PKey::RSA::PKCS1_PADDING))
+      end
+
+      def extract_cookie(resp)
+        set_cookie = resp["set-cookie"]
+        return nil unless set_cookie
+        m = set_cookie.match(/sessionid=([^;]+)/)
+        m ? "sessionid=#{m[1]}" : nil
+      end
+
+      def sync_activities
+        pending_ids.filter_map { |p| process_one(p) }.size
+      end
+
+      def fetch_page(offset, limit)
+        resp = http_request(:get, WORKOUTS_PATH,
+          params: { offset: offset, limit: limit },
+          headers: @headers
+        )
+        return nil unless resp.code.to_i == 200
+
+        JSON.parse(resp.body).dig("data", "data")
+      end
+
+      def tz_resolver
+        @tz_resolver ||= GitFit::Timezone::Resolver.new({})
+      end
+
+      def resolve_local_time(start_utc, pts)
+        return start_utc.iso8601 unless pts&.any?
+
+        lat, lng = pts.first
+        return start_utc.iso8601 unless lat && lng
+
+        tz_string = tz_resolver.resolve(lat, lng)
+        tz = TZInfo::Timezone.get(tz_string)
+        tz.utc_to_local(start_utc).iso8601
+      rescue => e
+        warn "XingZhe: timezone resolution failed: #{e.message}"
+        start_utc.iso8601
+      end
+
+      def process_activity(act, type)
+        aid = act["id"].to_s
+        start_t = Time.at(act["start_time"] / 1000.0).utc rescue nil
+        return false unless start_t
+
+        attrs = {
+          run_id: "xingzhe_#{aid}",
+          name: act["title"] || "XingZhe Activity",
+          distance: act["distance"].to_f,
+          moving_time: (t = act["duration"].to_i) > 0 ? t : nil,
+          elapsed_time: t > 0 ? t : nil,
+          sport_category: type,
+          sport_type: act["sport"].to_s,
+          start_date: start_t.iso8601,
+          start_date_local: start_t.iso8601,
+          average_speed: (act["avg_speed"].to_f / 3.6).round(2).nonzero?,
+          elevation_gain: act["elevation_gain"].to_f.nonzero?,
+          source: "xingzhe"
+        }
+
+        pts = nil
+        stream = fetch_stream(aid)
+        if stream
+          write_source_archive({
+            source: "xingzhe",
+            fetchedAt: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            stream: stream
+          }, aid)
+          if (locs = stream["location"]) && locs.size >= 2
+            pts = locs.map { |lng, lat| [lat, lng] }
+            write_std(pts, stream, aid)
+            attrs[:summary_polyline] = stream_to_polyline(aid)
+          end
+        end
+
+        if attrs[:summary_polyline].nil? && (detail = fetch_activity_detail(aid)) && (segments = detail["segments_km"])
+          pts = segments.map { |s| [s["latitude"], s["longitude"]] }
+          attrs[:summary_polyline] = Geo::Polyline.encode(pts) if pts.size >= 2
+        end
+
+        attrs[:start_date_local] = resolve_local_time(start_t, pts)
+
+        upsert_activity(attrs)
+        attrs
+      end
+
+      def raw_path(platform_id)
+        File.join(raw_dir, "#{platform_id}.#{RAW_EXT}")
+      end
+
+      def fetch_stream(id)
+        resp = http_request(:get, "#{STREAM_PATH}#{id}/stream/", headers: @headers || {})
+        return nil unless resp.code.to_i == 200
+
+        JSON.parse(resp.body).dig("data")
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write_std(pts, stream, id)
+        dir = std_dir
+        FileUtils.mkdir_p(dir)
+        ts_arr = stream["timestamp"] || []
+        alt_arr = stream["altitude"] || []
+        spd_arr = stream["speed"] || []
+        dst_arr = stream["distance"] || []
+
+        extended = pts.each_with_index.map do |(lat, lng), i|
+          ts_val = ts_arr[i]
+          {
+            latitude: lat, longitude: lng,
+            altitude: alt_arr[i],
+            timestamp: ts_val ? Time.at(ts_val).utc.strftime("%Y-%m-%dT%H:%M:%SZ") : nil,
+            speed: spd_arr[i],
+            distance: dst_arr[i]
+          }
+        end
+
+        tmp = File.join(dir, ".#{id}.json.tmp")
+        final = File.join(dir, "#{id}.json")
+        File.write(tmp, JSON.generate(extended))
+        File.rename(tmp, final)
+      end
+
+      def stream_to_polyline(id)
+        raw = JSON.parse(File.read(raw_path(id)))
+        locs = raw.dig("stream", "location") || []
+        return nil if locs.size < 2
+
+        pts = locs.map { |lng, lat| [lat, lng] }
+        Geo::Polyline.encode(pts)
+      rescue Errno::ENOENT, JSON::ParserError
+        nil
+      end
+
+      def fetch_activity_detail(id)
+        resp = http_request(:get, "#{DETAIL_PATH}#{id}/")
+        return nil unless resp.code.to_i == 200
+
+        data = JSON.parse(resp.body)
+        data.dig("data", "workout")
+      end
+
+      def map_sport(sport)
+        SPORT_MAP[sport] || "other"
+      end
+
+      def existing_run_ids
+        @db[:activities].where(source: "xingzhe").select_map(:run_id)
+          .map { |id| id.sub("xingzhe_", "") }
+      end
+    end
+  end
+end

data/lib/git_fit/sync/xoss.rb

@@ -0,0 +1,369 @@
+require_relative "base"
+require "fileutils"
+require "tzinfo"
+
+module GitFit
+  module Sync
+    class SyncError < RuntimeError; end unless const_defined?(:SyncError)
+
+    class XOSS < Base
+      FIT_FILE_PATH = "/api/v3/activity/%<id>s/fit_file/"
+      BASE_URL = "https://backend.xoss.co"
+      LOGIN_PATH = "/api/v1/jwt-token/"
+      REFRESH_PATH = "/api/v1/jwt-token/refresh/"
+      ACTIVITIES_PATH = "/api/v3/activity/"
+      ACCESS_TOKEN_TTL = 86400
+
+      SPORT_MAP = {
+        1 => "run",
+        2 => "ride",
+        3 => "other",
+        4 => "workout",
+        5 => "swim",
+        11 => "walk"
+      }.freeze
+
+      register_adapter
+      register_config :phone, :password
+
+      def initialize(...)
+        super
+        @email = @config["email"]
+        @password = @config["password"]
+        @token_path = @config["token_path"] || File.join("data", "cache", "xoss_tokens.json")
+      end
+
+      def before_call
+        return false if @email.nil? || @password.nil?
+        super
+      end
+
+      def authenticate
+        return true if load_tokens && access_token_valid?
+        return true if refresh_access_token
+        return true if login
+        false
+      end
+
+      def pending_ids
+        existing = existing_run_ids
+        ids = []
+        offset = 1
+        limit = 50
+        loop do
+          acts = fetch_page(offset, limit)
+          break if acts.nil? || acts.empty?
+          acts.each do |act|
+            act_id = act["id"].to_s
+            next if existing.include?(act_id) && raw_file_exists?(act_id)
+            type = map_sport(act["sport"])
+            next if skip_type?(type)
+            ids << { id: act_id, type: type, summary: act }
+          end
+          offset += limit
+        end
+        ids
+      end
+
+      def process_one(pending)
+        process_activity(pending[:summary])
+      end
+
+      private
+
+      def http_request(method, path, body: nil, params: nil, headers: {})
+        uri = URI("#{BASE_URL}#{path}")
+        uri.query = URI.encode_www_form(params) if params
+
+        req = case method
+              when :get then Net::HTTP::Get.new(uri)
+              when :post then Net::HTTP::Post.new(uri)
+              end
+
+        headers.each { |k, v| req[k] = v }
+        req.body = body if body
+
+        proxy = proxy_uri
+        http = if proxy
+                 Net::HTTP.new(uri.host, uri.port, proxy.host, proxy.port, proxy.user, proxy.password)
+               else
+                 Net::HTTP.new(uri.host, uri.port)
+               end
+        http.use_ssl = true
+        http.open_timeout = 30
+        http.read_timeout = 60
+        http.start { |h| h.request(req) }
+      end
+
+      def proxy_uri
+        uri = URI(ENV["http_proxy"] || ENV["HTTP_PROXY"] || ENV["https_proxy"] || ENV["HTTPS_PROXY"] || "")
+        uri.host ? uri : nil
+      end
+
+      def login
+        retries ||= 0
+        resp = http_request(:post, LOGIN_PATH,
+          body: JSON.generate({ email: @email, password: @password }),
+          headers: { "Content-Type" => "application/json", "Origin" => "xoss" }
+        )
+        return false unless resp.code.to_i == 200
+
+        data = JSON.parse(resp.body)
+        return false unless data["code"] == 0
+
+        @access_token = data.dig("data", "access")
+        @refresh_token = data.dig("data", "refresh")
+        unless @access_token
+          remove_stale_tokens
+          return false
+        end
+
+        @auth_headers = { "Authorization" => "Bearer #{@access_token}", "Origin" => "xoss" }
+        save_tokens
+        true
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        if (retries += 1) <= 2
+          sleep 2
+          retry
+        end
+        raise SyncError, "XOSS login timeout: #{e.message}"
+      end
+
+      def token_path
+        @token_path
+      end
+
+      def load_tokens
+        return false unless File.exist?(token_path)
+
+        data = JSON.parse(File.read(token_path))
+        @access_token = data["access"]
+        @refresh_token = data["refresh"]
+        @expires_at = data["expires_at"]
+        @auth_headers = { "Authorization" => "Bearer #{@access_token}", "Origin" => "xoss" } if @access_token
+        true
+      rescue => e
+        warn "XOSS: failed to load cached tokens: #{e.message}"
+        false
+      end
+
+      def save_tokens
+        return unless @access_token
+
+        FileUtils.mkdir_p(File.dirname(token_path))
+        File.write(token_path, JSON.generate({
+          access: @access_token,
+          refresh: @refresh_token,
+          expires_at: @expires_at || Time.now.to_i + ACCESS_TOKEN_TTL
+        }))
+      rescue => e
+        warn "XOSS: failed to save tokens: #{e.message}"
+      end
+
+      def remove_stale_tokens
+        File.delete(token_path) if File.exist?(token_path)
+      rescue => e
+        warn "XOSS: failed to remove stale tokens: #{e.message}"
+      end
+
+      def access_token_valid?
+        return false unless @access_token
+        return false unless @expires_at
+        Time.now.to_i < @expires_at - 60
+      end
+
+      def refresh_access_token
+        return false unless @refresh_token
+
+        retries ||= 0
+        resp = http_request(:post, REFRESH_PATH,
+          body: JSON.generate({ refresh: @refresh_token }),
+          headers: { "Content-Type" => "application/json", "Origin" => "xoss" }
+        )
+        unless resp.code.to_i == 200
+          remove_stale_tokens
+          return false
+        end
+
+        data = JSON.parse(resp.body)
+        unless data["code"] == 0
+          remove_stale_tokens
+          return false
+        end
+
+        @access_token = data.dig("data", "access")
+        @refresh_token = data.dig("data", "refresh")
+        return false unless @access_token
+
+        @expires_at = Time.now.to_i + ACCESS_TOKEN_TTL
+        @auth_headers = { "Authorization" => "Bearer #{@access_token}", "Origin" => "xoss" }
+        save_tokens
+        true
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        if (retries += 1) <= 2
+          sleep 2
+          retry
+        end
+        raise SyncError, "XOSS token refresh timeout: #{e.message}"
+      end
+
+      def raw_path(platform_id)
+        File.join(raw_dir, "#{platform_id}.fit")
+      end
+
+      def sync_activities
+        pending_ids.filter_map { |p| process_one(p) }.size
+      end
+
+      def fetch_page(offset, limit)
+        retries ||= 0
+        resp = http_request(:get, ACTIVITIES_PATH,
+          params: { offset: offset, limit: limit },
+          headers: @auth_headers
+        )
+        return nil unless resp.code.to_i == 200
+
+        JSON.parse(resp.body).dig("data", "results")
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        if (retries += 1) <= 2
+          sleep 2
+          retry
+        end
+        raise SyncError, "XOSS fetch timeout: #{e.message}"
+      rescue JSON::ParserError
+        if (retries ||= 0; (retries += 1) <= 2)
+          sleep 2
+          retry
+        end
+        nil
+      end
+
+      def tz_resolver
+        @tz_resolver ||= GitFit::Timezone::Resolver.new({})
+      end
+
+      def resolve_local_time(start_utc, wgs_points)
+        return start_utc.iso8601 unless wgs_points&.any?
+
+        lat = wgs_points.first["positionLat"]
+        lng = wgs_points.first["positionLong"]
+        return start_utc.iso8601 unless lat && lng
+
+        tz_string = tz_resolver.resolve(lat, lng)
+        tz = TZInfo::Timezone.get(tz_string)
+        tz.utc_to_local(start_utc).iso8601
+      rescue => e
+        warn "XOSS: timezone resolution failed: #{e.message}"
+        start_utc.iso8601
+      end
+
+      def process_activity(act)
+        act_id = act["id"].to_s
+        type = map_sport(act["sport"])
+
+        start_t = Time.at(act["start_timestamp"]).utc rescue nil
+        return false unless start_t
+
+        distance = act["distance"].to_f
+        moving_time = act["duration"].to_i
+        avg_speed = distance > 0 && moving_time > 0 ? (distance / moving_time).round(2) : nil
+
+        attrs = {
+          run_id: "xoss_#{act_id}",
+          name: act["title"] || "XOSS Activity",
+          distance: distance,
+          moving_time: moving_time > 0 ? moving_time : nil,
+          elapsed_time: moving_time > 0 ? moving_time : nil,
+          sport_category: type,
+          sport_type: act["sub_sport"].to_s,
+          start_date: start_t.iso8601,
+          start_date_local: start_t.iso8601,
+          location_country: nil,
+          average_speed: avg_speed,
+          elevation_gain: act["elevation_gain"].to_f.nonzero?,
+          calories: act["total_calories"]&.to_i&.nonzero?,
+          source: "xoss"
+        }
+
+        wgs_points = []
+        if act["fit_file_hash"].to_s != ""
+          fit_data = download_fit(act_id)
+          if fit_data
+            write_source_archive(fit_data, act_id, "fit")
+            begin
+              wgs_points = FIT::Decoder.decode(raw_path(act_id))
+            rescue => e
+              warn "XOSS: FIT decode failed for #{act_id}: #{e.message}"
+              wgs_points = []
+            end
+            if wgs_points.any?
+              write_std(wgs_points, act_id)
+              pts = wgs_points.map { |pt| [pt["positionLat"], pt["positionLong"]] }
+              attrs[:summary_polyline] = Geo::Polyline.encode(pts)
+              attrs.merge!(compute_sensor_summary(wgs_points))
+            end
+          end
+        end
+
+        attrs[:start_date_local] = resolve_local_time(start_t, wgs_points)
+
+        upsert_activity(attrs)
+        attrs
+      end
+
+      def download_fit(act_id)
+        resp = http_request(:get, format(FIT_FILE_PATH, id: act_id), headers: @auth_headers)
+        return nil unless resp.code.to_i == 302
+
+        fit_uri = URI(resp["location"])
+        fit_http = Net::HTTP.new(fit_uri.host, fit_uri.port)
+        fit_http.use_ssl = fit_uri.scheme == "https"
+        fit_http.open_timeout = 60
+        fit_http.read_timeout = 180
+        fit_resp = fit_http.start { |h| h.request(Net::HTTP::Get.new(fit_uri)) }
+        return nil unless fit_resp.code.to_i == 200
+
+        fit_resp.body
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        warn "XOSS: FIT download timeout for #{act_id}: #{e.message}"
+        nil
+      end
+
+      def write_std(points, act_id)
+        dir = std_dir
+        FileUtils.mkdir_p(dir)
+        tmp = File.join(dir, ".#{act_id}.json.tmp")
+        final = File.join(dir, "#{act_id}.json")
+        File.write(tmp, JSON.generate(points))
+        File.rename(tmp, final)
+      end
+
+      def compute_sensor_summary(records)
+        return {} if records.empty?
+
+        cad = records.map { |r| r["cadence"] }.compact
+        pow = records.map { |r| r["power"] }.compact
+        tmp = records.map { |r| r["temperature"] }.compact
+        hr = records.map { |r| r["heart_rate"] }.compact
+
+        {
+          average_cadence: cad.any? ? (cad.sum.to_f / cad.size).round(1) : nil,
+          max_cadence: cad.max,
+          average_power: pow.any? ? (pow.sum.to_f / pow.size).round(1) : nil,
+          max_power: pow.max,
+          average_temperature: tmp.any? ? (tmp.sum.to_f / tmp.size).round(1) : nil,
+          average_heartrate: hr.any? ? (hr.sum.to_f / hr.size).round(1) : nil
+        }
+      end
+
+      def map_sport(sport)
+        SPORT_MAP[sport] || "other"
+      end
+
+      def existing_run_ids
+        @db[:activities].where(source: "xoss").select_map(:run_id)
+          .map { |id| id.sub("xoss_", "") }
+      end
+    end
+  end
+end

data/lib/git_fit/version.rb

@@ -1,3 +1,3 @@
 module GitFit
-  VERSION = "0.6.1"
+  VERSION = "0.7.1"
 end