squarecloud-unofficial 1.0.0

data/lib/squarecloud/http/endpoint.rb

@@ -0,0 +1,158 @@
+module Squarecloud
+  module HTTP
+    class Endpoint
+      ENDPOINTS = {
+        'USER' => { 'METHOD' => 'GET', 'PATH' => '/users/me' },
+        'APP_DATA' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}' },
+        'APP_STATUS' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/status' },
+        'ALL_APPS_STATUS' => { 'METHOD' => 'GET', 'PATH' => '/apps/status' },
+        'ALL_BACKUPS' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/backups' },
+        'LOGS' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/logs' },
+        'START' => { 'METHOD' => 'POST', 'PATH' => '/apps/{app_id}/start' },
+        'STOP' => { 'METHOD' => 'POST', 'PATH' => '/apps/{app_id}/stop' },
+        'RESTART' => { 'METHOD' => 'POST', 'PATH' => '/apps/{app_id}/restart' },
+        'BACKUP' => { 'METHOD' => 'POST', 'PATH' => '/apps/{app_id}/backups' },
+        'COMMIT' => { 'METHOD' => 'POST', 'PATH' => '/apps/{app_id}/commit' },
+        'DELETE_APP' => { 'METHOD' => 'DELETE', 'PATH' => '/apps/{app_id}' },
+        'UPLOAD_APP' => { 'METHOD' => 'POST', 'PATH' => '/apps' },
+        'FILES_LIST' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/files?path={path}' },
+        'FILES_READ' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/files/content?path={path}' },
+        'FILES_CREATE' => { 'METHOD' => 'PUT', 'PATH' => '/apps/{app_id}/files' },
+        'FILES_DELETE' => { 'METHOD' => 'DELETE', 'PATH' => '/apps/{app_id}/files' },
+        'MOVE_FILE' => { 'METHOD' => 'PATCH', 'PATH' => '/apps/{app_id}/files' },
+        'LAST_DEPLOYS' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/deployments' },
+        'CURRENT_INTEGRATION' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/deployments/current' },
+        'GITHUB_INTEGRATION' => { 'METHOD' => 'POST', 'PATH' => '/apps/{app_id}/deploy/webhook' },
+        'CUSTOM_DOMAIN' => { 'METHOD' => 'POST', 'PATH' => '/apps/{app_id}/network/custom' },
+        'DOMAIN_ANALYTICS' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/network/analytics' },
+        'DNSRECORDS' => { 'METHOD' => 'GET', 'PATH' => '/apps/{app_id}/network/dns' }
+      }.freeze
+      
+      attr_reader :name, :method, :path
+      
+      def initialize(name)
+        endpoint = ENDPOINTS[name]
+        raise ArgumentError, "Invalid endpoint: '
+        
+        @name = name
+        @method = endpoint['METHOD']
+        @path = endpoint['PATH']
+      end
+      
+      def build_path(params = {})
+        path = @path.dup
+        params.each do |key, value|
+          placeholder = "{
+          path = path.gsub(placeholder, value.to_s) if path.include?(placeholder)
+        end
+        path
+      end
+      
+      def ==(other)
+        other.is_a?(Endpoint) && @name == other.name
+      end
+      
+      def to_s
+        "Endpoint('
+      end
+      
+      class << self
+        def user
+          new('USER')
+        end
+        
+        def app_data
+          new('APP_DATA')
+        end
+        
+        def app_status
+          new('APP_STATUS')
+        end
+        
+        def logs
+          new('LOGS')
+        end
+        
+        def start
+          new('START')
+        end
+        
+        def stop
+          new('STOP')
+        end
+        
+        def restart
+          new('RESTART')
+        end
+        
+        def backup
+          new('BACKUP')
+        end
+        
+        def commit
+          new('COMMIT')
+        end
+        
+        def delete_app
+          new('DELETE_APP')
+        end
+        
+        def upload
+          new('UPLOAD_APP')
+        end
+        
+        def files_list
+          new('FILES_LIST')
+        end
+        
+        def files_read
+          new('FILES_READ')
+        end
+        
+        def files_create
+          new('FILES_CREATE')
+        end
+        
+        def files_delete
+          new('FILES_DELETE')
+        end
+        
+        def last_deploys
+          new('LAST_DEPLOYS')
+        end
+        
+        def github_integration
+          new('GITHUB_INTEGRATION')
+        end
+        
+        def domain_analytics
+          new('DOMAIN_ANALYTICS')
+        end
+        
+        def custom_domain
+          new('CUSTOM_DOMAIN')
+        end
+        
+        def all_backups
+          new('ALL_BACKUPS')
+        end
+        
+        def all_apps_status
+          new('ALL_APPS_STATUS')
+        end
+        
+        def current_integration
+          new('CURRENT_INTEGRATION')
+        end
+        
+        def move_file
+          new('MOVE_FILE')
+        end
+        
+        def dns_records
+          new('DNSRECORDS')
+        end
+      end
+    end
+  end
+end 

data/lib/squarecloud/models.rb

@@ -0,0 +1,419 @@
+require 'date'
+
+module Squarecloud
+  class PlanData
+    attr_reader :name, :memory, :duration
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @name = data[:name]
+      @memory = data[:memory]
+      @duration = data[:duration]
+    end
+    
+    def to_h
+      {
+        name: @name,
+        memory: @memory,
+        duration: @duration
+      }
+    end
+  end
+  
+  class Language
+    attr_reader :name, :version
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @name = data[:name]
+      @version = data[:version]
+    end
+    
+    def to_h
+      {
+        name: @name,
+        version: @version
+      }
+    end
+  end
+  
+  class StatusData
+    attr_reader :cpu, :ram, :status, :running, :storage, :network, :requests, :uptime, :time
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @cpu = data[:cpu]
+      @ram = data[:ram]
+      @status = data[:status]
+      @running = data[:running]
+      @storage = data[:storage]
+      @network = data[:network]
+      @requests = data[:requests]
+      @uptime = data[:uptime]
+      @time = data[:time]
+    end
+    
+    def to_h
+      {
+        cpu: @cpu,
+        ram: @ram,
+        status: @status,
+        running: @running,
+        storage: @storage,
+        network: @network,
+        requests: @requests,
+        uptime: @uptime,
+        time: @time
+      }
+    end
+  end
+  
+  class ResumedStatus
+    attr_reader :id, :running, :cpu, :ram
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @id = data[:id]
+      @running = data[:running]
+      @cpu = data[:cpu]
+      @ram = data[:ram]
+    end
+    
+    def to_h
+      {
+        id: @id,
+        running: @running,
+        cpu: @cpu,
+        ram: @ram
+      }
+    end
+  end
+  
+  class AppData
+    attr_reader :id, :name, :cluster, :ram, :language, :domain, :custom, :desc
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @id = data[:id]
+      @name = data[:name]
+      @cluster = data[:cluster]
+      @ram = data[:ram]
+      @language = data[:language]
+      @domain = data[:domain]
+      @custom = data[:custom]
+      @desc = data[:desc]
+    end
+    
+    def to_h
+      {
+        id: @id,
+        name: @name,
+        cluster: @cluster,
+        ram: @ram,
+        language: @language,
+        domain: @domain,
+        custom: @custom,
+        desc: @desc
+      }
+    end
+  end
+  
+  class UserData
+    attr_reader :id, :name, :plan, :email, :apps
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @id = data[:id]
+      @name = data[:name]
+      @plan = data[:plan] ? PlanData.new(data[:plan]) : nil
+      @email = data[:email]
+      @apps = data[:apps] || []
+    end
+    
+    def to_h
+      {
+        id: @id,
+        name: @name,
+        plan: @plan&.to_h,
+        email: @email,
+        apps: @apps
+      }
+    end
+  end
+  
+  class LogsData
+    attr_reader :logs
+    
+    def initialize(data)
+      @logs = data[:logs] || ''
+    end
+    
+    def ==(other)
+      other.is_a?(LogsData) && @logs == other.logs
+    end
+    
+    def to_h
+      {
+        logs: @logs
+      }
+    end
+  end
+  
+  class BackupInfo
+    attr_reader :name, :size, :modified, :key
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @name = data[:name]
+      @size = data[:size]
+      @modified = data[:modified] ? DateTime.parse(data[:modified]) : nil
+      @key = data[:key]
+    end
+    
+    def to_h
+      {
+        name: @name,
+        size: @size,
+        modified: @modified,
+        key: @key
+      }
+    end
+  end
+  
+  class Backup
+    attr_reader :url, :key
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @url = data[:url]
+      @key = data[:key]
+    end
+    
+    def to_h
+      {
+        url: @url,
+        key: @key
+      }
+    end
+    
+    def download(path = './')
+      require 'open-uri'
+      require 'zip'
+      
+      zip_path = File.join(path, "backup_
+      IO.copy_stream(URI.open(@url), zip_path)
+      Zip::File.open(zip_path)
+    end
+  end
+  
+  class UploadData
+    attr_reader :id, :name, :language, :ram, :cpu, :domain, :description
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @id = data[:id]
+      @name = data[:name]
+      @language = data[:language] ? Language.new(data[:language]) : nil
+      @ram = data[:ram]
+      @cpu = data[:cpu]
+      @domain = data[:domain]
+      @description = data[:description]
+    end
+    
+    def to_h
+      {
+        id: @id,
+        name: @name,
+        language: @language&.to_h,
+        ram: @ram,
+        cpu: @cpu,
+        domain: @domain,
+        description: @description
+      }
+    end
+  end
+  
+  class FileInfo
+    attr_reader :app_id, :type, :name, :last_modified, :path, :size
+    
+    def initialize(app_id, data)
+      @app_id = app_id
+      return unless data.is_a?(Hash)
+      
+      @type = data[:type]
+      @name = data[:name]
+      @last_modified = data[:lastModified]
+      @path = data[:path]
+      @size = data[:size] || 0
+    end
+    
+    def to_h
+      {
+        app_id: @app_id,
+        type: @type,
+        name: @name,
+        last_modified: @last_modified,
+        path: @path,
+        size: @size
+      }
+    end
+  end
+  
+  class DeployData
+    attr_reader :id, :state, :date
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @id = data[:id]
+      @state = data[:state]
+      @date = data[:date] ? DateTime.parse(data[:date]) : nil
+    end
+    
+    def to_h
+      {
+        id: @id,
+        state: @state,
+        date: @date
+      }
+    end
+  end
+  
+  class AnalyticsTotal
+    attr_reader :visits, :megabytes, :bytes
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @visits = data[:visits]
+      @megabytes = data[:megabytes]
+      @bytes = data[:bytes]
+    end
+    
+    def to_h
+      {
+        visits: @visits,
+        megabytes: @megabytes,
+        bytes: @bytes
+      }
+    end
+  end
+  
+  class DomainAnalytics
+    class Analytics
+      attr_reader :total, :countries, :methods, :referers, :browsers,
+                  :device_types, :operating_systems, :agents, :hosts, :paths
+      
+      def initialize(data)
+        return unless data.is_a?(Hash)
+        
+        @total = data[:total] ? data[:total].map { |t| AnalyticsTotal.new(t) } : []
+        @countries = data[:countries] || []
+        @methods = data[:methods] || []
+        @referers = data[:referers] || []
+        @browsers = data[:browsers] || []
+        @device_types = data[:deviceTypes] || []
+        @operating_systems = data[:operatingSystems] || []
+        @agents = data[:agents] || []
+        @hosts = data[:hosts] || []
+        @paths = data[:paths] || []
+      end
+      
+      def to_h
+        {
+          total: @total.map(&:to_h),
+          countries: @countries,
+          methods: @methods,
+          referers: @referers,
+          browsers: @browsers,
+          device_types: @device_types,
+          operating_systems: @operating_systems,
+          agents: @agents,
+          hosts: @hosts,
+          paths: @paths
+        }
+      end
+    end
+    
+    class Domain
+      attr_reader :hostname, :analytics
+      
+      def initialize(data)
+        return unless data.is_a?(Hash)
+        
+        @hostname = data[:hostname]
+        @analytics = data[:analytics] ? Analytics.new(data[:analytics]) : nil
+      end
+      
+      def to_h
+        {
+          hostname: @hostname,
+          analytics: @analytics&.to_h
+        }
+      end
+    end
+    
+    class Custom
+      attr_reader :analytics
+      
+      def initialize(data)
+        return unless data.is_a?(Hash)
+        
+        @analytics = data[:analytics] ? Analytics.new(data[:analytics]) : nil
+      end
+      
+      def to_h
+        {
+          analytics: @analytics&.to_h
+        }
+      end
+    end
+    
+    attr_reader :domain, :custom
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @domain = data[:domain] ? Domain.new(data[:domain]) : nil
+      @custom = data[:custom] ? Custom.new(data[:custom]) : nil
+    end
+    
+    def to_h
+      {
+        domain: @domain&.to_h,
+        custom: @custom&.to_h
+      }
+    end
+  end
+  
+  class DNSRecord
+    attr_reader :type, :name, :value, :status
+    
+    def initialize(data)
+      return unless data.is_a?(Hash)
+      
+      @type = data[:type]
+      @name = data[:name]
+      @value = data[:value]
+      @status = data[:status]
+    end
+    
+    def to_h
+      {
+        type: @type,
+        name: @name,
+        value: @value,
+        status: @status
+      }
+    end
+  end
+end 

data/lib/squarecloud/version.rb

@@ -0,0 +1,3 @@
+module Squarecloud
+  VERSION = '1.0.0'
+end