Proyectos de Subversion LeadersLinked - Backend

            if($step == 'process') {

                // get the key from the post

                $key = Functions::sanitizeFilterString($this->params()->fromPost('key')); 

                if(!$key) {

                    return new JsonModel([

                        'success' => false,

                        'data' => 'ERROR_CACHE_KEY_EMPTY'

                    ]); 

                }

                // get the value from the cache

                $value = $this->cache->getItem($key);

                $this->logger->info('Value: ' . print_r($value, true));

                // if the value is not found, return an error

                if(!$value) {

                    return new JsonModel([

                        'success' => false,

                        'data' => 'ERROR_CACHE_NOT_FOUND'

                    ]); 

                }

                // unserialize the value

                $records = unserialize($value);

                $this->logger->info('Records: ' . print_r($records, true));

                // if the value is not found, return an error

                if(!$records) {

                    return new JsonModel([

                        'success' => false,

                        'data' => 'ERROR_CACHE_INVALID'

                    ]);

                }

                // get the network, company, company follower

                $networkMapper = NetworkMapper::getInstance($this->adapter);

                $companyMapper = CompanyMapper::getInstance($this->adapter);

                $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);

                // get the connection, user, user password, topic user

                $connectionMapper = ConnectionMapper::getInstance($this->adapter);

                $userMapper = UserMapper::getInstance($this->adapter);

                $userPasswordMapper = UserPasswordMapper::getInstance($this->adapter);

                $topicUserMapper = MicrolearningTopicUserMapper::getInstance($this->adapter);

                // get the microlearning extend user, microlearning extend user company, microlearning extend user function, microlearning extend user group, microlearning extend user institution, microlearning extend user program, microlearning extend user partner, microlearning extend user sector, microlearning extend user student type, microlearning extend user country

                $microlearningExtendUserMapper = MicrolearningExtendUserMapper::getInstance($this->adapter);

                $microlearningExtendUserCompanyMapper = MicrolearningExtendUserCompanyMapper::getInstance($this->adapter);

                $microlearningExtendUserFunctionMapper = MicrolearningExtendUserFunctionMapper::getInstance($this->adapter);

                $microlearningExtendUserGroupMapper = MicrolearningExtendUserGroupMapper::getInstance($this->adapter);

                $microlearningExtendUserInstitutionMapper = MicrolearningExtendUserInstitutionMapper::getInstance($this->adapter);

                $microlearningExtendUserProgramMapper = MicrolearningExtendUserProgramMapper::getInstance($this->adapter);

                $microlearningExtendUserPartnerMapper = MicrolearningExtendUserPartnerMapper::getInstance($this->adapter);

                $microlearningExtendUserSectorMapper = MicrolearningExtendUserSectorMapper::getInstance($this->adapter);

                $microlearningExtendUserStudentTypeMapper = MicrolearningExtendUserStudentTypeMapper::getInstance($this->adapter);

                $microlearningExtendUserCountryMapper = MicrolearningExtendUserCountryMapper::getInstance($this->adapter);

                // get the network default, user default for connection, company for follower

                $networkDefault = $networkMapper->fetchOneByDefault();

                $userDefaultForConnection = $userMapper->fetchOneDefaultForConnection();

                $companyForFollower = $companyMapper->fetchOneDefaultForFollowers();

                // create the csv

                $csv = "FIRST NAME|LAST NAME|EMAIL|STATUS\r\n";

                // get the users processed, users assigned, user ids

                $users_processed = 0;

                $users_assigned = 0;

                $user_ids = [];

                foreach($records as $record)

                {

                    $first_name = $record['first_name'];

                    $last_name = $record['last_name'];

                    $password = $record['password'];

                    $email = $record['email'];

                    $company = $record['company'];

                    $function = $record['function'];

                    $group = $record['group'];

                    $institution = $record['institution'];

                    $program = $record['program'];

                    $partner = $record['partner'];

                    $sector = $record['sector'];

                    $studentType = $record['studentType'];

                    $country = $record['country'];

                    $isAdult = strtolower(trim( $record['isAdult'])) == User::IS_ADULT_YES;

                    $user = $userMapper->fetchOneByEmail($email);

                    // if the user is not found, create the user

                    if(!$user) {    

                        // if the password is not empty, create the user

                        if($password) {

                            $password_hash = password_hash($password, PASSWORD_DEFAULT);

                            $user = new User();

                            $user->network_id = $currentNetwork->id;

                            $user->blocked = User::BLOCKED_NO;

                            $user->email_verified = User::EMAIL_VERIFIED_YES;

                            $user->email = $email;

                            $user->first_name = $first_name;

                            $user->last_name = $last_name;

                            $user->password = $password_hash;

                            $user->login_attempt = 0;

                            $user->usertype_id = UserType::USER;

                            $user->status = User::STATUS_ACTIVE;

                            $user->is_adult = $isAdult ? User::IS_ADULT_YES : User::IS_ADULT_NO;

                            $result = $userMapper->insert($user);

                            if($result) {

                                $userPassword = new UserPassword();

                                $userPassword->user_id = $user->id;

                                $userPassword->password = $password_hash;

                                $userPasswordMapper->insert($userPassword);

                                $csv .= "$first_name|$last_name|$email|CREATE USER \r\n";

                            } else {

                                $csv .= "$first_name|$last_name|$email|FAIL CREATE USER \r\n";

                                continue;

                            } 

                        }

                    } else {

                        $user->is_adult = $isAdult ? User::IS_ADULT_YES : User::IS_ADULT_NO;

                        if($user->email_verified == User::EMAIL_VERIFIED_NO || $user->status != User::STATUS_ACTIVE) {

                            $user->email_verified = User::EMAIL_VERIFIED_YES;

                            $user->status != User::STATUS_ACTIVE;

                        }

                        if(!$userMapper->update($user)) {

                            $csv .= "$first_name|$last_name|$email|FAIL UPDATE USER \r\n";

                            continue;

                        }

                    }

                    $user_id_in_default_network = 0;

                    if($user->is_adult == User::IS_ADULT_YES) {

                        if($currentNetwork->default == Network::DEFAULT_YES) {

                            $user_id_in_default_network = $user->id;

                        } else {

                            $userInDefaultNetwork = $userMapper->fetchOneByEmailAndNetworkId($user->email, $networkDefault->id);

                            if($userInDefaultNetwork) {

                                $user_id_in_default_network = $userInDefaultNetwork->id;

                                if($userInDefaultNetwork->email_verified == User::EMAIL_VERIFIED_NO || $userInDefaultNetwork->status != User::STATUS_ACTIVE) {

                                    $userInDefaultNetwork->email_verified = User::EMAIL_VERIFIED_YES;

                                    $userInDefaultNetwork->status != User::STATUS_ACTIVE;

                                    if(!$userMapper->update($userInDefaultNetwork)) {

                                        $csv .= "$first_name|$last_name|$email|FAIL UPDATE USER IN DEFAULT NETWORK \r\n";

                                        continue;

                                    }

                                }

                            } else {

                                $userInDefaultNetwork = new User();

                                $userInDefaultNetwork->network_id = $networkDefault->id;

                                $userInDefaultNetwork->blocked = User::BLOCKED_NO;

                                $userInDefaultNetwork->email_verified = User::EMAIL_VERIFIED_YES;

                                $userInDefaultNetwork->email = $email;

                                $userInDefaultNetwork->first_name = $first_name;

                                $userInDefaultNetwork->last_name = $last_name;

                                $userInDefaultNetwork->password = $password_hash;

                                $userInDefaultNetwork->login_attempt = 0;

                                $userInDefaultNetwork->usertype_id = UserType::USER;

                                $userInDefaultNetwork->status = User::STATUS_ACTIVE;

                                $userInDefaultNetwork->is_adult = $isAdult == User::IS_ADULT_YES;

                                $result = $userMapper->insert($userInDefaultNetwork);

                                if($result) {

                                    $user_id_in_default_network = $userInDefaultNetwork->id;

                                    $userPassword = new UserPassword();

                                    $userPassword->user_id = $userInDefaultNetwork->id;

                                    $userPassword->password = $password_hash;

                                    $userPasswordMapper->insert($userPassword);

                                    $csv .= "$first_name|$last_name|$email|CREATE USER IN DEFAULT NETWORK \r\n";

                                } else {

                                    $csv .= "$first_name|$last_name|$email|FAIL CREATE USER IN DEFAULT NETWORK \r\n";

                                }

                            }

                        }

                    }

                    if($user_id_in_default_network) {

                        if($userDefaultForConnection) {

                            $connection = $connectionMapper->fetchOneByUserId1AndUserId2($userDefaultForConnection->id, $user_id_in_default_network);

                            if($connection) {

                                if($connection->status != Connection::STATUS_ACCEPTED) {

                                    $connection->status = Connection::STATUS_ACCEPTED;

                                    $connectionMapper->update($connection);

                                }

                            } else {

                                $connection = new Connection();

                                $connection->request_to = $user_id_in_default_network;

                                $connection->request_from = $userDefaultForConnection->id;

                                $connection->status = Connection::STATUS_ACCEPTED;

                                $connectionMapper->insert($connection);

                            }

                        }

                        if($companyForFollower) {

                            $companyFollower = $companyFollowerMapper->fetchOneByCompanyIdAndUserId($companyForFollower->id, $user_id_in_default_network);

                            if(!$companyFollower) {

                                $companyFollower = new CompanyFollower();

                                $companyFollower->company_id = $companyForFollower->id;

                                $companyFollower->follower_id = $user_id_in_default_network;

                                $companyFollowerMapper->insert($companyFollower);

                            }

                        }

                    }

                    if(!in_array($user->id, $user_ids)) {

                        array_push($user_ids, $user->id);

                    }

                    /*

                    echo '$filterCompany = ' . $filterCompany . PHP_EOL;

                    echo '$filterFunctio = ' . $filterFunction . PHP_EOL;

                    echo '$filterGroup = ' . $filterGroup . PHP_EOL;

                    echo '$filterInstitution = ' . $filterInstitution . PHP_EOL;

                    echo '$filterPartner = ' . $filterPartner . PHP_EOL;

                    echo '$filterProgram = ' . $filterProgram . PHP_EOL;

                    echo '$filterSector = ' . $filterSector . PHP_EOL;

                    echo '$filterStudentType = ' . $filterStudentType . PHP_EOL;

                    */

                    $extendUser = $microlearningExtendUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);

                    if(!$extendUser) {

                        $extendUser = new MicrolearningExtendUser();

                        $extendUser->company_id = $currentCompany->id;

                        $extendUser->user_id = $user->id;

                    }

                    if($company) {

                        $record = $microlearningExtendUserCompanyMapper->fetchOneByCompanyIdAndName($currentCompany->id, $company);

                        if(!$record) {

                            $record = new MicrolearningExtendUserCompany();

                            $record->company_id = $currentCompany->id;

                            $record->name = $company;

                            $microlearningExtendUserCompanyMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_company_id = $record->id;

                        }

                    }

                    if($function) {

                        $record = $microlearningExtendUserFunctionMapper->fetchOneByCompanyIdAndName($currentCompany->id, $function);

                        if(!$record) {

                            $record = new MicrolearningExtendUserFunction();

                            $record->company_id = $currentCompany->id;

                            $record->name = $function;

                            $microlearningExtendUserFunctionMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_function_id = $record->id;

                        }

                    }

                    if($group) {

                        $record = $microlearningExtendUserGroupMapper->fetchOneByCompanyIdAndName($currentCompany->id, $group);

                        if(!$record) {

                            $record = new MicrolearningExtendUserGroup();

                            $record->company_id = $currentCompany->id;

                            $record->name = $group;

                            $microlearningExtendUserGroupMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_group_id = $record->id;

                        }

                    }

                    if($institution) {

                        $record = $microlearningExtendUserInstitutionMapper->fetchOneByCompanyIdAndName($currentCompany->id, $institution);

                        if(!$record) {

                            $record = new MicrolearningExtendUserInstitution();

                            $record->company_id = $currentCompany->id;

                            $record->name = $institution;

                            $microlearningExtendUserInstitutionMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_institution_id = $record->id;

                        }

                    }

                    if($program) {

                        $record = $microlearningExtendUserProgramMapper->fetchOneByCompanyIdAndName($currentCompany->id, $program);

                        if(!$record) {

                            $record = new MicrolearningExtendUserProgram();

                            $record->company_id = $currentCompany->id;

                            $record->name = $program;

                            $microlearningExtendUserProgramMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_program_id = $record->id;

                        }

                    }

                    if($partner) {

                        $record = $microlearningExtendUserPartnerMapper->fetchOneByCompanyIdAndName($currentCompany->id, $partner);

                        if(!$record) {

                            $record = new MicrolearningExtendUserPartner();

                            $record->company_id = $currentCompany->id;

                            $record->name = $partner;

                            $microlearningExtendUserPartnerMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_partner_id = $record->id;

                        }

                    }

                    if($sector) {

                        $record = $microlearningExtendUserSectorMapper->fetchOneByCompanyIdAndName($currentCompany->id, $sector);

                        if(!$record) {

                            $record = new MicrolearningExtendUserSector();

                            $record->company_id = $currentCompany->id;

                            $record->name = $sector;

                            $microlearningExtendUserSectorMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_sector_id = $record->id;

                        }

                    }

                    if($studentType) {

                        $record = $microlearningExtendUserStudentTypeMapper->fetchOneByCompanyIdAndName($currentCompany->id, $studentType);

                        if(!$record) {

                            $record = new MicrolearningExtendUserStudentType();

                            $record->company_id = $currentCompany->id;

                            $record->name = $studentType;

                            $microlearningExtendUserStudentTypeMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_student_type_id = $record->id;

                        }

                    }

                    if($country) {

                        $record = $microlearningExtendUserCountryMapper->fetchOneByCompanyIdAndName($currentCompany->id, $country);

                        if(!$record) {

                            $record = new MicrolearningExtendUserCountry();

                            $record->company_id = $currentCompany->id;

                            $record->name = $country;

                            $microlearningExtendUserCountryMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_country_id = $record->id;

                        }

                    }

                    if($extendUser->id) {

                        $result =   $microlearningExtendUserMapper->update($extendUser);

                    } else {

                        $result = $microlearningExtendUserMapper->insert($extendUser);

                    }

                }

                $notificationMapper = NotificationMapper::getInstance($this->adapter);

                $users_processed = 0;

                $users_previous = 0;

                foreach($user_ids as $user_id)

                {

                    $user = $userMapper->fetchOne($user_id);

                    $first_name = $user->first_name;

                    $last_name = $user->last_name;

                    $email = $user->email;

                    $users_processed++;

                    $topicUser = $topicUserMapper->fetchOneByUserIdAndTopicId($user_id, $topic->id);

                    if($topicUser) {

                        $users_previous++;

                        $csv .= "$first_name|$last_name|$email|PREVIOUS FOUND \r\n";

                    } else {

                        $topicUser = new MicrolearningTopicUser();

                        $topicUser->company_id = $topic->company_id;

                        $topicUser->topic_id = $topic->id;

                        $topicUser->topic_id = $topic->id;

                        $topicUser->user_id = $user_id;

                        $topicUser->access = MicrolearningTopicUser::ACCESS_UNLIMITED;

                        if($topicUserMapper->insert($topicUser)) {

                            $notification = new Notification();

                            $notification->company_id = $topic->company_id;

                            $notification->user_id = $user_id;

                            $notification->topic_id = $topic->id;

                            $notification->topic_id = $topic->id;

                            $notification->type = Notification::TYPE_NEW_MICROLEARNING_CAPSULE;

                            $notification->message  = 'LABEL_NOTIFICATION_NEW_MICROLEARNING_CAPSULE' . ' : ' . $topic->name;

                            $notification->url      = '/microlearning/topics/' . $topic->uuid .  '/detail';

                            $notificationMapper->insert($notification);

                            $csv .= "$first_name|$last_name|$email|CAPSULE USER ASSIGNED\r\n";

                            $users_assigned++;  

                            $topicUser = $topicUserMapper->fetchOne($topicUser->id);

                            if($topicUser) {

                                $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);

                                $microlearningUser = $microlearningUserMapper->fetchOneByUserIdAndCompanyId($topicUser->user_id, $topicUser->company_id);

                                if($microlearningUser) {

                                    $microlearningUser->updated_on = $topicUser->updated_on;

                                    $microlearningUserMapper->update($microlearningUser);

                                } else {

                                    $microlearningUser = new MicrolearningUser();

                                    $microlearningUser->company_id = $topicUser->company_id;

                                    $microlearningUser->user_id = $topicUser->user_id;

                                    $microlearningUser->added_on = $topicUser->added_on;

                                    $microlearningUser->updated_on = $topicUser->updated_on;

                                    $microlearningUserMapper->insert($microlearningUser);

                                } 

                            }

                        } else {

                            $csv .= "$first_name|$last_name|$email|CAPSULE USER PREVIOUS \r\n";

                        }

                    }

                }

                $users_in_the_topic = $topicUserMapper->fetchCountByCompanyIdAndTopicId($topic->company_id, $topic->id);

                return new JsonModel([

                    'success' => true, 

                    'data' => [

                        'users_assigned' => $users_assigned, 

                        'users_processed' => $users_processed,

                        'users_in_the_topic' => $users_in_the_topic,

                        'users_previous' => $users_previous,

                        'csv_base64_content' => base64_encode($csv),

                        'csv_filename' => 'topic-users-' .date('Y-m-d-h-i-s').  '.csv'

                    ]

                ]); 

            }