SQLHelper.rb

require 'active_record' # for managing model objects

require_relative 'User'
require_relative 'Group'
require_relative 'Badge'
require_relative 'Friend'

# class that handles all I/O for database.
class SQLHelper < ActiveRecord::Migration

	SQLUsername = 'badgeradmin'
	SQLPassword = 'AppBadger1!'
	
	HARD_ERR = {:error => "There was a problem with the API."}
	
	# connect to the SQL database
	def initialize
		ActiveRecord::Base.establish_connection(
			:adapter => "mysql2",
			:host => "badgerdb.cz2y13cetnjg.us-west-2.rds.amazonaws.com",
			:username => SQLUsername,
			:password => SQLPassword,
			:database => "BadgerDB"
		)
	end
	
	def fatalError(exception)
	 puts exception
	 File.open("log.txt", "a") do |f|
 f.puts exception
 f.puts exception.backtrace
 end
 return HARD_ERR
	end
	
	def getFirstUser
	 user = User.find(1)
	 user.username
	end
	
	def getUserById(id)
	 begin
		user = User.find(id)
		rescue ActiveRecord::RecordNotFound
		 return {:error => "User not found."}
		rescue Exception => e
 self.fatalError e
 HARD_ERR
		else
		 puts user.inspect
		 user.toArray
		end
	end
	
	# return user info given a username
	def getUserByUsername(name)
	 begin
	 user = User.find_by username: name
	 if user.nil?
	 return {:error => "User not found."}
	 else
	 user.toArray
	 end 
	 end
	end
	
	# find and authenticate the user with the given credentials
	def login(name, password)
	 user = User.find_by username: name
	 if user.nil?
	 return {:error => "No records exist for that username."}
	 else
	 if user.authenticate password
	 return user.toArray
	 else
	 return {:error => "Incorrect password."}
	 end
	 end
	end
	
	 def getGroupById(id)
 begin
 group = Group.find(id)
 rescue ActiveRecord::RecordNotFound
 return {:error => "Group not found."}
 rescue Exception => e
 self.fatalError e
 HARD_ERR
 else
 group.toArray
 end
 end
 
	# permanently delete a user from the database
 def deleteUser(id) 
 user = User.find(id)
 rescue ActiveRecord::RecordNotFound
 return {:error => "User not found."}
 rescue Exception => e
 self.fatalError e
 HARD_ERR
 else
 user.destroy # `destroy` checks for dependencies (badges, groups)
 return {:response => "User with id #{id} deleted."}
 end
 
	# get the badge object with the given id
 def getBadgeById(id)
 begin
 badge = Badge.find(id)
 rescue ActiveRecord::RecordNotFound
 return {:error => "Badge not found."}
 rescue Exception => e
 self.fatalError e
 HARD_ERR
 else
 badge.toArray
 end
 end
	
	# create a new user with the given credentials
	def createUser(name, password, passwordConfirmation, email)
		begin
		user = User.create!(:username => name, :password => password, :email => email, :password_confirmation => passwordConfirmation) #throws exception if invalid
		rescue ActiveRecord::RecordNotUnique => e
			return {:error => "Username or email already exists."}
		rescue ActiveRecord::RecordInvalid => ri
		 return {:error => ri}
		rescue Exception => ex
		 self.fatalError ex
		 HARD_ERR
		else
			user.toArray
		end
	end
	
	# add a friend to the given user, also adds in reverse direction
 def addFriend(userId, friendId)
 user = User.find(userId)
 User.find(friendId)
 if user.friends.exists?(friendId)
 return {:error => "Users are already friends."}
 end
 Friend.create(:user_id => userId, :friend_id => friendId)
 Friend.create(:user_id => friendId, :friend_id => userId)
 return {:response => "Success"}
 
 rescue ActiveRecord::RecordNotFound
 return {:error => "User and/or friend not found."}
 end	
	# update user with given credentials
	def updateUser(args)
	 if args['id'] then
	 userId = args['id']
	 user = User.find(userId)
 user.update! args
 return {:response => "Record updated."}
 else
	 return {:error => "'id' is required."}
	 end
 rescue ActiveRecord::RecordInvalid => ri
 return {:error => ri}
 rescue Exception => e
 self.fatalError e
 HARD_ERR
	end
	
	def updateBadge(args)
 if args['id'] then
 badgeId = args['id']
 badge = Badge.find(badgeId)
 puts "ARG: #{args['is_new']}"
 badge.update! args
 if args['recipient_id'] then
 badge.is_new = true
 end
 return {:response => "Record updated."}
 else
 return {:error => "'id' is required."}
 end
 rescue ActiveRecord::RecordInvalid => ri
 return {:error => ri}
 rescue Exception => e
 self.fatalError e
 HARD_ERR
 end
	
	 # create a new group
	def createGroup(name, description, adminId)
	 group = Group.create(:group_name => name, :group_description => description, :admin_id => adminId)
	rescue ActiveRecord::RecordInvalid => ri
	 return {:error => ri}
	rescue Exception => e
 self.fatalError e
 HARD_ERR
	else
	 group.toArray
	end
	
	 # create a new badge with given properties
	def createBadge(imageURL, name, description, authorId)
	 user = User.find(authorId)
	 badge = Badge.create(:image_url => imageURL, :badge_name => name, :badge_description => description, :author_id => user.id)
	rescue ActiveRecord::RecordInvalid => ri
	 return {:error => ri}
	rescue Exception => e
	 self.fatalError e
	 HARD_ERR
	else
	 badge.toArray
	end
	
	 # adds a user to the given group
	def addUserToGroup(userId, groupId)
	 user = User.find(userId)
	 group = Group.find(groupId)
	 user.groups << group
	 
	rescue ActiveRecord::RecordNotUnique => rnu
	 return {:error => "User already member of group."}
	rescue ActiveRecord::RecordNotFound
 return {:error => "User/group not found."}
 rescue Exception => e
 self.fatalError e
 return HARD_ERR
	else
	 return {:response => 'User added to group.', :user_id => userId, :group_id => groupId}
	end
	
	 # removes a given user from a given group
	def removeUserFromGroup(userId, groupId)
	 user = User.find(userId)
	 group = Group.find(groupId)
	 user.groups.delete(group)
	 rescue ActiveRecord::RecordNotFound
 return {:error => "User/group not found."}
 else
	 return {:response => 'User removed from group.', :user_id => userId, :group_id => groupId}
	end
end