static $meta = array(

'table' => FORM_SEC_TABLE,

'ordering' => array('title'),

'pk' => array('id'),

'joins' => array(

'fields' => array(

'reverse' => 'DynamicFormField.form',

),

),

);

// Registered form types

static $types = array(

'T' => 'Ticket Information',

'U' => 'User Information',

'O' => 'Organization Information',

);

const FLAG_DELETABLE = 0x0001;

const FLAG_DELETED = 0x0002;

var $_form;

var $_fields;

var $_has_data = false;

var $_dfields;

function getInfo() {

$base = $this->ht;

unset($base['fields']);

return $base;

}

function getId() {

return $this->id;

}

/**

function getFields() {

if (!$this->_fields) {

$this->_fields = new ListObject();

foreach ($this->getDynamicFields() as $f)

$this->_fields->append($f->getImpl($f));

}

return $this->_fields;

}

/**

function getDynamicFields() {

return $this->fields;

}

// Multiple inheritance -- delegate methods not defined to a forms API

// Form

function __call($what, $args) {

$delegate = array($this->getForm(), $what);

if (!is_callable($delegate))

throw new Exception(sprintf(__('%s: Call to non-existing function'), $what));

return call_user_func_array($delegate, $args);

}

function getTitle() {

return $this->getLocal('title');

}

function getInstructions() {

return $this->getLocal('instructions');

}

/**

function reset() {

foreach ($this->getFields() as $f)

$f->reset();

return $this;

}

function getForm($source=false) {

if ($source)

$this->reset();

$fields = $this->getFields();

$form = new SimpleForm($fields, $source, array(

'title' => $this->getLocal('title'),

'instructions' => Format::htmldecode($this->getLocal('instructions')),

'id' => $this->getId(),

'type' => $this->type ?: null,

));

return $form;

}

function hasFlag($flag) {

return (isset($this->flags) && ($this->flags & $flag) != 0);

}

function isDeleted() {

return $this->hasFlag(self::FLAG_DELETED);

}

function isDeletable() {

return $this->hasFlag(self::FLAG_DELETABLE);

}

function setFlag($flag) {

$this->flags |= $flag;

}

function hasAnyVisibleFields($user=false) {

global $thisstaff, $thisclient;

$user = $user ?: $thisstaff ?: $thisclient;

$visible = 0;

$isstaff = $user instanceof Staff;

foreach ($this->getFields() as $F) {

if ($isstaff) {

if ($F->isVisibleToStaff())

$visible++;

}

elseif ($F->isVisibleToUsers()) {

$visible++;

}

}

return $visible > 0;

}

function instanciate($sort=1, $data=null) {

$inst = DynamicFormEntry::create(

array('form_id'=>$this->get('id'), 'sort'=>$sort)

);

if ($data)

$inst->setSource($data);

$inst->_fields = $this->_fields ?: null;

return $inst;

}

function disableFields(array $ids) {

foreach ($this->getFields() as $F) {

if (in_array($F->get('id'), $ids)) {

$F->disable();

}

}

}

function getTranslateTag($subtag) {

return _H(sprintf('form.%s.%s', $subtag, $this->id));

}

function getLocal($subtag) {

$tag = $this->getTranslateTag($subtag);

$T = CustomDataTranslation::translate($tag);

return $T != $tag ? $T : $this->get($subtag);

}

function save($refetch=false) {

if (count($this->dirty))

$this->set('updated', new SqlFunction('NOW'));

if ($rv = parent::save($refetch || $this->dirty))

return $this->saveTranslations();

return $rv;

}

function delete() {

if (!$this->isDeletable())

return false;

// Soft Delete: Mark the form as deleted.

$this->setFlag(self::FLAG_DELETED);

$type = array('type' => 'deleted');

Signal::send('object.deleted', $this, $type);

return $this->save();

}

function getExportableFields($exclude=array(), $prefix='__') {

$fields = array();

foreach ($this->getFields() as $f) {

// Ignore core fields

if ($exclude && in_array($f->get('name'), $exclude))

continue;

// Ignore non-data fields

// FIXME: Consider ::isStorable() too

elseif (!$f->hasData() || $f->isPresentationOnly())

continue;

$name = $f->get('name') ?: ('field_'.$f->get('id'));

$fields[$prefix.$name] = $f;

}

return $fields;

}

static function create($ht=false) {

$inst = new static($ht);

$inst->set('created', new SqlFunction('NOW'));

if (isset($ht['fields'])) {

$inst->save();

foreach ($ht['fields'] as $f) {

$field = DynamicFormField::create(array('form' => $inst) + $f);

$field->save();

}

}

return $inst;

}

function saveTranslations($vars=false) {

global $thisstaff;

$vars = $vars ?: $_POST;

$tags = array(

'title' => $this->getTranslateTag('title'),

'instructions' => $this->getTranslateTag('instructions'),

);

$rtags = array_flip($tags);

$translations = CustomDataTranslation::allTranslations($tags, 'phrase');

foreach ($translations as $t) {

$T = $rtags[$t->object_hash];

$content = @$vars['trans'][$t->lang][$T];

if (!isset($content))

continue;

// Content is not new and shouldn't be added below

unset($vars['trans'][$t->lang][$T]);

$t->text = $content;

$t->agent_id = $thisstaff->getId();

$t->updated = SqlFunction::NOW();

if (!$t->save())

return false;

}

// New translations (?)

if ($vars['trans'] && is_array($vars['trans'])) {

foreach ($vars['trans'] as $lang=>$parts) {

if (!Internationalization::isLanguageEnabled($lang))

continue;

foreach ($parts as $T => $content) {

$content = trim($content);

if (!$content)

continue;

$t = CustomDataTranslation::create(array(

'type' => 'phrase',

'object_hash' => $tags[$T],

'lang' => $lang,

'text' => $content,

'agent_id' => $thisstaff->getId(),

'updated' => SqlFunction::NOW(),

));

if (!$t->save())

return false;

}

}

}

return true;

}

static function getNewInstance() {

return static::objects()

->one()

->instanciate();

}

static function rebuildDynamicDataViews() {

// Flush the object cache

ModelInstanceManager::flushCache();

return self::ensureDynamicDataViews(true, true);

}

// ensure cdata tables exists

static function ensureDynamicDataViews($build=true, $force=false) {

$forms = ['TicketForm', 'TaskForm', 'UserForm', 'OrganizationForm'];

foreach ($forms as $form) {

if ($force && $build)

$form::dropDynamicDataView(false);

$form::ensureDynamicDataView($build);

}

}

static function ensureCdataTables($obj, $data) {

// Only perfrom check on real cron call, not autocrons triggered on

// agents activity.

if ($data['autocron'] === false)

self::ensureDynamicDataViews(true);

}

static function ensureDynamicDataView($build=false, $croak=true) {

if (!($cdata=static::$cdata) || !$cdata['table'])

return false;

$sql = 'SHOW TABLES LIKE \''.$cdata['table'].'\'';

// Return true if the cdata table exists

if (db_num_rows(db_query($sql)))

return true;

if (!$build && $croak)

die(sprintf('%s. %s.',

__('Missing CDATA table'),

__('Get technical support')));

return $build ? static::buildDynamicDataView($cdata) : false;

}

static function buildDynamicDataView($cdata) {

$sql = 'CREATE TABLE IF NOT EXISTS `'.$cdata['table'].'` (PRIMARY KEY

('.$cdata['object_id'].')) DEFAULT CHARSET=utf8 AS '

. static::getCrossTabQuery( $cdata['object_type'], $cdata['object_id']);

db_query($sql);

}

static function dropDynamicDataView($rebuild=true) {

if (!($cdata=static::$cdata) || !$cdata['table'])

return false;

$sql = 'DROP TABLE IF EXISTS `'.$cdata['table'].'`';

if (!db_query($sql))

return false;

return $rebuild ? static::ensureDynamicDataView($rebuild, false) :

true;

}

static function updateDynamicDataView($answer, $data) {

// TODO: Detect $data['dirty'] for value and value_id

// We're chiefly concerned with Ticket form answers

$cdata = static::$cdata;

if (!$cdata

|| !$cdata['table']

|| !($e = $answer->getEntry())

|| $e->form->get('type') != $cdata['object_type'])

return;

// $record = array();

// $record[$f] = $answer->value'

// TicketFormData::objects()->filter(array('ticket_id'=>$a))

// ->merge($record);

$sql = 'SHOW TABLES LIKE \''.$cdata['table'].'\'';

if (!db_num_rows(db_query($sql)))

return;

$f = $answer->getField();

$name = $f->get('name') ? $f->get('name')

: 'field_'.$f->get('id');

$fields = sprintf('`%s`=', $name) . db_input($answer->getSearchKeys());

$sql = 'INSERT INTO `'.$cdata['table'].'` SET '.$fields

. sprintf(', `%s`= %s',

$cdata['object_id'],

db_input($answer->getEntry()->get('object_id')))

.' ON DUPLICATE KEY UPDATE '.$fields;

db_query($sql);

}

static function updateDynamicFormEntryAnswer($answer, $data) {

if (!$answer

|| !($e = $answer->getEntry())

|| !$e->form)

return;

switch ($e->form->get('type')) {

case 'T':

return TicketForm::updateDynamicDataView($answer, $data);

case 'A':

return TaskForm::updateDynamicDataView($answer, $data);

case 'U':

return UserForm::updateDynamicDataView($answer, $data);

case 'O':

return OrganizationForm::updateDynamicDataView($answer, $data);

}

}

static function updateDynamicFormField($field, $data) {

if (!$field || !$field->form)

return;

switch ($field->form->get('type')) {

case 'T':

return TicketForm::dropDynamicDataView();

case 'A':

return TaskForm::dropDynamicDataView();

case 'U':

return UserForm::dropDynamicDataView();

case 'O':

return OrganizationForm::dropDynamicDataView();

}

}

static function getCrossTabQuery($object_type, $object_id='object_id', $exclude=array()) {

$fields = static::getDynamicDataViewFields($exclude);

return "SELECT entry.`object_id` as `$object_id`, ".implode(',', $fields)

.' FROM '.FORM_ENTRY_TABLE.' entry

JOIN '.FORM_ANSWER_TABLE.' ans ON ans.entry_id = entry.id

JOIN '.FORM_FIELD_TABLE." field ON field.id=ans.field_id

WHERE entry.object_type='$object_type' GROUP BY entry.object_id";

}

// Materialized View for custom data (MySQL FlexViews would be nice)

//

// @see http://code.google.com/p/flexviews/

static function getDynamicDataViewFields($exclude) {

$fields = array();

foreach (static::getNewInstance()->getFields() as $f) {

if ($exclude && in_array($f->get('name'), $exclude))

continue;

$impl = $f->getImpl($f);

if (!$impl->hasData() || $impl->isPresentationOnly())

continue;

$id = $f->get('id');

$name = ($f->get('name')) ? $f->get('name')

: 'field_'.$id;

if ($impl instanceof ChoiceField || $impl instanceof SelectionField) {

$fields[] = sprintf(

'MAX(CASE WHEN field.id=\'%1$s\' THEN REPLACE(REPLACE(REPLACE(REPLACE(coalesce(ans.value_id, ans.value), \'{\', \'\'), \'}\', \'\'), \'"\', \'\'), \':\', \',\') ELSE NULL END) as `%2$s`',

$id, $name);

}

else {

$fields[] = sprintf(

'MAX(IF(field.id=\'%1$s\',coalesce(ans.value_id, ans.value),NULL)) as `%2$s`',

$id, $name);

}

}

return $fields;

}

static $instance;

static $form;

static $cdata = array(

'table' => USER_CDATA_TABLE,

'object_id' => 'user_id',

'object_type' => ObjectModel::OBJECT_TYPE_USER,

);

static function objects() {

$os = parent::objects();

return $os->filter(array('type'=>'U'));

}

static function getUserForm() {

if (!isset(static::$form)) {

static::$form = static::objects()->one();

}

return static::$form;

}

static function getInstance() {

if (!isset(static::$instance))

static::$instance = self::getNewInstance();

return static::$instance;

}

static $instance;

static $cdata = array(

'table' => TICKET_CDATA_TABLE,

'object_id' => 'ticket_id',

'object_type' => 'T',

);

static function objects() {

$os = parent::objects();

return $os->filter(array('type'=>'T'));

}

static function getInstance() {

if (!isset(static::$instance))

static::$instance = self::getNewInstance();

return static::$instance;

}

static $meta = array(

'table' => FORM_FIELD_TABLE,

'ordering' => array('sort'),

'pk' => array('id'),

'select_related' => array('form'),

'joins' => array(

'form' => array(

'null' => true,

'constraint' => array('form_id' => 'DynamicForm.id'),

),

'answers' => array(

'reverse' => 'DynamicFormEntryAnswer.field',

),

),

);

var $_field;

var $_disabled = false;

const FLAG_ENABLED = 0x00001;

const FLAG_EXT_STORED = 0x00002; // Value stored outside of form_entry_value

const FLAG_CLOSE_REQUIRED = 0x00004;

const FLAG_MASK_CHANGE = 0x00010;

const FLAG_MASK_DELETE = 0x00020;

const FLAG_MASK_EDIT = 0x00040;

const FLAG_MASK_DISABLE = 0x00080;

const FLAG_MASK_REQUIRE = 0x10000;

const FLAG_MASK_VIEW = 0x20000;

const FLAG_MASK_NAME = 0x40000;

const MASK_MASK_INTERNAL = 0x400B2; # !change, !delete, !disable, !edit-name

const MASK_MASK_ALL = 0x700F2;

const FLAG_CLIENT_VIEW = 0x00100;

const FLAG_CLIENT_EDIT = 0x00200;

const FLAG_CLIENT_REQUIRED = 0x00400;

const MASK_CLIENT_FULL = 0x00700;

const FLAG_AGENT_VIEW = 0x01000;

const FLAG_AGENT_EDIT = 0x02000;

const FLAG_AGENT_REQUIRED = 0x04000;

const MASK_AGENT_FULL = 0x7000;

// Multiple inheritance -- delegate methods not defined here to the

// forms API FormField instance

function __call($what, $args) {

return call_user_func_array(

array($this->getField(), $what), $args);

}

/**

function getField() {

global $thisstaff;

// Finagle the `required` flag for the FormField instance

$ht = $this->ht;

$ht['required'] = ($thisstaff) ? $this->isRequiredForStaff()

: $this->isRequiredForUsers();

if (!isset($this->_field))

$this->_field = new FormField($ht);

return $this->_field;

}

function getForm() { return $this->form; }

function getFormId() { return $this->form_id; }

/**

function setConfiguration($vars, &$errors=array()) {

$config = array();

foreach ($this->getConfigurationForm($vars)->getFields() as $name=>$field) {

$config[$name] = $field->to_php($field->getClean());

$errors = array_merge($errors, $field->errors());

}

if (count($errors))

return false;

// See if field impl. need to save or override anything

$config = $this->getImpl()->to_config($config);

$this->set('configuration', JsonDataEncoder::encode($config));

$this->set('hint', Format::sanitize($vars['hint']) ?: NULL);

return true;

}

function isDeletable() {

return !$this->hasFlag(self::FLAG_MASK_DELETE);

}

function isNameForced() {

return $this->hasFlag(self::FLAG_MASK_NAME);

}

function isPrivacyForced() {

return $this->hasFlag(self::FLAG_MASK_VIEW);

}

function isRequirementForced() {

return $this->hasFlag(self::FLAG_MASK_REQUIRE);

}

function isChangeable() {

return !$this->hasFlag(self::FLAG_MASK_CHANGE);

}

function isEditable() {

return $this->hasFlag(self::FLAG_MASK_EDIT);

}

function disable() {

$this->_disabled = true;

}

function isEnabled() {

return !$this->_disabled && $this->hasFlag(self::FLAG_ENABLED);

}

function hasFlag($flag) {

return (isset($this->flags) && ($this->flags & $flag) != 0);

}

/**

function getVisibilityDescription() {

$F = $this->flags;

if (!$this->hasFlag(self::FLAG_ENABLED))

return __('Disabled');

$impl = $this->getImpl();

$hints = array();

$VIEW = self::FLAG_CLIENT_VIEW | self::FLAG_AGENT_VIEW;

if (($F & $VIEW) == 0) {

$hints[] = __('Hidden');

}

elseif (~$F & self::FLAG_CLIENT_VIEW) {

$hints[] = __('Internal');

}

elseif (~$F & self::FLAG_AGENT_VIEW) {

$hints[] = __('For EndUsers Only');

}

if ($impl->hasData()) {

if ($F & (self::FLAG_CLIENT_REQUIRED | self::FLAG_AGENT_REQUIRED)) {

$hints[] = __('Required');

}

else {

$hints[] = __('Optional');

}

if (!($F & (self::FLAG_CLIENT_EDIT | self::FLAG_AGENT_EDIT))) {

$hints[] = __('Immutable');

}

}

return implode(', ', $hints);

}

function getTranslateTag($subtag) {

return _H(sprintf('field.%s.%s', $subtag, $this->id));

}

function getLocal($subtag, $default=false) {

$tag = $this->getTranslateTag($subtag);

$T = CustomDataTranslation::translate($tag);

return $T != $tag ? $T : ($default ?: $this->get($subtag));

}

/**

static function allRequirementModes() {

return array(

'a' => array('desc' => __('Optional'),

'flags' => self::FLAG_CLIENT_VIEW | self::FLAG_AGENT_VIEW

| self::FLAG_CLIENT_EDIT | self::FLAG_AGENT_EDIT),

'b' => array('desc' => __('Required'),

'flags' => self::FLAG_CLIENT_VIEW | self::FLAG_AGENT_VIEW

| self::FLAG_CLIENT_EDIT | self::FLAG_AGENT_EDIT

| self::FLAG_CLIENT_REQUIRED | self::FLAG_AGENT_REQUIRED),

'c' => array('desc' => __('Required for EndUsers'),

'flags' => self::FLAG_CLIENT_VIEW | self::FLAG_AGENT_VIEW

| self::FLAG_CLIENT_EDIT | self::FLAG_AGENT_EDIT

| self::FLAG_CLIENT_REQUIRED),

'd' => array('desc' => __('Required for Agents'),

'flags' => self::FLAG_CLIENT_VIEW | self::FLAG_AGENT_VIEW

| self::FLAG_CLIENT_EDIT | self::FLAG_AGENT_EDIT

| self::FLAG_AGENT_REQUIRED),

'e' => array('desc' => __('Internal, Optional'),

'flags' => self::FLAG_AGENT_VIEW | self::FLAG_AGENT_EDIT),

'f' => array('desc' => __('Internal, Required'),

'flags' => self::FLAG_AGENT_VIEW | self::FLAG_AGENT_EDIT

| self::FLAG_AGENT_REQUIRED),

'g' => array('desc' => __('For EndUsers Only'),

'flags' => self::FLAG_CLIENT_VIEW | self::FLAG_CLIENT_EDIT

| self::FLAG_CLIENT_REQUIRED),

);

}

/**

function getAllRequirementModes() {

$modes = static::allRequirementModes();

if ($this->isPrivacyForced()) {

// Required to be internal

foreach ($modes as $m=>$info) {

if ($info['flags'] & (self::FLAG_CLIENT_VIEW | self::FLAG_AGENT_VIEW))

unset($modes[$m]);

}

}

if ($this->isRequirementForced()) {

// Required to be required

foreach ($modes as $m=>$info) {

if ($info['flags'] & (self::FLAG_CLIENT_REQUIRED | self::FLAG_AGENT_REQUIRED))

unset($modes[$m]);

}

}

return $modes;

}

function setRequirementMode($mode) {

$modes = $this->getAllRequirementModes();

if (!isset($modes[$mode]))

return false;

$info = $modes[$mode];

$this->set('flags', $info['flags'] | self::FLAG_ENABLED);

}

function isRequiredForStaff() {

return $this->hasFlag(self::FLAG_AGENT_REQUIRED);

}

function isRequiredForUsers() {

return $this->hasFlag(self::FLAG_CLIENT_REQUIRED);

}

function isRequiredForClose() {

return $this->hasFlag(self::FLAG_CLOSE_REQUIRED);

}

function isEditableToStaff() {

return $this->isEnabled()

&& $this->hasFlag(self::FLAG_AGENT_EDIT);

}

function isVisibleToStaff() {

return $this->isEnabled()

&& $this->hasFlag(self::FLAG_AGENT_VIEW);

}

function isEditableToUsers() {

return $this->isEnabled()

&& $this->hasFlag(self::FLAG_CLIENT_EDIT);

}

function isVisibleToUsers() {

return $this->isEnabled()

&& $this->hasFlag(self::FLAG_CLIENT_VIEW);

}

function addToQuery($query, $name=false) {

return $query->values($name ?: $this->get('name'));

}

/**

function isValid() {

if (count($this->errors()))

return false;

if (!$this->get('label'))

$this->addError(

__("Label is required for custom form fields"), "label");

if (($this->isRequiredForStaff() || $this->isRequiredForUsers())

&& !$this->get('name')

) {

$this->addError(

__("Variable name is required for required fields"

/* `required` is a visibility setting fields */

/* `variable` is used for automation. Internally it's called `name` */

), "name");

}

if ($this->get('name') && !preg_match('/^(?!\d)([[:alnum:]]|_)+$/u', $this->get('name')))

$this->addError(__(

'Invalid character in variable name. Please use letters and numbers only.'

), 'name');

return count($this->errors()) == 0;

}

function delete() {

$values = $this->answers->count();

// Don't really delete form fields with data as that will screw up the data

// model. Instead, just drop the association with the form which

// will give the appearance of deletion. Not deleting means that

// the field will continue to exist on form entries it may already

// have answers on, but since it isn't associated with the form, it

// won't be available for new form submittals.

$this->set('form_id', 0);

$impl = $this->getImpl();

// Trigger db_clean so the field can do house cleaning

$impl->db_cleanup(true);

// Short-circuit deletion if the field has data.

if ($impl->hasData() && $values)

return $this->save();

// Delete the field for realz

parent::delete();

}

function save($refetch=false) {

if (count($this->dirty))

$this->set('updated', new SqlFunction('NOW'));

return parent::save($this->dirty || $refetch);

}

static function create($ht=false) {

$inst = new static($ht);

$inst->set('created', new SqlFunction('NOW'));

if (isset($ht['configuration']))

$inst->configuration = JsonDataEncoder::encode($ht['configuration']);

return $inst;

}

static $meta = array(

'table' => FORM_ENTRY_TABLE,

'ordering' => array('sort'),

'pk' => array('id'),

'select_related' => array('form'),

'joins' => array(

'form' => array(

'null' => true,

'constraint' => array('form_id' => 'DynamicForm.id'),

),

'answers' => array(

'reverse' => 'DynamicFormEntryAnswer.entry',

),

),

);

var $_fields;

var $_form;

var $_errors = false;

var $_clean = false;

var $_source = null;

function getId() {

return $this->get('id');

}