SOPHAL/MYSOPHAL
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

commit vendor

Browse Source
This commit is contained in:
BACHIR SOULDI
2025-11-11 14:49:30 +01:00
parent f33121a308
commit 6d03080c00
2436 changed files with 483781 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
vendor/sabre/dav/lib/DAV/Xml/Element/Prop.php vendored Normal file
View File

@ -0,0 +1,110 @@
<?php
declare(strict_types=1);
namespace Sabre\DAV\Xml\Element;
use Sabre\DAV\Xml\Property\Complex;
use Sabre\Xml\Reader;
use Sabre\Xml\XmlDeserializable;
/**
* This class is responsible for decoding the {DAV:}prop element as it appears
* in {DAV:}property-update.
*
* This class doesn't return an instance of itself. It just returns a
* key->value array.
*
* @copyright Copyright (C) fruux GmbH (https://fruux.com/)
* @author Evert Pot (http://evertpot.com/)
* @license http://sabre.io/license/ Modified BSD License
*/
class Prop implements XmlDeserializable
{
/**
* The deserialize method is called during xml parsing.
*
* This method is called statically, this is because in theory this method
* may be used as a type of constructor, or factory method.
*
* Often you want to return an instance of the current class, but you are
* free to return other data as well.
*
* You are responsible for advancing the reader to the next element. Not
* doing anything will result in a never-ending loop.
*
* If you just want to skip parsing for this element altogether, you can
* just call $reader->next();
*
* $reader->parseInnerTree() will parse the entire sub-tree, and advance to
* the next element.
*
* @return mixed
*/
public static function xmlDeserialize(Reader $reader)
{
// If there's no children, we don't do anything.
if ($reader->isEmptyElement) {
$reader->next();
return [];
}
$values = [];
$reader->read();
do {
if (Reader::ELEMENT === $reader->nodeType) {
$clark = $reader->getClark();
$values[$clark] = self::parseCurrentElement($reader)['value'];
} else {
$reader->read();
}
} while (Reader::END_ELEMENT !== $reader->nodeType);
$reader->read();
return $values;
}
/**
* This function behaves similar to Sabre\Xml\Reader::parseCurrentElement,
* but instead of creating deep xml array structures, it will turn any
* top-level element it doesn't recognize into either a string, or an
* XmlFragment class.
*
* This method returns arn array with 2 properties:
* * name - A clark-notation XML element name.
* * value - The parsed value.
*
* @return array
*/
private static function parseCurrentElement(Reader $reader)
{
$name = $reader->getClark();
if (array_key_exists($name, $reader->elementMap)) {
$deserializer = $reader->elementMap[$name];
if (is_subclass_of($deserializer, 'Sabre\\Xml\\XmlDeserializable')) {
$value = call_user_func([$deserializer, 'xmlDeserialize'], $reader);
} elseif (is_callable($deserializer)) {
$value = call_user_func($deserializer, $reader);
} else {
$type = gettype($deserializer);
if ('string' === $type) {
$type .= ' ('.$deserializer.')';
} elseif ('object' === $type) {
$type .= ' ('.get_class($deserializer).')';
}
throw new \LogicException('Could not use this type as a deserializer: '.$type);
}
} else {
$value = Complex::xmlDeserialize($reader);
}
return [
'name' => $name,
'value' => $value,
];
}
}

237
vendor/sabre/dav/lib/DAV/Xml/Element/Response.php vendored Normal file
View File

@ -0,0 +1,237 @@
<?php
declare(strict_types=1);
namespace Sabre\DAV\Xml\Element;
use Sabre\Xml\Element;
use Sabre\Xml\Reader;
use Sabre\Xml\Writer;
/**
* WebDAV {DAV:}response parser.
*
* This class parses the {DAV:}response element, as defined in:
*
* https://tools.ietf.org/html/rfc4918#section-14.24
*
* @copyright Copyright (C) fruux GmbH (https://fruux.com/)
* @author Evert Pot (http://www.rooftopsolutions.nl/)
* @license http://sabre.io/license/ Modified BSD License
*/
class Response implements Element
{
/**
* Url for the response.
*
* @var string
*/
protected $href;
/**
* Propertylist, ordered by HTTP status code.
*
* @var array
*/
protected $responseProperties;
/**
* The HTTP status for an entire response.
*
* This is currently only used in WebDAV-Sync
*
* @var string
*/
protected $httpStatus;
/**
* The href argument is a url relative to the root of the server. This
* class will calculate the full path.
*
* The responseProperties argument is a list of properties
* within an array with keys representing HTTP status codes
*
* Besides specific properties, the entire {DAV:}response element may also
* have a http status code.
* In most cases you don't need it.
*
* This is currently used by the Sync extension to indicate that a node is
* deleted.
*
* @param string $href
* @param string $httpStatus
*/
public function __construct($href, array $responseProperties, $httpStatus = null)
{
$this->href = $href;
$this->responseProperties = $responseProperties;
$this->httpStatus = $httpStatus;
}
/**
* Returns the url.
*
* @return string
*/
public function getHref()
{
return $this->href;
}
/**
* Returns the httpStatus value.
*
* @return string
*/
public function getHttpStatus()
{
return $this->httpStatus;
}
/**
* Returns the property list.
*
* @return array
*/
public function getResponseProperties()
{
return $this->responseProperties;
}
/**
* The serialize method is called during xml writing.
*
* It should use the $writer argument to encode this object into XML.
*
* Important note: it is not needed to create the parent element. The
* parent element is already created, and we only have to worry about
* attributes, child elements and text (if any).
*
* Important note 2: If you are writing any new elements, you are also
* responsible for closing them.
*/
public function xmlSerialize(Writer $writer)
{
if ($status = $this->getHTTPStatus()) {
$writer->writeElement('{DAV:}status', 'HTTP/1.1 '.$status.' '.\Sabre\HTTP\Response::$statusCodes[$status]);
}
$writer->writeElement('{DAV:}href', $writer->contextUri.\Sabre\HTTP\encodePath($this->getHref()));
$empty = true;
foreach ($this->getResponseProperties() as $status => $properties) {
// Skipping empty lists
if (!$properties || (!ctype_digit($status) && !is_int($status))) {
continue;
}
$empty = false;
$writer->startElement('{DAV:}propstat');
$writer->writeElement('{DAV:}prop', $properties);
$writer->writeElement('{DAV:}status', 'HTTP/1.1 '.$status.' '.\Sabre\HTTP\Response::$statusCodes[$status]);
$writer->endElement(); // {DAV:}propstat
}
if ($empty) {
/*
* The WebDAV spec _requires_ at least one DAV:propstat to appear for
* every DAV:response. In some circumstances however, there are no
* properties to encode.
*
* In those cases we MUST specify at least one DAV:propstat anyway, with
* no properties.
*/
$writer->writeElement('{DAV:}propstat', [
'{DAV:}prop' => [],
'{DAV:}status' => 'HTTP/1.1 418 '.\Sabre\HTTP\Response::$statusCodes[418],
]);
}
}
/**
* The deserialize method is called during xml parsing.
*
* This method is called statically, this is because in theory this method
* may be used as a type of constructor, or factory method.
*
* Often you want to return an instance of the current class, but you are
* free to return other data as well.
*
* You are responsible for advancing the reader to the next element. Not
* doing anything will result in a never-ending loop.
*
* If you just want to skip parsing for this element altogether, you can
* just call $reader->next();
*
* $reader->parseInnerTree() will parse the entire sub-tree, and advance to
* the next element.
*
* @return mixed
*/
public static function xmlDeserialize(Reader $reader)
{
$reader->pushContext();
$reader->elementMap['{DAV:}propstat'] = 'Sabre\\Xml\\Element\\KeyValue';
// We are overriding the parser for {DAV:}prop. This deserializer is
// almost identical to the one for Sabre\Xml\Element\KeyValue.
//
// The difference is that if there are any child-elements inside of
// {DAV:}prop, that have no value, normally any deserializers are
// called. But we don't want this, because a singular element without
// child-elements implies 'no value' in {DAV:}prop, so we want to skip
// deserializers and just set null for those.
$reader->elementMap['{DAV:}prop'] = function (Reader $reader) {
if ($reader->isEmptyElement) {
$reader->next();
return [];
}
$values = [];
$reader->read();
do {
if (Reader::ELEMENT === $reader->nodeType) {
$clark = $reader->getClark();
if ($reader->isEmptyElement) {
$values[$clark] = null;
$reader->next();
} else {
$values[$clark] = $reader->parseCurrentElement()['value'];
}
} else {
$reader->read();
}
} while (Reader::END_ELEMENT !== $reader->nodeType);
$reader->read();
return $values;
};
$elems = $reader->parseInnerTree();
$reader->popContext();
$href = null;
$propertyLists = [];
$statusCode = null;
foreach ($elems as $elem) {
switch ($elem['name']) {
case '{DAV:}href':
$href = $elem['value'];
break;
case '{DAV:}propstat':
$status = $elem['value']['{DAV:}status'];
list(, $status) = explode(' ', $status, 3);
$properties = isset($elem['value']['{DAV:}prop']) ? $elem['value']['{DAV:}prop'] : [];
if ($properties) {
$propertyLists[$status] = $properties;
}
break;
case '{DAV:}status':
list(, $statusCode) = explode(' ', $elem['value'], 3);
break;
}
}
return new self($href, $propertyLists, $statusCode);
}
}

189
vendor/sabre/dav/lib/DAV/Xml/Element/Sharee.php vendored Normal file
View File

@ -0,0 +1,189 @@
<?php
declare(strict_types=1);
namespace Sabre\DAV\Xml\Element;
use Sabre\DAV\Exception\BadRequest;
use Sabre\DAV\Sharing\Plugin;
use Sabre\DAV\Xml\Property\Href;
use Sabre\DAV\Xml\Property\ShareAccess;
use Sabre\Xml\Deserializer;
use Sabre\Xml\Element;
use Sabre\Xml\Reader;
use Sabre\Xml\Writer;
/**
* This class represents the {DAV:}sharee element.
*
* @copyright Copyright (C) fruux GmbH. (https://fruux.com/)
* @author Evert Pot (http://evertpot.com/)
* @license http://sabre.io/license/ Modified BSD License
*/
class Sharee implements Element
{
/**
* A URL. Usually a mailto: address, could also be a principal url.
* This uniquely identifies the sharee.
*
* @var string
*/
public $href;
/**
* A local principal path. The server will do its best to locate the
* principal uri based on the given uri. If we could find a local matching
* principal uri, this property will contain the value.
*
* @var string|null
*/
public $principal;
/**
* A list of WebDAV properties that describe the sharee. This might for
* example contain a {DAV:}displayname with the real name of the user.
*
* @var array
*/
public $properties = [];
/**
* Share access level. One of the Sabre\DAV\Sharing\Plugin::ACCESS
* constants.
*
* Can be one of:
*
* ACCESS_READ
* ACCESS_READWRITE
* ACCESS_SHAREDOWNER
* ACCESS_NOACCESS
*
* depending on context.
*
* @var int
*/
public $access;
/**
* When a sharee is originally invited to a share, the sharer may add
* a comment. This will be placed in this property.
*
* @var string
*/
public $comment;
/**
* The status of the invite, should be one of the
* Sabre\DAV\Sharing\Plugin::INVITE constants.
*
* @var int
*/
public $inviteStatus;
/**
* Creates the object.
*
* $properties will be used to populate all internal properties.
*/
public function __construct(array $properties = [])
{
foreach ($properties as $k => $v) {
if (property_exists($this, $k)) {
$this->$k = $v;
} else {
throw new \InvalidArgumentException('Unknown property: '.$k);
}
}
}
/**
* The xmlSerialize method is called during xml writing.
*
* Use the $writer argument to write its own xml serialization.
*
* An important note: do _not_ create a parent element. Any element
* implementing XmlSerializable should only ever write what's considered
* its 'inner xml'.
*
* The parent of the current element is responsible for writing a
* containing element.
*
* This allows serializers to be re-used for different element names.
*
* If you are opening new elements, you must also close them again.
*/
public function xmlSerialize(Writer $writer)
{
$writer->write([
new Href($this->href),
'{DAV:}prop' => $this->properties,
'{DAV:}share-access' => new ShareAccess($this->access),
]);
switch ($this->inviteStatus) {
case Plugin::INVITE_NORESPONSE:
$writer->writeElement('{DAV:}invite-noresponse');
break;
case Plugin::INVITE_ACCEPTED:
$writer->writeElement('{DAV:}invite-accepted');
break;
case Plugin::INVITE_DECLINED:
$writer->writeElement('{DAV:}invite-declined');
break;
case Plugin::INVITE_INVALID:
$writer->writeElement('{DAV:}invite-invalid');
break;
}
}
/**
* The deserialize method is called during xml parsing.
*
* This method is called statically, this is because in theory this method
* may be used as a type of constructor, or factory method.
*
* Often you want to return an instance of the current class, but you are
* free to return other data as well.
*
* You are responsible for advancing the reader to the next element. Not
* doing anything will result in a never-ending loop.
*
* If you just want to skip parsing for this element altogether, you can
* just call $reader->next();
*
* $reader->parseInnerTree() will parse the entire sub-tree, and advance to
* the next element.
*
* @return mixed
*/
public static function xmlDeserialize(Reader $reader)
{
// Temporarily override configuration
$reader->pushContext();
$reader->elementMap['{DAV:}share-access'] = 'Sabre\DAV\Xml\Property\ShareAccess';
$reader->elementMap['{DAV:}prop'] = 'Sabre\Xml\Deserializer\keyValue';
$elems = Deserializer\keyValue($reader, 'DAV:');
// Restore previous configuration
$reader->popContext();
$sharee = new self();
if (!isset($elems['href'])) {
throw new BadRequest('Every {DAV:}sharee must have a {DAV:}href child-element');
}
$sharee->href = $elems['href'];
if (isset($elems['prop'])) {
$sharee->properties = $elems['prop'];
}
if (isset($elems['comment'])) {
$sharee->comment = $elems['comment'];
}
if (!isset($elems['share-access'])) {
throw new BadRequest('Every {DAV:}sharee must have a {DAV:}share-access child element');
}
$sharee->access = $elems['share-access']->getValue();
return $sharee;
}
}