summaryrefslogtreecommitdiff
path: root/app/models
diff options
context:
space:
mode:
Diffstat (limited to 'app/models')
-rw-r--r--app/models/match.rb6
-rw-r--r--app/models/team.rb2
-rw-r--r--app/models/tournament.rb41
-rw-r--r--app/models/user.rb149
4 files changed, 196 insertions, 2 deletions
diff --git a/app/models/match.rb b/app/models/match.rb
index bb814c1..782dce8 100644
--- a/app/models/match.rb
+++ b/app/models/match.rb
@@ -1,4 +1,8 @@
class Match < ActiveRecord::Base
belongs_to :tournament
- belongs_to :winner
+
+ has_and_belongs_to_many :teams
+
+ belongs_to :winner, class_name: "Team"
+
end
diff --git a/app/models/team.rb b/app/models/team.rb
index 9e71557..2348de5 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 cc915a0..69bedf5 100644
--- a/app/models/tournament.rb
+++ b/app/models/tournament.rb
@@ -1,3 +1,42 @@
class Tournament < ActiveRecord::Base
- belongs_to :game
+ belongs_to :game
+ has_many :matches
+ 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 open?
+ return true
+ end
+
+ def joinable_by?(user)
+ return ((not user.nil?) and user.in_group?(:player) and open?)
+ end
+
+ def join(user)
+ unless joinable_by?(user)
+ return false
+ end
+ players.push(user)
+ end
+
+ def setup(tournament)
+ num_teams = (self.players.count/self.max_players_per_team).floor
+ num_matches = num_teams - 1
+ for i in 1..num_matches
+ self.matches.create(name: "Match #{i}")
+ end
+ match_num = 0
+ team_num = 0
+ self.players.each_slice(tournament.max_players_per_team) do |players|
+ self.matches[match_num].teams.push(Team.create(users: players))
+ if (team_num != 0 and team_num % tournament.max_teams_per_match == 0)
+ match_num += 1
+ team_num = 0
+ else
+ team_num += 1
+ end
+ end
+ end
+
+
end
diff --git a/app/models/user.rb b/app/models/user.rb
index 4a57cf0..6e439fb 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -1,2 +1,151 @@
class User < ActiveRecord::Base
+ 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
+
+ before_save { self.email = email.downcase }
+ before_save { self.user_name = user_name }
+
+ ##
+ # Rails looks for the create_remember_token and runs the method
+ # before anything else.
+ #
+ # This method cannot be called by a user since it is denoted
+ # as private.
+ before_create :create_remember_token
+
+ def in_group?(group)
+ case group
+ when :admin
+ return ((groups & 2) != 0)
+ when :host
+ return true #((groups & 1) != 0)
+ when :player
+ return true
+ when :specator
+ return true
+ else
+ return false
+ end
+ end
+
+ def join_groups(join=[])
+ # FIXME: race condition
+ join.each do |group|
+ case group
+ when :admin
+ groups |= 2
+ when :host
+ groups |= 1
+ else
+ end
+ end
+ end
+
+ def leave_groups(leave=[])
+ # FIXME: race condition
+ leave.each do |group|
+ case group
+ when :admin
+ groups &= ~ 2
+ when :host
+ groups &= ~ 1
+ else
+ 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 }
+
+ ##
+ # Create a random remember token for the user. This will be
+ # changed every time the user creates a new session.
+ #
+ # 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 User.new_remember_token
+ SecureRandom.urlsafe_base64
+ 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 User.hash(token)
+ Digest::SHA1.hexdigest(token.to_s)
+ end
+
+ ##
+ # 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
+
+
+ # Everything under private is hidden so you cannot call.
+ private
+
+ ##
+ # Create_remember_token in order to ensure a user always has
+ # a remember token.
+ def create_remember_token
+ self.remember_token = User.hash(User.new_remember_token)
+ end
+
+ ##
+ # In order to ensure that someone did not accidentally submit
+ # two accounts rapidly (which would throw off the validates
+ # for user_name and email), I added an index to the Users
+ # email and user_name in the database to ensure uniqueness
+ # This also gives and index to the user_name and email
+ # so finding a user SHOULD be easier for the database.
end