oqapi/webgui
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Account release candidate - final changes before merge

Browse source
This commit is contained in:
Frank Dillon 2008-11-15 02:39:23 +00:00
parent aec93573f0
commit 11d18075fa
45 changed files with 3379 additions and 1325 deletions
Download patch file Download diff file Expand all files Collapse all files

346
lib/WebGUI/Operation/Friends.pm
View file

@ -25,373 +25,53 @@ Package WebGUI::Operation::Friends
Operation handler for handling the friends network.
DEPRECATED - Do not use this package in new code.
=cut
#-------------------------------------------------------------------
=head2 www_addFriend ( )
Form for inviting a user to become your friend.
DEPRECATED - See WebGUI::Account::Friends::sendFriendsRequest
=cut
sub www_addFriend {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my $friendId = $session->form->get('userId');
my $protoFriend = WebGUI::User->new($session, $friendId);
my $i18n = WebGUI::International->new($session, 'Friends');
my $friends = WebGUI::Friends->new($session);
if($friends->isFriend($friendId)) {
my $returnToProfile = sprintf($i18n->get('add to friends profile'),$protoFriend->getFirstName);
my $backUrl = $session->url->append($session->url->getRequestedUrl, 'op=viewProfile;uid='.$friendId);
return $session->style->userStyle(
sprintf($i18n->get("error user is already friend"),$backUrl,$returnToProfile)
);
}
elsif($friends->isInvited($friendId)) {
my $returnToProfile = sprintf($i18n->get('add to friends profile'),$protoFriend->getFirstName);
my $backUrl = $session->url->append($session->url->getRequestedUrl, 'op=viewProfile;uid='.$friendId);
return $session->style->userStyle(
sprintf($i18n->get("error user is already invited"),$backUrl,$returnToProfile)
);
}
# Check for non-existant user id.
if ((!$protoFriend->username) || (!$protoFriend->profileField('ableToBeFriend'))) {
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('add to friends'),
$i18n->get('does not want to be a friend'),
$session->url->getBackToSiteURL(),
$i18n->get('493', 'WebGUI');
return $session->style->userStyle($output);
}
my $output = join '',
sprintf("<h1>%s</h1>\n", $i18n->get('add to friends')),
'<p>',
sprintf($i18n->get('add to friends description'),
$protoFriend->getWholeName),
'</p>',
WebGUI::Form::formHeader($session),
WebGUI::Form::hidden($session,
{
name => 'op',
value => 'addFriendSave',
}
),
WebGUI::Form::hidden($session,
{
name => 'userId',
value => $friendId,
}
),
WebGUI::Form::textarea($session,
{
name => 'comments',
value => sprintf($i18n->get('default friend comments'), $protoFriend->getFirstName, $session->user->getFirstName),
}
),
WebGUI::Form::Submit($session,
{
value => $i18n->get('add')
}
),
WebGUI::Form::Button($session,
{
value => $i18n->get('cancel', 'WebGUI'),
extras => q|onclick="history.go(-1);" class="backwardButton"|,
}
),
WebGUI::Form::formFooter($session),
;
return $session->style->userStyle($output);
my $uid = $session->form->process("userId");
my $instance = WebGUI::Content::Account->createInstance($session,"friends");
return $instance->displayContent($instance->callMethod("sendFriendsRequest",[],$uid));
}
#-------------------------------------------------------------------
=head2 www_addFriendSave ( )
Post process the form, check for required fields, handle inviting users who are already
members (determined by email address) and send the email.
=cut
sub www_addFriendSave {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my $friendId = $session->form->get('userId');
my $protoFriend = WebGUI::User->new($session, $friendId);
my $i18n = WebGUI::International->new($session, 'Friends');
my $friends = WebGUI::Friends->new($session);
if($friends->isFriend($friendId) || $friends->isInvited($friendId)) {
return www_addFriend($session);
}
# Check for non-existant user id.
if ((!$protoFriend->username) || (!$protoFriend->profileField('ableToBeFriend'))) {
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('add to friends'),
$i18n->get('does not want to be a friend'),
$session->url->getBackToSiteURL(),
$i18n->get('493', 'WebGUI');
return $session->style->userStyle($output);
}
my $friends = WebGUI::Friends->new($session);
$friends->sendAddRequest($friendId, $session->form->get('comments'));
# display result
my $output = sprintf(
q!<h1>%s</h1><p>%s</p><p><a href="%s">%s</a></p><p><a href="%s">%s</a></p>!,
$i18n->get('add to friends'),
sprintf($i18n->get('add to friends confirmation'), $protoFriend->getWholeName),
$session->url->append($session->url->getRequestedUrl, 'op=viewProfile;uid='.$friendId),
sprintf($i18n->get('add to friends profile'), $protoFriend->getFirstName),
$session->url->getBackToSiteURL(),
$i18n->get('493', 'WebGUI'),
);
return $session->style->userStyle($output);
}
#-------------------------------------------------------------------
=head2 www_friendRequest ( )
Form for the friend to accept or deny the request.
DEPRECATED - See WebGUI::Account::Inbox::viewInvitation
=cut
sub www_friendRequest {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my $i18n = WebGUI::International->new($session, 'Friends');
my $inviteId = $session->form->get('inviteId');
my $friends = WebGUI::Friends->new($session);
my $invitation = $friends->getAddRequest($inviteId);
##Invalid invite ID
unless (exists $invitation->{friendId}) { ##No userId corresponds to the inviteId
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('invalid invite code'),
$i18n->get('invalid invite code message'),
$session->url->page("op=viewInbox"),
$i18n->get('354', 'WebGUI');
return $session->style->userStyle($output);
}
##Already a friend (check friendId already in the group)
if ($friends->isFriend($invitation->{inviterId})) {
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('invalid invite code'),
$i18n->get('already a friend'),
$session->url->page("op=viewInbox"),
$i18n->get('354', 'WebGUI');
return $session->style->userStyle($output);
}
##Someone else's invite (check friendId vs current userId).
if ($session->user->userId ne $invitation->{friendId}) { ##This isn't your invitation, dude.
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('invalid invite code'),
$i18n->get('not the right user'),
$session->url->page("op=viewInbox"),
$i18n->get('354', 'WebGUI');
return $session->style->userStyle($output);
}
##Everything looks good. Make the form!
my $inviter = WebGUI::User->new($session, $invitation->{inviterId});
my $output = join '',
sprintf("<h1>%s</h1>\n", $i18n->get('friend request')),
'<p>',
sprintf($i18n->get('friend request description'),
$inviter->getWholeName),
'</p>',
WebGUI::Form::formHeader($session),
WebGUI::Form::hidden($session,
{
name => 'op',
value => 'friendRequestSave',
}
),
WebGUI::Form::hidden($session,
{
name => 'inviteId',
value => $inviteId,
}
),
WebGUI::Form::textarea($session,
{
name => 'comments',
value => $invitation->{comments},
extras => 'disabled=disabled',
}
),
WebGUI::Form::Submit($session, ##Approve
{
name => 'doWhat',
value => $i18n->get('572', 'WebGUI'),
}
),
WebGUI::Form::Submit($session, ##Deny
{
name => 'doWhat',
value => $i18n->get('574', 'WebGUI'),
}
),
WebGUI::Form::formFooter($session),
;
return $session->style->userStyle($output);
}
#-------------------------------------------------------------------
=head2 www_friendRequestSave ( )
Handle form data from the friend's response to the invitation
=cut
sub www_friendRequestSave {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my $i18n = WebGUI::International->new($session, 'Friends');
my $doWhat = $session->form->get('doWhat');
my $inviteId = $session->form->get('inviteId');
my $friends = WebGUI::Friends->new($session);
my $invite = $friends->getAddRequest($inviteId);
my $inviter = WebGUI::User->new($session, $invite->{inviterId});
##Invalid invite ID
if (!$invite->{inviterId}) { ##No userId corresponds to the inviteId
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('invalid invite code'),
$i18n->get('invalid invite code message'),
$session->url->page("op=viewInbox"),
$i18n->get('354', 'WebGUI');
return $session->style->userStyle($output);
}
##If deny, change the status of the request to denied.
if ($doWhat ne $i18n->get('572', 'WebGUI')) { ##request denied
$friends->rejectAddRequest($inviteId);
##Return screen that says they denied the request.
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('friend request'),
sprintf($i18n->get('you have not been added'), $inviter->getWholeName),
$session->url->page("op=viewInbox"),
$i18n->get('354', 'WebGUI');
return $session->style->userStyle($output);
}
##If accepted,
# set the status to accepted.
$friends->approveAddRequest($inviteId);
# Return screen that says they accepted the request.
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('friend request'),
sprintf($i18n->get('you have been added'), $inviter->getWholeName),
$session->url->page("op=viewInbox"),
$i18n->get('354', 'WebGUI');
return $session->style->userStyle($output);
my $instance = WebGUI::Content::Account->createInstance($session,"inbox");
return $instance->displayContent($instance->callMethod("viewInvitation"));
}
#-------------------------------------------------------------------
=head2 www_manageFriends ( )
Display the list of friends and allow the user to remove friends or
send private messages to a subset of them.
DEPRECATED - See WebGUI::Account::Friends::view
=cut
sub www_manageFriends {
my $session = shift;
my ($user, $url, $style) = $session->quick(qw(user url style));
return $session->privilege->insufficient() unless ($user->isRegistered);
my $i18n = WebGUI::International->new($session, 'Friends');
##You have no friends!
my $friends = $user->friends->getUsers;
unless (scalar(@{$friends})) {
my $output = sprintf qq!<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>!,
$i18n->get('my friends'),
$i18n->get('no friends'),
$url->getBackToSiteURL(),
$i18n->get('493', 'WebGUI');
return $style->userStyle($output);
}
# show the friend manager
my %var = (
"account.options" => WebGUI::Operation::Shared::accountOptions($session),
formHeader => WebGUI::Form::formHeader($session)
. WebGUI::Form::hidden($session, { name => 'op', value => 'sendMessageToFriends', }),
removeFriendButton => WebGUI::Form::button($session, { value => $i18n->get('remove'), extras => q|onclick="confirmRemovalOfFriends(form);"|, }),
subjectForm => WebGUI::Form::text($session, { name=>"subject" }),
sendMessageButton => WebGUI::Form::Submit($session, { value => $i18n->get('send message'), }),
messageForm => WebGUI::Form::textarea($session, { name=>"message" }),
formFooter => WebGUI::Form::formFooter($session),
);
foreach my $userId (@{ $friends}) {
my $friend = WebGUI::User->new($session, $userId);
push(@{$var{friends}}, {
name => $friend->getWholeName,
profileUrl => $url->append($url->getRequestedUrl, 'op=viewProfile;uid='.$userId),
status => ($friend->isOnline ? $i18n->get('online') : $i18n->get('offline')),
checkboxForm => WebGUI::Form::checkbox($session, { name => 'userId', value => $userId, }),
});
}
my $template = WebGUI::Asset->new(
$session,
$session->setting->get("manageFriendsTemplateId"),
"WebGUI::Asset::Template",
);
return $style->userStyle($template->process(\%var));
}
#-------------------------------------------------------------------
=head2 www_removeFriends ()
Removes friends from the current user's friends list.
=cut
sub www_removeFriends {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my @users = $session->form->param("userId");
WebGUI::Friends->new($session)->delete(\@users);
return www_manageFriends($session);
}
#-------------------------------------------------------------------
=head2 www_sendMessageToFriends ()
Sends a message to selected friends.
=cut
sub www_sendMessageToFriends {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my @users = $session->form->param("userId");
my $friends = WebGUI::Friends->new($session);
$friends->sendMessage($session->form->process("subject", "text"), $session->form->process("message","textarea"), \@users);
return www_manageFriends($session);
my $instance = WebGUI::Content::Account->createInstance($session,"friends");
return $instance->displayContent($instance->callMethod("view"));
}
1;

318
lib/WebGUI/Operation/Inbox.pm
View file

@ -79,18 +79,23 @@ sub _appendPrivateMessageForm {
name=>"message",
value=>$form->get("message") || "",
});
my $messageId = $form->get("messageId") || $message->getId;
my $messageId = "";
if($form->get("messageId")) {
$messageId = $form->get("messageId");
}
elsif(defined $message) {
$messageId = $message->getId;
}
$vars->{'form_header' } = WebGUI::Form::formHeader($session,{
action => $session->url->page->("op=account;module=inbox;do=sendMessageSave;messageId=$messageId;userId=$userTo->userId"),
action => $session->url->page("op=account;module=inbox;do=sendMessageSave;messageId=$messageId;userId=".$userTo->userId),
extras => q{name="messageForm"}
});
$vars->{ submit_button } = WebGUI::Form::submit($session,{});
$vars->{ submit_label } = $i18n->get("private message submit label");
$vars->{ form_footer } = WebGUI::Form::formFooter($session, {});
}
#-------------------------------------------------------------------
@ -99,263 +104,42 @@ sub _appendPrivateMessageForm {
returns a hashref with internationalized values for message status.
DEPRECATED: Use WebGUI::Inbox::Message->statusCodes
DEPRECATED: Do not use this method in new code. Use WebGUI::Inbox::Message->statusCodes
=cut
sub _status {
my $session = shift;
return WebGUI::Inbox::Message->statusCodes($session);
#my $i18n = WebGUI::International->new($session);
#return {
# "pending" =>$i18n->get(552),
# "completed" =>$i18n->get(350),
# "unread" =>$i18n->get("private message status unread"),
# "read" =>$i18n->get("private message status read"),
# "replied" =>$i18n->get("private message status replied"),
#};
}
#-------------------------------------------------------------------
=head2 www_sendPrivateMessage ( )
DEPRECATED: Use WebGUI::Account::Inbox
Form for sending private messages
DEPRECATED: See WebGUI::Account::Inbox::sendMessage
=cut
sub www_sendPrivateMessage {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my $i18n = WebGUI::International->new($session);
my $form = $session->form;
my $user = $session->user;
my $style = $session->style;
my $settings = $session->setting;
my $templateId = $settings->get("sendPrivateMessageTemplateId");
my $uid = $form->get("uid");
my $userTo = WebGUI::User->new($session,$uid);
my $vars = {};
$vars->{title} = $i18n->get('private message title');
if($uid eq "") {
$vars->{'error_msg'} = $i18n->get('private message no user');
return $style->userStyle(WebGUI::Asset::Template->new($session,$templateId)->process($vars));
}
elsif($uid eq $user->userId) {
$vars->{'error_msg'} = $i18n->get('private message no self error');
return $style->userStyle(WebGUI::Asset::Template->new($session,$templateId)->process($vars));
}
unless($userTo->acceptsPrivateMessages($user->userId)) {
$vars->{'error_msg'} = $i18n->get('private message blocked error');
return $style->userStyle(WebGUI::Asset::Template->new($session,$templateId)->process($vars));
}
_appendPrivateMessageForm($session,$vars,$userTo);
$vars->{ accountOptions } = WebGUI::Operation::Shared::accountOptions($session);
return $style->userStyle(WebGUI::Asset::Template->new($session,$templateId)->process($vars));
my $session = shift;
my $uid = $session->form->get("uid");
my $instance = WebGUI::Content::Account->createInstance($session,"inbox");
return $instance->displayContent($instance->callMethod("sendMessage",[],$uid));
}
#-------------------------------------------------------------------
=head2 www_sendPrivateMessageSave ( )
DEPRECATED: Use WebGUI::Account::Inbox
Post process the form, check for required fields, handle inviting users who are already
members (determined by email address) and send the email.
=cut
sub www_sendPrivateMessageSave {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my $i18n = WebGUI::International->new($session);
my $form = $session->form;
my $user = $session->user;
my $style = $session->style;
my $uid = $form->get("uid");
my $userTo = WebGUI::User->new($session,$uid);
if($uid eq "") {
my $output = sprintf qq|<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>|,
$i18n->get('private message error'),
$i18n->get('private message no user'),
$session->url->getBackToSiteURL(),
$i18n->get('493', 'WebGUI');
return $style->userStyle($output);
} elsif($uid eq $user->userId) {
my $output = sprintf qq|<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>|,
$i18n->get('private message error'),
$i18n->get('private message no self error'),
$session->url->getBackToSiteURL(),
$i18n->get('493', 'WebGUI');
return $style->userStyle($output);
}
my $isReply = 0;
if($form->get("messageId")) {
my $message = WebGUI::Inbox->new($session)->getMessage($form->get("messageId"));
# Ensure that the user sending the message was sent by the user being replied to
# and that the user reponding is the user the message was sent to
if($message->get("sentBy") eq $uid && $message->get("userId") eq $user->userId) {
$isReply = 1;
$message->setStatus("replied");
}
}
my $message = WebGUI::Inbox->new($session)->addPrivateMessage({
message => $form->get("message"),
subject => $form->get("subject"),
userId => $uid,
status => 'unread',
sentBy => $user->userId
},$isReply);
unless(defined $message) {
my $output = sprintf qq|<h1>%s</h1>\n<p>%s</p><a href="%s">%s</a>|,
$i18n->get('private message error'),
$i18n->get('private message blocked error'),
$session->url->getBackToSiteURL(),
$i18n->get('493', 'WebGUI');
return $style->userStyle($output);
}
my $output = sprintf qq!<p>%s</p><a href="%s">%s</a>!,
$i18n->get('private message sent'),
$session->url->getBackToSiteURL(),
$i18n->get('493', 'WebGUI');
return $session->style->userStyle($output);
}
#-------------------------------------------------------------------
=head2 www_viewInbox ( )
DEPRECATED: Use WebGUI::Account::Inbox
Templated display all messages for the current user.
DEPRECATED: See WebGUI::Account::Inbox::view
=cut
sub www_viewInbox {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
my $i18n = WebGUI::International->new($session);
my $vars = {};
my @msg = ();
my $rpp = 50;
#Deal with page number
my $pn = $session->form->get("pn") || 1;
my $pn_url = "";
$pn_url = ";pn=$pn";
#Deal with sort order
my $sortBy = $session->form->get("sortBy");
my $sort_url = "";
$sort_url = ";sortBy=$sortBy" if($sortBy);
#Cache the base url
my $inboxUrl = $session->url->page('op=viewInbox');
$vars->{ title } = $i18n->get(159);
$vars->{'subject_label' } = $i18n->get(351);
$vars->{'subject_url' } = $inboxUrl.$pn_url.";sortBy=subject";
$vars->{'status_label' } = $i18n->get(553);
$vars->{'status_url' } = $inboxUrl.$pn_url.";sortBy=status";
$vars->{'from_label' } = $i18n->get("private message from label");
$vars->{'from_url' } = $inboxUrl.$pn_url.";sortBy=sentBy";
$vars->{'dateStamp_label'} = $i18n->get(352);
$vars->{'dateStamp_url' } = $inboxUrl.$pn_url.";sortBy=dateStamp";
my $adminUser = WebGUI::User->new($session,3)->username;
my $messages = WebGUI::Inbox->new($session)->getMessagesForUser($session->user,$rpp,$pn,$sortBy);
foreach my $message (@$messages) {
next if($message->get('status') eq 'deleted');
my $hash = {};
$hash->{ message_url } = $session->url->page('op=viewInboxMessage;messageId='.$message->getId);
$hash->{ subject } = $message->get("subject");
$hash->{ status_class } = $message->get("status");
$hash->{ status } = _status($session)->{$hash->{ status_class }};
#Get the username of the person who sent the message
my $sentBy = $message->get("sentBy");
#Assume it's the admin user for speed purposes - admin user is cached above the loop
my $from = $adminUser;
#If it wasn't the admin user, get the username of the person who sent it
if($sentBy ne "3") {
my $u = WebGUI::User->new($session,$sentBy);
#If the user that sent the message is valid, get the username
#This case would happen if the user was deleted after sending a private message
if($u->isRegistered) {
$from = $u->username;
}
}
$hash->{ from } = $from;
$hash->{ dateStamp } = $session->datetime->epochToHuman($message->get("dateStamp"));
push(@msg,$hash);
}
my $msgCount = scalar(@{$messages});
#Pagination has to exist on every page regardless if there are more messages or not.
if($pn > 1 ) {
$vars->{'prev_url' } = $inboxUrl.';pn='.($pn-1).$sort_url;
$vars->{'prev_label' } = $i18n->get("private message prev label");
}
if (scalar(@msg) >= $rpp) {
$vars->{'next_url' } = $inboxUrl.';pn='.($pn+1).$sort_url;
$vars->{'next_label' } = $i18n->get("private message next label");
}
$vars->{'messages' } = \@msg;
$vars->{'noresults' } = $i18n->get(353) unless ($msgCount > 0);
$vars->{'accountOptions'} = WebGUI::Operation::Shared::accountOptions($session);
my $templateId = $session->setting->get("viewInboxTemplateId");
return $session->style->userStyle(WebGUI::Asset::Template->new($session,$templateId)->process($vars));
}
#-------------------------------------------------------------------
=head2 www_deletePrivateMessage ( )
DEPRECATED: Use WebGUI::Account::Inbox
Mark a private message in the inbox as deleted.
=cut
sub www_deletePrivateMessage {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
#Get the message
my $message = WebGUI::Inbox->new($session)->getMessage($session->form->param("messageId"));
if(defined $message) {
# set the message status to 'deleted'
$message->setStatus("deleted");
}
return www_viewInbox($session);
my $instance = WebGUI::Content::Account->createInstance($session,"inbox");
return $instance->displayContent($instance->callMethod("view"));
}
#-------------------------------------------------------------------
@ -370,68 +154,8 @@ Templated display of a single message for the user.
sub www_viewInboxMessage {
my $session = shift;
return $session->privilege->insufficient() unless ($session->user->isRegistered);
#Get the message
my $message = WebGUI::Inbox->new($session)->getMessage($session->form->param("messageId"));
#Make sure users can only read their own messages
my $userId = $message->get("userId");
my $groupId = $message->get("groupId");
return $session->privilege->insufficient() unless (
$session->user->userId eq $userId
|| (defined $groupId && $session->user->isInGroup($groupId))
);
my $i18n = WebGUI::International->new($session);
my $vars = {};
$vars->{ title } = $i18n->get("private message reply title");
$vars->{ from_label } = $i18n->get("private message from label");
$vars->{ date_label } = $i18n->get("private message date label");
if (defined $message) {
my $origStatus = $message->get("status");
$message->setStatus("read") if($origStatus eq "unread");
$vars->{'message_subject' } = $message->get("subject");
$vars->{'dateStamp'} =$session->datetime->epochToHuman($message->get("dateStamp"));
$vars->{'status' } = _status($session)->{$message->get("status")};
$vars->{ message } = $message->get("message");
$vars->{ delete_text } = $i18n->get("private message delete text");
$vars->{ delete_url } = '?op=deletePrivateMessage;messageId=' . $message->getId;
unless ($vars->{message} =~ /\<a/ig) {
$vars->{message} =~ s/(http\S*)/\<a href=\"$1\"\>$1\<\/a\>/g;
}
unless ($vars->{message} =~ /\<div/ig || $vars->{message} =~ /\<br/ig || $vars->{message} =~ /\<p/ig) {
$vars->{message} =~ s/\n/\<br \/\>\n/g;
}
#Get the username of the person who sent the message
my $sentBy = $message->get("sentBy");
#Assume it's the admin user who sent the message
my $from = WebGUI::User->new($session,3)->username;
#If the user actually exists, get the username
if($sentBy ne "1" && $sentBy ne "3") {
$from = WebGUI::User->new($session,$sentBy)->username;
}
$vars->{ from } = $from;
#If the person didn't send the message to themselves (for admin only) and the user still exsists (check visitor case)
if($sentBy ne $session->user->userId &&
$sentBy ne "1" &&
$origStatus ne "pending" &&
$origStatus ne "completed") {
my $u = WebGUI::User->new($session,$sentBy);
$vars->{'canReply'} = "true";
_appendPrivateMessageForm($session,$vars,$u,$message);
}
}
$vars->{'accountOptions'} = WebGUI::Operation::Shared::accountOptions($session);
my $templateId = $session->setting->get("viewInboxMessageTemplateId");
return $session->style->userStyle(WebGUI::Asset::Template->new($session,$templateId)->process($vars));
my $instance = WebGUI::Content::Account->createInstance($session,"inbox");
return $instance->displayContent($instance->callMethod("viewMessage"));
}
1;

204
lib/WebGUI/Operation/Profile.pm
View file

@ -24,6 +24,7 @@ use WebGUI::ProfileField;
use WebGUI::ProfileCategory;
use WebGUI::Operation::Shared;
use WebGUI::Operation::Friends;
use WebGUI::Account::Profile;
=head1 NAME
@ -92,12 +93,9 @@ email address to check for duplication
sub isDuplicateEmail {
my $session = shift;
my $email = shift;
my ($otherEmail)
= $session->db->quickArray(
'select count(*) from userProfileData where email = ? and userId <> ?',
[$email, $session->user->userId]
);
return ($otherEmail > 0);
my $field = WebGUI::ProfileField->new($session,'email');
return $field->isDuplicate($email);
}
#-------------------------------------------------------------------
@ -107,7 +105,7 @@ sub isDuplicateEmail {
Saves profile data to a user's profile. Does not validate any of the data.
DEPRECATED - This method is deprecated, and should not be used in new code. Use
the saveProfileFields method from WebGUI::Account::Profile instead
the updateProfileFields method in WebGUI::User
=head3 session
@ -127,8 +125,7 @@ sub saveProfileFields {
my $session = shift;
my $u = shift;
my $profile = shift;
WebGUI::Account::Profile->saveProfileFields($session,$u,$profile);
$u->updateProfileFields($profile);
}
#-------------------------------------------------------------------
@ -139,7 +136,7 @@ Validates profile data from the session form variables. Returns processed data,
and errors.
DEPRECATED - This method is deprecated, and should not be used in new code. Use
the validateProfileData method from WebGUI::Account::Profile instead
the validateProfileDataFromForm method from WebGUI::User instead
There are two levels of validation:
@ -159,48 +156,38 @@ warning if it is a duplicate.
=cut
sub validateProfileData {
my $session = shift;
my $opts = shift || {};
my $regOnly = $opts->{regOnly};
my %data = ();
my $error = "";
my $warning = "";
my $i18n = WebGUI::International->new($session);
my $fields = $regOnly ? WebGUI::ProfileField->getRegistrationFields($session)
my $session = shift;
my $opts = shift || {};
my $regOnly = $opts->{regOnly};
my $error = "";
my $warning = "";
my $fields = $regOnly ? WebGUI::ProfileField->getRegistrationFields($session)
: WebGUI::ProfileField->getEditableFields($session);
foreach my $field (@$fields) {
my $fieldValue = $field->formProcess;
if (ref $fieldValue eq "ARRAY") {
$data{$field->getId} = $$fieldValue[0];
} else {
$data{$field->getId} = $fieldValue;
}
if ($field->isRequired && $data{$field->getId} eq "") {
$error .= '<li>'.$field->getLabel.' '.$i18n->get(451).'</li>';
} elsif ($field->getId eq "email" && isDuplicateEmail($session,$data{$field->getId}) && WebGUI::ProfileField->new($session, "email")->isRequired() ) {
$warning .= '<li>'.$i18n->get(1072).'</li>';
}
if ($field->getId eq "language" && $fieldValue ne "") {
unless (exists $i18n->getLanguages()->{$fieldValue}) {
$error .= '<li>'.$field->getLabel.' '.$i18n->get(451).'</li>';
}
}
}
return (\%data, $error, $warning);
my $retHash = $session->user->validateProfileDataFromForm($fields);
use Data::Dumper;
print Dumper($retHash)."\n\n\n";
my $warnings = $retHash->{warnings};
my $errors = $retHash->{errors};
my $format = "<li>%s</li>";
my $warning = "";
my $error = "";
map { $warning .= sprintf($format,$_) }@{$warnings};
map { $error .= sprintf($format,$_) }@{$errors};
return ($retHash->{profile},$error,$warning);
}
#-------------------------------------------------------------------
=head2 www_editProfile ( session )
Provide a form where user profile data can be entered or edited. The subroutine
makes a large set of template variables which are passed to a template for presentation
and styling. The default template is PBtmpl0000000000000051 and is not user
selectable.
DEPRECATED - Use WebGUI::Account::Profile::www_edit
Calls www_editProfileSave on submission.
DEPRECATED - This method is deprecated, and should not be used in new code.
Use WebGUI::Account::Profile::www_edit
=head3 session
@ -209,91 +196,18 @@ A reference to the current session.
=cut
sub www_editProfile {
my $session = shift;
return WebGUI::Operation::Auth::www_auth($session,"init") if($session->user->isVisitor);
my $i18n = WebGUI::International->new($session);
my $vars = {};
$vars->{displayTitle} .= $i18n->get(338);
$vars->{'profile.message'} = $_[0] if($_[0]);
$vars->{'profile.form.header'} = "\n\n".WebGUI::Form::formHeader($session,{});
$vars->{'profile.form.footer'} = WebGUI::Form::formFooter($session,);
$vars->{'profile.form.hidden'} = WebGUI::Form::hidden($session,{"name"=>"op","value"=>"editProfileSave"});
$vars->{'profile.form.hidden'} .= WebGUI::Form::hidden($session,{"name"=>"uid","value"=>$session->user->userId});
my @array = ();
foreach my $category (@{WebGUI::ProfileCategory->getCategories($session)}) {
next unless $category->isEditable;
my @temp = ();
foreach my $field (@{$category->getFields}) {
next unless ($field->isEditable);
next if $field->getId =~ /contentPositions/;
push(@temp, {
'profile.form.element' => $field->formField,
'profile.form.element.label' => $field->getLabel,
'profile.form.element.subtext' => $field->isRequired ? "*" : undef,
'profile.form.element.extras' => $field->getExtras,
});
}
push(@array, {
'profile.form.category' => $category->getLabel,
'profile.form.category.loop' => \@temp
});
}
$vars->{'profile.form.elements'} = \@array;
$vars->{'profile.form.submit'} = WebGUI::Form::submit($session,{});
$vars->{'profile.form.cancel'} = WebGUI::Form::button($session,{
value => $i18n->get('cancel'),
extras=>q|onclick="history.go(-1);" class="backwardButton"|,
});
$vars->{'profile.accountOptions'} = WebGUI::Operation::Shared::accountOptions($session);
return $session->style->userStyle(WebGUI::Asset::Template->new($session, $session->setting->get('editUserProfileTemplate'))->process($vars));
my $session = shift;
my $instance = WebGUI::Content::Account->createInstance($session,"profile");
return $instance->displayContent($instance->callMethod("edit"));
}
#-------------------------------------------------------------------
=head2 www_editProfileSave ( session )
Validates all data submitted by www_editProfile. If errors or warnings are present,
they are concatenated and sent back to www_editProfile for display and to let the user
correct their mistakes.
If no mistakes are present, saves the data to the user's profile, updates the session user
object.
Returns the user to WebGUI::Operation::Auth::www_auth when done.
DEPRECATED: Use WebGUI::Account::Profile::www_editSave
=head3 session
A reference to the current session.
=cut
sub www_editProfileSave {
my $session = shift;
my ($profile, $error, $warning);
return WebGUI::Operation::Auth::www_auth($session, "init") if ($session->user->isVisitor);
($profile, $error, $warning) = validateProfileData($session);
$error .= $warning;
return www_editProfile($session, '<ul>'.$error.'</ul>') if($error ne "");
foreach my $fieldName (keys %{$profile}) {
$session->user->profileField($fieldName,$profile->{$fieldName});
}
return WebGUI::Operation::Auth::www_auth($session);
}
#-------------------------------------------------------------------
=head2 www_viewProfile ( session )
View the profile data for a user by the userId specified by the form variable C<uid>.
Validates that the user requesting the profile data is allowed to see it.
Similarly to www_editProfile, this method is templated. The default template
is PBtmpl0000000000000052. The template is not user selectable.
DEPRECATED: Use WebGUI::Account::Profile::www_view
DEPRECATED: This method is deprecated, and should not be used in new code.
Use WebGUI::Account::Profile::www_view
=head3 session
@ -302,46 +216,10 @@ A reference to the current session.
=cut
sub www_viewProfile {
my $session = shift;
my $u = WebGUI::User->new($session,$session->form->process("uid"));
my $i18n = WebGUI::International->new($session);
my $vars = {};
$vars->{displayTitle} = $i18n->get(347).' '.$u->username;
return $session->privilege->notMember() if($u->username eq "");
return $session->style->userStyle($vars->{displayTitle}.'. '.$i18n->get(862)) if($u->profileField("publicProfile") < 1 && ($session->user->userId ne $session->form->process("uid") || $session->user->isAdmin));
return $session->privilege->insufficient() if(!$session->user->isRegistered);
my @array = ();
foreach my $category (@{WebGUI::ProfileCategory->getCategories($session)}) {
next unless ($category->get("visible"));
push(@array, {'profile.category' => $category->getLabel});
foreach my $field (@{$category->getFields}) {
next unless ($field->get("visible"));
next if ($field->get("fieldName") eq "email" && !$u->profileField("publicEmail"));
push @array, {
'profile.label' => $field->getLabel,
'profile.value' => $field->formField(undef,2,$u),
'profile.extras' => $field->getExtras,
};
}
}
$vars->{'profile.elements'} = \@array;
if ($session->user->userId eq $session->form->process("uid")) {
$vars->{'profile.accountOptions'} = WebGUI::Operation::Shared::accountOptions($session);
}
else {
## TODO: Make this more legible code, maybe refactor into a method
push @{$vars->{'profile.accountOptions'}}, {
'options.display' => '<a href="'.$session->url->page("op=addFriend;userId=".$u->userId).'">'.$i18n->get('add to friends list', 'Friends').'</a>',
}, {
'options.display' => '<a href="'.$session->url->page('op=sendPrivateMessage;uid='.$session->form->process("uid")).'">'.$i18n->get('send private message').'</a>',
};
}
return $session->style->userStyle(WebGUI::Asset::Template->new($session, $session->setting->get('viewUserProfileTemplate'))->process($vars));
my $session = shift;
my $uid = $session->form->process("uid");
my $instance = WebGUI::Content::Account->createInstance($session,"profile");
return $instance->displayContent($instance->callMethod("view",[],$uid));
}

74
lib/WebGUI/Operation/Settings.pm
View file

@ -226,34 +226,7 @@ sub definition {
namespace=>"AdminConsole",
defaultValue=>$setting->get("AdminConsoleTemplate")
});
# messaging settings
push(@fields, {
tab=>"messaging",
fieldType=>"template",
name=>"viewInboxTemplateId",
label=>$i18n->get('view inbox template'),
hoverHelp=>$i18n->get('view inbox template description'),
namespace=>"Inbox",
defaultValue=>$setting->get("viewInboxTemplateId"),
});
push(@fields, {
tab=>"messaging",
fieldType=>"template",
name=>"viewInboxMessageTemplateId",
label=>$i18n->get('view inbox message template'),
hoverHelp=>$i18n->get('view inbox message template description'),
namespace=>"Inbox/Message",
defaultValue=>$setting->get("viewInboxMessageTemplateId"),
});
push(@fields, {
tab=>"messaging",
fieldType=>"template",
name=>"sendPrivateMessageTemplateId",
label=>$i18n->get('send private message template'),
hoverHelp=>$i18n->get('send private message template description'),
namespace=>"Inbox/SendPrivateMessage",
defaultValue=>$setting->get("sendPrivateMessageTemplateId"),
});
# messaging settings
push(@fields, {
tab=>"messaging",
fieldType=>"text",
@ -444,15 +417,6 @@ sub definition {
namespace=>"userInvite/Email",
defaultValue=>$setting->get("userInvitationsEmailTemplateId"),
});
push(@fields, {
tab => "user",
fieldType => "template",
defaultValue => "managefriends_________",
namespace => "friends/manage",
name => "manageFriendsTemplateId",
label => $i18n->get("manage friends template", "Friends"),
hoverHelp => $i18n->get("manage friends template help", "Friends"),
});
push @fields, {
tab => "user",
name => "showMessageOnLogin",
@ -485,24 +449,7 @@ sub definition {
hoverHelp => $i18n->get( 'showMessageOnLoginBody description' ),
defaultValue => $setting->get('showMessageOnLoginBody'),
};
push @fields, {
tab => "user",
name => 'viewUserProfileTemplate',
fieldType => 'template',
namespace => 'Operation/Profile/View',
label => $i18n->get( 'user profile view template' ),
hoverHelp => $i18n->get( 'user profile view template description' ),
defaultValue => $setting->get('viewUserProfileTemplate'),
};
push @fields, {
tab => "user",
name => 'editUserProfileTemplate',
fieldType => 'template',
namespace => 'Operation/Profile/Edit',
label => $i18n->get( 'user profile edit template' ),
hoverHelp => $i18n->get( 'user profile edit template description' ),
defaultValue => $setting->get('editUserProfileTemplate'),
};
# auth settings
my $options;
foreach (@{$session->config->get("authMethods")}) {
@ -638,14 +585,18 @@ sub www_editSettings {
#Create the instance
my $className = $account->{className};
my $instance = eval { WebGUI::Pluggable::instanciate($className,"new",[ $session ]) };
if ( my $e = WebGUI::Error->caught ) {
if ( $@ ) {
$session->log->warn("Could not instantiate account pluggin $className...skipping");
next;
}
#Get the content of the settings form from the instance
my $settingsForm = $instance->editSettingsForm;
my $settingsForm = eval { $instance->editSettingsForm };
if( $@ ) {
$session->log->warn("Error calling editSettingsForm in $className...skipping : ".$@);
next;
}
#If editUserSettingsForm is empty, skip it
next if $settingsForm eq "";
@ -710,7 +661,12 @@ sub www_saveSettings {
next;
}
#Save the settings
$instance->editSettingsFormSave;
eval { $instance->editSettingsFormSave };
if( my $e = WebGUI::Error->caught ) {
$session->log->warn("Error calling editSettingsFormSave in $className...skipping : ".$e->error);
next;
}
}

65
lib/WebGUI/Operation/Shared.pm
View file

@ -27,71 +27,18 @@ Shared routines for WebGUI Operations.
TODO: DOCUMENT ME
DEPRECATED - USE WebGUI::Account::User->appendAccountOptions
=cut
#-------------------------------------------------------------------
sub accountOptions {
my $session = shift;
my $i18n = WebGUI::International->new($session);
my @array;
my $op = $session->form->process("op");
if ($session->user->isInGroup(12)) {
my %hash;
if ($session->var->isAdminOn) {
$hash{'options.display'} .= '<a href="'.$session->url->page('op=switchOffAdmin').'">'.$i18n->get(12).'</a>';
} else {
$hash{'options.display'} .= '<a href="'.$session->url->page('op=switchOnAdmin').'">'.$i18n->get(63).'</a>';
}
push(@array,\%hash);
}
unless ($op eq "displayAccount"){
my %hash;
$hash{'options.display'} = '<a href="'.$session->url->page('op=auth;method=init').'">'.$i18n->get(342).'</a>';
push(@array,\%hash);
}
unless ($op eq "editProfile"){
my %hash;
$hash{'options.display'} = '<a href="'.$session->url->page('op=editProfile').'">'.$i18n->get(341).'</a>';
push(@array,\%hash);
}
unless ($op eq "viewProfile"){
my %hash;
$hash{'options.display'} = '<a href="'.$session->url->page('op=viewProfile;uid='.$session->user->userId).'">'.$i18n->get(343).'</a>';
push(@array,\%hash);
}
unless ($op eq "viewInbox"){
my %hash;
$hash{'options.display'} = '<a href="'.$session->url->page('op=viewInbox').'">'.$i18n->get(354).'</a>';
push(@array,\%hash);
}
push(@array, {'options.display' => '<a href="'.$session->url->page('shop=transaction;method=manageMy').'">'.$i18n->get('my purchases', 'Shop').'</a>'});
if ($session->setting->get('userInvitationsEnabled')) {
push @array, {
'options.display' => sprintf('<a href=%s>%s</a>', $session->url->page('op=inviteUser'), $i18n->get('invite a friend')),
};
}
unless ($op eq "manageFriends") {
push @array, {
'options.display' => sprintf('<a href=%s>%s</a>', $session->url->page('op=manageFriends'), $i18n->get('see my friends', 'Friends')),
};
}
my %logout;
$logout{'options.display'} = '<a href="'.$session->url->page('op=auth;method=logout').'">'.$i18n->get(64).'</a>';
push(@array,\%logout);
if ($session->setting->get("selfDeactivation") && !$session->user->isAdmin){
my %hash;
$hash{'options.display'} = '<a href="'.$session->url->page('op=auth;method=deactivateAccount').'">'.$i18n->get(65).'</a>';
push(@array,\%hash);
}
{ ##Return to site link
my %hash;
$hash{'options.display'} = '<a href="'.$session->url->getBackToSiteURL.'">'.$i18n->get(493).'</a>';
push(@array,\%hash);
}
return \@array;
my $vars = {};
WebGUI::Account->appendAccountLinks($session,$vars);
return $vars->{'account.options'};
}