sim-meter-au 0.1.0

data/lib/sim_meter_au/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SimMeterAU
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class ProviderNotFoundError < ConfigurationError; end
+  class AuthenticationError < Error; end
+  class ConnectionError < Error; end
+  class UnexpectedResponseError < Error; end
+  class ServiceNotFoundError < Error; end
+  class AmbiguousServiceError < Error; end
+end

data/lib/sim_meter_au/models.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module SimMeterAU
+  Plan = Data.define(
+    :name,
+    :type,
+    :expires_on,
+    :days_remaining,
+    :auto_recharge
+  ) do
+    include Serializable
+  end
+
+  DataBalance = Data.define(
+    :plan_remaining_bytes,
+    :rollover_bytes,
+    :total_remaining_bytes
+  ) do
+    include Serializable
+  end
+
+  Payg = Data.define(
+    :balance_cents,
+    :expires_on,
+    :days_until_expiry
+  ) do
+    include Serializable
+  end
+
+  ServiceDetails = Data.define(
+    :service,
+    :status,
+    :plan,
+    :data,
+    :payg,
+    :roaming_enabled,
+    :retrieved_at
+  ) do
+    include Serializable
+  end
+
+  UsageSummary = Data.define(
+    :type,
+    :count,
+    :rounded_usage,
+    :charge_dollars
+  ) do
+    include Serializable
+  end
+
+  UsageRecord = Data.define(
+    :type,
+    :number,
+    :destination,
+    :usage,
+    :charge_dollars,
+    :date_label
+  ) do
+    include Serializable
+  end
+
+  UsageReport = Data.define(
+    :service,
+    :from,
+    :to,
+    :summaries,
+    :records
+  ) do
+    include Serializable
+  end
+
+  Order = Data.define(
+    :id,
+    :number,
+    :type,
+    :plan_name,
+    :date_label,
+    :total_cents,
+    :transaction_reference
+  ) do
+    include Serializable
+  end
+end

data/lib/sim_meter_au/provider.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SimMeterAU
+  class Provider
+    OPERATIONS = %i[
+      authenticate!
+      authenticated?
+      services
+      service
+      service_details
+      usage
+      orders
+    ].freeze
+
+    class << self
+      def provider_key(value = nil)
+        @provider_key = value.to_sym if value
+        @provider_key
+      end
+
+      def display_name(value = nil)
+        @display_name = value.to_s if value
+        @display_name || provider_key.to_s
+      end
+
+      def credential_names(*names)
+        @credential_names = names.map(&:to_sym) unless names.empty?
+        @credential_names || []
+      end
+
+      def credentials_from(environment)
+        prefix = provider_key.to_s.upcase
+        credential_names.to_h do |name|
+          [name, environment.fetch("#{prefix}_#{name.to_s.upcase}", "")]
+        end
+      end
+    end
+
+    def provider
+      self.class.provider_key
+    end
+
+    def authenticate!
+      unsupported_operation(__method__)
+    end
+
+    def login!
+      authenticate!
+    end
+
+    def authenticated?
+      unsupported_operation(__method__)
+    end
+
+    def services
+      unsupported_operation(__method__)
+    end
+
+    def service(_identifier)
+      unsupported_operation(__method__)
+    end
+
+    def service_details(_identifier)
+      unsupported_operation(__method__)
+    end
+
+    def usage(_identifier, from:, to:)
+      unsupported_operation(__method__)
+    end
+
+    def orders(_identifier)
+      unsupported_operation(__method__)
+    end
+
+    private
+
+    def unsupported_operation(operation)
+      raise NotImplementedError,
+        "#{self.class} must implement ##{operation}"
+    end
+  end
+end

data/lib/sim_meter_au/providers/aldi_mobile/parsers/orders.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SimMeterAU
+  module Providers
+    class AldiMobile
+      module Parsers
+        class Orders
+      HEADERS = ["Order #", "Number", "Type", "Plan", "Date", "Actions"].freeze
+
+      def parse(page)
+        table = page.css("table").find do |candidate|
+          candidate.css("th").map { |heading| text(heading) } == HEADERS
+        end
+        return [] unless table
+
+        orders = []
+        current = nil
+
+        table.css("tbody tr").each do |row|
+          cells = row.css("td").map { |cell| text(cell) }
+          if cells.length >= 6
+            orders << build_order(current) if current
+            current = {
+              id: cells[0],
+              number: normalize_number(cells[1]),
+              type: cells[2],
+              plan_name: cells[3],
+              date_label: cells[4]
+            }
+          elsif current && cells.length == 1
+            current[:total_cents] = parse_total(cells[0])
+            current[:transaction_reference] = cells[0][/Transaction Ref:\s*([^\s]+)/i, 1]
+          end
+        end
+
+        orders << build_order(current) if current
+        orders
+      end
+
+      private
+
+      def build_order(attributes)
+        Order.new(
+          id: attributes[:id],
+          number: attributes[:number],
+          type: attributes[:type],
+          plan_name: attributes[:plan_name],
+          date_label: attributes[:date_label],
+          total_cents: attributes[:total_cents],
+          transaction_reference: attributes[:transaction_reference]
+        )
+      end
+
+      def parse_total(value)
+        amount = value[/Total Cost:\s*\$([\d,]+(?:\.\d+)?)/i, 1]
+        return unless amount
+
+        (amount.delete(",").to_f * 100).round
+      end
+
+      def normalize_number(number)
+        digits = number.gsub(/\D/, "")
+        digits.start_with?("61") ? "0#{digits.delete_prefix("61")}" : digits
+      end
+
+      def text(node)
+        node&.text.to_s.gsub(/\s+/, " ").strip
+      end
+        end
+      end
+    end
+  end
+end

data/lib/sim_meter_au/providers/aldi_mobile/parsers/service_details.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "date"
+
+module SimMeterAU
+  module Providers
+    class AldiMobile
+      module Parsers
+        class ServiceDetails
+      QUANTITY_UNITS = {
+        "B" => 1,
+        "KB" => 1024,
+        "MB" => 1024**2,
+        "GB" => 1024**3,
+        "TB" => 1024**4
+      }.freeze
+
+      def parse(page:, service:, roaming_enabled:, retrieved_at: Time.now)
+        plan_panel = find_panel(page, excluding: /Pay As You Go/i)
+        payg_panel = find_panel(page, including: /Pay As You Go/i)
+        plan_rows = resource_rows(plan_panel)
+        payg_rows = resource_rows(payg_panel)
+        plan = parse_plan(plan_panel, plan_rows)
+
+        SimMeterAU::ServiceDetails.new(
+          service:,
+          status: plan ? "active_plan" : "no_active_plan",
+          plan:,
+          data: parse_data(plan_rows),
+          payg: parse_payg(payg_rows),
+          roaming_enabled:,
+          retrieved_at:
+        )
+      end
+
+      private
+
+      def find_panel(page, including: nil, excluding: nil)
+        page.css("#service-body .panel").find do |panel|
+          heading = text(panel.at_css("h3.panel-title"))
+          next false if heading.empty?
+          next false if including && !heading.match?(including)
+          next false if excluding && heading.match?(excluding)
+
+          true
+        end
+      end
+
+      def resource_rows(panel)
+        return {} unless panel
+
+        panel.css(".row.clearfix").to_h do |row|
+          label = text(row.at_css("label"))
+          value = text(row.css(".col-xs-6").last)
+          [label, value]
+        end.reject { |label, _value| label.empty? }
+      end
+
+      def parse_plan(panel, rows)
+        return unless panel
+
+        name = text(panel.at_css("h3.panel-title"))
+        days, expiry = parse_expiry(rows["Days remaining"])
+        auto_recharge = panel.at_css("#autorechargeswitch")&.key?("checked")
+
+        Plan.new(
+          name:,
+          type: plan_type(name),
+          expires_on: expiry,
+          days_remaining: days,
+          auto_recharge:
+        )
+      end
+
+      def parse_data(rows)
+        values = {
+          plan_remaining_bytes: parse_bytes(rows["Plan data remaining"]),
+          rollover_bytes: parse_bytes(rows["Data rollover"]),
+          total_remaining_bytes: parse_bytes(rows["Total data for you to use"])
+        }
+        return if values.values.all?(&:nil?)
+
+        DataBalance.new(**values)
+      end
+
+      def parse_payg(rows)
+        balance_label = rows.keys.find { |label| label.match?(/Pay As You Go.*balance/i) }
+        days, expiry = parse_expiry(rows["Days until service expiry"])
+        balance = parse_money(rows[balance_label]) if balance_label
+        return if balance.nil? && expiry.nil? && days.nil?
+
+        Payg.new(
+          balance_cents: balance,
+          expires_on: expiry,
+          days_until_expiry: days
+        )
+      end
+
+      def parse_expiry(value)
+        return [nil, nil] if value.to_s.empty?
+
+        days = value[/\A\d+/]&.to_i
+        date = value[/Expiry\s+(\d{2}\/\d{2}\/\d{4})/, 1]
+        expiry = Date.strptime(date, "%d/%m/%Y") if date
+        [days, expiry]
+      end
+
+      def parse_bytes(value)
+        match = /([\d,.]+)\s*(B|KB|MB|GB|TB)\b/i.match(value.to_s)
+        return unless match
+
+        number = match[1].delete(",").to_f
+        (number * QUANTITY_UNITS.fetch(match[2].upcase)).round
+      end
+
+      def parse_money(value)
+        amount = value.to_s[/\$\s*([\d,]+(?:\.\d+)?)/, 1]
+        return unless amount
+
+        (amount.delete(",").to_f * 100).round
+      end
+
+      def plan_type(name)
+        case name
+        when /Family Plan/i then "family"
+        when /Mobile Plan/i then "mobile"
+        when /Data Plan/i then "data"
+        when /Super Pack/i then "super_pack"
+        else "unknown"
+        end
+      end
+
+      def text(node)
+        node&.text.to_s.gsub(/\s+/, " ").strip
+      end
+        end
+      end
+    end
+  end
+end

data/lib/sim_meter_au/providers/aldi_mobile/parsers/usage.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module SimMeterAU
+  module Providers
+    class AldiMobile
+      module Parsers
+        class Usage
+      def parse(page:, service:, from:, to:)
+        UsageReport.new(
+          service:,
+          from:,
+          to:,
+          summaries: parse_summaries(page),
+          records: parse_records(page)
+        )
+      end
+
+      private
+
+      def parse_summaries(page)
+        table = find_table(page, ["Usage Type", "Count", "Rounded Duration/Data", "Charge"])
+        return [] unless table
+
+        table.css("tbody tr").filter_map do |row|
+          cells = row.css("td").map { |cell| text(cell) }
+          next unless cells.length >= 4
+
+          UsageSummary.new(
+            type: cells[0],
+            count: cells[1].delete(",").to_i,
+            rounded_usage: cells[2],
+            charge_dollars: money_string(cells[3])
+          )
+        end
+      end
+
+      def parse_records(page)
+        table = find_table(page, ["Number", "Destination", "Duration/Data", "Charge", "Date"])
+        return [] unless table
+
+        current_type = nil
+        table.css("tbody tr").filter_map do |row|
+          cells = row.css("td").map { |cell| text(cell) }
+          if cells.length == 1
+            current_type = cells.first
+            next
+          end
+          next unless cells.length >= 5
+
+          UsageRecord.new(
+            type: current_type,
+            number: normalize_number(cells[0]),
+            destination: cells[1],
+            usage: cells[2],
+            charge_dollars: money_string(cells[3]),
+            date_label: cells[4]
+          )
+        end
+      end
+
+      def find_table(page, expected_headers)
+        page.css("table").find do |table|
+          table.css("th").map { |heading| text(heading) } == expected_headers
+        end
+      end
+
+      def normalize_number(number)
+        digits = number.gsub(/\D/, "")
+        digits.start_with?("61") ? "0#{digits.delete_prefix("61")}" : digits
+      end
+
+      def money_string(value)
+        value.to_s.delete_prefix("$").delete(",")
+      end
+
+      def text(node)
+        node&.text.to_s.gsub(/\s+/, " ").strip
+      end
+        end
+      end
+    end
+  end
+end

data/lib/sim_meter_au/providers/aldi_mobile.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "mechanize"
+require "openssl"
+require "json"
+require "date"
+
+module SimMeterAU
+  module Providers
+    class AldiMobile < Provider
+      provider_key :aldi_mobile
+      display_name "ALDImobile"
+      credential_names :login, :password
+    DEFAULT_BASE_URL = "https://my.aldimobile.com.au"
+    LOGIN_PATH = "/login/"
+    LOGIN_FORM_ACTION = %r{/login_check/?\z}
+    SERVICE_SWITCH_PATH = %r{\A/admin/s/(?<id>\d+)/switch/?\z}
+    MOBILE_NUMBER = /(?:\+?61[\s-]?|0)4(?:[\s-]?\d){8}/
+
+    attr_reader :page
+
+    def initialize(login:, password:, base_url: DEFAULT_BASE_URL, agent: nil)
+      raise ConfigurationError, "login cannot be empty" if login.to_s.strip.empty?
+      raise ConfigurationError, "password cannot be empty" if password.to_s.empty?
+
+      @login = login.to_s
+      @password = password.to_s
+      @base_url = base_url.delete_suffix("/")
+      @agent = agent || build_agent
+      @authenticated = false
+    end
+
+    def authenticate!
+      login_page = @agent.get("#{@base_url}#{LOGIN_PATH}")
+      form = find_login_form(login_page)
+
+      unless form
+        raise UnexpectedResponseError, "ALDImobile login form was not found"
+      end
+
+      form["login_user[login]"] = @login
+      form["login_user[password]"] = @password
+
+      submit_button = form.button_with(name: "login_user[save]")
+      @page = submit_button ? @agent.submit(form, submit_button) : form.submit
+
+      unless authenticated_page?(@page)
+        @authenticated = false
+        raise AuthenticationError, authentication_error_message(@page)
+      end
+
+      @authenticated = true
+      self
+    rescue Mechanize::ResponseCodeError => error
+      raise ConnectionError, "ALDImobile returned HTTP #{error.response_code}"
+    rescue SocketError, Timeout::Error, EOFError, Errno::ECONNREFUSED,
+      Errno::ECONNRESET, OpenSSL::SSL::SSLError => error
+      raise ConnectionError, "Could not connect to ALDImobile: #{error.class}"
+    end
+
+    def authenticated?
+      @authenticated
+    end
+
+    def services
+      ensure_authenticated!
+
+      @page.links.filter_map do |link|
+        match = SERVICE_SWITCH_PATH.match(link.href.to_s)
+        next unless match
+
+        number = link.text.to_s[MOBILE_NUMBER]
+        next unless number
+
+        Service.new(
+          id: match[:id],
+          name: service_name(link.text, number),
+          number: normalize_mobile_number(number)
+        )
+      end.uniq(&:id)
+    end
+
+    def service(identifier)
+      ensure_authenticated!
+      return identifier if identifier.is_a?(Service)
+
+      query = identifier.to_s.strip
+      matches = services.select do |candidate|
+        candidate.id == query ||
+          candidate.number == normalize_identifier_number(query) ||
+          candidate.name.casecmp?(query)
+      end
+
+      if matches.empty?
+        raise ServiceNotFoundError, "No ALDImobile service matches #{query.inspect}"
+      end
+      if matches.length > 1
+        raise AmbiguousServiceError, "More than one ALDImobile service matches #{query.inspect}"
+      end
+
+      matches.first
+    end
+
+    def service_details(identifier)
+      selected_service = service(identifier)
+      overview = request { @agent.get("#{@base_url}/admin/s/#{selected_service.id}/switch") }
+      roaming_enabled = roaming_enabled?(selected_service)
+
+      Parsers::ServiceDetails.new.parse(
+        page: overview,
+        service: selected_service,
+        roaming_enabled:
+      )
+    end
+
+    def usage(identifier, from: Date.today - 30, to: Date.today)
+      selected_service = service(identifier)
+      from = coerce_date(from)
+      to = coerce_date(to)
+      raise ConfigurationError, "usage start date must not be after end date" if from > to
+
+      page = request { @agent.get("#{@base_url}/admin/s/#{selected_service.id}/usage") }
+      form = page.forms.find { |candidate| candidate.action.to_s.end_with?("/usage") }
+      unless form
+        raise UnexpectedResponseError, "ALDImobile usage form was not found"
+      end
+
+      form["usage[start]"] = from.iso8601
+      form["usage[end]"] = to.iso8601
+      submit_button = form.button_with(name: "usage[getusage]")
+      result = request { submit_button ? @agent.submit(form, submit_button) : form.submit }
+
+      Parsers::Usage.new.parse(page: result, service: selected_service, from:, to:)
+    end
+
+    def orders(identifier)
+      selected_service = service(identifier)
+      page = request { @agent.get("#{@base_url}/admin/s/#{selected_service.id}/orders") }
+      Parsers::Orders.new.parse(page)
+    end
+
+    private
+
+    def ensure_authenticated!
+      raise AuthenticationError, "Log in before requesting services" unless authenticated?
+    end
+
+    def roaming_enabled?(selected_service)
+      response = request do
+        @agent.get("#{@base_url}/admin/roaming/status/#{selected_service.number}")
+      end
+      status = JSON.parse(response.body).fetch("roaming_status", nil)
+      return true if status.to_s == "1"
+      return false if status.to_s == "0"
+
+      nil
+    rescue JSON::ParserError
+      nil
+    end
+
+    def request
+      yield
+    rescue Mechanize::ResponseCodeError => error
+      raise ConnectionError, "ALDImobile returned HTTP #{error.response_code}"
+    rescue SocketError, Timeout::Error, EOFError, Errno::ECONNREFUSED,
+      Errno::ECONNRESET, OpenSSL::SSL::SSLError => error
+      raise ConnectionError, "Could not connect to ALDImobile: #{error.class}"
+    end
+
+    def coerce_date(value)
+      return value if value.is_a?(Date)
+
+      Date.iso8601(value.to_s)
+    rescue Date::Error
+      raise ConfigurationError, "invalid ISO date: #{value.inspect}"
+    end
+
+    def build_agent
+      Mechanize.new.tap do |agent|
+        agent.user_agent = "sim_meter_au/#{VERSION} aldi_mobile"
+        agent.open_timeout = 10
+        agent.read_timeout = 30
+      end
+    end
+
+    def find_login_form(login_page)
+      return unless login_page.respond_to?(:form_with)
+
+      login_page.form_with(id: "login-specific") ||
+        login_page.form_with(action: LOGIN_FORM_ACTION)
+    end
+
+    def authenticated_page?(response_page)
+      path = response_page.uri.path
+      on_account_page = path == "/admin" || path.start_with?("/admin/")
+      has_login_form = !find_login_form(response_page).nil?
+      has_logout_link = !response_page.link_with(href: %r{/logout/?\z}).nil?
+
+      !has_login_form && (on_account_page || has_logout_link)
+    end
+
+    def authentication_error_message(response_page)
+      error_element = response_page.at(
+        ".alert-danger, .form-error-message, .error, [role='alert']"
+      )
+      message = error_element&.text.to_s.gsub(/\s+/, " ").strip
+
+      message.empty? ? "ALDImobile login failed" : message
+    end
+
+    def service_name(link_text, number)
+      link_text.to_s.sub(number, "").sub(/\s*-\s*\z/, "").strip
+    end
+
+    def normalize_mobile_number(number)
+      digits = number.gsub(/\D/, "")
+      digits.start_with?("61") ? "0#{digits.delete_prefix("61")}" : digits
+    end
+
+    def normalize_identifier_number(identifier)
+      digits = identifier.gsub(/\D/, "")
+      return "" if digits.length < 9
+
+      digits.start_with?("61") ? "0#{digits.delete_prefix("61")}" : digits
+    end
+    end
+  end
+end