Page MenuHomeGitPull.it

class-PDC.php
No OneTemporary

Authored By
Unknown
Size
11 KB
Referenced Files
None
Subscribers
None

class-PDC.php

<?php
# it.wiki deletion bot in PHP
# Copyright (C) 2013 Mauro742, MauroBot
# https://it.wikipedia.org/wiki/Utente:Mauro742
# https://it.wikipedia.org/wiki/Utente:MauroBot
# Originally under Creative Commons BY SA 3.0 International
# https://it.wikipedia.org/wiki/Utente:MauroBot/BotCancellazioni/core.js
# https://creativecommons.org/licenses/by-sa/3.0/
# https://wikimediafoundation.org/wiki/Special:MyLanguage/Terms_of_Use/it
# Copyright (C) 2018 Valerio Bozzolan
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
namespace itwikidelbot;
use DateTime;
/**
* Handle a "Procedura di cancellazione"
*
* It is a page like "Wikipedia:Pagine da cancellare/ASD"
*/
class PDC extends Page {
/**
* Prefix of every PDC
*/
const PREFIX = 'Wikipedia:Pagine da cancellare/';
/**
* Prefix of every multiple PDC
*/
const PREFIX_MULTIPLE = self::PREFIX . 'multiple/';
/**
* PDC category type
*
* @var CategoryYearMonthDay
*/
private $categoryType;
/**
* Page id
*
* @var int
*/
private $id;
/**
* Title of the PDC subject page (the Wikipedia article title)
*
* Obtained from {{DEFAULTSORT}} category sortkey
*
* @var string
*/
private $titleSubject;
/**
* Page length in bytes
*
* @var int
*/
private $length;
/**
* Creation date
*
* @var date
*/
private $creationDate;
/**
* Last update
*
* @var date
*/
private $lasteditDate;
/**
* Is Protected?
*
* @var bool
*/
private $isProtected;
/**
* Properties that the raw object must have
*
* @see self::createFromRaw()
* @var array
*/
private static $RAW_PROPERTIES = [
'pageid',
'title',
'length',
'touched',
'protection',
'categories',
];
/**
* Properties that a raw category must have
*
* @see self::createFromRaw()
* @var array
*/
private static $RAW_CATEGORY_PROPERTIES = [
'title',
'sortkeyprefix',
'timestamp', // TODO: remove as dependency if it's unuseful
];
/**
* Constructor
*
* @param $category_type CategoryYearMonthDay PDC category type
* @param $id int PDC page id
* @param $title string PDC title prefixed
* @param $title_subject string Title of the subject page (the Wikipedia article title)
* @param $length int PDC length
* @param $start DateTime When the PDC was added to the PDC type category
* @param $creation DateTime PDC creation date
* @param $lastedit DateTime PDC lastedit date
* @param $is_protected bool Is the PDC protected?
* @see Page::__construct()
* @throws PDCException
*/
public function __construct( CategoryYearMonthDay $category_type, $id, $title, $title_subject, $length, DateTime $creation, DateTime $lastedit, $is_protected ) {
$this->id = $id;
$this->titleSubject = $title_subject;
$this->length = $length;
$this->creationDate = $creation;
$this->lasteditDate = $lastedit;
$this->isProtected = $is_protected;
$this->setCategoryType( $category_type );
parent::__construct( $title );
// consistence checks
if( ! $this->isTitlePrefixValid() ) {
throw new PDCException( 'not a PDC' );
}
if( $this->getDurationDays() > 7 ) {
throw new PDCExceptionExpired( 'not anymore a PDC of type ' . $this->getType() );
}
$this->checkTitleSubjectConsistence();
}
/**
* Static constructor
*
* @see YearMonthDayTypes::fetchPDCs()
* @param $page mixed
* @return self
* @throws PDCException
*/
public static function createFromRaw( $page ) {
// verify the API response consistence
foreach( self::$RAW_PROPERTIES as $property ) {
if( ! isset( $page->$property ) ) {
throw new PDCException( "missing property $property" );
}
}
foreach( $page->categories as $category_raw ) {
foreach( self::$RAW_CATEGORY_PROPERTIES as $property ) {
if( ! isset( $category_raw->$property ) ) {
throw new PDCException( "missing property $property in categories" );
}
}
}
if( 0 === count( $page->categories ) ) {
throw new PDCException( "no category" );
}
// get the page title of the subject from the {{DEFAULTSORT:xxx}} value
$title_subject = null;
foreach( $page->categories as $category_raw ) {
$title_subject = $category_raw->sortkeyprefix;
break;
}
// array of instances of the class CategoryYearMonthDay (and subclasses)
$categories = [];
foreach( $page->categories as $category_raw ) {
$category = CategoryYearMonthDayTypes::createParsingTitle( $category_raw->title );
if( $category ) {
$categories[] = $category;
}
}
// creation date
$creation = null;
foreach( $categories as $category ) {
if( get_class( $category ) === CategoryYearMonthDay::class ) {
$creation = DateTime::createFromFormat( DateTime::ISO8601, $category_raw->timestamp );
break;
}
}
if( ! $creation ) {
throw new Exception( "not into the main category" );
}
if( ! $categories ) {
throw new PDCException( sprintf(
"the PDC was in %d categories and/but no one was recognized",
count( $page->categories )
) );
}
// find the best (the newest) category to be applied
$best_category = CategoryYearMonthDayTypes::findBestCategory( $categories );
// read protection status
$is_protected = false;
foreach( $page->protection as $protection ) {
if( 'edit' === $protection->type && 'sysop' === $protection->level ) {
$is_protected = true;
break;
}
}
return new self(
$best_category,
(int) $page->pageid,
$page->title,
$title_subject,
(int) $page->length,
$creation,
DateTime::createFromFormat( DateTime::ISO8601, $page->touched ),
$is_protected
);
}
/**
* Get the page id
*
* @return int
*/
public function getId() {
return $this->id;
}
/**
* Get the title of the subject page (the Wikipedia article title)
*
* Obtained from {{DEFAULTSORT}} category sortkey
*
* @return string
*/
public function getTitleSubject() {
return $this->titleSubject;
}
/**
* Get the page length
*
* @return int
*/
public function getLength() {
return $this->length;
}
/**
* Get the category type
*
* @return CategoryYearMonthDay
*/
public function getCategoryType() {
return $this->categoryType;
}
/**
* Set the category type
*
* @param $category_type CategoryYearMonthDay
* @return self
*/
public function setCategoryType( CategoryYearMonthDay $category_type ) {
$this->categoryType = $category_type;
return $this;
}
/**
* Get the start date of this PDC (of this type)
*
* @return DateTime
*/
public function getStartDate() {
return $this->getCategoryType()->getDateTime();
}
/**
* Get the creation date
*
* @return DateTime
*/
public function getCreationDate() {
return $this->creationDate;
}
/**
* Get the latest update date
*
* @return DateTime
*/
public function getLasteditDate() {
return $this->lasteditDate;
}
/**
* Get the PDC type class
*
* @return class
*/
public function getTypeClass() {
return get_class( $this->getCategoryType() );
}
/**
* Get the PDC type class genericity
*
* @see CategoryYearMonthDay::genericity()
* @return int
*/
public function getCategoryGenericity() {
$class_name = self::getTypeClass();
return $class_name::genericity();
}
/**
* Get the PDC type name
*
* @return string e.g. 'con votazioni'
*/
public function getType() {
$class = $this->getTypeClass();
return $class::PDC_TYPE;
}
/**
* Get the PDC human type
*
* @return string e.g. 'votazione'
*/
public function getHumanType() {
$class = $this->getTypeClass();
return $class::PDC_TYPE_HUMAN;
}
/**
* Check if this page is protected
*
* @return bool
*/
public function isProtected() {
return $this->isProtected;
}
/**
* Check if this PDC has a known prefix
*
* @return bool
*/
private function isTitlePrefixValid() {
return $this->titlehasPrefix( self::PREFIX );
}
/**
* Check if this PDC involves multiple PDCs
*
* @return bool
*/
public function isMultiple() {
return $this->titleHasPrefix( self::PREFIX_MULTIPLE );
}
/**
* Get the title prefix
*
* @return string
*/
private function getTitlePrefix() {
return $this->isMultiple()
? self::PREFIX_MULTIPLE
: self::PREFIX;
}
/**
* Get the title unprefixed
*
* @return string
*/
private function getTitleUnprefixed() {
return substr( $this->getTitle(), strlen( $this->getTitlePrefix() ) );
}
/**
* Check if the title has a certain prefix
*
* @param $prefix string
* @return bool
*/
private function titleHasPrefix( $prefix ) {
return 0 === strpos( $this->getTitle(), $prefix );
}
/**
* Verify if the title of the subject is consistent with the PDC title
*
* @return bool
*/
private function checkTitleSubjectConsistence() {
// subject from {{DEFAULTSORT}} category prefix
$subject = $this->getTitleSubject();
// subject generated unprefixing page title
$subject_gen = $this->getTitleUnprefixed();
if( $subject !== $subject_gen ) {
// Check if the PDC title ends with an enumeration e.g. 'asd/14'
$status = preg_match( '@(.*)/[0-9]+$@', $subject_gen, $matches );
if( 1 === $status ) {
// Get the interesting part e.g. 'asd'
$subject_gen = $matches[ 1 ];
}
}
if( $subject !== $subject_gen ) {
throw new PDCException( sprintf(
'the sortkey is "%s" and it is inconsistent with the PDC suffix "%s"',
$subject_gen,
$subject
) );
}
}
/**
* Get the PDC temperature
*
* The temperature is a value betweeen 0-100
*
* @return int
*/
public function getTemperature() {
$slope = null;
$offset = null;
switch( $this->getType() ) {
case CategoryYearMonthDay::PDC_TYPE;
$slope = 0.0365;
$offset = -24.0;
break;
case CategoryYearMonthDayTypeConsensual::PDC_TYPE:
$slope = 0.0075;
$offset = -12.81;
break;
case CategoryYearMonthDayTypeProlonged::PDC_TYPE:
$slope = 0.0035;
$offset = -9.76;
break;
case CategoryYearMonthDayTypeOrdinary::PDC_TYPE:
case CategoryYearMonthDayTypeVoting ::PDC_TYPE:
$slope = 0.0025;
$offset = -16.43;
break;
default:
throw new PDCException( 'unexpected type' );
}
$temp = round( $slope * $this->getLength() + $offset );
if ( $temp > 100 ) {
$temp = 100;
} elseif ( $temp < 0 ) {
$temp = 0;
}
return $temp;
}
/**
* Get the number of days of duration of this PDC
*
* @return int
*/
public function getDurationDays() {
return (int) $this->getLasteditDate()->diff( $this->getStartDate() )->format( '%a' );
}
/**
* Get an human rappresentation of the duration of this PDC
*
* @return string
*/
public function getHumanDuration() {
$days = $this->getDurationDays();
if( 0 === $days ) {
return Template::get( 'DURATION.hours' );
}
if( 1 === $days ) {
return Template::get( 'DURATION.day' );
}
return Template::get( 'DURATION.days', [ $days ] );
}
/**
* Merge a PDC with in this one
*
* @param $pdc PDC
*/
public function merge( PDC $pdc ) {
if( $this->getId() !== $pdc->getId() ) {
throw new InvalidArgumentException( 'PDCs can be merged only if they are of the same type' );
}
$this->setCategoryType( CategoryYearMonthDayTypes::findBestCategory( [
$this->getCategoryType(),
$pdc ->getCategoryType()
] ) );
}
}

File Metadata

Mime Type
text/x-php
Expires
Thu, Nov 19, 05:17 (15 h, 31 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2264898
Default Alt Text
class-PDC.php (11 KB)

Event Timeline