489 lines
14 KiB
PHP
489 lines
14 KiB
PHP
<?php
|
|
|
|
/** Types of starting */
|
|
abstract class StartingType
|
|
{
|
|
public const __default = null;
|
|
|
|
public const Fighter = 1;
|
|
public const Audience = 2;
|
|
public const NoParticipation = 3;
|
|
|
|
/** convert a variable into a StartingType
|
|
*
|
|
* @param [int] $type starting type candidate
|
|
* @return int representation of the StartingType if successful converted, otherwise null
|
|
*/
|
|
public static function toStartingType($type)
|
|
{
|
|
return filter_var($type, FILTER_VALIDATE_INT, ['options' => ['default' => null, 'min_range' => 1, 'max_range' => 3]]);
|
|
}
|
|
|
|
/** string representations of the starting type
|
|
*
|
|
* @var array array of StartingType => its string representation
|
|
*/
|
|
public static $AsString = [1 => 'Kämpfer', 2 => 'Zuschauer', 3 => 'keine Teilnahme'];
|
|
}
|
|
|
|
/** Frame for a start to a shiai */
|
|
class Starter
|
|
{
|
|
/** Constructor
|
|
*
|
|
* @todo Document
|
|
*/
|
|
public function __construct($id, $eventId, $typeId, $userId, $rideId = null, $mass = null, $result = null)
|
|
{
|
|
$this->id = filter_var($id, FILTER_VALIDATE_INT, ['options' => ['default' => null, 'min_range' => 1]]);
|
|
$this->eventId = filter_var($eventId, FILTER_VALIDATE_INT, ['options' => ['default' => null, 'min_range' => 1]]);
|
|
$this->typeId = StartingType::toStartingType($typeId);
|
|
$this->userId = filter_var($userId, FILTER_VALIDATE_INT, ['options' => ['default' => null, 'min_range' => 1]]);
|
|
$this->rideId = filter_var($rideId, FILTER_VALIDATE_INT, ['options' => ['default' => null, 'min_range' => 1]]);
|
|
$this->mass = filter_var($mass, FILTER_VALIDATE_FLOAT, ['options' => ['default' => null, 'min_range' => 0.0]]);
|
|
|
|
if (is_iterable($result)) {
|
|
$this->result = [];
|
|
foreach ($result as $r) {
|
|
$r = filter_var($r, FILTER_VAR_INT, ['options' => ['default' => null, 'min_range' => 0]]);
|
|
if ($r) {
|
|
array_push($this->result, $r);
|
|
}
|
|
}
|
|
} else {
|
|
$this->$result = filter_var($r, FILTER_VALIDATE_INT, ['options' => ['default' => null, 'min_range' => 0]]);
|
|
}
|
|
}
|
|
|
|
////
|
|
// dbInterface
|
|
////
|
|
|
|
/** Load a Start from the db via an id
|
|
*
|
|
* @param int $startId
|
|
* @return loaded start or null (if sth. wrong)
|
|
*/
|
|
public static function loadFromDb($startId)
|
|
{
|
|
$startId = filterId($startId);
|
|
if (!isset($startId)) {
|
|
return null;
|
|
}
|
|
return self::loadFromDbBy('id', $startId);
|
|
}
|
|
|
|
/** Retrieve the linked Event from the database
|
|
*
|
|
* @param bool $force By default, if there already is an event in the buffer it is reused. Set this parameter to true to enforce the loading.
|
|
* @return Event the event in the db identified via the eventId
|
|
*/
|
|
public function loadEvent(bool $force = false)
|
|
{
|
|
if ($force || (!isset($this->event))) {
|
|
if (isset($this->eventId)) {
|
|
$this->event = Event::loadFromDb($this->eventId);
|
|
}
|
|
}
|
|
return $this->event;
|
|
}
|
|
|
|
/** Retrieve the linked User from the database
|
|
*
|
|
* @param bool $force By default, if there already is an user in the buffer it is reused. Set this parameter to true to enforce the loading.
|
|
* @return User the user in the db identified via the userId
|
|
*/
|
|
public function loadStarter(bool $force = false)
|
|
{
|
|
if ($force || (!isset($this->user))) {
|
|
if (isset($this->userId)) {
|
|
$this->user = User::loadFromDb($this->userId);
|
|
}
|
|
}
|
|
return $this->user;
|
|
}
|
|
|
|
/** Add the shiai to the database
|
|
*
|
|
* - before adding to the db it is checked wether the currently logged in user has sufficient rights
|
|
* - all starts of the same user to the same event get deleted before adding the start (again)
|
|
*
|
|
* @todo an admin should also be allowed
|
|
* @todo the deadline of the event should be checked as well
|
|
*
|
|
* @return int id under which the
|
|
*/
|
|
public function addToDb()
|
|
{
|
|
// - if the id is already set it *has* to be already in the DB hence we don't add it
|
|
// - the logged in user must have wardship over the starter
|
|
if (isset($this->id) || !participo::isWardOf($this->userId)) {
|
|
return null;
|
|
}
|
|
|
|
// You can only start once to an event so delete *all* other starts of this user to this event
|
|
self::dbDelete($this->eventId, $this->userId);
|
|
$this->id = self::dbInsert($this->eventId, $this->typeId, $this->userId);
|
|
return $this->id;
|
|
}
|
|
|
|
/** Remove the start from the db
|
|
*
|
|
* - check if the currently logged in user is allowed to remove the start first
|
|
*
|
|
* @todo an admin should also be allowed
|
|
* @todo the deadline of the event should be checked as well
|
|
*
|
|
* @return void
|
|
*/
|
|
public function removeFromDb()
|
|
{
|
|
// - the logged in user must have wardship over the starter
|
|
if (!participo::isWardOf($this->userId)) {
|
|
return;
|
|
}
|
|
|
|
self::dbDelete($this->eventId, $this->userId);
|
|
return;
|
|
}
|
|
|
|
// Getter for the member
|
|
public function getId()
|
|
{
|
|
return $this->id;
|
|
}
|
|
|
|
public function getEventId()
|
|
{
|
|
return $this->eventId;
|
|
}
|
|
|
|
public function getTypeId()
|
|
{
|
|
return $this->typeId;
|
|
}
|
|
|
|
public function getUserId()
|
|
{
|
|
return $this->userId;
|
|
}
|
|
|
|
public function getRideId()
|
|
{
|
|
return $this->rideId;
|
|
}
|
|
|
|
public function getMass()
|
|
{
|
|
return $this->mass;
|
|
}
|
|
|
|
public function getResult()
|
|
{
|
|
return $this->result;
|
|
}
|
|
|
|
public function getUser()
|
|
{
|
|
return User::loadFromDb($this->userId);
|
|
}
|
|
|
|
public function getEvent()
|
|
{
|
|
return $this->event;
|
|
}
|
|
|
|
public function getHtmlFormRemove($class = null)
|
|
{
|
|
$today = new DateTime();
|
|
$event = $this->loadEvent();
|
|
$eventDeadline = $event->getDeadline();
|
|
|
|
if ($today > $eventDeadline) {
|
|
return self::getHtmlModalToLate($this->id);
|
|
}
|
|
return self::getHtmlFormRemoveStarterFromEvent($this->getId(), $class);
|
|
}
|
|
|
|
// inject html code of table with coming starts for the session user
|
|
public static function htmlTableComingStarts()
|
|
{
|
|
$userId = participo::getSessionUserId();
|
|
echo(self::getHtmlTableComingStarts($userId));
|
|
}
|
|
|
|
// member variables
|
|
// - static member
|
|
/** Name of the table with all the starts
|
|
*
|
|
* @var string
|
|
*/
|
|
private static $tableName = 'wkParticipo_Starter';
|
|
/** Names of the columns in the table (in the database) with their type
|
|
*
|
|
* @var array
|
|
*/
|
|
private static $dbColumns = [
|
|
'id' => PDO::PARAM_INT,
|
|
'eventId' => PDO::PARAM_INT,
|
|
'type' => PDO::PARAM_INT,
|
|
'userId' => PDO::PARAM_INT,
|
|
'fahrtId' => PDO::PARAM_INT,
|
|
'masse' => PDO::PARAM_STR,
|
|
'platz' => PDO::PARAM_STR,
|
|
];
|
|
// - non-static member
|
|
// data that's stored in the start table
|
|
/** unique database id for the start
|
|
*
|
|
* @var int/null
|
|
*/
|
|
private $id = null;
|
|
/** unique database id of the event one is starting
|
|
*
|
|
* @var int/null
|
|
*/
|
|
private $eventId = null;
|
|
/** type(id) of the starter
|
|
*
|
|
* @var int/null
|
|
*/
|
|
private $typeId = null;
|
|
/** unique database id of the starting user
|
|
*
|
|
* @var int/null
|
|
*/
|
|
private $userId = null;
|
|
/** unique database id of the ride where the starter can car pool
|
|
*
|
|
* @var int/null
|
|
*/
|
|
private $rideId = null;
|
|
/** the mass(-class) the starter had at the event, comma separated list if multiple
|
|
*
|
|
* @var string
|
|
*/
|
|
private $mass = null;
|
|
/** place result of the starter at the event, comma separated list if multiple
|
|
*
|
|
* @var string
|
|
*/
|
|
private $result = null;
|
|
|
|
/** Create a Starter from an assoziative array like it is returned from db requests
|
|
*
|
|
* @param array $member associative array with the UserData from the dbRequest
|
|
* @param $columnMappings renaming of columnNames, e.g., if the id isn't under id in the array, add 'id'=>'starterId' to the mappings
|
|
* @return User initialized user
|
|
*/
|
|
private static function fromDbArray($member, $columnMappings = [])
|
|
{
|
|
// if it isn't remapped, take default column name
|
|
foreach (self::$dbColumns as $columnName => $columnDataType) {
|
|
if (!array_key_exists($columnName, $columnMappings)) {
|
|
$columnMappings[$columnName] = $columnName;
|
|
}
|
|
}
|
|
|
|
return new Starter(
|
|
$member[$columnMappings['id']] ?? null,
|
|
$member[$columnMappings['eventId']] ?? null,
|
|
$member[$columnMappings['type']] ?? null,
|
|
$member[$columnMappings['userId']] ?? null,
|
|
$member[$columnMappings['fahrtId']] ?? null,
|
|
$member[$columnMappings['masse']] ?? null,
|
|
$member[$columnMappings['platz']] ?? null
|
|
);
|
|
}
|
|
|
|
/** Load a starter from the db by a column
|
|
*
|
|
* @param [string] $name name of the column
|
|
* @param [mixed] $value value to look for
|
|
* @param [bool] $unique if the value is unique (true->return single value) or not (false->return array)
|
|
* @return loaded user or null (if sth. wrong)
|
|
*/
|
|
private static function loadFromDbBy($name, $value)
|
|
{
|
|
if (!array_key_exists($name, self::$dbColumns)) {
|
|
return null;
|
|
}
|
|
|
|
$response = dbConnector::query(
|
|
'SELECT * FROM `wkParticipo_Starter` WHERE `' . $name . '` = :' . $name,
|
|
[$name => ['value' => $value, 'data_type' => self::$dbColumns[$name]]]
|
|
);
|
|
|
|
if (count($response) != 1) {
|
|
return null;
|
|
}
|
|
|
|
return self::fromDbArray($response[0]);
|
|
}
|
|
|
|
/** Add a Start to the db
|
|
*
|
|
* - backend function no input validation/sanitation is done
|
|
*
|
|
* @param [int] $eventId eventId for the start
|
|
* @param [int] $typeId type(Id) for the start
|
|
* @param [int] $userId id of the starting user
|
|
* @return [int] lastInserted id of the Start
|
|
*/
|
|
private static function dbInsert($eventId, $typeId, $userId)
|
|
{
|
|
$query = 'INSERT INTO `cwsvjudo`.`wkParticipo_Starter` (eventId, type, userId) values (:eventId, :typeId, :userId);';
|
|
$params = [
|
|
':eventId' => ['value' => $eventId, 'data_type' => PDO::PARAM_INT],
|
|
':typeId' => ['value' => $typeId, 'data_type' => PDO::PARAM_INT],
|
|
':userId' => ['value' => $userId, 'data_type' => PDO::PARAM_INT]
|
|
];
|
|
// @todo remove ignoreErrors again
|
|
// @todo Inserting-Starter-Statement returns false on execution: Why? It seems to succeed!
|
|
$response = dbConnector::query($query, $params, ['ignoreErrors'=>true]);
|
|
return dbConnector::getLastInsertId();
|
|
}
|
|
|
|
private static function dbDelete($eventId, $userId)
|
|
{
|
|
$query = 'DELETE FROM `cwsvjudo`.`wkParticipo_Starter` WHERE eventId = :eventId AND userId = :userId;';
|
|
$params = [
|
|
':eventId' => ['value' => $eventId, 'data_type' => PDO::PARAM_INT],
|
|
':userId' => ['value' => $userId, 'data_type' => PDO::PARAM_INT]
|
|
];
|
|
|
|
$response = dbConnector::query($query, $params);
|
|
return;
|
|
}
|
|
|
|
// request coming starts of a user from the db
|
|
private static function getComingStarts($userId = null, $sinceDate = null)
|
|
{
|
|
// if no user is given, take it from the session data
|
|
$userId = $userId ?? participo::getSessionUserId();
|
|
|
|
// If no data is given, we take today
|
|
if (!$sinceDate) {
|
|
$sinceDate = 'CURDATE()';
|
|
} else {
|
|
$sinceDate = 'DATE("' . $sinceDate . '")';
|
|
}
|
|
|
|
// Query all interesting starts
|
|
$query =
|
|
'SELECT '
|
|
. '`wkParticipo_Starter`.`id` as startId, '
|
|
. '`wkParticipo_Starter`.`userId` as starterId, '
|
|
. '`wkParticipo_Starter`.`eventId` as eventId, '
|
|
. '`wkParticipo_Events`.`wkId` as shiaiId '
|
|
. 'FROM `wkParticipo_Starter` '
|
|
// link to the event (to get the date)
|
|
. 'LEFT JOIN `wkParticipo_Events` ON `wkParticipo_Starter`.`eventId` = `wkParticipo_Events`.`id` '
|
|
// link to all wardships for the starter
|
|
. 'LEFT JOIN `vormundschaft` ON `wkParticipo_Starter`.`userId` = `vormundschaft`.`kidId` '
|
|
// link to the shiai of the event
|
|
. 'LEFT JOIN `wettkampfkalender` on `wettkampfkalender`.`lfdeNr` = `wkParticipo_Events`.`wkId` '
|
|
. 'WHERE '
|
|
// only events after
|
|
. '`wkParticipo_Events`.`date` >= ' . $sinceDate . ' AND '
|
|
// only if the current user is warden of the starte
|
|
. '`vormundschaft`.`userId` = :userId '
|
|
. 'ORDER BY `wkParticipo_Events`.`date` ASC;';
|
|
$params = [':userId' => ['value' => $userId, 'data_type' => PDO::PARAM_INT]];
|
|
|
|
$response = dbConnector::query($query, $params);
|
|
|
|
$comingStarts = [];
|
|
foreach ($response as $r) {
|
|
$start = Starter::loadFromDb($r['startId']);
|
|
$comingStarts[] = $start;
|
|
}
|
|
|
|
return $comingStarts;
|
|
}
|
|
|
|
// get html code of a list of starts
|
|
private static function getHtmlTable($starts)
|
|
{
|
|
$html = '<table class="responsive-table">'
|
|
. '<thead><tr><th>Datum</th><th>Veranstaltung</th><th>Starter</th><th></th><th></th></tr></thead>'
|
|
. '<tbody>';
|
|
foreach ($starts as $start) {
|
|
$today = new DateTime();
|
|
|
|
$startingUser = User::loadFromDb($start->getUserId());
|
|
$event = Event::loadFromDb($start->getEventId());
|
|
$shiai = Shiai::loadFromDb($event->getShiaiId());
|
|
|
|
$eventDeadline = $event->getDeadline();
|
|
$eventDate = $event->getDate();
|
|
|
|
$html .= '<tr>'
|
|
. '<td>' . getHtmlSquareDate($eventDate) . '</td>'
|
|
. '<td>' . $shiai->getHtmlName() . '</td>'
|
|
. '<td>' . $startingUser->getName() . ', ' . $startingUser->getFirstName() . '</td>'
|
|
. '<td>' . StartingType::$AsString[$start->getTypeId()] . '</td>'
|
|
. '<td>' . $start->getHtmlFormRemove() . '</td>'
|
|
. '</tr>';
|
|
}
|
|
$html .= '</tbody></table>';
|
|
return $html;
|
|
}
|
|
|
|
private static function getHtmlModalToLate($startId, $caption = 'Austragen')
|
|
{
|
|
$modal = '<a class="btn grey waves-effect waves-light modal-trigger" href="#modal-remove-starter-' . $startId . '">' . $caption . '</a>'
|
|
. '<div id="modal-remove-starter-' . $startId . '" class="modal">'
|
|
. '<div class="modal-content">'
|
|
. '<p>Das Fenster zum Ein- und Austragen ist bereits geschlossen.</p>'
|
|
. '</div>'
|
|
. '<div class="modal-footer">'
|
|
. '<a href="#!" class="modal-close waves-effect waves-green btn-flat">OK</a>'
|
|
. '</div>'
|
|
. '</div>';
|
|
|
|
return $modal;
|
|
}
|
|
|
|
private static function getHtmlFormRemoveStarterFromEvent($starterId, $class = null)
|
|
{
|
|
$returnToUrl = urlencode(getCurPagesUrl());
|
|
$form =
|
|
'<form ' . (isset($class) ? ('class="' . $class . '"') : '') . ' action="api.starter.remove.php" method="post">'
|
|
. '<input type="hidden" name="returnToUrl" id="returnToUrl" value="' . $returnToUrl . '" >'
|
|
. '<input type="hidden" name="starterId" id="starterId" value="' . $starterId . '">'
|
|
. '<button class="btn red" type="submit" name="submit">austragen</button>'
|
|
. '</form>';
|
|
|
|
return $form;
|
|
}
|
|
|
|
/** Generate the htmlCode for the list of upcoming starts of wards of the current user
|
|
*
|
|
* @return void
|
|
*/
|
|
private static function getHtmlTableComingStarts($userId = null)
|
|
{
|
|
$userId = $userId ?? participo::getSessionUserId();
|
|
|
|
$starts = self::getComingStarts($userId);
|
|
if (!(count($starts) > 0)) {
|
|
return '<div>Keine Meldungen zu bevorstehenden Events<div>';
|
|
}
|
|
return self::getHtmlTable($starts);
|
|
}
|
|
|
|
// buffers to reduce db access
|
|
/** Event of the start
|
|
*
|
|
* @var Event/null
|
|
*/
|
|
private $event = null;
|
|
|
|
/** Starting user of the start
|
|
*
|
|
* @var User/null
|
|
*/
|
|
private $user = null;
|
|
}
|