public function importValue($value) { if ($value) { Assert::isEqual(get_class($value), $this->className); } else { return parent::importValue(null); } return $this->import([$this->getName() => $value->getId()]); }
/** * @return Form **/ public function fillOwn($object, &$result) { Assert::isInstance($result, Form::class); foreach ($this->getFormMapping() as $primitive) { if ($primitive instanceof PrimitiveForm && $result->exists($primitive->getName()) && $primitive->isComposite()) { Assert::isEqual($primitive->getProto(), $result->get($primitive->getName())->getProto()); continue; } $result->add($primitive); } $result = parent::fillOwn($object, $result); $result->setProto($this->proto); return $result; }
public static function copyProperties($source, $destination) { Assert::isEqual(get_class($source), get_class($destination)); $class = new \ReflectionClass($source); foreach ($class->getProperties() as $property) { $name = ucfirst($property->getName()); $getter = 'get' . $name; $setter = 'set' . $name; if ($class->hasMethod($getter) && $class->hasMethod($setter)) { $sourceValue = $source->{$getter}(); if ($sourceValue === null) { $setMethood = $class->getMethod($setter); $parameterList = $setMethood->getParameters(); $firstParameter = $parameterList[0]; if ($firstParameter->allowsNull()) { $destination->{$setter}($sourceValue); } } else { $destination->{$setter}($sourceValue); } } } }
public static function getCovariance(array $list1, array $list2) { $list1Size = count($list1); $list2Size = count($list2); Assert::isEqual($list1Size, $list2Size, 'Array sizes should be equals!'); $list1AverageValue = self::getAverage($list1); $list2AverageValue = self::getAverage($list2); $tempSum = 0; for ($i = 0; $i < $list1Size; $i++) { $elt1Dev = self::getMeanDeviation($list1[$i], $list1AverageValue); $elt2Dev = self::getMeanDeviation($list2[$i], $list2AverageValue); $tempSum += $elt1Dev * $elt2Dev; } return $tempSum / ($list1Size - 1); }
public final function validateList($objectsList, $formsList, $previousObjectsList = null) { Assert::isEqual(count($objectsList), count($formsList)); reset($formsList); if ($previousObjectsList) { Assert::isEqual(count($objectsList), count($previousObjectsList)); reset($previousObjectsList); } $result = true; $previousObject = null; foreach ($objectsList as $object) { $form = current($formsList); next($formsList); if ($previousObjectsList) { $previousObject = current($previousObjectsList); next($previousObjectsList); } if (!$this->validate($object, $form, $previousObject)) { $result = false; } } return $result; }
protected function call($method, DTOMessage $request, $resultClass) { $requestDto = $request->makeDto(); Assert::isInstance($requestDto, DTOClass::class); if (defined('__LOCAL_DEBUG__') && !defined('SIMPLE_TEST')) { // self-validation $form = ObjectToFormConverter::create($request->entityProto())->make($request); Assert::isTrue(!$form->getErrors() && $request->entityProto()->validate($request, $form), Assert::dumpArgument($request)); } try { try { $resultDto = $this->getSoapClient()->{$method}($requestDto); } catch (BaseException $e) { if (get_class($e) == BaseException::class) { throw new SoapFault('Server', get_class($e) . ': ' . $e->getMessage()); } else { $this->logCall(); throw $e; } } } catch (SoapFault $e) { $this->logCall(); throw self::convertSoapFault($e); } $this->logCall(); if (!$resultClass) { Assert::isNull($resultDto); $result = null; } else { Assert::isInstance($resultDto, DTOClass::class); Assert::isEqual($resultDto->entityProto()->className(), $resultClass); $form = DTOToFormImporter::create($resultDto->entityProto())->make($resultDto); Assert::isTrue(!$form->getErrors(), Assert::dumpArgument($resultDto)); $result = $resultDto->makeObject($form); Assert::isInstance($result, DTOMessage::class); Assert::isEqual(get_class($result), $resultClass); Assert::isTrue($result->entityProto()->validate($result, $form), Assert::dumpArgument($result)); } return $result; }
public static function makeUniqueLatinName($originalName) { $extension = substr($originalName, strrpos($originalName, '.')); Assert::isEqual(preg_match('/\\.[^0-9a-zA-Z]/', $extension), 0, 'I don\'t know how to work with this extension: ' . $extension); return time() . '_' . uniqid() . $extension; }
public static function setChars($chars) { self::check($chars); Assert::isEqual(mb_strlen($chars), 62, 'Wrong length'); self::$chars = $chars; }
private function __construct($name) { $units = self::getUnits(); if (!isset($units[$name])) { throw new WrongArgumentException("know nothing about unit '{$name}'"); } if (!$units[$name]) { throw new UnimplementedFeatureException('need for complex logic, see manual'); } $this->name = $name; $this->months = $units[$name][0]; $this->days = $units[$name][1]; $this->seconds = $units[$name][2]; $notNulls = 0; if ($this->months > 0) { ++$notNulls; } if ($this->days > 0) { ++$notNulls; } if ($this->seconds > 0) { ++$notNulls; } Assert::isEqual($notNulls, 1, "broken unit '{$name}'"); }
/** * @return MetaConfiguration **/ public function checkIntegrity() { $out = $this->getOutput()->newLine()->infoLine('Checking sanity of generated files: ')->newLine(); $out->info("\t"); $formErrors = []; foreach ($this->classes as $name => $class) { if (!($class->getPattern() instanceof SpookedClassPattern || $class->getPattern() instanceof SpookedEnumerationPattern || $class->getPattern() instanceof SpookedEnumPattern || $class->getPattern() instanceof SpookedRegistryPattern || $class->getPattern() instanceof InternalClassPattern) && class_exists(MetaClassNameBuilder::getClassOfMetaClass($class, true))) { $out->info($name, true); $className = MetaClassNameBuilder::getClassOfMetaClass($class); $info = new \ReflectionClass($className); $this->checkClassSanity($class, $info); if ($info->implementsInterface(Prototyped::class)) { $this->checkClassSanity($class, new \ReflectionClass($class->getProtoClass())); } if ($info->implementsInterface(DAOConnected::class)) { $this->checkClassSanity($class, new \ReflectionClass($class->getDaoClass())); } foreach ($class->getInterfaces() as $interface) { Assert::isTrue($info->implementsInterface($interface), 'class ' . $class->getName() . ' expected to implement interface ' . $interface); } // special handling for Enumeration instances if ($class->getPattern() instanceof EnumerationClassPattern || $class->getPattern() instanceof EnumClassPattern || $class->getPattern() instanceof RegistryClassPattern) { $object = new $className(call_user_func([$className, 'getAnyId'])); Assert::isTrue(unserialize(serialize($object)) == $object); $out->info(', '); if ($this->checkEnumerationRefIntegrity) { if ($object instanceof Enumeration || $object instanceof Enum || $object instanceof Registry) { $this->checkEnumerationReferentialIntegrity($object, $class->getTableName()); } } continue; } if ($class->getPattern() instanceof AbstractClassPattern) { $out->info(', '); continue; } /** @var Prototyped $object */ $object = new $className(); $proto = $object->proto(); $form = $proto->makeForm(); foreach ($class->getProperties() as $name => $property) { Assert::isTrue($property->toLightProperty($class) == $proto->getPropertyByName($name), 'defined property does not match autogenerated one - ' . $class->getName() . '::' . $property->getName()); } if (!$object instanceof DAOConnected) { $out->info(', '); continue; } $dao = $object->dao(); Assert::isEqual($dao->getIdName(), $class->getIdentifier()->getColumnName(), 'identifier name mismatch in ' . $class->getName() . ' class'); try { DBPool::getByDao($dao); } catch (MissingElementException $e) { // skipping $out->info(', '); continue; } $query = Criteria::create($dao)->setLimit(1)->add(Expression::notNull($class->getIdentifier()->getName()))->addOrder($class->getIdentifier()->getName())->toSelectQuery(); $out->warning(' (' . $query->getFieldsCount() . '/' . $query->getTablesCount() . '/'); $clone = clone $object; if (serialize($clone) == serialize($object)) { $out->info('C', true); } else { $out->error('C', true); } $out->warning('/'); try { $object = $dao->getByQuery($query); $form = $object->proto()->makeForm(); FormUtils::object2form($object, $form); if ($errors = $form->getErrors()) { $formErrors[$class->getName()] = $errors; $out->error('F', true); } else { $out->info('F', true); } } catch (ObjectNotFoundException $e) { $out->warning('F'); } $out->warning('/'); if (Criteria::create($dao)->setFetchStrategy(FetchStrategy::cascade())->toSelectQuery() == $dao->makeSelectHead()) { $out->info('H', true); } else { $out->error('H', true); } $out->warning('/'); // cloning once again $clone = clone $object; FormUtils::object2form($object, $form); FormUtils::form2object($form, $object); if ($object != $clone) { $out->error('T', true); } else { $out->info('T', true); } $out->warning(')')->info(', '); } } $out->infoLine('done.'); if ($formErrors) { $out->newLine()->errorLine('Errors found:')->newLine(); foreach ($formErrors as $class => $errors) { $out->errorLine("\t" . $class . ':', true); foreach ($errors as $name => $error) { $out->errorLine("\t\t" . $name . ' - ' . ($error == Form::WRONG ? ' wrong' : ' missing')); } $out->newLine(); } } return $this; }
public static function hex2Binary($hex) { $length = strlen($hex); Assert::isEqual($length % 2, 0); $out = null; for ($i = 0; $i < $length; $i += 2) { $out .= pack('C', hexdec(substr($hex, $i, 2))); } return $out; }
public function endPrefetch(array $objectList) { if (!$this->depth) { throw new WrongStateException('prefetch mode is already off'); } foreach ($this->storage[$this->depth] as $setter => $innerList) { Assert::isEqual(count($objectList), count($innerList) + array_sum($this->skipList[$this->depth])); $ids = []; foreach ($innerList as $inner) { if ($inner) { $ids[] = $inner->getId(); } } // finding first available inner object foreach ($innerList as $inner) { if ($inner) { break; } } if (!$inner) { continue; } // put yet unmapped objects into dao's identityMap $inner->dao()->getListByIds($ids); $skippedMap = $this->skipList[$this->depth]; $i = $j = 0; foreach ($objectList as $object) { $objectId = $object->getId(); if (isset($skippedMap[$objectId])) { if ($skippedMap[$objectId] == 1) { unset($skippedMap[$objectId]); } else { --$skippedMap[$objectId]; } ++$j; continue; } if ($innerList[$i]) { try { // avoid dao "caching" here // because of possible breakage // in overriden properties $object->{$setter}($innerList[$i]->dao()->getById($innerList[$i]->getId())); } catch (ObjectNotFoundException $e) { throw new WrongStateException('possible corruption found: ' . $e->getMessage()); } } ++$i; } Assert::isEqual($i, count($objectList) - $j); } unset($this->skipList[$this->depth], $this->storage[$this->depth--]); return $objectList; }
private function assertSavePointName($savepointName) { Assert::isEqual(1, preg_match('~^[A-Za-z][A-Za-z0-9]*$~iu', $savepointName)); }
public function store($localFile, $desiredName) { if (!is_readable($localFile) || !is_file($localFile)) { throw new WrongArgumentException('Wrong file: ' . $localFile); } if (preg_match($this->unAllowedName, $desiredName)) { throw new WrongArgumentException('Wrong desired name: ' . $desiredName); } $origDesiredName = $desiredName; $desiredNameFull = $this->getPath($desiredName, true); if ($this->exists($desiredName) && $this->resolveNameConflicts) { $desiredName = $this->generateName($desiredName); $desiredNameFull = $this->getPath($desiredName, true); } if ($this->exists($desiredName)) { throw new Exception('File name conflict:' . $origDesiredName . '"'); } $context = $this->context; $upload = function () use($localFile, $desiredNameFull, $desiredName, $context) { $src = fopen($localFile, 'rb'); $dst = fopen($desiredNameFull, 'wb', false, $context); Assert::isEqual(stream_copy_to_stream($src, $dst), filesize($localFile), 'Bytes copied mismatch'); $this->closeHandles($src, $dst); if (!$this->exists($desiredName)) { throw new Exception('Could not find file after upload"' . $desiredName . '", linkId: ' . $this->linkId); } }; $this->tryToDo($upload, 'Couldn`t store file ' . $origDesiredName . ', reason: %s'); return $desiredName; }