Browse Source

Prosseguimento no desenvolvimento do plugin

master
Matheus Garcia 6 years ago
parent
commit
1460a1977d
  1. 8
      README.md
  2. 4
      block_escola_modelo.php
  3. 151
      classes/observer.php
  4. 164
      classes/task/escola_modelo.php
  5. 317
      classes/util.php
  6. 30
      db/events.php
  7. 35
      db/install.xml
  8. 13
      db/tasks.php
  9. 10
      lang/en/block_escola_modelo.php
  10. 40
      settings.php
  11. 3
      version.php

8
README.md

@ -0,0 +1,8 @@
Plugin para Escolas Modelo
- implementa mecanismos para atualização síncrona (por meio de eventos) e assíncrona (por meio de tarefa) de cursos, certificados e matrículas na EVL
- define uma API para ser consultada externamente, provendo informações sobre a Escola Modelo

4
block_escola_modelo.php

@ -16,4 +16,8 @@ class block_escola_modelo extends block_base
return $this->content; return $this->content;
} }
function has_config() {
return true;
}
} }

151
classes/observer.php

@ -3,6 +3,7 @@
require_once($CFG->dirroot.'/config.php'); require_once($CFG->dirroot.'/config.php');
include('httpful.phar'); include('httpful.phar');
include('util.php');
class block_escola_modelo_observer { class block_escola_modelo_observer {
@ -10,112 +11,102 @@ class block_escola_modelo_observer {
// EVENTOS RELACIONADOS A CURSOS // EVENTOS RELACIONADOS A CURSOS
// //
/* /**
{ * Trata evento de criação de curso.
"course": { * Como estamos criando o curso agora, é possível sabermos com certeza que ele
"name": "nome do curso", * ainda não existe na EVL e sua visibilidade (público/privado). Então somente
"url": "url do curso", * será chamado o web service se o curso for público.
"course_load": "carga horário do curso", */
"description": "descrição do curso",
"logo":"endereco da logo",
"ead_id": "id do curso no moodle"
}
}
*/
public static function course_created(\core\event\base $event) { public static function course_created(\core\event\base $event) {
global $DB, $CFG; global $DB, $CFG;
$curso = $DB->get_record($event->objecttable,array('id'=>$event->objectid)); $curso = $DB->get_record($event->objecttable,array('id'=>$event->objectid));
$idnumber = $curso->idnumber; if(cursoPublico($curso)) {
preg_match("/\_CH([0-9]+)/", $idnumber, $x); atualizaCursoEVL($curso, true);
$ch = $x[1];
//$escola = $DB->get_record("{course}",array('id'=>$curso->));
$uri = 'https://escolamodelows.interlegis.leg.br/api/v1/cursos/adicionar/';
$obj = new StdClass();
$camposCurso = array(
"name" => $curso->fullname,
"url" => "", // fixme não deve haver esse campo
"course_load" => $ch, // fixme como obter esse campo no Moodle
"description" => $curso->summary,
"logo" => "", // fixme não deve ter esse campo
"ead_id" => $curso->id
);
$obj->course = $camposCurso;
$obj->school = "SSL";
$obj->category = "1";
$json = json_encode($obj);
$response = \Httpful\Request::post($uri)
->sendsJson()
->body($json)
->send();
}
/*
{
"school": "iniciais",
"course": {
"name": "nome do curso",
"url": "url do curso",
"course_load": "carga horário do curso",
"description": "descrição do curso",
"logo":"endereco da logo, se vazio permanece a logo atual e para remover deve ser enviado o texto 'remover' ",
"school": "iniciais da escola",
"ead_id": "id do curso no moodle"
} }
} }
*/
/**
* Trata evento de atualização de curso.
* A atualização de curso em uma Escola Modelo sempre deve chamar o web service,
* pois não temos certeza do status do curso na EVL.
*/
public static function course_updated(\core\event\base $event) { public static function course_updated(\core\event\base $event) {
global $DB, $CFG; global $DB, $CFG;
$curso = $DB->get_record($event->objecttable,array('id'=>$event->objectid)); $curso = $DB->get_record($event->objecttable,array('id'=>$event->objectid));
$idnumber = $curso->idnumber; atualizaCursoEVL($curso);
preg_match("/\_CH([0-9]+)/", $idnumber, $x); }
$ch = $x[1];
$uri = 'https://escolamodelows.interlegis.leg.br/api/v1/cursos/atualizar';
$obj = new StdClass(); /**
* Trata evento de remoção de um curso.
* TODO: tratar situações em que isso pode ou não ocorrer, bem como a forma adequada de tratar o evento.
*/
public static function course_deleted(\core\event\base $event) {
global $DB, $CFG;
$curso = $DB->get_record($event->objecttable,array('id'=>$event->objectid));
$camposCurso = array( // Por enquanto, atualizamos o curso na EVL, porém o mesmo fica invisível
"name" => $curso->fullname, atualizaCursoEVL($curso, false);
"url" => "", // fixme não deve haver esse campo }
"course_load" => $ch, // fixme como obter esse campo no Moodle
"description" => $curso->summary,
"logo" => "", // fixme não deve ter esse campo
"school" => "SSL", // fixme criar campo no moodle
"ead_id" => $curso->id
);
$obj->school = $CFG->school; //
$obj->course = $camposCurso; // EVENTOS RELACIONADOS A CATEGORIAS
$json = json_encode($obj); //
$response = \Httpful\Request::patch($uri) /**
->sendsJson() * Trata evento de modificação de categoria.
->body($json) * A princípio, toda mudança de categoria deve ser tratada com a atualização de todos
->send(); * os cursos nela contidos, pois a alteração pode ser nos critérios de visibilidade,
error_log("Retorno é " . $response->code); * e não é possível saber a visibilidade anterior da categoria, no momento da
* chamada desta função.
* Outro ponto importante é que são tratados apenas os cursos inseridos diretamente
* na categoria, e não em categorias filhas.
*/
public static function course_category_updated(\core\event\base $event) {
global $DB, $CFG;
$categoria = $DB->get_record($event->objecttable,array('id'=>$event->objectid));
// A forma mais segura de fazê-lo é modificar timemodified de todos os cursos,
// de modo que na próxima sincronização eles tenham seu status modificado
atualizaCategoriaEVL($categoria);
} }
public static function course_deleted(\core\event\base $event) { // EVENTOS RELACIONADOS A CERTIFICADOS
public static function certificates_created(\core\event\base $event) {
global $DB, $CFG;
$categoria = $DB->get_record($event->objecttable,array('id'=>$event->objectid));
// A forma mais segura de fazê-lo é modificar timemodified de todos os cursos,
// de modo que na próxima sincronização eles tenham seu status modificado
atualizaCategoriaEVL($categoria);
} }
// TODO: verificar se é necessário tratar remoção de categoria
// //
// EVENTOS RELACIONADOS A MATRÍCULAS // EVENTOS RELACIONADOS A MATRÍCULAS
// //
// Retirado pois supõe-se que matrículas serão feitas apenas na EVL
// public static function user_enrolment_created(\core\event\base $event) {
// global $DB, $CFG;
// $ue = $DB->get_record($event->objecttable,array('id'=>$event->objectid));
// atualizaMatriculaEVL($ue, true);
// }
//public static function course_updated(\core\event\base $event) { // public static function user_enrolment_updated(\core\event\base $event) {
// global $DB, $CFG;
// $ue = $DB->get_record($event->objecttable,array('id'=>$event->objectid));
// atualizaMatriculaEVL($ue);
// }
//} // public static function user_enrolment_deleted(\core\event\base $event) {
// global $DB, $CFG;
// $ue = $DB->get_record($event->objecttable,array('id'=>$event->objectid));
// atualizaMatriculaEVL($ue, false);
// }
} }

164
classes/task/escola_modelo.php

@ -0,0 +1,164 @@
<?php
/**
* escola_modelo.php
*
* Implementa procedimentos para sincronização de informações de uma instalação
* da Escola Modelo com o servidor da EVL
*
**/
namespace block_escola_modelo\task;
global $CFG;
require_once($CFG->dirroot.'/config.php');
require_once($CFG->dirroot.'/blocks/escola_modelo/classes/util.php');
class escola_modelo extends \core\task\scheduled_task {
public function get_name() {
return get_string('escola_modelo', 'block_escola_modelo');
}
// Ponto de entrada da task
public function execute() {
global $DB;
// Momento do início do procedimento, para fins de gravação em
// tabelas de controle
$syncStartTime = $DB->get_record_sql('SELECT extract(epoch from now())::int8');
$this->sincronizaDadosEscola($syncStartTime);
$this->sincronizaCursos($syncStartTime);
//$this->sincronizaMatriculas($syncStartTime);
$this->sincronizaCertificados($syncStartTime);
}
/**
* Realiza procedimento de sincronização nos cursos criados e/ou atualizados
* que ainda não foram atualizados na EVL
*/
public function sincronizaDadosEscola($syncStartTime) {
global $DB, $CFG;
mtrace("Iniciando sincronização de dados da escola");
// Obtem todos os cursos pendentes de sincronização
$sqlDadosEscola = '
SELECT ? as sigla_escola, ? as url_escola, c.fullname as nome_escola,
? || \'/pluginfile.php/1/core_admin/logo/0x150/-1\' || logo.value as url_logo_escola
FROM mdl_course c
JOIN (
SELECT value
FROM mdl_config_plugins
WHERE plugin = \'core_admin\'
AND name = \'logocompact\'
) logo
ON 1 = 1
WHERE c.id = 1
';
$dadosEscola = $DB->get_record_sql($sqlDadosEscola,array($CFG->emSigla, $CFG->emURL, $CFG->emURL));
// Atualiza cada um dos cursos pendentes
atualizaDadosEscola($dadosEscola);
mtrace("Fim da sincronização de dados da escola");
}
/**
* Realiza procedimento de sincronização nos cursos criados e/ou atualizados
* que ainda não foram atualizados na EVL
*/
public function sincronizaCursos($syncStartTime) {
global $DB;
mtrace("Iniciando sincronização de cursos");
// Obtem todos os cursos pendentes de sincronização
$sqlCourses = '
SELECT c.*
FROM {course} c
LEFT JOIN {ilb_sync_course} sc
ON c.id = sc.course_id
WHERE sc.course_id is null
OR c.timemodified > sc.time_sync
';
$listaCursos = $DB->get_records_sql($sqlCourses,array());
// Atualiza cada um dos cursos pendentes
foreach($listaCursos as $curso) {
atualizaCursoEVL($curso);
}
mtrace("Fim da sincronização de cursos");
}
// /**
// * Realiza procedimento de sincronização de matrículas de usuários a cursos,
// * as quais ainda não foram atualizadas na EVL
// */
// public function sincronizaMatriculas($syncStartTime) {
// global $DB;
// // Obtem todas as matrículas pendentes de sincronização
// $sqlEnrolments = '
// SELECT ue.*
// FROM mdl_user_enrolments ue
// LEFT JOIN mdl_ilb_sync_user_enrolments sue
// ON ue.id = sue.user_enrolment_id
// WHERE sue.user_enrolment_id is null
// OR ue.timemodified > sue.time_sync
// ';
// $listaMatriculas = $DB->get_records_sql($sqlEnrolments,array());
// // Atualiza cada um dos cursos pendentes
// foreach($listaMatriculas as $matricula) {
// atualizaMatriculaEVL($matricula);
// }
// }
/**
* Realiza procedimento de sincronização de certificados ainda não
* atualizados na EVL
*/
public function sincronizaCertificados($syncStartTime) {
global $DB;
mtrace("Iniciando sincronização de certificados");
// Identifica eventuais cursos não sincronizados
$sqlCertificates = '
SELECT c.id as courseid, u.username, ci.timecreated, gg.finalgrade, ci.code, cert.id
FROM (
SELECT ci.timecreated, sc.time_sync, ci.code, ci.certificateid, ci.userid
FROM mdl_certificate_issues ci
LEFT JOIN mdl_ilb_sync_certificate sc
ON ci.id = sc.certificate_id
WHERE sc.time_sync is null
OR ci.timecreated > sc.time_sync
) ci
JOIN mdl_certificate cert
ON cert.id = ci.certificateid
JOIN mdl_course c
ON c.id = cert.course
JOIN mdl_user u
ON u.id = ci.userid
LEFT JOIN mdl_grade_items gi
ON gi.courseid = c.id
AND gi.itemtype = \'course\'
LEFT JOIN mdl_grade_grades gg
ON gg.itemid = gi.id
AND gg.userid = ci.userid
';
$certificados = $DB->get_records_sql($sqlCertificates,array());
// Processa cada certificado, gerando chamada ao web service
foreach ($certificados as $certificado) {
atualizaCertificadoEVL($certificado);
}
mtrace("Fim da sincronização de certificados");
}
}
?>

317
classes/util.php

@ -0,0 +1,317 @@
<?php
/**
* Funções utilitárias para plugin da Escola Modelo
*/
require_once($CFG->dirroot.'/config.php');
include('httpful.phar');
/**
* Verifica se um curso é público, conforme critérios da EVL.
* Pelas regras estabelecidas, um curso é público se a categoria raiz em que ele
* estiver for uma categoria pública.
*/
function cursoPublico($course) {
global $DB;
$category = $DB->get_record('course_categories', array('id'=>$course->category));
$path = explode('/',$category->path);
$root_category_id = $path[1];
$root_category = $DB->get_record('course_categories',array('id'=>$root_category_id));
return categoriaPublica($root_category);
}
/**
* Verifica se uma categoria é pública, conforme critérios da EVL
* Pelas regras estabelecidas, uma categoria é pública se possuir idnumber iniciado por PUB_
*/
function categoriaPublica($category) {
$idnumber=$category->idnumber;
$isPublic=(strcasecmp(substr($idnumber,0,4), 'PUB_') == 0);
return $isPublic;
}
/**
* Registra um determinado curso na EVL, com o status informado
*
* Formato do JSON:
* {
* "school": "Iniciais da escola",
* "course":
* {
* "name": "nome do curso",
* "url": "url do curso",
* "description": "descrição do curso",
* "logo":"endereco da logo",
* "ead_id": "id do curso no moodle",
* "visible": Visibilidade do curso(Público ou privado, de acordo com a categoria do moodle),
* "conteudista": "",
* "certificador": "",
* "carga_horaria": ""
* },
* "key": "k4B5YcbKa619ohu3wxk2xXbmtoxFuQqrwcKEOTAnZi7iy4tl9z"
* }
*/
function atualizaCursoEVL($curso, $visivel = null) {
global $DB;
mtrace("curso " . $curso->id);
// Detecta status, caso ele não tenha sido especificado
$visivel = $visivel ?? cursoPublico($curso);
// Hack: enquanto não há campos personalizados no curso, a carga horária
// precisa ser obtida a partir do idnumber
$idnumber = $curso->idnumber;
$ch = 0;
if(preg_match("/\_CH([0-9]+)/", $idnumber, $x)) {
$ch = $x[1];
}
$school = $DB->get_record('course',array('id'=>'1'));
$uri = 'https://escolamodelows.interlegis.leg.br/api/v1/cursos/registrar/';
$obj = new StdClass();
$camposCurso = array(
"name" => $curso->fullname,
"url" => "",
"description" => $curso->summary,
"logo" => "",
"ead_id" => $curso->id,
"visible" => $visivel,
"conteudista" => "", //$school->shortname,
"certificador" => $school->shortname,
"carga_horaria" => $ch
);
// Monta o JSON que será enviado ao Web Service
$obj->school = $school->shortname; // sigla da escola
$obj->course = $camposCurso;
$obj->key = "k4B5YcbKa619ohu3wxk2xXbmtoxFuQqrwcKEOTAnZi7iy4tl9z";
$json = json_encode($obj);
$response = \Httpful\Request::post($uri)
->sendsJson()
->body($json)
->send();
// Se o registro foi criado no servidor, registra em tabela de controle
if(!$response->hasErrors()) {
registraSincronizacaoCurso($curso);
} else {
mtrace("Erro sincronizando ". $curso->fullname . ": " . $response->code . " " );
}
}
/**
* Insere ou atualiza registro da última sincronização de determinado curso
*/
function registraSincronizacaoCurso($curso) {
global $DB;
$qry = '
INSERT INTO {ilb_sync_course} (course_id, time_sync)
VALUES (?,?)
ON CONFLICT (course_id) DO UPDATE
SET time_sync = ?';
$params = array($curso->id, $curso->timemodified, $curso->timemodified);
return $DB->execute($qry, $params);
}
/**
* Identifica e atualiza registro de todos os cursos da categoria especificada
* (excluindo subcategorias)
*/
function atualizaCategoriaEVL($categoria) {
global $DB;
$visivel = categoriaPublica($categoria);
$cursos = $DB->get_records('course', array('category'=>$categoria->id));
foreach ($cursos as $curso) {
atualizaCursoEVL($curso, $visivel);
}
}
//
// Matrículas
//
// Retirado pois supõe-se que matrículas serão feitas apenas na EVL
// function atualizaMatriculaEVL($matricula) {
// global $DB;
// // Detecta status, caso ele não tenha sido especificado
// $visivel = true; //$visivel ?? cursoPublico($curso);
// // Hack: enquanto não há campos personalizados no curso, a carga horária
// // precisa ser obtida a partir do idnumber
// $idnumber = $curso->idnumber;
// $ch = 0;
// if(preg_match("/\_CH([0-9]+)/", $idnumber, $x)) {
// $ch = $x[1];
// }
// $school = $DB->get_record('course',array('id'=>'1'));
// $uri = 'https://escolamodelows.interlegis.leg.br/api/v1/cursos/registrar/';
// $obj = new StdClass();
// $camposCurso = array(
// "name" => $curso->fullname,
// "url" => "",
// "description" => $curso->summary,
// "logo" => "",
// "ead_id" => $curso->id,
// "visible" => $visivel,
// "conteudista" => "", //$school->shortname,
// "certificador" => $school->shortname,
// "carga_horaria" => $ch
// );
// // Monta o JSON que será enviado ao Web Service
// $obj->school = $school->shortname; // sigla da escola
// $obj->course = $camposCurso;
// $obj->key = "k4B5YcbKa619ohu3wxk2xXbmtoxFuQqrwcKEOTAnZi7iy4tl9z";
// $json = json_encode($obj);
// $response = \Httpful\Request::post($uri)
// ->sendsJson()
// ->body($json)
// ->send();
// // Se o registro foi criado no servidor, registra em tabela de controle
// if(!$response->hasErrors()) {
// registraSincronizacaoMatriculaUsuario($matricula);
// } else {
// mtrace("Erro sincronizando ". $matricula->fullname . ": " . $response->code . " " );
// }
// }
// /**
// * Insere ou atualiza registro da última sincronização de determinada matricula
// */
// function registraSincronizacaoMatriculaUsuario($userEnrolment) {
// global $DB;
// $qry = '
// INSERT INTO {ilb_sync_user_enrolments} (user_enrolment_id, time_sync)
// VALUES (?,?)
// ON CONFLICT (user_enrolment_id) DO UPDATE
// SET time_sync = ?';
// $params = array($userEnrolment->id, $userEnrolment->timemodified, $userEnrolment->timemodified);
// return $DB->execute($qry, $params);
// }
//
// CERTIFICADOS
//
function atualizaCertificadoEVL($certificado) {
global $DB, $CFG;
mtrace("certificado " . $certificado->code);
$school = $DB->get_record('course',array('id'=>'1'));
$uri = 'https://escolamodelows.interlegis.leg.br/api/v1/certificados/adicionar/';
$obj = new StdClass();
$certArray = array();
// Gravação de certificado para envio ao Web Service da EVL
$certItem = array(
'course' => $certificado->courseid,
'student' => $certificado->username,
'date' => $certificado->timecreated,
'grade' => $certificado->finalgrade,
'code' => $certificado->code,
);
array_push($certArray, $certItem);
$mainArray = array(
'school' => $CFG->emSigla,
'certificates' => $certArray,
'key' => "k4B5YcbKa619ohu3wxk2xXbmtoxFuQqrwcKEOTAnZi7iy4tl9z"
);
$json = json_encode($mainArray);
$response = \Httpful\Request::post($uri)
->sendsJson()
->body($json)
->send();
// Se o registro foi criado no servidor, registra em tabela de controle
if(!$response->hasErrors()) {
registraSincronizacaoCertificado($certificado);
} else {
mtrace("Erro sincronizando certificado " . $certificado->code . ": " . $response->code . " " );
}
}
/**
* Insere ou atualiza registro da última sincronização de determinado certificado
*/
function registraSincronizacaoCertificado($certificado) {
global $DB;
$qry = '
INSERT INTO {ilb_sync_certificate} (certificate_id, time_sync)
VALUES (?,?)
ON CONFLICT (certificate_id) DO UPDATE
SET time_sync = ?';
$params = array($certificado->id, $certificado->timecreated, $certificado->timecreated);
return $DB->execute($qry, $params);
}
//
// DADOS DA ESCOLA
//
function atualizaDadosEscola($dadosEscola) {
global $DB;
$school = $DB->get_record('course',array('id'=>'1'));
$uri = 'https://escolamodelows.interlegis.leg.br/api/v1/escolas/atualizar/';
$obj = new StdClass();
// Gravação de certificado para envio ao Web Service da EVL
$schoolArray = array(
'name' => $dadosEscola->nome_escola,
'url' => $dadosEscola->url_escola,
'logo' => $dadosEscola->url_logo_escola,
'initials' => $dadosEscola->sigla_escola
);
$mainArray = array(
'initials_school' => $dadosEscola->sigla_escola,
'school' => $schoolArray,
'key' => "k4B5YcbKa619ohu3wxk2xXbmtoxFuQqrwcKEOTAnZi7iy4tl9z"
);
$json = json_encode($mainArray);
$response = \Httpful\Request::patch($uri)
->sendsJson()
->body($json)
->send();
// Se o registro foi criado no servidor, registra em tabela de controle
if($response->hasErrors()) {
mtrace("Erro sincronizando dados da escola " . $dadosEscola->sigla_escola);
}
}

30
db/events.php

@ -1,4 +1,5 @@
<?php <?php
$observers = array( $observers = array(
// Eventos de cursos // Eventos de cursos
array( array(
@ -13,17 +14,28 @@ $observers = array(
'eventname' => '\core\event\course_deleted', 'eventname' => '\core\event\course_deleted',
'callback' => 'block_escola_modelo_observer::course_deleted' 'callback' => 'block_escola_modelo_observer::course_deleted'
), ),
// Eventos de matrícula a cursos // Eventos de categorias
array( array(
'eventname' => 'core\event\user_enrolment_created', 'eventname' => 'core\event\course_category_updated',
'callback' => 'block_escola_modelo_observer::user_enrolment_created' 'callback' => 'block_escola_modelo_observer::course_category_updated'
), ),
// Eventos de certificados
array( array(
'eventname' => 'core\event\user_enrolment_deleted', 'eventname' => 'mod_certificate\event\certificates_created',
'callback' => 'block_escola_modelo_observer::user_enrolment_deleted' 'callback' => 'block_escola_modelo_observer::certificates_created'
),
array(
'eventname' => 'core\event\user_enrolment_updated',
'callback' => 'block_escola_modelo_observer::user_enrolment_updated'
) )
// ),
// // Eventos de matrícula a cursos
// array(
// 'eventname' => 'core\event\user_enrolment_created',
// 'callback' => 'block_escola_modelo_observer::user_enrolment_created'
// ),
// array(
// 'eventname' => 'core\event\user_enrolment_deleted',
// 'callback' => 'block_escola_modelo_observer::user_enrolment_deleted'
// ),
// array(
// 'eventname' => 'core\event\user_enrolment_updated',
// 'callback' => 'block_escola_modelo_observer::user_enrolment_updated'
//)
); );

35
db/install.xml

@ -0,0 +1,35 @@
<?xml version="1.0" encoding="UTF-8" ?>
<XMLDB PATH="blocks/escola_modelo/db" VERSION="20180604" COMMENT="XML para criação de tabelas para escola_modelo."
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../../../lib/xmldb/xmldb.xsd"
>
<TABLES>
<TABLE NAME="mdl_ilb_sync_course" COMMENT="Tabela de sincronização de informações de cursos">
<FIELDS>
<FIELD NAME="course_id" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="false"/>
<FIELD NAME="time_sync" TYPE="int" LENGTH="8" NOTNULL="true" SEQUENCE="false"/>
</FIELDS>
<KEYS>
<KEY NAME="primary" TYPE="primary" FIELDS="course_id"/>
</KEYS>
</TABLE>
<TABLE NAME="mdl_ilb_sync_certificate" COMMENT="Tabela de sincronização de informações de certificados">
<FIELDS>
<FIELD NAME="certificate_id" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="false"/>
<FIELD NAME="time_sync" TYPE="int" LENGTH="8" NOTNULL="true" SEQUENCE="false"/>
</FIELDS>
<KEYS>
<KEY NAME="primary" TYPE="primary" FIELDS="certificate_id"/>
</KEYS>
</TABLE>
<TABLE NAME="mdl_ilb_sync_user_enrolments" COMMENT="Tabela de sincronização de informações de matrículas">
<FIELDS>
<FIELD NAME="user_enrolment_id" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="false"/>
<FIELD NAME="time_sync" TYPE="int" LENGTH="8" NOTNULL="true" SEQUENCE="false"/>
</FIELDS>
<KEYS>
<KEY NAME="primary" TYPE="primary" FIELDS="user_enrolment_id"/>
</KEYS>
</TABLE>
</TABLES>
</XMLDB>

13
db/tasks.php

@ -0,0 +1,13 @@
<?php
$tasks = [
[
'classname' => 'block_escola_modelo\task\escola_modelo',
'blocking' => 0,
'minute' => '30',
'hour' => '17',
'day' => '*',
'month' => '1,7',
'dayofweek' => '0',
],
];

10
lang/en/block_escola_modelo.php

@ -1,3 +1,9 @@
<?php <?php
$string['pluginname'] = 'Bloco para Escola Modelo'; $string['pluginname'] = 'Escola Modelo';
$string['escola_modelo'] = 'Customizações para Escola Modelo'; $string['escola_modelo'] = 'Bloco para Escola Modelo';
$string['config_sigla_evl_titulo'] = 'Sigla da Escola Modelo';
$string['config_sigla_evl_descricao'] = 'Sigla da Escola Modelo na EVL';
$string['config_apikey_titulo'] = 'Chave de API';
$string['config_apikey_descricao'] = 'Chave de API para interação com EVL';

40
settings.php

@ -0,0 +1,40 @@
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Configurações para o plugin Escola Modelo
*
* @package enrol_evl
* @author Interlegis
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*
*/
defined('MOODLE_INTERNAL') || die();
if ($ADMIN->fulltree) {
// Sigla da Escola na EVL
$setting = new admin_setting_configtext('block_escola_modelo/config_sigla_evl',
get_string('config_sigla_evl_titulo', 'block_escola_modelo'),
get_string('config_sigla_evl_descricao', 'block_escola_modelo'), '', PARAM_ALPHA, 3);
$settings->add($setting);
$setting = new admin_setting_configtext('block_escola_modelo/config_apikey',
get_string('config_apikey_titulo', 'block_escola_modelo'),
get_string('config_apikey_descricao', 'block_escola_modelo'), '', PARAM_ALPHA, 50);
$settings->add($setting);
}

3
version.php

@ -1,4 +1,5 @@
<?php <?php
$plugin->version = 2018061801; $plugin->version = 2019012101;
$plugin->requires = 2017110800; $plugin->requires = 2017110800;
$plugin->component = 'block_escola_modelo'; $plugin->component = 'block_escola_modelo';
Loading…
Cancel
Save