ig3tool 0.1.0 → 0.2.0

data/lib/ldap.rb

@@ -0,0 +1,104 @@
+=begin
+
+beetje stuff om te authen naar ldap
+bvb: 
+	bitch?("joske", "dejoszijnpasswd")
+	=> true/false
+
+TODO: filteren op debugger!
+
+=end
+
+require 'mymd5'
+
+begin
+
+	require "ldap"
+
+	class IGLDAP < LDAP::Conn
+		DN = "cn=Proxyuser,dc=infogroep,dc=be"
+		PASS = "pRoxyAuth"
+		BASE_DN = "dc=infogroep,dc=be"
+		PEOPLE_DN = "ou=People,dc=infogroep,dc=be"
+		LDAP_HOST = "infogroep.be"
+		LDAP_PORT = 389
+		PROTOCOL_VERSION = 3
+
+		def initialize (host = LDAP_HOST, version = PROTOCOL_VERSION)
+			super( host, LDAP_PORT )
+			set_option( LDAP::LDAP_OPT_PROTOCOL_VERSION, version )
+			return self
+		end
+
+		def bind(dn = DN, pass = PASS)
+			super( dn, pass )
+		end
+
+		def self.bitchke?(user, pass)
+			begin
+				conn = IGLDAP.new.bind
+				attrs = %w{uid userPassword}
+				filter = "uid=#{user}"
+				result = conn.search2(IGLDAP::PEOPLE_DN, LDAP::LDAP_SCOPE_SUBTREE,filter, attrs)
+
+				passr = result.first["userPassword"].first.gsub(/\{crypt\}/, "")
+
+
+				match = passr.match(/(\$.+\$.+\$)(.*)/)
+				#salt = match[1]
+				salt = match[1].gsub(/\$1\$/, "").delete("$")
+				passh = match[2]
+				#pass.crypt(salt) == passr
+				crypt(pass, :md5, salt) == passr
+			rescue Exception => e
+				false
+			end
+		end
+
+	end
+
+rescue
+
+	require 'net/ldap'
+	include Net
+
+	class IGLDAP
+		DN = "cn=Proxyuser,dc=infogroep,dc=be"
+		PASS = "pRoxyAuth"
+		BASE_DN = "dc=infogroep,dc=be"
+		PEOPLE_DN = "ou=People,dc=infogroep,dc=be"
+		LDAP_HOST = "infogroep.be"
+		LDAP_PORT = 389
+		PROTOCOL_VERSION = 3
+
+		def initialize
+			@conn = Net::LDAP.new( {:host => LDAP_HOST, :port => LDAP_PORT, :auth => { :method => :simple, :username => DN, :password => PASS }} )
+		end
+
+		def bind
+			@conn.bind
+			@conn
+		end
+
+		def self.bitchke?(user, pass)
+			begin
+				conn = IGLDAP.new.bind
+				attrs = %w{uid userPassword}
+				filter = "uid=#{user}"
+				result = conn.search(:base => PEOPLE_DN, :filter => filter)
+
+				passr = result.first["userPassword"].first.gsub(/\{crypt\}/, "")
+
+				match = passr.match(/(\$.+\$.+\$)(.*)/)
+				salt = match[1].gsub(/\$1\$/, "").delete("$")
+				#salt = match[1]
+				passh = match[2]
+				crypt(pass, :md5, salt) == passr
+				#pass.crypt(salt) == passr
+			rescue Exception => e
+				false
+			end
+		end
+
+	end
+end

data/lib/log.rb

@@ -0,0 +1,25 @@
+module Ig3tool
+
+	class LogEntry < ActiveRecord::Base
+
+		set_table_name "log"
+
+		validates_presence_of :system,
+		                      :subsystem,
+		                      :timestamp,
+		                      :message
+
+	end
+
+	class Logger
+
+		def self.log(system, subsystem, message)
+			LogEntry.create(:system    => system.to_s,
+			                :timestamp => Time.now.to_i,
+			                :subsystem => subsystem.to_s,
+			                :message   => message.to_s)
+		end
+
+	end
+
+end

data/lib/membership.rb

@@ -0,0 +1,32 @@
+module Ig3tool
+  class Membership < ActiveRecord::Base
+		set_table_name "Memberships"
+		set_nonauto_primary_key :barcode
+		
+		validates_uniqueness_of :barcode
+		
+		validates_presence_of :barcode, 
+		                      :username, 
+		                      :year, 
+		                      :status
+		
+		validates_inclusion_of :status, 
+		                       :in => ["debugger", 
+		                               "ex-debugger", 
+		                               "member", 
+		                               "honorary member"]
+    
+		belongs_to :person, 
+		           :class_name => "Person", 
+		           :foreign_key => "username"
+
+		def self.member?(barcode)
+			begin
+				membership = find(barcode)
+				membership.year == Time.werkjaar
+			rescue ActiveRecord::RecordNotFound
+				false
+			end
+		end
+  end
+end

data/lib/mymd5.rb

@@ -0,0 +1,95 @@
+require 'English'
+require 'base64'
+require 'md5'
+require 'sha1'
+
+ITOA64	=	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+
+def crypt(password, algo = :md5, salt = nil, magic='$1$')
+
+   salt ||= generate_salt(8)
+   
+   case algo
+     when :md5, :sha1, :rmd160
+       require "digest/#{algo}"
+     when :sha256, :sha384, :sha512
+       require "digest/sha2"
+     else
+       raise(ArgumentError, "unknown algorithm")
+   end
+   digest_class = Digest.const_get(algo.to_s.upcase)
+   
+   # The password first, since that is what is most unknown. Then our magic string. Then the raw salt.
+   m = digest_class.new
+   m.update(password + magic + salt)
+
+   # Then just as many characters of the MD5(pw,salt,pw)
+   mixin = digest_class.new.update(password + salt + password).digest
+   password.length.times do |i|
+     m.update(mixin[i % 16].chr)
+   end
+
+   # Then something really weird...
+   # Also really broken, as far as I can tell.  -m
+   i = password.length
+   while i != 0
+     if (i & 1) != 0
+       m.update("\x00")
+     else
+       m.update(password[0].chr)
+     end
+     i >>= 1
+   end
+
+   final = m.digest
+
+   # and now, just to make sure things don't run too fast
+   1000.times do |i|
+     m2 = digest_class.new
+
+     if (i & 1) != 0 
+       m2.update(password) 
+     else
+       m2.update(final)
+     end
+
+     if (i % 3) != 0 
+       m2.update(salt)
+     end
+     if (i % 7) != 0 
+       m2.update(password) 
+     end
+     
+     if (i & 1) != 0 
+       m2.update(final) 
+     else
+       m2.update(password)
+     end
+
+     final = m2.digest
+   end
+
+   # This is the bit that uses to64() in the original code.
+
+   rearranged = ""
+
+   [ [0, 6, 12], [1, 7, 13], [2, 8, 14], [3, 9, 15], [4, 10, 5] ].each do |a, b, c|
+
+     v = final[a] << 16 | final[b] << 8 | final[c]
+
+     4.times do
+       rearranged += ITOA64[v & 0x3f].chr
+       v >>= 6 
+     end
+   end
+
+   v = final[11]
+
+   2.times do
+     rearranged += ITOA64[v & 0x3f].chr
+     v >>= 6
+   end
+
+   magic + salt + '$' + rearranged
+ end

data/lib/people.rb

@@ -0,0 +1,143 @@
+require 'utils'
+
+module Ig3tool
+
+	class Person < ActiveRecord::Base
+
+		set_table_name "people"
+		set_nonauto_primary_key :username
+
+		# XXX wat willen we dat aanwezig is?
+		validates_presence_of :username, 
+		                      :email,
+		                      :first_name,
+		                      :last_name
+
+		validates_uniqueness_of :username,
+		                        :email
+
+		has_one :interne,
+		        :class_name => "Interne",
+		        :foreign_key => "username"
+
+#     breekt horribly met to_yaml, zucht
+#     has_one :membership, 
+#             :conditions => ["year = ?", Time.werkjaar],
+#             :class_name => 'Membership',
+#             :foreign_key => "username"
+
+		has_many :memberships, 
+		         :class_name => "Membership",
+		         :foreign_key => "username",
+		         :order => "year desc" 
+
+		has_one :print_user,
+						:class_name => "PrintUser",
+						:foreign_key => "username"
+						# :dependent => :destroy # destroyes printuser when person gets deleted
+						# XXX do we want that?
+
+		def membership
+			if !memberships.empty? and memberships[0].year == Time.werkjaar
+				memberships[0]
+			else
+				nil
+			end
+		end
+
+		def username=(newusername)
+			write_attribute(:username, newusername)
+		end
+
+		def member?
+			not membership.nil?
+		end
+
+		def honorarymember?
+			member? and membership.status == "honorary member"
+		end
+
+		def exhonorarymember?
+			not honorarymember? and not memberships.find(:all).find_all{|m| m.status == "honorary member"}.empty?
+		end
+
+		def debugger?
+			(not interne.nil?) and (interne.afgesloten != 1) and member? and (membership.status == "debugger")
+		end
+
+		def exdebugger?
+			(not debugger?) and (not memberships.find(:all).find_all{|m| m.status == "debugger" or m.status == "ex-debugger"}.empty?)
+		end
+
+		def self.everybody
+			find(:all)
+		end
+
+		def self.members
+			find(:all).find_all{|p| p.member?}
+		end
+
+		def self.nonmembers
+			find(:all).find_all{|p| p.membership.nil?}
+		end
+
+		def self.debuggers
+			find(:all).find_all{|p| p.debugger?}
+		end
+
+		def self.exdebuggers
+			find(:all).find_all{|p| p.exdebugger?}
+		end
+
+		def self.honorarymembers
+			find(:all).find_all{|p| p.honorarymember?}
+		end
+		
+		def self.exhonorarymembers
+			find(:all).find_all{|p| p.exhonorarymember?}
+		end
+
+		def unbugger!
+			raise NotADebugger unless debugger?
+			raise SaldoNotZero if interne.saldo != 0
+
+			interne.afgesloten = true
+			membership.status = "member"
+
+			transaction do
+				print_user.remove_aliases
+
+				membership.save!
+				interne.save!
+			end
+		end
+
+    def bugger!
+			raise NotAMember unless member?
+			raise IG3Error, "already a debugger" if debugger?
+
+			membership.status = "debugger"
+
+			# interne
+			self.interne = i = Interne.new
+			i.username = username
+			i.saldo = 0
+			i.afgesloten = false
+
+			transaction do
+				# centjes overzetten
+				if print_user.saldo > 0
+					i.deposit("printaccount", print_user.saldo, "printkrediet")
+					# XXX print krediet?
+					# print_user.saldo = 0
+				end
+
+				membership.save!
+				i.save!
+			end
+    end
+
+	end
+
+
+end

data/lib/printing.rb

@@ -0,0 +1,238 @@
+module Ig3tool
+
+	#   The printing section of ig3tool
+	#   
+	#   Classes & methods:
+	#  
+	#   PrintUser
+	#   ---------
+	#   	lookup(username) 
+	#   		looks for a printuser by username as well as alias
+	#   		use this method to look usernames up
+	#  
+	#  		add_credit(amount)
+	#  			adds amount of credit to a user' saldo
+	#  
+	#  		refund(amount, printid, msg)
+	#  			refunds a failed job
+	#  			should ONLY be called from PrintTransaction
+	#
+	#  		remove(username)
+	#  		  removes a printuser along its aliasses
+	#  
+	#   	print(job, pages, copies, host, amount, queue, message)
+	#   		handles the printing of a job
+	#   		should ONLY be used by the printscript
+	#  
+	#   	err(queue, message)
+	#   		logs an error
+	#   		again printscript ONLY
+	#  
+	#  
+	#  
+	#   PrintAlias
+	#   ----------
+	#   	no special functions
+	#  
+	#  
+	#  
+	#   PrintTransaction
+	#   ----------------
+	#   	refund()
+	#   		refunds a specific job, calls aprintuser.refund()
+	#   
+	#   
+	#   
+
+
+
+
+	# Implements a printuser.
+	class PrintUser < ActiveRecord::Base
+
+		set_table_name "print_users"
+		set_nonauto_primary_key :username
+		validates_uniqueness_of :username
+
+		# _username_ and _saldo_ must be provided
+		# a PrintUser must be linked with an existing _person_
+		validates_presence_of :username, :saldo, :person
+		belongs_to :person, :class_name => "Person", :foreign_key => "username"
+		has_many :print_transactions, :class_name => "PrintTransaction", :foreign_key => "username"
+		has_many :print_aliases, :class_name => "PrintAlias", :foreign_key => "username", :dependent => :destroy
+		attr_accessible	:username
+		validates_associated :person
+
+		# override because of non-standard primary key	
+		def username=(newusername)
+			write_attribute(:username, newusername)
+			save!
+		end
+
+		def self.lookup(username)
+			user = nil
+			begin
+				user = PrintUser.find(username) # Error if not found
+			rescue
+				begin
+					user = PrintAlias.find(username).print_user
+				rescue
+					raise NotFound, "the ig3tool imps found no such user..."
+				end
+			end
+			user
+		end
+
+		def self.errortest
+			raise NotFound
+		end
+
+		def remove_aliases
+			print_aliases.each {|pa| pa.destroy }
+		end
+
+		def self.remove(username)
+			user = PrintUser.lookup(username)
+			user.destroy
+		end
+
+		def email
+			self.person.email
+		end
+
+		def debugger?
+			self.person.debugger?
+		end
+
+		def add_credit (amount)
+			if self.debugger? 
+        raise PermissionDenied, "debuggers cannot add credits to their account..."
+      else
+				PrintUser.transaction do
+					reload()
+					PrintTransaction.new do |pt|
+						pt.time = Time.now()
+						pt.username = username
+						pt.refunded = 0
+						pt.amount = amount.to_i
+						pt.queue = "ig3tool" 
+						pt.message = "added #{amount} eurocents to #{username}'s account."
+						pt.category = "add"
+						pt.save!
+					end
+					self.saldo += amount.to_i
+					save!
+				end
+			end
+		end
+
+		def refund(amount, printid, undo, msg)
+			PrintUser.transaction do
+				reload()
+				pt = PrintTransaction.new
+				pt.time = Time.now()
+				pt.username = username
+				pt.refunded = 0
+				pt.queue = "ig3tool"
+				pt.amount = amount.to_i
+				pt.message = "#{"undo " if undo}refunded print #{printid} of #{amount} euro to #{username}."
+				pt.category = "refund"
+				pt.save!
+				if debugger?
+					person.interne.refundprint(amount, "#{"undo " if undo }refund print, id: #{printid}", undo)
+				else
+					if undo
+						self.saldo += amount
+					else
+						self.saldo -= amount
+					end
+					save!
+				end
+			end
+		end
+
+		def print(job, pages, copies, host, amount, queue, message)
+			PrintUser.transaction do
+				reload()
+				PrintTransaction.new do |pt|
+					pt.time = Time.now()
+					pt.username = username
+					pt.refunded = 0
+					pt.amount = amount.to_i 
+					pt.pages = pages.to_i
+					pt.copies = copies.to_i
+					pt.host = host
+					pt.queue = queue
+					pt.job = job
+					pt.message = "Printed #{job} of #{pages} pages for #{amount} EUR - #{message}" 
+					pt.category = "print"
+					pt.save!
+				end
+				if debugger?
+					person.interne.print(amount, "job: #{job}")
+				else
+					if self.saldo < amount.to_i
+						raise NotEnoughCredit, "you are broke!"
+					else
+						self.saldo -= amount.to_i
+						save!
+					end
+				end
+			end
+		end
+
+
+		def err(message, queue)
+			PrintTransaction.new do |pt|
+				pt.time = Time.now()
+				pt.username = username
+				pt.queue = queue
+				pt.category = "error"
+				pt.save!
+			end
+		end
+
+	end
+
+
+	class PrintAlias < ActiveRecord::Base
+
+		set_table_name "print_aliases"
+		set_primary_key :alias
+		validates_uniqueness_of :alias
+		validates_presence_of :alias, :username, :print_user
+		belongs_to :print_user, :class_name => "PrintUser", :foreign_key => "username"
+		validates_associated :print_user
+
+		def alias=(newalias)
+			@attributes["alias"] = newalias
+		end
+
+	end
+
+
+	class PrintTransaction < ActiveRecord::Base
+
+		set_table_name "print_transactions"
+		validates_presence_of :time, :username, :category, :queue
+		validates_inclusion_of :category, :in => ["error", "add", "print", "refund", "debug"]
+		belongs_to :printuser, :class_name => "PrintUser", :foreign_key => "username"
+		attr_protected :refunded
+
+		def refund
+			PrintTransaction.transaction do
+				reload()
+				if category == "print" then
+					printuser.refund(amount, id, !refunded.to_b, message)
+					toggle!(:refunded)
+				else
+					raise WrongPrintlogType
+				end
+			end
+		end
+
+	end  # class PrintTransaction
+
+
+
+end # module Ig3tool