summaryrefslogtreecommitdiff
path: root/app/models
diff options
context:
space:
mode:
Diffstat (limited to 'app/models')
-rw-r--r--app/models/alert.rb2
-rw-r--r--app/models/game.rb1
-rw-r--r--app/models/match.rb39
-rw-r--r--app/models/remote_username.rb8
-rw-r--r--app/models/server.rb36
-rw-r--r--app/models/session.rb39
-rw-r--r--app/models/team.rb2
-rw-r--r--app/models/tournament.rb127
-rw-r--r--app/models/user.rb180
9 files changed, 432 insertions, 2 deletions
diff --git a/app/models/alert.rb b/app/models/alert.rb
index 0516355..9876711 100644
--- a/app/models/alert.rb
+++ b/app/models/alert.rb
@@ -1,3 +1,3 @@
class Alert < ActiveRecord::Base
- belongs_to :author
+ belongs_to :author, class_name: "User"
end
diff --git a/app/models/game.rb b/app/models/game.rb
index a181c26..ec865d8 100644
--- a/app/models/game.rb
+++ b/app/models/game.rb
@@ -1,2 +1,3 @@
class Game < ActiveRecord::Base
+ has_many :settings, class_name: "GameSetting"
end
diff --git a/app/models/match.rb b/app/models/match.rb
index fe68d31..ac74fe1 100644
--- a/app/models/match.rb
+++ b/app/models/match.rb
@@ -1,4 +1,41 @@
class Match < ActiveRecord::Base
belongs_to :tournament
- belongs_to :winner
+ has_many :scores
+ has_and_belongs_to_many :teams
+
+ belongs_to :winner, class_name: "Team"
+
+ def setup()
+
+ end
+
+ def is_match_over(match, firstPlayer)
+ #response = HTTParty.get("https://prod.api.pvp.net/api/lol/na/v1.3/summoner/by-name/#{firstPlayer}?api_key=ad539f86-22fd-474d-9279-79a7a296ac38")
+ #riot_id = response["#{firstPlayer}"]['id']
+ #recent game information
+ #game_info = HTTParty.get("https://prod.api.pvp.net/api/lol/na/v1.3/game/by-summoner/#{riot_id}/recent?api_key=ad539f86-22fd-474d-9279-79a7a296ac38")
+ #first_id = game_info["games"][0]["gameId"]
+
+ count = 0
+ while true do
+ #sleep(5) #wait four minutes
+
+ puts("Every 4 minutes.")
+ puts("Every 4 minutes.")
+ count += 1
+ #game_info = HTTParty.get("https://prod.api.pvp.net/api/lol/na/v1.3/game/by-summoner/#{riot_id}/recent?api_key=ad539f86-22fd-474d-9279-79a7a296ac38")
+ #current_id = game_info["games"][0]["gameId"]
+
+ #if current_id != first_id
+ if count > 2
+ puts(count)
+ #sleep(10)
+ match.status = 2
+ match.save
+ return true
+ end
+ end #while
+ end
+ #handle_asynchronously :is_match_over
+
end
diff --git a/app/models/remote_username.rb b/app/models/remote_username.rb
index c477f8a..e5d0a8c 100644
--- a/app/models/remote_username.rb
+++ b/app/models/remote_username.rb
@@ -1,4 +1,12 @@
class RemoteUsername < ActiveRecord::Base
belongs_to :game
belongs_to :user
+
+ def value
+ JSON.parse(self.json_value)
+ end
+
+ def value=(v)
+ self.json_value = v.to_json
+ end
end
diff --git a/app/models/server.rb b/app/models/server.rb
index 120f0fa..5ba7524 100644
--- a/app/models/server.rb
+++ b/app/models/server.rb
@@ -1,2 +1,38 @@
class Server < ActiveRecord::Base
+ def default_user_abilities
+ @abilities ||= User::Abilities.new(DefaultUser.new(self))
+ end
+ def default_user_abilities=(new)
+ new.each do |k,v|
+ if v == "0"
+ v = false
+ end
+ default_user_abilities[k] = v
+ end
+ end
+ class DefaultUser
+ def initialize(server)
+ @server = server
+ end
+ def can?(action)
+ bit = User.permission_bits[action]
+ if bit.nil?
+ return false
+ else
+ return (@server.default_user_permissions & bit != 0)
+ end
+ end
+ def add_ability(action)
+ bit = User.permission_bits[action.to_sym]
+ unless bit.nil?
+ @server.default_user_permissions |= bit
+ end
+ end
+ def remove_ability(action)
+ bit = User.permission_bits[action.to_sym]
+ unless bit.nil?
+ @server.default_user_permissions &= ~ bit
+ end
+ end
+ end
end
diff --git a/app/models/session.rb b/app/models/session.rb
index a5fd26e..f5e642b 100644
--- a/app/models/session.rb
+++ b/app/models/session.rb
@@ -1,3 +1,42 @@
class Session < ActiveRecord::Base
belongs_to :user
+
+ ##
+ # Create a random remember token for the user. This will be
+ # changed every time the user creates a new session.
+ #
+ # If you want this value, hang on to it; the raw value is
+ # discarded afterward.
+ #
+ # By changing the cookie every new session, any hijacked sessions
+ # (where the attacker steals a cookie to sign in as a certain
+ # user) will expire the next time the user signs back in.
+ #
+ # The random string is of length 16 composed of A-Z, a-z, 0-9
+ # This is the browser's cookie value.
+ def create_token()
+ t = SecureRandom.urlsafe_base64
+ self.token = Session.hash_token(t)
+ t
+ end
+
+ ##
+ # Encrypt the remember token.
+ # This is the encrypted version of the cookie stored on
+ # the database.
+ #
+ # The reasoning for storing a hashed token is so that even if
+ # the database is compromised, the attacker won't be able to use
+ # the remember tokens to sign in.
+ def Session.hash_token(token)
+ # SHA-1 (Secure Hash Algorithm) is a US engineered hash
+ # function that produces a 20 byte hash value which typically
+ # forms a hexadecimal number 40 digits long.
+ # The reason I am not using the Bcrypt algorithm is because
+ # SHA-1 is much faster and I will be calling this on
+ # every page a user accesses.
+ #
+ # https://en.wikipedia.org/wiki/SHA-1
+ Digest::SHA1.hexdigest(token.to_s)
+ end
end
diff --git a/app/models/team.rb b/app/models/team.rb
index 8d89f51..7aae7c2 100644
--- a/app/models/team.rb
+++ b/app/models/team.rb
@@ -1,3 +1,5 @@
class Team < ActiveRecord::Base
belongs_to :match
+ has_and_belongs_to_many :matches
+ has_and_belongs_to_many :users
end
diff --git a/app/models/tournament.rb b/app/models/tournament.rb
index dcdb8d5..bf44cdf 100644
--- a/app/models/tournament.rb
+++ b/app/models/tournament.rb
@@ -1,3 +1,130 @@
class Tournament < ActiveRecord::Base
belongs_to :game
+ has_many :matches
+ has_many :settings_raw, class_name: "TournamentSetting"
+ has_and_belongs_to_many :players, class_name: "User", association_foreign_key: "player_id", join_table: "players_tournaments"
+ has_and_belongs_to_many :hosts, class_name: "User", association_foreign_key: "host_id", join_table: "hosts_tournaments"
+
+ def matches_ordered
+ h = {}
+ i = 1
+ matches.order(:id).each do |m|
+ h[i] = m
+ i += 1
+ end
+ return h
+ end
+
+ def settings
+ @settings ||= Settings.new(self)
+ end
+ def settings=(setting)
+ setting.each do |key, value|
+ value = false if value == "0"
+ settings[key] = value
+ end
+ end
+
+ class Settings
+ @vartypes = {
+ :true_false => 0,
+ :integer => 1,
+ :string => 2,
+ :select => 3,
+ :range => 4
+ }
+
+ def initialize(tournament)
+ @tournament = tournament
+ end
+
+ def [](setting)
+ p = @tournament.settings_raw.find_by_name(setting)
+ if p.nil?
+ return nil
+ else
+ return p.value
+ end
+ end
+
+ def []=(setting, val)
+ p = @tournament.settings_raw.find_by_name(setting)
+ if p.nil?
+ TournamentSetting.create( tournament_id: @tournament.id, vartype: get_type(val), name: setting, value: val )
+ else
+ p.value = val
+ end
+ end
+
+ def get_type(val)
+ case val
+ when "true", "false"
+ vartypes[:true_false]
+ when /\d+-\d/ =~ val
+ vartypes[:range]
+ when /\d+/ =~ val
+ vartypes[:integer]
+ when /,/ =~ val
+ vartypes[:select]
+ else
+ vartypes[:string]
+ end
+ end
+
+ def keys
+ @tournament.settings_raw.all.collect { |x| x.name }
+ end
+
+ def method_missing(name, *args)
+ if name.to_s.ends_with?('=')
+ self[name.to_s.sub(/=$/, '').to_sym] = args.first
+ else
+ return self[name.to_sym]
+ end
+ end
+ end
+
+ def open?
+ return true
+ end
+
+ def joinable_by?(user)
+ return (open? and user.can?(:join_tournament) and !players.include?(user))
+ end
+
+ def join(user)
+ unless joinable_by?(user)
+ return false
+ end
+ players.push(user)
+ end
+
+ def leave(user)
+ if players.include?(user) && status == 0
+ players.delete(user)
+ end
+ end
+
+ def setup
+ num_teams = (self.players.count/self.min_players_per_team).floor
+ num_matches = num_teams - 1
+ for i in 1..num_matches
+ self.matches.create(name: "Match #{i}", status: 0, submitted_peer_evaluations: 0)
+ end
+ match_num = num_matches-1
+ team_num = 0
+ #for each grouping of min_players_per_team
+ players.each_slice(min_players_per_team) do |players|
+
+ #if the match is full, move to the next match, otherwise move to the next team
+ if (team_num == min_teams_per_match)
+ match_num -= 1
+ team_num = 0
+ else
+ team_num += 1
+ end
+ #create a new team in the current match
+ self.matches[match_num].teams.push(Team.create(users: players))
+ end
+ end
end
diff --git a/app/models/user.rb b/app/models/user.rb
index 4a57cf0..57746b7 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -1,2 +1,182 @@
class User < ActiveRecord::Base
+ before_save :default_values
+
+ has_and_belongs_to_many :tournaments_played, class_name: "Tournament", foreign_key: "player_id", join_table: "players_tournaments"
+ has_and_belongs_to_many :tournaments_hosted, class_name: "Tournament", foreign_key: "host_id", join_table: "hosts_tournaments"
+ has_and_belongs_to_many :teams
+ has_many :sessions
+ has_many :scores
+ has_many :remote_usernames
+
+ apply_simple_captcha
+
+ before_save { self.email = email.downcase }
+ before_save { self.user_name = user_name }
+
+ def default_values
+ self.permissions ||= Server.first.default_user_permissions
+ end
+
+ def find_remote_username(game)
+ obj = remote_username.where(:game => game)
+ if obj.nil? and not game.parent.nil?
+ return find_remote_username(game.parent)
+ else
+ return obj.value
+ end
+ end
+
+ def self.permission_bits
+ return {
+ :create_tournament => (2**1),
+ :edit_tournament => (2**2),
+ :join_tournament => (2**3),
+ :delete_tournament => (2**4),
+
+ :create_game => (2**5),
+ :edit_game => (2**6),
+ :delete_game => (2**7),
+
+ :create_user => (2**8),
+ :edit_user => (2**9),
+ :delete_user => (2**10),
+
+ :create_alert => (2**11),
+ :edit_alert => (2**12),
+ :delete_alert => (2**13),
+
+ :create_pm => (2**14),
+ :edit_pm => (2**15),
+ :delete_pm => (2**16),
+
+ :create_session => (2**17),
+ :delete_session => (2**18),
+
+ :edit_permissions => (2**19),
+ :edit_server => (2**20),
+ }
+ end
+
+ def can?(action)
+ bit = User.permission_bits[action]
+ if bit.nil?
+ return false
+ else
+ return (self.permissions & bit != 0)
+ end
+ end
+
+ def add_ability(action)
+ bit = User.permission_bits[action.to_sym]
+ unless bit.nil?
+ self.permissions |= bit
+ end
+ end
+
+ def remove_ability(action)
+ bit = User.permission_bits[action.to_sym]
+ unless bit.nil?
+ self.permissions &= ~ bit
+ end
+ end
+
+
+ # A representation of the permission bits as a mock-array.
+ def abilities
+ @abilities ||= Abilities.new(self)
+ end
+ def abilities=(new)
+ new.each do |k,v|
+ if v == "0"
+ v = false
+ end
+ abilities[k] = v
+ end
+ end
+
+ # A thin array-like wrapper around the permission bits to make it
+ # easy to modify them using a form.
+ class Abilities
+ def initialize(user)
+ @user = user
+ end
+ def [](ability)
+ return @user.can?(ability)
+ end
+ def []=(ability, val)
+ if val
+ @user.add_ability(ability)
+ else
+ @user.remove_ability(ability)
+ end
+ end
+ def keys
+ User.permission_bits.keys
+ end
+ def method_missing(name, *args)
+ if name.to_s.ends_with?('=')
+ self[name.to_s.sub(/=$/, '').to_sym] = args.first
+ else
+ return self[name.to_sym]
+ end
+ end
+ end
+
+ # VAILD_EMAIL is the regex used to validate a user given email.
+ VALID_EMAIL_REG = /\A\S+@\S+\.\S+\z/i
+
+ # VALID_USER_NAME checks to make sure a user's user_name
+ # is in the proper format.
+ VALID_USER_NAME_REG = /\A[a-zA-Z0-9 _\-]+\z/
+
+ # The following lines put a user account through a series of
+ # validations in order to make sure all of their information
+ # is in the proper format.
+ #
+ # validates :symbol_to_be_validated
+ #
+ # - presence: determines whether or not a symbol is filled or not
+ # - length: ensures there is a length limit on the symbol
+ # - format: checks the format of given information to ensure
+ # validity
+ validates(:name, presence: true, length: { maximum: 50 })
+ validates(:email, presence: true, format: {with:
+ VALID_EMAIL_REG},
+ uniqueness: { case_sensitive: false })
+ validates(:user_name, presence: true, length:{maximum: 50},
+ format: {with: VALID_USER_NAME_REG },
+ uniqueness: {case_sensitive: false })
+
+ # Instead of adding password and password_confirmation
+ # attributes, requiring the presence of a password,
+ # requiring that pw and pw_com match, and add an authenticate
+ # method to compare an encrypted password to the
+ # password_digest to authenticate users, I can just add
+ # has_secure_password which does all of this for me.
+ has_secure_password
+
+ validates :password, length: { minimum: 6 }
+
+ class NilUser
+ def nil?
+ return true
+ end
+ def can?(action)
+ case action
+ when :create_user
+ return true
+ when :create_session
+ return true
+ else
+ return false
+ end
+ end
+ def method_missing(name, *args)
+ # Throw an error if User doesn't have this method
+ super unless User.new.respond_to?(name)
+ # User has this method -- return a blank value
+ # 'false' if the method ends with '?'; 'nil' otherwise.
+ name.to_s.ends_with?('?') ? false : nil
+ end
+ end
end
generated by cgit v1.2.3-2-g168b (git 2.25.1) at 2024-11-01 02:54:15 +0000