/**
* @return bool
*/
public function saveObject()
{
if (!$this->fillObject()) {
return false;
}
if ($this->placeholder->getId()) {
$this->placeholder->update();
} else {
$this->placeholder->create();
if ($this->getInput('update_definitions')) {
$type = $this->placeholder->getCertificateType();
$definitions = srCertificateDefinition::where(array('type_id' => $type->getId()))->get();
/** @var $def srCertificateDefinition */
foreach ($definitions as $def) {
$phv = srCertificatePlaceholderValue::where(array('definition_id' => $def->getId(), 'placeholder_id' => $this->placeholder->getId()))->first();
if (!is_null($phv)) {
continue;
// Extra check... should never be the case
}
$phv = new srCertificatePlaceholderValue();
$phv->setDefinitionId($def->getId());
$phv->setPlaceholderId($this->placeholder->getId());
foreach ($type->getLanguages() as $lang_code) {
$phv->setValue($this->getInput("default_value_{$lang_code}"), $lang_code);
}
$phv->create();
}
}
}
return true;
}
protected function initForm()
{
$this->setFormAction($this->ctrl->getFormAction($this->parent_gui));
$this->setTitle($this->pl->txt('certificate_placeholders'));
// Each placeholder can define values for each language defined in the type
$languages = $this->definition->getType()->getLanguages();
$label_lang = in_array($this->user->getLanguage(), $languages) ? $this->user->getLanguage() : $this->definition->getDefaultLanguage();
/** @var $placeholder_value srCertificatePlaceholderValue */
foreach ($this->definition->getPlaceholderValues() as $placeholder_value) {
$section = new ilFormSectionHeaderGUI();
$section->setTitle($placeholder_value->getPlaceholder()->getLabel($label_lang));
$this->addItem($section);
foreach ($languages as $lang) {
$this->addItem($this->getInputField($placeholder_value, $lang));
}
}
if ($signatures = $this->definition->getType()->getSignatures()) {
$section = new ilFormSectionHeaderGUI();
$section->setTitle($this->pl->txt('signature'));
$this->addItem($section);
$select_input = new ilSelectInputGUI($this->pl->txt('signature'), 'signature');
$options = array(0 => '');
foreach ($signatures as $signature) {
$options[$signature->getId()] = $signature->getFirstName() . ' ' . $signature->getLastName();
}
$select_input->setOptions($options);
$select_input->setValue($this->definition->getSignatureId());
$this->addItem($select_input);
}
$this->addCommandButton('updatePlaceholders', $this->pl->txt('save'));
return;
}
/**
* Get dropdown for choosing the certificate type
*
* @return ilSelectInputGUI
*/
protected function getTypeInput()
{
$types = srcertificateType::get();
$options = array();
$object_type = $this->pl->isCourseTemplate((int) $_GET['ref_id']) ? 'crs-tpl' : ilObject::_lookupType((int) $_GET['ref_id'], true);
/** @var $type srCertificateType */
$invalid = array();
foreach ($types as $type) {
if (!srCertificateType::isSelectable($type, (int) $_GET['ref_id'])) {
continue;
}
// Skip the type if it contains no valid template file!
if (!is_file($type->getCertificateTemplatesPath(true))) {
$invalid[] = $type->getTitle();
continue;
}
$options[$type->getId()] = $type->getTitle();
}
if (count($invalid) && $this->isNew) {
ilUtil::sendInfo(sprintf($this->pl->txt('msg_info_invalid_cert_types'), implode(', ', $invalid)));
}
$item = new ilSelectInputGUI($this->pl->txt('setting_id_type'), 'type_id');
asort($options);
$item->setOptions($options);
$info = $this->isNew ? $this->pl->txt('setting_id_type_info_new') : $this->pl->txt('setting_id_type_info_change');
$item->setInfo($info);
$item->setValue($this->definition->getTypeId());
$item->setRequired(true);
return $item;
}
/**
* Update type of definition
*
*/
public function updateType()
{
$new_type_id = (int) $_POST['type_id'];
if ($new_type_id && $new_type_id != $this->definition->getTypeId()) {
$this->definition->setTypeId($new_type_id);
$this->definition->update();
ilUtil::sendSuccess($this->pl->txt('msg_type_updated'), true);
}
$this->ctrl->redirect($this, 'showDefinition');
}
/**
* @param string $value
*/
public function setValue($value)
{
// This should be factored out, currently there is one exception where a value needs to be parsed before storing in DB
if ($value && $this->getIdentifier() == srCertificateTypeSetting::IDENTIFIER_VALIDITY) {
/** @var srCertificateDefinition $definition */
$definition = srCertificateDefinition::find($this->getDefinitionId());
$validity_type = $definition->getSettingByIdentifier(srCertificateTypeSetting::IDENTIFIER_VALIDITY_TYPE)->getValue();
$value = srCertificateTypeSetting::formatValidityBasedOnType($validity_type, $value);
}
$this->value = $value;
}
public function delete()
{
// Delete setting on all definitions
foreach (srCertificateDefinition::where(array('type_id' => $this->getTypeId()))->get() as $definition) {
/** @var srCertificateDefinition $setting */
$setting = srCertificateCustomDefinitionSetting::where(array('definition_id' => $definition->getId(), 'identifier' => $this->getIdentifier()))->first();
if ($setting) {
$setting->delete();
}
}
parent::delete();
}
public function delete()
{
parent::delete();
@unlink($this->getFilePath(true));
@unlink($this->getFilePath(true) . '.' . $this->getSuffix());
// We must update any definitions holding this signature
$definitions = srCertificateDefinition::where(array('signature_id' => $this->getId()))->get();
foreach ($definitions as $definition) {
/** @var srCertificateDefinition $definition */
$definition->setSignatureId(0);
$definition->update();
}
}
$setting->setEditableIn(array('crs'));
$setting->setValue(0);
$setting->save();
}
?>
<#17>
<?php
require_once './Customizing/global/plugins/Services/UIComponent/UserInterfaceHook/Certificate/classes/Definition/class.srCertificateDefinition.php';
srCertificateDefinition::updateDB();
// Migrate from signature table
global $ilDB;
if ($ilDB->tableExists('cert_signature_def')) {
$set = $ilDB->query('SELECT * FROM cert_signature_def');
while ($row = $ilDB->fetchObject($set)) {
/** @var srCertificateDefinition $definition */
$definition = srCertificateDefinition::find($row->definition_id);
$definition->setSignatureId($row->signature_id);
$definition->save();
}
}
?>
<#18>
<?php
// Change data-type for longer emails
global $ilDB;
if ($ilDB->tableExists('uihkcertificate_c')) {
$ilDB->modifyTableColumn('uihkcertificate_c', 'value', array("type" => "clob", "default" => null, "notnull" => false));
}
?>
<#19>
<?php
/**
* Clone/copy this definition for a new course
*
* @param int $ref_id ref-ID of new course
* @return srCertificateDefinition
*/
public function copy($ref_id)
{
$this->log('Certificate: copy definitions from ' . $this->getRefId() . ' to ' . $ref_id);
$new_definition = srCertificateDefinition::where(array("ref_id" => $ref_id))->first();
if (!$new_definition) {
$this->log('there is no existing definition for ' . $ref_id . ', generating a new one.');
$new_definition = new srCertificateDefinition();
$new_definition->setRefId($ref_id);
$new_definition->setTypeId($this->getTypeId());
$new_definition->create();
} else {
$this->log('used existing definition for ' . $ref_id . '.');
}
$this->log('ID of clone: ' . $new_definition->getId());
$new_definition->setRefId($ref_id);
$new_definition->setTypeId($this->getTypeId());
// Clone Signature setting
if ($this->getSignatureId()) {
$new_definition->setSignatureId($this->getSignatureId());
}
$new_definition->setTypeChanged(false);
$new_definition->update();
// Settings and placeholder values now contain default values inherited from type.
// We overwrite them with the values from this definition
/** @var $setting srCertificateDefinitionSetting */
$this->log('copy srCertificateDefinitionSetting');
foreach ($this->getSettings() as $setting) {
$s = $new_definition->getSettingByIdentifier($setting->getIdentifier());
$this->log($setting->getIdentifier());
if (!$s instanceof srCertificateDefinitionSetting) {
$this->log('not found, generating new one');
$s = new srCertificateDefinitionSetting();
$s->setDefinitionId($new_definition->getId());
$s->setIdentifier($setting->getIdentifier());
$s->create();
}
$s->setValue($setting->getValue());
$s->update();
}
/** @var $ph_value srCertificatePlaceholderValue */
$this->log('copy srCertificatePlaceholderValue');
foreach ($this->getPlaceholderValues() as $ph_value) {
$ph = $new_definition->getPlaceholderValueByPlaceholderId($ph_value->getPlaceholderId());
$this->log($ph_value->getPlaceholderId());
if (!$ph instanceof srCertificatePlaceholderValue) {
$this->log('not found, generating new one');
$ph = new srCertificatePlaceholderValue();
$ph->setDefinitionId($new_definition->getId());
$ph->setPlaceholderId($ph_value->getPlaceholderId());
$ph->create();
}
$ph->setValue($ph_value->getValue());
// This does set the values for each language
$ph->update();
}
/** @var $cust_setting srCertificateCustomDefinitionSetting */
foreach ($this->getCustomSettings() as $cust_setting) {
$cs = $new_definition->getCustomSettingByIdentifier($cust_setting->getIdentifier());
$this->log($cust_setting->getIdentifier());
if (!$cs instanceof srCertificateCustomDefinitionSetting) {
$this->log('not found, generating new one');
$cs = new srCertificateCustomDefinitionSetting();
$cs->setDefinitionId($new_definition->getId());
$cs->setIdentifier($cust_setting->getIdentifier());
$cs->create();
}
$cs->setValue($cust_setting->getValue());
// This does set the values for each language
$cs->update();
$this->log('old value: ' . $cust_setting->getValue());
$this->log('cloned value: ' . $cs->getValue());
}
$this->log('finished');
return $new_definition;
}
/**
* Delete also related certificate definitions and assets
*/
public function delete()
{
parent::delete();
$definitions = srCertificateDefinition::where(array('type_id' => $this->getId()))->get();
/** @var $def srCertificateDefinition */
foreach ($definitions as $def) {
$def->delete();
}
}
/**
* @param $a_set
* @return bool
*/
protected function hasAction($a_set)
{
$definition = srCertificateDefinition::find((int) $a_set['definition_id']);
return $definition && $definition->getDownloadable() && parent::hasAction($a_set);
}
/**
* @return srCertificateCustomTypeSetting
*/
public function getCustomTypeSetting()
{
/** @var srCertificateDefinition $definition */
$definition = srCertificateDefinition::find($this->getDefinitionId());
return srCertificateCustomTypeSetting::where(array('identifier' => $this->getIdentifier(), 'type_id' => $definition->getTypeId()))->first();
}
/**
* @param int $definition_id
*/
public function setDefinitionId($definition_id)
{
$this->definition_id = $definition_id;
$this->definition = srCertificateDefinition::find($definition_id);
}
/**
* @return bool
*/
public function saveObject()
{
if (!$this->checkInput()) {
return false;
}
try {
$this->setting->setTypeId((int) $_GET['type_id']);
$this->setting->setIdentifier($this->getInput('identifier'));
$this->setting->setSettingTypeId($this->getInput('setting_type_id'));
$this->setting->setData($this->getInput('data'));
$this->setting->setValue($this->getInput('value'));
$this->setting->setEditableIn($this->getInput('editable_in'));
/** @var srCertificateType $type */
$type = srCertificateType::find($this->setting->getTypeId());
foreach ($type->getLanguages() as $lang_code) {
$this->setting->setLabel($this->getInput("label_{$lang_code}"), $lang_code);
}
$this->setting->save();
// Check if existing definitions should be updated to own this setting
if ($this->getInput('update_definitions')) {
$definitions = srCertificateDefinition::where(array('type_id' => $type->getId()))->get();
/** @var $def srCertificateDefinition */
foreach ($definitions as $def) {
$definition_setting = new srCertificateCustomDefinitionSetting();
$definition_setting->setDefinitionId($def->getId());
$definition_setting->setIdentifier($this->setting->getIdentifier());
$definition_setting->setValue($this->setting->getValue());
$definition_setting->save();
}
}
} catch (ilException $e) {
ilUtil::sendFailure($e->getMessage());
return false;
}
return true;
}
/**
* @return \srCertificateDefinition
*/
public function getDefinition()
{
if (is_null($this->definition)) {
$this->definition = srCertificateDefinition::find($this->getDefinitionId());
}
return $this->definition;
}
