public/main/cron/import_csv.php
<?php
/* For licensing terms, see /license.txt */
use Chamilo\CourseBundle\Entity\CCalendarEvent;
use Chamilo\CourseBundle\Entity\CItemProperty;
use Chamilo\PluginBundle\Entity\StudentFollowUp\CarePost;
use Fhaculty\Graph\Graph;
use Monolog\Handler\BufferHandler;
use Monolog\Handler\ErrorLogHandler;
use Monolog\Handler\RotatingFileHandler;
use Monolog\Handler\StreamHandler;
use Monolog\Logger;
if (PHP_SAPI != 'cli') {
exit('Run this script through the command line or comment this line in the code');
}
if (file_exists('multiple_url_fix.php')) {
require 'multiple_url_fix.php';
}
require_once __DIR__.'/../inc/global.inc.php';
ini_set('memory_limit', -1);
ini_set('max_execution_time', 0);
ini_set('log_errors', '1');
ini_set('display_errors', '1');
/**
* Class ImportCsv.
*/
class ImportCsv
{
public $test;
public $defaultLanguage = 'dutch';
public $extraFieldIdNameList = [
'session' => 'external_session_id',
'session_career' => 'external_career_id',
'course' => 'external_course_id',
'user' => 'external_user_id',
'calendar_event' => 'external_calendar_event_id',
'career' => 'external_career_id',
'career_urls' => 'career_urls',
'career_diagram' => 'career_diagram',
];
public $defaultAdminId = 1;
public $defaultSessionVisibility = 1;
/**
* When creating a user the expiration date is set to registration date + this value.
*
* @var int number of years
*/
public $expirationDateInUserCreation = 1;
public $batchSize = 20;
/**
* When updating a user the expiration date is set to update date + this value.
*
* @var int number of years
*/
public $expirationDateInUserUpdate = 1;
public $daysCoachAccessBeforeBeginning = 14;
public $daysCoachAccessAfterBeginning = 14;
public $conditions;
private $logger;
private $dumpValues;
private $updateEmailToDummy;
/**
* @param Monolog\Logger $logger
* @param array
*/
public function __construct($logger, $conditions)
{
$this->logger = $logger;
$this->conditions = $conditions;
$this->updateEmailToDummy = false;
}
/**
* @param bool $dump
*/
public function setDumpValues($dump)
{
$this->dumpValues = $dump;
}
/**
* @return bool
*/
public function getDumpValues()
{
return $this->dumpValues;
}
/**
* Runs the import process.
*/
public function run()
{
global $_configuration;
$value = api_get_configuration_value('import_csv_custom_url_id');
if (!empty($value)) {
$_configuration['access_url'] = $value;
}
$path = api_get_path(SYS_CODE_PATH).'cron/incoming/';
if (!is_dir($path)) {
echo "The folder! $path does not exits";
return 0;
}
if ($this->getDumpValues()) {
$this->dumpDatabaseTables();
}
echo 'Reading files: '.PHP_EOL.PHP_EOL;
$files = scandir($path);
$fileToProcess = [];
$fileToProcessStatic = [];
$teacherBackup = [];
$groupBackup = [];
$this->prepareImport();
if (!empty($files)) {
foreach ($files as $file) {
$fileInfo = pathinfo($file);
if (isset($fileInfo['extension']) && 'csv' === $fileInfo['extension']) {
// Checking teachers_yyyymmdd.csv,
// courses_yyyymmdd.csv, students_yyyymmdd.csv and sessions_yyyymmdd.csv
$parts = explode('_', $fileInfo['filename']);
$preMethod = ucwords($parts[1]);
$preMethod = str_replace('-static', 'Static', $preMethod);
$method = 'import'.$preMethod;
$isStatic = strpos($method, 'Static');
if ('importSessionsextidStatic' == $method) {
$method = 'importSessionsExtIdStatic';
}
if ('importCourseinsertStatic' == $method) {
$method = 'importSubscribeUserToCourse';
}
if ('importUnsubsessionsextidStatic' == $method) {
$method = 'importUnsubsessionsExtidStatic';
}
if ('importCareersdiagram' == $method) {
$method = 'importCareersDiagram';
}
if ('importCareersresults' == $method) {
$method = 'importCareersResults';
}
if ('importOpensessions' == $method) {
$method = 'importOpenSessions';
}
if ('importSubsessionsextidStatic' == $method) {
$method = 'importSubscribeUserToCourseSessionExtStatic';
}
if (method_exists($this, $method)) {
if ((
'importSubscribeStatic' == $method ||
'importSubscribeUserToCourse' == $method
) ||
empty($isStatic)
) {
$fileToProcess[$parts[1]][] = [
'method' => $method,
'file' => $path.$fileInfo['basename'],
];
} else {
$fileToProcessStatic[$parts[1]][] = [
'method' => $method,
'file' => $path.$fileInfo['basename'],
];
}
} else {
echo "Error - This file '$file' can't be processed.".PHP_EOL;
echo "Trying to call $method".PHP_EOL;
echo "The file have to has this format:".PHP_EOL;
echo "prefix_students_ddmmyyyy.csv, prefix_teachers_ddmmyyyy.csv,
prefix_courses_ddmmyyyy.csv, prefix_sessions_ddmmyyyy.csv ".PHP_EOL;
exit;
}
}
}
if (empty($fileToProcess) && empty($fileToProcessStatic)) {
echo 'Error - no files to process.';
return 0;
}
$sections = [
'students',
'teachers',
'courses',
'sessions',
'opensessions',
'subscribe-static',
'courseinsert-static',
'unsubscribe-static',
'care',
'careers',
'careersdiagram',
'careersresults',
];
foreach ($sections as $section) {
if (isset($fileToProcess[$section]) && !empty($fileToProcess[$section])) {
$this->logger->addInfo("-- Import $section --");
$files = $fileToProcess[$section];
foreach ($files as $fileInfo) {
$method = $fileInfo['method'];
$file = $fileInfo['file'];
echo 'File: '.$file.PHP_EOL;
echo 'Method : '.$method.PHP_EOL;
echo PHP_EOL;
$this->logger->addInfo('====================================================');
$this->logger->addInfo("Reading file: $file");
$this->logger->addInfo("Loading method $method ");
if ('importSessions' == $method || 'importOpenSessions' == $method) {
$this->$method(
$file,
true,
$teacherBackup,
$groupBackup
);
} else {
$this->$method($file, true);
}
$this->logger->addInfo('--Finish reading file--');
}
}
}
$sections = [
'students-static',
'teachers-static',
'courses-static',
'sessions-static',
'sessionsextid-static',
'unsubscribe-static',
'unsubsessionsextid-static',
'subsessionsextid-static',
'calendar-static',
];
foreach ($sections as $section) {
if (isset($fileToProcessStatic[$section]) &&
!empty($fileToProcessStatic[$section])
) {
$this->logger->addInfo("-- Import static files $section --");
$files = $fileToProcessStatic[$section];
foreach ($files as $fileInfo) {
$method = $fileInfo['method'];
$file = $fileInfo['file'];
echo 'Static file: '.$file.PHP_EOL;
echo 'Method : '.$method.PHP_EOL;
echo PHP_EOL;
$this->logger->addInfo("Reading static file: $file");
$this->logger->addInfo("Loading method $method ");
$this->$method(
$file,
true,
$teacherBackup,
$groupBackup
);
$this->logger->addInfo('--Finish reading file--');
}
}
}
$this->logger->addInfo('teacher backup');
$this->logger->addInfo(print_r($teacherBackup, 1));
}
}
/**
* @param $file
* @param bool $moveFile
*/
public function importCare($file, $moveFile = false)
{
$data = Import::csv_reader($file);
$counter = 1;
$batchSize = $this->batchSize;
$em = Database::getManager();
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
$items = [];
foreach ($data as $list) {
$post = [];
foreach ($list as $key => $value) {
$key = (string) trim($key);
// Remove utf8 bom
$key = preg_replace('/[\x00-\x1F\x80-\xFF]/', '', $key);
$post[$key] = $value;
}
if (empty($post)) {
continue;
}
$externalId = $post['External_care_id'];
$items[$externalId] = $post;
}
ksort($items);
foreach ($items as $row) {
// Insert user
//$insertUserInfo = api_get_user_info_from_username($row['Added_by']);
// User about the post
$userId = UserManager::get_user_id_from_original_id(
$row['Added_by'],
$this->extraFieldIdNameList['user']
);
$insertUserInfo = api_get_user_info($userId);
if (empty($insertUserInfo)) {
$this->logger->addInfo("User: '".$row['Added_by']."' doesn't exists. Skip this entry.");
continue;
}
$insertUserInfo = api_get_user_entity($insertUserInfo['user_id']);
// User about the post
$userId = UserManager::get_user_id_from_original_id(
$row['External_user_id'],
$this->extraFieldIdNameList['user']
);
if (empty($userId)) {
$this->logger->addInfo("User does '".$row['External_user_id']."' not exists skip this entry.");
continue;
}
$userInfo = api_get_user_entity($userId);
if (empty($userInfo)) {
$this->logger->addInfo("Chamilo user does not found: #".$userId."' ");
continue;
}
// Dates
$createdAt = $this->createDateTime($row['Added_On']);
$updatedAt = $this->createDateTime($row['Edited_on']);
// Parent
$parent = null;
if (!empty($row['Parent_id'])) {
$parentId = $items[$row['Parent_id']];
$criteria = [
'externalCareId' => $parentId,
];
$parent = $em->getRepository('ChamiloPluginBundle:StudentFollowUp\CarePost')->findOneBy($criteria);
}
// Tags
$tags = explode(',', $row['Tags']);
// Check if post already was added:
$criteria = [
'externalCareId' => $row['External_care_id'],
];
$post = $em->getRepository('ChamiloPluginBundle:StudentFollowUp\CarePost')->findOneBy($criteria);
if (empty($post)) {
$post = new CarePost();
$this->logger->addInfo("New post will be created no match for externalCareId = ".$row['External_care_id']);
}
$contentDecoded = utf8_encode(base64_decode($row['Article']));
$post
->setTitle($row['Title'])
->setContent($contentDecoded)
->setExternalCareId($row['External_care_id'])
->setCreatedAt($createdAt)
->setUpdatedAt($updatedAt)
->setPrivate((int) $row['Private'])
->setInsertUser($insertUserInfo)
->setExternalSource((int) $row['Source_is_external'])
->setParent($parent)
->setTags($tags)
->setUser($userInfo)
->setAttachment($row['Attachement'])
;
$em->persist($post);
$em->flush();
$this->logger->addInfo("Post id saved #".$post->getId());
if (0 === ($counter % $batchSize)) {
$em->flush();
$em->clear(); // Detaches all objects from Doctrine!
}
$counter++;
}
$em->clear(); // Detaches all objects from Doctrine!
}
}
/**
* @return mixed
*/
public function getUpdateEmailToDummy()
{
return $this->updateEmailToDummy;
}
/**
* @param mixed $updateEmailToDummy
*/
public function setUpdateEmailToDummy($updateEmailToDummy)
{
$this->updateEmailToDummy = $updateEmailToDummy;
}
/**
* Change emails of all users except admins.
*/
public function updateUsersEmails()
{
if (true === $this->getUpdateEmailToDummy()) {
$sql = "UPDATE user SET email = CONCAT(username,'@example.com') WHERE id NOT IN (SELECT user_id FROM admin)";
Database::query($sql);
}
}
/**
* Prepares extra fields before the import.
*/
private function prepareImport()
{
// Create user extra field: extra_external_user_id
UserManager::create_extra_field(
$this->extraFieldIdNameList['user'],
1,
'External user id',
null
);
// Create course extra field: extra_external_course_id
CourseManager::create_course_extra_field(
$this->extraFieldIdNameList['course'],
1,
'External course id',
''
);
CourseManager::create_course_extra_field(
'disable_import_calendar',
13,
'Disable import calendar',
''
);
// Create session extra field extra_external_session_id
SessionManager::create_session_extra_field(
$this->extraFieldIdNameList['session'],
1,
'External session id'
);
SessionManager::create_session_extra_field(
$this->extraFieldIdNameList['session_career'],
1,
'Career id'
);
// Create calendar_event extra field extra_external_session_id
$extraField = new ExtraField('calendar_event');
$extraField->save(
[
'value_type' => ExtraField::FIELD_TYPE_TEXT,
'variable' => $this->extraFieldIdNameList['calendar_event'],
'display_text' => 'External calendar event id',
]
);
$extraField = new ExtraField('career');
$extraField->save(
[
'visible_to_self' => 1,
'value_type' => ExtraField::FIELD_TYPE_TEXT,
'variable' => $this->extraFieldIdNameList['career'],
'display_text' => 'External career id',
]
);
$extraField->save(
[
'visible_to_self' => 1,
'value_type' => ExtraField::FIELD_TYPE_TEXTAREA,
'variable' => $this->extraFieldIdNameList['career_diagram'],
'display_text' => 'Career diagram',
]
);
$extraField->save(
[
'visible_to_self' => 1,
'value_type' => ExtraField::FIELD_TYPE_TEXTAREA,
'variable' => $this->extraFieldIdNameList['career_urls'],
'display_text' => 'Career urls',
]
);
}
/**
* @param string $file
*/
private function moveFile($file)
{
$moved = str_replace('incoming', 'treated', $file);
if ($this->test) {
$result = 1;
} else {
$result = rename($file, $moved);
}
if ($result) {
$this->logger->addInfo("Moving file to the treated folder: $file");
} else {
$this->logger->addError(
"Error - Cant move file to the treated folder: $file"
);
}
}
/**
* @param array $row
*
* @return array
*/
private function cleanUserRow($row)
{
$row['lastname'] = $row['LastName'];
$row['firstname'] = $row['FirstName'];
$row['email'] = $row['Email'];
$row['username'] = $row['UserName'];
$row['password'] = $row['Password'];
$row['auth_source'] = isset($row['AuthSource']) ? $row['AuthSource'] : PLATFORM_AUTH_SOURCE;
$row['official_code'] = $row['OfficialCode'];
$row['phone'] = isset($row['PhoneNumber']) ? $row['PhoneNumber'] : '';
if (isset($row['StudentID'])) {
$row['extra_'.$this->extraFieldIdNameList['user']] = $row['StudentID'];
}
if (isset($row['TeacherID'])) {
$row['extra_'.$this->extraFieldIdNameList['user']] = $row['TeacherID'];
}
return $row;
}
/**
* @param array $row
*
* @return array
*/
private function cleanCourseRow($row)
{
$row['title'] = $row['Title'];
$row['course_code'] = $row['Code'];
$row['course_category'] = $row['CourseCategory'];
$row['email'] = $row['Teacher'];
$row['language'] = $row['Language'];
$row['visibility'] = isset($row['Visibility']) ? $row['Visibility'] : COURSE_VISIBILITY_REGISTERED;
$row['teachers'] = [];
if (isset($row['Teacher']) && !empty($row['Teacher'])) {
$this->logger->addInfo("Teacher list found: ".$row['Teacher']);
$teachers = explode(',', $row['Teacher']);
if (!empty($teachers)) {
foreach ($teachers as $teacherUserName) {
$teacherUserName = trim($teacherUserName);
$userInfo = api_get_user_info_from_username($teacherUserName);
if (!empty($userInfo)) {
$this->logger->addInfo("Username found: $teacherUserName");
$row['teachers'][] = $userInfo['user_id'];
}
}
}
}
if (isset($row['CourseID'])) {
$row['extra_'.$this->extraFieldIdNameList['course']] = $row['CourseID'];
}
return $row;
}
/**
* File to import.
*
* @param string $file
*/
private function importTeachersStatic($file)
{
$this->importTeachers($file, true);
}
/**
* File to import.
*
* @param string $file
* @param bool $moveFile
*/
private function importTeachers($file, $moveFile = true)
{
$this->fixCSVFile($file);
$data = Import::csvToArray($file);
/* Unique identifier: official-code username.
Email address and password should never get updated. *ok
The only fields that I can think of that should update if the data changes in the csv file are FirstName and LastName. *ok
A slight edit of these fields should be taken into account. ???
Adding teachers is no problem, but deleting them shouldn’t be automated, but we should get a log of “to delete teachers”.
We’ll handle that manually if applicable.
No delete!
*/
$language = $this->defaultLanguage;
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
$expirationDateOnCreation = api_get_utc_datetime(strtotime("+".intval($this->expirationDateInUserCreation)."years"));
$expirationDateOnUpdate = api_get_utc_datetime(strtotime("+".intval($this->expirationDateInUserUpdate)."years"));
$batchSize = $this->batchSize;
$em = Database::getManager();
$counter = 1;
foreach ($data as $row) {
$row = $this->cleanUserRow($row);
$externalUserId = $row['official_code'];
$row['extra_'.$this->extraFieldIdNameList['user']] = $externalUserId;
$user_id = UserManager::get_user_id_from_original_id(
$row['extra_'.$this->extraFieldIdNameList['user']],
$this->extraFieldIdNameList['user']
);
$userInfo = [];
$userInfoByOfficialCode = null;
if (!empty($user_id)) {
$userInfo = api_get_user_info($user_id);
$userInfoByOfficialCode = api_get_user_info_from_official_code($row['official_code']);
}
if (empty($userInfo) && empty($userInfoByOfficialCode)) {
// Create user
$userId = UserManager::create_user(
$row['firstname'],
$row['lastname'],
COURSEMANAGER,
$row['email'],
$row['username'],
$row['password'],
$row['official_code'],
$language, //$row['language'],
$row['phone'],
null, //$row['picture'], //picture
$row['auth_source'], // ?
$expirationDateOnCreation, //'0000-00-00 00:00:00', //$row['expiration_date'], //$expiration_date = '0000-00-00 00:00:00',
1, //active
0,
null, // extra
null, //$encrypt_method = '',
false //$send_mail = false
);
$row['extra_mail_notify_invitation'] = 1;
$row['extra_mail_notify_message'] = 1;
$row['extra_mail_notify_group_message'] = 1;
if ($userId) {
foreach ($row as $key => $value) {
if ('extra_' == substr($key, 0, 6)) {
//an extra field
UserManager::update_extra_field_value(
$userId,
substr($key, 6),
$value
);
}
}
$this->logger->addInfo("Teachers - User created: ".$row['username']);
} else {
$this->logger->addError("Teachers - User NOT created: ".$row['username']." ".$row['firstname']." ".$row['lastname']);
$this->logger->addError(strip_tags(Display::getFlashToString()));
Display::cleanFlashMessages();
}
} else {
if (empty($userInfo)) {
$this->logger->addError("Teachers - Can't update user :".$row['username']);
continue;
}
// Update user
$result = UserManager::update_user(
$userInfo['user_id'],
$row['firstname'], // <<-- changed
$row['lastname'], // <<-- changed
$userInfo['username'],
null, //$password = null,
$row['auth_source'],
$userInfo['email'],
COURSEMANAGER,
$userInfo['official_code'],
$userInfo['phone'],
$userInfo['picture_uri'],
$expirationDateOnUpdate,
$userInfo['active'],
null, //$creator_id = null,
0, //$hr_dept_id = 0,
null, // $extra = null,
null, //$language = 'english',
null, //$encrypt_method = '',
false, //$send_email = false,
0 //$reset_password = 0
);
if ($result) {
foreach ($row as $key => $value) {
if ('extra_' == substr($key, 0, 6)) {
//an extra field
UserManager::update_extra_field_value(
$userInfo['user_id'],
substr($key, 6),
$value
);
}
}
$this->logger->addInfo("Teachers - User updated: ".$row['username']);
} else {
$this->logger->addError("Teachers - User not updated: ".$row['username']);
}
}
if (0 === ($counter % $batchSize)) {
$em->flush();
$em->clear(); // Detaches all objects from Doctrine!
}
$counter++;
}
$em->clear(); // Detaches all objects from Doctrine!
}
if ($moveFile) {
$this->moveFile($file);
}
$this->updateUsersEmails();
}
/**
* @param string $file
*/
private function importStudentsStatic($file)
{
$this->importStudents($file, true);
}
/**
* @param string $file
* @param bool $moveFile
*/
private function importStudents($file, $moveFile = true)
{
$this->fixCSVFile($file);
$data = Import::csvToArray($file);
/*
* Another users import.
Unique identifier: official code and username . ok
Password should never get updated. ok
If an update should need to occur (because it changed in the .csv),
we’ll want that logged. We will handle this manually in that case.
All other fields should be updateable, though passwords should of course not get updated. ok
If a user gets deleted (not there anymore),
He should be set inactive one year after the current date.
So I presume you’ll just update the expiration date.
We want to grant access to courses up to a year after deletion.
*/
$timeStart = microtime(true);
$batchSize = $this->batchSize;
$em = Database::getManager();
if (!empty($data)) {
$language = $this->defaultLanguage;
$this->logger->addInfo(count($data)." records found.");
$expirationDateOnCreate = api_get_utc_datetime(
strtotime("+".intval($this->expirationDateInUserCreation)."years")
);
$expirationDateOnUpdate = api_get_utc_datetime(
strtotime("+".intval($this->expirationDateInUserUpdate)."years")
);
$counter = 1;
$secondsInYear = 365 * 24 * 60 * 60;
foreach ($data as $row) {
$row = $this->cleanUserRow($row);
$externalUserId = $row['official_code'];
$row['extra_'.$this->extraFieldIdNameList['user']] = $externalUserId;
$user_id = UserManager::get_user_id_from_original_id(
$row['extra_'.$this->extraFieldIdNameList['user']],
$this->extraFieldIdNameList['user']
);
$userInfo = [];
$userInfoByOfficialCode = null;
if (!empty($user_id)) {
$userInfo = api_get_user_info($user_id, false, true);
$userInfoByOfficialCode = api_get_user_info_from_official_code($row['official_code']);
}
$userInfoFromUsername = api_get_user_info_from_username($row['username']);
if (!empty($userInfoFromUsername)) {
$extraFieldValue = new ExtraFieldValue('user');
$extraFieldValues = $extraFieldValue->get_values_by_handler_and_field_variable(
$userInfoFromUsername['user_id'],
$this->extraFieldIdNameList['user']
);
if (!empty($extraFieldValues)) {
$value = 0;
foreach ($extraFieldValues as $extraFieldValue) {
$value = $extraFieldValue['value'];
}
if (!empty($user_id) && $value != $user_id) {
$emails = api_get_setting('mail.cron_notification_help_desk', true);
if (!empty($emails)) {
$this->logger->addInfo('Preparing email to users in configuration: "cron_notification_help_desk"');
$subject = 'User not added due to same username';
$body = 'Cannot add username: "'.$row['username'].'"
with external_user_id: '.$row['extra_'.$this->extraFieldIdNameList['user']].'
because '.$userInfoFromUsername['username'].' with external_user_id '.$value.' exists on the portal';
$this->logger->addInfo($body);
foreach ($emails as $email) {
api_mail_html('', $email, $subject, $body);
}
}
}
}
}
if (empty($userInfo) && empty($userInfoByOfficialCode)) {
// Create user
$result = UserManager::create_user(
$row['firstname'],
$row['lastname'],
STUDENT,
$row['email'],
$row['username'],
$row['password'],
$row['official_code'],
$language, //$row['language'],
$row['phone'],
null, //$row['picture'], //picture
$row['auth_source'], // ?
$expirationDateOnCreate,
1, //active
0,
null, // extra
null, //$encrypt_method = '',
false //$send_mail = false
);
$row['extra_mail_notify_invitation'] = 1;
$row['extra_mail_notify_message'] = 1;
$row['extra_mail_notify_group_message'] = 1;
if ($result) {
foreach ($row as $key => $value) {
if ('extra_' === substr($key, 0, 6)) {
//an extra field
UserManager::update_extra_field_value(
$result,
substr($key, 6),
$value
);
}
}
$this->logger->addInfo("Students - User created: ".$row['username']);
} else {
$this->logger->addError("Students - User NOT created: ".$row['username']." ".$row['firstname']." ".$row['lastname']);
$this->logger->addError(strip_tags(Display::getFlashToString()));
Display::cleanFlashMessages();
}
} else {
if (empty($userInfo)) {
$this->logger->addError("Students - Can't update user :".$row['username']);
continue;
}
if (isset($row['action']) && 'delete' === $row['action']) {
// Inactive one year later
$userInfo['expiration_date'] = api_get_utc_datetime(api_strtotime(time() + $secondsInYear));
}
$password = $row['password']; // change password
$email = $row['email']; // change email
$resetPassword = 2; // allow password change
// Conditions that disables the update of password and email:
if (isset($this->conditions['importStudents'])) {
if (isset($this->conditions['importStudents']['update']) &&
isset($this->conditions['importStudents']['update']['avoid'])
) {
// Blocking email update -
// 1. Condition
$avoidUsersWithEmail = $this->conditions['importStudents']['update']['avoid']['email'];
if ($userInfo['email'] != $row['email'] && in_array($row['email'], $avoidUsersWithEmail)) {
$this->logger->addInfo("Students - User email is not updated : ".$row['username']." because the avoid conditions (email).");
// Do not change email keep the old email.
$email = $userInfo['email'];
}
// 2. Condition
if (!in_array($userInfo['email'], $avoidUsersWithEmail) && !in_array($row['email'], $avoidUsersWithEmail)) {
$email = $userInfo['email'];
}
// 3. Condition
if (in_array($userInfo['email'], $avoidUsersWithEmail) && !in_array($row['email'], $avoidUsersWithEmail)) {
$email = $row['email'];
}
// Blocking password update
//$avoidUsersWithPassword = $this->conditions['importStudents']['update']['avoid']['password'];
/*if (isset($row['password'])) {
$user = api_get_user_entity($userInfo['id']);
$encoded = UserManager::encryptPassword(
$row['password'],
$user
);
if ($userInfo['password'] != $encoded &&
in_array($row['password'], $avoidUsersWithPassword)
) {
$this->logger->addInfo(
"Students - User password is not updated: ".$row['username']." because the avoid conditions (password)."
);
$password = null;
$resetPassword = 0; // disallow password change
}
}*/
}
}
// Always disallow password change during update
$password = null;
$resetPassword = 0; // disallow password change
// Update user
$result = UserManager::update_user(
$userInfo['user_id'],
$row['firstname'], // <<-- changed
$row['lastname'], // <<-- changed
$row['username'], // <<-- changed
$password, //$password = null,
$row['auth_source'],
$email,
STUDENT,
$userInfo['official_code'],
$userInfo['phone'],
$userInfo['picture_uri'],
$expirationDateOnUpdate,
$userInfo['active'],
null, //$creator_id = null,
0, //$hr_dept_id = 0,
null, // $extra = null,
null, //$language = 'english',
null, //$encrypt_method = '',
false, //$send_email = false,
$resetPassword //$reset_password = 0
);
if ($result) {
if ($row['username'] != $userInfo['username']) {
$this->logger->addInfo("Students - Username was changes from '".$userInfo['username']."' to '".$row['username']."' ");
}
foreach ($row as $key => $value) {
if ('extra_' === substr($key, 0, 6)) {
//an extra field
UserManager::update_extra_field_value(
$userInfo['user_id'],
substr($key, 6),
$value
);
}
}
$this->logger->addInfo("Students - User updated: ".$row['username']);
} else {
$this->logger->addError("Students - User NOT updated: ".$row['username']." ".$row['firstname']." ".$row['lastname']);
}
}
if (0 === ($counter % $batchSize)) {
$em->flush();
$em->clear(); // Detaches all objects from Doctrine!
$this->logger->addInfo("Detaches all objects");
}
$counter++;
}
$em->clear(); // Detaches all objects from Doctrine!
}
$timeEnd = microtime(true);
$executionTime = round(($timeEnd - $timeStart) / 60, 2);
$this->logger->addInfo("Execution Time for process students: $executionTime Min");
if ($moveFile) {
$this->moveFile($file);
}
$this->updateUsersEmails();
}
/**
* @param string $file
*/
private function importCoursesStatic($file, $moveFile, &$teacherBackup = [], &$groupBackup = [])
{
$this->importCourses($file, true, $teacherBackup, $groupBackup);
}
/**
* @param string $file
* @param bool $moveFile
*
* @return int
*/
private function importCalendarStatic($file, $moveFile = true)
{
$this->fixCSVFile($file);
$this->updateUsersEmails();
$data = Import::csvToArray($file);
if (!empty($data)) {
$this->logger->addInfo(count($data).' records found.');
$eventsToCreate = [];
$errorFound = false;
$courseExtraFieldValue = new ExtraFieldValue('course');
foreach ($data as $row) {
$sessionId = null;
$externalSessionId = null;
if (isset($row['external_sessionID'])) {
$externalSessionId = $row['external_sessionID'];
$sessionId = SessionManager::getSessionIdFromOriginalId(
$externalSessionId,
$this->extraFieldIdNameList['session']
);
}
$courseCode = null;
if (isset($row['coursecode'])) {
$courseCode = $row['coursecode'];
}
$courseInfo = api_get_course_info($courseCode);
$item = $courseExtraFieldValue->get_values_by_handler_and_field_variable(
$courseInfo['real_id'],
'disable_import_calendar'
);
if (!empty($item) && isset($item['value']) && 1 == $item['value']) {
$this->logger->addInfo(
"Course '".$courseInfo['code']."' has 'disable_import_calendar' turn on. Skip"
);
$errorFound = true;
}
if (empty($courseInfo)) {
$this->logger->addInfo("Course '$courseCode' does not exists");
} else {
if (COURSE_VISIBILITY_HIDDEN == $courseInfo['visibility']) {
$this->logger->addInfo("Course '".$courseInfo['code']."' has hidden visiblity. Skip");
$errorFound = true;
}
}
if (empty($sessionId)) {
$this->logger->addInfo("external_sessionID: $externalSessionId does not exists.");
}
$teacherId = null;
$sessionInfo = [];
if (!empty($sessionId) && !empty($courseInfo)) {
$sessionInfo = api_get_session_info($sessionId);
$courseIncluded = SessionManager::relation_session_course_exist(
$sessionId,
$courseInfo['real_id']
);
if (false == $courseIncluded) {
$this->logger->addInfo(
"Course '$courseCode' is not included in session: $sessionId"
);
$errorFound = true;
} else {
$teachers = CourseManager::get_coach_list_from_course_code(
$courseInfo['code'],
$sessionId
);
// Getting first teacher.
if (!empty($teachers)) {
$teacher = current($teachers);
$teacherId = $teacher['user_id'];
} else {
$generalCoachesId = SessionManager::getGeneralCoachesIdForSession($sessionId);
$teacherId = $generalCoachesId[0] ?? 0;
}
}
} else {
$errorFound = true;
}
if (empty($teacherId)) {
$errorFound = true;
$this->logger->addInfo(
"No teacher found in course code : '$courseCode' and session: '$sessionId'"
);
}
$date = $row['date'];
$startTime = $row['time_start'];
$endTime = $row['time_end'];
$title = $row['title'];
$comment = $row['comment'];
$color = isset($row['color']) ? $row['color'] : '';
$startDateYear = substr($date, 0, 4);
$startDateMonth = substr($date, 4, 2);
$startDateDay = substr($date, 6, 8);
$startDate = $startDateYear.'-'.$startDateMonth.'-'.$startDateDay.' '.$startTime.':00';
$endDate = $startDateYear.'-'.$startDateMonth.'-'.$startDateDay.' '.$endTime.':00';
if (!api_is_valid_date($startDate) || !api_is_valid_date($endDate)) {
$this->logger->addInfo("Verify your dates: '$startDate' : '$endDate' ");
$errorFound = true;
}
// Check session dates
if ($sessionInfo && !empty($sessionInfo['access_start_date'])) {
$date = new \DateTime($sessionInfo['access_start_date']);
$interval = new \DateInterval('P7D');
$date->sub($interval);
if ($date->getTimestamp() > time()) {
$this->logger->addInfo(
"Calendar event # ".$row['external_calendar_itemID']."
in session [$externalSessionId] was not added
because the startdate is more than 7 days in the future: ".$sessionInfo['access_start_date']
);
$errorFound = true;
}
}
if (false == $errorFound) {
$eventsToCreate[] = [
'start' => $startDate,
'end' => $endDate,
'title' => $title,
'sender_id' => $teacherId,
'course_id' => $courseInfo['real_id'],
'session_id' => $sessionId,
'comment' => $comment,
'color' => $color,
$this->extraFieldIdNameList['calendar_event'] => $row['external_calendar_itemID'],
];
}
$errorFound = false;
}
if (empty($eventsToCreate)) {
$this->logger->addInfo('No events to add');
return 0;
}
$extraFieldValue = new ExtraFieldValue('calendar_event');
$extraFieldName = $this->extraFieldIdNameList['calendar_event'];
$externalEventId = null;
$extraField = new ExtraField('calendar_event');
$extraFieldInfo = $extraField->get_handler_field_info_by_field_variable($extraFieldName);
if (empty($extraFieldInfo)) {
$this->logger->addInfo(
"No calendar event extra field created: $extraFieldName"
);
return 0;
}
$this->logger->addInfo('Ready to insert # '.count($eventsToCreate).' events');
$batchSize = $this->batchSize;
$counter = 1;
$em = Database::getManager();
$eventStartDateList = [];
$eventEndDateList = [];
$report = [
'mail_sent' => 0,
'mail_not_sent_announcement_exists' => 0,
'mail_not_sent_because_date' => 0,
];
$eventsToCreateFinal = [];
foreach ($eventsToCreate as $event) {
$update = false;
$item = null;
if (!isset($event[$extraFieldName])) {
$this->logger->addInfo('No external_calendar_itemID found. Skipping ...');
continue;
} else {
$externalEventId = $event[$extraFieldName];
if (empty($externalEventId)) {
$this->logger->addInfo('external_calendar_itemID was set but empty. Skipping ...');
continue;
}
$item = $extraFieldValue->get_item_id_from_field_variable_and_field_value(
$extraFieldName,
$externalEventId,
false,
false,
false
);
if (!empty($item)) {
$update = true;
}
}
$courseInfo = api_get_course_info_by_id($event['course_id']);
$event['course_info'] = $courseInfo;
$event['update'] = $update;
$event['item'] = $item;
$calendarEvent = null;
/* Check if event changed of course code */
if (!empty($item) && isset($item['item_id']) && !empty($item['item_id'])) {
/** @var CCalendarEvent $calendarEvent */
$calendarEvent = $em->getRepository('ChamiloCourseBundle:CCalendarEvent')->find($item['item_id']);
}
if ($calendarEvent) {
$this->logger->addInfo('Calendar event found '.$item['item_id']);
if ($calendarEvent->getCId() != $courseInfo['real_id']) {
$this->logger->addInfo('Move from course #'.$calendarEvent->getCId().' to #'.$courseInfo['real_id']);
// Seems that the course id changed in the csv
$calendarEvent->setCId($courseInfo['real_id']);
$em->persist($calendarEvent);
$em->flush();
$criteria = [
'tool' => 'calendar_event',
'ref' => $item['item_id'],
];
/** @var CItemProperty $itemProperty */
$itemProperty = $em->getRepository('ChamiloCourseBundle:CItemProperty')->findOneBy($criteria);
$courseEntity = $em->getRepository('ChamiloCoreBundle:Course')->find($courseInfo['real_id']);
if ($itemProperty && $courseEntity) {
$itemProperty->setCourse($courseEntity);
$em->persist($itemProperty);
$em->flush();
}
}
// Checking if session still exists
$calendarSessionId = (int) $calendarEvent->getSessionId();
if (!empty($calendarSessionId)) {
$calendarSessionInfo = api_get_session_info($calendarSessionId);
if (empty($calendarSessionInfo)) {
$calendarId = (int) $calendarEvent->getIid();
// Delete calendar events because the session was deleted!
$this->logger->addInfo(
"Delete event # $calendarId because session # $calendarSessionId doesn't exist"
);
$sql = "DELETE FROM c_calendar_event
WHERE iid = $calendarId AND session_id = $calendarSessionId";
Database::query($sql);
$this->logger->addInfo($sql);
$sql = "DELETE FROM c_item_property
WHERE
tool = 'calendar_event' AND
ref = $calendarSessionId AND
session_id = $calendarSessionId";
Database::query($sql);
$this->logger->addInfo($sql);
}
}
} else {
$this->logger->addInfo('Calendar event not found '.$item['item_id']);
}
$event['external_event_id'] = $externalEventId;
if (isset($eventStartDateList[$courseInfo['real_id']]) &&
isset($eventStartDateList[$courseInfo['real_id']][$event['session_id']])
) {
$currentItemDate = api_strtotime($event['start']);
$firstDate = $eventStartDateList[$courseInfo['real_id']][$event['session_id']];
if ($currentItemDate < api_strtotime($firstDate)) {
$eventStartDateList[$courseInfo['real_id']][$event['session_id']] = $event['start'];
$eventEndDateList[$courseInfo['real_id']][$event['session_id']] = $event['end'];
}
} else {
// First time
$eventStartDateList[$courseInfo['real_id']][$event['session_id']] = $event['start'];
$eventEndDateList[$courseInfo['real_id']][$event['session_id']] = $event['end'];
}
$eventsToCreateFinal[] = $event;
}
$eventAlreadySent = [];
$tpl = new Template(null, false, false, false, false, false, false);
foreach ($eventsToCreateFinal as $event) {
$courseInfo = $event['course_info'];
$item = $event['item'];
$update = $event['update'];
$externalEventId = $event['external_event_id'];
$info = 'Course: '.$courseInfo['real_id'].' ('.$courseInfo['code'].') - Session: '.$event['session_id'].' external event id: '.$externalEventId;
$agenda = new Agenda(
'course',
$event['sender_id'],
$courseInfo['real_id'],
$event['session_id']
);
$agenda->set_course($courseInfo);
$agenda->setSessionId($event['session_id']);
$agenda->setSenderId($event['sender_id']);
$agenda->setIsAllowedToEdit(true);
$eventComment = $event['comment'];
$color = $event['color'];
// To use the event comment you need
// ALTER TABLE c_calendar_event ADD COLUMN comment TEXT;
// add in configuration.php allow_agenda_event_comment = true
if (empty($courseInfo)) {
$this->logger->addInfo(
"No course found for event #$externalEventId Course #".$event['course_id']." Skipping ..."
);
continue;
}
if (empty($event['sender_id'])) {
$this->logger->addInfo(
"No sender found for event #$externalEventId Send #".$event['sender_id']." Skipping ..."
);
continue;
}
// Taking first element of course-session event
$alreadyAdded = false;
$firstDate = $eventStartDateList[$courseInfo['real_id']][$event['session_id']];
$firstEndDate = $eventEndDateList[$courseInfo['real_id']][$event['session_id']];
if (isset($eventAlreadySent[$courseInfo['real_id']]) &&
isset($eventAlreadySent[$courseInfo['real_id']][$event['session_id']])
) {
$alreadyAdded = true;
} else {
$eventAlreadySent[$courseInfo['real_id']][$event['session_id']] = true;
}
// Working days (Mon-Fri)see BT#12156#note-16
$days = 3;
$startDatePlusDays = api_strtotime("$days weekdays");
/*
$timePart = date('H:i:s', api_strtotime('now'));
$datePart = date('Y-m-d', api_strtotime("$days weekdays"));
$startDatePlusDays = "$timePart $datePart";
*/
$this->logger->addInfo(
'startDatePlusDays: '.api_get_utc_datetime($startDatePlusDays).' - First date: '.$firstDate
);
// Send
$sendMail = false;
if ($startDatePlusDays > api_strtotime($firstDate)) {
$sendMail = true;
}
// Send announcement to users
if ($sendMail && false == $alreadyAdded) {
$start = $firstDate;
$end = $firstEndDate;
if (!empty($end) &&
api_format_date($start, DATE_FORMAT_LONG) ==
api_format_date($end, DATE_FORMAT_LONG)
) {
$date = api_format_date($start, DATE_FORMAT_LONG).' ('.
api_format_date($start, TIME_NO_SEC_FORMAT).' '.
api_format_date($end, TIME_NO_SEC_FORMAT).')';
} else {
$date = api_format_date($start, DATE_TIME_FORMAT_LONG_24H).' - '.
api_format_date($end, DATE_TIME_FORMAT_LONG_24H);
}
$sessionName = '';
$sessionId = isset($event['session_id']) && !empty($event['session_id']) ? $event['session_id'] : 0;
if (!empty($sessionId)) {
$sessionName = api_get_session_name($sessionId);
}
$courseTitle = $courseInfo['title'];
// Get the value of the "careerid" extra field of this
// session
$sessionExtraFieldValue = new ExtraFieldValue('session');
$externalCareerIdList = $sessionExtraFieldValue->get_values_by_handler_and_field_variable(
$event['session_id'],
'careerid'
);
$externalCareerIdList = $externalCareerIdList['value'];
if ('[' === substr($externalCareerIdList, 0, 1)) {
$externalCareerIdList = substr($externalCareerIdList, 1, -1);
$externalCareerIds = preg_split('/,/', $externalCareerIdList);
} else {
$externalCareerIds = [$externalCareerIdList];
}
$careerExtraFieldValue = new ExtraFieldValue('career');
$career = new Career();
$careerName = '';
// Concat the names of each career linked to this session
foreach ($externalCareerIds as $externalCareerId) {
// Using the external_career_id field (from above),
// find the career ID
$careerValue = $careerExtraFieldValue->get_item_id_from_field_variable_and_field_value(
'external_career_id',
$externalCareerId
);
$career = $career->find($careerValue['item_id']);
$careerName .= $career['name'].', ';
}
// Remove trailing comma
$careerName = substr($careerName, 0, -2);
$subject = sprintf(
get_lang('WelcomeToPortalXInCourseSessionX'),
api_get_setting('Institution'),
$courseInfo['title']
);
$tpl->assign('course_title', $courseTitle);
$tpl->assign('career_name', $careerName);
$tpl->assign('first_lesson', $date);
$tpl->assign('location', $eventComment);
$tpl->assign('session_name', $sessionName);
if (empty($sessionId)) {
$teachersToString = CourseManager::getTeacherListFromCourseCodeToString($courseInfo['code'], ',');
} else {
$teachersToString = SessionManager::getCoachesByCourseSessionToString(
$sessionId,
$courseInfo['real_id'],
','
);
}
$tpl->assign('teachers', $teachersToString);
$templateName = $tpl->get_template('mail/custom_calendar_welcome.tpl');
$emailBody = $tpl->fetch($templateName);
$coaches = SessionManager::getCoachesByCourseSession(
$event['session_id'],
$courseInfo['real_id']
);
// Search if an announcement exists:
$announcementsWithTitleList = AnnouncementManager::getAnnouncementsByTitle(
$subject,
$courseInfo['real_id'],
$event['session_id'],
1
);
if (0 === count($announcementsWithTitleList)) {
$this->logger->addInfo(
'Mail to be sent because start date: '.$event['start'].' and no announcement found.'
);
$senderId = $this->defaultAdminId;
if (!empty($coaches) && isset($coaches[0]) && !empty($coaches[0])) {
$senderId = $coaches[0];
}
$announcementId = AnnouncementManager::add_announcement(
$courseInfo,
$event['session_id'],
$subject,
$emailBody,
[
'everyone',
'users' => $coaches,
],
[],
null,
null,
false,
$senderId
);
if ($announcementId) {
$this->logger->addInfo("Announcement added: $announcementId in $info");
$this->logger->addInfo("<<--SENDING MAIL Sender id: $senderId-->>");
$report['mail_sent']++;
AnnouncementManager::sendEmail(
$courseInfo,
$event['session_id'],
$announcementId,
false,
false,
$this->logger,
$senderId,
true
);
} else {
$this->logger->addError(
"Error when trying to add announcement with title $subject here: $info and SenderId = $senderId"
);
}
} else {
$report['mail_not_sent_announcement_exists']++;
$this->logger->addInfo(
"Mail NOT sent. An announcement seems to be already saved in '$info'"
);
}
} else {
$this->logger->addInfo(
"Send Mail: ".intval($sendMail).' - Already added: '.intval($alreadyAdded)
);
if (false == $sendMail) {
$report['mail_not_sent_because_date']++;
}
}
$content = '';
if ($update && isset($item['item_id'])) {
$eventInfo = $agenda->get_event($item['item_id']);
if (empty($eventInfo)) {
// Means that agenda external id exists but the event doesn't exist
$this->logger->addInfo("external event id exists: $externalEventId");
$this->logger->addInfo("but Chamilo event doesn't exists: ".$item['item_id']);
$eventId = $agenda->addEvent(
$event['start'],
$event['end'],
false,
$event['title'],
$content,
['everyone'], // $usersToSend
false, //$addAsAnnouncement = false
null, // $parentEventId
[], //$attachmentArray = array(),
[], //$attachmentCommentList
$eventComment,
$color
);
if (!empty($eventId)) {
$this->logger->addInfo("Chamilo event created: ".$eventId);
$extraFieldValueItem = $extraFieldValue->get_values_by_handler_and_field_id(
$item['item_id'],
$extraFieldInfo['id']
);
if (!empty($extraFieldValueItem) && isset($extraFieldValueItem['id'])) {
$params = [
'id' => $extraFieldValueItem['id'],
'item_id' => $eventId,
];
$extraFieldValue->update($params);
$this->logger->addInfo(
'Updating calendar extra field #'.$extraFieldValueItem['id'].'
new item_id: '.$eventId.' old item_id: '.$item['item_id']
);
}
} else {
$this->logger->addInfo("Error while creating event external id: $externalEventId");
}
} else {
// The event already exists, just update
$eventResult = $agenda->editEvent(
$item['item_id'],
$event['start'],
$event['end'],
false,
$event['title'],
$content,
['everyone'], // $usersToSend
[], //$attachmentArray = array(),
[], //$attachmentCommentList
$eventComment,
$color,
false,
false,
$this->defaultAdminId
);
if (false !== $eventResult) {
$this->logger->addInfo(
"Event updated #".$item['item_id']." External cal Id: (".$externalEventId.") $info"
);
} else {
$this->logger->addInfo(
"Error while updating event with external id: $externalEventId"
);
}
}
} else {
// New event. Create it.
$eventId = $agenda->addEvent(
$event['start'],
$event['end'],
false,
$event['title'],
$content,
['everyone'], // $usersToSend
false, //$addAsAnnouncement = false
null, // $parentEventId
[], //$attachmentArray = array(),
[], //$attachmentCommentList
$eventComment,
$color
);
if (!empty($eventId)) {
$extraFieldValue->save(
[
'field_value' => $externalEventId,
'field_id' => $extraFieldInfo['id'],
'item_id' => $eventId,
]
);
$this->logger->addInfo(
"Event added: #$eventId External cal id: (".$externalEventId.") $info"
);
} else {
$this->logger->addInfo(
"Error while creating event external id: $externalEventId"
);
}
}
if (0 === ($counter % $batchSize)) {
$em->flush();
$em->clear(); // Detaches all objects from Doctrine!
}
$counter++;
}
$em->clear(); // Detaches all objects from Doctrine!
$this->logger->addInfo('------Summary------');
foreach ($report as $title => $count) {
$this->logger->addInfo("$title: $count");
}
$this->logger->addInfo('------End Summary------');
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* @param string $file
* @param bool $moveFile
* @param array $teacherBackup
* @param array $groupBackup
*/
private function importCourses(
$file,
$moveFile = true,
&$teacherBackup = [],
&$groupBackup = []
) {
$this->fixCSVFile($file);
$data = Import::csvToArray($file);
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
foreach ($data as $row) {
$row = $this->cleanCourseRow($row);
$courseId = CourseManager::get_course_id_from_original_id(
$row['extra_'.$this->extraFieldIdNameList['course']],
$this->extraFieldIdNameList['course']
);
$courseInfo = api_get_course_info_by_id($courseId);
if (empty($courseInfo)) {
// Create
$params = [];
$params['title'] = $row['title'];
$params['exemplary_content'] = false;
$params['wanted_code'] = $row['course_code'];
$params['course_category'] = $row['course_category'];
$params['course_language'] = $row['language'];
$params['teachers'] = $row['teachers'];
$params['visibility'] = $row['visibility'];
$course = CourseManager::create_course(
$params,
$this->defaultAdminId
);
if (null !== $course) {
CourseManager::update_course_extra_field_value(
$course->getCode(),
'external_course_id',
$row['extra_'.$this->extraFieldIdNameList['course']]
);
$this->logger->addInfo("Courses - Course created ".$course->getCode());
} else {
$this->logger->addError("Courses - Can't create course:".$row['title']);
}
} else {
// Update
$params = [
'title' => $row['title'],
'category_code' => $row['course_category'],
'visibility' => $row['visibility'],
];
$result = CourseManager::update_attributes(
$courseInfo['real_id'],
$params
);
$addTeacherToSession = isset($courseInfo['add_teachers_to_sessions_courses']) && !empty($courseInfo['add_teachers_to_sessions_courses']) ? true : false;
$teachers = $row['teachers'];
if (!is_array($teachers)) {
$teachers = [$teachers];
}
if ($addTeacherToSession) {
$this->logger->addInfo("Add teacher to all course sessions");
CourseManager::updateTeachers(
$courseInfo,
$row['teachers'],
false,
true,
false,
$teacherBackup,
$this->logger
);
} else {
CourseManager::updateTeachers(
$courseInfo,
$row['teachers'],
true,
false,
false,
$teacherBackup,
$this->logger
);
}
foreach ($teachers as $teacherId) {
if (isset($groupBackup['tutor'][$teacherId]) &&
isset($groupBackup['tutor'][$teacherId][$courseInfo['code']])
) {
foreach ($groupBackup['tutor'][$teacherId][$courseInfo['code']] as $data) {
$groupInfo = GroupManager::get_group_properties($data['group_id']);
GroupManager::subscribeTutors(
[$teacherId],
$groupInfo,
$data['c_id']
);
}
}
if (isset($groupBackup['user'][$teacherId]) &&
isset($groupBackup['user'][$teacherId][$courseInfo['code']]) &&
!empty($groupBackup['user'][$teacherId][$courseInfo['code']])
) {
foreach ($groupBackup['user'][$teacherId][$courseInfo['code']] as $data) {
GroupManager::subscribeUsers(
[$teacherId],
api_get_group_entity($data['group_id']),
$data['c_id']
);
}
}
}
if ($result) {
$this->logger->addInfo("Courses - Course updated ".$courseInfo['code']);
} else {
$this->logger->addError("Courses - Course NOT updated ".$courseInfo['code']);
}
}
}
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* Parse filename: encora_subsessionsextid-static_31082016.csv.
*
* @param string $file
*/
private function importSubscribeUserToCourseSessionExtStatic($file, $moveFile = true)
{
$data = Import::csv_reader($file);
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
$userIdList = [];
foreach ($data as $row) {
$chamiloUserName = $row['UserName'];
$chamiloCourseCode = $row['CourseCode'];
$externalSessionId = $row['ExtSessionID'];
$status = $row['Status'];
$chamiloSessionId = null;
if (!empty($externalSessionId)) {
$chamiloSessionId = SessionManager::getSessionIdFromOriginalId(
$externalSessionId,
$this->extraFieldIdNameList['session']
);
}
$sessionInfo = api_get_session_info($chamiloSessionId);
if (empty($sessionInfo)) {
$this->logger->addError('Session does not exists: '.$chamiloSessionId);
continue;
}
$courseInfo = api_get_course_info($chamiloCourseCode);
if (empty($courseInfo)) {
$this->logger->addError('Course does not exists: '.$courseInfo);
continue;
}
$userId = UserManager::get_user_id_from_username($chamiloUserName);
if (empty($userId)) {
$this->logger->addError('User does not exists: '.$chamiloUserName);
continue;
}
switch ($status) {
case 'student':
SessionManager::subscribe_users_to_session_course(
[$userId],
$chamiloSessionId,
$courseInfo['code']
);
break;
case 'teacher':
SessionManager::set_coach_to_course_session(
$userId,
$chamiloSessionId,
$courseInfo['code']
);
break;
case 'drh':
$removeAllSessionsFromUser = true;
if (in_array($userId, $userIdList)) {
$removeAllSessionsFromUser = false;
} else {
$userIdList[] = $userId;
}
$userInfo = api_get_user_info($userId);
SessionManager::subscribeSessionsToDrh(
$userInfo,
[$chamiloSessionId],
false,
$removeAllSessionsFromUser
);
break;
}
$this->logger->addError(
"User '$chamiloUserName' was added as '$status' to Session: #$chamiloSessionId - Course: ".$courseInfo['code']
);
}
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* @param $file
* @param bool $moveFile
*/
private function importUnsubSessionsExtIdStatic($file, $moveFile = true)
{
$data = Import::csv_reader($file);
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
foreach ($data as $row) {
$chamiloUserName = $row['UserName'];
$chamiloCourseCode = $row['CourseCode'];
$externalSessionId = $row['ExtSessionID'];
$dateStop = $row['DateStop'];
$chamiloSessionId = null;
if (!empty($externalSessionId)) {
$chamiloSessionId = SessionManager::getSessionIdFromOriginalId(
$externalSessionId,
$this->extraFieldIdNameList['session']
);
}
$sessionInfo = api_get_session_info($chamiloSessionId);
if (empty($sessionInfo)) {
$this->logger->addError('Session does not exists: '.$chamiloSessionId);
continue;
}
$courseInfo = api_get_course_info($chamiloCourseCode);
if (empty($courseInfo)) {
$this->logger->addError('Course does not exists: '.$courseInfo);
continue;
}
$userId = UserManager::get_user_id_from_username($chamiloUserName);
if (empty($userId)) {
$this->logger->addError('User does not exists: '.$chamiloUserName);
continue;
}
SessionManager::removeUsersFromCourseSession(
[$userId],
$chamiloSessionId,
$courseInfo
);
$this->logger->addError(
"User '$chamiloUserName' was remove from Session: #$chamiloSessionId - Course: ".$courseInfo['code']
);
}
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* @param string $file
*/
private function importSessionsExtIdStatic($file, $moveFile = true)
{
$data = Import::csv_reader($file);
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
foreach ($data as $row) {
$chamiloUserName = $row['UserName'];
$chamiloCourseCode = $row['CourseCode'];
$externalSessionId = $row['ExtSessionID'];
$type = $row['Type'];
$chamiloSessionId = null;
if (!empty($externalSessionId)) {
$chamiloSessionId = SessionManager::getSessionIdFromOriginalId(
$externalSessionId,
$this->extraFieldIdNameList['session']
);
}
$sessionInfo = api_get_session_info($chamiloSessionId);
if (empty($sessionInfo)) {
$this->logger->addError('Session does not exists: '.$chamiloSessionId);
continue;
}
$courseInfo = api_get_course_info($chamiloCourseCode);
if (empty($courseInfo)) {
$this->logger->addError('Course does not exists: '.$courseInfo);
continue;
}
$userId = UserManager::get_user_id_from_username($chamiloUserName);
if (empty($userId)) {
$this->logger->addError('User does not exists: '.$chamiloUserName);
continue;
}
switch ($type) {
case 'student':
SessionManager::subscribe_users_to_session_course(
[$userId],
$chamiloSessionId,
$courseInfo['code'],
null,
false
);
break;
case 'teacher':
SessionManager::set_coach_to_course_session(
$userId,
$chamiloSessionId,
$courseInfo['code']
);
break;
}
$this->logger->addError(
"User '$chamiloUserName' with status $type was added to session: #$chamiloSessionId - Course: ".$courseInfo['code']
);
}
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* Updates the session synchronize with the csv file.
*
* @param bool $moveFile
* @param string $file
*/
private function importSessionsStatic($file, $moveFile = true)
{
$content = file($file);
$sessions = [];
$tag_names = [];
foreach ($content as $key => $enreg) {
$enreg = explode(';', trim($enreg));
if ($key) {
foreach ($tag_names as $tag_key => $tag_name) {
if (isset($enreg[$tag_key])) {
$sessions[$key - 1][$tag_name] = $enreg[$tag_key];
}
}
} else {
foreach ($enreg as $tag_name) {
$tag_names[] = api_preg_replace(
'/[^a-zA-Z0-9_\-]/',
'',
$tag_name
);
}
if (!in_array('SessionName', $tag_names) ||
!in_array('DateStart', $tag_names) || !in_array('DateEnd', $tag_names)
) {
$error_message = get_lang('NoNeededData');
break;
}
}
}
if (!empty($sessions)) {
// Looping the sessions.
foreach ($sessions as $session) {
if (!empty($session['SessionID'])) {
$sessionId = SessionManager::getSessionIdFromOriginalId(
$session['SessionID'],
$this->extraFieldIdNameList['session']
);
$coachUserName = isset($session['Coach']) ? $session['Coach'] : null;
$categoryId = isset($session['category_id']) ? $session['category_id'] : null;
// 2014-06-30
$dateStart = explode('/', $session['DateStart']);
$dateEnd = explode('/', $session['DateEnd']);
$visibility = $this->defaultSessionVisibility;
$coachId = null;
if (!empty($coachUserName)) {
$coachInfo = api_get_user_info_from_username($coachUserName);
$coachId = $coachInfo['user_id'];
}
$dateStart = $dateStart[0].'-'.$dateStart[1].'-'.$dateStart[2].' 00:00:00';
$dateEnd = $dateEnd[0].'-'.$dateEnd[1].'-'.$dateEnd[2].' 23:59:59';
$date = new \DateTime($dateStart);
$interval = new DateInterval('P'.$this->daysCoachAccessBeforeBeginning.'D');
$date->sub($interval);
$coachBefore = $date->format('Y-m-d h:i');
$date = new \DateTime($dateEnd);
$interval = new DateInterval('P'.$this->daysCoachAccessAfterBeginning.'D');
$date->add($interval);
$coachAfter = $date->format('Y-m-d h:i');
/*$dateStart = api_get_utc_datetime($dateStart);
$dateEnd = api_get_utc_datetime($dateEnd);
$coachBefore = api_get_utc_datetime($coachBefore);
$coachAfter = api_get_utc_datetime($coachAfter);*/
if (empty($sessionId)) {
$result = SessionManager::create_session(
$session['SessionName'],
$dateStart,
$dateEnd,
$dateStart,
$dateEnd,
$coachBefore,
$coachAfter,
[$coachId],
$categoryId,
$visibility
);
if (is_numeric($result)) {
$sessionId = $result;
$this->logger->addInfo("Session #$sessionId created: ".$session['SessionName']);
SessionManager::update_session_extra_field_value(
$sessionId,
$this->extraFieldIdNameList['session'],
$session['SessionID']
);
} else {
$this->logger->addInfo("Failed creating session: ".$session['SessionName']);
}
} else {
$sessionInfo = api_get_session_info($sessionId);
$accessBefore = null;
$accessAfter = null;
if (empty($sessionInfo['nb_days_access_before_beginning']) ||
(!empty($sessionInfo['nb_days_access_before_beginning']) &&
$sessionInfo['nb_days_access_before_beginning'] < $this->daysCoachAccessBeforeBeginning)
) {
$accessBefore = $coachBefore;
}
$accessAfter = null;
if (empty($sessionInfo['nb_days_access_after_end']) ||
(!empty($sessionInfo['nb_days_access_after_end']) &&
$sessionInfo['nb_days_access_after_end'] < $this->daysCoachAccessAfterBeginning)
) {
$accessAfter = $coachAfter;
}
$showDescription = isset($sessionInfo['show_description']) ? $sessionInfo['show_description'] : 1;
$result = SessionManager::edit_session(
$sessionId,
$session['SessionName'],
$dateStart,
$dateEnd,
$dateStart,
$dateEnd,
$accessBefore,
$accessAfter,
$coachId,
$categoryId,
$visibility,
null, //$description = null,
$showDescription
);
if (is_numeric($result)) {
$this->logger->addInfo("Session #$sessionId updated: ".$session['SessionName']);
$tbl_session = Database::get_main_table(TABLE_MAIN_SESSION);
$params = [
'description' => $session['SessionDescription'],
];
Database::update(
$tbl_session,
$params,
['id = ?' => $sessionId]
);
}
}
if (!empty($sessionId)) {
// Courses
$courses = explode('|', $session['Courses']);
$courseList = [];
$courseListWithCoach = [];
foreach ($courses as $course) {
$courseArray = bracketsToArray($course);
$courseCode = $courseArray[0];
if (CourseManager::course_exists($courseCode)) {
$courseInfo = api_get_course_info($courseCode);
$courseList[] = $courseInfo['real_id'];
// Extracting course coaches
$courseCoaches = isset($courseArray[1]) ? $courseArray[1] : null;
$courseCoaches = explode(',', $courseCoaches);
// Extracting students
$courseUsers = isset($courseArray[2]) ? $courseArray[2] : null;
$courseUsers = explode(',', $courseUsers);
$courseListWithCoach[] = [
'course_info' => $courseInfo,
'coaches' => $courseCoaches,
'course_users' => $courseUsers,
];
}
}
SessionManager::add_courses_to_session(
$sessionId,
$courseList,
true
);
$this->logger->addInfo("Session #$sessionId: Courses added: '".implode(', ', $courseList)."'");
if (empty($courseListWithCoach)) {
$this->logger->addInfo("No users/coaches to update");
continue;
}
foreach ($courseListWithCoach as $courseData) {
$courseInfo = $courseData['course_info'];
$courseCode = $courseInfo['code'];
$courseId = $courseInfo['real_id'];
$courseCoaches = $courseData['coaches'];
$courseUsers = $courseData['course_users'];
// Coaches
if (!empty($courseCoaches)) {
$coachList = [];
foreach ($courseCoaches as $courseCoach) {
$courseCoachId = UserManager::get_user_id_from_username(
$courseCoach
);
if (false !== $courseCoachId) {
// Just insert new coaches
$coachList[] = $courseCoachId;
}
}
$this->logger->addInfo("Session #$sessionId: course '$courseCode' coaches added: '".implode(', ', $coachList)."'");
SessionManager::updateCoaches(
$sessionId,
$courseId,
$coachList,
true
);
} else {
$this->logger->addInfo("No coaches added");
}
// Students
if (!empty($courseUsers)) {
$userList = [];
foreach ($courseUsers as $username) {
$userInfo = api_get_user_info_from_username(trim($username));
if (!empty($userInfo)) {
$userList[] = $userInfo['user_id'];
}
}
$this->logger->addInfo("Session #$sessionId: course '$courseCode': Students added '".implode(', ', $userList)."'");
SessionManager::subscribe_users_to_session_course(
$userList,
$sessionId,
$courseCode,
SESSION_VISIBLE_READ_ONLY,
true
);
} else {
$this->logger->addInfo("No users to register.");
}
}
} else {
$this->logger->addInfo(
'SessionID not found in system.'
);
}
} else {
$this->logger->addInfo('SessionID does not exists');
}
}
} else {
$this->logger->addInfo($error_message);
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* @param $file
* @param bool $moveFile
* @param array $teacherBackup
* @param array $groupBackup
*/
private function importOpenSessions(
$file,
$moveFile = true,
&$teacherBackup = [],
&$groupBackup = []
) {
$this->importSessions($file, $moveFile, $teacherBackup, $groupBackup);
}
/**
* @param string $file
* @param bool $moveFile
* @param array $teacherBackup
* @param array $groupBackup
*/
private function importSessions(
$file,
$moveFile = true,
&$teacherBackup = [],
&$groupBackup = []
) {
$avoid = null;
if (isset($this->conditions['importSessions']) &&
isset($this->conditions['importSessions']['update'])
) {
$avoid = $this->conditions['importSessions']['update'];
}
$result = SessionManager::importCSV(
$file,
true,
$this->defaultAdminId,
$this->logger,
[
'SessionID' => 'extra_'.$this->extraFieldIdNameList['session'],
'CareerId' => 'extra_'.$this->extraFieldIdNameList['session_career'],
],
$this->extraFieldIdNameList['session'],
$this->daysCoachAccessBeforeBeginning,
$this->daysCoachAccessAfterBeginning,
$this->defaultSessionVisibility,
$avoid,
false, // deleteUsersNotInList
false, // updateCourseCoaches
true, // sessionWithCoursesModifier
true, //$addOriginalCourseTeachersAsCourseSessionCoaches
false, //$removeAllTeachersFromCourse
1, // $showDescription,
$teacherBackup,
$groupBackup
);
if (!empty($result['error_message'])) {
$this->logger->addError($result['error_message']);
}
$this->logger->addInfo("Sessions - Sessions parsed: ".$result['session_counter']);
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* @param string $file
* @param bool $moveFile
*/
private function importSubscribeStatic($file, $moveFile = true)
{
$data = Import::csv_reader($file);
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
foreach ($data as $row) {
$chamiloUserName = $row['UserName'];
$chamiloCourseCode = $row['CourseCode'];
$chamiloSessionId = $row['SessionID'];
$type = $row['Type'];
$sessionInfo = api_get_session_info($chamiloSessionId);
if (empty($sessionInfo)) {
$this->logger->addError('Session does not exists: '.$chamiloSessionId);
continue;
}
$courseInfo = api_get_course_info($chamiloCourseCode);
if (empty($courseInfo)) {
$this->logger->addError('Course does not exists: '.$courseInfo);
continue;
}
$userId = UserManager::get_user_id_from_username($chamiloUserName);
if (empty($userId)) {
$this->logger->addError('User does not exists: '.$chamiloUserName);
continue;
}
switch ($type) {
case 'student':
SessionManager::subscribe_users_to_session_course(
[$userId],
$chamiloSessionId,
$courseInfo['code'],
null,
false
);
break;
case 'teacher':
SessionManager::set_coach_to_course_session(
$userId,
$chamiloSessionId,
$courseInfo['real_id']
);
break;
}
$this->logger->addError(
"User '$chamiloUserName' with status $type was added to session: #$chamiloSessionId - Course: ".$courseInfo['code']
);
}
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* @param $file
* @param bool $moveFile
*/
private function importSubscribeUserToCourse($file, $moveFile = false, &$teacherBackup = [])
{
$data = Import::csv_reader($file);
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
foreach ($data as $row) {
$chamiloUserName = $row['UserName'];
$chamiloCourseCode = $row['CourseCode'];
$status = $row['Status'];
$courseInfo = api_get_course_info($chamiloCourseCode);
if (empty($courseInfo)) {
$this->logger->addError(
'Course does not exists: '.$chamiloCourseCode
);
continue;
}
$userId = UserManager::get_user_id_from_username(
$chamiloUserName
);
if (empty($userId)) {
$this->logger->addError(
'User does not exists: '.$chamiloUserName
);
continue;
}
$userCourseCategory = '';
if (isset($teacherBackup[$userId]) &&
isset($teacherBackup[$userId][$courseInfo['code']])
) {
$courseUserData = $teacherBackup[$userId][$courseInfo['code']];
$userCourseCategory = $courseUserData['user_course_cat'];
}
$result = CourseManager::subscribeUser(
$userId,
$courseInfo['real_id'],
$status,
0,
$userCourseCategory
);
if ($result) {
$this->logger->addInfo(
"User $userId added to course ".$courseInfo['code']." with status '$status' with course category: '$userCourseCategory'"
);
} else {
$this->logger->addInfo(
"User $userId was NOT ADDED to course ".$courseInfo['code']." with status '$status' with course category: '$userCourseCategory'"
);
}
}
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* 23/4/2017 to datetime.
*
* @param $string
*
* @return mixed
*/
private function createDateTime($string)
{
if (empty($string)) {
return null;
}
$date = DateTime::createFromFormat('j/m/Y', $string);
if ($date) {
return $date;
}
return null;
}
/**
* @param $file
* @param bool $moveFile
* @param array $teacherBackup
* @param array $groupBackup
*
* @return bool
*/
private function importCareers(
$file,
$moveFile = false,
&$teacherBackup = [],
&$groupBackup = []
) {
$data = Import::csv_reader($file);
if (!empty($data)) {
$this->logger->addInfo(count($data).' records found.');
$extraFieldValue = new ExtraFieldValue('career');
$extraFieldName = $this->extraFieldIdNameList['career'];
$externalEventId = null;
$extraField = new ExtraField('career');
$extraFieldInfo = $extraField->get_handler_field_info_by_field_variable($extraFieldName);
if (empty($extraFieldInfo)) {
$this->logger->addInfo("Extra field doesn't exists: $extraFieldName");
return false;
}
foreach ($data as $row) {
foreach ($row as $key => $value) {
$key = (string) trim($key);
// Remove utf8 bom
$key = preg_replace('/[\x00-\x1F\x80-\xFF]/', '', $key);
$row[$key] = $value;
}
$itemId = $row['CareerId'];
$item = $extraFieldValue->get_item_id_from_field_variable_and_field_value(
$extraFieldName,
$itemId,
false,
false,
false
);
$career = new Career();
if (empty($item)) {
$params = [
'status' => 1,
'name' => $row['CareerName'],
];
$careerId = $career->save($params);
if ($careerId) {
$this->logger->addInfo('Career saved: '.print_r($params, 1));
$params = [
'item_id' => $careerId,
'extra_'.$extraFieldName => $itemId,
];
$links = isset($row['HLinks']) ? $row['HLinks'] : [];
if (!empty($links)) {
$extraFieldUrlName = $this->extraFieldIdNameList['career_urls'];
$extraFieldInfo = $extraField->get_handler_field_info_by_field_variable(
$extraFieldUrlName
);
if (!empty($extraFieldInfo)) {
$params['extra_'.$extraFieldUrlName] = $links;
}
}
$extraFieldValue->saveFieldValues($params);
}
} else {
if (isset($item['item_id'])) {
$params = [
'id' => $item['item_id'],
'name' => $row['CareerName'],
];
$career->update($params);
$this->logger->addInfo('Career updated: '.print_r($params, 1));
$links = isset($row['HLinks']) ? $row['HLinks'] : [];
if (!empty($links)) {
$extraFieldUrlName = $this->extraFieldIdNameList['career_urls'];
$extraFieldInfo = $extraField->get_handler_field_info_by_field_variable(
$extraFieldUrlName
);
if (!empty($extraFieldInfo)) {
$params = [
'item_id' => $item['item_id'],
'extra_'.$extraFieldName => $itemId,
'extra_'.$extraFieldUrlName => $links,
];
$extraFieldValue->saveFieldValues($params);
}
}
}
}
}
}
}
/**
* @param $file
* @param bool $moveFile
* @param array $teacherBackup
* @param array $groupBackup
*/
private function importCareersResults(
$file,
$moveFile = false,
&$teacherBackup = [],
&$groupBackup = []
) {
$data = Import::csv_reader($file);
$userTable = Database::get_main_table(TABLE_MAIN_USER);
$careerIdList = [];
$userIdList = [];
if (!empty($data)) {
$totalCount = count($data);
$this->logger->addInfo($totalCount.' records found.');
$extraFieldValue = new ExtraFieldValue('career');
$extraFieldName = $this->extraFieldIdNameList['career'];
$rowCounter = 0;
foreach ($data as $row) {
$this->logger->addInfo("---------- Row: # $rowCounter");
$rowCounter++;
if (empty($row)) {
continue;
}
foreach ($row as $key => $value) {
$key = (string) trim($key);
// Remove utf8 bom
$key = preg_replace('/[\x00-\x1F\x80-\xFF]/', '', $key);
$row[$key] = $value;
}
$rowStudentId = $row['StudentId'];
if (isset($userIdList[$rowStudentId])) {
$studentId = $userIdList[$rowStudentId];
} else {
$studentId = UserManager::get_user_id_from_original_id(
$rowStudentId,
$this->extraFieldIdNameList['user']
);
$userIdList[$rowStudentId] = $studentId;
}
//$studentInfo = api_get_user_info($studentId);
/*$sql = "SELECT id FROM $userTable WHERE id = $studentId";
$result = Database::query($sql);
if (empty(Database::num_rows($result))) {
$this->logger->addInfo("Student chamilo id not found: $studentId row data StudentId: ".$row['StudentId']);
continue;
}*/
$careerId = $row['CareerId'];
//$careerChamiloId = 0;
if (isset($careerIdList[$careerId])) {
$careerChamiloId = $careerIdList[$careerId];
} else {
$item = $extraFieldValue->get_item_id_from_field_variable_and_field_value(
$extraFieldName,
$careerId
);
if (empty($item)) {
//$this->logger->addInfo("Career not found: $careerId case 1");
$careerIdList[$careerId] = 0;
continue;
} else {
if (isset($item['item_id'])) {
$careerChamiloId = $item['item_id'];
$careerIdList[$careerId] = $careerChamiloId;
} else {
$careerIdList[$careerId] = 0;
//$this->logger->addInfo("Career not found: $careerId case 2");
continue;
}
}
}
if (empty($careerChamiloId)) {
$this->logger->addInfo("Career not found: $careerId ");
continue;
}
$userCareerData = UserManager::getUserCareer($studentId, $careerChamiloId);
if (empty($userCareerData)) {
$this->logger->addInfo(
"User chamilo id # $studentId (".$row['StudentId'].") has no career #$careerChamiloId (ext #$careerId)"
);
continue;
}
$extraData = isset($userCareerData['extra_data']) && !empty($userCareerData['extra_data']) ? unserialize($userCareerData['extra_data']) : [];
//$teacherInfo = api_get_user_info_from_username($row['TeacherUsername']);
$sql = "SELECT firstname, lastname FROM $userTable
WHERE username='".Database::escape_string($row['TeacherUsername'])."'";
$result = Database::query($sql);
$teacherName = $row['TeacherUsername'];
if (Database::num_rows($result)) {
$teacherInfo = Database::fetch_array($result);
$teacherName = $teacherInfo['firstname'].' '.$teacherInfo['lastname'];
}
$extraData[$row['CourseId']][$row['ResultId']] = [
'Description' => $row['Description'],
'Period' => $row['Period'],
'TeacherText' => $row['TeacherText'],
'TeacherUsername' => $teacherName,
'ScoreText' => $row['ScoreText'],
'ScoreValue' => $row['ScoreValue'],
'Info' => $row['Info'],
'BgColor' => $row['BgColor'],
'Color' => $row['Color'],
'BorderColor' => $row['BorderColor'],
'Icon' => $row['Icon'],
'IconColor' => $row['IconColor'],
];
$serializedValue = serialize($extraData);
UserManager::updateUserCareer($userCareerData['id'], $serializedValue);
$this->logger->addInfo(
"Saving graph for user chamilo # $studentId (".$row['StudentId'].") with career #$careerChamiloId (ext #$careerId)"
);
}
}
}
/**
* @param $file
* @param bool $moveFile
* @param array $teacherBackup
* @param array $groupBackup
*/
private function importCareersDiagram(
$file,
$moveFile = false,
&$teacherBackup = [],
&$groupBackup = []
) {
$data = Import::csv_reader($file);
$extraFieldValue = new ExtraFieldValue('career');
$extraFieldName = $this->extraFieldIdNameList['career'];
$externalEventId = null;
$extraField = new ExtraField('career');
$extraFieldInfo = $extraField->get_handler_field_info_by_field_variable($extraFieldName);
$careerDiagramExtraFieldName = $this->extraFieldIdNameList['career_diagram'];
$extraFieldDiagramInfo = $extraField->get_handler_field_info_by_field_variable(
$careerDiagramExtraFieldName
);
if (empty($extraFieldInfo) || empty($extraFieldDiagramInfo)) {
return false;
}
if (!empty($data)) {
$this->logger->addInfo(count($data).' records found.');
$values = [];
foreach ($data as $row) {
if (empty($row)) {
continue;
}
foreach ($row as $key => $value) {
$key = (string) trim($key);
// Remove utf8 bom
$key = preg_replace('/[\x00-\x1F\x80-\xFF]/', '', $key);
$row[$key] = $value;
}
$values[$row['Column']][] = $row;
}
$careerList = [];
$careerNameList = [];
ksort($values);
$careerChamiloIdList = [];
// 1. First create all items
foreach ($values as $column => $rowList) {
foreach ($rowList as $row) {
$careerId = $row['CareerId'];
$item = $extraFieldValue->get_item_id_from_field_variable_and_field_value(
$extraFieldName,
$careerId,
false,
false,
false
);
if (empty($item)) {
$this->logger->addInfo("Career not found: $careerId");
continue;
} else {
if (isset($item['item_id'])) {
$careerChamiloId = $item['item_id'];
$career = new Career();
$career = $career->find($careerChamiloId);
$chamiloCareerName = $career['name'];
$careerNameList[$careerId] = $chamiloCareerName;
$careerChamiloIdList[$careerId] = $careerChamiloId;
} else {
continue;
}
}
if (empty($chamiloCareerName)) {
$this->logger->addInfo("Career not found: $careerId");
continue;
}
if (isset($careerList[$careerId])) {
$graph = $careerList[$careerId];
} else {
$graph = new Graph($careerId);
$graph->setAttribute('graphviz.graph.rankdir', 'LR');
$careerList[$careerId] = $graph;
}
$currentCourseId = $row['CourseId'];
$name = $row['CourseName'];
$notes = $row['Notes'];
$groupValue = $row['Group'];
$boxColumn = $row['Column'];
$rowValue = $row['Row'];
$color = isset($row['DefinedColor']) ? $row['DefinedColor'] : '';
$arrow = isset($row['DrawArrowFrom']) ? $row['DrawArrowFrom'] : '';
$subGroup = isset($row['SubGroup']) ? $row['SubGroup'] : '';
$connections = isset($row['Connections']) ? $row['Connections'] : '';
$linkedElement = isset($row['LinkedElement']) ? $row['LinkedElement'] : '';
if ($graph->hasVertex($currentCourseId)) {
// Avoid double insertion
continue;
} else {
$current = $graph->createVertex($currentCourseId);
$current->setAttribute('graphviz.label', $name);
$current->setAttribute('DefinedColor', $color);
$current->setAttribute('Notes', $notes);
$current->setAttribute('Row', $rowValue);
$current->setAttribute('Group', $groupValue);
$current->setAttribute('Column', $boxColumn);
$current->setAttribute('DrawArrowFrom', $arrow);
$current->setAttribute('SubGroup', $subGroup);
$current->setAttribute('Connections', $connections);
$current->setAttribute('LinkedElement', $linkedElement);
$current->setAttribute('graphviz.shape', 'box');
$current->setGroup($column);
}
}
}
// 2. Create connections
// $column start with 1 (depending in Column row)
foreach ($values as $column => $rowList) {
foreach ($rowList as $row) {
$careerId = $row['CareerId'];
if (isset($careerList[$careerId])) {
$graph = $careerList[$careerId];
} else {
continue;
}
$currentCourseId = $row['CourseId'];
if ($graph->hasVertex($currentCourseId)) {
$current = $graph->getVertex($currentCourseId);
} else {
continue;
}
if (isset($row['DependedOn']) && !empty($row['DependedOn'])) {
$parentList = explode(',', $row['DependedOn']);
foreach ($parentList as $parentId) {
$parentId = (int) $parentId;
if ($graph->hasVertex($parentId)) {
/** @var Vertex $parent */
$parent = $graph->getVertex($parentId);
/*$parent->setAttribute('graphviz.color', 'red');
$parent->setAttribute('graphviz.label', $name);
$parent->setAttribute('graphviz.shape', 'square');*/
$parent->createEdgeTo($current);
}
}
}
}
}
/** @var Graph $graph */
foreach ($careerList as $id => $graph) {
if (isset($careerChamiloIdList[$id])) {
$params = [
'item_id' => $careerChamiloIdList[$id],
'extra_'.$careerDiagramExtraFieldName => serialize($graph),
'extra_'.$extraFieldName => $id,
];
$extraFieldValue->saveFieldValues($params, true);
}
}
}
}
/**
* @param string $file
* @param bool $moveFile
* @param array $teacherBackup
* @param array $groupBackup
*/
private function importUnsubscribeStatic(
$file,
$moveFile = false,
&$teacherBackup = [],
&$groupBackup = []
) {
$data = Import::csv_reader($file);
if (!empty($data)) {
$this->logger->addInfo(count($data)." records found.");
foreach ($data as $row) {
$chamiloUserName = $row['UserName'];
$chamiloCourseCode = $row['CourseCode'];
$chamiloSessionId = $row['SessionID'];
$sessionInfo = api_get_session_info($chamiloSessionId);
if (empty($sessionInfo)) {
$this->logger->addError('Session does not exists: '.$chamiloSessionId);
continue;
}
$courseInfo = api_get_course_info($chamiloCourseCode);
if (empty($courseInfo)) {
$this->logger->addError('Course does not exists: '.$courseInfo);
continue;
}
$userId = UserManager::get_user_id_from_username($chamiloUserName);
if (empty($userId)) {
$this->logger->addError('User does not exists: '.$chamiloUserName);
continue;
}
$sql = "SELECT * FROM ".Database::get_main_table(TABLE_MAIN_COURSE_USER)."
WHERE
user_id = ".$userId." AND
c_id = '".$courseInfo['real_id']."'
";
$result = Database::query($sql);
$rows = Database::num_rows($result);
if ($rows > 0) {
$userCourseData = Database::fetch_assoc($result);
if (!empty($userCourseData)) {
$teacherBackup[$userId][$courseInfo['code']] = $userCourseData;
}
}
$sql = "SELECT * FROM ".Database::get_course_table(TABLE_GROUP_USER)."
WHERE
user_id = ".$userId." AND
c_id = '".$courseInfo['real_id']."'
";
$result = Database::query($sql);
while ($groupData = Database::fetch_assoc($result)) {
$groupBackup['user'][$userId][$courseInfo['code']][$groupData['group_id']] = $groupData;
}
$sql = "SELECT * FROM ".Database::get_course_table(TABLE_GROUP_TUTOR)."
WHERE
user_id = ".$userId." AND
c_id = '".$courseInfo['real_id']."'
";
$result = Database::query($sql);
while ($groupData = Database::fetch_assoc($result)) {
$groupBackup['tutor'][$userId][$courseInfo['code']][$groupData['group_id']] = $groupData;
}
CourseManager::unsubscribe_user(
$userId,
$courseInfo['code'],
$chamiloSessionId
);
$this->logger->addError(
"User '$chamiloUserName' was removed from session: #$chamiloSessionId, Course: ".$courseInfo['code']
);
}
}
if ($moveFile) {
$this->moveFile($file);
}
}
/**
* Dump database tables.
*/
private function dumpDatabaseTables()
{
echo 'Dumping tables'.PHP_EOL;
// User
$table = Database::get_main_table(TABLE_MAIN_USER);
$tableAdmin = Database::get_main_table(TABLE_MAIN_ADMIN);
$sql = "DELETE FROM $table
WHERE user_id not in (select user_id from $tableAdmin) and status <> ".ANONYMOUS;
Database::query($sql);
echo $sql.PHP_EOL;
// Truncate tables
$truncateTables = [
Database::get_main_table(TABLE_MAIN_COURSE),
Database::get_main_table(TABLE_MAIN_COURSE_USER),
Database::get_main_table(TABLE_MAIN_ACCESS_URL_REL_COURSE),
Database::get_main_table(TABLE_MAIN_CATEGORY),
Database::get_main_table(TABLE_MAIN_COURSE_MODULE),
Database::get_main_table(TABLE_MAIN_ACCESS_URL_REL_USER),
Database::get_main_table(TABLE_MAIN_SESSION),
Database::get_main_table(TABLE_MAIN_SESSION_CATEGORY),
Database::get_main_table(TABLE_MAIN_SESSION_COURSE),
Database::get_main_table(TABLE_MAIN_SESSION_COURSE_USER),
Database::get_main_table(TABLE_MAIN_SESSION_USER),
Database::get_main_table(TABLE_MAIN_ACCESS_URL_REL_SESSION),
Database::get_main_table(TABLE_MAIN_SESSION_FIELD_VALUES),
Database::get_main_table(TABLE_MAIN_COURSE_FIELD_VALUES),
Database::get_main_table(TABLE_MAIN_USER_FIELD_VALUES),
Database::get_main_table(TABLE_MAIN_USER_FIELD),
Database::get_main_table(TABLE_MAIN_USER_FIELD_OPTIONS),
Database::get_main_table(TABLE_MAIN_COURSE_FIELD),
Database::get_main_table(TABLE_MAIN_COURSE_FIELD_VALUES),
Database::get_main_table(TABLE_MAIN_SESSION_FIELD),
Database::get_main_table(TABLE_MAIN_SESSION_FIELD_VALUES),
Database::get_course_table(TABLE_AGENDA),
Database::get_course_table(TABLE_AGENDA_ATTACHMENT),
Database::get_course_table(TABLE_AGENDA_REPEAT),
Database::get_course_table(TABLE_AGENDA_REPEAT_NOT),
Database::get_main_table(TABLE_PERSONAL_AGENDA),
Database::get_main_table(TABLE_PERSONAL_AGENDA_REPEAT_NOT),
Database::get_main_table(TABLE_PERSONAL_AGENDA_REPEAT),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_LASTACCESS),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_ACCESS),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_LOGIN),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_DOWNLOADS),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_EXERCISES),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_ATTEMPT),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_ATTEMPT_QUALIFY),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_DEFAULT),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_UPLOADS),
Database::get_main_table(TABLE_STATISTIC_TRACK_E_HOTSPOT),
Database::get_main_table(TABLE_MAIN_GRADEBOOK_CATEGORY),
Database::get_main_table(TABLE_MAIN_GRADEBOOK_EVALUATION),
Database::get_main_table(TABLE_MAIN_GRADEBOOK_LINKEVAL_LOG),
Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT),
Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT_LOG),
Database::get_main_table(TABLE_MAIN_GRADEBOOK_LINK),
Database::get_main_table(TABLE_MAIN_GRADEBOOK_SCORE_DISPLAY),
Database::get_main_table(TABLE_MAIN_GRADEBOOK_CERTIFICATE),
Database::get_course_table(TABLE_STUDENT_PUBLICATION),
Database::get_course_table(TABLE_QUIZ_QUESTION),
Database::get_course_table(TABLE_QUIZ_TEST),
Database::get_course_table(TABLE_QUIZ_ORDER),
Database::get_course_table(TABLE_QUIZ_ANSWER),
Database::get_course_table(TABLE_QUIZ_TEST_QUESTION),
Database::get_course_table(TABLE_QUIZ_QUESTION_OPTION),
Database::get_course_table(TABLE_QUIZ_QUESTION_CATEGORY),
Database::get_course_table(TABLE_QUIZ_QUESTION_REL_CATEGORY),
Database::get_course_table(TABLE_LP_MAIN),
Database::get_course_table(TABLE_LP_ITEM),
Database::get_course_table(TABLE_LP_VIEW),
Database::get_course_table(TABLE_LP_ITEM_VIEW),
Database::get_course_table(TABLE_DOCUMENT),
Database::get_course_table(TABLE_ITEM_PROPERTY),
Database::get_course_table(TABLE_TOOL_LIST),
Database::get_course_table(TABLE_TOOL_INTRO),
Database::get_course_table(TABLE_COURSE_SETTING),
Database::get_course_table(TABLE_SURVEY),
Database::get_course_table(TABLE_SURVEY_QUESTION),
Database::get_course_table(TABLE_SURVEY_QUESTION_OPTION),
Database::get_course_table(TABLE_SURVEY_INVITATION),
Database::get_course_table(TABLE_SURVEY_ANSWER),
Database::get_course_table(TABLE_SURVEY_QUESTION_GROUP),
Database::get_course_table(TABLE_SURVEY_REPORT),
Database::get_course_table(TABLE_GLOSSARY),
Database::get_course_table(TABLE_LINK),
Database::get_course_table(TABLE_LINK_CATEGORY),
Database::get_course_table(TABLE_GROUP),
Database::get_course_table(TABLE_GROUP_USER),
Database::get_course_table(TABLE_GROUP_TUTOR),
Database::get_course_table(TABLE_GROUP_CATEGORY),
Database::get_course_table(TABLE_DROPBOX_CATEGORY),
Database::get_course_table(TABLE_DROPBOX_FEEDBACK),
Database::get_course_table(TABLE_DROPBOX_POST),
Database::get_course_table(TABLE_DROPBOX_FILE),
Database::get_course_table(TABLE_DROPBOX_PERSON),
];
foreach ($truncateTables as $table) {
$sql = "TRUNCATE $table";
Database::query($sql);
echo $sql.PHP_EOL;
}
$table = Database::get_course_table(TABLE_ITEM_PROPERTY);
$sql = "DELETE FROM $table WHERE tool = 'calendar_event'";
Database::query($sql);
echo $sql.PHP_EOL;
}
/**
* If csv file ends with '"' character then a '";' is added.
*
* @param string $file
*/
private function fixCSVFile($file)
{
/*$f = fopen($file, 'r+');
$cursor = -1;
fseek($f, $cursor, SEEK_END);
$char = fgetc($f);
while ($char === "\n" || $char === "\r") {
fseek($f, $cursor--, SEEK_END);
$char = fgetc($f);
}
if ($char === "\"") {
fseek($f, -1, SEEK_CUR);
fwrite($f, '";');
}*/
}
}
$logger = new Logger('cron');
$emails = api_get_setting('mail.cron_notification_help_desk', true);
$minLevel = Logger::DEBUG;
if (!is_array($emails)) {
$emails = [$emails];
}
$subject = "Cron main/cron/import_csv.php ".date('Y-m-d h:i:s');
$from = api_get_setting('emailAdministrator');
/*
if (!empty($emails)) {
foreach ($emails as $email) {
$stream = new NativeMailerHandler($email, $subject, $from, $minLevel);
$logger->pushHandler(new BufferHandler($stream, 0, $minLevel));
}
}*/
$stream = new StreamHandler(
api_get_path(SYS_ARCHIVE_PATH).'import_csv.log',
$minLevel
);
$logger->pushHandler(new BufferHandler($stream, 0, $minLevel));
$logger->pushHandler(new RotatingFileHandler('import_csv', 5, $minLevel));
$verbose = false;
if (isset($argv[1]) && '--verbose' === $argv[1]) {
$verbose = true;
}
if ($verbose) {
$logger->pushHandler(new ErrorLogHandler());
}
$cronImportCSVConditions = isset($_configuration['cron_import_csv_conditions']) ? $_configuration['cron_import_csv_conditions'] : null;
echo 'See the error log here: '.api_get_path(SYS_ARCHIVE_PATH).'import_csv.log'."\n";
$import = new ImportCsv($logger, $cronImportCSVConditions);
if (isset($_configuration['default_admin_user_id_for_cron'])) {
$import->defaultAdminId = $_configuration['default_admin_user_id_for_cron'];
}
// @todo in production disable the dump option
$dump = false;
if (isset($argv[1]) && '--dump' === $argv[1]) {
$dump = true;
}
if (isset($_configuration['import_csv_disable_dump']) &&
true == $_configuration['import_csv_disable_dump']
) {
$import->setDumpValues(false);
} else {
$import->setDumpValues($dump);
}
$settingEmailDummy = ('true' === api_get_setting('mail.update_users_email_to_dummy_except_admins'));
$import->setUpdateEmailToDummy($settingEmailDummy);
// Do not moves the files to treated
if (isset($_configuration['import_csv_test'])) {
$import->test = $_configuration['import_csv_test'];
} else {
$import->test = true;
}
$languageFilesToLoad = api_get_language_files_to_load($import->defaultLanguage);
foreach ($languageFilesToLoad as $languageFile) {
include $languageFile;
}
// Set default language to be loaded
$language = $import->defaultLanguage;
global $language_interface;
$language_interface = $language;
global $language_interface_initial_value;
$language_interface_initial_value = $language;
$timeStart = microtime(true);
$import->run();
$timeEnd = microtime(true);
$executionTime = round(($timeEnd - $timeStart) / 60, 2);
$logger->addInfo("Total execution Time $executionTime Min");
if (isset($_configuration['import_csv_fix_permissions']) &&
true == $_configuration['import_csv_fix_permissions']
) {
$command = "sudo find ".api_get_path(SYS_COURSE_PATH)." -type d -exec chmod 777 {} \; ";
echo "Executing: ".$command.PHP_EOL;
system($command);
$command = "sudo find ".api_get_path(SYS_CODE_PATH)."upload/users -type d -exec chmod 777 {} \;";
echo "Executing: ".$command.PHP_EOL;
system($command);
}