blackicedbear/FHC-Core
1
0
Fork 0
mirror of https://github.com/FH-Complete/FHC-Core.git synced 2026-07-22 17:32:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature-3716/Messaging_inbox_outbox_user'

Browse Source
This commit is contained in:
Andreas Österreicher
2020-02-20 14:59:49 +01:00
parent cc5bfdc292 0b3d5e19a3
commit 4477afc5ed
83 changed files with 4886 additions and 3385 deletions
Download Patch File Download Diff File Expand all files Collapse all files
application/models/CL/Messages_model.php
+757 -112
View File
@@ -1,11 +1,31 @@
<?php
/**
* This model extends CI_Model because here is just implemented logic
* It does not represent a resource (ex. like models that extend DB_Model)
* Messages GUI logic
* - This model extends CI_Model because here is just implemented logic
* - It does not represent a resource (ex. like models that extend DB_Model)
*/
class Messages_model extends CI_Model
{
const REPLY_SUBJECT_PREFIX = 'Re: '; // reply subject prefix
// To quote a reply body message
const REPLY_BODY_FORMAT = '<br>
<br>
<blockquote>
<i>
On %s %s %s wrote:
</i>
</blockquote>
<blockquote style="border-left:2px solid; padding-left: 8px">
%s
</blockquote>';
const NO_AUTH_UID = 'online'; // hard coded uid if no authentication is performed
// Recipients types
const TYPE_PERSONS = 'persons';
const TYPE_PRESTUDENTS = 'prestudents';
/**
* Constructor
*/
@@ -14,159 +34,617 @@ class Messages_model extends CI_Model
parent::__construct();
// Loads the message library
$this->load->library('MessageLib');
$this->load->library('MessageLib'); // MessageModel loaded here!
// Loads the person log library
$this->load->library('PersonLogLib');
// Loads the widget library
$this->load->library('WidgetLib');
// Loads model MessageToken_model
$this->load->model('system/MessageToken_model', 'MessageTokenModel');
// Loads model Benutzerrolle_model
$this->load->model('system/Benutzerrolle_model', 'BenutzerrolleModel');
// Loads model Prestudent_model
$this->load->model('crm/Prestudent_model', 'PrestudentModel');
}
//------------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Executes message sending
* @param $sender_id
* @return array wether execution was successfull - error or success
* Set a message as read by its id ($message_id + $person_id)
*/
public function send($msgVarsData, $relationmessage_id = null, $oe_kurzbz = null, $vorlage_kurzbz = null, $msgVars = null)
public function setMessageRead($message_id, $person_id)
{
$subject = $this->input->post('subject');
$body = $this->input->post('body');
// Checks parameters
if (!is_numeric($message_id) || !is_numeric($person_id)) return error('Invalid setMessageRead parameters');
$authUser = $this->getAuthUser();
// Loads needed models
$this->load->model('system/MsgStatus_model', 'MsgStatusModel');
if (isError($authUser)) return $authUser;
$statuResult = $this->MsgStatusModel->loadWhere(
array(
'message_id' => $message_id,
'person_id' => $person_id,
'status' => MSG_STATUS_READ
)
);
$sender_id = getData($authUser)[0]->person_id;
// Send message(s)
if (hasData($msgVarsData))
if (isError($statuResult)) return $statuResult;
if (!hasData($statuResult))
{
for ($i = 0; $i < count(getData($msgVarsData)); $i++)
{
$parsedText = "";
$msgVarsDataArray = $this->replaceKeys((array)getData($msgVarsData)[$i]); // replaces array keys
// Send without vorlage
if (isEmptyString($vorlage_kurzbz))
{
$parsedText = $this->messagelib->parseMessageText($body, $msgVarsDataArray);
$msg = $this->messagelib->sendMessage($sender_id, $msgVarsDataArray['person_id'], $subject, $parsedText, PRIORITY_NORMAL, $relationmessage_id, $oe_kurzbz);
}
// Send with vorlage
else
{
if (is_array($msgVars))
{
// Additional message variables
foreach ($msgVars as $key => $msgvar)
{
$msgVarsDataArray[$key] = $msgvar;
}
}
$msg = $this->messagelib->sendMessageVorlage($sender_id, $msgVarsDataArray['person_id'], $vorlage_kurzbz, $oe_kurzbz, $msgVarsDataArray);
}
if (isError($msg)) return $msg;
// Write log entry
$personLog = $this->personloglib->log(
$msgVarsDataArray['person_id'],
'Action',
array(
'name' => 'Message sent',
'message' => 'Message sent from person '.$sender_id.' to '.$msgVarsDataArray['person_id'].', messageid '.getData($msg),
'success' => 'true'
),
'kommunikation',
'core',
null,
getAuthUID()
);
if (isError($personLog)) return $personLog;
}
return success('Messages sent successfully');
// Set date used to insert
return $this->MsgStatusModel->insert(
array(
'message_id' => $message_id,
'person_id' => $person_id,
'status' => MSG_STATUS_READ,
'insertvon' => getAuthUID()
)
); // insert and return result
}
else
{
return $msgVarsData;
return success('Already set as read');
}
}
/**
* Send a reply
* Prepares data for the view system/messages/ajaxWrite
*/
public function sendReply($subject, $body, $persons, $relationmessage_id, $token)
public function prepareAjaxWrite()
{
$relationmsg = $this->MessageTokenModel->getMessageByToken($token);
if (!hasData($relationmsg) || $relationmessage_id !== getData($relationmsg)[0]->message_id)
{
show_error('Error while sending reply');
}
$ouResult = $this->PrestudentModel->getOrganisationunitsByPersonId(getAuthPersonId());
// Get sender (receiver of previous msg)
$sender_id = getData($relationmsg)[0]->receiver_id;
if (isError($ouResult)) show_error('An error occurred while loading this page, please contact the site administrator');
// Get message data of persons
$data = $this->MessageTokenModel->getPersonData($persons);
if (hasData($data))
$ouOptions = '<option value="0">Select...</option>';
if (hasData($ouResult))
{
for ($i = 0; $i < count(getData($data)); $i++)
foreach (getData($ouResult) as $ou)
{
$dataArray = (array)getData($data)[$i];
$msg = $this->messagelib->sendMessage($sender_id, $dataArray['person_id'], $subject, $body, PRIORITY_NORMAL, $relationmessage_id, null);
if (isError($msg)) return $msg;
// Logs person data
$personLog = $this->personloglib->log(
$sender_id,
'Action',
array(
'name' => 'Message sent',
'message' => 'Message sent from person '.$sender_id.' to '.$dataArray['person_id'].', messageid '.getData($msg),
'success' => 'true'
),
'kommunikation',
'core',
null,
'online'
$ouOptions .= sprintf(
"\n".'<option value="%s">%s</option>',
is_numeric($ou->prestudent_id) ? $ou->oe_kurzbz : MessageLib::ALT_OE,
$ou->bezeichnung . (is_numeric($ou->prestudent_id) ? '' : ' *')
);
// Unpark bewerber after he sends message
$personLog = $this->personloglib->unPark($sender_id);
if (isError($personLog)) return $personLog;
}
}
return success('Reply sent');
return array('organisationUnitOptions' => $ouOptions);
}
/**
*
* Prepares data for the view system/messages/ajaxWriteReply
*/
public function getAuthUser()
public function prepareAjaxWriteReply($token)
{
$sender_id = null;
if (isEmptyString($token)) show_error('The given token is not valid');
$this->load->model('person/Person_model', 'PersonModel');
$authUser = $this->PersonModel->getByUid(getAuthUID());
// Retrieves message using the given token
$messageResult = $this->MessageTokenModel->getMessageByToken($token);
if (isError($messageResult)) show_error('An error occurred while loading this page, please contact the site administrator');
if (!hasData($authUser)) $authUser = error('The current logged user person_id is not defined');
if (hasData($messageResult))
{
$message = getData($messageResult)[0]; // Found message data
return $authUser;
// Retrieves message sender information
$senderResult = $this->MessageTokenModel->getSenderData($message->sender_id);
if (isError($senderResult)) show_error('An error occurred while loading this page, please contact the site administrator');
if (hasData($senderResult))
{
$sender = getData($senderResult)[0]; // Found sender data
$replySubject = self::REPLY_SUBJECT_PREFIX.$message->subject;
$replyBody = $this->_getReplyBody($message->body, $sender->vorname, $sender->nachname, $message->sent);
return array (
'receiver' => $sender->vorname.' '.$sender->nachname, // yep! the sender of the sent message is the receiver of the reply message
'subject' => $replySubject,
'body' => $replyBody,
'receiver_id' => $message->sender_id,
'relationmessage_id' => $message->message_id,
'token' => $token
);
}
}
}
/**
*
* Prepares data for the view system/messages/ajaxRead
* If everything is fine returns a list of received messages (objects)
*/
public function replaceKeys($data)
public function prepareAjaxReadReceived()
{
// Retrieves received messages for the logged user and its organisation units
$receivedMessagesResult = $this->RecipientModel->getReceivedMessages(
getAuthPersonId(),
$this->config->item(MessageLib::CFG_OU_RECEIVERS)
);
// If an error occurred return it
if (isError($receivedMessagesResult)) return $receivedMessagesResult;
// If data were found
if (hasData($receivedMessagesResult))
{
$jsonArray = array(); // array that contains all the received messages
// Collect'em all in the array $jsonArray
foreach (getData($receivedMessagesResult) as $receivedMessage)
{
$jsonRecord = new stdClass();
$jsonRecord->message_id = $receivedMessage->message_id;
$jsonRecord->subject = $receivedMessage->subject;
$jsonRecord->body = $receivedMessage->body;
$jsonRecord->from = $receivedMessage->vorname.' '.$receivedMessage->nachname;
$sentDate = new DateTime($receivedMessage->sent);
$jsonRecord->sent = $sentDate->format('d/m/Y H:i:s');
$jsonRecord->status = $receivedMessage->status;
$jsonRecord->statusPersonId = $receivedMessage->statuspersonid;
$jsonRecord->token = $receivedMessage->token;
$jsonArray[] = $jsonRecord;
}
return success(json_encode($jsonArray)); // return as an json encoded string
}
return success('No messages were found'); // NOT a blocking error
}
/**
* Prepares data for the view system/messages/ajaxRead
* If everything is fine returns a list of sent messages (objects)
*/
public function prepareAjaxReadSent()
{
// Retrieves sent messages from the logged user
$sentMessagesResult = $this->RecipientModel->getSentMessages(getAuthPersonId());
if (isError($sentMessagesResult)) return $sentMessagesResult; // If an error occurred return it
if (hasData($sentMessagesResult))
{
$jsonArray = array();// array that contains all the sent messages
// Collect'em all in the array $jsonArray
foreach (getData($sentMessagesResult) as $sentMessage)
{
$jsonRecord = new stdClass();
$jsonRecord->message_id = $sentMessage->message_id;
$jsonRecord->subject = $sentMessage->subject;
$jsonRecord->body = $sentMessage->body;
$sentDate = new DateTime($sentMessage->sent);
$jsonRecord->sent = $sentDate->format('d/m/Y H:i:s');
$jsonRecord->status = $sentMessage->status;
$jsonRecord->statusPersonId = $sentMessage->statuspersonid;
$jsonRecord->token = $sentMessage->token;
if ($sentMessage->person_id == $this->config->item(MessageLib::CFG_SYSTEM_PERSON_ID))
{
$jsonRecord->to = $sentMessage->oe;
}
else
{
$jsonRecord->to = $sentMessage->vorname.' '.$sentMessage->nachname;
}
$jsonArray[] = $jsonRecord;
}
return success(json_encode($jsonArray)); // return as an json encoded string
}
return success('No messages were found'); // NOT a blocking error
}
/**
* Prepares data for the view system/messages/htmlRead using a token that identifies a single message
*/
public function prepareHtmlRead($token)
{
if (isEmptyString($token)) show_error('The given token is not valid');
// Retrieves message using the given token
$messageResult = $this->MessageTokenModel->getMessageByToken($token);
if (isError($messageResult)) show_error(getError($messageResult));
if (!hasData($messageResult)) show_error('No message found with the given token');
$message = getData($messageResult)[0]; // Found message data
// Set message as read
$srmsbtResult = $this->MessageTokenModel->setReadMessageStatusByToken($token);
if (isError($srmsbtResult)) show_error(getError($srmsbtResult));
// Retrieves message sender information
$senderResult = $this->MessageTokenModel->getSenderData($message->sender_id);
if (isError($senderResult)) show_error(getError($senderResult));
if (!hasData($senderResult)) show_error('No sender information found');
$sender = getData($senderResult)[0]; // Found sender data
// Check if the receiver is an employee
$isEmployee = false; // not by default
$isEmployeeResult = $this->MessageTokenModel->isEmployee($message->receiver_id);
if (isError($isEmployeeResult)) show_error(getError($isEmployeeResult));
if (hasData($isEmployeeResult)) $isEmployee = true;
// If the sender is an employee and are present configurations to reply
$hrefReply = '';
if ($isEmployee && !isEmptyString($this->config->item(MessageLib::CFG_REDIRECT_VIEW_MESSAGE_URL)))
{
$hrefReply = $this->config->item(MessageLib::CFG_MESSAGE_SERVER).
$this->config->item(MessageLib::CFG_REDIRECT_VIEW_MESSAGE_URL).
$token;
}
return array (
'sender' => $sender,
'message' => $message,
'hrefReply' => $hrefReply
);
}
/**
* Prepares data for the view system/messages/htmlWriteReply using a token that identifies a single message
*/
public function prepareHtmlWriteReply($token)
{
if (isEmptyString($token)) show_error('The given token is not valid');
// Retrieves message using the given token
$messageResult = $this->MessageTokenModel->getMessageByToken($token);
if (isError($messageResult)) show_error(getError($messageResult));
if (!hasData($messageResult)) show_error('No message found with the given token');
$message = getData($messageResult)[0]; // Found message data
// Retrieves message sender information
$senderResult = $this->MessageTokenModel->getSenderData($message->sender_id);
if (isError($senderResult)) show_error(getError($senderResult));
if (!hasData($senderResult)) show_error('No sender information found');
$sender = getData($senderResult)[0]; // Found sender data
$replySubject = self::REPLY_SUBJECT_PREFIX.$message->subject;
$replyBody = $this->_getReplyBody($message->body, $sender->vorname, $sender->nachname, $message->sent);
return array (
'receiver' => $sender->vorname.' '.$sender->nachname, // yep! the sender of the sent message is the receiver of the reply message
'subject' => $replySubject,
'body' => $replyBody,
'receiver_id' => $message->sender_id,
'relationmessage_id' => $message->message_id,
'token' => $token
);
}
/**
* Prepares data for the view system/messages/htmlWriteTemplate using person ids as main parameter
* Wrap method to _prepareHtmlWriteTemplate
*/
public function prepareHtmlWriteTemplatePersons($persons, $message_id = null, $recipient_id = null)
{
// Retrieves persons information
$msgVarsData = $this->MessageModel->getMsgVarsDataByPersonId($persons);
return $this->_prepareHtmlWriteTemplate($msgVarsData, $message_id, $recipient_id);
}
/**
* Prepares data for the view system/messages/htmlWriteTemplate using prestudent ids as main parameter
* Wrap method to _prepareHtmlWriteTemplate
*/
public function prepareHtmlWriteTemplatePrestudents($prestudents, $message_id = null, $recipient_id = null)
{
// Retrieves prestudents information
$msgVarsData = $this->MessageModel->getMsgVarsDataByPrestudentId($prestudents);
return $this->_prepareHtmlWriteTemplate($msgVarsData, $message_id, $recipient_id);
}
/**
* Sends a new message or a reply to a message (if $relationmessage_id is given)
* using the template stored in the subject and body
*/
public function sendImplicitTemplate($type, $recipients_ids, $subject, $body, $relationmessage_id = null)
{
// Retrieves the sender id
$sender_id = getAuthPersonId();
if (!is_numeric($sender_id)) show_error('The current logged user person_id is not defined');
$msgVarsData = error('No persons nor prestudents were provided');
// Retrieves message vars data for the given user/s
if ($type == self::TYPE_PERSONS) // if persons were given
{
$msgVarsData = $this->MessageModel->getMsgVarsDataByPersonId($recipients_ids);
}
elseif ($type == self::TYPE_PRESTUDENTS) // otherwise prestudents were given
{
$msgVarsData = $this->MessageModel->getMsgVarsDataByPrestudentId($recipients_ids);
// Retrieve organisation unit for the recipients
$organisationUnitsResult = $this->PrestudentModel->getOrganisationunits($recipients_ids);
if (isError($organisationUnitsResult)) return $organisationUnitsResult;
if (hasData($organisationUnitsResult)) $senderOUArray = getData($organisationUnitsResult);
}
if (isError($msgVarsData)) show_error(getError($msgVarsData));
if (!hasData($msgVarsData)) show_error('No recipients were given');
$senderOU = null; // sender organisation unit only for presetudents
$receiversCounter = 0; // a counter
// Looping on receivers data
foreach (getData($msgVarsData) as $receiver)
{
$msgVarsDataArray = $this->_lowerReplaceSpaceArrayKeys((array)$receiver); // replaces array keys
$parsedSubject = parseText($subject, $msgVarsDataArray);
$parsedBody = parseText($body, $msgVarsDataArray);
// If exist an organisation unit for this prestudent and it is valid
if (isset($senderOUArray[$receiversCounter])
&& isset($senderOUArray[$receiversCounter]->oe_kurzbz)
&& !isEmptyString($senderOUArray[$receiversCounter]->oe_kurzbz))
{
$senderOU = $senderOUArray[$receiversCounter]->oe_kurzbz;
}
else
{
$senderOU = null;
}
$message = $this->messagelib->sendMessageUser(
$msgVarsDataArray['person_id'], // receiverPersonId
$parsedSubject, // subject
$parsedBody, // body
$sender_id, // sender_id
$senderOU, // senderOU
$relationmessage_id, // relationmessage_id
MSG_PRIORITY_NORMAL // priority
);
if (isError($message)) return $message;
if (!hasData($message)) return error('No messages were saved in database');
// Write log entry only if persons were given
if ($type == self::TYPE_PERSONS)
{
$personLog = $this->_personLog($sender_id, $msgVarsDataArray['person_id'], getData($message)[0]);
if (isError($personLog)) return $personLog;
}
$receiversCounter++; // increment the counter
}
return success('Messages sent successfully');
}
/**
* Sends a new message using the given template and information present in parameter prestudents
* Extra variables can be added using parameter $msgVars
*/
public function sendExplicitTemplate($prestudents, $oe_kurzbz, $vorlage_kurzbz, $msgVars)
{
// Retrieves the sender id
$sender_id = getAuthPersonId();
if (!is_numeric($sender_id)) show_error('The current logged user person_id is not defined');
// Retrieves message vars data for the given user/s
$msgVarsData = $this->MessageModel->getMsgVarsDataByPrestudentId($prestudents);
if (isError($msgVarsData)) show_error(getError($msgVarsData));
if (!hasData($msgVarsData)) show_error('No recipients were given');
$prestudentsData = $this->PrestudentModel->getOrganisationunits($prestudents);
// Adds the organisation unit to each prestudent
if (isEmptyString($oe_kurzbz) && hasData($msgVarsData) && hasData($prestudentsData))
{
$this->CLMessagesModel->_addOeToPrestudents($msgVarsData, $prestudentsData);
}
foreach (getData($msgVarsData) as $receiver)
{
$msgVarsDataArray = $this->_lowerReplaceSpaceArrayKeys((array)$receiver); // replaces array keys
// Additional message variables
if (is_array($msgVars)) $msgVarsDataArray = array_merge($msgVarsDataArray, $msgVars);
$message = $this->messagelib->sendMessageUserTemplate(
$msgVarsDataArray['person_id'], // receiversPersonId
$vorlage_kurzbz, // vorlage
$msgVarsDataArray, // parseData
null, // orgform
$sender_id, // sender_id
$oe_kurzbz // senderOU
);
if (isError($message)) return $message;
// Write log entry
$personLog = $this->_personLog($sender_id, $msgVarsDataArray['person_id'], getData($message)[0]);
if (isError($personLog)) return $personLog;
}
return success('Messages sent successfully');
}
/**
* Send a reply to a single recipient for a message identified by a token (no templates are used)
* NOTE: this method could be also called from not authenticated controllers
*/
public function sendReply($receiver_id, $subject, $body, $relationmessage_id, $token)
{
// Retrieves message sender information
$senderResult = $this->MessageTokenModel->getSenderData($receiver_id);
if (isError($senderResult)) show_error(getError($senderResult));
if (!hasData($senderResult)) show_error('No sender information found');
$sender = getData($senderResult)[0]; // Found sender data
$messageResult = $this->MessageTokenModel->getMessageByToken($token);
if (isError($messageResult)) show_error(getError($messageResult));
// Security check! It is possible to reply only to a received message!!
if (!hasData($messageResult) || $relationmessage_id != getData($messageResult)[0]->message_id)
{
show_error('An error occurred while sending your message, please contact the site administrator');
}
// If the user is logged then use its person id as sender id, otherwise get the receiver id of the previous message
$sender_id = isLogged() ? getAuthPersonId() : getData($messageResult)[0]->receiver_id;
if (!is_numeric($sender_id)) return error('The sender id is not valid');
$message = $this->messagelib->sendMessageUser(
$receiver_id, // receiverPersonId
$subject, // subject
$body, // body
$sender_id, // sender_id, the receiver of the previous message is the sender of the current one
null, // senderOU
$relationmessage_id, // relationmessage_id
MSG_PRIORITY_NORMAL // priority
);
if (isError($message)) return $message;
if (!hasData($message)) return error('No messages were saved in database');
// Write log entry
$personLog = $this->_personLog($sender_id, $receiver_id, getData($message)[0]);
if (isError($personLog)) return $personLog;
return success('Messages sent successfully');
}
/**
* Send a message to an organisation unit
*/
public function sendToOrganisationUnit($receiverOU, $subject, $body)
{
if (isEmptyString($receiverOU)) return error('Not a valid organisation unit');
if (isEmptyString($subject)) return error('Subject is an empty string');
if (isEmptyString($body)) return error('Body is an empty string');
$sender_id = getAuthPersonId();
if (!is_numeric($sender_id)) return error('The current logged user person_id is not defined');
$message = $this->messagelib->sendMessageOU(
$receiverOU, // receiverPersonId
$subject, // subject
$body, // body
$sender_id // sender_id
);
if (isError($message)) return $message;
if (!hasData($message)) return error('No messages were saved in database');
// Write log entry
$personLog = $this->_personLog($sender_id, $this->config->item(MessageLib::CFG_SYSTEM_PERSON_ID), getData($message)[0], $receiverOU);
if (isError($personLog)) return $personLog;
return success('Messages sent successfully');
}
//------------------------------------------------------------------------------------------------------------------
// Public methods called by controller system/messages/Messages
/**
* Returns an object that represent a template store in database
* If no templates are found with the given parameter or the given parameter is an empty string,
* then an error is returned
*/
public function getVorlage($vorlage_kurzbz)
{
$getVorlage = error('The given vorlage_kurzbz is not valid');
if (!isEmptyString($vorlage_kurzbz))
{
$this->load->model('system/Vorlagestudiengang_model', 'VorlagestudiengangModel');
$this->VorlagestudiengangModel->addOrder('version','DESC');
$getVorlage = $this->VorlagestudiengangModel->loadWhere(array('vorlage_kurzbz' => $vorlage_kurzbz));
}
return $getVorlage;
}
/**
* Parse the given given text using data from the given user
* Use the CI parser which performs simple text substitution for pseudo-variable
*/
public function parseMessageTextPerson($person_id, $text)
{
$parseMessageText = error('The given person_id is not a valid number');
if (is_numeric($person_id)) $parseMessageText = $this->MessageModel->getMsgVarsDataByPersonId($person_id);
if (hasData($parseMessageText))
{
$parseMessageText = success(
parseText(
$text,
$this->_lowerReplaceSpaceArrayKeys((array)getData($parseMessageText)[0])
)
);
}
return $parseMessageText;
}
/**
* Parse the given given text using data from the given user
* Use the CI parser which performs simple text substitution for pseudo-variable
*/
public function parseMessageTextPrestudent($prestudent_id, $text)
{
$parseMessageText = error('The given prestudent_id is not a valid number');
if (is_numeric($prestudent_id)) $parseMessageText = $this->MessageModel->getMsgVarsDataByPrestudentId($prestudent_id);
if (hasData($parseMessageText))
{
$parseMessageText = success(
parseText(
$text,
$this->_lowerReplaceSpaceArrayKeys((array)getData($parseMessageText)[0])
)
);
}
return $parseMessageText;
}
/**
* Outputs message data for a message (identified my msg id and receiver id) in JSON format
*/
public function getMessageFromIds($message_id, $receiver_id)
{
$getMessageFromIds = error('The given message id or receiver id are not valid');
if (is_numeric($message_id) && is_numeric($receiver_id))
{
$getMessageFromIds = $this->messagelib->getMessage($message_id, $receiver_id);
}
if (isError($getMessageFromIds) || !hasData($getMessageFromIds))
{
return array();
}
else
{
return array(getData($getMessageFromIds)[0]);
}
}
//------------------------------------------------------------------------------------------------------------------
// Private methods
/**
* Replaces data array keys to a lowercase string with underscores instead of spaces
*/
private function _lowerReplaceSpaceArrayKeys($data)
{
$tmpData = array();
// Replaces data array keys to a lowercase without spaces string
foreach ($data as $key => $val)
{
$tmpData[str_replace(' ', '_', strtolower($key))] = $val;
@@ -176,9 +654,9 @@ class Messages_model extends CI_Model
}
/**
*
* Add organisation unit to an array of prestudents (objects)
*/
public function addOeToPrestudents(&$msgVarsData, $prestudentsData)
private function _addOeToPrestudents(&$msgVarsData, $prestudentsData)
{
for ($i = 0; $i < count(getData($msgVarsData)); $i++)
{
@@ -192,4 +670,171 @@ class Messages_model extends CI_Model
}
}
}
/**
* Perform a person log after a message is sent
*/
private function _personLog($sender_id, $receiver_id, $message_id, $receiverOU = null)
{
// In case the message is accessed via ViewMessage controller -> no authentication
// If no authentication is performed then use a hard coded uid
$loggedUserUID = isLogged() ? getAuthUID() : self::NO_AUTH_UID;
$message = 'Message sent from person '.$sender_id.' to '.$receiver_id.', message id: '.$message_id;
if (!isEmptyString($receiverOU)) $message .= ', receiverOU: '.$receiverOU;
return $this->personloglib->log(
$receiver_id,
'Action',
array(
'name' => 'Message sent',
'message' => $message,
'success' => 'true'
),
'kommunikation',
'core',
null,
$loggedUserUID
);
}
/**
* Quotes the previous message body
*/
private function _getReplyBody($body, $receiverName, $receiverSurname, $sentDate)
{
return sprintf(
self::REPLY_BODY_FORMAT,
date_format(date_create($sentDate), 'd.m.Y H:i'), $receiverName, $receiverSurname, $body
);
}
/**
* Prepares data for the view system/messages/htmlWriteTemplate using the given parameters
*/
private function _prepareHtmlWriteTemplate($info, $message_id, $recipient_id)
{
// Checks that info parameter is valid
if (isError($info)) show_error(getError($info));
if (!hasData($info)) show_error('No recipients were given');
// If the message id and recipient id are given, then both they must be valid numbers
if ((is_numeric($message_id) && !is_numeric($recipient_id))
|| (!is_numeric($message_id) && is_numeric($recipient_id)))
{
show_error('If given, message id and recipient id both must be valid numbers');
}
// ---------------------------------------------------------------------------------------
// Retrieves the recipients information and builds:
// - recipientsArray: an array that contains objects with id (person_id) and description (Vorname + Nachname) of recipient
// - recipientsList: a string that contains all the recipients descriptions (Vorname + Nachname) separated by ;
// - persons: a string that contains HTML input hidden with alla the receivers id (person_id)
$recipientsArray = array();
$recipientsList = '';
$recipients_ids = '';
foreach (getData($info) as $receiver)
{
$id = 0;
$recipient = new stdClass();
$recipient->description = $receiver->Vorname.' '.$receiver->Nachname;
$recipientsList .= $receiver->Vorname.' '.$receiver->Nachname.'; ';
// If it is a prestudent then
if (isset($receiver->prestudent_id) && is_numeric($receiver->prestudent_id))
{
$recipient->id = $receiver->prestudent_id;
$id = $receiver->prestudent_id;
}
else // otherwise it is a person
{
$recipient->id = $receiver->person_id;
$id = $receiver->person_id;
}
$recipients_ids .= '<input type="hidden" name="recipients_ids[]" value="'.$id.'">'."\n";
$recipientsArray[] = $recipient;
}
// ---------------------------------------------------------------------------------------
// Retrieves the message to reply to, if it is specified by parameters $message_id and $recipient_id
$replySubject = ''; // message reply subject
$replyBody = ''; // message reply body
$relationmessage = ''; // input hidden that contains the message id to be replied to
// If both are given and they are valid
if (is_numeric($message_id) && is_numeric($recipient_id))
{
// Retrieves a received message from tbl_msg_recipient
$messageResult = $this->messagelib->getMessage($message_id, $recipient_id);
if (isError($messageResult)) show_error(getError($messageResult));
if (!hasData($messageResult)) show_error('The selected message does not exist');
$message = getData($messageResult)[0];
$replySubject = self::REPLY_SUBJECT_PREFIX.$message->subject;
$replyBody = $this->_getReplyBody($message->body, $receiver->Vorname, $receiver->Nachname, $message->sent);
$relationmessage = '<input type="hidden" name="relationmessage_id" value="'.$message_id.'">';
}
// ---------------------------------------------------------------------------------------
// Retrieves message vars from database view vw_msg_vars/vw_msg_vars_person
$variablesResult = null;
$type = '';
// If data contains a prestudent id
// NOTE:
// - info is checked at the beginning of this method so it is safe to use getData($info)[0]
// - the provided data inside info are all persons or all prestudents, so it is safe to check only the first one
if (isset(getData($info)[0]->prestudent_id) && is_numeric(getData($info)[0]->prestudent_id))
{
$variablesResult = $this->messagelib->getMessageVarsPrestudent();
$type = '<input type="hidden" id="type" name="type" value="'.self::TYPE_PRESTUDENTS.'">';
}
else
{
$variablesResult = $this->messagelib->getMessageVarsPerson();
$type = '<input type="hidden" id="type" name="type" value="'.self::TYPE_PERSONS.'">';
}
if (isError($variablesResult)) show_error(getError($variablesResult));
// Then builds an array that contains objects with id (person_id) and description (Vorname + Nachname) of recipient
$variables = array();
foreach (getData($variablesResult) as $id => $description)
{
$tmpVar = new stdClass();
$tmpVar->id = $id;
$tmpVar->description = $description;
$variables[] = $tmpVar;
}
// ---------------------------------------------------------------------------------------
// Retrieves the sender id
$sender_id = getAuthPersonId();
if (!is_numeric($sender_id)) show_error('The current logged user person_id is not defined');
// ---------------------------------------------------------------------------------------
// Organisation units and a boolean (true if the sender is administrator) are used to get the templates
$organisationUnits = $this->messagelib->getOeKurzbz($sender_id);
if (isError($organisationUnits)) show_error(getError($organisationUnits));
$senderIsAdmin = $this->BenutzerrolleModel->isAdminByPersonId($sender_id);
if (isError($senderIsAdmin)) show_error(getError($senderIsAdmin));
// ---------------------------------------------------------------------------------------
// Returns data as an array
return array (
'recipientsList' => $recipientsList,
'subject' => $replySubject,
'body' => $replyBody,
'variables' => $variables,
'organisationUnits' => getData($organisationUnits),
'senderIsAdmin' => getData($senderIsAdmin),
'recipientsArray' => $recipientsArray,
'recipients_ids' => $recipients_ids,
'relationmessage_id' => $relationmessage,
'type' => $type
);
}
}
application/models/crm/Prestudent_model.php
+31
View File
@@ -521,4 +521,35 @@ class Prestudent_model extends DB_Model
}
}
}
/**
* Get organisation units for all the prestudents of a person
*/
public function getOrganisationunitsByPersonId($person_id)
{
$query = 'SELECT o.oe_kurzbz,
o.bezeichnung,
(CASE
WHEN sg.typ = \'b\' THEN ps.prestudent_id
WHEN sg.typ = \'m\' THEN p.prestudent_id
ELSE NULL
END) AS prestudent_id
FROM public.tbl_prestudent p
JOIN public.tbl_studiengang sg USING(studiengang_kz)
JOIN public.tbl_organisationseinheit o USING(oe_kurzbz)
LEFT JOIN (
SELECT prestudent_id
FROM public.tbl_prestudentstatus
WHERE status_kurzbz = \'Bewerber\'
) ps USING(prestudent_id)
WHERE p.person_id = ?
GROUP BY o.oe_kurzbz,
o.bezeichnung,
sg.typ,
ps.prestudent_id,
p.prestudent_id
ORDER BY o.bezeichnung';
return $this->execQuery($query, array($person_id));
}
}
application/models/person/Benutzer_model.php
+15
View File
@@ -18,4 +18,19 @@ class Benutzer_model extends DB_Model
return $this->loadWhere(array('person_id' => $person_id, 'aktiv' => true));
}
/**
*
*/
public function getActiveUserByPersonIdAndOrganisationUnit($person_id, $oe_kurzbz)
{
$sql = 'SELECT b.uid
FROM public.tbl_benutzer b
JOIN public.tbl_prestudent ps USING (person_id)
JOIN public.tbl_studiengang sg USING (studiengang_kz)
WHERE ps.person_id = ?
AND sg.oe_kurzbz = ?
AND b.aktiv = TRUE';
return $this->execQuery($sql, array($person_id, $oe_kurzbz));
}
}
application/models/person/Kontakt_model.php
+28 -13
View File
@@ -8,17 +8,17 @@ class Kontakt_model extends DB_Model
public function __construct()
{
parent::__construct();
$this->dbTable = "public.tbl_kontakt";
$this->pk = "kontakt_id";
$this->dbTable = 'public.tbl_kontakt';
$this->pk = 'kontakt_id';
}
public function getWholeKontakt($kontakt_id, $person_id = null, $kontakttyp = null)
{
$result = null;
$this->addJoin("public.tbl_standort", "standort_id", "LEFT");
$this->addJoin("public.tbl_firma", "firma_id", "LEFT");
$this->addJoin('public.tbl_standort', 'standort_id', 'LEFT');
$this->addJoin('public.tbl_firma', 'firma_id', 'LEFT');
if (isset($kontakt_id))
{
$result = $this->load($kontakt_id);
@@ -26,22 +26,37 @@ class Kontakt_model extends DB_Model
else
{
$parametersArray = array();
if (!is_null($person_id))
{
$parametersArray["person_id"] = $person_id;
$parametersArray['person_id'] = $person_id;
}
if (!is_null($kontakttyp))
{
$parametersArray["kontakttyp"] = $kontakttyp;
$parametersArray['kontakttyp'] = $kontakttyp;
}
if (count($parametersArray) > 0)
{
$result = $this->loadWhere($parametersArray);
}
}
return $result;
}
}
/**
*
*/
public function getContactByPersonId($person_id, $kontakttyp)
{
$sql = 'SELECT kontakt
FROM public.tbl_kontakt
WHERE zustellung = TRUE
AND person_id = ?
AND kontakttyp = ?
ORDER BY updateamum, insertamum';
return $this->execQuery($sql, array($person_id, $kontakttyp));
}
}
application/models/system/MessageToken_model.php
-18
View File
@@ -136,24 +136,6 @@ class MessageToken_model extends DB_Model
return $this->execQuery($sql, array($person_id));
}
/**
* Get data of a person
*/
public function getPersonData($person_id)
{
$sql = 'SELECT person_id,
vorname as "Vorname",
nachname as "Nachname",
anrede as "Anrede",
titelpost as "TitelPost",
titelpre as "TitelPre",
vornamen as "Vornamen"
FROM public.tbl_person
WHERE person_id %s ?';
return $this->execQuery(sprintf($sql, is_array($person_id) ? 'IN' : '='), array($person_id));
}
/**
* Searchs for a person by its person_id and checks if it is an employee
*/
application/models/system/Recipient_model.php
+148 -20
View File
@@ -25,7 +25,8 @@ class Recipient_model extends DB_Model
ks.kontakt,
p.nachname,
p.vorname,
b.uid
b.uid,
mr.sent
FROM public.tbl_msg_recipient mr INNER JOIN public.tbl_msg_message mm USING (message_id)
INNER JOIN public.tbl_person p ON (mm.person_id = p.person_id)
LEFT JOIN public.tbl_benutzer b ON (mr.person_id = b.person_id)
@@ -56,11 +57,13 @@ class Recipient_model extends DB_Model
m.oe_kurzbz,
s.status,
s.statusinfo,
s.insertamum as statusamum
s.insertamum as statusamum,
b.uid
FROM public.tbl_msg_recipient r JOIN public.tbl_msg_message m USING (message_id)
JOIN (
SELECT * FROM public.tbl_msg_status WHERE status < ? ORDER BY insertamum DESC, status DESC
) s ON (r.message_id = s.message_id AND r.person_id = s.person_id)
) s ON (r.message_id = s.message_id AND r.person_id = s.person_id),
LEFT JOIN public.tbl_benutzer b USING(person_id)
WHERE r.token = ?
LIMIT 1';
@@ -205,7 +208,7 @@ class Recipient_model extends DB_Model
* @param limit specifies the number of messages to get
* @param message_id specifies a single message
*/
public function getMessages($kontaktType, $sent, $limit = null, $message_id = null)
public function getMessages($kontaktType, $message_id = null, $limit = 1)
{
$query = 'SELECT mm.message_id,
ks.kontakt as sender,
@@ -216,13 +219,14 @@ class Recipient_model extends DB_Model
mr.token,
mm.subject,
mm.body,
mr.sentinfo
mr.sentinfo,
mr.oe_kurzbz
FROM public.tbl_msg_recipient mr INNER JOIN public.tbl_msg_message mm USING (message_id)
LEFT JOIN (
SELECT person_id, kontakt FROM public.tbl_kontakt WHERE kontakttyp = ?
SELECT person_id, kontakt FROM public.tbl_kontakt WHERE zustellung = true AND kontakttyp = ?
) ks ON (ks.person_id = mm.person_id)
LEFT JOIN (
SELECT person_id, kontakt FROM public.tbl_kontakt WHERE kontakttyp = ?
SELECT person_id, kontakt FROM public.tbl_kontakt WHERE zustellung = true AND kontakttyp = ?
) kr ON (kr.person_id = mr.person_id)
LEFT JOIN (
SELECT b.person_id,
@@ -235,21 +239,12 @@ class Recipient_model extends DB_Model
m.mitarbeiter_uid
FROM public.tbl_benutzer b INNER JOIN public.tbl_mitarbeiter m ON(b.uid = m.mitarbeiter_uid)
WHERE b.aktiv = TRUE
) ms ON (ms.person_id = mm.person_id)';
) ms ON (ms.person_id = mm.person_id)
WHERE mr.sent IS NULL';
$parametersArray = array($kontaktType, $kontaktType);
if (is_null($sent) || $sent == '')
{
$query .= ' WHERE mr.sent IS NULL';
}
else
{
array_push($parametersArray, $sent);
$query .= ' WHERE mr.sent = ?';
}
if (!is_null($message_id))
if (is_numeric($message_id))
{
array_push($parametersArray, $message_id);
$query .= ' AND mm.message_id = ?';
@@ -257,7 +252,7 @@ class Recipient_model extends DB_Model
$query .= ' ORDER BY mr.insertamum ASC';
if (!is_null($limit))
if (is_numeric($limit))
{
$query .= ' LIMIT ?';
array_push($parametersArray, $limit);
@@ -307,4 +302,137 @@ class Recipient_model extends DB_Model
return $this->execQuery($sql, $parametersArray);
}
/**
* - Gets the directly recieved messages using the given person id
* - Gets the recieved messages from an organisation unit where this person plays a role given by the parameter functions
*/
public function getReceivedMessages($person_id, $functions)
{
$sql = '-- Messages sent directly to the person
SELECT mr.message_id,
mm.relationmessage_id,
mm.subject,
mm.body,
mm.insertamum AS sent,
p.vorname,
p.nachname,
MAX(ms.status) AS status,
ms.person_id AS statusPersonId,
mr.token
FROM public.tbl_msg_recipient mr
JOIN public.tbl_msg_message mm ON (mm.message_id = mr.message_id)
JOIN public.tbl_msg_status ms ON (ms.message_id = mr.message_id AND ms.person_id = mr.person_id)
JOIN public.tbl_person p ON (p.person_id = mm.person_id)
WHERE mr.person_id = ?
GROUP BY mr.message_id,
mm.relationmessage_id,
mm.subject,
mm.body,
mm.insertamum,
p.vorname,
p.nachname,
ms.person_id,
mr.token
UNION
-- Messages sent to a person that belongs to the recipient organisation unit
SELECT mrou.message_id,
mm.relationmessage_id,
mm.subject,
mm.body,
mm.insertamum AS sent,
pr.vorname,
pr.nachname,
MAX(ms.status) AS status,
ms.person_id AS statusPersonId,
mrou.token
FROM public.tbl_person p
JOIN public.tbl_benutzer b ON (b.person_id = p.person_id)
JOIN (
SELECT uid, oe_kurzbz
FROM public.tbl_benutzerfunktion
WHERE (datum_von IS NULL OR datum_von <= NOW())
AND (datum_bis IS NULL OR datum_bis >= NOW())
AND funktion_kurzbz IN ?
) bf ON (bf.uid = b.uid)
JOIN public.tbl_msg_recipient mrou ON (mrou.oe_kurzbz = bf.oe_kurzbz)
JOIN public.tbl_msg_message mm ON (mm.message_id = mrou.message_id)
JOIN public.tbl_msg_status ms ON (ms.message_id = mrou.message_id AND ms.person_id = mrou.person_id)
JOIN public.tbl_person pr ON (pr.person_id = mm.person_id)
WHERE p.person_id = ?
GROUP BY mrou.message_id,
mm.relationmessage_id,
mm.subject,
mm.body,
mm.insertamum,
pr.vorname,
pr.nachname,
ms.person_id,
mrou.token
ORDER BY sent DESC';
return $this->execQuery($sql, array($person_id, $functions, $person_id));
}
/**
* Gets all the sent message by the given person
*/
public function getSentMessages($person_id)
{
$sql = 'SELECT mm.message_id,
mm.relationmessage_id,
mm.subject,
mm.body,
mm.insertamum AS sent,
p.person_id,
p.vorname,
p.nachname,
MAX(ms.status) AS status,
ms.person_id AS statusPersonId,
oe.bezeichnung AS oe,
mr.token
FROM public.tbl_msg_message mm
JOIN public.tbl_msg_recipient mr ON (mr.message_id = mm.message_id)
JOIN public.tbl_msg_status ms ON (ms.message_id = mm.message_id AND ms.person_id = mr.person_id)
JOIN public.tbl_person p ON (p.person_id = mr.person_id)
LEFT JOIN public.tbl_organisationseinheit oe ON (oe.oe_kurzbz = mr.oe_kurzbz)
WHERE mm.person_id = ?
GROUP BY mm.message_id,
mm.relationmessage_id,
mm.subject,
mm.body,
mm.insertamum,
p.person_id,
p.vorname,
p.nachname,
ms.person_id,
oe.bezeichnung,
mr.token
ORDER BY sent DESC';
return $this->execQuery($sql, array($person_id));
}
/**
*
*/
public function getMessagesById($messageIds)
{
$sql = 'SELECT mm.message_id,
mm.person_id AS sender_id,
mm.subject,
mm.body,
mm.relationmessage_id,
mm.oe_kurzbz AS sender_ou,
mr.person_id AS receiver_id,
mr.token,
mr.sent,
mr.sentinfo,
mr.oe_kurzbz AS receiver_ou
FROM public.tbl_msg_message mm
JOIN public.tbl_msg_recipient mr ON (mr.message_id = mm.message_id)
WHERE mm.message_id IN ?';
return $this->execQuery($sql, array($messageIds));
}
}