/**
*
* @author Patrick Plichart, patrick@taotesting.com
* @param string $uri
* @throws common_exception_InvalidArgumentType
* @return boolean
*/
public function isInScope($uri)
{
if (!common_Utils::isUri($uri)) {
throw new common_exception_InvalidArgumentType();
}
$resource = new core_kernel_classes_Resource($uri);
return $resource->hasType($this->getRootClass());
}
/**
* @param \core_kernel_classes_Triple $triple
* @return bool
*/
public static function isFileReference(\core_kernel_classes_Triple $triple)
{
$prop = new \core_kernel_classes_Property($triple->predicate);
$range = $prop->getRange();
$rangeUri = is_null($range) ? '' : $range->getUri();
switch ($rangeUri) {
case CLASS_GENERIS_FILE:
return true;
case RDFS_RESOURCE:
$object = new \core_kernel_classes_Resource($triple->object);
return $object->hasType(new \core_kernel_classes_Class(CLASS_GENERIS_FILE));
default:
return false;
}
}
public function __construct()
{
parent::__construct();
$this->processDefinitionService = wfEngine_models_classes_ProcessDefinitionService::singleton();
$processDefinitionUri = urldecode($this->getRequestParameter('processDefinitionUri'));
if (!empty($processDefinitionUri) && common_Utils::isUri($processDefinitionUri)) {
$process = new core_kernel_classes_Resource($processDefinitionUri);
if ($process->hasType(new core_kernel_classes_Class(CLASS_PROCESS))) {
$this->processDefinition = $process;
} else {
$this->setErrorMessage(__('The resource is not a process definition'));
}
} else {
$this->setErrorMessage(__('No process definition uri given'));
}
}
/**
* Short description of method attachResource
*
* @access public
* @author Jerome Bogaerts, <*****@*****.**>
* @param core_kernel_classes_Property $targetProperty
* @param core_kernel_classes_Resource $targetResource
* @param string $value
* @return mixed
*/
public function attachResource(core_kernel_classes_Property $targetProperty, core_kernel_classes_Resource $targetResource, $value)
{
// We have to check if the resource identified by value exists in the Ontology.
$resource = new core_kernel_classes_Resource($value);
if ($resource->exists()) {
// Is the range correct ?
$targetPropertyRanges = $targetProperty->getPropertyValuesCollection(new core_kernel_classes_Property(RDFS_RANGE));
$rangeCompliance = true;
// If $targetPropertyRange->count = 0, we consider that the resouce
// may be attached because $rangeCompliance = true.
foreach ($targetPropertyRanges->getIterator() as $range) {
// Check all classes in target property's range.
if ($resource->hasType(new core_kernel_classes_Class($range))) {
$rangeCompliance = false;
break;
}
}
if (true == $rangeCompliance) {
$targetResource->setPropertyValue($targetProperty, $resource->getUri());
}
}
}
/**
* Short description of method isTransitionRule
*
* @access public
* @author Lionel Lecaque, <*****@*****.**>
* @param Resource rule
* @return boolean
*/
public function isTransitionRule(core_kernel_classes_Resource $rule)
{
$returnValue = (bool) false;
$returnValue = $rule->hasType(new core_kernel_classes_Class(CLASS_TRANSITIONRULES));
return (bool) $returnValue;
}
/**
* Short description of method deleteProcessExecution
*
* @access public
* @author Somsack Sipasseuth, <*****@*****.**>
* @param Resource processExecution
* @param boolean finishedOnly
* @return boolean
*/
public function deleteProcessExecution(core_kernel_classes_Resource $processExecution, $finishedOnly = false)
{
$returnValue = (bool) false;
if ($processExecution->hasType($this->processInstancesClass)) {
if ($finishedOnly) {
if (!$this->isFinished($processExecution)) {
return $returnValue;
}
}
$allActivityExecutions = $processExecution->getPropertyValues($this->processInstancesActivityExecutionsProp);
$count = count($allActivityExecutions);
for ($i = 0; $i < $count; $i++) {
$uri = $allActivityExecutions[$i];
if (common_Utils::isUri($uri)) {
$activityExecution = new core_kernel_classes_Resource($uri);
$activityExecution->delete();
//no need for the second param to "true" since all the related resources are going to be deleted in this method
}
}
$returnValue = $processExecution->delete();
}
return (bool) $returnValue;
}
/**
* Short description of method removeType
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource resource
* @param Class class
* @return boolean
*/
public function removeType(\core_kernel_classes_Resource $resource, \core_kernel_classes_Class $class)
{
$returnValue = (bool) false;
$dbWrapper = \core_kernel_classes_DbWrapper::singleton();
$referencer = ResourceReferencer::singleton();
if ($resource->hasType($class)) {
$resourceId = intval(Utils::getResourceToTableId($resource));
$classInfo = Utils::getClassInfo($class);
$triples = $resource->getRdfTriples();
if (!empty($resourceId)) {
$resource->delete(false);
$referencer->unReferenceResource($resource);
$query = 'INSERT INTO "statements" ("modelid", "subject", "predicate", "object", "l_language") VALUES (?, ?, ?, ?, ?);';
foreach ($triples as $t) {
$dbWrapper->exec($query, array(99999, $t->subject, $t->predicate, $t->object, $t->lg));
}
}
}
$returnValue = true;
return (bool) $returnValue;
}
/**
* Short description of method setAcl
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource processDefinition
* @param Resource mode
* @param Resource target
* @return core_kernel_classes_Resource
*/
public function setAcl(core_kernel_classes_Resource $processDefinition, core_kernel_classes_Resource $mode, core_kernel_classes_Resource $target = null)
{
$returnValue = null;
if (!$processDefinition->hasType(new core_kernel_classes_Class(CLASS_PROCESS))) {
throw new Exception("Process must be an instance of the class Process");
}
if (!in_array($mode->getUri(), array_keys($this->getAclModes()))) {
throw new Exception("Unknow acl mode");
}
//set the ACL mode
$properties = array(PROPERTY_PROCESS_INIT_ACL_MODE => $mode->getUri());
switch ($mode->getUri()) {
case INSTANCE_ACL_ROLE:
if (is_null($target)) {
throw new Exception("Target must reference a role resource");
}
$properties[PROPERTY_PROCESS_INIT_RESTRICTED_ROLE] = $target->getUri();
break;
case INSTANCE_ACL_USER:
if (is_null($target)) {
throw new Exception("Target must reference a user resource");
}
$properties[PROPERTY_PROCESS_INIT_RESTRICTED_USER] = $target->getUri();
break;
}
//bind the mode and the target (user or role) to the activity
$returnValue = $this->bindProperties($processDefinition, $properties);
return $returnValue;
}
/**
* Short description of method isFile
*
* @access public
* @author Jerome Bogaerts, <*****@*****.**>
* @param Resource resource
* @return boolean
*/
public static function isFile(core_kernel_classes_Resource $resource)
{
return $resource->hasType(new core_kernel_classes_Class(CLASS_GENERIS_FILE));
}
/**
* Short description of method setActualParameter
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource callOfService
* @param Resource formalParam
* @param string value
* @param string parameterInOrOut
* @param string actualParameterType
* @return boolean
*/
public function setActualParameter(core_kernel_classes_Resource $callOfService, core_kernel_classes_Resource $formalParam, $value, $parameterInOrOut = PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN, $actualParameterType = PROPERTY_ACTUALPARAMETER_CONSTANTVALUE)
{
$returnValue = (bool) false;
//must exist:
if ($formalParam->hasType(new core_kernel_classes_Class(CLASS_FORMALPARAMETER))) {
if (in_array($parameterInOrOut, array(PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN, PROPERTY_CALLOFSERVICES_ACTUALPARAMETEROUT)) && in_array($actualParameterType, array(PROPERTY_ACTUALPARAMETER_CONSTANTVALUE, PROPERTY_ACTUALPARAMETER_PROCESSVARIABLE))) {
//create new resource for the property value of the current call of service PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN or PROPERTY_CALLOFSERVICES_ACTUALPARAMETEROUT
$actualParameterClass = new core_kernel_classes_Class(CLASS_ACTUALPARAMETER);
$newActualParameter = $actualParameterClass->createInstance($formalParam->getLabel(), "actual parameter created by Process Authoring Service");
$newActualParameter->setPropertyValue(new core_kernel_classes_Property(PROPERTY_ACTUALPARAMETER_FORMALPARAMETER), $formalParam->getUri());
$newActualParameter->setPropertyValue(new core_kernel_classes_Property($actualParameterType), $value);
$returnValue = $callOfService->setPropertyValue(new core_kernel_classes_Property($parameterInOrOut), $newActualParameter->getUri());
}
} else {
throw new Exception('the formal parameter ' . $formalParam->getUri() . ' does not exist');
}
return (bool) $returnValue;
}
/**
* Short description of method isProcessVariable
*
* @access public
* @author Somsack Sipasseuth, <*****@*****.**>
* @param Resource variable
* @return boolean
*/
public function isProcessVariable(core_kernel_classes_Resource $variable)
{
$returnValue = (bool) false;
$returnValue = $variable->hasType(new core_kernel_classes_Class(CLASS_PROCESSVARIABLES));
return (bool) $returnValue;
}
/**
* (non-PHPdoc)
* @see core_kernel_persistence_ClassInterface::createInstance()
*/
public function createInstance(core_kernel_classes_Class $resource, $label = '', $comment = '', $uri = '')
{
$returnValue = null;
$subject = '';
if ($uri == '') {
$subject = common_Utils::getNewUri();
} else {
if ($uri[0] == '#') {
//$uri should start with # and be well formed
$modelUri = common_ext_NamespaceManager::singleton()->getLocalNamespace()->getUri();
$subject = rtrim($modelUri, '#') . $uri;
} else {
$subject = $uri;
}
}
$returnValue = new core_kernel_classes_Resource($subject, __METHOD__);
if (!$returnValue->hasType($resource)) {
$returnValue->setType($resource);
} else {
common_Logger::e('already had type ' . $resource);
}
if (!empty($label)) {
$returnValue->setLabel($label);
}
if (!empty($comment)) {
$returnValue->setComment($comment);
}
return $returnValue;
}
/**
* Check if a resource is a versioned file resource
*
* @access public
* @author Lionel Lecaque, <*****@*****.**>
* @param Resource resource
* @return boolean
*/
public static function isVersionedFile(core_kernel_classes_Resource $resource)
{
$returnValue = (bool) false;
$returnValue = $resource->hasType(new core_kernel_classes_Class(CLASS_GENERIS_FILE));
return (bool) $returnValue;
}
