/**
* Sends an email submitted through a contact form.
*
* @param ContactFormModel $message
* @throws Exception
* @return bool
*/
public function sendMessage(ContactFormModel $message)
{
$settings = craft()->plugins->getPlugin('contactform')->getSettings();
if (!$settings->toEmail) {
throw new Exception('The "To Email" address is not set on the plugin’s settings page.');
}
// Fire an 'onBeforeSend' event
Craft::import('plugins.contactform.events.ContactFormEvent');
$event = new ContactFormEvent($this, array('message' => $message));
$this->onBeforeSend($event);
if ($event->isValid) {
if (!$event->fakeIt) {
$toEmails = ArrayHelper::stringToArray($settings->toEmail);
foreach ($toEmails as $toEmail) {
$email = new EmailModel();
$emailSettings = craft()->email->getSettings();
$email->fromEmail = $emailSettings['emailAddress'];
$email->replyTo = $message->fromEmail;
$email->sender = $emailSettings['emailAddress'];
$email->fromName = $settings->prependSender . ($settings->prependSender && $message->fromName ? ' ' : '') . $message->fromName;
$email->toEmail = $toEmail;
$email->subject = $settings->prependSubject . ($settings->prependSubject && $message->subject ? ' - ' : '') . $message->subject;
$email->body = $message->message;
if ($message->attachment) {
$email->addAttachment($message->attachment->getTempName(), $message->attachment->getName(), 'base64', $message->attachment->getType());
}
craft()->email->sendEmail($email);
}
}
return true;
}
return false;
}
public function get(array $hashMap, $isNestedKeysName = false)
{
$pattern = $this->getPattern($isNestedKeysName);
$this->mapper->match($pattern, [$hashMap]);
$data = $this->mapper->current();
if (empty($data)) {
$result = $this->getEmptyArray($pattern);
} else {
$result = $this->arrayHelper->toTuple($data, $pattern);
}
return $result;
}
public function generate(array $possiblyLinkableDatasetNames = NULL) {
$adjustedPossiblyLinkableDatasetNames = NULL;
if (isset($possiblyLinkableDatasetNames)) {
foreach ($possiblyLinkableDatasetNames as $possiblyLinkableDatasetName) {
$adjustedPossiblyLinkableDatasetName = $this->adjustDatasetName($possiblyLinkableDatasetName);
// we should not try to link with itself
if ($adjustedPossiblyLinkableDatasetName == $this->primaryDatasetName) {
continue;
}
ArrayHelper::addUniqueValue($adjustedPossiblyLinkableDatasetNames, $adjustedPossiblyLinkableDatasetName);
}
}
// preparing reference paths for all datasets which we need to test for possible linkage
$referencePaths = NULL;
if (isset($adjustedPossiblyLinkableDatasetNames)) {
foreach ($adjustedPossiblyLinkableDatasetNames as $adjustedPossiblyLinkableDatasetName) {
// column name should not be provided because we just try to link with the dataset
$referencePath = ReferencePathHelper::assembleReference($adjustedPossiblyLinkableDatasetName, NULL);
$referencePaths[$referencePath] = FALSE; // FALSE - if we cannot find link it is ok. Not everything could be connected
}
}
$linkBuilder = new ReferenceLinkBuilder();
$link = $linkBuilder->prepareReferenceBranches($this->primaryDatasetName, $referencePaths);
return $link;
}
protected function serialize(AbstractQueryRequest $request) {
$parameters = NULL;
// serializing columns names to sort result
if (isset($request->sortingConfigurations)) {
$sortColumns = NULL;
foreach ($request->sortingConfigurations as $sortingConfiguration) {
$sortColumns[] = ColumnBasedComparator_AbstractSortingConfiguration::assembleDirectionalColumnName(
$sortingConfiguration->getColumnName(), $sortingConfiguration->isSortAscending);
}
ArrayHelper::merge(
$parameters,
$this->serializeValue(
DataQueryControllerUIParameterNames::SORT,
DataQueryControllerUIRequestPreparer::prepareSortColumns($sortColumns)));
}
// serializing record offset
if (isset($request->startWith) && ($request->startWith > 0)) {
$parameters[DataQueryControllerUIParameterNames::OFFSET] = $request->startWith;
}
// serializing record limit
if (isset($request->limit)) {
$parameters[DataQueryControllerUIParameterNames::LIMIT] = $request->limit;
}
return $parameters;
}
public function merge(Statement $statement)
{
ArrayHelper::mergeArrays($this->tables, $statement->tables);
ArrayHelper::mergeArrays($this->conditions, $statement->conditions);
ArrayHelper::mergeArrays($this->groupByColumns, $statement->groupByColumns);
ArrayHelper::mergeArrays($this->havingConditions, $statement->havingConditions);
}
protected function registerRecordImpl(array &$records = NULL, $record) {
parent::registerRecordImpl($records, $record);
$recordKey = NULL;
foreach ($this->keyColumnNames as $keyColumnName) {
$recordKey[] = isset($record[$keyColumnName]) ? $record[$keyColumnName] : NULL;
}
$key = ArrayHelper::prepareCompositeKey($recordKey);
if (isset($records[$key])) {
if ($this->isColumnValueUnique) {
throw new IllegalArgumentException(t(
'Found several records for the key: %key',
array('%key' => ArrayHelper::serialize($recordKey, ', ', TRUE, TRUE))));
}
$records[$key][] = $record;
}
else {
if ($this->isColumnValueUnique) {
$records[$key] = $record;
}
else {
$records[$key][] = $record;
}
}
return TRUE;
}
/**
* @param mixed|null $element
*
* @throws \Exception
* @return array|string
*/
public function getRecipients($element = null)
{
$recipientsString = $this->getAttribute('recipients');
// Possibly called from entry edit screen
if (is_null($element)) {
return $recipientsString;
}
// Previously converted to array somehow?
if (is_array($recipientsString)) {
return $recipientsString;
}
// Previously stored as JSON string?
if (stripos($recipientsString, '[') === 0) {
return JsonHelper::decode($recipientsString);
}
// Still a string with possible twig generator code?
if (stripos($recipientsString, '{') !== false) {
try {
$recipients = craft()->templates->renderObjectTemplate($recipientsString, $element);
return array_unique(ArrayHelper::filterEmptyStringsFromArray(ArrayHelper::stringToArray($recipients)));
} catch (\Exception $e) {
throw $e;
}
}
// Just a regular CSV list
if (!empty($recipientsString)) {
return ArrayHelper::filterEmptyStringsFromArray(ArrayHelper::stringToArray($recipientsString));
}
return array();
}
public function testConstructAndGetAndSet()
{
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
$ah = new ArrayHelper($array);
// Make sure we are not using by reference
$this->assertEquals(10, $ah->pop());
$this->assertEquals(10, $ah->pop());
// Make sure we are not using by reference
$this->assertEquals(1, $ah->shift());
$this->assertEquals(1, $ah->shift());
$ah->setMutable(true);
$this->assertEquals(1, $ah->shift());
$this->assertEquals(2, $ah->shift());
$ah->unshift(2, 1);
$this->assertEquals(1, $ah->shift());
}
protected static function _attributesTo($dimension, $modelData, $attributes = NULL)
{
$attributes = self::_parseMoneyAttributes($modelData, $attributes);
foreach ($attributes as $key => $attribute) {
$name = is_string($key) ? $key : $attribute;
if (empty($modelData[$name]) and !is_object($modelData) || empty($modelData->{$name})) {
continue;
}
$value = $modelData[$name];
if (is_array($attribute)) {
if (!ArrayHelper::isAssoc($attribute, true)) {
$modelData[$name] = self::_arrayTo($dimension, $value, $attribute);
} elseif (is_array($value) or is_object($value)) {
$modelData[$name] = self::_attributesTo($dimension, $value, $attribute);
} else {
$modelData[$name] = self::_to($dimension, $value);
}
} else {
if (is_array($value)) {
$modelData[$name] = self::_arrayTo($dimension, $value);
} else {
$modelData[$name] = self::_to($dimension, $value);
}
}
}
return $modelData;
}
public function getHandler($type) {
if (isset($this->handlers[$type])) {
return $this->handlers[$type];
}
$extensionConfiguration = $this->getExtensionConfiguration($type);
$handlerConfiguration = $this->getHandlerConfiguration($type);
$combinedExtensionConfigurations = NULL;
// adding generic configuration
ArrayHelper::merge($combinedExtensionConfigurations, $extensionConfiguration['extensions']);
// adding handler specific configurations
if (isset($handlerConfiguration['extensions'])) {
ArrayHelper::merge($combinedExtensionConfigurations, $handlerConfiguration['extensions']);
unset($handlerConfiguration['extensions']);
}
$classname = $handlerConfiguration['classname'];
$handler = new $classname($type, $combinedExtensionConfigurations);
$this->handlers[$type] = $handler;
return $handler;
}
private function registerDatasetConfig(array &$datasetConfigs = NULL, $index, DatasetMetaData $dataset = NULL, $columnName = NULL, AbstractConditionSection $condition = NULL) {
if (isset($datasetConfigs[$index])) {
$datasetConfig = $datasetConfigs[$index];
}
else {
// TODO create a class
$datasetConfig = new stdClass();
$datasetConfig->dataset = NULL;
$datasetConfig->usedColumnNames = NULL;
$datasetConfig->conditions = NULL;
$datasetConfigs[$index] = $datasetConfig;
}
if (isset($dataset)) {
if (isset($datasetConfig->dataset)) {
if ($datasetConfig->dataset->name !== $dataset->name) {
throw new IllegalStateException(t(
'Inconsistent dataset configuration: [@datasetName, @tableDatasetName]',
array('@datasetName' => $dataset->publicName, '@tableDatasetName' => $datasetConfig->dataset->publicName)));
}
}
else {
$datasetConfig->dataset = $dataset;
}
}
if (isset($columnName)) {
ArrayHelper::addUniqueValue($datasetConfig->usedColumnNames, $columnName);
}
if (isset($condition)) {
$datasetConfig->conditions[] = $condition;
}
}
public function get(Object $oObject, $aParams = array())
{
if (isset($this->aParams['ToModuleAlias'])) {
Core::import('Modules.' . $this->aParams['ToModuleAlias']);
}
$oMapper = Manager::getInstance()->getMapper($this->aParams['ToMapperAlias']);
$nLimit = 0;
$nOffset = 0;
$aLocCriteria = array($this->aParams['Field'] => $oObject->getId());
$aLocOrder = array('Pos' => 'ASC');
if (count($aParams) > 0) {
if (isset($aParams['Criteria'])) {
foreach ($aParams['Criteria'] as $key => $val) {
$aLocCriteria[$key] = $val;
}
}
if (isset($aParams['Order'])) {
$aLocOrder = $aParams['Order'];
}
if (isset($aParams['Limit'])) {
$nLimit = intval($aParams['Limit']);
}
if (isset($aParams['Offset'])) {
$nOffset = intval($aParams['Offset']);
}
}
$aDefaultParams = isset($this->aParams['Params']) ? $this->aParams['Params'] : array();
return $oMapper->find(ArrayHelper::merge($aDefaultParams, array('Order' => $aLocOrder, 'Criteria' => $aLocCriteria, 'Limit' => $nLimit, 'Offset' => $nOffset)));
}
public function prepareDataProvider()
{
$params = \Yii::$app->request->queryParams;
//print_r($params);die();
$model = new $this->modelClass();
// I'm using yii\base\Model::getAttributes() here
// In a real app I'd rather properly assign
// $model->scenario then use $model->safeAttributes() instead
$modelAttr = $model->attributes;
// this will hold filtering attrs pairs ( 'name' => 'value' )
$search = [];
if (!empty($params)) {
foreach ($params as $key => $value) {
// In case if you don't want to allow wired requests
// holding 'objects', 'arrays' or 'resources'
if (!is_scalar($key) or !is_scalar($value)) {
throw new BadRequestHttpException('Bad Request');
}
// if the attr name is not a reserved Keyword like 'q' or 'sort' and
// is matching one of models attributes then we need it to filter results
if (!in_array(strtolower($key), $this->reservedParams) && ArrayHelper::keyExists($key, $modelAttr, false)) {
$search[$key] = $value;
}
}
}
// you may implement and return your 'ActiveDataProvider' instance here.
// in my case I prefer using the built in Search Class generated by Gii which is already
// performing validation and using 'like' whenever the attr is expecting a 'string' value.
$searchByAttr['ProductSearch'] = $search;
$lat = isset($params['lat']) ? $params['lat'] : 18.509111;
$lon = isset($params['lon']) ? $params['lon'] : -69.8468487;
$model = new Categorias();
$searchModel = $model->find()->all();
return $searchModel;
}
public function formatRecord(array &$records = NULL, $record)
{
$result = parent::formatRecord($records, $record);
if ($result) {
$this->errorUnsupportedChainOfResultFormatters();
}
$recordKey = NULL;
foreach ($this->keyColumnNames as $columnName) {
$recordKey[] = isset($record[$columnName]) ? $record[$columnName] : NULL;
}
$key = ArrayHelper::prepareCompositeKey($recordKey);
if (isset($records[$key])) {
if ($this->isColumnValueUnique) {
throw new IllegalArgumentException(t('Found several records for the key: @key', array('@key' => ArrayHelper::printArray($recordKey, ', ', TRUE, TRUE))));
}
$records[$key][] = $record;
} else {
if ($this->isColumnValueUnique) {
$records[$key] = $record;
} else {
$records[$key][] = $record;
}
}
return TRUE;
}
public function assemble(AbstractSQLDataSourceQueryHandler $datasourceHandler, DataControllerCallContext $callcontext, DatasetMetaData $dataset, array $columnNames = NULL)
{
$statement = new Statement();
$requestedColumnNames = self::prepareRequestedColumnNames($columnNames);
ArrayHelper::mergeArrays($statement->tables, self::prepareTableSections4Statement($datasourceHandler, $callcontext, $requestedColumnNames, TRUE));
return $statement;
}
protected function collectReferencedFormulaNames(AbstractQueryRequest $request) {
$usedFormulaNames = NULL;
// checking dimensions
if (isset($request->dimensions)) {
foreach ($request->dimensions as $dimension) {
$dimensionName = $dimension->name;
if ($request->findFormula($dimensionName) != NULL) {
ArrayHelper::addUniqueValue($usedFormulaNames, $dimensionName);
}
}
}
// checking measures
if (isset($request->measures)) {
foreach ($request->measures as $measure) {
$measureName = $measure->name;
if ($request->findFormula($measureName) != NULL) {
ArrayHelper::addUniqueValue($usedFormulaNames, $measureName);
}
}
}
// checking conditions
if (isset($request->queries)) {
foreach ($request->queries as $query) {
$name = $query->name;
if ($request->findFormula($name) != NULL) {
ArrayHelper::addUniqueValue($usedFormulaNames, $name);
}
}
}
return $usedFormulaNames;
}
/**
* @inheritDoc IFieldType::prepValue()
*
* @param mixed $value
*
* @return mixed
*/
public function prepValue($value)
{
$selectedValues = ArrayHelper::stringToArray($value);
if ($this->multi) {
if (is_array($value)) {
// Convert all the values to OptionData objects
foreach ($value as &$val) {
$label = $this->getOptionLabel($val);
$val = new OptionData($label, $val, true);
}
} else {
$value = array();
}
$value = new MultiOptionsFieldData($value);
} else {
// Convert the value to a SingleOptionFieldData object
$label = $this->getOptionLabel($value);
$value = new SingleOptionFieldData($label, $value, true);
}
$options = array();
foreach ($this->getOptions() as $option) {
$selected = in_array($option['value'], $selectedValues);
$options[] = new OptionData($option['label'], $option['value'], $selected);
}
$value->setOptions($options);
return $value;
}
protected function collectReferencedFormulaNames(AbstractQueryRequest $request) {
$usedFormulaNames = NULL;
// checking conditions
if (isset($request->queries)) {
foreach ($request->queries as $index => $query) {
foreach ($query as $columnName => $values) {
if ($request->findFormula($columnName) != NULL) {
ArrayHelper::addUniqueValue($usedFormulaNames, $columnName);
}
}
}
}
// checking columns
if ($request instanceof DatasetQueryRequest) {
if (isset($request->columns)) {
foreach ($request->columns as $columnName) {
if ($request->findFormula($columnName) != NULL) {
ArrayHelper::addUniqueValue($usedFormulaNames, $columnName);
}
}
}
}
return $usedFormulaNames;
}
public function initiateHandler($operatorName)
{
$values = func_get_args();
array_shift($values);
$handlerConfiguration = $this->getHandlerConfiguration($operatorName);
$classname = $handlerConfiguration['handler']['classname'];
$handlerClass = new ReflectionClass($classname);
$params = NULL;
// first parameter is the operator configuration
$operatorMetaData = $this->getOperatorMetaData($operatorName);
$params[] = $operatorMetaData;
// next are parameters which represent values
if (count($values) === 1 && is_array($values[0])) {
$parameterCount = count($values[0]);
$expectedMinimumParameterCount = isset($operatorMetaData) ? $operatorMetaData->getRequiredParameterCount() : 0;
$expectedTotalParameterCount = isset($operatorMetaData) ? $operatorMetaData->getParameterCount() : 0;
if ($parameterCount == $expectedTotalParameterCount) {
ArrayHelper::mergeArrays($params, $values[0]);
} elseif ($expectedTotalParameterCount === 1) {
$params[] = $values[0];
} elseif ($parameterCount < $expectedTotalParameterCount && $parameterCount >= $expectedMinimumParameterCount) {
// we have some optional parameters which do not need to be provided
ArrayHelper::mergeArrays($params, $values[0]);
} else {
throw new IllegalArgumentException(t("Inconsistent number of arguments for '@name' operator", array('@name' => $operatorName)));
}
} else {
ArrayHelper::mergeArrays($params, $values);
}
return $handlerClass->newInstanceArgs($params);
}
public function __clone() {
parent::__clone();
$this->datasets = ArrayHelper::copy($this->datasets);
$this->references = ArrayHelper::copy($this->references);
$this->cubes = ArrayHelper::copy($this->cubes);
}
protected function processMetaModelFilters(array &$processedFilters = NULL, array $filters = NULL)
{
if (!isset($filters)) {
return;
}
foreach ($filters as $className => $properties) {
foreach ($properties as $propertyName => $values) {
$uniqueValues = isset($processedFilters[$className][$propertyName]) ? $processedFilters[$className][$propertyName] : NULL;
if ($uniqueValues === FALSE) {
// this property should be ignored
} else {
foreach ($values as $value) {
if (isset($value)) {
ArrayHelper::addUniqueValue($uniqueValues, $value);
} else {
// if there is at least one NULL value we ignore the property completely
$uniqueValues = FALSE;
break;
}
}
}
$processedFilters[$className][$propertyName] = $uniqueValues;
}
}
}
/**
* Convert display date for saving to model
*
* @returns JSON encoded HTML output
*/
public function actionConvert()
{
$output = '';
$module = Yii::$app->controller->module;
$post = Yii::$app->request->post();
if (isset($post['displayDate'])) {
$type = empty($post['type']) ? Module::FORMAT_DATE : $post['type'];
$saveFormat = ArrayHelper::getValue($post, 'saveFormat');
$dispFormat = ArrayHelper::getValue($post, 'dispFormat');
$dispTimezone = ArrayHelper::getValue($post, 'dispTimezone');
$saveTimezone = ArrayHelper::getValue($post, 'saveTimezone');
if ($dispTimezone != null) {
$date = DateTime::createFromFormat($dispFormat, $post['displayDate'], new DateTimeZone($dispTimezone));
} else {
$date = DateTime::createFromFormat($dispFormat, $post['displayDate']);
}
if (empty($date) || !$date) {
$value = '';
} elseif ($saveTimezone != null) {
$date->setTimezone(new DateTimeZone($saveTimezone))->format($saveFormat);
} else {
$value = $date->format($saveFormat);
}
echo Json::encode(['status' => 'success', 'output' => $value]);
} else {
echo Json::encode(['status' => 'error', 'output' => 'No display date found']);
}
}
public function serialize(AbstractQueryRequest $request) {
$parameters = parent::serialize($request);
$columns = NULL;
// preparing dimension-related column
if (isset($request->dimensions)) {
foreach ($request->dimensions as $dimension) {
if (isset($dimension->requestColumnIndex)) {
$columns[] = ParameterNameHelper::assemble($dimension->name);
}
if (isset($dimension->columns)) {
foreach ($dimension->columns as $column) {
$columns[] = ParameterNameHelper::assemble($dimension->name, $column->name);
}
}
}
}
// preparing measure-related columns
if (isset($request->measures)) {
foreach ($request->measures as $measure) {
$columns[] = $measure->name;
}
}
// serializing columns
if (isset($columns)) {
ArrayHelper::merge(
$parameters,
$this->serializeValue(
DataQueryControllerUIParameterNames::COLUMNS,
DataQueryControllerUIRequestPreparer::prepareColumns($columns)));
}
// serializing query
if (isset($request->queries)) {
$queryParameters = NULL;
foreach ($request->queries as $query) {
if ($query instanceof __AbstractCubeQueryRequest_DimensionQuery) {
if (isset($query->columns)) {
foreach ($query->columns as $column) {
ArrayHelper::merge(
$queryParameters,
DataQueryControllerUIRequestPreparer::prepareParameter(
ParameterNameHelper::assemble($query->name, $column->name),
$column->values));
}
}
}
elseif ($query instanceof __AbstractCubeQueryRequest_FactsDatasetColumnQuery) {
ArrayHelper::merge($queryParameters, DataQueryControllerUIRequestPreparer::prepareParameter($query->name, $query->values));
}
elseif ($query instanceof __AbstractCubeQueryRequest_MeasureQuery) {
ArrayHelper::merge($queryParameters, DataQueryControllerUIRequestPreparer::prepareParameter($query->name, $query->values));
}
}
ArrayHelper::merge($parameters, $this->serializeValue(DataQueryControllerUIParameterNames::PARAMETERS, $queryParameters));
}
return $parameters;
}
public function __clone()
{
parent::__clone();
$this->cachedPropertyNameMappings = ArrayHelper::cloneArray($this->cachedPropertyNameMappings);
if (isset($this->parent)) {
$this->parent = clone $this->parent;
}
}
public function __construct(array $data = NULL, $keyColumnNames = NULL, $columnPrefix = NULL, $columnSuffix = NULL)
{
parent::__construct();
$this->keyColumnNames = ArrayHelper::toArray($keyColumnNames);
$this->columnPrefix = $columnPrefix;
$this->columnSuffix = $columnSuffix;
$this->data = $data;
}
/**
* Получить массив собранных данных
* @param array $condition
* @return array
*/
public static function listData($condition = [])
{
$query = self::find();
if ($condition) {
$query->where($condition[0], !empty($condition[1]) ? $condition[1] : []);
}
return ArrayHelper::map($query->all(), 'id', 'title');
}
public function __clone()
{
parent::__clone();
$this->groupByPropertyNames = ArrayHelper::cloneArray($this->groupByPropertyNames);
$this->subjectPropertyNames = ArrayHelper::cloneArray($this->subjectPropertyNames);
$this->adjustedGroupByPropertyNames = ArrayHelper::cloneArray($this->adjustedGroupByPropertyNames);
$this->adjustedSubjectPropertyNames = ArrayHelper::cloneArray($this->adjustedSubjectPropertyNames);
}
public function __clone() {
parent::__clone();
$this->groupByColumnNames = ArrayHelper::copy($this->groupByColumnNames);
$this->subjectColumnNames = ArrayHelper::copy($this->subjectColumnNames);
$this->formattedGroupByColumnNames = ArrayHelper::copy($this->formattedGroupByColumnNames);
$this->formattedSubjectColumnNames = ArrayHelper::copy($this->formattedSubjectColumnNames);
}
public function renderContent()
{
$user_id = Yii::app()->user->id;
$sql = "SELECT DISTINCT users.id\n FROM users\n INNER JOIN messages\n ON (messages.to_user_id = {$user_id} OR messages.from_user_id = {$user_id})\n ORDER BY messages.date_create";
$users_ids = Yii::app()->db->createCommand($sql)->queryAll();
$users_ids = ArrayHelper::extract($users_ids, 'id');
$this->render('MessageDialogsSidebar', array('users' => User::model()->findAllByPk($users_ids)));
}
public function actionAssign($id)
{
$incoming = $this->loadModel($id);
$endpoint = new Endpoint();
$deptList = ArrayHelper::map(\app\models\Department::getAll(), 'id', 'name');
return $this->render('assign', ['incoming' => $incoming, 'endpoint' => $endpoint, 'deptList' => $deptList]);
}
