ig3tool 0.3.0 → 0.4.0

data/lib/actions/bitching.rb

@@ -1,19 +0,0 @@
-require 'bitching'
-
-module Ig3tool
-	class Actions
-
-		def self.wannabe!(params)
-			username = params["username"] or raise Needed, "username"
-			password = params["password"] or raise Needed, "password"
-			Bitch.wannabe(username, password)
-		end
-		
-		def self.register!(params)
-			username = params["username"] or raise Needed, "username"
-			password = params["password"] or raise Needed, "password"
-			Bitch.wannabe(username, password)
-		end
-
-	end
-end

data/lib/actions/cultuur.rb

@@ -1,3 +0,0 @@
-module Ig3tool
-	# :)
-end

data/lib/actions/interne.rb

@@ -1,98 +0,0 @@
-require 'people'
-require 'interne'
-
-module Ig3tool
-	class Actions
-
-		def self.internes(params)
-			internes = {}
-			Interne.find(:all) \
-			       .sort { |a,b| a.person.username <=> b.person.username } \
-						 .each { |i| internes[i.person.username] = i.saldo }
-			internes
-		end
-
-		# Verwacht een 'username' in de URL
-		# Geeft saldo terug
-		def self.interne(params)
-			raise NeedDebugger unless params[:given_uri] == 1
-			name = params[:from_uri].first
-			_interne(name).saldo
-		end
-
-		# Toon de InterneTransactions
-		# Geen debugger-username -> Alles
-		# Debugger-username -> Donor + Recipient
-		def self.interne_log(params)
-			# XXX TODO
-			# Change from LogEntry to InterneTransaction
-			# MAAR:
-			# 	eerst nog zorgen dat alle transacties ivm interne (dus ook scribblen enzo) ook weergegeven worden
-			# 	voorlopig dus via LogEntry zodat je meer info hebt
-			name, max_lines = params[:from_uri]
-			max_lines = 500 if max_lines.nil?
-
-			if name
-				name = "%#{name}%"
-				LogEntry.find(:all, :conditions => ["system   = 'interne'  and 
-				                                    subsystem = 'transfer' and
-				                                    message like ?", name],
-				                    :order => "timestamp DESC",
-				                    :limit => max_lines)
-			else
-				LogEntry.find(:all, :order => "timestamp DESC",
-				                    :limit => max_lines)
-			end
-		end
-
-		# Verwacht in 'from','to' usernames
-		# Verwacht in 'saldo' een getal
-		# Geeft saldo terug.
-		def self.interne_transfer!(params)
-			from   = params['from']        or raise Needed, "source interne"
-			to     = params['to']          or raise Needed, "target interne"
-			amount = params['amount'].to_i or raise Needed, "amount"
-
-			if amount < 0 then
-				amount *= -1
-				from, to = to, from
-			end
-
-			raise IG3Error, "Having fun playing with yourself?"    if from == to
-			raise IG3Error, "No sense in transferring 0 credits.." if amount == 0
-
-			case
-				when from == "kas" # geld UIT de kassa
-					Logger::log :interne, :withdraw, '%s withdrew %.2f from kas' % [to, amount.to_f / 100]
-					_with_interne(to) { |s| s - amount }
-
-				when to == "kas"   # geld IN de kassa
-					Logger::log :interne, :deposit, '%s deposited %.2f in kas' % [from, amount.to_f / 100]
-					_with_interne(from) { |s| s + amount }
-
-				else
-					Logger::log :interne, :transfer, '%s transferred %.2f to %s' % [from, amount.to_f / 100, to]
-					Interne.transaction do
-						_with_interne(to)   { |s| s + amount }
-						_with_interne(from) { |s| s - amount }
-					end
-			end
-		end
-
-		private
-
-		def self._interne(name)
-			d = Person.find(name)
-			raise NotADebugger, name.to_s unless d.debugger?
-			d.interne
-		end
-
-		def self._with_interne(name)
-			i = _interne(name)
-			i.saldo = yield i.saldo
-			i.save
-			i.saldo
-		end
-
-	end
-end

data/lib/actions/kaching.rb

@@ -1,90 +0,0 @@
-require 'sales'
-require 'people'
-require 'interne'
-
-module Ig3tool
-	class Actions
-
-		# This one's for you, joris :P
-		def self.kaching_cola(params)
-			scribble(params.update({"items" => {"5449000000996" => 1}}))
-		end
-
-		# Verwacht een array van [barcode,aantal] in 'items'
-		# Verwacht een username in 'debugger'
-		# Geeft het nieuwe saldo terug
-		def self.scribble!(params)
-			name = params['debugger'] or raise Needed, "debugger"
-
-			interne = _interne(name) or raise NotADebugger, name
-			Product.transaction do
-				_kaching_log :scribble, name, params['items']
-				total = _kaching(params['items'], "debugger")
-				interne.saldo -= total
-				interne.save!
-				total
-			end
-		end
-
-		# Verwacht een hash van barcode => aantal in 'items'
-		# Optioneel een status in 'status'
-		# Geeft kost terug.
-		def self.kaching!(params)
-			Product.transaction do
-				total = _kaching(params['items'], params['status'] || "plebs")
-				_kaching_log :kaching, params['debugger'], params['items']
-				total
-			end
-		end
-
-		# Automaat bijvullen. 'items' zoals kaching, en 'debugger'
-		def self.product_restock!(params)
-			debugger = params['debugger']
-			items    = params['items']
-
-			Product.transaction do
-				total = _kaching(items, "plebs")
-				_kaching_log(:restock, debugger, items)
-				total
-			end
-		end
-
-		private
-
-		# Verwacht een hash van barcode => aantal en een status
-		# Past de stock aan, en geeft de kost terug.
-		def self._kaching(items, status)
-			cost = 0
-			raise Needed, "items" if items.nil? or items.empty?
-			Product.transaction do
-				items.each do |barcode, amount|
-					p = Product.find(barcode)
-					p.decrement_stock(amount)
-					cost += p.price(status, amount)
-				end
-
-				cost
-			end
-		rescue ActiveRecord::RecordNotFound => e
-			raise ProductNotFound, e.message[/ID=(.*)/]
-		end
-
-		def self._kaching_log(action, naam, items)
-			Product.transaction do
-				items.each do |barcode, amount|
-					p = Product.find(barcode)
-					raise IG3Error, "You did not enter a correct amount!" unless !amount.nil? and amount.integer? and amount > 0
-				action_lookup = { :kaching  => "sold",
-				                  :scribble => "scribbled",
-				                  :restock  => "restocked automaat with" }
-				action_str = action_lookup[action] or raise NotFound, "action"
-					Logger::log :sales, action, "%s %s %d %s" %
-					             [ naam, action_str, amount, p.name ]
-				end
-			end
-		rescue ActiveRecord::RecordNotFound => e
-			raise ProductNotFound, e.message[/ID=(.*)/]
-		end
-
-	end
-end

data/lib/actions/people.rb

@@ -1,178 +0,0 @@
-module Ig3tool
-  class Actions
-
-    STATUSSEN = { 0 => "non-member", 1 => "member", 2 => "honorary member", 3 => "debugger", 4 => "ex-debugger"}
-
-    # Methods om alle mensen op te vragen
-    singleton = class << self; self; end
-    %w(everybody nonmembers honorarymembers members debuggers).each do |k|
-      body = Proc.new do |params|
-        Person.send(k.to_sym)
-    end 
-
-      singleton.class_eval { define_method "person_#{k}", body}
-    end
-
-    # Zoekt persons op adhv attributes
-    # Verwacht minstens 1 key => value pair, kan meerdere mensen teruggeven.
-    # Mogelijke keys: username, email, first_name, last_name, rolnr, address, phone, gsm
-    def self.person_lookup(params)
-      raise Needed, "At least one search value"    if params[:given_uri] < 1
-      raise Needed, "Even number of search values" if params[:given_uri] % 2 == 1
-
-      keys   = params[:from_uri].to_h
-      status = keys.delete 'status'
-      valid_keys = %w(username email first_name last_name rolnr address phone gsm)
-      res = Person.hash_lookup(keys, valid_keys)
-
-      if status
-        return res.select {|x| x.send "#{status}?".to_sym }
-      else
-        return res
-      end
-    rescue RuntimeError => e
-      raise IG3Error, e.message
-    end
-
-    # Geeft de memberships van een persoon terug, gesorteerd op datum
-    # Verwacht een username.
-    def self.person_memberships(params)
-      raise Needed, "username" if params[:given_uri] != 1
-      Person.find(params[:from_uri].first).memberships.sort { |a,b| b.year <=> a.year }
-    end
-
-    # Returnt een persoon adhv een membership barcode
-    def self.person_member(params)
-      raise Needed, "memberid" if params[:given_uri] != 1
-      memberid = params[:from_uri].first
-      member = Membership.find_by_barcode(memberid)
-      raise NotAMember if member.nil?
-      Person.find(member.username) # Zoek het member, en return de persoon
-    end
-
-    # Verwijdert een member (indien mogelijk -> Geen openstaande leningen/niet-0-internes/...)
-    def self.person_remove!(params)
-      username = params["username"] or raise Needed, "username"
-
-      p = Person.find username
-
-      # Controleer Interne
-      i = p.interne
-      raise SaldoNotZero, "Debugger: saldo not zero!" if !i.nil? and i.saldo != 0
-
-      # Controleer leningen
-      p.memberships.each do |m|
-        unless m.nil?
-          loans = BibLoan.find_by_member_id m.id
-          raise StillHaveLoans, "Member: outstanding loans" unless loans.nil? or loans.empty?
-        end
-      end
-
-      begin
-        p.destroy
-      rescue ActiveRecord::RecordNotFound
-        raise NotFound, "Person"
-      else
-        :ok
-      end
-    end
-
-    # Returnt alle mogelijk statussen
-    def self.person_statussen(params)
-      STATUSSEN  # Return de Hash
-    end
-
-    # Voegt een persoon toe
-    def self.person_add!(params)
-      p = Person.new
-      p.username   = params['username'] or raise Needed, "Username"
-      p.email      = params['email'] or raise Needed, "Email"
-      p.first_name = params['first_name'] or raise Needed, "First_name"
-      p.last_name  = params['last_name'] or raise Needed, "Last_name"
-      p.rolnr   = params['rolnr']
-      p.address = params['address']
-      p.phone   = params['phone']
-      p.gsm     = params['gsm']
-
-      status   = params['status'] || "non-member"
-      memberid = params['memberid']
-      if status != "non-member"
-        m = Membership.new
-        m.barcode  = memberid
-        m.username = p.username
-        m.status   = status
-        m.year     = Time.werkjaar
-      end
-
-      pu = PrintUser.new
-      pu.saldo = 0
-
-      Person.transaction do
-        # Set username as latest because it calls save!
-        p.save!
-        pu.username = p.username
-        pu.save!
-        m.save! if status != "non-member"
-
-        pu.add_credit(200) if status == "member"
-        "OK"
-      end
-    end
-
-    # Update een persoon (adhv een id)
-    def self.person_update!(params)
-      raise Needed, "Username" unless params['username']
-      p = Person.find_by_username(params['username'])
-      raise NotFound if p.nil?
-      p.email      = params['email'] or raise Needed, "Email"
-      p.first_name = params['first_name'] or raise Needed, "First_name"
-      p.last_name  = params['last_name'] or raise Needed, "Last_name"
-      p.rolnr      = params['rolnr']
-      p.address    = params['address']
-      p.phone      = params['phone']
-      p.gsm        = params['gsm']
-      p.save!
-    end
-
-    def self.person_isdebugger(params)
-      raise Needed, "Username" unless params[:from_uri].size > 0
-      p = Person.find_by_username(params[:from_uri].first)
-      raise NotFound if p.nil?
-      p.debugger?
-    end
-
-    def self.person_status(params)
-      raise Needed, "Username" unless params[:from_uri].size > 0
-      p = Person.find_by_username(params[:from_uri].first)
-      raise NotFound if p.nil?
-      if p.debugger?
-        "debugger"
-      elsif p.member?
-        "member"
-      else 
-        "non-member"
-      end
-    end
-
-    def self.person_bugger!(params)
-      raise Needed, "Username" unless params['username']
-      p = Person.find_by_username(params['username'])
-      raise NotFound if p.nil?
-      raise NotAMember unless p.member?
-      raise IG3Error, "already a debugger" if p.debugger?
-
-      p.bugger!
-      "OK"
-    end
-
-    def self.person_unbugger!(params)
-      raise Needed, "Username" unless params['username']
-      p = Person.find_by_username(params['username'])
-      raise NotFound if p.nil?
-      raise NotADebugger unless p.debugger?
-
-      p.unbugger!
-      "OK"
-    end
-end
-end

data/lib/actions/printing.rb

@@ -1,125 +0,0 @@
-require 'people'
-require 'interne'
-require 'printing'
-
-module Ig3tool
-	class Actions
-
-		def self.print_users(params)
-			PrintUser.find(:all, :order => "username")
-		end
-
-    def self.print_debuggers(params)
-			users = PrintUser.find(:all, :order => "username")
-      users.select{|user| user.debugger?}
-    end
-
-		def self.print_logs(params)
-			max_lines = (params[:given_uri] < 1 ? 50 : params[:given_uri].first)
-			PrintTransaction.find(:all, :limit => max_lines, :order => "time DESC")
-		end
-
-		def self.print_user(params)
-			raise Needed, "username or alias" if params[:given_uri] < 1
-			username = params[:from_uri].first
-			PrintUser.lookup(username)
-		end
-
-		def self.print_remove!(params)
-			username = params["username"] or raise Needed, "username"
-			PrintUser.remove(username)
-		end
-
-		def self.print_addcredit!(params)
-			username = params["username"] or raise Needed, "username"
-			amount = params["amount"] or raise Needed, "amount"
-			pu = PrintUser.lookup(username) or raise NotFound, "username"
-			pu.add_credit(amount)
-			pu
-		end
-
-		def self.print_errortest(params)
-			PrintUser.errortest
-		end
-
-		def self.print_update!(params)
-			username = params["username"] or raise Needed, "username"
-			firstname = params["firstname"]
-			lastname = params["lastname"] 
-			email = params["email"]
-		  raise Needed, "at least one of: username, firstname, lastname" if lastname.nil? && firstname.nil? && email.nil?
-			amount = params["amount"] || 0
-			begin
-				p = Person.find(username) 
-			rescue
-				p =	Person.new
-				p.username = username
-		  	raise Needed, "username, firstname and lastname" if lastname.nil? && firstname.nil? && email.nil?
-			end
-			p.first_name = firstname unless firstname.nil?
-			p.last_name = lastname unless lastname.nil?
-			p.email = email unless email.nil?
-			p.save!
-			begin
-				pu = PrintUser.lookup(username) 
-			rescue NotFound => err
-				pu =	PrintUser.new
-				pu.username = username
-				pu.save!
-			end
-			pu.add_credit(amount) if amount.to_i.to_b
-			pu
-		end
-	
-		def self.print_refund!(params)
-			logid = params["logid"] or raise Needed, "logid"
-			begin
-				transaction = PrintTransaction.find(logid)
-				transaction.refund
-			rescue
-				raise TransactionNotFound, "this log id is not valid"
-			end
-		end
-
-		def self.print_print!(params)
-			username = params["username"] or raise Needed, "username"
-			job = params["job"] or raise Needed, "job"
-			pages = params["pages"] or raise Needed, "pages"
-			copies = params["copies"] or raise Needed, "copies"
-			host = params["host"] or raise Needed, "host"
-			amount = params["amount"] or raise Needed, "amount"
-			queue = params["queue"] or raise Needed, "queue"
-			message = params["message"] || ""
-			pu = PrintUser.lookup(username)
-			pu.print(job, pages, copies, host, amount, queue, message)
-		end
-
-		def self.print_addalias!(params)
-			username = params["username"] or raise Needed, "username"
-			nwalias = params["alias"] or raise Needed, "alias"
-			pu = PrintUser.find(username) # dit is eigenlijk overkill, lekker!
-			pa = PrintAlias.new
-			pa.username = username
-			pa.alias = nwalias
-			pa.save!
-		end
-
-		def self.print_removealias!(params)
-			username = params["username"] or raise Needed, "username"
-			a = params["alias"] or raise Needed, "alias"
-			pa = PrintAlias.find(a)
-			if pa.print_user.username == username
-				pa.destroy
-			else
-				raise NotFound, "wrong username"
-			end
-		end
-
-		def self.print_removealiases!(params)
-			username = params["username"] or raise Needed, "username"
-			pu = PrintUser.lookup(username).remove_aliases
-			pu
-		end
-
-	end
-end