/**
* @param FREST\Resource $resource
* @throws FREST\Exception
*/
public function setupWithResource($resource)
{
parent::setupWithResource($resource);
// Resource ID
if (isset($this->resourceID)) {
/** @var Setting\Field $fieldSetting */
$this->resource->getIDField($fieldSetting);
$idType = $fieldSetting->getVariableType();
$parsedResourceID = Type\Variable::castValue($this->resourceID, $idType);
if (!isset($parsedResourceID)) {
$typeString = Type\Variable::getString($idType);
throw new FREST\Exception(FREST\Exception::InvalidType, "Resource ID needs to be of type '{$typeString}' but was supplied with '{$this->resourceID}'");
}
$this->resourceID = $parsedResourceID;
}
}
/**
* @throws FREST\Exception
*/
protected function setupResourceFunction()
{
$resourceFunctions = $this->resource->getResourceFunctions();
// check if valid Func name
if (!isset($resourceFunctions) || !isset($resourceFunctions[$this->resourceFunctionName])) {
throw new FREST\Exception(FREST\Exception::ResourceFunctionDoesntExist, "Function name: '{$this->resourceFunctionName}'");
}
/** @var Func\Resource $resourceFunction */
$resourceFunction = $resourceFunctions[$this->resourceFunctionName];
$resourceFunctionParameters = $resourceFunction->getParameters();
// check method
$requiredMethod = $resourceFunction->getMethod();
$currentMethod = $this->frest->getMethod();
if ($requiredMethod != $currentMethod) {
$currentMethodString = Type\Method::getString($currentMethod);
$requiredMethodString = Type\Method::getString($requiredMethod);
throw new FREST\Exception(FREST\Exception::MismatchingResourceFunctionMethod, "Requires '{$requiredMethodString}' but using '{$currentMethodString}'");
}
// check for invalid parameters and build parameter list for Func
$functionParameters = array();
foreach ($this->parameters as $parameterName => $value) {
$isValidMiscParam = isset($this->miscParameters[$parameterName]);
if (!$isValidMiscParam) {
if (!isset($resourceFunctionParameters[$parameterName])) {
throw new FREST\Exception(FREST\Exception::InvalidFunctionParameter, "Parameter name: '{$parameterName}'");
}
$functionParameters[$parameterName] = $value;
}
}
if (isset($resourceFunctionParameters) && count($resourceFunctionParameters) > 0) {
// check for all required parameters
/** @var Func\FunctionParam $parameter */
$missingParameterNames = array();
foreach ($resourceFunctionParameters as $parameterName => $parameter) {
// check type
if (isset($functionParameters[$parameterName])) {
$variableType = $parameter->getVariableType();
$value = $functionParameters[$parameterName];
$castedValue = Type\Variable::castValue($value, $variableType);
if (!isset($castedValue)) {
$typeString = Type\Variable::getString($variableType);
throw new FREST\Exception(FREST\Exception::InvalidType, "Expecting parameter '{$parameterName}' to be of type '{$typeString}' but received '{$value}'");
}
$functionParameters[$parameterName] = $castedValue;
} else {
if ($parameter->getRequired()) {
$missingParameterNames[] = $parameterName;
}
}
}
if (count($missingParameterNames) > 0) {
$missingString = implode(', ', $missingParameterNames);
throw new FREST\Exception(FREST\Exception::MissingRequiredFunctionParameter, "Parameter name: '{$missingString}'");
}
}
// Check for Func implementation existence
if (!method_exists($this->resource, $this->resourceFunctionName)) {
throw new FREST\Exception(FREST\Exception::ResourceFunctionMissing, "Function name: '{$this->resourceFunctionName}', resource: '{$this->resource->getName()}'");
}
if ($resourceFunction->getRequiresResourceID()) {
$functionParameters['resourceID'] = $this->resourceID;
}
$this->resourceFunction = $resourceFunction;
$this->resourceFunctionParameters = $functionParameters;
}
/**
* @param FREST\Resource $resource
* @return array
* @throws FREST\Exception
*/
private function generateCreateSpecs($resource)
{
$createSpecs = array();
$createSettings = $resource->getCreateSettings();
if (isset($this->resourceID)) {
/** @var Setting\Field $idFieldSetting */
$idFieldName = $this->resource->getIDField($idFieldSetting);
$idAlias = $this->resource->getAliasForField($idFieldName);
$idCreateSpec = new Spec\Create($idAlias, $idFieldName, $this->resourceID, $idFieldSetting->getVariableType());
$createSpecs[$idAlias] = $idCreateSpec;
}
/** @var Setting\Create $createSetting */
foreach ($createSettings as $createSetting) {
$alias = $createSetting->getAlias();
if (isset($this->parameters[$alias])) {
$value = $this->parameters[$alias];
$field = $resource->getFieldForAlias($alias);
$fieldSetting = $resource->getFieldSettingForAlias($alias);
$variableType = $fieldSetting->getVariableType();
// Type checking
$castedValue = Type\Variable::castValue($value, $variableType);
if (!isset($castedValue)) {
$typeString = Type\Variable::getString($variableType);
throw new FREST\Exception(FREST\Exception::InvalidType, "Expecting '{$alias}' to be of type '{$typeString}' but received '{$value}'");
}
// Condition Func
$conditionFunction = $createSetting->getConditionFunction();
if (isset($conditionFunction)) {
if (!method_exists($resource, $conditionFunction)) {
throw new FREST\Exception(FREST\Exception::ConditionFunctionMissing, "Function name: '{$conditionFunction}', resource: '{$this->resource->getName()}'");
}
$isValueValid = $resource->{$conditionFunction}($castedValue);
if (!$isValueValid) {
throw new FREST\Exception(FREST\Exception::InvalidFieldValue, "Field: '{$alias}'");
}
}
// Filter Func
$filterFunction = $createSetting->getFilterFunction();
if (isset($filterFunction)) {
if (!method_exists($resource, $filterFunction)) {
throw new FREST\Exception(FREST\Exception::FilterFunctionMissing, "Function name: '{$filterFunction}', resource: '{$resource->getName()}'");
}
$castedValue = $resource->{$filterFunction}($castedValue);
}
$createSpec = new Spec\Create($alias, $field, $castedValue, $variableType);
$createSpecs[$alias] = $createSpec;
} else {
if ($createSetting->getRequired()) {
// get list of all parameters required but not set
$missingParameters = array();
/** @var Setting\Create $aCreateSetting */
foreach ($createSettings as $aCreateSetting) {
$alias = $aCreateSetting->getAlias();
if (!isset($this->parameters[$alias]) && $aCreateSetting->getRequired()) {
$missingParameters[] = $alias;
}
}
$missingParametersString = implode(', ', $missingParameters);
throw new FREST\Exception(FREST\Exception::MissingRequiredParams, "Missing parameters: {$missingParametersString}");
}
}
}
if (count($createSpecs) > 0) {
return $createSpecs;
}
return NULL;
}
/**
* @param mixed $valueToCheck
* @param int $valueVariableType
* @param array $functions
* @param mixed $parsedValue
* @param int $parsedValueVariableType
*
* @return Func\Condition
* @throws FREST\Exception
*/
private function checkForFunctions($valueToCheck, $valueVariableType, $functions, &$parsedValue, &$parsedValueVariableType)
{
$functionUsed = NULL;
/** @var Func\Condition $function */
foreach ($functions as $function) {
$functionName = $function->getName();
$functionParameters = $function->getParameters();
$functionReplacements = $function->getReplacements();
/** @var Func\FunctionParam $firstParameter */
$firstParameter = $functionParameters[0];
$beginsWithFunctionOpen = substr_compare("{$functionName}(", $valueToCheck, 0, strlen($functionName) + 1, TRUE) === 0;
$endsWithFunctionClose = substr($valueToCheck, -1) === ')';
if ($beginsWithFunctionOpen && $endsWithFunctionClose) {
$functionUsed = $function;
$innerValue = trim(substr($valueToCheck, strlen($functionName) + 1, -1));
if (strlen($innerValue) == 0) {
throw new FREST\Exception(FREST\Exception::InvalidValue, "Empty value specified in Func '{$functionName}'");
}
if (isset($functionReplacements)) {
foreach ($functionReplacements as $old => $new) {
$innerValue = str_replace($old, $new, $innerValue);
}
}
$valuesToConcatenate = NULL;
$innerValueVariableType = Type\Variable::stricterVariableType($firstParameter->getVariableType(), $valueVariableType);
$castedValue = Type\Variable::castValue($innerValue, $innerValueVariableType);
if (!isset($castedValue)) {
$variableTypeString = Type\Variable::getString($innerValueVariableType);
throw new FREST\Exception(FREST\Exception::InvalidType, "Expecting value for Func '{$functionName}' to be of type '{$variableTypeString}' but received '{$innerValue}'");
}
$parsedValue = $castedValue;
$parsedValueVariableType = $innerValueVariableType;
break;
// found use of Func already, don't keep checking
}
}
return $functionUsed;
}
/**
* @param FREST\Resource $resource
* @return array
* @throws FREST\Exception
*/
private function generateUpdateSpecs($resource)
{
$updateSpecs = array();
$updateSettings = $resource->getUpdateSettings();
/** @var Setting\Update $updateSetting */
foreach ($updateSettings as $updateSetting) {
$alias = $updateSetting->getAlias();
if (isset($this->parameters[$alias])) {
$value = $this->parameters[$alias];
$field = $resource->getFieldForAlias($alias);
$fieldSetting = $resource->getFieldSettingForAlias($alias);
$variableType = $fieldSetting->getVariableType();
// Type checking
$castedValue = Type\Variable::castValue($value, $variableType);
if (!isset($castedValue)) {
$typeString = Type\Variable::getString($variableType);
throw new FREST\Exception(FREST\Exception::InvalidType, "Expecting '{$alias}' to be of type '{$typeString}' but received '{$value}'");
}
// Condition Func
$conditionFunction = $updateSetting->getConditionFunction();
if (isset($conditionFunction)) {
if (!method_exists($resource, $conditionFunction)) {
throw new FREST\Exception(FREST\Exception::ConditionFunctionMissing, "Function name: '{$conditionFunction}', resource: '{$resource->getName()}'");
}
$isValueValid = $resource->{$conditionFunction}($castedValue);
if (!$isValueValid) {
throw new FREST\Exception(FREST\Exception::InvalidFieldValue, "Field: '{$alias}'");
}
}
// Filter Func
$filterFunction = $updateSetting->getFilterFunction();
if (isset($filterFunction)) {
if (!method_exists($resource, $filterFunction)) {
throw new FREST\Exception(FREST\Exception::FilterFunctionMissing, "Function name: '{$filterFunction}', resource: '{$resource->getName()}'");
}
$castedValue = $resource->{$filterFunction}($castedValue);
}
$updateSpec = new Spec\Update($alias, $field, $castedValue, $variableType);
$updateSpecs[$alias] = $updateSpec;
}
}
return $updateSpecs;
}
