/**
* Sets the layout's tabs.
*
* @param array $tabs
*
* @return null
*/
public function setTabs($tabs)
{
$this->_tabs = array();
foreach ($tabs as $tab) {
if (is_array($tab)) {
$tab = new FieldLayoutTabModel($tab);
}
$tab->setLayout($this);
$this->_tabs[] = $tab;
}
}
/**
* Saves a block type.
*
* @param MatrixBlockTypeModel $blockType The block type to be saved.
* @param bool $validate Whether the block type should be validated before being saved.
* Defaults to `true`.
*
* @throws \Exception
* @return bool Whether the block type was saved successfully.
*/
public function saveBlockType(MatrixBlockTypeModel $blockType, $validate = true)
{
if (!$validate || $this->validateBlockType($blockType)) {
$transaction = craft()->db->getCurrentTransaction() === null ? craft()->db->beginTransaction() : null;
try {
$contentService = craft()->content;
$fieldsService = craft()->fields;
$originalFieldContext = $contentService->fieldContext;
$originalFieldColumnPrefix = $contentService->fieldColumnPrefix;
$originalOldFieldColumnPrefix = $fieldsService->oldFieldColumnPrefix;
// Get the block type record
$blockTypeRecord = $this->_getBlockTypeRecord($blockType);
$isNewBlockType = $blockType->isNew();
if (!$isNewBlockType) {
// Get the old block type fields
$oldBlockTypeRecord = MatrixBlockTypeRecord::model()->findById($blockType->id);
$oldBlockType = MatrixBlockTypeModel::populateModel($oldBlockTypeRecord);
$contentService->fieldContext = 'matrixBlockType:' . $blockType->id;
$contentService->fieldColumnPrefix = 'field_' . $oldBlockType->handle . '_';
$fieldsService->oldFieldColumnPrefix = 'field_' . $oldBlockType->handle . '_';
$oldFieldsById = array();
foreach ($oldBlockType->getFields() as $field) {
$oldFieldsById[$field->id] = $field;
}
// Figure out which ones are still around
foreach ($blockType->getFields() as $field) {
if (!$field->isNew()) {
unset($oldFieldsById[$field->id]);
}
}
// Drop the old fields that aren't around anymore
foreach ($oldFieldsById as $field) {
$fieldsService->deleteField($field);
}
// Refresh the schema cache
craft()->db->getSchema()->refresh();
}
// Set the basic info on the new block type record
$blockTypeRecord->fieldId = $blockType->fieldId;
$blockTypeRecord->name = $blockType->name;
$blockTypeRecord->handle = $blockType->handle;
$blockTypeRecord->sortOrder = $blockType->sortOrder;
// Save it, minus the field layout for now
$blockTypeRecord->save(false);
if ($isNewBlockType) {
// Set the new ID on the model
$blockType->id = $blockTypeRecord->id;
}
// Save the fields and field layout
// -------------------------------------------------------------
$fieldLayoutFields = array();
$sortOrder = 0;
// Resetting the fieldContext here might be redundant if this isn't a new blocktype but whatever
$contentService->fieldContext = 'matrixBlockType:' . $blockType->id;
$contentService->fieldColumnPrefix = 'field_' . $blockType->handle . '_';
foreach ($blockType->getFields() as $field) {
// Hack to allow blank field names
if (!$field->name) {
$field->name = '__blank__';
}
if (!$fieldsService->saveField($field, false)) {
throw new Exception(Craft::t('An error occurred while saving this Matrix block type.'));
}
$fieldLayoutField = new FieldLayoutFieldModel();
$fieldLayoutField->fieldId = $field->id;
$fieldLayoutField->required = $field->required;
$fieldLayoutField->sortOrder = ++$sortOrder;
$fieldLayoutFields[] = $fieldLayoutField;
}
$contentService->fieldContext = $originalFieldContext;
$contentService->fieldColumnPrefix = $originalFieldColumnPrefix;
$fieldsService->oldFieldColumnPrefix = $originalOldFieldColumnPrefix;
$fieldLayoutTab = new FieldLayoutTabModel();
$fieldLayoutTab->name = 'Content';
$fieldLayoutTab->sortOrder = 1;
$fieldLayoutTab->setFields($fieldLayoutFields);
$fieldLayout = new FieldLayoutModel();
$fieldLayout->type = ElementType::MatrixBlock;
$fieldLayout->setTabs(array($fieldLayoutTab));
$fieldLayout->setFields($fieldLayoutFields);
$fieldsService->saveLayout($fieldLayout);
// Update the block type model & record with our new field layout ID
$blockType->setFieldLayout($fieldLayout);
$blockType->fieldLayoutId = $fieldLayout->id;
$blockTypeRecord->fieldLayoutId = $fieldLayout->id;
// Update the block type with the field layout ID
$blockTypeRecord->save(false);
if (!$isNewBlockType) {
// Delete the old field layout
$fieldsService->deleteLayoutById($oldBlockType->fieldLayoutId);
}
if ($transaction !== null) {
$transaction->commit();
}
} catch (\Exception $e) {
if ($transaction !== null) {
$transaction->rollback();
}
throw $e;
}
return true;
} else {
return false;
}
}
/**
* Assembles a field layout.
*
* @param array $postedFieldLayout
* @param array|null $requiredFields
*
* @return FieldLayoutModel
*/
public function assembleLayout($postedFieldLayout, $requiredFields)
{
$tabs = array();
$fields = array();
$tabSortOrder = 0;
foreach ($postedFieldLayout as $tabName => $fieldIds) {
$tabFields = array();
$tabSortOrder++;
foreach ($fieldIds as $fieldSortOrder => $fieldId) {
$field = new FieldLayoutFieldModel();
$field->fieldId = $fieldId;
$field->required = in_array($fieldId, $requiredFields);
$field->sortOrder = $fieldSortOrder + 1;
$fields[] = $field;
$tabFields[] = $field;
}
$tab = new FieldLayoutTabModel();
$tab->name = urldecode($tabName);
$tab->sortOrder = $tabSortOrder;
$tab->setFields($tabFields);
$tabs[] = $tab;
}
$layout = new FieldLayoutModel();
$layout->setTabs($tabs);
$layout->setFields($fields);
return $layout;
}
/**
* Sets the layout's tabs.
*
* @param array $tabs
*/
public function setTabs($tabs)
{
$this->_tabs = FieldLayoutTabModel::populateModels($tabs);
}
/**
* Attempt to import a field layout.
*
* @param array $fieldLayoutDef
*
* @return FieldLayoutModel
*/
private function _importFieldLayout(array $fieldLayoutDef)
{
$layoutTabs = array();
$layoutFields = array();
if (array_key_exists('tabs', $fieldLayoutDef)) {
$tabSortOrder = 0;
foreach ($fieldLayoutDef['tabs'] as $tabName => $tabDef) {
$layoutTabFields = array();
foreach ($tabDef as $fieldHandle => $required) {
$fieldSortOrder = 0;
$field = craft()->fields->getFieldByHandle($fieldHandle);
if ($field) {
$layoutField = new FieldLayoutFieldModel();
$layoutField->setAttributes(array('fieldId' => $field->id, 'required' => $required, 'sortOrder' => ++$fieldSortOrder));
$layoutTabFields[] = $layoutField;
$layoutFields[] = $layoutField;
}
}
$layoutTab = new FieldLayoutTabModel();
$layoutTab->setAttributes(array('name' => $tabName, 'sortOrder' => ++$tabSortOrder));
$layoutTab->setFields($layoutTabFields);
$layoutTabs[] = $layoutTab;
}
} else {
if (array_key_exists('fields', $fieldLayoutDef)) {
$fieldSortOrder = 0;
foreach ($fieldLayoutDef['fields'] as $fieldHandle => $required) {
$field = craft()->fields->getFieldByHandle($fieldHandle);
if ($field) {
$layoutField = new FieldLayoutFieldModel();
$layoutField->setAttributes(array('fieldId' => $field->id, 'required' => $required, 'sortOrder' => ++$fieldSortOrder));
$layoutFields[] = $layoutField;
}
}
}
}
$fieldLayout = new FieldLayoutModel();
$fieldLayout->type = ElementType::Entry;
$fieldLayout->setTabs($layoutTabs);
$fieldLayout->setFields($layoutFields);
return $fieldLayout;
}
/**
* Add fields to Set's layout.
*
* @param array $fields Array filled with FieldLayoutFieldModel.
*/
private function _addFieldsToLayout($fields)
{
$oldLayout = false;
$newLayout = $this->_globalSet->getFieldLayout();
$layoutTabs = array();
$layoutFields = array();
// Delete old layout if available
if ($this->_globalSet->fieldLayoutId) {
$oldLayout = $this->_globalSet->getFieldLayout();
// Overwrite variables
$layoutTabs = $oldLayout->getTabs();
$layoutFields = $oldLayout->getFields();
}
// Create layout
if (!count($layoutTabs)) {
// Nothing is set, so we have to create it
$tab = new FieldLayoutTabModel();
$tab->name = Craft::t('Content');
$tab->sortOrder = 1;
$tab->setFields($fields);
$layoutTabs[] = $tab;
// Add fields to layout
foreach ($fields as $field) {
$layoutFields[] = $field;
}
} else {
// Update existing information
foreach ($layoutTabs as $tab) {
// Add fields to first tab
if ($tab === reset($layoutTabs)) {
$tabFields = $tab->getFields();
$sortOrder = count($tabFields) + 1;
foreach ($fields as $field) {
// Update position for added field
$field->sortOrder = $sortOrder;
// Add field to tab and layout
$tabFields[] = $field;
$layoutFields[] = $field;
// Update order
$sortOrder++;
}
$tab->setFields($tabFields);
}
}
}
$newLayout->setTabs($layoutTabs);
$newLayout->setFields($layoutFields);
// Delete old layout
if ($oldLayout !== false) {
craft()->fields->deleteLayoutById($oldLayout->id);
}
// Set new layout
$this->_globalSet->setFieldLayout($newLayout);
}
/**
* Save a field.
*/
public function actionSaveField()
{
$this->requirePostRequest();
// Make sure our field has a section
// @TODO - handle this much more gracefully
$tabId = craft()->request->getPost('tabId');
// Get the Form these fields are related to
$formId = craft()->request->getRequiredPost('formId');
$form = sproutForms()->forms->getFormById($formId);
$field = new FieldModel();
$field->id = craft()->request->getPost('fieldId');
$field->name = craft()->request->getRequiredPost('name');
$field->handle = craft()->request->getRequiredPost('handle');
$field->instructions = craft()->request->getPost('instructions');
$field->required = craft()->request->getPost('required');
$field->translatable = (bool) craft()->request->getPost('translatable');
$field->type = craft()->request->getRequiredPost('type');
$typeSettings = craft()->request->getPost('types');
if (isset($typeSettings[$field->type])) {
$field->settings = $typeSettings[$field->type];
}
// Set our field context
craft()->content->fieldContext = $form->getFieldContext();
craft()->content->contentTable = $form->getContentTable();
// Does our field validate?
if (!craft()->fields->validateField($field)) {
SproutFormsPlugin::log("Field does not validate.");
// Send the field back to the template
craft()->urlManager->setRouteVariables(array('field' => $field));
// Route our request back to the field template
$route = craft()->urlManager->parseUrl(craft()->request);
craft()->runController($route);
craft()->end();
}
// Save a new field
if (!$field->id) {
SproutFormsPlugin::log('New Field');
$isNewField = true;
} else {
SproutFormsPlugin::log('Existing Field');
$isNewField = false;
}
// Save our field
craft()->fields->saveField($field);
// Now let's add this field to our field layout
// ------------------------------------------------------------
// Set the field layout
$oldFieldLayout = $form->getFieldLayout();
$oldFields = $oldFieldLayout->getFields();
$oldTabs = $oldFieldLayout->getTabs();
$tabFields = array();
$postedFieldLayout = array();
$requiredFields = array();
// If no tabs exist, let's create a
// default one for all of our fields
if (!$oldTabs) {
// Create a tab
$fieldLayoutTab = new FieldLayoutTabModel();
$fieldLayoutTab->name = Craft::t('Form');
$fieldLayoutTab->sortOrder = 1;
if ($oldFields) {
$fieldSortOrder = 0;
// Add any existing fields to a default tab
foreach ($oldFields as $oldFieldLayoutField) {
$fieldSortOrder++;
$newField = new FieldLayoutFieldModel();
$newField->fieldId = $oldFieldLayoutField->fieldId;
$newField->required = $oldFieldLayoutField->required;
$newField->sortOrder = $fieldSortOrder;
$tabFields[] = $newField;
$postedFieldLayout[$fieldLayoutTab->name][] = $oldFieldLayoutField->fieldId;
if ($oldFieldLayoutField->required) {
$requiredFields[] = $oldFieldLayoutField->fieldId;
}
}
}
// Add our new field
$postedFieldLayout[$fieldLayoutTab->name][] = $field->id;
$fieldLayoutTab->setFields($tabFields);
} else {
foreach ($oldTabs as $oldTab) {
$oldTabFields = $oldTab->getFields();
foreach ($oldTabFields as $oldFieldLayoutField) {
$postedFieldLayout[$oldTab->name][] = $oldFieldLayoutField->fieldId;
if ($oldFieldLayoutField->required) {
$requiredFields[] = $oldFieldLayoutField->fieldId;
}
}
// Add our new field to the tab it belongs to
if ($isNewField && $tabId == $oldTab->id) {
$postedFieldLayout[$oldTab->name][] = $field->id;
}
}
}
// Set the field layout
$fieldLayout = craft()->fields->assembleLayout($postedFieldLayout, $requiredFields);
$fieldLayout->type = 'SproutForms_Form';
$form->setFieldLayout($fieldLayout);
// Hand the field off to be saved in the
// field layout of our Form Element
if (sproutForms()->forms->saveForm($form)) {
SproutFormsPlugin::log('Field Saved');
craft()->userSession->setNotice(Craft::t('Field saved.'));
$this->redirectToPostedUrl($field);
} else {
SproutFormsPlugin::log("Couldn't save field.");
craft()->userSession->setError(Craft::t('Couldn’t save field.'));
// Send the field back to the template
craft()->urlManager->setRouteVariables(array('field' => $field));
}
}