PerlModuleUsers
CssWork parent
Man page for users
Don't waste your time...
# man Slash::Users
No manual entry for Slash::Users
[root@slashcode htdocs]# man Slash::Users2
Users2(3) User Contributed Perl Documentation Users2(3)
NAME
Slash::Users2
SYNOPSIS
use Slash::Users2;
DESCRIPTION
Provides homepages for users.
AUTHOR
Christopher Brown, cbrown@corp.sourcefore.com
SEE ALSO
perl(1).
perl v5.10.1 2014-02-20 Users2(3)
Source of users.pl
#!/usr/bin/perl -w
# This code is a part of Slash, and is released under the GPL.
# Copyright 1997-2005 by Open Source Technology Group. See README
# and COPYING for more information, or see http://slashcode.com/.
# $Id$
use strict;
use Digest::MD5 'md5_hex';
use Slash;
use Slash::Display;
use Slash::Utility;
use Slash::Constants qw(:messages);
#################################################################
sub main {
my $slashdb = getCurrentDB();
my $constants = getCurrentStatic();
my $user = getCurrentUser();
my $form = getCurrentForm();
my $gSkin = getCurrentSkin();
my $formname = $0;
$formname =~ s/.*\/(\w+)\.pl/$1/;
my $error_flag = 0;
my $formkey = $form->{formkey};
my $suadmin_flag = $user->{seclev} >= 10000 ? 1 : 0 ;
my $postflag = $user->{state}{post};
my $op = lc($form->{op});
# savepasswd is a special case, because once it's called, you
# have to reload the form, and you don't want to do any checks if
# you've just saved.
my $savepass_flag = $op eq 'savepasswd' ? 1 : 0 ;
my $ops = {
admin => {
function => \&adminDispatch,
seclev => 10000, # if this should be lower,
# then something else is
# broken, because it allows
# anyone with this seclev
# to change their own seclev
formname => $formname,
# just in case we need it for something else, we have it ...
checks => [ qw (generate_formkey) ],
},
# userlogin => {
# function => \&showInfo,
# seclev => 1,
# formname => $formname,
# checks => [],
# tab_selected_1 => 'me',
# },
no_user => {
function => \&noUser,
seclev => 0,
formname => $formname,
checks => [],
},
userinfo => {
function => \&showInfo,
#I made this change, not all sites are going to care. -Brian
seclev => $constants->{users_show_info_seclev},
formname => $formname,
checks => [],
tab_selected_1 => 'me',
tab_selected_2 => 'info',
},
userfirehose => {
function => \&showFireHose,
seclev => 0,
formname => $formname,
checks => [],
tab_selected_1 => 'me',
tab_selected_2 => 'firehose'
},
usersubmissions => {
function => \&showSubmissions,
#I made this change, not all sites are going to care. -Brian
seclev => $constants->{users_show_info_seclev},
checks => [],
tab_selected_1 => 'me',
},
usercomments => {
function => \&showComments,
#I made this change, not all sites are going to care. -Brian
seclev => $constants->{users_show_info_seclev},
checks => [],
tab_selected_1 => 'me',
},
display => {
function => \&showInfo,
#I made this change, not all sites are going to care. -Brian
seclev => $constants->{users_show_info_seclev},
formname => $formname,
checks => [],
tab_selected_1 => 'me',
tab_selected_2 => 'info',
},
# savepasswd => {
# function => \&savePasswd,
# seclev => 1,
# post => 1,
# formname => $formname,
# checks => [ qw (max_post_check valid_check
# formkey_check regen_formkey) ],
# tab_selected_1 => 'preferences',
# tab_selected_2 => 'password',
# },
saveuseradmin => {
function => \&saveUserAdmin,
seclev => 10000,
post => 1,
formname => $formname,
checks => [],
},
savehome => {
function => \&saveHome,
seclev => 1,
post => 1,
formname => $formname,
checks => [ qw (valid_check
formkey_check regen_formkey) ],
tab_selected_1 => 'preferences',
tab_selected_2 => 'home',
},
savecomm => {
function => \&saveComm,
seclev => 1,
post => 1,
formname => $formname,
checks => [ qw (valid_check
formkey_check regen_formkey) ],
tab_selected_1 => 'preferences',
tab_selected_2 => 'comments',
},
saveuser => {
function => \&saveUser,
seclev => 1,
post => 1,
formname => $formname,
checks => [ qw (valid_check
formkey_check regen_formkey) ],
tab_selected_1 => 'preferences',
tab_selected_2 => 'user',
},
# changepasswd => {
# function => \&changePasswd,
# seclev => 1,
# formname => $formname,
# checks => $savepass_flag ? [] :
# [ qw (generate_formkey) ],
# tab_selected_1 => 'preferences',
# tab_selected_2 => 'password',
# },
editmiscopts => {
function => \&editMiscOpts,
seclev => 1,
formname => $formname,
checks => [ ],
tab_selected_1 => 'preferences',
tab_selected_2 => 'misc',
},
savemiscopts => {
function => \&saveMiscOpts,
seclev => 1,
formname => $formname,
checks => [ ],
tab_selected_1 => 'preferences',
tab_selected_2 => 'misc',
},
edituser => {
function => \&editUser,
seclev => 1,
formname => $formname,
checks => [ qw (generate_formkey) ],
tab_selected_1 => 'preferences',
tab_selected_2 => 'user',
},
authoredit => {
function => \&editUser,
seclev => 10000,
formname => $formname,
checks => [],
},
edithome => {
function => \&editHome,
seclev => 1,
formname => $formname,
checks => [ qw (generate_formkey) ],
tab_selected_1 => 'preferences',
tab_selected_2 => 'home',
},
editcomm => {
function => \&editComm,
seclev => 1,
formname => $formname,
checks => [ qw (generate_formkey) ],
tab_selected_1 => 'preferences',
tab_selected_2 => 'comments',
},
# newuser => {
# function => \&newUser,
# seclev => 0,
# formname => "${formname}/nu",
# checks => [ qw (max_post_check valid_check
# formkey_check regen_formkey) ],
# },
newuseradmin => {
function => \&newUserForm,
seclev => 10000,
formname => "${formname}/nu",
checks => [],
},
previewbox => {
function => \&previewSlashbox,
seclev => 0,
formname => $formname,
checks => [],
},
# mailpasswd => {
# function => \&mailPasswd,
# seclev => 0,
# formname => "${formname}/mp",
# checks => [ qw (max_post_check valid_check
# interval_check formkey_check ) ],
# tab_selected_1 => 'preferences',
# tab_selected_2 => 'password',
# },
validateuser => {
function => \&validateUser,
seclev => 1,
formname => $formname,
checks => ['regen_formkey'],
},
showtags => {
function => \&showTags,
seclev => 1,
formname => $formname,
checks => [],
tab_selected => 'tags',
},
showbookmarks => {
function => \&showBookmarks,
seclev => 0,
formname => $formname,
checks => [],
tab_selected => 'bookmarks',
},
edittags => {
function => \&editTags,
seclev => 1,
formname => $formname,
checks => [],
tab_selected => 'tags',
},
savetags => {
function => \&saveTags,
seclev => 1,
formname => $formname,
checks => [],
tab_selected => 'tags',
},
# userclose => {
# function => \&displayForm,
# seclev => 0,
# formname => $formname,
# checks => [],
# },
# newuserform => {
# function => \&displayForm,
# seclev => 0,
# formname => "${formname}/nu",
# checks => [ qw (max_post_check
# generate_formkey) ],
# },
# mailpasswdform => {
# function => \&displayForm,
# seclev => 0,
# formname => "${formname}/mp",
# checks => [ qw (max_post_check
# generate_formkey) ],
# tab_selected_1 => 'preferences',
# tab_selected_2 => 'password',
# },
displayform => {
function => \&displayForm,
seclev => 0,
formname => $formname,
checks => [ qw (generate_formkey) ],
tab_selected_1 => 'me',
},
listreadonly => {
function => \&listReadOnly,
seclev => 100,
formname => $formname,
checks => [],
adminmenu => 'security',
tab_selected => 'readonly',
},
listbanned => {
function => \&listBanned,
seclev => 100,
formname => $formname,
checks => [],
adminmenu => 'security',
tab_selected => 'banned',
},
topabusers => {
function => \&topAbusers,
seclev => 100,
formname => $formname,
checks => [],
adminmenu => 'security',
tab_selected => 'abusers',
},
listabuses => {
function => \&listAbuses,
seclev => 100,
formname => $formname,
checks => [],
},
force_acct_verify => {
function => \&forceAccountVerify,
seclev => 100,
post => 1,
formname => $formname,
checks => []
}
} ;
# Note this is NOT the default op. "userlogin" or "userinfo" is
# the default op, and it's set either 5 lines down or about 100
# lines down, depending. Yes, that's dumb. Yes, we should
# change it. It would require tracing through a fair bit of logic
# though and I don't have the time right now. - Jamie
$ops->{default} = $ops->{displayform};
for (qw(newuser newuserform mailpasswd mailpasswdform changepasswd savepasswd userlogin userclose)) {
$ops->{$_} = $ops->{default};
}
my $errornote = "";
if ($form->{op} && ! defined $ops->{$op}) {
$errornote .= getError('bad_op', { op => $form->{op}}, 0, 1);
$op = $user->{is_anon} ? 'userlogin' : 'userinfo';
}
if ($op eq 'userlogin' && ! $user->{is_anon}) {
redirect(cleanRedirectUrl($form->{returnto} || ''));
return;
# this will only redirect if it is a section-based rootdir with
# its rootdir different from real_rootdir
} elsif ($op eq 'userclose' && $gSkin->{rootdir} ne $constants->{real_rootdir}) {
redirect($constants->{real_rootdir} . '/login.pl?op=userclose');
return;
} elsif ($op =~ /^(?:newuser|newuserform|mailpasswd|mailpasswdform|changepasswd|savepasswd|userlogin|userclose|displayform)$/) {
my $op = $form->{op};
$op = 'changeprefs' if $op eq 'changepasswd';
$op = 'saveprefs' if $op eq 'savepasswd';
redirect($constants->{real_rootdir} . '/login.pl?op=' . $op);
return;
# never get here now
} elsif ($op eq 'savepasswd') {
my $error_flag = 0;
if ($user->{seclev} < 100) {
for my $check (@{$ops->{savepasswd}{checks}}) {
# the only way to save the error message is to pass by ref
# $errornote and add the message to note (you can't print
# it out before header is called)
$error_flag = formkeyHandler($check, $formname, $formkey, \$errornote);
last if $error_flag;
}
}
if (! $error_flag) {
$error_flag = savePasswd({ noteref => \$errornote }) ;
}
# change op to edituser and let fall through;
# we need to have savePasswd set the cookie before
# header() is called -- pudge
if ($user->{seclev} < 100 && ! $error_flag) {
$slashdb->updateFormkey($formkey, length($ENV{QUERY_STRING}));
}
$op = $error_flag ? 'changepasswd' : 'userinfo';
$form->{userfield} = $user->{uid};
}
# Figure out what the op really is.
$op = 'userinfo' if (! $form->{op} && ($form->{uid} || $form->{nick}));
$op ||= $user->{is_anon} ? 'userlogin' : 'userinfo';
if ($user->{is_anon} && ( ($ops->{$op}{seclev} > 0) || ($op =~ /^newuserform|mailpasswdform|displayform$/) )) {
redirect($constants->{real_rootdir} . '/login.pl');
return;
} elsif ($user->{seclev} < $ops->{$op}{seclev}) {
$op = 'userinfo';
}
if ($ops->{$op}{post} && !$postflag) {
$op = $user->{is_anon} ? 'default' : 'userinfo';
}
# Print the header and very top stuff on the page. We have
# three ops that (may) end up routing into showInfo(), which
# needs to do some stuff before it calls header(), so for
# those three, don't bother.
my $header;
if ($op !~ /^(userinfo|display|saveuseradmin|admin|userfirehose$)/) {
my $data = {
adminmenu => $ops->{$op}{adminmenu} || 'admin',
tab_selected => $ops->{$op}{tab_selected},
};
header(getMessage('user_header'), '', $data) or return;
# This is a hardcoded position, bad idea and should be fixed -Brian
# Yeah, we should pull this into a template somewhere...
print getMessage('note', { note => $errornote }) if defined $errornote;
$header = 1;
}
if ($constants->{admin_formkeys} || $user->{seclev} < 100) {
my $done = 0;
$done = 1 if $op eq 'savepasswd'; # special case
$formname = $ops->{$op}{formname};
# No need for HumanConf if the constant for it is not
# switched on, or if the user's karma is high enough
# to get out of it. (But for "newuserform," the current
# user's karma doesn't get them out of having to prove
# they're a human for creating a *new* user.)
my $options = {};
if ( !$constants->{plugin}{HumanConf}
|| !$constants->{hc}
|| !$constants->{hc_sw_newuser}
&& ($formname eq 'users/nu' || $op eq 'newuserform')
|| !$constants->{hc_sw_mailpasswd}
&& ($formname eq 'users/mp' || $op eq 'mailpasswdform')
|| $user->{karma} > $constants->{hc_maxkarma}
&& !$user->{is_anon}
&& !($op eq 'newuser' || $op eq 'newuserform')
) {
$options->{no_hc} = 1;
}
DO_CHECKS: while (!$done) {
for my $check (@{$ops->{$op}{checks}}) {
$ops->{$op}{update_formkey} = 1 if $check eq 'formkey_check';
$error_flag = formkeyHandler($check, $formname, $formkey,
undef, $options);
if ($error_flag == -1) {
# Special error: HumanConf failed. Go
# back to the previous op, start over.
if ($op =~ /^(newuser|mailpasswd)$/) {
$op .= "form";
$error_flag = 0;
next DO_CHECKS;
}
} elsif ($error_flag) {
$done = 1;
last;
}
}
$done = 1;
}
if (!$error_flag && !$options->{no_hc}) {
my $hc = getObject("Slash::HumanConf");
$hc->reloadFormkeyHC($formname) if $hc;
}
}
errorLog("users.pl error_flag '$error_flag'") if $error_flag;
# call the method
my $retval;
$retval = $ops->{$op}{function}->({
op => $op,
tab_selected_1 => $ops->{$op}{tab_selected_1} || "",
note => $errornote,
}) if !$error_flag;
return if !$retval;
if ($op eq 'mailpasswd' && $retval) {
$ops->{$op}{update_formkey} = 0;
}
if ($ops->{$op}{update_formkey} && $user->{seclev} < 100 && ! $error_flag) {
# successful save action, no formkey errors, update existing formkey
# why assign to an unused variable? -- pudge
my $updated = $slashdb->updateFormkey($formkey, length($ENV{QUERY_STRING}));
}
# if there were legit error levels returned from the save methods
# I would have it clear the formkey in case of an error, but that
# needs to be sorted out later
# else { resetFormkey($formkey); }
writeLog($user->{nickname});
footer();
}
#################################################################
sub checkList {
my($string, $len) = @_;
my $constants = getCurrentStatic();
$string =~ s/[^\w,-]//g;
my @items = grep { $_ } split /,/, $string;
$string = join ",", @items;
$len ||= $constants->{checklist_length} || 255;
if (length($string) > $len) {
print getError('checklist_err');
$string = substr($string, 0, $len);
$string =~ s/,?\w*$//g;
} elsif (length($string) < 1) {
$string = '';
}
return $string;
}
#################################################################
sub previewSlashbox {
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $constants = getCurrentStatic();
my $user = getCurrentUser();
my $form = getCurrentForm();
my $block = $reader->getBlock($form->{bid}, ['title', 'block', 'url']);
my $is_editable = $user->{seclev} >= 1000;
my $title = getTitle('previewslashbox_title', { blocktitle => $block->{title} });
slashDisplay('previewSlashbox', {
width => '100%',
title => $title,
block => $block,
is_editable => $is_editable,
});
print portalbox($constants->{fancyboxwidth}, $block->{title},
$block->{block}, '', $block->{url});
}
#################################################################
sub newUserForm {
my $user = getCurrentUser();
my $suadmin_flag = $user->{seclev} >= 10000;
my $title = getTitle('newUserForm_title');
slashDisplay('newUserForm', {
title => $title,
suadmin_flag => $suadmin_flag,
});
}
#################################################################
sub newUser {
my $slashdb = getCurrentDB();
my $form = getCurrentForm();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $plugins = $slashdb->getDescriptions('plugins');
my $title;
my $suadmin_flag = $user->{seclev} >= 10000 ? 1 : 0;
# Check if User Exists
$form->{newusernick} = nickFix($form->{newusernick});
my $matchname = nick2matchname($form->{newusernick});
if (!$form->{email} || $form->{email} !~ /\@/) {
print getError('email_invalid', 0, 1);
return;
} elsif ($form->{email} ne $form->{email2}) {
print getError('email_do_not_match', 0, 1);
return;
} elsif ($slashdb->existsEmail($form->{email})) {
print getError('emailexists_err', 0, 1);
return;
} elsif ($matchname ne '' && $form->{newusernick} ne '') {
if ($constants->{newuser_portscan}) {
my $is_trusted = $slashdb->checkAL2($user->{srcids}, 'trusted');
if (!$is_trusted) {
my $is_proxy = $slashdb->checkForOpenProxy($user->{hostip});
if ($is_proxy) {
print getError('new user open proxy', {
unencoded_ip => $ENV{REMOTE_ADDR},
port => $is_proxy,
});
return;
}
}
}
my $uid;
my $rootdir = getCurrentSkin('rootdir');
$uid = $slashdb->createUser(
$matchname, $form->{email}, $form->{newusernick}
);
if ($uid) {
my $data = {};
getOtherUserParams($data);
for (qw(tzcode)) {
$data->{$_} = $form->{$_} if defined $form->{$_};
}
$data->{creation_ipid} = $user->{ipid};
$slashdb->setUser($uid, $data) if keys %$data;
$title = getTitle('newUser_title');
$form->{pubkey} = $plugins->{'Pubkey'} ?
strip_nohtml($form->{pubkey}, 1) : '';
print getMessage('newuser_msg', {
suadmin_flag => $suadmin_flag,
title => $title,
uid => $uid
});
if ($form->{newsletter} || $form->{comment_reply} || $form->{headlines}) {
my $messages = getObject('Slash::Messages');
my %params;
$params{MSG_CODE_COMMENT_REPLY()} = MSG_MODE_EMAIL()
if $form->{comment_reply};
$params{MSG_CODE_NEWSLETTER()} = MSG_MODE_EMAIL()
if $form->{newsletter};
$params{MSG_CODE_HEADLINES()} = MSG_MODE_EMAIL()
if $form->{headlines};
$messages->setPrefs($uid, \%params);
}
mailPasswd({ uid => $uid });
return;
} else {
$slashdb->resetFormkey($form->{formkey});
print getError('duplicate_user', {
nick => $form->{newusernick},
});
return;
}
} else {
print getError('duplicate_user', {
nick => $form->{newusernick},
});
return;
}
}
#################################################################
sub mailPasswd {
my($hr) = @_;
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $uid = $hr->{uid} || 0;
my $slashdb = getCurrentDB();
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $form = getCurrentForm();
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
if (! $uid) {
if ($form->{unickname} =~ /\@/) {
$uid = $slashdb->getUserEmail($form->{unickname});
} elsif ($form->{unickname} =~ /^\d+$/) {
my $tmpuser = $slashdb->getUser($form->{unickname}, ['uid']);
$uid = $tmpuser->{uid};
} else {
$uid = $slashdb->getUserUID($form->{unickname});
}
}
my $user_edit;
my $err_name = '';
my $err_opts = {};
if (!$uid || isAnon($uid)) {
$err_name = 'mailpasswd_notmailed_err';
}
if (!$err_name) {
# Check permissions of _this_ user, not the target
# user, to determine whether this IP is OK'd to
# send the mail to the target user.
# XXXSRCID This should check a separate field like
# 'openproxy' instead of piggybacking off of the
# existing nopost and spammer
my $srcids_to_check = $user->{srcids};
$err_name = 'mailpasswd_readonly_err'
if $reader->checkAL2($srcids_to_check, 'nopost');
}
if (!$err_name) {
$err_name = 'mailpasswd_toooften_err'
if $slashdb->checkMaxMailPasswords($user_edit);
}
if (!$err_name) {
if ($constants->{mailpasswd_portscan}) {
my $is_trusted = $slashdb->checkAL2($user->{srcids}, 'trusted');
if (!$is_trusted) {
my $is_proxy = $slashdb->checkForOpenProxy($user->{hostip});
if ($is_proxy) {
$err_name = 'mailpasswd open proxy';
$err_opts = { unencoded_ip => $ENV{REMOTE_ADDR}, port => $is_proxy };
}
}
}
}
if ($err_name) {
print getError($err_name, $err_opts);
$slashdb->resetFormkey($form->{formkey});
$form->{op} = 'mailpasswdform';
displayForm();
return(1);
}
my $newpasswd = $slashdb->getNewPasswd($uid);
my $tempnick = $user_edit->{nickname};
my $emailtitle = getTitle('mailPassword_email_title', {
nickname => $user_edit->{nickname}
}, 1);
# Pull out some data passed in with the request. Only the IP
# number is actually trustworthy, the others could be forged.
# Note that we strip the forgeable ones to make sure there
# aren't any "<>" chars which could fool a stupid mail client
# into parsing a plaintext email as HTML.
my $r = Apache->request;
my $remote_ip = $r->connection->remote_ip;
my $xff = $r->header_in('X-Forwarded-For') || '';
$xff =~ s/\s+/ /g;
$xff = substr(strip_notags($xff), 0, 20);
my $ua = $r->header_in('User-Agent') || '';
$ua =~ s/\s+/ /g;
$ua = substr(strip_attribute($ua), 0, 60);
my $msg = getMessage('mailpasswd_msg', {
newpasswd => $newpasswd,
tempnick => $tempnick,
remote_ip => $remote_ip,
x_forwarded_for => $xff,
user_agent => $ua,
}, 1);
doEmail($uid, $emailtitle, $msg) if $user_edit->{nickname};
print getMessage('mailpasswd_mailed_msg', { name => $user_edit->{nickname} });
$slashdb->setUserMailPasswd($user_edit);
}
#################################################################
sub showSubmissions {
my($hr) = @_;
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $form = getCurrentForm();
my $constants = getCurrentStatic();
my $user = getCurrentUser();
my($uid, $nickname);
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
if ($form->{uid} or $form->{nick}) {
$uid = $form->{uid} || $reader->getUserUID($form->{nick});
$nickname = $reader->getUser($uid, 'nickname');
} else {
$nickname = $user->{nickname};
$uid = $user->{uid};
}
my $storycount = $reader->countStoriesBySubmitter($uid);
my $stories = $reader->getStoriesBySubmitter(
$uid,
$constants->{user_submitter_display_default}
) unless !$storycount;
slashDisplay('userSub', {
nick => $nickname,
uid => $uid,
nickmatch_flag => ($user->{uid} == $uid ? 1 : 0),
stories => $stories,
storycount => $storycount,
});
}
#################################################################
sub showComments {
my($hr) = @_;
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $form = getCurrentForm();
my $constants = getCurrentStatic();
my $user = getCurrentUser();
my $commentstruct = [];
my($uid, $nickname);
my $user_edit;
if ($form->{uid} || $form->{nick}) {
$uid = $form->{uid} || $reader->getUserUID($form->{nick});
$user_edit = $reader->getUser($uid);
} else {
$uid = $user->{uid};
$user_edit = $user;
}
$nickname = $user_edit->{nickname};
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $user_edit->{uid} == $user->{uid} ? 'me' : 'otheruser',
});
my $min_comment = $form->{min_comment} || 0;
$min_comment = 0 unless $user->{seclev} > $constants->{comments_more_seclev}
|| $constants->{comments_more_seclev} == 2 && $user->{is_subscriber};
my $comments_wanted = $user->{show_comments_num}
|| $constants->{user_comment_display_default};
my $commentcount = $reader->countCommentsByUID($uid);
my $comments = $reader->getCommentsByUID(
$uid, $comments_wanted, $min_comment
) if $commentcount;
if (ref($comments) eq 'ARRAY') {
my $kinds = $reader->getDescriptions('discussion_kinds');
for my $comment (@$comments) {
# This works since $sid is numeric.
$comment->{replies} = $reader->countCommentsBySidPid($comment->{sid}, $comment->{cid});
# This is ok, since with all luck we will not be hitting the DB
# ...however, the "sid" parameter here must be the string
# based SID from either the "stories" table or from
# pollquestions.
my $discussion = $reader->getDiscussion($comment->{sid});
if ($kinds->{ $discussion->{dkid} } =~ /^journal(?:-story)?$/) {
$comment->{type} = 'journal';
} elsif ($kinds->{ $discussion->{dkid} } eq 'poll') {
$comment->{type} = 'poll';
} else {
$comment->{type} = 'story';
}
$comment->{disc_title} = $discussion->{title};
$comment->{url} = $discussion->{url};
}
}
my $mod_reader = getObject("Slash::$constants->{m1_pluginname}", { db_type => 'reader' });
slashDisplay('userCom', {
nick => $nickname,
useredit => $user_edit,
nickmatch_flag => ($user->{uid} == $uid ? 1 : 0),
commentstruct => $comments,
commentcount => $commentcount,
min_comment => $min_comment,
reasons => $mod_reader->getReasons(),
karma_flag => 0,
admin_flag => $user->{is_admin},
});
}
sub noUser {
print getData("no_user");
}
sub showFireHose {
my($hr) = @_;
my $user = getCurrentUser();
my $form = getCurrentForm();
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $uid = $form->{uid} || $user->{uid};
my $user_edit = $reader->getUser($uid);
$user->{state}{firehose_page} = "user";
$user->{state}{firehose_user_uid} = $uid;
my $firehose = getObject("Slash::FireHose");
header(getMessage('userfirehose_header', { useredit => $user_edit })) or return;
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $user_edit->{uid} == $user->{uid} ? 'me' : 'otheruser',
});
$form->{mode} = "full";
$form->{color} = "black";
$form->{orderby} = "createtime";
$form->{orderdir} = "DESC";
$form->{skipmenu} = 1;
$form->{duration} = -1;
$form->{fhfilter} = "\"user:$user_edit->{nickname}\"";
$form->{pause} = 1;
$form->{listonly} = 1;
$form->{legacy} = 1;
my $fhbox = $firehose->listView({ fh_page => 'users.pl', tab => 'userfirehose', user_view => $user_edit });
slashDisplay("userFireHose", { firehosebox => $fhbox, uid => $uid, useredit => $user_edit });
}
#################################################################
# arhgghgh. I love torture. I love pain. This subroutine satisfies
# these needs of mine
sub showInfo {
my($hr) = @_;
my $id = $hr->{uid} || 0;
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $slashdb = getCurrentDB();
my $form = getCurrentForm();
my $constants = getCurrentStatic();
my $user = getCurrentUser();
my $admin_flag = ($user->{is_admin}) ? 1 : 0;
my $suadmin_flag = $user->{seclev} >= 10000 ? 1 : 0;
my($title, $admin_block, $fieldkey) = ('', '', '');
my $comments = undef;
my $commentcount = 0;
my $commentcount_time = 0;
my $commentstruct = [];
my $requested_user = {};
my $time_period = $constants->{admin_comment_display_days} || 30;
my $cid_for_time_period = $reader->getVar("min_cid_last_$time_period\_days",'value', 1) || 0;
my $admin_time_period_limit = $constants->{admin_daysback_commentlimit} || 100;
my $admin_non_time_limit = $constants->{admin_comment_subsequent_pagesize} || 24;
my($points, $nickmatch_flag, $uid, $nick);
my($mod_flag, $karma_flag, $n) = (0, 0, 0);
if ($admin_flag
&& (defined($form->{show_m2s}) || defined($form->{show_m1s}) || defined($form->{m2_listing})))
{
my $update_hr = {};
$update_hr->{mod_with_comm} = $form->{show_m1s}
if defined $form->{show_m1s};
$update_hr->{m2_with_mod} = ($constants->{m2} ? $form->{show_m2s} : undef)
if defined $form->{show_m2s};
$update_hr->{show_m2_listing} = ($constants->{m2} ? $form->{m2_listing} : undef)
if defined $form->{m2_listing};
$slashdb->setUser($user->{uid}, $update_hr);
}
if (!$id && !$form->{userfield}) {
if ($form->{uid} && ! $id) {
$fieldkey = 'uid';
($uid, $id) = ($form->{uid}, $form->{uid});
$requested_user = isAnon($uid) ? $user : $reader->getUser($id);
$nick = $requested_user->{nickname};
$form->{userfield} = $nick if $admin_flag;
} elsif ($form->{nick} && ! $id) {
$fieldkey = 'nickname';
($nick, $id) = ($form->{nick}, $form->{nick});
$uid = $reader->getUserUID($id);
if (isAnon($uid)) {
$requested_user = $user;
($nick, $uid, $id) = @{$user}{qw(nickname uid nickname)};
} else {
$requested_user = $reader->getUser($uid);
}
$form->{userfield} = $uid if $admin_flag;
} else {
$fieldkey = 'uid';
($id, $uid) = ($user->{uid}, $user->{uid});
$requested_user = $reader->getUser($uid);
$form->{userfield} = $uid if $admin_flag;
}
} elsif ($user->{is_admin}) {
$id ||= $form->{userfield} || $user->{uid};
if ($id =~ /^[0-9a-f]{16}$/) {
$requested_user->{nonuid} = 1;
$fieldkey = "srcid";
$requested_user->{$fieldkey} = $id;
} elsif ($id =~ /^\d+$/) {
# If it's longer than a uid could possibly be, it
# must be a srcid. The uid column right now is a
# MEDIUMINT (max 16M) but at most might someday
# be an INT (max 4G).
if (length($id) > 11) {
$requested_user->{nonuid} = 1;
$fieldkey = "srcid";
$requested_user->{$fieldkey} = $id;
} else {
$fieldkey = 'uid';
$requested_user = $reader->getUser($id);
$uid = $requested_user->{uid};
$nick = $requested_user->{nickname};
if ((my $conflict_id = $reader->getUserUID($id)) && $form->{userinfo}) {
slashDisplay('showInfoConflict', {
op => 'userinfo',
id => $uid,
nick => $nick,
conflict_id => $conflict_id
});
return 1;
}
}
} elsif (length($id) == 32) {
$requested_user->{nonuid} = 1;
if ($form->{fieldname}
&& $form->{fieldname} =~ /^(ipid|subnetid)$/) {
$fieldkey = $form->{fieldname};
} else {
$fieldkey = 'md5id';
}
$requested_user->{$fieldkey} = $id;
} elsif ($id =~ /^(\d{1,3}\.\d{1,3}.\d{1,3}\.0)$/
|| $id =~ /^(\d{1,3}\.\d{1,3}\.\d{1,3})\.?$/) {
$fieldkey = 'subnetid';
$requested_user->{subnetid} = $1;
$requested_user->{subnetid} .= '.0' if $requested_user->{subnetid} =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}$/;
$requested_user->{nonuid} = 1;
$requested_user->{subnetid} = md5_hex($requested_user->{subnetid});
} elsif ($id =~ /^([\d+\.]+)$/) {
$fieldkey = 'ipid';
$requested_user->{nonuid} = 1;
$id ||= $1;
$requested_user->{ipid} = md5_hex($1);
} elsif ($id =~ /^(.*@.*\..*?)$/) {
# check for email addy, but make it by uid
$fieldkey = 'uid';
$id = $uid = $reader->getUserEmail($id);
$requested_user = $reader->getUser($uid);
$nick = $requested_user->{nickname};
} else { # go by nickname, but make it by uid
$fieldkey = 'uid';
$id = $uid = $reader->getUserUID($id);
$requested_user = $reader->getUser($uid);
$nick = $requested_user->{nickname};
}
} else {
$fieldkey = 'uid';
($id, $uid) = ($user->{uid}, $user->{uid});
$requested_user = $reader->getUser($uid);
}
# Can't get user data for the anonymous user.
if ($fieldkey eq 'uid' && isAnon($uid)) {
header(getMessage('user_header')) or return;
return displayForm();
}
my $user_change = { };
if ($fieldkey eq 'uid' && !$user->{is_anon}
&& $uid != $user->{uid} && !isAnon($uid)) {
# Store the fact that this user last looked at that user.
# For maximal convenience in stalking.
$user_change->{lastlookuid} = $uid;
$user_change->{lastlooktime} = time;
$user->{lastlookuid} = $uid;
$user->{lastlooktime} = time;
$hr->{tab_selected_1} = 'otheruser';
}
# showInfo's header information is delayed until here, because
# the target user's info is not available until here.
vislenify($requested_user);
header(getMessage('user_header', { useredit => $requested_user, fieldkey => $fieldkey })) or return;
# This is a hardcoded position, bad idea and should be fixed -Brian
# Yeah, we should pull this into a template somewhere...
print getMessage('note', { note => $hr->{note} }) if defined $hr->{note};
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
my $comments_wanted = $user->{show_comments_num}
|| $constants->{user_comment_display_default};
my $min_comment = $form->{min_comment} || 0;
$min_comment = 0 unless $user->{seclev} > $constants->{comments_more_seclev}
|| $constants->{comments_more_seclev} == 2 && $user->{is_subscriber};
my($netid, $netid_vis) = ('', '');
my $comment_time;
my $non_admin_limit = $comments_wanted;
if ($requested_user->{nonuid}) {
$requested_user->{fg} = $user->{fg};
$requested_user->{bg} = $user->{bg};
if ($requested_user->{ipid}) {
$netid = $requested_user->{ipid} ;
} elsif ($requested_user->{md5id}) {
$netid = $requested_user->{md5id} ;
} elsif ($requested_user->{srcid}) {
$netid = $requested_user->{srcid} ;
} else {
$netid = $requested_user->{subnetid} ;
}
my $data = {
id => $id,
md5id => $netid,
};
vislenify($data); # add $data->{md5id_vis}
$netid_vis = $data->{md5id_vis};
$title = getTitle('user_netID_user_title', $data);
$admin_block = getUserAdmin($netid, $fieldkey, 0) if $admin_flag;
if ($form->{fieldname}) {
if ($form->{fieldname} eq 'ipid') {
$commentcount = $reader->countCommentsByIPID($netid);
$commentcount_time = $reader->countCommentsByIPID($netid, { cid_at_or_after => $cid_for_time_period });
$comments = getCommentListing("ipid", $netid,
$min_comment, $time_period, $commentcount, $commentcount_time, $cid_for_time_period,
$non_admin_limit, $admin_time_period_limit, $admin_non_time_limit)
if $commentcount;
} elsif ($form->{fieldname} eq 'subnetid') {
$commentcount = $reader->countCommentsBySubnetID($netid);
$commentcount_time = $reader->countCommentsBySubnetID($netid, { cid_at_or_after => $cid_for_time_period });
$comments = getCommentListing("subnetid", $netid,
$min_comment, $time_period, $commentcount, $commentcount_time, $cid_for_time_period,
$non_admin_limit, $admin_time_period_limit, $admin_non_time_limit)
if $commentcount;
} else {
delete $form->{fieldname};
}
}
if (!defined($comments)) {
# Last resort; here for backwards compatibility mostly.
my $type;
($commentcount,$type) = $reader->countCommentsByIPIDOrSubnetID($netid);
$commentcount_time = $reader->countCommentsByIPIDOrSubnetID($netid, { cid_at_or_after => $cid_for_time_period });
if ($type eq "ipid") {
$comments = getCommentListing("ipid", $netid,
$min_comment, $time_period, $commentcount, $commentcount_time, $cid_for_time_period,
$non_admin_limit, $admin_time_period_limit, $admin_non_time_limit)
if $commentcount;
} elsif ($type eq "subnetid") {
$comments = getCommentListing("subnetid", $netid,
$min_comment, $time_period, $commentcount, $commentcount_time, $cid_for_time_period,
$non_admin_limit, $admin_time_period_limit, $admin_non_time_limit)
if $commentcount;
}
}
} else {
$admin_block = getUserAdmin($id, $fieldkey, 1) if $admin_flag;
$commentcount = $reader->countCommentsByUID($requested_user->{uid});
$commentcount_time = $reader->countCommentsByUID($requested_user->{uid}, { cid_at_or_after => $cid_for_time_period });
$comments = getCommentListing("uid", $requested_user->{uid},
$min_comment, $time_period, $commentcount, $commentcount_time, $cid_for_time_period,
$non_admin_limit, $admin_time_period_limit, $admin_non_time_limit,
{ use_uid_cid_cutoff => 1 })
if $commentcount;
$netid = $requested_user->{uid};
}
# Grab the nicks of the uids we have, we're going to be adding them
# into the struct.
my @users_extra_cols_wanted = qw( nickname );
my @discussions_extra_cols_wanted = qw( type );
my $uid_hr = { };
my $sid_hr = { };
if ($comments && @$comments) {
my %uids = ();
my %sids = ();
for my $c (@$comments) {
$uids{$c->{uid}}++;
$sids{$c->{sid}}++;
}
my $uids = join(", ", sort { $a <=> $b } keys %uids);
my $sids = join(", ", sort { $a <=> $b } keys %sids);
$uid_hr = $reader->sqlSelectAllHashref(
"uid",
"uid, " . join(", ", @users_extra_cols_wanted),
"users",
"uid IN ($uids)"
);
$sid_hr = $reader->sqlSelectAllHashref(
"id",
"id, " . join(", ", @discussions_extra_cols_wanted),
"discussions",
"id IN ($sids)"
);
}
my $cids_seen = {};
my $kinds = $slashdb->getDescriptions('discussion_kinds');
for my $comment (@$comments) {
$cids_seen->{$comment->{cid}}++;
my $type;
# This works since $sid is numeric.
my $replies = $reader->countCommentsBySidPid($comment->{sid}, $comment->{cid});
# This is cached.
my $discussion = $reader->getDiscussion($comment->{sid});
#use Data::Dumper; if ($discussion && !$discussion->{dkid}) { print STDERR scalar(gmtime) . " users.pl discussion but no dkid: " . Dumper($discussion) }
if (!$discussion || !$discussion->{dkid}) {
# A comment with no accompanying discussion;
# basically we pretend it doesn't exist.
next;
} elsif ($kinds->{ $discussion->{dkid} } =~ /^journal(?:-story)?$/) {
$type = 'journal';
} elsif ($kinds->{ $discussion->{dkid} } eq 'poll') {
$type = 'poll';
} else {
$type = 'story';
}
$comment->{points} += $user->{karma_bonus}
if $user->{karma_bonus} && $comment->{karma_bonus} eq 'yes';
$comment->{points} += $user->{subscriber_bonus}
if $user->{subscriber_bonus} && $comment->{subscriber_bonus} eq 'yes';
# fix points in case they are out of bounds
$comment->{points} = $constants->{comment_minscore} if $comment->{points} < $constants->{comment_minscore};
$comment->{points} = $constants->{comment_maxscore} if $comment->{points} > $constants->{comment_maxscore};
vislenify($comment);
my $data = {
pid => $comment->{pid},
url => $discussion->{url},
disc_type => $type,
disc_title => $discussion->{title},
disc_time => $discussion->{ts},
sid => $comment->{sid},
cid => $comment->{cid},
subj => $comment->{subject},
cdate => $comment->{date},
pts => $comment->{points},
reason => $comment->{reason},
uid => $comment->{uid},
replies => $replies,
ipid => $comment->{ipid},
ipid_vis => $comment->{ipid_vis},
karma => $comment->{karma},
tweak => $comment->{tweak},
tweak_orig => $comment->{tweak_orig},
};
#Karma bonus time
for my $col (@users_extra_cols_wanted) {
$data->{$col} = $uid_hr->{$comment->{uid}}{$col} if defined $uid_hr->{$comment->{uid}}{$col};
}
for my $col(@discussions_extra_cols_wanted) {
$data->{$col} = $sid_hr->{$comment->{sid}}{$col} if defined $sid_hr->{$comment->{sid}}{$col};
}
push @$commentstruct, $data;
}
# if (grep { !defined($_->{disc_time}) || !defined($_->{sid}) } @$commentstruct) { use Data::Dumper; print STDERR "showInfo undef in commentstruct for id=$id: " . Dumper($commentstruct) }
# Sort so the chosen group of comments is sorted by discussion
@$commentstruct = sort {
$b->{disc_time} cmp $a->{disc_time} || $b->{sid} <=> $a->{sid}
} @$commentstruct
unless $user->{user_comment_sort_type} && $user->{user_comment_sort_type} == 1;
my $cid_list = [ keys %$cids_seen ];
my $cids_to_mods = {};
my $mod_reader = getObject("Slash::$constants->{m1_pluginname}", { db_type => 'reader' });
if ($constants->{m1} && $admin_flag && $constants->{show_mods_with_comments}) {
my $comment_mods = $mod_reader->getModeratorCommentLog("DESC",
$constants->{mod_limit_with_comments}, "cidin", $cid_list);
# Loop through mods and group them by the sid they're attached to
while (my $mod = shift @$comment_mods) {
push @{$cids_to_mods->{$mod->{cid}}}, $mod;
}
}
my $sub_limit = ((($admin_flag || $user->{uid} == $requested_user->{uid}) ? $constants->{submissions_all_page_size} : $constants->{submissions_accepted_only_page_size}) || "");
my $sub_options = { limit_days => 365 };
$sub_options->{accepted_only} = 1 if !$admin_flag && $user->{uid} != $requested_user->{uid};
my $sub_field = $form->{fieldname};
my ($subcount, $ret_field) = $reader->countSubmissionsByNetID($netid, $sub_field)
if $requested_user->{nonuid};
my $submissions = $reader->getSubmissionsByNetID($netid, $ret_field, $sub_limit, $sub_options)
if $requested_user->{nonuid};
my $ipid_hoursback = $constants->{istroll_ipid_hours} || 72;
my $uid_hoursback = $constants->{istroll_uid_hours} || 72;
if ($requested_user->{nonuid}) {
slashDisplay('netIDInfo', {
title => $title,
id => $id,
useredit => $requested_user,
commentstruct => $commentstruct || [],
commentcount => $commentcount,
min_comment => $min_comment,
admin_flag => $admin_flag,
admin_block => $admin_block,
netid => $netid,
netid_vis => $netid_vis,
reasons => $mod_reader->getReasons(),
subcount => $subcount,
submissions => $submissions,
hr_hours_back => $ipid_hoursback,
cids_to_mods => $cids_to_mods,
comment_time => $comment_time
});
} else {
if (! $requested_user->{uid}) {
print getError('userinfo_idnf_err', { id => $id, fieldkey => $fieldkey});
return 1;
}
$karma_flag = 1 if $admin_flag;
$requested_user->{nick_plain} = $nick ||= $requested_user->{nickname};
$nick = strip_literal($nick);
if ($requested_user->{uid} == $user->{uid}) {
$karma_flag = 1;
$nickmatch_flag = 1;
$points = $requested_user->{points};
$mod_flag = 1 if $points > 0;
$title = getTitle('userInfo_main_title', { nick => $nick, uid => $uid });
} else {
$title = getTitle('userInfo_user_title', { nick => $nick, uid => $uid });
}
my $lastjournal = _get_lastjournal($uid);
my $subcount = $reader->countSubmissionsByUID($uid);
my $submissions = $reader->getSubmissionsByUID($uid, $sub_limit, $sub_options);
my $metamods;
if ($constants->{m2} && $admin_flag) {
my $metamod_reader = getObject('Slash::Metamod', { db_type => 'reader' });
$metamods = $metamod_reader->getMetamodlogForUser($uid, 30);
}
my $tags_reader = getObject('Slash::Tags', { db_type => 'reader' });
my $tagshist = [];
if ($tags_reader && $user->{is_admin}) {
$tagshist = $tags_reader->getAllTagsFromUser($requested_user->{uid}, { orderby => 'created_at', orderdir => 'DESC', limit => 30, include_private => 1 });
}
slashDisplay('userInfo', {
title => $title,
uid => $uid,
useredit => $requested_user,
points => $points,
commentstruct => $commentstruct || [],
commentcount => $commentcount,
min_comment => $min_comment,
nickmatch_flag => $nickmatch_flag,
mod_flag => $mod_flag,
karma_flag => $karma_flag,
admin_block => $admin_block,
admin_flag => $admin_flag,
suadmin_flag => $suadmin_flag,
reasons => $mod_reader->getReasons(),
lastjournal => $lastjournal,
hr_hours_back => $ipid_hoursback,
cids_to_mods => $cids_to_mods,
comment_time => $comment_time,
submissions => $submissions,
subcount => $subcount,
metamods => $metamods,
tagshist => $tagshist
});
}
if ($user_change && %$user_change) {
$slashdb->setUser($user->{uid}, $user_change);
}
return 1;
}
sub _get_lastjournal {
my($uid) = @_;
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $lastjournal = undef;
if (my $journal = getObject('Slash::Journal', { db_type => 'reader' })) {
my $j = $journal->getsByUid($uid, 0, 1);
if ($j && @$j) {
# Yep, there are 1 or more journals... get the first.
$j = $j->[0];
}
if ($j && @$j) {
# Yep, that first journal exists and has entries...
# convert from stupid numeric array to a hashref.
my @field = qw( date article description id
posttype tid discussion );
$lastjournal = { };
for my $i (0..$#field) {
$lastjournal->{$field[$i]} = $j->[$i];
}
}
}
if ($lastjournal) {
# Strip the article field for display.
$lastjournal->{article} = strip_mode($lastjournal->{article},
$lastjournal->{posttype});
# For display, include a reduced-size version, where the
# size is based on the user's maxcomment size (which
# defaults to 4K) and can't have too many line-breaking
# tags.
my $art_shrunk = $lastjournal->{article};
my $maxsize = int($constants->{default_maxcommentsize} / 25);
$maxsize = 80 if $maxsize < 80;
$maxsize = 600 if $maxsize > 600;
$art_shrunk = chopEntity($art_shrunk, $maxsize);
my $approvedtags_break = $constants->{approvedtags_break} || [];
my $break_tag = join '|', @$approvedtags_break;
if (scalar(() = $art_shrunk =~ /<(?:$break_tag)>/gi) > 2) {
$art_shrunk =~ s/\A
(
(?: <(?:$break_tag)> )?
.*? <(?:$break_tag)>
.*?
) <(?:$break_tag)>.*
/$1/six;
if (length($art_shrunk) < 15) {
# This journal entry has too much whitespace
# in its first few chars; scrap it.
undef $art_shrunk;
}
$art_shrunk = chopEntity($art_shrunk) if defined($art_shrunk);
}
if (defined $art_shrunk) {
if (length($art_shrunk) < length($lastjournal->{article})) {
$art_shrunk .= " ...";
}
$art_shrunk = strip_html($art_shrunk);
$art_shrunk = balanceTags($art_shrunk);
}
$lastjournal->{article_shrunk} = $art_shrunk;
if ($lastjournal->{discussion}) {
$lastjournal->{commentcount} = $reader->getDiscussion(
$lastjournal->{discussion}, 'commentcount');
}
}
return $lastjournal;
}
#####################################################################
sub validateUser {
my($hr) = @_;
my $user = getCurrentUser();
my $form = getCurrentForm();
my $slashdb = getCurrentDB();
my $constants = getCurrentStatic();
# If we aren't expiring accounts in some way, we don't belong here.
if (! allowExpiry()) {
displayForm();
return;
}
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
# Since we are here, if the minimum values for the comment trigger and
# the day trigger are -1, then they should be reset to 1.
$constants->{min_expiry_comm} = $constants->{min_expiry_days} = 1
if $constants->{min_expiry_comm} <= 0 ||
$constants->{min_expiry_days} <= 0;
if ($user->{is_anon} || $user->{registered}) {
if ($user->{is_anon}) {
print getError('anon_validation_attempt');
displayForm();
return;
} else {
print getMessage('no_registration_needed')
if !$user->{reg_id};
showInfo({ uid => $user->{uid} });
return;
}
# Maybe this should be taken care of in a more centralized location?
} elsif ($user->{reg_id} eq $form->{id}) {
# We have a user and the registration IDs match. We are happy!
my($maxComm, $maxDays) = ($constants->{max_expiry_comm},
$constants->{max_expiry_days});
my($userComm, $userDays) =
($user->{user_expiry_comm}, $user->{user_expiry_days});
# Ensure both $userComm and $userDays aren't -1 (expiry has
# just been turned on).
$userComm = $constants->{min_expiry_comm}
if $userComm < $constants->{min_expiry_comm};
$userDays = $constants->{min_expiry_days}
if $userDays < $constants->{min_expiry_days};
my $exp = $constants->{expiry_exponent};
# Increment only the trigger that was used.
my $new_comment_expiry = ($maxComm > 0 && $userComm > $maxComm)
? $maxComm
: $userComm * (($user->{expiry_comm} < 0)
? $exp
: 1
);
my $new_days_expiry = ($maxDays > 0 && $userDays > $maxDays)
? $maxDays
: $userDays * (($user->{expiry_days} < 0)
? $exp
: 1
);
# Reset re-registration triggers for user.
$slashdb->setUser($user->{uid}, {
'expiry_comm' => $new_comment_expiry,
'expiry_days' => $new_days_expiry,
'user_expiry_comm' => $new_comment_expiry,
'user_expiry_days' => $new_days_expiry,
});
# Handles rest of re-registration process.
setUserExpired($user->{uid}, 0);
}
slashDisplay('regResult');
}
#####################################################################
sub editTags {
my($hr) = @_;
my $slashdb = getCurrentDB();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $note = $hr->{note} || "";
return if $user->{is_anon}; # shouldn't be, but can't hurt to check
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
my $user_edit = $slashdb->getUser($user->{uid});
my $title = getTitle('editTags_title');
slashDisplay('editTags', {
user_edit => $user_edit,
title => $title,
note => $note,
});
}
sub saveTags {
my($hr) = @_;
my $slashdb = getCurrentDB();
my $user = getCurrentUser();
my $form = getCurrentForm();
my $constants = getCurrentStatic();
return if $user->{is_anon}; # shouldn't be, but can't hurt to check
$slashdb->setUser($user->{uid}, {
tags_turnedoff => $form->{showtags} ? '' : 1 });
editTags({ note => getMessage('savetags_msg') });
}
#####################################################################
sub showTags {
my($hr) = @_;
my $user = getCurrentUser();
my $form = getCurrentForm();
my $slashdb = getCurrentDB();
my $constants = getCurrentStatic();
my $tags_reader = getObject('Slash::Tags', { db_type => 'reader' });
# XXX if $user_edit->{acl}{spammer}, either abort or put ref=nofollow in all links
my $tagname = $form->{tagname} || '';
$tagname = '' if !$tags_reader->tagnameSyntaxOK($tagname);
my($uid, $user_edit);
if ($form->{uid} || $form->{nick}) {
$uid = $form->{uid} || $tags_reader->getUserUID($form->{nick});
$user_edit = $tags_reader->getUser($uid);
}
if (!$user_edit || $user_edit->{is_anon}) {
$uid = $user->{uid};
$user_edit = $user;
}
my $nickname = $user_edit->{nickname};
if (!$constants->{plugin}{Tags}) {
print getError('bad_op', { op => $form->{op}});
return;
}
my $tagnameid = $tags_reader->getTagnameidFromNameIfExists($tagname);
if ($tagnameid) {
# Show all user's tags for one particular tagname.
my $tags_hr = $tags_reader->getGroupedTagsFromUser($user_edit->{uid},
{ tagnameid => $tagnameid });
my $tags_ar = $tags_hr->{$tagname} || [ ];
slashDisplay('usertagsforname', {
useredit => $user_edit,
tagname => $tagname,
tags => $tags_ar,
});
} else {
my $tags_hr = $tags_reader->getGroupedTagsFromUser($user_edit->{uid});
my $num_tags = 0;
for my $tn (keys %$tags_hr) {
$num_tags += scalar @{ $tags_hr->{$tn} };
}
my $cutoff = $constants->{tags_usershow_cutoff} || 200;
if ($num_tags <= $cutoff) {
# Show all user's tags, grouped by tagname.
slashDisplay('usertags', {
useredit => $user_edit,
tags_grouped => $tags_hr,
});
} else {
# Show all user's tagnames, with links to show all
# tags for each particular tagname.
my $tagname_ar = [ sort keys %$tags_hr ];
slashDisplay('usertagnames', {
useredit => $user_edit,
tagnames => $tagname_ar,
});
}
}
}
#################################################################
sub showBookmarks {
my($hr) = @_;
my $user = getCurrentUser();
my $form = getCurrentForm();
my $slashdb = getCurrentDB();
my $constants = getCurrentStatic();
my $tags_reader = getObject('Slash::Tags', { db_type => 'reader' });
my($uid, $user_edit);
if ($form->{uid} || $form->{nick}) {
$uid = $form->{uid} || $tags_reader->getUserUID($form->{nick});
$user_edit = $tags_reader->getUser($uid);
}
if (!$user_edit || $user_edit->{is_anon}) {
$uid = $user->{uid};
$user_edit = $user;
}
my $nickname = $user_edit->{nickname};
if (!$constants->{plugin}{Tags}) {
print getError('bad_op', { op => $form->{op}});
return;
}
my $tags_ar = $tags_reader->getGroupedTagsFromUser($user_edit->{uid}, { type => "urls", only_bookmarked => 1 });
slashDisplay('userbookmarks', {
useredit => $user_edit,
tags_grouped => $tags_ar,
});
}
#################################################################
sub editKey {
my($uid) = @_;
my $slashdb = getCurrentDB();
my $pubkey = $slashdb->getUser($uid, 'pubkey');
my $editkey = slashDisplay('editKey', { pubkey => $pubkey }, 1);
return $editkey;
}
#################################################################
# We arrive here without header() having been called. Some of the
# functions we dispatch to call it, some do not.
sub adminDispatch {
my($hr) = @_;
my $form = getCurrentForm();
my $op = $hr->{op} || $form->{op};
if ($op eq 'authoredit') {
# editUser() does not call header(), so we DO need to.
header(getMessage('user_header'), '', {}) or return;
editUser($hr);
} elsif ($form->{saveuseradmin}) {
# saveUserAdmin() tail-calls showInfo(), which calls
# header(), so we need to NOT.
saveUserAdmin($hr);
} elsif ($form->{userinfo}) {
# showInfo() calls header(), so we need to NOT.
showInfo($hr);
} elsif ($form->{userfield}) {
# none of these calls header(), so we DO need to.
header(getMessage('user_header'), '', {}) or return;
if ($form->{edituser}) {
editUser($hr);
} elsif ($form->{edithome}) {
editHome($hr);
} elsif ($form->{editcomm}) {
editComm($hr);
} elsif ($form->{changepasswd}) {
changePasswd($hr);
}
} else {
# showInfo() calls header(), so we need to NOT.
showInfo($hr);
}
}
#################################################################
sub tildeEd {
my($user_edit) = @_;
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $constants = getCurrentStatic();
my %story023_default = (
author => { },
nexus => { },
topic => { },
);
my %prefs = ( );
for my $field (qw(
story_never_topic story_never_author story_never_nexus
story_always_topic story_always_author story_always_nexus story_brief_always_nexus
story_full_brief_nexus story_full_best_nexus story_brief_best_nexus
)) {
for my $id (
grep /^\d+$/,
split /,/,
($user_edit->{$field} || "")
) {
$prefs{$field}{$id} = 1;
}
}
#print STDERR scalar(localtime) . " prefs: " . Dumper(\%prefs);
# Set up $author_hr, @aid_order, and $story023_default{author}.
my $author_hr = $reader->getDescriptions('authors');
my @aid_order = sort { lc $author_hr->{$a} cmp lc $author_hr->{$b} } keys %$author_hr;
for my $aid (@aid_order) {
if ($prefs{story_never_author}{$aid}) {
$story023_default{author}{$aid} = 0;
} elsif ($prefs{story_always_author}{$aid}) {
$story023_default{author}{$aid} = 3;
} else {
$story023_default{author}{$aid} = 2;
}
}
# Set up $topic_hr, @topictid_order, and $story023_default{topic}.
my $topic_hr = $reader->getDescriptions('non_nexus_topics-storypickable');
my @topictid_order = sort { lc $topic_hr->{$a} cmp lc $topic_hr->{$b} } keys %$topic_hr;
for my $tid (@topictid_order) {
if ($prefs{story_never_topic}{$tid}) {
$story023_default{topic}{$tid} = 0;
} elsif ($prefs{story_always_topic}{$tid}) {
$story023_default{topic}{$tid} = 3;
} else {
$story023_default{topic}{$tid} = 2;
}
}
# Set up $nexus_hr, @nexustid_order, and $story023_default{nexus}.
my $topic_tree = $reader->getTopicTree();
my $nexus_tids_ar = $reader->getStorypickableNexusChildren($constants->{mainpage_nexus_tid}, 1);
my $nexus_hr = { };
for my $tid (@$nexus_tids_ar) {
$nexus_hr->{$tid} = $topic_tree->{$tid}{textname};
}
my @nexustid_order = sort {($b == $constants->{mainpage_nexus_tid}) <=> ($a == $constants->{mainpage_nexus_tid}) ||
lc $nexus_hr->{$a} cmp lc $nexus_hr->{$b} } keys %$nexus_hr;
my $mp_disp_nexuses = $reader->getMainpageDisplayableNexuses();
my %mp_disp_nexus = ( map { ($_, 1) } @$mp_disp_nexuses );
for my $tid (@nexustid_order) {
if ($prefs{story_never_nexus}{$tid}) {
$story023_default{nexus}{$tid} = 0;
} elsif ($prefs{story_always_nexus}{$tid}) {
$story023_default{nexus}{$tid} = 5;
} elsif ($prefs{story_full_brief_nexus}{$tid}) {
$story023_default{nexus}{$tid} = 4;
} elsif ($prefs{story_brief_always_nexus}{$tid}) {
$story023_default{nexus}{$tid} = 3;
} elsif ($prefs{story_full_best_nexus}{$tid}) {
$story023_default{nexus}{$tid} = 2;
} elsif ($prefs{story_brief_best_nexus}{$tid}) {
$story023_default{nexus}{$tid} = 1;
} else {
# If brief_sectional_mainpage is set, then all
# nexuses in getMainpageDisplayableNexuses are,
# by default, shown as brief on the mainpage.
if ($constants->{brief_sectional_mainpage}
&& $mp_disp_nexus{$tid}
) {
$story023_default{nexus}{$tid} = 4;
} else {
$story023_default{nexus}{$tid} = 2;
}
}
}
# Set up $section_descref and $box_order, used to decide which
# slashboxes appear. Really this doesn't seem to have anything
# to do with sections, so I'm not sure why it's called
# "section"_descref.
my $section_descref = { };
my $box_order;
my $sections_description = $reader->getSectionBlocks();
# the names of all the boxes in @{$skinBoxes->{$constants->{mainpage_skid}}}
# should be unioned into sections_description. whether the
# values are 0 or 1 is calculated correctly, but we're
# missing some 0's that should appear, I think, under
# some circumstances. ah heck, the whole concept of
# sectional slashboxes should be redone (why the heck
# do we have skinname_more instead of just a block
# called olderstories?)
my $slashboxes_hr = { };
my $slashboxes_textlist = $user_edit->{slashboxes};
if (!$slashboxes_textlist) {
# Use the default.
my($boxes, $skinBoxes) = $reader->getPortalsCommon();
$slashboxes_textlist = join ",", @{$skinBoxes->{$constants->{mainpage_skid}}};
}
for my $bid (
map { /^'?([^']+)'?$/; $1 }
split /,/,
$slashboxes_textlist
) {
$slashboxes_hr->{$bid} = 1;
}
for my $ary (sort { lc $a->[1] cmp lc $b->[1]} @$sections_description) {
my($bid, $title, $boldflag) = @$ary;
push @$box_order, $bid;
$section_descref->{$bid}{checked} =
$slashboxes_hr->{$bid}
? $constants->{markup_checked_attribute}
: '';
$title =~ s/<(.*?)>//g;
$section_descref->{$bid}{title} = $title;
}
my $dynamic_blocks = getObject("Slash::DynamicBlocks");
my $extra_blocks = [];
if ($dynamic_blocks) {
my $userblocks = $dynamic_blocks->getUserBlocks("name", $user_edit->{uid}) || {};
my $friendblocks = $dynamic_blocks->getFriendBlocks("name", $user_edit->{uid}) || {};
push(@$extra_blocks, grep { $slashboxes_textlist =~ $_; } (keys(%$userblocks), keys(%$friendblocks)));
}
# Userspace.
my $userspace = $user_edit->{mylinks} || "";
# Titles of stuff.
my $tildeEd_title = getTitle('tildeEd_title');
my $criteria_msg = getMessage('tilded_criteria_msg');
my $customize_title = getTitle('tildeEd_customize_title');
my $tilded_customize_msg = getMessage('tilded_customize_msg',
{ userspace => $userspace });
my $tilded_box_msg = getMessage('tilded_box_msg');
my $tilde_ed = slashDisplay('tildeEd', {
user_edit => $user_edit,
title => $tildeEd_title,
criteria_msg => $criteria_msg,
customize_title => $customize_title,
tilded_customize_msg => $tilded_customize_msg,
tilded_box_msg => $tilded_box_msg,
story023_default => \%story023_default,
authorref => $author_hr,
aid_order => \@aid_order,
topicref => $topic_hr,
topictid_order => \@topictid_order,
nexusref => $nexus_hr,
nexustid_order => \@nexustid_order,
section_descref => $section_descref,
box_order => $box_order,
userspace => $userspace,
extra_blocks => $extra_blocks,
}, 1);
return $tilde_ed;
}
#################################################################
sub changePasswd {
my($hr) = @_;
my $form = getCurrentForm();
my $slashdb = getCurrentDB();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
my $user_edit = {};
my $title;
my $suadmin_flag = ($user->{seclev} >= 10000) ? 1 : 0;
my $admin_flag = ($user->{is_admin}) ? 1 : 0;
my $admin_block = '';
my $id = '';
if ($admin_flag) {
if ($form->{userfield}) {
$id ||= $form->{userfield};
if ($id =~ /^\d+$/) {
$user_edit = $slashdb->getUser($id);
} else {
$user_edit = $slashdb->getUser($slashdb->getUserUID($id));
}
} else {
$user_edit = $id eq '' ? $user : $slashdb->getUser($id);
$id = $user_edit->{uid};
}
} else {
$id = $user->{uid};
$user_edit = $user;
}
$admin_block = getUserAdmin($id, 'uid', 1) if $admin_flag;
# print getMessage('note', { note => $form->{note}}) if $form->{note};
$title = getTitle('changePasswd_title', { user_edit => $user_edit });
my $session = $slashdb->getDescriptions('session_login');
my $session_select = createSelect('session_login', $session, $user_edit->{session_login}, 1);
my $clocation = $slashdb->getDescriptions('cookie_location');
my @clocation_order = grep { exists $clocation->{$_} } qw(none classbid subnetid ipid);
my $clocation_select = createSelect('cookie_location', $clocation,
$user_edit->{cookie_location}, 1, 0, \@clocation_order
);
my $got_oldpass = 0;
if ($form->{oldpass}) {
my $return_uid = $slashdb->getUserAuthenticate($id, $form->{oldpass}, 1);
$got_oldpass = 1 if $return_uid && $id == $return_uid;
}
slashDisplay('changePasswd', {
useredit => $user_edit,
admin_flag => $suadmin_flag,
title => $title,
session => $session_select,
clocation => $clocation_select,
admin_block => $admin_block,
got_oldpass => $got_oldpass
});
}
#################################################################
sub editUser {
my($hr) = @_;
my $id = $hr->{uid} || '';
my $note = $hr->{note} || '';
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
my $form = getCurrentForm();
my $slashdb = getCurrentDB();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $plugins = $slashdb->getDescriptions('plugins');
my $user_edit = {};
my($admin_block, $title);
my $admin_flag = ($user->{is_admin}) ? 1 : 0;
my $fieldkey;
if ($admin_flag && $form->{userfield}) {
$id ||= $form->{userfield};
if ($form->{userfield} =~ /^\d+$/) {
$user_edit = $slashdb->getUser($id);
$fieldkey = 'uid';
} else {
$user_edit = $slashdb->getUser($slashdb->getUserUID($id));
$fieldkey = 'nickname';
}
} else {
$user_edit = $id eq '' ? $user : $slashdb->getUser($id);
$fieldkey = 'uid';
$id = $user_edit->{uid};
}
return if isAnon($user_edit->{uid}) && ! $admin_flag;
$admin_block = getUserAdmin($id, $fieldkey, 1) if $admin_flag;
$user_edit->{homepage} ||= "http://";
# Remove domain tags, they'll be added back in, in saveUser.
for my $dat (@{$user_edit}{qw(sig bio)}) {
$dat = parseDomainTags($dat, 0, 1);
}
$title = getTitle('editUser_title', { user_edit => $user_edit});
my $editkey = "";
$editkey = editKey($user_edit->{uid}) if $fieldkey eq 'uid' && $plugins->{PubKey};
slashDisplay('editUser', {
useredit => $user_edit,
admin_flag => $admin_flag,
title => $title,
editkey => $editkey,
admin_block => $admin_block,
note => $note,
});
}
#################################################################
sub editHome {
my($hr) = @_;
my $id = $hr->{uid} || '';
my $note = $hr->{note} || '';
my $slashdb = getCurrentDB();
my $form = getCurrentForm();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
my($formats, $title, $tzformat_select);
my $user_edit = {};
my $fieldkey;
my $admin_flag = ($user->{is_admin}) ? 1 : 0;
my $admin_block = '';
if ($admin_flag && $form->{userfield}) {
$id ||= $form->{userfield};
if ($form->{userfield} =~ /^\d+$/) {
$user_edit = $slashdb->getUser($id);
$fieldkey = 'uid';
} else {
$user_edit = $slashdb->getUser($slashdb->getUserUID($id));
$fieldkey = 'nickname';
}
} else {
$user_edit = $id eq '' ? $user : $slashdb->getUser($id);
$fieldkey = 'uid';
}
#use Data::Dumper; $Data::Dumper::Sortkeys = 1; print STDERR scalar(localtime) . " user_edit: " . Dumper($user_edit);
return if isAnon($user_edit->{uid}) && ! $admin_flag;
$admin_block = getUserAdmin($id, $fieldkey, 1) if $admin_flag;
$title = getTitle('editHome_title');
return if $user->{seclev} < 100 && isAnon($user_edit->{uid});
$formats = $slashdb->getDescriptions('dateformats');
$tzformat_select = createSelect('tzformat', $formats, $user_edit->{dfid}, 1);
my $lb_check = $user_edit->{lowbandwidth} ? $constants->{markup_checked_attribute} : '';
my $sd_check = $user_edit->{simpledesign} ? $constants->{markup_checked_attribute} : '';
my $i_check = $user_edit->{noicons} ? $constants->{markup_checked_attribute} : '';
my $w_check = $user_edit->{willing} ? $constants->{markup_checked_attribute} : '';
my $classic_check = $user_edit->{index_classic} ? $constants->{markup_checked_attribute} : '';
my $tilde_ed = tildeEd($user_edit);
slashDisplay('editHome', {
title => $title,
admin_block => $admin_block,
user_edit => $user_edit,
tzformat_select => $tzformat_select,
i_check => $i_check,
w_check => $w_check,
lb_check => $lb_check,
sd_check => $sd_check,
classic_check => $classic_check,
tilde_ed => $tilde_ed,
note => $note,
});
}
#################################################################
sub editComm {
my($hr) = @_;
my $id = $hr->{uid} || '';
my $note = $hr->{note} || '';
my $slashdb = getCurrentDB();
my $form = getCurrentForm();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $user_edit = {};
my($formats, $commentmodes_select, $commentsort_select, $title,
$uthreshold_select, $highlightthresh_select, $posttype_select,
$bytelimit_select);
my $admin_block = '';
my $fieldkey;
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
my $admin_flag = $user->{is_admin} ? 1 : 0;
if ($admin_flag && $form->{userfield}) {
$id ||= $form->{userfield};
if ($form->{userfield} =~ /^\d+$/) {
$user_edit = $slashdb->getUser($id);
$fieldkey = 'uid';
} else {
$user_edit = $slashdb->getUser($slashdb->getUserUID($id));
$fieldkey = 'nickname';
}
} else {
$user_edit = $id eq '' ? $user : $slashdb->getUser($id);
$fieldkey = 'uid';
}
my $hi = $constants->{comment_maxscore} - $constants->{comment_minscore};
my $lo = -$hi;
my @range = map { $_ > 0 ? "+$_" : $_ } ($lo .. $hi);
my @reasons = ( );
my %reason_select = ( );
if ($constants->{m1}) {
my $mod_reader = getObject("Slash::$constants->{m1_pluginname}", { db_type => 'reader' });
my $reasons = $mod_reader->getReasons();
for my $id (sort { $a <=> $b } keys %$reasons) {
push @reasons, $reasons->{$id}{name};
}
# Reason modifiers
for my $reason_name (@reasons) {
my $key = "reason_alter_$reason_name";
$reason_select{$reason_name} = createSelect(
$key, \@range,
$user_edit->{$key} || 0, 1, 1
);
}
}
# Zoo relation modifiers
my %people_select;
my @people = qw(friend foe anonymous fof eof freak fan);
for (@people) {
my $key = "people_bonus_$_";
$people_select{$_} = createSelect($key, \@range,
$user_edit->{$key} || 0, 1, 1
);
}
# New-user modifier
my $new_user_bonus_select = createSelect('new_user_bonus', \@range,
$user_edit->{new_user_bonus} || 0, 1, 1);
my $new_user_percent_select = createSelect('new_user_percent',
[( 1..15, 20, 25, 30, 35, 40, 45, 50, 55,
60, 65, 70, 75, 80, 85, 90, 95 )],
$user_edit->{new_user_percent} || 100, 1, 1);
# Karma modifier
my $karma_bonus = createSelect('karma_bonus', \@range,
$user_edit->{karma_bonus} || 0, 1, 1);
# Subscriber modifier
my $subscriber_bonus = createSelect('subscriber_bonus', \@range,
$user_edit->{subscriber_bonus} || 0, 1, 1);
# Length modifier
my $small_length_bonus_select = createSelect('clsmall_bonus', \@range,
$user_edit->{clsmall_bonus} || 0, 1, 1);
my $long_length_bonus_select = createSelect('clbig_bonus', \@range,
$user_edit->{clbig_bonus} || 0, 1, 1);
return if isAnon($user_edit->{uid}) && ! $admin_flag;
$admin_block = getUserAdmin($id, $fieldkey, 1) if $admin_flag;
$title = getTitle('editComm_title');
$formats = $slashdb->getDescriptions('commentmodes');
$commentmodes_select=createSelect('umode', $formats, $user_edit->{mode}, 1);
$formats = $slashdb->getDescriptions('sortcodes');
$commentsort_select = createSelect(
'commentsort', $formats, $user_edit->{commentsort}, 1
);
$formats = $slashdb->getDescriptions('threshcodes');
$uthreshold_select = createSelect(
'uthreshold', $formats, $user_edit->{threshold}, 1
);
$formats = $slashdb->getDescriptions('threshcodes');
$highlightthresh_select = createSelect(
'highlightthresh', $formats, $user_edit->{highlightthresh}, 1
);
$user_edit->{bytelimit} = $constants->{defaultbytelimit}
if $user_edit->{bytelimit} < 0 || $user_edit->{bytelimit} > 7;
my $bytelimit_desc = $user_edit->{is_subscriber} ? 'bytelimit' : 'bytelimit_sub';
$formats = $slashdb->getDescriptions($bytelimit_desc);
$bytelimit_select = createSelect(
'bytelimit', $formats, $user_edit->{bytelimit}, 1
);
my $h_check = $user_edit->{hardthresh} ? $constants->{markup_checked_attribute} : '';
my $r_check = $user_edit->{reparent} ? $constants->{markup_checked_attribute} : '';
my $n_check = $user_edit->{noscores} ? $constants->{markup_checked_attribute} : '';
my $s_check = $user_edit->{nosigs} ? $constants->{markup_checked_attribute} : '';
my $b_check = $user_edit->{nobonus} ? $constants->{markup_checked_attribute} : '';
my $sb_check = $user_edit->{nosubscriberbonus} ? $constants->{markup_checked_attribute} : '';
my $p_check = $user_edit->{postanon} ? $constants->{markup_checked_attribute} : '';
my $nospell_check = $user_edit->{no_spell} ? $constants->{markup_checked_attribute} : '';
my $s_mod_check = $user_edit->{mod_with_comm} ? $constants->{markup_checked_attribute} : '';
my $s_m2_check = $user_edit->{m2_with_mod} ? $constants->{markup_checked_attribute} : '';
my $s_m2c_check = $user_edit->{m2_with_comm_mod} ? $constants->{markup_checked_attribute} : '';
$formats = $slashdb->getDescriptions('postmodes');
$posttype_select = createSelect(
'posttype', $formats, $user_edit->{posttype}, 1
);
slashDisplay('editComm', {
title => $title,
admin_block => $admin_block,
user_edit => $user_edit,
h_check => $h_check,
r_check => $r_check,
n_check => $n_check,
s_check => $s_check,
b_check => $b_check,
sb_check => $sb_check,
p_check => $p_check,
s_mod_check => $s_mod_check,
s_m2_check => $s_m2_check,
s_m2c_check => $s_m2c_check,
nospell_check => $nospell_check,
commentmodes_select => $commentmodes_select,
commentsort_select => $commentsort_select,
highlightthresh_select => $highlightthresh_select,
uthreshold_select => $uthreshold_select,
posttype_select => $posttype_select,
reasons => \@reasons,
reason_select => \%reason_select,
people => \@people,
people_select => \%people_select,
new_user_percent_select => $new_user_percent_select,
new_user_bonus_select => $new_user_bonus_select,
note => $note,
karma_bonus => $karma_bonus,
subscriber_bonus => $subscriber_bonus,
small_length_bonus_select => $small_length_bonus_select,
long_length_bonus_select => $long_length_bonus_select,
bytelimit_select => $bytelimit_select,
});
}
#################################################################
sub saveUserAdmin {
my($hr) = @_;
my $slashdb = getCurrentDB();
my $form = getCurrentForm();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my($user_edits_table, $user_edit) = ({}, {});
my $author_flag;
my $note = '';
my $srcid;
my $id;
my $user_editfield_flag;
my $banned = 0;
my $banref;
if ($form->{uid}) {
$user_editfield_flag = 'uid';
$id = $form->{uid};
$user_edit = $slashdb->getUser($id);
$srcid = $id;
} elsif ($form->{subnetid}) {
$user_editfield_flag = 'subnetid';
($id, $user_edit->{subnetid}) = ($form->{subnetid}, $form->{subnetid});
$user_edit->{nonuid} = 1;
$srcid = convert_srcid(subnetid => $id);
} elsif ($form->{ipid}) {
$user_editfield_flag = 'ipid';
($id, $user_edit->{ipid}) = ($form->{ipid}, $form->{ipid});
$user_edit->{nonuid} = 1;
$srcid = convert_srcid(ipid => $id);
} elsif ($form->{md5id}) {
$user_editfield_flag = 'md5id';
my $fieldname = $form->{fieldname} || 'md5id';
($id, $user_edit->{$fieldname})
= ($form->{md5id}, $form->{md5id});
warn "form field md5id specified, no srcid saving possible";
} elsif ($form->{srcid}) {
$user_editfield_flag = 'srcid';
my $fieldname = $form->{fieldname} || 'srcid';
($id, $user_edit->{$fieldname})
= ($form->{srcid}, $form->{srcid});
$srcid = $id;
} else {
# If we were not fed valid data, don't do anything.
return ;
}
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $all_al2types = $reader->getAL2Types;
my $al2_change = { };
# First, get a hash of what aclams (AL2's and ACLs) this user
# had when the previous admin page was loaded.
# XXXSRCID Right now acl_old is just calculated for debugging
# printing purposes, not actually used.
my @al2_old = ( );
@al2_old =
@{ $form->{al2_old_multiple} } if $form->{al2_old_multiple};
my %al2_old = ( map { ($_, 1) } @al2_old );
my @acl_old = ( );
@acl_old =
@{ $form->{acl_old_multiple} } if $form->{acl_old_multiple};
my %acl_old = ( map { ($_, 1) } @acl_old );
# Next, get the list of the new data submitted. Separate
# it out into AL2's which are legitimate. Anything left
# over is an ACL.
my @al2_new_formfields = ( );
@al2_new_formfields = @{ $form->{aclams_new_multiple} } if $form->{aclams_new_multiple};
my @al2_new_submitted = map { s/^aclam_//; $_ } @al2_new_formfields;
my @al2_new = grep { exists $all_al2types->{$_} } @al2_new_submitted;
my %al2_new = ( map { ($_, 1) } @al2_new );
my @acl_new = grep { !$al2_new{$_} } @al2_new_submitted;
my %acl_new = ( map { ($_, 1) } @acl_new );
# Find out what changed for AL2's.
for my $al2 (@al2_old, @al2_new) {
next if defined($al2_old{$al2}) && defined($al2_new{$al2})
&& $al2_old{$al2} == $al2_new{$al2};
$al2_change->{$al2} = $al2_new{$al2} ? 1 : 0;
}
#print STDERR "al2_change for '$srcid': " . Dumper($al2_change);
# If there's a comment, throw that in.
if ($form->{al2_new_comment}) {
$al2_change->{comment} = $form->{al2_new_comment};
}
$al2_change = undef if !keys %$al2_change;
# Find out what changed for ACL's.
my $acl_change = { };
for my $acl (@acl_old, @acl_new) {
next if $acl_old{$acl} == $acl_new{$acl};
$acl_change->{$acl} = $acl_new{$acl} ? 1 : 0;
}
$acl_change = undef if !keys %$acl_change;
if ($user->{is_admin} && $srcid) {
$slashdb->setAL2($srcid, $al2_change);
}
if ($user->{is_admin} && ($user_editfield_flag eq 'uid' ||
$user_editfield_flag eq 'nickname')) {
# This admin user cannot assign a seclev higher than he/she
# already has.
my $seclev = $form->{seclev};
$seclev = $user->{seclev} if $seclev > $user->{seclev};
$user_edits_table->{seclev} = $seclev;
$user_edits_table->{section} = $form->{section};
$user_edits_table->{author} = $form->{author} ? 1 : 0 ;
$user_edits_table->{defaultpoints} = $form->{defaultpoints};
$user_edits_table->{tokens} = $form->{tokens};
$user_edits_table->{tag_clout} = $form->{tag_clout};
$user_edits_table->{m2info} = $form->{m2info};
$user_edits_table->{acl} = $acl_change if $acl_change;
$user_edits_table->{shill_static_marquee} = $form->{shill_static_marquee} ? 1 : undef;
$user_edits_table->{u2_friends_bios} = $form->{u2_friends_bios} ? 1 : undef;
$user_edits_table->{shill_rss_url} = $form->{shill_rss_url} ? $form->{shill_rss_url} : undef;
my $author = $slashdb->getAuthor($id);
my $was_author = ($author && $author->{author}) ? 1 : 0;
$slashdb->setUser($id, $user_edits_table);
$note .= getMessage('saveuseradmin_saveduser', { field => $user_editfield_flag, id => $id });
if ($was_author xor $user_edits_table->{author}) {
# A frequently-asked question for new Slash admins is
# why their authors aren't showing up immediately.
# Give them some help here with an informative message.
$note .= getMessage('saveuseradmin_authorchg', {
basedir => $slashdb->getDescriptions("site_info")
->{base_install_directory},
virtuser => $slashdb->{virtual_user},
});
}
}
if (!$user_edit->{nonuid}) {
if ($form->{expired} && $form->{expired} eq 'on') {
# $slashdb->setExpired($user_edit->{uid});
} else {
# $slashdb->setUnexpired($user_edit->{uid});
}
}
my $data = { uid => $id };
$data->{note} = $note if defined $note;
showInfo($data);
}
#################################################################
sub savePasswd {
my($hr) = @_;
my $note = $hr->{noteref} || undef;
my $slashdb = getCurrentDB();
my $form = getCurrentForm();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $error_flag = 0;
my $user_edit = {};
my $uid;
my $user_edits_table = {};
if ($user->{is_admin}) {
$uid = $form->{uid} || $user->{uid};
} else {
$uid = ($user->{uid} == $form->{uid}) ? $form->{uid} : $user->{uid};
}
$user_edit = $slashdb->getUser($uid);
if (!$user_edit->{nickname}) {
$$note .= getError('cookie_err', { titlebar => 0 }, 0, 1)
if $note;
$error_flag++;
}
if ($form->{pass1} ne $form->{pass2}) {
$$note .= getError('saveuser_passnomatch_err', { titlebar => 0 }, 0, 1)
if $note;
$error_flag++;
}
if (!$form->{pass1} || length $form->{pass1} < 6) {
$$note .= getError('saveuser_passtooshort_err', { titlebar => 0 }, 0, 1)
if $note;
$error_flag++;
}
if (!$user->{is_admin}){
# not an admin -- check old password before changing passwd
my $return_uid = $slashdb->getUserAuthenticate($uid, $form->{oldpass}, 1);
if (!$return_uid || $return_uid != $uid) {
$$note .= getError('saveuser_badoldpass_err', { titlebar => 0 }, 0, 1)
if $note;
$error_flag++;
}
}
if (! $error_flag) {
$user_edits_table->{passwd} = $form->{pass1} if $form->{pass1};
$user_edits_table->{session_login} = $form->{session_login};
$user_edits_table->{cookie_location} = $form->{cookie_location};
# changed pass, so delete all logtokens
$slashdb->deleteLogToken($form->{uid}, 1);
if ($user->{admin_clearpass}
&& !$user->{state}{admin_clearpass_thisclick}) {
# User is an admin who sent their password in the clear
# some time ago; now that it's been changed, we'll forget
# about that incident, unless this click was sent in the
# clear as well.
$user_edits_table->{admin_clearpass} = '';
}
getOtherUserParams($user_edits_table);
$slashdb->setUser($uid, $user_edits_table) ;
$$note .= getMessage('saveuser_passchanged_msg',
{ nick => $user_edit->{nickname}, uid => $user_edit->{uid} },
0, 1) if $note;
# only set cookie if user is current user
if ($form->{uid} eq $user->{uid}) {
$user->{logtoken} = bakeUserCookie($uid, $slashdb->getLogToken($form->{uid}, 1));
setCookie('user', $user->{logtoken}, $user_edits_table->{session_login});
}
}
return $error_flag;
}
#################################################################
sub saveUser {
my($hr) = @_;
my $slashdb = getCurrentDB();
my $form = getCurrentForm();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $gSkin = getCurrentSkin();
my $plugins = $slashdb->getDescriptions('plugins');
my $uid;
my $user_editfield_flag;
$uid = $user->{is_admin} && $form->{uid} ? $form->{uid} : $user->{uid};
my $user_edit = $slashdb->getUser($uid);
my($note, $formname);
$note .= getMessage('savenickname_msg', {
nickname => $user_edit->{nickname},
}, 1);
if (!$user_edit->{nickname}) {
$note .= getError('cookie_err', 0, 1);
}
# Check to ensure that if a user is changing his email address, that
# it doesn't already exist in the userbase.
if ($user_edit->{realemail} ne $form->{realemail}) {
if ($slashdb->existsEmail($form->{realemail})) {
$note .= getError('emailexists_err', 0, 1);
$form->{realemail} = $user_edit->{realemail}; # can't change!
}
}
my(%extr, $err_message, %limit);
$limit{sig} = 120; # schema is 200, give an extra buffer for domain tags
$limit{bio} = $constants->{users_bio_length} || 1024; # can be up to 2^16
for my $key (keys %limit) {
my $dat = chopEntity($form->{$key}, $limit{$key});
$dat = strip_html($dat);
$dat = balanceTags($dat, { deep_nesting => 2, length => $limit{$key} });
$dat = addDomainTags($dat) if $dat;
# If the sig becomes too long to fit (domain tagging causes
# string expansion and tag balancing can too), warn the user to
# use shorter domain names and don't save their change.
if ($key eq 'sig' && defined($dat) && length($dat) > 200) {
print getError('sig_too_long_err');
$extr{sig} = undef;
}
# really, comment filters should ignore short length IMO ... oh well.
if (length($dat) > 1 && ! filterOk('comments', 'postersubj', $dat, \$err_message)) {
print getError('filter message', {
err_message => $err_message,
item => $key,
});
$extr{$key} = undef;
} elsif (! compressOk('comments', 'postersubj', $dat)) {
print getError('compress filter', {
ratio => 'postersubj',
item => $key,
});
$extr{$key} = undef;
} else {
$extr{$key} = $dat;
}
}
# We should do some conformance checking on a user's pubkey,
# make sure it looks like one of the known types of public
# key. Until then, just make sure it doesn't have HTML.
$form->{pubkey} = $plugins->{'PubKey'} ? strip_nohtml($form->{pubkey}, 1) : '';
my $homepage = $form->{homepage};
$homepage = '' if $homepage eq 'http://';
$homepage = fudgeurl($homepage);
$homepage = URI->new_abs($homepage, $gSkin->{absolutedir})
->canonical
->as_string if $homepage ne '';
$homepage = substr($homepage, 0, 100) if $homepage ne '';
my $calendar_url = $form->{calendar_url};
if (length $calendar_url) {
# fudgeurl() doesn't like webcal; will remove later anyway
$calendar_url =~ s/^webcal/http/i;
$calendar_url = fudgeurl($calendar_url);
$calendar_url = URI->new_abs($calendar_url, $gSkin->{absolutedir})
->canonical
->as_string if $calendar_url ne '';
$calendar_url =~ s|^http://||i;
$calendar_url = substr($calendar_url, 0, 200) if $calendar_url ne '';
}
# for the users table
my $user_edits_table = {
homepage => $homepage,
realname => $form->{realname},
pubkey => $form->{pubkey},
copy => $form->{copy},
quote => $form->{quote},
calendar_url => $calendar_url,
yahoo => $form->{yahoo},
jabber => $form->{jabber},
aim => $form->{aim},
aimdisplay => $form->{aimdisplay},
icq => $form->{icq},
playing => $form->{playing},
mobile_text_address => $form->{mobile_text_address},
};
if ($constants->{wow}) {
my $wowdb = getObject("Slash::WoW");
if ($wowdb) {
$user_edits_table->{wow_main_name} = "\L\u$form->{wow_main_name}";
$user_edits_table->{wow_main_realm} = $form->{wow_main_realm};
my $charid = $wowdb->getCharidCreate($user_edits_table->{wow_main_realm},
$user_edits_table->{wow_main_name});
$wowdb->setChar($charid, { uid => $uid }, { if_unclaimed => 1 }) if $charid;
}
}
for (keys %extr) {
$user_edits_table->{$_} = $extr{$_} if defined $extr{$_};
}
# don't want undef, want to be empty string so they
# will overwrite the existing record
for (keys %$user_edits_table) {
$user_edits_table->{$_} = '' unless defined $user_edits_table->{$_};
}
if ($user_edit->{realemail} ne $form->{realemail}) {
$user_edits_table->{realemail} =
chopEntity($form->{realemail}, 50);
my $new_fakeemail = ''; # at emaildisplay 0, don't show any email address
if ($user->{emaildisplay}) {
$new_fakeemail = getArmoredEmail($uid, $user_edits_table->{realemail})
if $user->{emaildisplay} == 1;
$new_fakeemail = $user_edits_table->{realemail}
if $user->{emaildisplay} == 2;
}
$user_edits_table->{fakeemail} = $new_fakeemail;
$note .= getMessage('changeemail_msg', {
realemail => $user_edit->{realemail}
}, 1);
my $saveuser_emailtitle = getTitle('saveUser_email_title', {
nickname => $user_edit->{nickname},
realemail => $form->{realemail}
}, 1);
my $saveuser_email_msg = getMessage('saveuser_email_msg', {
nickname => $user_edit->{nickname},
realemail => $form->{realemail}
}, 1);
sendEmail($form->{realemail}, $saveuser_emailtitle, $saveuser_email_msg);
doEmail($uid, $saveuser_emailtitle, $saveuser_email_msg);
}
getOtherUserParams($user_edits_table);
$slashdb->setUser($uid, $user_edits_table);
editUser({ uid => $uid, note => $note });
}
#################################################################
sub saveComm {
my($hr) = @_;
my $slashdb = getCurrentDB();
my $user = getCurrentUser();
my $form = getCurrentForm();
my $constants = getCurrentStatic();
my($uid, $user_fakeemail);
if ($user->{is_admin}) {
$uid = $form->{uid} || $user->{uid};
} else {
$uid = ($user->{uid} == $form->{uid}) ?
$form->{uid} : $user->{uid};
}
# Do the right thing with respect to the chosen email display mode
# and the options that can be displayed.
my $user_edit = $slashdb->getUser($uid);
my $new_fakeemail = ''; # at emaildisplay 0, don't show any email address
if ($form->{emaildisplay}) {
$new_fakeemail = getArmoredEmail($uid) if $form->{emaildisplay} == 1;
$new_fakeemail = $user_edit->{realemail} if $form->{emaildisplay} == 2;
}
my $name = $user->{seclev} && $form->{name} ?
$form->{name} : $user->{nickname};
my $note = getMessage('savenickname_msg',
{ nickname => $name });
print getError('cookie_err') if isAnon($uid) || !$name;
# Take care of the lists
# Enforce Ranges for variables that need it
$form->{commentlimit} = 0 if $form->{commentlimit} < 1;
my $cl_max = $constants->{comment_commentlimit} || 0;
$form->{commentlimit} = $cl_max if $cl_max > 0 && $form->{commentlimit} > $cl_max;
$form->{commentspill} = 0 if $form->{commentspill} < 1;
# For some of these values, namely the ones that we happen to
# know get stored in users_param, we change them to 'undef'
# if they are the default value. This deletes them from the
# users_param table, which has the same effect as storing the
# default except it's faster all around. If we ever change
# the schema to promote these fields from params into a
# proper users_* table, then this will no longer be correct.
# See prepareUser().
my $max = $constants->{comment_maxscore} - $constants->{comment_minscore};
my $min = -$max;
my $karma_bonus = ($form->{karma_bonus} !~ /^[\-+]?\d+$/) ? "+1" : $form->{karma_bonus};
my $subscriber_bonus = ($form->{subscriber_bonus} !~ /^[\-+]?\d+$/) ? "+1" : $form->{subscriber_bonus};
my $new_user_bonus = ($form->{new_user_bonus} !~ /^[\-+]?\d+$/) ? 0 : $form->{new_user_bonus};
my $new_user_percent = (($form->{new_user_percent} <= 100 && $form->{new_user_percent} >= 0)
? $form->{new_user_percent}
: 100);
my $clsmall_bonus = ($form->{clsmall_bonus} !~ /^[\-+]?\d+$/) ? 0 : $form->{clsmall_bonus};
my $clbig_bonus = ($form->{clbig_bonus} !~ /^[\-+]?\d+$/) ? 0 : $form->{clbig_bonus};
# plum
$form->{d2_comment_q} = (isSubscriber($user_edit) || $user_edit->{seclev} >= 100)
? $form->{d2_comment_q}
: ($form->{d2_comment_q} eq '0')
? 1
: $form->{d2_comment_q};
my $user_edits_table = {
# MC: More D2 neutring
#discussion2 => $form->{discussion2} || undef,
#d2_comment_q => $form->{d2_comment_q} || undef,
#d2_comment_order => $form->{d2_comment_order} || undef,
clsmall => $form->{clsmall},
clsmall_bonus => ($clsmall_bonus || undef),
clbig => $form->{clbig},
clbig_bonus => ($clbig_bonus || undef),
commentlimit => $form->{commentlimit},
bytelimit => $form->{bytelimit},
commentsort => $form->{commentsort},
commentspill => $form->{commentspill},
domaintags => ($form->{domaintags} != 2 ? $form->{domaintags} : undef),
emaildisplay => $form->{emaildisplay} || undef,
fakeemail => $new_fakeemail,
highlightthresh => $form->{highlightthresh},
mode => $form->{umode},
posttype => $form->{posttype},
threshold => $form->{uthreshold},
nosigs => ($form->{nosigs} ? 1 : 0),
reparent => ($form->{reparent} ? 1 : 0),
noscores => ($form->{noscores} ? 1 : 0),
hardthresh => ($form->{hardthresh} ? 1 : 0),
no_spell => ($form->{no_spell} ? 1 : undef),
nobonus => ($form->{nobonus} ? 1 : undef),
nosubscriberbonus => ($form->{nosubscriberbonus} ? 1 : undef),
postanon => ($form->{postanon} ? 1 : undef),
new_user_percent => ($new_user_percent && $new_user_percent != 100
? $new_user_percent : undef),
new_user_bonus => ($new_user_bonus || undef),
karma_bonus => ($karma_bonus ne '+1' ? $karma_bonus : undef),
subscriber_bonus => ($subscriber_bonus || undef),
textarea_rows => ($form->{textarea_rows} != $constants->{textarea_rows}
? $form->{textarea_rows} : undef),
textarea_cols => ($form->{textarea_cols} != $constants->{textarea_cols}
? $form->{textarea_cols} : undef),
user_comment_sort_type => ($form->{user_comment_sort_type} != 2
? $form->{user_comment_sort_type} : undef ),
mod_with_comm => ($form->{mod_with_comm} ? 1 : undef),
m2_with_mod => ($form->{m2_with_mod} ? 1 : undef),
m2_with_comm_mod => ($form->{m2_with_mod_on_comm} ? 1 : undef),
};
# set our default values for the items where an empty-string won't do
my $defaults = {
posttype => 2,
highlightthresh => 4,
reparent => 1,
commentlimit => 100,
commentspill => 50,
mode => 'thread'
};
my $mod_reader = getObject("Slash::$constants->{m1_pluginname}", { db_type => 'reader' });
my @reasons = ( );
my $reasons = $mod_reader->getReasons();
for my $id (sort { $a <=> $b } keys %$reasons) {
push @reasons, $reasons->{$id}{name};
}
for my $reason_name (@reasons) {
my $key = "reason_alter_$reason_name";
my $answer = $form->{$key} || 0;
$answer = 0 if !$answer || $answer !~ /^[\-+]?\d+$/;
$user_edits_table->{$key} = ($answer == 0) ? '' : $answer;
}
for (qw| friend foe anonymous fof eof freak fan |) {
my $answer = $form->{"people_bonus_$_"};
$answer = 0 if $answer !~ /^[\-+]?\d+$/;
$user_edits_table->{"people_bonus_$_"} = ($answer == 0) ? '' : $answer;
}
getOtherUserParams($user_edits_table);
setToDefaults($user_edits_table, {}, $defaults) if $form->{restore_defaults};
$slashdb->setUser($uid, $user_edits_table);
editComm({ uid => $uid, note => $note });
}
#################################################################
sub saveHome {
my($hr) = @_;
my $slashdb = getCurrentDB();
my $user = getCurrentUser();
my $form = getCurrentForm();
my $constants = getCurrentStatic();
my($uid, $error);
if ($user->{is_admin}) {
$uid = $form->{uid} || $user->{uid} ;
} else {
$uid = ($user->{uid} == $form->{uid}) ?
$form->{uid} : $user->{uid};
}
my $edit_user = $slashdb->getUser($uid);
my $name = $user->{seclev} && $form->{name} ?
$form->{name} : $user->{nickname};
$name = substr($name, 0, 20);
my $note = getMessage('savenickname_msg',
{ nickname => $name });
if (isAnon($uid) || !$name) {
my $cookiemsg = getError('cookie_err');
print $cookiemsg;
}
# Using the existing list of slashboxes and the set of
# what's checked and not, build up the new list.
# (New arrivals go at the end.)
my $slashboxes = $edit_user->{slashboxes};
# Only go through all this if the user clicked save,
# not "Restore Slashbox Defaults"!
my($boxes, $skinBoxes) = $slashdb->getPortalsCommon();
my $default_slashboxes_textlist = join ",",
@{$skinBoxes->{$constants->{mainpage_skid}}};
if (!$form->{restore_slashbox_defaults}) {
$slashboxes = $default_slashboxes_textlist if !$slashboxes;
my @slashboxes = split /,/, $slashboxes;
my %slashboxes = ( );
for my $i (0..$#slashboxes) {
$slashboxes{$slashboxes[$i]} = $i;
}
# Add new boxes in.
for my $key (sort grep /^showbox_/, keys %$form) {
my($bid) = $key =~ /^showbox_(\w+)$/;
next if length($bid) < 1 || length($bid) > 30 || $bid !~ /^\w+$/;
if (! exists $slashboxes{$bid}) {
$slashboxes{$bid} = 999; # put it at the end
}
}
# Remove any boxes that weren't checked.
for my $bid (@slashboxes) {
delete $slashboxes{$bid} unless $form->{"showbox_$bid"};
}
for my $key (sort grep /^dynamic_/, keys %$form) {
my($bid) = $key =~ /^dynamic_(.+)$/;
next if length($bid) < 1;
if (! exists $slashboxes{$bid}) {
$slashboxes{$bid} = 999;
}
}
@slashboxes = sort {
$slashboxes{$a} <=> $slashboxes{$b}
||
$a cmp $b
} keys %slashboxes;
# This probably should be a var (and appear in tilded_customize_msg)
$#slashboxes = 19 if $#slashboxes > 19;
$slashboxes = join ",", @slashboxes;
}
# If we're right back to the default, that means the
# empty string.
if ($slashboxes eq $default_slashboxes_textlist) {
$slashboxes = "";
}
# Set the story_never and story_always fields.
my $author_hr = $slashdb->getDescriptions('authors');
my $tree = $slashdb->getTopicTree();
my(@story_never_topic, @story_never_author, @story_never_nexus);
my(@story_always_topic, @story_always_author);
my(@story_always_nexus, @story_full_brief_nexus, @story_brief_always_nexus, @story_full_best_nexus, @story_brief_best_nexus);
my($story_topic_all, $story_author_all, $story_nexus_all) = (0, 0, 0);
# Topics are either present (value=2) or absent (value=0). If absent,
# push them onto the never list. Otherwise, do nothing. (There's no
# way to have an "always" topic, at the moment.) If the hidden
# field topictids_present is false, then there are no topic tids,
# skip this.
if ($form->{topictids_present}) {
for my $tid (
sort { $a <=> $b }
grep { !$tree->{$_}{nexus} }
keys %$tree
) {
my $key = "topictid$tid";
$story_topic_all++;
if (!$form->{$key}) { push @story_never_topic, $tid }
}
}
# Authors are either present (value=2) or absent (value=0). If
# absent, push them onto the never list. Otherwise, do nothing.
# (There's no way to have an "always" author, at the moment.)
for my $aid (sort { $a <=> $b } keys %$author_hr) {
my $key = "aid$aid";
$story_author_all++;
if (!$form->{$key}) { push @story_never_author, $aid }
}
# Nexuses can have value 0, 1, 2, 3, 4, 5.
# 0 means the never list,
# 1 means brief view of mainpage articles only
# 2 means full view of mainpage articles only
# 3 means brief view of all content
# 4 means full view of mainpage content, brief view of sectional
# 5 means full view of all content
for my $tid (
sort { $a <=> $b }
map { /^nexustid(\d+)$/; $1 }
grep { /^nexustid\d+$/ }
keys %$form
) {
my $key = "nexustid$tid";
next unless $tid && $tree->{$tid} && $tree->{$tid}{nexus};
$story_nexus_all++;
if (!$form->{$key}) { push @story_never_nexus, $tid }
elsif ($form->{$key} == 5 ) { push @story_always_nexus, $tid }
elsif ($form->{$key} == 4 ) { push @story_full_brief_nexus, $tid }
elsif ($form->{$key} == 3 ) { push @story_brief_always_nexus, $tid }
elsif ($form->{$key} == 2 ) { push @story_full_best_nexus, $tid }
elsif ($form->{$key} == 1 ) { push @story_brief_best_nexus, $tid }
}
#use Data::Dumper; $Data::Dumper::Sortkeys = 1; print STDERR scalar(localtime) . " s_n_t '@story_never_topic' s_n_a '@story_never_author' s_n_n '@story_never_nexus' s_a_n '@story_always_nexus' form: " . Dumper($form);
# Sanity check.
$#story_never_topic = 299 if $#story_never_topic > 299;
$#story_never_author = 299 if $#story_never_author > 299;
$#story_never_nexus = 299 if $#story_never_nexus > 299;
$#story_always_topic = 299 if $#story_always_topic > 299;
$#story_always_author = 299 if $#story_always_author > 299;
$#story_always_nexus = 299 if $#story_always_nexus > 299;
$#story_full_brief_nexus = 299 if $#story_full_brief_nexus > 299;
$#story_brief_always_nexus = 299 if $#story_brief_always_nexus > 299;
$#story_brief_best_nexus = 299 if $#story_brief_best_nexus > 299;
$#story_full_best_nexus = 299 if $#story_full_best_nexus > 299;
my $story_never_topic = join ",", @story_never_topic;
$story_never_topic = ($constants->{subscribe} && $user->{is_subscriber})
? checkList($story_never_topic, 1024)
: checkList($story_never_topic);
my $story_never_author = checkList(join ",", @story_never_author);
my $story_never_nexus = checkList(join ",", @story_never_nexus);
my $story_always_topic = checkList(join ",", @story_always_topic);
$story_always_topic = ($constants->{subscribe} && $user->{is_subscriber})
? checkList($story_always_topic, 1024)
: checkList($story_always_topic);
my $story_always_author = checkList(join ",", @story_always_author);
my $story_always_nexus = checkList(join ",", @story_always_nexus);
my $story_full_brief_nexus = checkList(join ",", @story_full_brief_nexus);
my $story_brief_always_nexus = checkList(join ",", @story_brief_always_nexus);
my $story_brief_best_nexus = checkList(join ",", @story_brief_best_nexus);
my $story_full_best_nexus = checkList(join ",", @story_full_best_nexus);
my $user_edits_table = {
story_never_topic => $story_never_topic,
story_never_author => $story_never_author,
story_never_nexus => $story_never_nexus,
story_always_topic => $story_always_topic,
story_always_author => $story_always_author,
story_always_nexus => $story_always_nexus,
story_brief_always_nexus => $story_brief_always_nexus,
story_full_brief_nexus => $story_full_brief_nexus,
story_full_best_nexus => $story_full_best_nexus,
story_brief_best_nexus => $story_brief_best_nexus,
slashboxes => checkList($slashboxes, 1024),
maxstories => 30, # XXXSKIN fix this later
noboxes => ($form->{useslashboxes} ? 0 : 1),
lowbandwidth => ($form->{lowbandwidth} ? 1 : 0),
simpledesign => ($form->{simpledesign} ? 1 : 0),
noicons => ($form->{noicons} ? 1 : 0),
willing => ($form->{willing} ? 1 : 0),
index_classic => ($form->{index_classic} ? 1 : undef),
};
if (defined $form->{tzcode} && defined $form->{tzformat}) {
$user_edits_table->{tzcode} = $form->{tzcode};
$user_edits_table->{dfid} = $form->{tzformat};
$user_edits_table->{dst} = $form->{dst};
}
# Force the User Space area to contain only known-good HTML tags.
# Unfortunately the cookie login model makes it just too risky
# to allow scripts in here; CSS's steal passwords. There are
# no known vulnerabilities at this time, but a combination of the
# social engineering taking place (inviting users to put Javascript
# from websites in here, and making available script URLs for that
# purpose), plus the fact that this could be used to amplify the
# seriousness of any future vulnerabilities, means it's way past
# time to shut this feature down. - Jamie 2002/03/06
# it's a VARCHAR ...
my $mylinks_limit = 255;
$user_edits_table->{mylinks} = balanceTags(strip_html(
chopEntity($form->{mylinks} || '', $mylinks_limit)
), { deep_nesting => 2, length => $mylinks_limit });
$user_edits_table->{mylinks} = '' unless defined $user_edits_table->{mylinks};
$error = 1;
# must select at least 1/4 of nexuses, topics, authors
if ( scalar(@story_never_author) > ($story_author_all * 3/4) ) {
$note = getError('editHome_too_many_disabled');
} elsif ( scalar(@story_never_nexus) > ($story_nexus_all * 3/4) ) {
$note = getError('editHome_too_many_disabled');
} elsif ( scalar(@story_never_topic) > ($story_topic_all * 3/4) ) {
$note = getError('editHome_too_many_disabled');
} else {
$error = 0;
}
unless ($error) {
# If a user is unwilling to moderate, we should cancel all points, lest
# they be preserved when they shouldn't be.
if (!isAnon($uid) && !$form->{willing}) {
$slashdb->setUser($uid, { points => 0 });
}
getOtherUserParams($user_edits_table);
if ($form->{restore_defaults}) {
setToDefaults($user_edits_table, {}, {
maxstories => 30,
tzcode => "EST",
# XXX shouldn't this reset ALL the defaults,
# not just these two?
});
}
if ($form->{restore_slashbox_defaults}) {
setToDefaults($user_edits_table, {
'story_never_topic' => 1,
'story_never_author' => 1,
'story_never_nexus' => 1,
'story_always_topic' => 1,
'story_always_author' => 1,
'story_always_nexus' => 1,
'story_full_brief_nexus' => 1,
'story_brief_always_nexus' => 1,
'story_full_best_nexus' => 1,
'story_brief_best_nexus' => 1,
'maxstories' => 1,
'noboxes' => 1,
'light' => 1,
'noicons' => 1,
'willing' => 1
}, { slashboxes => "" });
}
#print scalar(localtime) . " uet: " . Dumper($user_edits_table);
$slashdb->setUser($uid, $user_edits_table);
}
editHome({ uid => $uid, note => $note });
}
#################################################################
# A generic way for a site to allow users to edit data about themselves.
# Most useful when your plugin or theme wants to let the user change
# minor settings but you don't want to write a whole new version
# of users.pl to provide a user interface. The user can save any
# param of the format "opt_foo", as long as "foo" shows up in
# getMiscUserOpts which lists all the misc opts that this user can edit.
# This is *not* protected by formkeys (yet), so assume attackers can make
# users click and accidentally edit their own settings: no really important
# data should be stored in this way.
sub editMiscOpts {
my($hr) = @_;
my $slashdb = getCurrentDB();
my $user = getCurrentUser();
my $constants = getCurrentStatic();
my $note = $hr->{note} || "";
return if $user->{is_anon}; # shouldn't be, but can't hurt to check
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
my $edit_user = $slashdb->getUser($user->{uid});
my $title = getTitle('editMiscOpts_title');
my $opts = $slashdb->getMiscUserOpts();
for my $opt (@$opts) {
my $opt_name = "opt_" . $opt->{name};
$opt->{checked} = $edit_user->{$opt_name} ? 1 : 0;
}
slashDisplay('editMiscOpts', {
# useredit => $user_edit,
title => $title,
opts => $opts,
note => $note,
});
}
#################################################################
#
sub saveMiscOpts {
my($hr) = @_;
my $slashdb = getCurrentDB();
my $user = getCurrentUser();
my $form = getCurrentForm();
my $constants = getCurrentStatic();
return if $user->{is_anon}; # shouldn't be, but can't hurt to check
my $edit_user = $slashdb->getUser($user->{uid});
my %opts_ok_hash = ( );
my $opts = $slashdb->getMiscUserOpts();
for my $opt (@$opts) {
$opts_ok_hash{"opt_$opt->{name}"} = 1;
}
my $update = { };
for my $opt (grep /^opt_/, keys %$form) {
next unless $opts_ok_hash{$opt};
$update->{$opt} = $form->{$opt} ? 1 : 0;
}
# Make the changes.
$slashdb->setUser($edit_user->{uid}, $update);
# Inform the user the change was made. Since we don't
# require formkeys, we always want to print a message to
# make sure the user sees what s/he did. This is done
# by passing in a note which ends up passed to the
# editMiscOpts template, which displays it.
editMiscOpts({ note => getMessage('savemiscopts_msg') });
}
#################################################################
sub listReadOnly {
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $readonlylist = $reader->getAL2List('nopost');
slashDisplay('listReadOnly', {
readonlylist => $readonlylist,
});
}
#################################################################
sub listBanned {
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $bannedlist = $reader->getAL2List('ban');
slashDisplay('listBanned', {
bannedlist => $bannedlist,
});
}
#################################################################
sub topAbusers {
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $topabusers = $reader->getTopAbusers();
slashDisplay('topAbusers', {
topabusers => $topabusers,
});
}
#################################################################
sub listAbuses {
my $user = getCurrentUser();
my $form = getCurrentForm();
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $constants = getCurrentStatic();
my $abuses = $reader->getAbuses($form->{key}, $form->{abuseid});
slashDisplay('listAbuses', {
abuseid => $form->{abuseid},
abuses => $abuses,
});
}
#################################################################
sub forceAccountVerify {
my $user = getCurrentUser();
my $form = getCurrentForm();
my $slashdb = getCurrentDB();
my $constants = getCurrentStatic();
my $uid = $form->{uid};
my $useredit = $slashdb->getUser($uid);
if ($useredit->{uid}) {
my $newpasswd = $slashdb->resetUserAccount($uid);
$slashdb->deleteLogToken($uid, 1);
my $emailtitle = getTitle('reset_acct_email_title', {
nickname => $useredit->{nickname}
}, 1);
my $msg = getMessage('reset_acct_msg', {
newpasswd => $newpasswd,
tempnick => $useredit->{nickname},
}, 1);
$slashdb->setUser($useredit->{uid}, {
waiting_for_account_verify => 1,
account_verify_request_time => $slashdb->getTime()
});
doEmail($useredit->{uid}, $emailtitle, $msg) if $useredit->{uid};
}
print getMessage("reset_acct_complete", { useredit => $useredit }, 1);
}
#################################################################
sub displayForm {
my($hr) = @_;
my $user = getCurrentUser();
my $form = getCurrentForm();
my $slashdb = getCurrentDB();
my $constants = getCurrentStatic();
my $suadmin_flag = $user->{seclev} >= 10000 ? 1 : 0;
print createMenu("users", {
style => 'tabbed',
justify => 'right',
color => 'colored',
tab_selected => $hr->{tab_selected_1} || "",
});
my $op = $hr->{op} || $form->{op} || 'displayform';
my $ops = {
displayform => 'loginForm',
edithome => 'loginForm',
editcomm => 'loginForm',
edituser => 'loginForm',
# mailpasswdform => 'sendPasswdForm',
# newuserform => 'newUserForm',
userclose => 'loginForm',
userlogin => 'loginForm',
editmiscopts => 'loginForm',
savemiscopts => 'loginForm',
default => 'loginForm'
};
$op = 'default' if !defined($ops->{$op});
my($title, $title2, $msg1, $msg2) = ('', '', '', '');
if ($op eq 'userclose') {
$title = getMessage('userclose');
} elsif ($op eq 'displayForm') {
$title = $form->{unickname}
? getTitle('displayForm_err_title')
: getTitle('displayForm_title');
} elsif ($op eq 'mailpasswdform') {
$title = getTitle('mailPasswdForm_title');
} elsif ($op eq 'newuserform') {
$title = getTitle('newUserForm_title');
} else {
$title = getTitle('displayForm_title');
}
$form->{unickname} ||= $form->{newusernick};
if ($form->{newusernick}) {
$title2 = getTitle('displayForm_dup_title');
} else {
$title2 = getTitle('displayForm_new_title');
}
$msg1 = getMessage('dispform_new_msg_1');
if (! $form->{newusernick} && $op eq 'newuserform') {
$msg2 = getMessage('dispform_new_msg_2');
} elsif ($op eq 'displayform' || $op eq 'userlogin') {
$msg2 = getMessage('newuserform_msg');
}
slashDisplay($ops->{$op}, {
newnick => nickFix($form->{newusernick}),
suadmin_flag => $suadmin_flag,
title => $title,
title2 => $title2,
logged_in => $user->{is_anon} ? 0 : 1,
msg1 => $msg1,
msg2 => $msg2
});
}
#################################################################
# this groups all the messages together in
# one template, called "messages;users;default"
sub getMessage {
my($value, $hashref, $nocomm) = @_;
$hashref ||= {};
$hashref->{value} = $value;
return slashDisplay('messages', $hashref,
{ Return => 1, Nocomm => $nocomm });
}
#################################################################
# this groups all the errors together in
# one template, called "errors;users;default"
sub getError {
my($value, $hashref, $nocomm) = @_;
$hashref ||= {};
$hashref->{value} = $value;
return slashDisplay('errors', $hashref,
{ Return => 1, Nocomm => $nocomm });
}
#################################################################
# this groups all the titles together in
# one template, called "users-titles"
sub getTitle {
my($value, $hashref, $nocomm) = @_;
$hashref ||= {};
$hashref->{value} = $value;
return slashDisplay('titles', $hashref,
{ Return => 1, Nocomm => $nocomm });
}
#################################################################
# getUserAdmin - returns a block of HTML text that provides
# information and editing capabilities for admin users.
# Most of this data is already in the getUserAdmin template,
# but really, we should try to get more of this logic into
# that template.
sub getUserAdmin {
my($id, $field, $seclev_field) = @_;
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $logdb = getObject('Slash::DB', { db_type => 'log_slave' });
my $user = getCurrentUser();
my $form = getCurrentForm();
my $constants = getCurrentStatic();
my $slashdb = getCurrentDB();
$id ||= $user->{uid};
my($expired, $uidstruct, $readonly);
my($user_edit, $user_editfield, $ipstruct, $ipstruct_order, $authors, $author_flag, $topabusers, $thresh_select,$section_select);
my $srcid;
my $proxy_check = {};
my @accesshits;
my $user_editinfo_flag = (!$form->{op} || $form->{op} eq 'userinfo'
|| $form->{userinfo} || $form->{saveuseradmin}
) ? 1 : 0;
my $authoredit_flag = ($user->{seclev} >= 10000) ? 1 : 0;
my $sectionref = $reader->getDescriptions('skins');
$sectionref->{''} = getData('all_sections');
$field ||= 'uid';
if ($field eq 'uid') {
$user_edit = $slashdb->getUser($id);
$user_editfield = $user_edit->{uid};
$srcid = convert_srcid( uid => $id );
#$expired = $slashdb->checkExpired($user_edit->{uid}) ? $constants->{markup_checked_attribute} : '';
$ipstruct = $slashdb->getNetIDStruct($user_edit->{uid});
@accesshits = $logdb->countAccessLogHitsInLastX($field, $user_edit->{uid}) if defined($logdb);
$section_select = createSelect('section', $sectionref, $user_edit->{section}, 1);
} elsif ($field eq 'nickname') {
$user_edit = $slashdb->getUser($slashdb->getUserUID($id));
$user_editfield = $user_edit->{nickname};
#$expired = $slashdb->checkExpired($user_edit->{uid}) ? $constants->{markup_checked_attribute} : '';
$ipstruct = $slashdb->getNetIDStruct($user_edit->{uid});
@accesshits = $logdb->countAccessLogHitsInLastX('uid', $user_edit->{uid}) if defined($logdb);
$section_select = createSelect('section', $sectionref, $user_edit->{section}, 1);
} elsif ($field eq 'md5id') {
$user_edit->{nonuid} = 1;
$user_edit->{md5id} = $id;
if ($form->{fieldname} && $form->{fieldname} =~ /^(ipid|subnetid)$/) {
$uidstruct = $slashdb->getUIDStruct($form->{fieldname}, $user_edit->{md5id});
@accesshits = $logdb->countAccessLogHitsInLastX($form->{fieldname}, $user_edit->{md5id}) if defined($logdb);
} else {
$uidstruct = $slashdb->getUIDStruct('md5id', $user_edit->{md5id});
@accesshits = $logdb->countAccessLogHitsInLastX($field, $user_edit->{md5id}) if defined($logdb);
}
} elsif ($field eq 'ipid') {
$user_edit->{nonuid} = 1;
$user_edit->{ipid} = $id;
$srcid = convert_srcid( ipid => $id );
$user_editfield = $id;
$uidstruct = $slashdb->getUIDStruct('ipid', $user_edit->{ipid});
@accesshits = $logdb->countAccessLogHitsInLastX('host_addr', $user_edit->{ipid}) if defined($logdb);
if ($form->{userfield} =~/^\d+\.\d+\.\d+\.(\d+)$/) {
if ($1 ne "0"){
$proxy_check->{available} = 1;
$proxy_check->{results} = $slashdb->checkForOpenProxy($form->{userfield}) if $form->{check_proxy};
}
}
} elsif ($field eq 'subnetid') {
$user_edit->{nonuid} = 1;
$srcid = convert_srcid( ipid => $id );
if ($id =~ /^(\d+\.\d+\.\d+)(?:\.\d)?/) {
$id = $1 . ".0";
$user_edit->{subnetid} = $id;
} else {
$user_edit->{subnetid} = $id;
}
$user_editfield = $id;
$uidstruct = $slashdb->getUIDStruct('subnetid', $user_edit->{subnetid});
@accesshits = $logdb->countAccessLogHitsInLastX($field, $user_edit->{subnetid}) if defined($logdb);
} elsif ($field eq "srcid") {
$user_edit->{nonuid} = 1;
$user_edit->{srcid} = $id;
$srcid = $id;
} else {
$user_edit = $id ? $slashdb->getUser($id) : $user;
$user_editfield = $user_edit->{uid};
$ipstruct = $slashdb->getNetIDStruct($user_edit->{uid});
@accesshits = $logdb->countAccessLogHitsInLastX('uid', $user_edit->{uid}) if defined($logdb);
}
##########
# Put together the array and hashref that the template will need
# to construct the list for display to the admin.
# Note that currently a srcid which is not a uid (i.e. which
# represents an IP address or masked IP network) cannot have
# any ACLs assigned to it. This may change in the future.
# The term "aclam" is used because it has a field set for both
# every ACL and every access modifier (i.e. AL2 bit) that is set
# for this user or srcid.
# For now, ACLs will be listed for IPs as well.
# First get the list of ACLs that can be used.
my $all_acls_ar = $reader->getAllACLNames();
my $all_acls_hr = { map { ( $_, 1 ) } @$all_acls_ar };
# Add in any ACLs selected for this user (just in case
# getAllACLNames is cached and stale).
for my $acl (keys %{$user_edit->{acl}}) {
$all_acls_hr->{$acl} = 1;
}
# Start creating the $all_aclam_hr data, in which the keys are
# the HTML selection names that all begin with aclam_ and the
# the values are their names/descriptions shown to the admin.
# First put all the ACLs into the hash, if we're editing a user.
my $all_aclam_hr = { };
if (!$user_edit->{nonuid}) {
$all_aclam_hr = { map { ( "aclam_$_", "ACL: $_" ) } keys %$all_acls_hr };
}
# Next put in all the al2 types.
my $all_al2types = $reader->getAL2Types;
for my $key (keys %$all_al2types) {
next if $key eq 'comment'; # skip the 'comment' type
$all_aclam_hr->{"aclam_$key"} = $all_al2types->{$key}{title};
}
# Finally, sort the keys of the hash into the order that we
# want them displayed to the admin (ACLs first).
my $all_acls_longkeys_hr = { map { ( "aclam_$_", 1 ) } keys %$all_acls_hr };
my $all_aclam_ar = [
sort {
(exists($all_acls_longkeys_hr->{$a}) ? -1 : 1) <=> (exists($all_acls_longkeys_hr->{$b}) ? -1 : 1)
||
$all_aclam_hr->{$a} cmp $all_aclam_hr->{$b}
} keys %$all_aclam_hr
];
# Now put together the hashref that identifies which of those
# items are selected for this user.
my $user_aclam_hr = { };
for my $acl (keys %{ $user_edit->{acl} }) {
$user_aclam_hr->{"aclam_$acl"} = 1;
}
my $al2_tid_comment = $all_al2types->{comment}{al2tid} || 0;
my $al2_log_ar = [ ];
my $al2_hr = { };
# XXXSRCID Once we get rid of the silly 'md5id' field and all the
# other bizarre backward-compatibility code paths early in this
# function, this won't be necessary, but until then we need this
# sanity check...
if ($srcid) {
# getAL2 works with either a srcids hashref or a single srcid
$al2_hr = $slashdb->getAL2($srcid);
for my $al2 (keys %{ $al2_hr }) {
$user_aclam_hr->{"aclam_$al2"} = 1;
}
$al2_log_ar = $slashdb->getAL2Log($srcid);
}
# Generate al2_nick_hr, which will be populated with keys of all
# the (presumably) admin uids who have logged rows for this al2,
# and values of their nicks.
my $al2_nick_hr = { };
for my $al2_log (@$al2_log_ar) {
my $uid = $al2_log->{adminuid};
next if !$uid; # odd error, might want to flag this
$al2_nick_hr->{$uid} ||= $slashdb->getUser($uid, 'nickname');
}
##########
$user_edit->{author} = ($user_edit->{author} && $user_edit->{author} == 1)
? $constants->{markup_checked_attribute} : '';
if (! $user->{nonuid}) {
my $threshcodes = $reader->getDescriptions('threshcode_values','',1);
$thresh_select = createSelect('defaultpoints', $threshcodes, $user_edit->{defaultpoints}, 1);
}
if (!ref $ipstruct) {
undef $ipstruct;
} else {
@$ipstruct_order = sort { $ipstruct->{$b}{dmin} cmp $ipstruct->{$a}{dmin} } keys %$ipstruct;
}
my $m2total = ($user_edit->{m2fair} || 0) + ($user_edit->{m2unfair} || 0);
if ($m2total) {
$user_edit->{m2unfairpercent} = sprintf("%.2f",
$user_edit->{m2unfair}*100/$m2total);
}
my $mod_total = ($user_edit->{totalmods} || 0) + ($user_edit->{stirred} || 0);
if ($mod_total) {
$user_edit->{stirredpercent} = sprintf("%.2f",
$user_edit->{stirred}*100/$mod_total);
}
if ($constants->{subscribe} and my $subscribe = getObject('Slash::Subscribe')) {
$user_edit->{subscribe_payments} =
$subscribe->getSubscriptionsForUser($user_edit->{uid});
$user_edit->{subscribe_purchases} =
$subscribe->getSubscriptionsPurchasedByUser($user_edit->{uid},{ only_types => [ "grant", "gift" ] });
}
my $ipid = $user_edit->{ipid};
my $subnetid = $user_edit->{subnetid};
my $post_restrictions = {};
my ($subnet_karma, $ipid_karma);
if ($ipid && !$subnetid) {
$ipid = md5_hex($ipid) if length($ipid) != 32;
$proxy_check->{ipid} = $ipid;
$proxy_check->{currently} = $slashdb->getKnownOpenProxy($ipid, "ipid");
# This next call is very slow.
$subnetid = $reader->getSubnetFromIPIDBasedOnComments($ipid);
}
if ($subnetid) {
$subnetid = md5_hex($subnetid) if length($subnetid) != 32;
# These next three calls can be very slow. In fact, getNetIDKarma
# is actually called twice on the same subnetid; if we can cache
# that data somehow that wouldn't be a bad idea.
$post_restrictions = $reader->getNetIDPostingRestrictions("subnetid", $subnetid);
$subnet_karma = $reader->getNetIDKarma("subnetid", $subnetid);
$ipid_karma = $reader->getNetIDKarma("ipid", $ipid) if $ipid;
}
my $clout_types_ar = [ sort grep /\D/, keys %{$slashdb->getCloutTypes} ];
return slashDisplay('getUserAdmin', {
field => $field,
useredit => $user_edit,
srcid => $srcid,
all_aclam_ar => $all_aclam_ar,
all_aclam_hr => $all_aclam_hr,
user_aclam_hr => $user_aclam_hr,
al2_old => $al2_hr,
al2_log => $al2_log_ar,
al2_tid_comment => $al2_tid_comment,
al2_nick => $al2_nick_hr,
userinfo_flag => $user_editinfo_flag,
userfield => $user_editfield,
ipstruct => $ipstruct,
ipstruct_order => $ipstruct_order,
uidstruct => $uidstruct,
accesshits => \@accesshits,
seclev_field => $seclev_field,
expired => $expired,
topabusers => $topabusers,
readonly => $readonly,
thresh_select => $thresh_select,
authoredit_flag => $authoredit_flag,
section_select => $section_select,
all_acls => $all_acls_hr,
proxy_check => $proxy_check,
subnet_karma => $subnet_karma,
ipid_karma => $ipid_karma,
post_restrictions => $post_restrictions,
clout_types_ar => $clout_types_ar,
}, 1);
}
#################################################################
# this is to allow alternate parameters to be specified. pass in
# your hash reference to be passed to setUser(), and this will
# add in those extra parameters. add the parameters to string_param,
# type = otherusersparam, code = name of the param. they will
# be checked for the main user prefs editing screens, and on
# user creation -- pudge
sub getOtherUserParams {
my($data) = @_;
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $user = getCurrentUser();
my $form = getCurrentForm();
my $params = $reader->getDescriptions('otherusersparam');
for my $param (keys %$params) {
if (exists $form->{$param}) {
# set user too for output in this request
$data->{$param} = $user->{$param} = $form->{$param} || undef;
}
}
}
###############################################################
# This modifies a hashref to default values -- if nothing
# else we assume the empty string which clears items in the
# user_param table
#
# takes 3 hashrefs currently
# $data - hashref to change to defaults
# $skip - hashref of keys to skip modifying
# $defaults - hashref of defaults to set to something other
# than the empty string
sub setToDefaults {
my($data, $skip, $defaults) = @_;
foreach my $key (keys %$data) {
next if $skip->{$key};
$data->{$key} = exists $defaults->{$key} ? $defaults->{$key} : "";
}
}
#################################################################
sub getCommentListing {
my ($type, $value,
$min_comment, $time_period, $cc_all, $cc_time_period, $cid_for_time_period,
$non_admin_limit, $admin_time_limit, $admin_non_time_limit,
$options) = @_;
my $reader = getObject('Slash::DB', { db_type => 'reader' });
my $slashdb = getCurrentDB();
my $constants = getCurrentStatic();
my $user = getCurrentUser();
my $store_cutoff = $options->{use_uid_cid_cutoff} ? $constants->{store_com_page1_min_cid_for_user_com_cnt} : 0;
my $s_opt = {};
my $num_wanted = 0;
if ($min_comment) {
if ($user->{is_admin}) {
$num_wanted = $admin_non_time_limit;
} else {
$num_wanted = $non_admin_limit;
}
} else {
if ($user->{is_admin}) {
if ($cc_time_period >= $admin_non_time_limit) {
$s_opt->{cid_at_or_after} = $cid_for_time_period;
$num_wanted = $admin_time_limit;
} else {
$num_wanted = $admin_non_time_limit;
if($store_cutoff){
my $min_cid = $reader->getUser($value,
"com_num_".$num_wanted."_at_or_after_cid");
$s_opt->{cid_at_or_after} = $min_cid
if $min_cid && $min_cid =~ /^\d+$/;
}
}
} else {
if ($cc_time_period >= $non_admin_limit ) {
$s_opt->{cid_at_or_after} = $cid_for_time_period;
$num_wanted = $non_admin_limit;
} else {
$num_wanted = $non_admin_limit;
if($store_cutoff){
my $min_cid = $reader->getUser($value,
"com_num_".$num_wanted."_at_or_after_cid");
$s_opt->{cid_at_or_after} = $min_cid
if $min_cid && $min_cid =~ /^\d+$/;
}
}
}
}
if ($type eq "uid") {
my $comments = $reader->getCommentsByUID($value, $num_wanted, $min_comment, $s_opt) if $cc_all;
if ($store_cutoff
&& $comments && $cc_all >= $store_cutoff && $min_comment == 0
&& scalar(@$comments) == $num_wanted) {
my $min_cid = 0;
for my $comment (@$comments) {
$min_cid = $comment->{cid}
if !$min_cid || ($comment->{cid} < $min_cid);
}
if ($min_cid && $min_cid =~/^\d+$/) {
$slashdb->setUser($value, {
"com_num_".$num_wanted."_at_or_after_cid" => $min_cid
});
}
}
return $comments;
} elsif ($type eq "ipid"){
return $reader->getCommentsByIPID($value, $num_wanted, $min_comment, $s_opt) if $cc_all;
} elsif ($type eq "subnetid"){
return $reader->getCommentsBySubnetID($value, $num_wanted, $min_comment, $s_opt) if $cc_all;
} else {
return $reader->getCommentsByIPIDOrSubnetID($value, $num_wanted, $min_comment, $s_opt) if $cc_all;
}
}
createEnvironment();
main();
1;