aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/sabre/dav/lib/DAV/PropPatch.php
diff options
context:
space:
mode:
authorredmatrix <git@macgirvin.com>2016-05-10 17:26:44 -0700
committerredmatrix <git@macgirvin.com>2016-05-10 17:26:44 -0700
commit0b02a6d123b2014705998c94ddf3d460948d3eac (patch)
tree78ff2cab9944a4f5ab3f80ec93cbe1120de90bb2 /vendor/sabre/dav/lib/DAV/PropPatch.php
parent40b5b6e9d2da7ab65c8b4d38cdceac83a4d78deb (diff)
downloadvolse-hubzilla-0b02a6d123b2014705998c94ddf3d460948d3eac.tar.gz
volse-hubzilla-0b02a6d123b2014705998c94ddf3d460948d3eac.tar.bz2
volse-hubzilla-0b02a6d123b2014705998c94ddf3d460948d3eac.zip
initial sabre upgrade (needs lots of work - to wit: authentication, redo the browser interface, and rework event export/import)
Diffstat (limited to 'vendor/sabre/dav/lib/DAV/PropPatch.php')
-rw-r--r--vendor/sabre/dav/lib/DAV/PropPatch.php373
1 files changed, 373 insertions, 0 deletions
diff --git a/vendor/sabre/dav/lib/DAV/PropPatch.php b/vendor/sabre/dav/lib/DAV/PropPatch.php
new file mode 100644
index 000000000..6d599dacc
--- /dev/null
+++ b/vendor/sabre/dav/lib/DAV/PropPatch.php
@@ -0,0 +1,373 @@
+<?php
+
+namespace Sabre\DAV;
+
+use UnexpectedValueException;
+
+/**
+ * This class represents a set of properties that are going to be updated.
+ *
+ * Usually this is simply a PROPPATCH request, but it can also be used for
+ * internal updates.
+ *
+ * Property updates must always be atomic. This means that a property update
+ * must either completely succeed, or completely fail.
+ *
+ * @copyright Copyright (C) fruux GmbH (https://fruux.com/)
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+class PropPatch {
+
+ /**
+ * Properties that are being updated.
+ *
+ * This is a key-value list. If the value is null, the property is supposed
+ * to be deleted.
+ *
+ * @var array
+ */
+ protected $mutations;
+
+ /**
+ * A list of properties and the result of the update. The result is in the
+ * form of a HTTP status code.
+ *
+ * @var array
+ */
+ protected $result = [];
+
+ /**
+ * This is the list of callbacks when we're performing the actual update.
+ *
+ * @var array
+ */
+ protected $propertyUpdateCallbacks = [];
+
+ /**
+ * This property will be set to true if the operation failed.
+ *
+ * @var bool
+ */
+ protected $failed = false;
+
+ /**
+ * Constructor
+ *
+ * @param array $mutations A list of updates
+ */
+ function __construct(array $mutations) {
+
+ $this->mutations = $mutations;
+
+ }
+
+ /**
+ * Call this function if you wish to handle updating certain properties.
+ * For instance, your class may be responsible for handling updates for the
+ * {DAV:}displayname property.
+ *
+ * In that case, call this method with the first argument
+ * "{DAV:}displayname" and a second argument that's a method that does the
+ * actual updating.
+ *
+ * It's possible to specify more than one property as an array.
+ *
+ * The callback must return a boolean or an it. If the result is true, the
+ * operation was considered successful. If it's false, it's consided
+ * failed.
+ *
+ * If the result is an integer, we'll use that integer as the http status
+ * code associated with the operation.
+ *
+ * @param string|string[] $properties
+ * @param callable $callback
+ * @return void
+ */
+ function handle($properties, callable $callback) {
+
+ $usedProperties = [];
+ foreach ((array)$properties as $propertyName) {
+
+ if (array_key_exists($propertyName, $this->mutations) && !isset($this->result[$propertyName])) {
+
+ $usedProperties[] = $propertyName;
+ // HTTP Accepted
+ $this->result[$propertyName] = 202;
+ }
+
+ }
+
+ // Only registering if there's any unhandled properties.
+ if (!$usedProperties) {
+ return;
+ }
+ $this->propertyUpdateCallbacks[] = [
+ // If the original argument to this method was a string, we need
+ // to also make sure that it stays that way, so the commit function
+ // knows how to format the arguments to the callback.
+ is_string($properties) ? $properties : $usedProperties,
+ $callback
+ ];
+
+ }
+
+ /**
+ * Call this function if you wish to handle _all_ properties that haven't
+ * been handled by anything else yet. Note that you effectively claim with
+ * this that you promise to process _all_ properties that are coming in.
+ *
+ * @param callable $callback
+ * @return void
+ */
+ function handleRemaining(callable $callback) {
+
+ $properties = $this->getRemainingMutations();
+ if (!$properties) {
+ // Nothing to do, don't register callback
+ return;
+ }
+
+ foreach ($properties as $propertyName) {
+ // HTTP Accepted
+ $this->result[$propertyName] = 202;
+
+ $this->propertyUpdateCallbacks[] = [
+ $properties,
+ $callback
+ ];
+ }
+
+ }
+
+ /**
+ * Sets the result code for one or more properties.
+ *
+ * @param string|string[] $properties
+ * @param int $resultCode
+ * @return void
+ */
+ function setResultCode($properties, $resultCode) {
+
+ foreach ((array)$properties as $propertyName) {
+ $this->result[$propertyName] = $resultCode;
+ }
+
+ if ($resultCode >= 400) {
+ $this->failed = true;
+ }
+
+ }
+
+ /**
+ * Sets the result code for all properties that did not have a result yet.
+ *
+ * @param int $resultCode
+ * @return void
+ */
+ function setRemainingResultCode($resultCode) {
+
+ $this->setResultCode(
+ $this->getRemainingMutations(),
+ $resultCode
+ );
+
+ }
+
+ /**
+ * Returns the list of properties that don't have a result code yet.
+ *
+ * This method returns a list of property names, but not its values.
+ *
+ * @return string[]
+ */
+ function getRemainingMutations() {
+
+ $remaining = [];
+ foreach ($this->mutations as $propertyName => $propValue) {
+ if (!isset($this->result[$propertyName])) {
+ $remaining[] = $propertyName;
+ }
+ }
+
+ return $remaining;
+
+ }
+
+ /**
+ * Returns the list of properties that don't have a result code yet.
+ *
+ * This method returns list of properties and their values.
+ *
+ * @return array
+ */
+ function getRemainingValues() {
+
+ $remaining = [];
+ foreach ($this->mutations as $propertyName => $propValue) {
+ if (!isset($this->result[$propertyName])) {
+ $remaining[$propertyName] = $propValue;
+ }
+ }
+
+ return $remaining;
+
+ }
+
+ /**
+ * Performs the actual update, and calls all callbacks.
+ *
+ * This method returns true or false depending on if the operation was
+ * successful.
+ *
+ * @return bool
+ */
+ function commit() {
+
+ // First we validate if every property has a handler
+ foreach ($this->mutations as $propertyName => $value) {
+
+ if (!isset($this->result[$propertyName])) {
+ $this->failed = true;
+ $this->result[$propertyName] = 403;
+ }
+
+ }
+
+ foreach ($this->propertyUpdateCallbacks as $callbackInfo) {
+
+ if ($this->failed) {
+ break;
+ }
+ if (is_string($callbackInfo[0])) {
+ $this->doCallbackSingleProp($callbackInfo[0], $callbackInfo[1]);
+ } else {
+ $this->doCallbackMultiProp($callbackInfo[0], $callbackInfo[1]);
+ }
+
+ }
+
+ /**
+ * If anywhere in this operation updating a property failed, we must
+ * update all other properties accordingly.
+ */
+ if ($this->failed) {
+
+ foreach ($this->result as $propertyName => $status) {
+ if ($status === 202) {
+ // Failed dependency
+ $this->result[$propertyName] = 424;
+ }
+ }
+
+ }
+
+ return !$this->failed;
+
+ }
+
+ /**
+ * Executes a property callback with the single-property syntax.
+ *
+ * @param string $propertyName
+ * @param callable $callback
+ * @return void
+ */
+ private function doCallBackSingleProp($propertyName, callable $callback) {
+
+ $result = $callback($this->mutations[$propertyName]);
+ if (is_bool($result)) {
+ if ($result) {
+ if (is_null($this->mutations[$propertyName])) {
+ // Delete
+ $result = 204;
+ } else {
+ // Update
+ $result = 200;
+ }
+ } else {
+ // Fail
+ $result = 403;
+ }
+ }
+ if (!is_int($result)) {
+ throw new UnexpectedValueException('A callback sent to handle() did not return an int or a bool');
+ }
+ $this->result[$propertyName] = $result;
+ if ($result >= 400) {
+ $this->failed = true;
+ }
+
+ }
+
+ /**
+ * Executes a property callback with the multi-property syntax.
+ *
+ * @param array $propertyList
+ * @param callable $callback
+ * @return void
+ */
+ private function doCallBackMultiProp(array $propertyList, callable $callback) {
+
+ $argument = [];
+ foreach ($propertyList as $propertyName) {
+ $argument[$propertyName] = $this->mutations[$propertyName];
+ }
+
+ $result = $callback($argument);
+
+ if (is_array($result)) {
+ foreach ($propertyList as $propertyName) {
+ if (!isset($result[$propertyName])) {
+ $resultCode = 500;
+ } else {
+ $resultCode = $result[$propertyName];
+ }
+ if ($resultCode >= 400) {
+ $this->failed = true;
+ }
+ $this->result[$propertyName] = $resultCode;
+
+ }
+ } elseif ($result === true) {
+
+ // Success
+ foreach ($argument as $propertyName => $propertyValue) {
+ $this->result[$propertyName] = is_null($propertyValue) ? 204 : 200;
+ }
+
+ } elseif ($result === false) {
+ // Fail :(
+ $this->failed = true;
+ foreach ($propertyList as $propertyName) {
+ $this->result[$propertyName] = 403;
+ }
+ } else {
+ throw new UnexpectedValueException('A callback sent to handle() did not return an array or a bool');
+ }
+
+ }
+
+ /**
+ * Returns the result of the operation.
+ *
+ * @return array
+ */
+ function getResult() {
+
+ return $this->result;
+
+ }
+
+ /**
+ * Returns the full list of mutations
+ *
+ * @return array
+ */
+ function getMutations() {
+
+ return $this->mutations;
+
+ }
+
+}