4 # :title: rbot auth management from IRC
\r
6 # Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
\r
7 # Copyright:: (C) 2006,2007 Giuseppe Bilotta
\r
10 class AuthModule < CoreBotModule
\r
15 # The namespace migration causes each Irc::Auth::PermissionSet to be
\r
16 # unrecoverable, and we have to rename their class name to
\r
17 # Irc::Bot::Auth::PermissionSet
\r
18 @registry.recovery = Proc.new { |val|
\r
19 patched = val.sub("o:\035Irc::Auth::PermissionSet", "o:\042Irc::Bot::Auth::PermissionSet")
\r
20 Marshal.restore(patched)
\r
23 load_array(:default, true)
\r
24 debug "initialized auth. Botusers: #{@bot.auth.save_array.pretty_inspect}"
\r
31 def save_array(key=:default)
\r
32 if @bot.auth.changed?
\r
33 @registry[key] = @bot.auth.save_array
\r
34 @bot.auth.reset_changed
\r
35 debug "saved botusers (#{key}): #{@registry[key].pretty_inspect}"
\r
39 def load_array(key=:default, forced=false)
\r
40 debug "loading botusers (#{key}): #{@registry[key].pretty_inspect}"
\r
41 @bot.auth.load_array(@registry[key], forced) if @registry.has_key?(key)
\r
44 # The permission parameters accept arguments with the following syntax:
\r
45 # cmd_path... [on #chan .... | in here | in private]
\r
46 # This auxiliary method scans the array _ar_ to see if it matches
\r
47 # the given syntax: it expects + or - signs in front of _cmd_path_
\r
48 # elements when _setting_ = true
\r
50 # It returns an array whose first element is the array of cmd_path,
\r
51 # the second element is an array of locations and third an array of
\r
52 # warnings occurred while parsing the strings
\r
54 def parse_args(ar, setting)
\r
59 next_must_be_chan = false
\r
62 ar.each_with_index { |x, i|
\r
63 if doing_cmds # parse cmd_path
\r
64 # check if the list is done
\r
65 if x == "on" or x == "in"
\r
67 next_must_be_chan = true if x == "on"
\r
70 if "+-".include?(x[0])
\r
71 warns << ArgumentError.new(_("please do not use + or - in front of command %{command} when resetting") % {:command => x}) unless setting
\r
73 warns << ArgumentError.new(_("+ or - expected in front of %{string}") % {:string => command}) if setting
\r
76 else # parse locations
\r
82 case next_must_be_chan
\r
84 locs << x.gsub(/^here$/,'_').gsub(/^private$/,'?')
\r
86 warns << ArgumentError.new(_("'%{string}' doesn't look like a channel name") % {:string => x}) unless @bot.server.supports[:chantypes].include?(x[0])
\r
95 warns << _("trailing comma") if want_more
\r
96 warns << _("you probably forgot a comma") unless last_idx == ar.length - 1
\r
97 return cmds, locs, warns
\r
100 def auth_edit_perm(m, params)
\r
102 setting = m.message.split[1] == "set"
\r
103 splits = params[:args]
\r
105 has_for = splits[-2] == "for"
\r
106 return usage(m) unless has_for
\r
109 user = @bot.auth.get_botuser(splits[-1].sub(/^all$/,"everyone"))
\r
111 return m.reply(_("couldn't find botuser %{name}") % {:name => splits[-1]})
\r
113 return m.reply(_("you can't change permissions for %{username}") % {:username => user.username}) if user.owner?
\r
114 splits.slice!(-2,2) if has_for
\r
116 cmds, locs, warns = parse_args(splits, setting)
\r
117 errs = warns.select { |w| w.kind_of?(Exception) }
\r
120 m.reply _("couldn't satisfy your request: %{errors}") % {:errors => errs.join(',')}
\r
131 ch = "?" if loc == "_"
\r
133 ch = m.target.to_s if loc == "_"
\r
135 cmds.each { |setval|
\r
137 val = setval[0].chr == '+'
\r
138 cmd = setval[1..-1]
\r
139 user.set_permission(cmd, val, ch)
\r
142 user.reset_permission(cmd, ch)
\r
147 m.reply "something went wrong while trying to set the permissions"
\r
150 @bot.auth.set_changed
\r
151 debug "user #{user} permissions changed"
\r
155 def auth_view_perm(m, params)
\r
157 if params[:user].nil?
\r
158 user = get_botusername_for(m.source)
\r
159 return m.reply(_("you are owner, you can do anything")) if user.owner?
\r
161 user = @bot.auth.get_botuser(params[:user].sub(/^all$/,"everyone"))
\r
162 return m.reply(_("owner can do anything")) if user.owner?
\r
165 return m.reply(_("couldn't find botuser %{name}") % {:name => params[:user]})
\r
169 perm.each { |k, val|
\r
170 next if val.perm.empty?
\r
173 str << _("on any channel: ")
\r
175 str << _("in private: ")
\r
177 str << _("on #{k}: ")
\r
180 val.perm.each { |cmd, bool|
\r
181 sub << (bool ? "+" : "-")
\r
182 sub.last << cmd.to_s
\r
184 str.last << sub.join(', ')
\r
187 m.reply _("no permissions set for %{user}") % {:user => user.username}
\r
189 m.reply _("permissions for %{user}:: %{permissions}") %
\r
190 { :user => user.username, :permissions => str.join('; ')}
\r
194 def get_botuser_for(user)
\r
195 @bot.auth.irc_to_botuser(user)
\r
198 def get_botusername_for(user)
\r
199 get_botuser_for(user).username
\r
203 _("welcome, %{user}") % {:user => get_botusername_for(user)}
\r
206 def auth_auth(m, params)
\r
207 params[:botuser] = 'owner'
\r
208 auth_login(m,params)
\r
211 def auth_login(m, params)
\r
213 case @bot.auth.login(m.source, params[:botuser], params[:password])
\r
215 m.reply welcome(m.source)
\r
216 @bot.auth.set_changed
\r
218 m.reply _("sorry, can't do")
\r
221 m.reply _("couldn't login: %{exception}") % {:exception => e}
\r
226 def auth_autologin(m, params)
\r
227 u = do_autologin(m.source)
\r
229 m.reply _("I couldn't find anything to let you login automatically")
\r
231 m.reply welcome(m.source)
\r
235 def do_autologin(user)
\r
236 @bot.auth.autologin(user)
\r
239 def auth_whoami(m, params)
\r
240 m.reply _("you are %{who}") % {
\r
241 :who => get_botusername_for(m.source).gsub(
\r
242 /^everyone$/, _("no one that I know")).gsub(
\r
243 /^owner$/, _("my boss"))
\r
247 def auth_whois(m, params)
\r
248 return auth_whoami(m, params) if !m.public?
\r
249 u = m.channel.users[params[:user]]
\r
251 return m.reply "I don't see anyone named '#{params[:user]}' here" unless u
\r
253 m.reply _("#{params[:user]} is %{who}") % {
\r
254 :who => get_botusername_for(u).gsub(
\r
255 /^everyone$/, _("no one that I know")).gsub(
\r
256 /^owner$/, _("my boss"))
\r
260 def help(cmd, topic="")
\r
263 return _("login [<botuser>] [<pass>]: logs in to the bot as botuser <botuser> with password <pass>. When using the full form, you must contact the bot in private. <pass> can be omitted if <botuser> allows login-by-mask and your netmask is among the known ones. if <botuser> is omitted too autologin will be attempted")
\r
265 return _("whoami: names the botuser you're linked to")
\r
267 return _("who is <user>: names the botuser <user> is linked to")
\r
271 return _("a permission is specified as module::path::to::cmd; when you want to enable it, prefix it with +; when you want to disable it, prefix it with -; when using the +reset+ command, do not use any prefix")
\r
272 when "set", "reset", "[re]set", "(re)set"
\r
273 return _("permissions [re]set <permission> [in <channel>] for <user>: sets or resets the permissions for botuser <user> in channel <channel> (use ? to change the permissions for private addressing)")
\r
275 return _("permissions view [for <user>]: display the permissions for user <user>")
\r
277 return _("permission topics: syntax, (re)set, view")
\r
282 return _("user show <what> : shows info about the user; <what> can be any of autologin, login-by-mask, netmasks")
\r
283 when /^(en|dis)able/
\r
284 return _("user enable|disable <what> : turns on or off <what> (autologin, login-by-mask)")
\r
286 return _("user set password <blah> : sets the user password to <blah>; passwords can only contain upper and lowercase letters and numbers, and must be at least 4 characters long")
\r
288 return _("user add|rm netmask <mask> : adds/removes netmask <mask> from the list of netmasks known to the botuser you're linked to")
\r
290 return _("user reset <what> : resets <what> to the default values. <what> can be +netmasks+ (the list will be emptied), +autologin+ or +login-by-mask+ (will be reset to the default value) or +password+ (a new one will be generated and you'll be told in private)")
\r
292 return _("user tell <who> the password for <botuser> : contacts <who> in private to tell him/her the password for <botuser>")
\r
294 return _("user create <name> <password> : create botuser named <name> with password <password>. The password can be omitted, in which case a random one will be generated. The <name> should only contain alphanumeric characters and the underscore (_)")
\r
296 return _("user list : lists all the botusers")
\r
298 return _("user destroy <botuser> <password> : destroys <botuser>; this function %{highlight}must%{highlight} be called in two steps. On the first call, no password must be specified: <botuser> is then queued for destruction. On the second call, you must specify the correct password for <botuser>, and it will be destroyed. If you want to cancel the destruction, issue the command +user cancel destroy <botuser>+") % {:highlight => Bold}
\r
300 return _("user topics: show, enable|disable, add|rm netmask, set, reset, tell, create, list, destroy")
\r
303 return _("auth <masterpassword>: log in as the bot owner; other commands: login, whoami, permission syntax, permissions [re]set, permissions view, user")
\r
305 return _("auth commands: auth, login, whoami, who, permission[s], user")
\r
310 _("sorry, I need more arguments to %{command}") % {:command => cmd}
\r
313 def not_args(cmd, *stuff)
\r
314 _("I can only %{command} these: %{arguments}") %
\r
315 {:command => cmd, :arguments => stuff.join(', ')}
\r
318 def set_prop(botuser, prop, val)
\r
319 k = prop.to_s.gsub("-","_")
\r
320 botuser.send( (k + "=").to_sym, val)
\r
321 if prop == :password and botuser == @bot.auth.botowner
\r
322 @bot.config.items[:'auth.password'].set_string(@bot.auth.botowner.password)
\r
326 def reset_prop(botuser, prop)
\r
327 k = prop.to_s.gsub("-","_")
\r
328 botuser.send( ("reset_"+k).to_sym)
\r
331 def ask_bool_prop(botuser, prop)
\r
332 k = prop.to_s.gsub("-","_")
\r
333 botuser.send( (k + "?").to_sym)
\r
336 def auth_manage_user(m, params)
\r
337 splits = params[:data]
\r
340 return auth_whoami(m, params) if cmd.nil?
\r
342 botuser = get_botuser_for(m.source)
\r
343 # By default, we do stuff on the botuser the irc user is bound to
\r
346 has_for = splits[-2] == "for"
\r
348 butarget = @bot.auth.get_botuser(splits[-1]) rescue nil
\r
349 return m.reply(_("no such bot user %{user}") % {:user => splits[-1]}) unless butarget
\r
350 splits.slice!(-2,2)
\r
352 return m.reply(_("you can't mess with %{user}") % {:user => butarget.username}) if butarget.owner? && botuser != butarget
\r
354 bools = [:autologin, :"login-by-mask"]
\r
355 can_set = [:password]
\r
356 can_addrm = [:netmasks]
\r
357 can_reset = bools + can_set + can_addrm
\r
358 can_show = can_reset + ["perms"]
\r
363 return m.reply(_("you can't see the properties of %{user}") %
\r
364 {:user => butarget.username}) if botuser != butarget &&
\r
365 !botuser.permit?("auth::show::other")
\r
371 if botuser != butarget
\r
372 return m.reply(_("no way I'm telling you the master password!")) if butarget == @bot.auth.botowner
\r
373 return m.reply(_("you can't ask for someone else's password"))
\r
375 return m.reply(_("c'mon, you can't be asking me seriously to tell you the password in public!")) if m.public?
\r
376 return m.reply(_("the password for %{user} is %{password}") %
\r
377 { :user => butarget.username, :password => butarget.password })
\r
379 props = splits[1..-1]
\r
386 next if k == :password
\r
389 if ask_bool_prop(butarget, k)
\r
390 str << _("can %{action}") % {:action => k}
\r
392 str << _("can not %{action}") % {:action => k}
\r
395 if butarget.netmasks.empty?
\r
396 str << _("knows no netmasks")
\r
398 str << _("knows %{netmasks}") % {:netmasks => butarget.netmasks.join(", ")}
\r
402 return m.reply("#{butarget.username} #{str.join('; ')}")
\r
404 when :enable, :disable
\r
405 return m.reply(_("you can't change the default user")) if butarget.default? && !botuser.permit?("auth::edit::other::default")
\r
406 return m.reply(_("you can't edit %{user}") % {:user => butarget.username}) if butarget != botuser && !botuser.permit?("auth::edit::other")
\r
408 return m.reply(need_args(cmd)) unless splits[1]
\r
411 splits[1..-1].each { |a|
\r
413 if bools.include?(arg)
\r
414 set_prop(butarget, arg, cmd.to_sym == :enable)
\r
421 m.reply(_("I ignored %{things} because %{reason}") % {
\r
422 :things => skipped.join(', '),
\r
423 :reason => not_args(cmd, *bools)}) unless skipped.empty?
\r
425 m.reply _("I haven't changed anything")
\r
427 @bot.auth.set_changed
\r
428 return auth_manage_user(m, {:data => ["show"] + things + ["for", butarget.username] })
\r
432 return m.reply(_("you can't change the default user")) if
\r
433 butarget.default? && !botuser.permit?("auth::edit::default")
\r
434 return m.reply(_("you can't edit %{user}") % {:user=>butarget.username}) if
\r
435 butarget != botuser && !botuser.permit?("auth::edit::other")
\r
437 return m.reply(need_args(cmd)) unless splits[1]
\r
438 arg = splits[1].to_sym
\r
439 return m.reply(not_args(cmd, *can_set)) unless can_set.include?(arg)
\r
441 return m.reply(need_args([cmd, splits[1]].join(" "))) unless argarg
\r
442 if arg == :password && m.public?
\r
443 return m.reply(_("is that a joke? setting the password in public?"))
\r
445 set_prop(butarget, arg, argarg)
\r
446 @bot.auth.set_changed
\r
447 auth_manage_user(m, {:data => ["show", arg, "for", butarget.username] })
\r
450 return m.reply(_("you can't change the default user")) if
\r
451 butarget.default? && !botuser.permit?("auth::edit::default")
\r
452 return m.reply(_("you can't edit %{user}") % {:user=>butarget.username}) if
\r
453 butarget != botuser && !botuser.permit?("auth::edit::other")
\r
455 return m.reply(need_args(cmd)) unless splits[1]
\r
458 splits[1..-1].each { |a|
\r
460 if can_reset.include?(arg)
\r
461 reset_prop(butarget, arg)
\r
468 m.reply(_("I ignored %{things} because %{reason}") %
\r
469 { :things => skipped.join(', '),
\r
470 :reason => not_args(cmd, *can_reset)}) unless skipped.empty?
\r
472 m.reply _("I haven't changed anything")
\r
474 @bot.auth.set_changed
\r
475 @bot.say(m.source, _("the password for %{user} is now %{password}") %
\r
476 {:user => butarget.username, :password => butarget.password}) if
\r
477 things.include?("password")
\r
478 return auth_manage_user(m, {:data => (["show"] + things - ["password"]) + ["for", butarget.username]})
\r
481 when :add, :rm, :remove, :del, :delete
\r
482 return m.reply(_("you can't change the default user")) if
\r
483 butarget.default? && !botuser.permit?("auth::edit::default")
\r
484 return m.reply(_("you can't edit %{user}") % {:user => butarget.username}) if
\r
485 butarget != botuser && !botuser.permit?("auth::edit::other")
\r
488 if arg.nil? or arg !~ /netmasks?/ or splits[2].nil?
\r
489 return m.reply(_("I can only add/remove netmasks. See +help user add+ for more instructions"))
\r
492 method = cmd.to_sym == :add ? :add_netmask : :delete_netmask
\r
496 splits[2..-1].each { |mask|
\r
498 butarget.send(method, mask.to_irc_netmask(:server => @bot.server))
\r
500 debug "failed with #{e.message}"
\r
501 debug e.backtrace.join "\n"
\r
505 m.reply "I failed to #{cmd} #{failed.join(', ')}" unless failed.empty?
\r
506 @bot.auth.set_changed
\r
507 return auth_manage_user(m, {:data => ["show", "netmasks", "for", butarget.username] })
\r
510 m.reply _("sorry, I don't know how to %{request}") % {:request => m.message}
\r
514 def auth_tell_password(m, params)
\r
515 user = params[:user]
\r
517 botuser = @bot.auth.get_botuser(params[:botuser])
\r
519 return m.reply(_("couldn't find botuser %{user}") % {:user => params[:botuser]})
\r
521 m.reply(_("I'm not telling the master password to anyway, pal")) if botuser == @bot.auth.botowner
\r
522 msg = _("the password for botuser %{user} is %{password}") %
\r
523 {:user => botuser.username, :password => botuser.password}
\r
525 @bot.say m.source, _("I told %{user} that %{message}") % {:user => user, :message => msg}
\r
528 def auth_create_user(m, params)
\r
529 name = params[:name]
\r
530 password = params[:password]
\r
531 return m.reply(_("are you nuts, creating a botuser with a publicly known password?")) if m.public? and not password.nil?
\r
533 bu = @bot.auth.create_botuser(name, password)
\r
534 @bot.auth.set_changed
\r
536 m.reply(_("failed to create %{user}: %{exception}") % {:user => name, :exception => e})
\r
537 debug e.inspect + "\n" + e.backtrace.join("\n")
\r
540 m.reply(_("created botuser %{user}") % {:user => bu.username})
\r
543 def auth_list_users(m, params)
\r
544 # TODO name regexp to filter results
\r
545 list = @bot.auth.save_array.inject([]) { |list, x| ['everyone', 'owner'].include?(x[:username]) ? list : list << x[:username] }
\r
546 if defined?(@destroy_q)
\r
548 @destroy_q.include?(x) ? x + _(" (queued for destruction)") : x
\r
551 return m.reply(_("I have no botusers other than the default ones")) if list.empty?
\r
552 return m.reply(n_("botuser: %{list}", "botusers: %{list}", list.length) %
\r
553 {:list => list.join(', ')})
\r
556 def auth_destroy_user(m, params)
\r
557 @destroy_q = [] unless defined?(@destroy_q)
\r
558 buname = params[:name]
\r
559 return m.reply(_("You can't destroy %{user}") % {:user => buname}) if
\r
560 ["everyone", "owner"].include?(buname)
\r
561 cancel = m.message.split[1] == 'cancel'
\r
562 password = params[:password]
\r
564 buser_array = @bot.auth.save_array
\r
565 buser_hash = buser_array.inject({}) { |h, u|
\r
566 h[u[:username]] = u
\r
570 return m.reply(_("no such botuser %{user}") % {:user=>buname}) unless
\r
571 buser_hash.keys.include?(buname)
\r
574 if @destroy_q.include?(buname)
\r
575 @destroy_q.delete(buname)
\r
576 m.reply(_("%{user} removed from the destruction queue") % {:user=>buname})
\r
578 m.reply(_("%{user} was not queued for destruction") % {:user=>buname})
\r
584 if @destroy_q.include?(buname)
\r
585 return m.reply(_("%{user} already queued for destruction, use %{highlight}user destroy %{user} <password>%{highlight} to destroy it") % {:user=>buname, :highlight=>Bold})
\r
587 @destroy_q << buname
\r
588 return m.reply(_("%{user} queued for destruction, use %{highlight}user destroy %{user} <password>%{highlight} to destroy it") % {:user=>buname, :highlight=>Bold})
\r
592 return m.reply(_("%{user} is not queued for destruction yet") %
\r
593 {:user=>buname}) unless @destroy_q.include?(buname)
\r
594 return m.reply(_("wrong password for %{user}") %
\r
595 {:user=>buname}) unless buser_hash[buname][:password] == password
\r
596 buser_array.delete_if { |u|
\r
597 u[:username] == buname
\r
599 @destroy_q.delete(buname)
\r
600 @bot.auth.load_array(buser_array, true)
\r
601 @bot.auth.set_changed
\r
603 return m.reply(_("failed: %{exception}") % {:exception => e})
\r
605 return m.reply(_("botuser %{user} destroyed") % {:user => buname})
\r
610 def auth_copy_ren_user(m, params)
\r
611 source = Auth::BotUser.sanitize_username(params[:source])
\r
612 dest = Auth::BotUser.sanitize_username(params[:dest])
\r
613 return m.reply(_("please don't touch the default users")) unless
\r
614 (["everyone", "owner"] & [source, dest]).empty?
\r
616 buser_array = @bot.auth.save_array
\r
617 buser_hash = buser_array.inject({}) { |h, u|
\r
618 h[u[:username]] = u
\r
622 return m.reply(_("no such botuser %{source}") % {:source=>source}) unless
\r
623 buser_hash.keys.include?(source)
\r
624 return m.reply(_("botuser %{dest} exists already") % {:dest=>dest}) if
\r
625 buser_hash.keys.include?(dest)
\r
627 copying = m.message.split[1] == "copy"
\r
631 buser_hash[source].each { |k, val|
\r
635 h = buser_hash[source]
\r
637 h[:username] = dest
\r
638 buser_array << h if copying
\r
640 @bot.auth.load_array(buser_array, true)
\r
641 @bot.auth.set_changed
\r
643 return m.reply(_("failed: %{exception}") % {:exception=>e})
\r
645 return m.reply(_("botuser %{source} copied to %{dest}") %
\r
646 {:source=>source, :dest=>dest}) if copying
\r
647 return m.reply(_("botuser %{source} renamed to %{dest}") %
\r
648 {:source=>source, :dest=>dest})
\r
652 def auth_export(m, params)
\r
654 exportfile = "#{@bot.botclass}/new-auth.users"
\r
656 what = params[:things]
\r
658 has_to = what[-2] == "to"
\r
660 exportfile = "#{@bot.botclass}/#{what[-1]}"
\r
666 m.reply _("selecting data to export ...")
\r
668 buser_array = @bot.auth.save_array
\r
669 buser_hash = buser_array.inject({}) { |h, u|
\r
670 h[u[:username]] = u
\r
675 we_want = buser_hash
\r
677 we_want = buser_hash.delete_if { |key, val|
\r
678 not what.include?(key)
\r
682 m.reply _("preparing data for export ...")
\r
685 we_want.each { |k, val|
\r
692 yaml_hash[k][kk] = []
\r
694 yaml_hash[k][kk] << {
\r
695 :fullform => nm.fullform,
\r
696 :casemap => nm.casemap.to_s
\r
700 yaml_hash[k][kk] = v
\r
705 m.reply _("failed to prepare data: %{exception}") % {:exception=>e}
\r
706 debug e.backtrace.dup.unshift(e.inspect).join("\n")
\r
710 m.reply _("exporting to %{file} ...") % {:file=>exportfile}
\r
712 # m.reply yaml_hash.inspect
\r
713 File.open(exportfile, "w") do |file|
\r
714 file.puts YAML::dump(yaml_hash)
\r
717 m.reply _("failed to export users: %{exception}") % {:exception=>e}
\r
718 debug e.backtrace.dup.unshift(e.inspect).join("\n")
\r
724 def auth_import(m, params)
\r
726 importfile = "#{@bot.botclass}/new-auth.users"
\r
728 what = params[:things]
\r
730 has_from = what[-2] == "from"
\r
732 importfile = "#{@bot.botclass}/#{what[-1]}"
\r
738 m.reply _("reading %{file} ...") % {:file=>importfile}
\r
740 yaml_hash = YAML::load_file(importfile)
\r
742 m.reply _("failed to import from: %{exception}") % {:exception=>e}
\r
743 debug e.backtrace.dup.unshift(e.inspect).join("\n")
\r
747 # m.reply yaml_hash.inspect
\r
749 m.reply _("selecting data to import ...")
\r
752 we_want = yaml_hash
\r
754 we_want = yaml_hash.delete_if { |key, val|
\r
755 not what.include?(key)
\r
759 m.reply _("parsing data from import ...")
\r
764 yaml_hash.each { |k, val|
\r
765 buser_hash[k] = { :username => k }
\r
769 buser_hash[k][kk] = []
\r
771 buser_hash[k][kk] << nm[:fullform].to_irc_netmask(:casemap => nm[:casemap].to_irc_casemap).to_irc_netmask(:server => @bot.server)
\r
774 buser_hash[k][kk] = v
\r
779 m.reply _("failed to parse data: %{exception}") % {:exception=>e}
\r
780 debug e.backtrace.dup.unshift(e.inspect).join("\n")
\r
784 # m.reply buser_hash.inspect
\r
786 org_buser_array = @bot.auth.save_array
\r
787 org_buser_hash = org_buser_array.inject({}) { |h, u|
\r
788 h[u[:username]] = u
\r
792 # TODO we may want to do a(n optional) key-by-key merge
\r
794 org_buser_hash.merge!(buser_hash)
\r
795 new_buser_array = org_buser_hash.values
\r
796 @bot.auth.load_array(new_buser_array, true)
\r
797 @bot.auth.set_changed
\r
804 auth = AuthModule.new
\r
806 auth.map "user export *things",
\r
807 :action => 'auth_export',
\r
808 :defaults => { :things => ['all'] },
\r
809 :auth_path => ':manage:fedex:'
\r
811 auth.map "user import *things",
\r
812 :action => 'auth_import',
\r
813 :auth_path => ':manage:fedex:'
\r
815 auth.map "user create :name :password",
\r
816 :action => 'auth_create_user',
\r
817 :defaults => {:password => nil},
\r
818 :auth_path => ':manage:'
\r
820 auth.map "user [cancel] destroy :name :password",
\r
821 :action => 'auth_destroy_user',
\r
822 :defaults => { :password => nil },
\r
823 :auth_path => ':manage::destroy:'
\r
825 auth.map "user copy :source [to] :dest",
\r
826 :action => 'auth_copy_ren_user',
\r
827 :auth_path => ':manage:'
\r
829 auth.map "user rename :source [to] :dest",
\r
830 :action => 'auth_copy_ren_user',
\r
831 :auth_path => ':manage:'
\r
833 auth.default_auth("user::manage", false)
\r
835 auth.map "user tell :user the password for :botuser",
\r
836 :action => 'auth_tell_password',
\r
839 auth.map "user list",
\r
840 :action => 'auth_list_users',
\r
843 auth.map "user *data",
\r
844 :action => 'auth_manage_user'
\r
846 auth.default_auth("user", true)
\r
847 auth.default_auth("edit::other", false)
\r
850 :action => 'auth_whoami',
\r
851 :auth_path => '!*!'
\r
853 auth.map "who is :user",
\r
854 :action => 'auth_whois',
\r
855 :auth_path => '!*!'
\r
857 auth.map "auth :password",
\r
858 :action => 'auth_auth',
\r
860 :auth_path => '!login!'
\r
862 auth.map "login :botuser :password",
\r
863 :action => 'auth_login',
\r
865 :defaults => { :password => nil },
\r
866 :auth_path => '!login!'
\r
868 auth.map "login :botuser",
\r
869 :action => 'auth_login',
\r
870 :auth_path => '!login!'
\r
873 :action => 'auth_autologin',
\r
874 :auth_path => '!login!'
\r
876 auth.map "permissions set *args",
\r
877 :action => 'auth_edit_perm',
\r
878 :auth_path => ':edit::set:'
\r
880 auth.map "permissions reset *args",
\r
881 :action => 'auth_edit_perm',
\r
882 :auth_path => ':edit::reset:'
\r
884 auth.map "permissions view [for :user]",
\r
885 :action => 'auth_view_perm',
\r
888 auth.default_auth('*', false)
\r