swisspost 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbd3ac04512275da8f1e0745fc3dcb2835a8668eac1b1ff2a64699d6e68c3906
+  data.tar.gz: 8c809ca4feb8765c5c8532134e18218944b171fe346847c8f9173b9cdc54c762
+SHA512:
+  metadata.gz: cac944edd2ddb6f5119899211e4404b55ea49b7b2a506f56c6d5072c743cb321b71c2f5e03bcfbbae69bfd7efab31d1c4744dd1b551a44077ccf2c873571a895
+  data.tar.gz: 7ebdc16d1b5e4612e728dd09ab5c2291054fbbd872e5e4e6742df39ada735f20a0992ed079033f6d52b667335f43974ffc5672bf009d8bc8438ca78e8a8da8d2

data/.devcontainer/devcontainer.json

@@ -0,0 +1,49 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/ruby
+{
+	"name": "Ruby",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/ruby:1-3.4-bullseye",
+
+  "mounts": [
+    "source=${localEnv:HOME}/.claude,target=/home/vscode/.claude,type=bind,consistency=cached",
+    "source=${localEnv:HOME}/.claude.json,target=/home/vscode/.claude.json,type=bind,consistency=cached"
+  ],
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	"features": {
+    "ghcr.io/devcontainers/features/node:1": {
+      "version": "lts",
+      "nvmVersion": "0.40.3"
+    },
+    "ghcr.io/anthropics/devcontainer-features/claude-code:1.0.5": {}
+  },
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "bundle install",
+
+	// Configure tool-specific properties.
+	"customizations": {
+    "vscode": {
+      "extensions": [
+        "shardulm94.trailing-spaces",
+        "Fooo.ruby-spec-runner",
+        "tomoki1207.pdf",
+        "GitHub.copilot"
+      ],
+      "settings": {
+        "rubyLsp.rubyVersionManager": {
+          "identifier": "none"
+        },
+        "rubyLsp.formatter": "auto",
+        "editor.formatOnSaveMode": "file"
+      }
+    }
+  }
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-07-23
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Lukas_Skywalker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,181 @@
+# Swisspost
+
+A Ruby gem for interacting with Swiss Post APIs, providing address validation, barcode generation, and price calculation services.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add swisspost
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install swisspost
+```
+
+## Usage
+
+### Configuration
+
+Before using any of the services, you need to configure your Swiss Post API credentials:
+
+```ruby
+require 'swisspost'
+
+# Configure your API credentials (required for all services)
+Swisspost.configure do |config|
+  config.client_id = 'your_client_id'
+  config.client_secret = 'your_client_secret'
+  config.api_key = 'your_api_key' # Required for price service
+end
+```
+
+### Address Validation Service
+
+Validate Swiss addresses using the Swiss Post address validation API:
+
+```ruby
+# Create an address object
+address = Swisspost::Model::Address.new(
+  first_name: 'John',
+  last_name: 'Doe',
+  street: 'Bahnhofstrasse',
+  house_number: '1',
+  zip: 8001,
+  city: 'Zürich'
+)
+
+# Validate the address
+service = Swisspost::AddressService.new
+result = service.validate(address: address)
+
+# Check the validation result
+puts result.quality.description
+# Possible qualities:
+# - DOMICILE_CERTIFIED: The address, including the full name of the person, is certified by SwissPost
+# - CERTIFIED: The address is certified by the Swiss Post
+# - USABLE: Parts of the address have been recognized and the address is considered as reusable
+# - FIXED: The address is USABLE, but some minor typos have been corrected
+# - UNUSABLE: The system was not able to recognize an acceptable address
+# - COMPROMISED: The address may have been modified by a man in the middle
+
+# Get the validated address
+validated_address = result.address
+```
+
+### Barcode Generation Service
+
+Generate address labels with barcodes for shipping:
+
+```ruby
+# Create sender and recipient addresses
+sender = Swisspost::Model::Address.new(
+  first_name: 'Alice',
+  last_name: 'Smith',
+  street: 'Poststrasse',
+  house_number: '10',
+  zip: 3000,
+  city: 'Bern'
+)
+
+recipient = Swisspost::Model::Address.new(
+  first_name: 'Bob',
+  last_name: 'Johnson',
+  street: 'Hauptstrasse',
+  house_number: '5',
+  zip: 4000,
+  city: 'Basel'
+)
+
+# Create a barcode item with service type and weight
+item = Swisspost::Model::BarcodeItem.new(
+  service_code: 'PRI',  # Options: ECO, PRI, APOST, BPOST
+  weight: 100  # Weight in grams
+)
+
+# Generate the barcode label
+service = Swisspost::BarcodeService.new
+result = service.generate(
+  sender: sender,
+  recipient: recipient,
+  item: item
+)
+
+# The result contains the label image and content type
+# result.image contains the base64-encoded label image
+# result.content_type contains the image format (e.g., 'image/png')
+
+# Save the label to a file
+require 'base64'
+File.open('shipping_label.png', 'wb') do |file|
+  file.write(Base64.decode64(result.image))
+end
+```
+
+### Price Calculation Service
+
+Calculate shipping prices for different countries and package formats:
+
+```ruby
+service = Swisspost::PriceService.new
+
+# Get available products for shipping
+products = service.products(
+  country: 'DE',    # ISO country code (e.g., 'DE' for Germany, 'FR' for France)
+  format: 'B5',     # Package format: B4, B5, MB, PK, SP, RL, FF
+  weight: 500       # Weight in grams
+)
+
+# The result contains available shipping products with prices
+products.each do |product|
+  puts "#{product['name']}: CHF #{product['price']}"
+end
+```
+
+### Error Handling
+
+All services raise appropriate errors when validation fails or API calls are unsuccessful:
+
+```ruby
+begin
+  # Invalid address (ZIP code out of range)
+  address = Swisspost::Model::Address.new(
+    first_name: 'John',
+    last_name: 'Doe',
+    street: 'Invalid Street',
+    house_number: '999',
+    zip: 999,  # Invalid Swiss ZIP code
+    city: 'Unknown'
+  )
+rescue Swisspost::ValidationError => e
+  puts "Validation failed: #{e.message}"
+end
+
+begin
+  service = Swisspost::AddressService.new
+  result = service.validate(address: some_address)
+rescue HTTPX::HTTPError => e
+  puts "API request failed: #{e.message}"
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/swisspost. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/swisspost/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Swisspost project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/swisspost/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/exe/swisspost

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "swisspost"
+require "swisspost/model/address"
+require "swisspost/model/barcode_item"
+require "swisspost/barcode_service"
+require "cli/ui"
+require "base64"
+
+class SwisspostCLI
+  def self.run(args)
+    command = args.first
+
+    case command
+    when "barcode"
+      generate_barcode
+    when nil, "--help", "-h"
+      show_help
+    else
+      CLI::UI.puts(CLI::UI.fmt("{{red:Unknown command: #{command}}}"))
+      show_help
+      exit(1)
+    end
+  end
+
+  def self.show_help
+    CLI::UI::Frame.open("Swiss Post CLI") do
+      CLI::UI.puts <<~HELP
+        Usage: swisspost <command>
+
+        Commands:
+          barcode    Generate a Swiss Post barcode interactively
+
+        Options:
+          --help, -h    Show this help message
+      HELP
+    end
+  end
+
+  def self.generate_barcode
+    CLI::UI::Frame.open("Generate Swiss Post Barcode") do
+      # Sender information
+      CLI::UI.puts(CLI::UI.fmt("{{blue:Enter sender information:}}"))
+      sender_first_name = CLI::UI.ask("Sender first name:")
+      sender_last_name = CLI::UI.ask("Sender last name:")
+      sender_street = CLI::UI.ask("Sender street:")
+      sender_house_number = CLI::UI.ask("Sender house number:")
+      sender_zip = CLI::UI.ask("Sender ZIP code:").to_i
+      sender_city = CLI::UI.ask("Sender city:")
+
+      # Recipient information
+      CLI::UI.puts(CLI::UI.fmt("\n{{blue:Enter recipient information:}}"))
+      recipient_first_name = CLI::UI.ask("Recipient first name:")
+      recipient_last_name = CLI::UI.ask("Recipient last name:")
+      recipient_street = CLI::UI.ask("Recipient street:")
+      recipient_house_number = CLI::UI.ask("Recipient house number:")
+      recipient_zip = CLI::UI.ask("Recipient ZIP code:").to_i
+      recipient_city = CLI::UI.ask("Recipient city:")
+
+      # Display entered data and ask for confirmation
+      CLI::UI.puts(CLI::UI.fmt("\n{{blue:Please confirm the entered information:}}"))
+
+      CLI::UI.puts(CLI::UI.fmt("\n{{bold:Sender Address:}}"))
+      CLI::UI.puts("  #{sender_first_name} #{sender_last_name}")
+      CLI::UI.puts("  #{sender_street} #{sender_house_number}")
+      CLI::UI.puts("  #{sender_zip} #{sender_city}")
+
+      CLI::UI.puts(CLI::UI.fmt("\n{{bold:Recipient Address:}}"))
+      CLI::UI.puts("  #{recipient_first_name} #{recipient_last_name}")
+      CLI::UI.puts("  #{recipient_street} #{recipient_house_number}")
+      CLI::UI.puts("  #{recipient_zip} #{recipient_city}")
+
+      confirm_addresses = CLI::UI.confirm("\nIs this information correct?")
+      if !confirm_addresses
+        CLI::UI.puts(CLI::UI.fmt("{{yellow:Operation cancelled. Please run the command again.}}"))
+        exit(0)
+      end
+
+      # Service information
+      CLI::UI.puts(CLI::UI.fmt("\n{{blue:Enter service information:}}"))
+      service_codes = ["ECO", "PRI", "APOST", "BPOST"]
+      service_code = CLI::UI.ask("Select service code:") do |handler|
+        service_codes.each do |code|
+          handler.option(code) { code }
+        end
+      end
+      weight = CLI::UI.ask("Weight in grams:").to_i
+
+      # Create barcode
+      CLI::UI.puts("\nGenerating barcode...")
+
+      begin
+        barcode_service = Swisspost::BarcodeService.new
+
+        sender_address = Swisspost::Model::Address.new(
+          first_name: sender_first_name,
+          last_name: sender_last_name,
+          street: sender_street,
+          house_number: sender_house_number,
+          zip: sender_zip,
+          city: sender_city
+        )
+
+        recipient_address = Swisspost::Model::Address.new(
+          first_name: recipient_first_name,
+          last_name: recipient_last_name,
+          street: recipient_street,
+          house_number: recipient_house_number,
+          zip: recipient_zip,
+          city: recipient_city
+        )
+
+        barcode_item = Swisspost::Model::BarcodeItem.new(
+          service_code: service_code,
+          weight: weight
+        )
+
+        result = barcode_service.generate({
+          sender: sender_address,
+          recipient: recipient_address,
+          item: barcode_item
+        })
+
+        CLI::UI.puts(CLI::UI.fmt("{{green:✓}} Barcode label generated successfully!"))
+        CLI::UI.puts("Image type: #{result.file_type}")
+
+        # Ask if user wants to save the image
+        save_image = CLI::UI.confirm("Would you like to save the label image?")
+        if save_image
+          filename = CLI::UI.ask("Enter filename (without extension):", default: "barcode_label")
+          full_filename = "#{filename}.#{result.file_type}"
+
+          File.open(full_filename, "wb") do |file|
+            file.write(Base64.decode64(result.image))
+          end
+
+          CLI::UI.puts("Label saved to: #{CLI::UI.fmt("{{green:#{full_filename}}}")}")
+        end
+      rescue HTTPX::Error => e
+        CLI::UI.puts(CLI::UI.fmt("{{red:✗ Network Error: #{e.message}}}"))
+        CLI::UI.puts("\nPlease check your internet connection and try again.")
+        exit(1)
+      rescue Swisspost::Model::ValidationError => e
+        CLI::UI.puts(CLI::UI.fmt("{{red:✗ Validation Error: #{e.message}}}"))
+        exit(1)
+      rescue => e
+        CLI::UI.puts(CLI::UI.fmt("{{red:✗ Error: #{e.message}}}"))
+        CLI::UI.puts(CLI::UI.fmt("{{red:#{e.class}: #{e.backtrace.first}}}"))
+        exit(1)
+      end
+    end
+  end
+end
+
+SwisspostCLI.run(ARGV)

data/lib/swisspost/address_service.rb

@@ -0,0 +1,85 @@
+require "dry-validation"
+require_relative "model/address"
+require_relative "base_service"
+require_relative "types"
+
+module Swisspost
+  class AddressService < BaseService
+    API_SCOPE = "DCAPI_ADDRESS_VALIDATE"
+    API_URL = "https://dcapi.api.post.ch/address/v1"
+
+    VALIDATE_VALIDATOR = Dry::Validation.Contract do
+      params do
+        required(:address).value(Types::Instance(Model::Address))
+      end
+    end
+
+    def validate(attributes)
+      path = "/addresses/validation"
+
+      result = VALIDATE_VALIDATOR.call(attributes)
+      raise ValidationError, result.errors.to_h.inspect if result.failure?
+
+      validated_data = result.to_h
+      address = validated_data[:address]
+
+      response = httpx.post(API_URL + path, json: {
+        addressee: {
+          firstName: address.first_name,
+          lastName: address.last_name,
+        }, geographicalLocation: {
+          house: {
+            street: address.street,
+            houseNumber: address.house_number,
+          },
+          zip: {
+            zip: address.zip,
+            city: address.city,
+          }
+        },
+        fullValidation: true,
+      })
+
+      response.raise_for_status
+
+      result = response.json
+
+      address = Address.new(
+        first_name: result[:addressee][:first_name],
+        last_name: result[:addressee][:last_name],
+        street: result[:geographical_location][:house][:street],
+        house_number: result[:geographical_location][:house][:house_number],
+        zip: result[:geographical_location][:zip][:zip],
+        city: result[:geographical_location][:zip][:city],
+      )
+
+      quality = Qualities.for(result[:quality])
+
+      return Result.new(
+        address: address,
+        quality: quality,
+      )
+    end
+
+    Result = Struct.new(:address, :quality, keyword_init: true)
+
+    Quality = Struct.new(:value, :description, keyword_init: true) do
+      def to_s
+        description
+      end
+    end
+
+    module Qualities
+      DOMICILE_CERTIFIED = Quality.new(value: "DOMICILE_CERTIFIED", description: "The address, including the full name of the person, is certified by SwissPost")
+      CERTIFIED = Quality.new(value: "CERTIFIED", description: "The address is certified by the Swiss Post")
+      USABLE = Quality.new(value: "USABLE", description: "Parts of the address have been recognized and the address is considered as reusable in other contexts")
+      FIXED = Quality.new(value: "FIXED", description: "The returned address is USABLE, but some minor typos have been corrected (e.g. you sent only the zip and the SwissPost service add the city name)")
+      UNUSABLE = Quality.new(value: "UNUSABLE", description: "The system was not able to recognize an acceptable address in any field provided")
+      COMPROMISED = Quality.new(value: "COMPROMISED", description: "The address may have been modified by a man in the middle")
+
+      def self.for(value)
+        Qualities.send(value.to_sym)
+      end
+    end
+  end
+end

data/lib/swisspost/auth.rb

@@ -0,0 +1,22 @@
+require "httpx"
+
+module Swisspost
+  class Auth
+    AUTH_URL = "https://api.post.ch/OAuth/token"
+
+    def get_access_token(api_scope)
+      response = HTTPX.with(headers: {
+        "Content-Type" => "application/x-www-form-urlencoded",
+      }).post(AUTH_URL, form: {
+        grant_type: "client_credentials",
+        client_id: "bdf1cf1f9133fcde0087c5ed95f9a488",
+        client_secret: "151a4c935dd6bc83d3488a69e2e5fd02",
+        scope: api_scope,
+      })
+
+      response.raise_for_status
+
+      response.json["access_token"]
+    end
+  end
+end

data/lib/swisspost/barcode_service.rb

@@ -0,0 +1,81 @@
+require "dry-validation"
+require_relative "model/address"
+require_relative "model/barcode_item"
+require_relative "model/validation_error"
+require_relative "base_service"
+require_relative "types"
+
+module Swisspost
+  class BarcodeService < BaseService
+    API_SCOPE = "DCAPI_BARCODE_READ"
+    API_URL = "https://dcapi.apis.post.ch/barcode/v1"
+    FRANKING_LICENSE = "60170283"
+
+    GENERATE_VALIDATOR = Dry::Validation.Contract do
+      params do
+        required(:sender).value(Types::Instance(Model::Address))
+        required(:recipient).value(Types::Instance(Model::Address))
+        required(:item).value(Types::Instance(Model::BarcodeItem))
+      end
+    end
+
+    GenerateResult = Struct.new(:image, :file_type, keyword_init: true)
+
+    def generate(attributes)
+      path = "/generateAddressLabel"
+
+      result = GENERATE_VALIDATOR.call(attributes)
+      raise Model::ValidationError, result.errors.to_h.inspect if result.failure?
+
+      validated_data = result.to_h
+      sender = validated_data[:sender]
+      recipient = validated_data[:recipient]
+      item = validated_data[:item]
+
+      client = httpx_oauth(API_SCOPE)
+
+      payload = {
+        language: 'DE',
+        frankingLicense: FRANKING_LICENSE,
+        ppFranking: false,
+        customer: {
+          name1: sender.full_name,
+          street: sender.full_street,
+          zip: sender.zip,
+          city: sender.city,
+        },
+        labelDefinition: {
+          labelLayout: 'A6',
+          printAddresses: 'ONLY_RECIPIENT',
+          imageFileType: 'PNG',
+          imageResolution: 300,
+          printPreview: false
+        },
+        item: {
+          recipient: {
+            name1: recipient.full_name,
+            street: recipient.street,
+            houseNo: recipient.house_number,
+            zip: recipient.zip,
+            city: recipient.city,
+          },
+          attributes: {
+            przl: [item.service_code],
+            weight: item.weight,
+          }
+        }
+      }
+
+      response = client.post(API_URL + path, json: payload)
+
+      response.raise_for_status
+
+      result = response.json
+
+      return GenerateResult.new(
+        image: result[:item][:label],
+        file_type: result[:labelDefinition][:imageFileType],
+      )
+    end
+  end
+end

data/lib/swisspost/base_service.rb

@@ -0,0 +1,24 @@
+require 'httpx'
+require_relative "auth"
+
+module Swisspost
+  class BaseService
+    def httpx_oauth(scope)
+      @httpx_oauth ||= HTTPX.with(headers: {
+        "Authorization" => "Bearer #{access_token(scope)}",
+        "Content-Type" => "application/json"
+      })
+    end
+
+    def httpx_apikey
+      @httpx_apikey ||= HTTPX.with(headers: {
+        "X-Apim-Api-Key" => "77b97c82-5324-4964-b97c-825324f964cb",
+        "Content-Type" => "application/json"
+      })
+    end
+
+    def access_token(scope)
+      @access_token ||= Auth.new.get_access_token(scope)
+    end
+  end
+end

data/lib/swisspost/model/address.rb

@@ -0,0 +1,48 @@
+require_relative "validation_error"
+
+module Swisspost
+  module Model
+    class Address
+      attr_reader :first_name, :last_name, :street, :house_number, :zip, :city
+
+      VALIDATOR = Dry::Validation.Contract do
+        params do
+          # Define all keys and their expected base types
+          required(:first_name).filled(:string)
+          required(:last_name).filled(:string)
+          required(:street).filled(:string)
+          required(:house_number).filled(:string)
+          required(:zip).value(:integer)
+          required(:city).filled(:string)
+        end
+
+        # Add more specific rules for keys that pass the initial check
+        rule(:zip) do
+          # Swiss ZIP codes are 4 digits, from 1000 to 9999
+          key.failure('must be a 4-digit Swiss ZIP code') unless value.between?(1000, 9999)
+        end
+      end
+
+      def initialize(attributes)
+        result = VALIDATOR.call(attributes)
+        raise ValidationError, result.errors.to_h.inspect if result.failure?
+
+        validated_data = result.to_h
+        @first_name = validated_data[:first_name]
+        @last_name = validated_data[:last_name]
+        @street = validated_data[:street]
+        @house_number = validated_data[:house_number]
+        @zip = validated_data[:zip]
+        @city = validated_data[:city]
+      end
+
+      def full_name
+        [@first_name, @last_name].compact.join(" ")
+      end
+
+      def full_street
+        [@street, @house_number].compact.join(" ")
+      end
+    end
+  end
+end

data/lib/swisspost/model/barcode_item.rb

@@ -0,0 +1,34 @@
+require_relative "validation_error"
+
+module Swisspost
+  module Model
+    class BarcodeItem
+      attr_reader :service_code, :weight
+
+      VALIDATOR = Dry::Validation.Contract do
+        params do
+          required(:weight).value(:integer)
+          required(:service_code).value(:string)
+        end
+
+        rule(:weight) do
+          key.failure('must be greater than 0') if value <= 0
+        end
+
+        rule(:service_code) do
+          allowed_services = %w[ECO PRI APOST BPOST]
+          key.failure("must be one of: #{allowed_services.join(', ')}") unless allowed_services.include?(value)
+        end
+      end
+
+      def initialize(attributes)
+        result = VALIDATOR.call(attributes)
+        raise ValidationError, result.errors.to_h.inspect if result.failure?
+
+        validated_data = result.to_h
+        @weight = validated_data[:weight]
+        @service_code = validated_data[:service_code]
+      end
+    end
+  end
+end

data/lib/swisspost/model/validation_error.rb

@@ -0,0 +1,6 @@
+module Swisspost
+  module Model
+    class ValidationError < StandardError
+    end
+  end
+end

data/lib/swisspost/price_service.rb

@@ -0,0 +1,41 @@
+require "dry-validation"
+require_relative "model/address"
+require_relative "base_service"
+
+module Swisspost
+  class PriceService < BaseService
+    API_URL = "https://vsc.apis.post.ch/product/v1"
+
+    PRODUCTS_VALIDATOR = Dry::Validation.Contract do
+      VALID_FORMATS = %w[B4 B5 MB PK SP RL FF].freeze
+      VALID_COUNTRIES = %w[AF EG AX AL DZ VI UM AD AO AI AQ AG GQ AR AM AW AZ ET AU BS BH BD BB BY BE BZ BJ BM BT BO BQ BA BW BV BR IO BN BG BF BI KY CL CN CK CR CW DK DE DJ DM DO EC CI SV ER EE SZ FK FO FJ FI FR GF PF TF GA GM GE GH GI GD GR GL GB GP GU GT GG GN GW GY HT HM HN HK IN ID IQ IR IE IS IL IT JM JP YE JE JO KH CM CA CV KZ KE KG KI CC CO KM CD CG KP KR XZ HR CU KW LA LS LV LB LR LY LI LT LU MO MG MW MY MV ML MT IM MP MA MH MQ MR MU YT MX FM MD MC MN ME MS MZ MM NA NR NP NC NZ NI NL NE NG NU MK NF NO OM AT PK PS PW PA PG PY PE PH PN PL PT PR QA RE RO RU RW SB ZM AS WS SM SA SE CH SN RS SC SL SG SK SI SO ES LK BL KN SH LC SX MF PM ST VC ZA SD GS SS SR SJ SY TJ TW TZ TH TL TG TK TO TT TD CZ TN TR TM TC TV UG UA HU UY US UZ VU VA VE AE US VN VG WF CX EH CF ZW CY].freeze
+
+      params do
+        required(:country).value(:string, included_in?: VALID_COUNTRIES)
+        required(:format).filled(:string, included_in?: VALID_FORMATS)
+        required(:weight).value(:integer, gteq?: 0)
+      end
+    end
+
+    def products(country, format, weight)
+      path = "/products"
+
+      result = PRODUCTS_VALIDATOR.call(country: country, format: format, weight: weight)
+      raise ValidationError, result.errors.to_h.inspect if result.failure?
+
+      response = httpx_apikey.get(API_URL + path, params: {
+        isoCode: country,
+        format: format,
+        weight: weight,
+      })
+
+      response.raise_for_status
+
+      result = response.json
+
+      return result
+    end
+
+    Result = Struct.new(:address, :quality, keyword_init: true)
+  end
+end

data/lib/swisspost/types.rb

@@ -0,0 +1,5 @@
+require 'dry-types'
+
+module Types
+  include Dry.Types()
+end

data/lib/swisspost/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Swisspost
+  VERSION = "0.1.0"
+end

data/lib/swisspost.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "swisspost/address_service"
+require_relative "swisspost/barcode_service"
+require_relative "swisspost/price_service"
+require_relative "swisspost/version"
+
+module Swisspost
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/swisspost.rbs

@@ -0,0 +1,4 @@
+module Swisspost
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: swisspost
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lukas_Skywalker
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: cli-ui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby gem for interacting with Swiss Post APIs including parcel tracking,
+  address validation, and other postal services
+email:
+- git@lukasdiener.ch
+executables:
+- swisspost
+extensions: []
+extra_rdoc_files: []
+files:
+- ".devcontainer/devcontainer.json"
+- ".rspec"
+- ".standard.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/swisspost
+- lib/swisspost.rb
+- lib/swisspost/address_service.rb
+- lib/swisspost/auth.rb
+- lib/swisspost/barcode_service.rb
+- lib/swisspost/base_service.rb
+- lib/swisspost/model/address.rb
+- lib/swisspost/model/barcode_item.rb
+- lib/swisspost/model/validation_error.rb
+- lib/swisspost/price_service.rb
+- lib/swisspost/types.rb
+- lib/swisspost/version.rb
+- sig/swisspost.rbs
+homepage: https://github.com/code-fabrik/swisspost
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/code-fabrik/swisspost
+  source_code_uri: https://github.com/code-fabrik/swisspost
+  changelog_uri: https://github.com/code-fabrik/swisspost/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Swiss Post API client for Ruby
+test_files: []