omegaup 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d68043d4f4131c6b4d11b1607e6d38b0ba05e74621bab4c08cf1bcc0e1c7a948
+  data.tar.gz: cefb8c9d26da0a24d6d720fcd22fbcdc8a4aedc57f5a8b28d1e2b7ceedad9226
+SHA512:
+  metadata.gz: 84ee8b49d4c2d380b03b9dbbe6c67ae0af343a89b09b7fe5c95ac639a8be46478d484bb9c2e4328eff7e2705303ffaf807c7636418825b7995d5e0ef3fe50509
+  data.tar.gz: 93c3a835cbbca8134b4ef626eb14c53061fc495c5cd7fc716a5333b8e209035e2beea10c840f0385f16a41d2632159a3b5367a7e36c4adb564f2433dfa26e99e

data/.rubocop.yml

@@ -0,0 +1,3 @@
+AllCops:
+  TargetRubyVersion: 2.7
+  NewCops: enable

data/Gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec

data/bin/omega

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/omega/cli'
+
+Omega::CLI.new(ARGV).execute

data/lib/omega.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'omega/base'
+require_relative 'omega/contest'
+require_relative 'omega/scoreboard'
+require_relative 'omega/user'
+require_relative 'omega/client'

data/lib/omega/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Omega
+  class Base
+    attr_reader :data
+
+    def initialize(client, data)
+      @client = client
+      @data = data
+    end
+  end
+end

data/lib/omega/cli.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative '../omega'
+require_relative 'cli/contest'
+require 'optimist'
+
+module Omega
+  class CLI
+    attr_reader :omega
+
+    include Omega::CLI::Contest
+    SUB_COMMANDS = %w[
+      register-users
+      user
+      scoreboard
+      create-contest
+      add-problem
+      help
+    ].freeze
+
+    def print_help
+      puts %(
+OmegaUp CLI. Developed by OMIJal https://github.com/omijal/omegaup-cli.
+Tool for interacting with omegaup from CLI and available throug ruby gems.
+Commands:
+ - register_users  Add a user or a bunch of users to the a contest.
+ - user            Generates a dump of the user data in yml format.
+ - scoreboard      Gets contest scoreboard with users and score.
+Parametes:
+ --contest         Contest name
+ --user            Username or email
+ --user_file       A file path containing a list of user one per line without
+                   header
+Setup:
+You need to add two env variables with your omegaup credentials.
+OMEGAUP_URL  *Optional* This is intended for development purpose, it will target
+                        to https://omegau.com by default.
+OMEGAUP_USER *Required* Your OmegaUp Username or Email
+OMEGAUP_PASS *Required* Your OmegaUp Password
+      )
+    end
+
+    def initialize(_)
+      @cmd = ARGV.shift
+
+      @cmd_opts = case @cmd
+                  when 'register-users'
+                    Optimist.options do
+                      opt :contest, 'Contest ShortName or identifier', type: :string
+                      opt :user, 'Username or email', type: :string
+                      opt :user_file, 'A file containing the users list one per line and without header', type: :string
+                    end
+                  when 'user'
+                    Optimist.options do
+                      opt :user, 'Username or email', type: :string
+                    end
+                  when 'scoreboard'
+                    Optimist.options do
+                      opt :contest, 'Contest ShortName or identifier', type: :string
+                    end
+                  # when 'create-contest'
+                  #   Optimist.options do
+                  #     opt :contest, 'Contest ShortName or identifier', type: :string
+                  #   end
+                  # when 'add-problem'
+                  #   Optimist.options do
+                  #     opt :contest, 'Contest ShortName or identifier', type: :string
+                  #     opt :problem, type: :string
+                  #   end
+                  else
+                    print_help
+                    exit(0)
+                  end
+    end
+
+    def login
+      config = {
+        'omega' => {
+          'endpoint' => ENV['OMEGAUP_URL'] || 'https://omegaup.com',
+          'user' => ENV['OMEGAUP_USER'],
+          'pass' => ENV['OMEGAUP_PASS']
+        }
+      }
+
+      @omega = Omega::Client.new(config['omega'])
+      @omega.login
+    end
+
+    def execute
+      login
+      case @cmd
+      when 'register-users'
+        register_user(@cmd_opts[:contest], @cmd_opts[:user]) if @cmd_opts[:user]
+        register_users(@cmd_opts[:contest], @cmd_opts[:user_file]) if @cmd_opts[:user_file]
+      when 'user'
+        user_data(@cmd_opts[:user])
+      when 'scoreboard'
+        scoreboard(@cmd_opts[:contest])
+      end
+    end
+  end
+end

data/lib/omega/cli/contest.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Omega
+  class CLI
+    module Contest
+      def register_user(contest_name, user)
+        contest = omega.contest(contest_name)
+        puts contest.add_user(user)[:status]
+      rescue StandardError => e
+        puts "Error adding #{user}: #{e.message}"
+      end
+
+      def register_users(contest_name, user_file)
+        users = File.readlines(user_file).map(&:strip)
+        contest = omega.contest(contest_name)
+        failed = []
+        users.each do |user|
+          puts "Adding #{user}..."
+          contest.add_user(user)
+        rescue StandardError => e
+          puts "Error adding #{user}: #{e.message}"
+          failed << user
+        end
+        puts "Failed users: \n- #{failed.join("\n- ")}"
+      end
+
+      def user_data(user)
+        puts omega.user(user).full_data.to_yaml
+      end
+
+      def scoreboard(contest_name)
+        score = omega.scoreboard(contest_name)
+        score.simple_display.each_with_index { |s, i| puts "#{i + 1}.- #{s.values.join(': ')}" }
+      rescue StandardError => e
+        puts "#{contest_name}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/omega/client.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'contest'
+require_relative 'scoreboard'
+require_relative 'user'
+
+require 'httparty'
+
+module Omega
+  class OmegaError < StandardError
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+    end
+
+    def message
+      "#{@data[:errorname]}::#{@data[:errorcode]} >> #{@data[:error]}"
+    end
+  end
+
+  class Client
+    include HTTParty
+
+    def initialize(conf)
+      @config = conf
+    end
+
+    def perform_request(method, endpoint, data)
+      url = "#{@config['endpoint']}#{endpoint}"
+      response = self.class.send(method, url, body: data)
+      body = JSON.parse(response.body, symbolize_names: true)
+      raise OmegaError, body if body[:error]
+
+      body
+    end
+
+    def post(endpoint, data)
+      perform_request(:post, endpoint, data)
+    end
+
+    def login
+      data = post('/api/user/login',
+                  usernameOrEmail: @config['user'],
+                  password: @config['pass'])
+      @token = data[:auth_token]
+      self.class.default_cookies.add_cookies('ouat' => data[:auth_token])
+    end
+
+    def open_contest(name)
+      post('/api/contest/open/', { contest_alias: name })
+    end
+
+    def contest(name)
+      data = post('/api/contest/details/', { contest_alias: name })
+      Contest.new(self, data)
+    rescue OmegaError => e
+      raise unless e.data[:errorname] == 'userNotAllowed'
+
+      open_contest(name)
+      retry
+    end
+
+    def scoreboard(name)
+      data = post('/api/contest/scoreboard/', { contest_alias: name })
+      Scoreboard.new(self, data)
+    end
+
+    def user(user)
+      data = post('/api/user/profile/', { username: user })
+      User.new(self, data)
+    end
+
+    def add_user_to_contest(user, contest)
+      post('/api/contest/addUser', { contest_alias: contest, usernameOrEmail: user })
+    end
+
+    def problems_solved(user)
+      post('/api/user/problemsSolved/', { username: user })
+    end
+  end
+end

data/lib/omega/contest.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Omega
+  class Contest < Base
+    def scoreboard
+      @client.scoreboard(data[:alias])
+    end
+
+    def add_user(user)
+      if user.is_a?(String)
+        @client.add_user_to_contest(user, data[:alias])
+      else
+        @client.add_user_to_contest(user.data[:username], data[:alias])
+      end
+    end
+
+    def observe
+      last = current = scoreboard
+      sleep(5)
+      loop do
+        current = scoreboard
+        last.users.each do |score|
+          puts score.username
+          current_score = current.score_for(score.username)
+          score.problems.each do |problem|
+            name = problem[:alias]
+            current_problem = current_score.score_for(name)
+            last_points = problem[:points]
+            current_points = current_problem[:points]
+            puts "  #{name}::#{last_points} >> #{current_points}"
+            yield(contest_name, score.username, name, current_points, last_points) if current_points != last_points
+          end
+          puts '-' * 60
+        end
+        last = current
+        sleep(15)
+      end
+    end
+  end
+end

data/lib/omega/scoreboard.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Omega
+  class ScoreboardEntry < Base
+    attr_accessor :problems
+    attr_reader :username
+
+    def initialize(client, entry)
+      @username = entry[:username]
+      @client = client
+      @problems = entry[:problems] || []
+      @data = entry
+    end
+
+    def merge(score)
+      result = clone
+      result.problems += score.problems
+      result.data[:total][:points] += score.data[:total][:points]
+      result
+    end
+
+    def simple_display
+      {
+        username: @data[:username],
+        score: @data[:total][:points]
+      }
+    end
+
+    def <=>(other)
+      other.data[:total][:points] <=> @data[:total][:points]
+    end
+
+    def score_for(name)
+      problems.each do |problem|
+        return problem if problem[:alias] == name
+      end
+      nil
+    end
+  end
+
+  class Scoreboard < Base
+    def initialize(client, data)
+      @client = client
+      @data = data.dup
+      @data[:ranking] = {}
+      data[:ranking].each do |entry|
+        @data[:ranking][entry[:username]] = ScoreboardEntry.new(client, entry)
+      end
+    end
+
+    def merge(board)
+      result = clone
+      board.data[:ranking].each do |user, score|
+        result.data[:ranking][user] =
+          result.data[:ranking][user].nil? ? score : result.data[:ranking][user].merge(score)
+      end
+      result
+    end
+
+    def simple_display
+      users.map(&:simple_display)
+    end
+
+    def score_for(user)
+      @data[:ranking][user]
+    end
+
+    def users
+      @data[:ranking].values.sort
+    end
+  end
+end

data/lib/omega/user.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Omega
+  class User < Base
+    def full_data
+      {
+        data: @data,
+        problems_solved: problems_solved,
+        resume: report
+      }
+    end
+
+    def problems_solved
+      @client.problems_solved(data[:username])[:problems]
+    end
+
+    def report
+      data = { score: 0, count: 0 }
+      problems_solved.each do |p|
+        data[:score] += p[:difficulty] || 0
+        data[:count] += 1
+      end
+      data
+    end
+  end
+end

data/lib/omega/version.rb

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

data/omega.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'omega/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'omegaup'
+  spec.version       = Omega::VERSION
+  spec.authors       = ['Gilberto Vargas']
+  spec.email         = ['tachoguitar@gmail.com']
+
+  spec.summary       = 'File created for encrypting files using ssh keys'
+  spec.description   = 'Allows to encrypt files using ssh keys'
+  spec.homepage      = 'https://github.com/omijal/omegaup-cli'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'amazing_print'
+  spec.add_development_dependency 'minitest', '~> 5'
+  spec.add_development_dependency 'optimist'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: omegaup
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gilberto Vargas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: amazing_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Allows to encrypt files using ssh keys
+email:
+- tachoguitar@gmail.com
+executables:
+- omega
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- bin/omega
+- lib/omega.rb
+- lib/omega/base.rb
+- lib/omega/cli.rb
+- lib/omega/cli/contest.rb
+- lib/omega/client.rb
+- lib/omega/contest.rb
+- lib/omega/scoreboard.rb
+- lib/omega/user.rb
+- lib/omega/version.rb
+- omega.gemspec
+homepage: https://github.com/omijal/omegaup-cli
+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: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: File created for encrypting files using ssh keys
+test_files: []