Symfony Profiler

<?php
/**
* Created by PhpStorm.
* User: grego
* Date: 02/06/2022
* Time: 12:30
*/
namespace App\Controller\ApiBundle;
use App\Entity\Badge;
use App\Entity\FAQQuestion;
use App\Entity\Feedback;
use App\Entity\Recipient;
use App\Entity\RequestLog;
use App\Entity\Recommendation;
use App\Entity\SkillsPath;
use App\Entity\User;
use App\Manager\CossManager;
use App\Manager\GamificationManager;
use App\Manager\MailerManager;
use App\Manager\UserManager;
use App\Repository\BadgeRepository;
use App\Repository\RecommendationRepository;
use App\Repository\RecipientRepository;
use DateTime;
use Doctrine\ORM\EntityManagerInterface;
use Dompdf\Dompdf;
use Dompdf\Options;
use FOS\RestBundle\Controller\AbstractFOSRestController;
use FOS\RestBundle\View\View;
use Imagick;
use ImagickException;
use pChart\pCharts;
use pChart\pColor;
use pChart\pDraw;
use Sonata\MediaBundle\Provider\Pool;
use Sonata\MediaBundle\Entity\MediaManager;
use Symfony\Bridge\Twig\Mime\TemplatedEmail;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Mailer\MailerInterface;
use Symfony\Component\Mime\Address;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Security;
use Symfony\Component\Security\Csrf\TokenStorage\TokenStorageInterface;
use Symfony\Contracts\Translation\TranslatorInterface;
use SymfonyCasts\Bundle\ResetPassword\Exception\ResetPasswordExceptionInterface;
use SymfonyCasts\Bundle\ResetPassword\ResetPasswordHelperInterface;
use Trikoder\Bundle\OAuth2Bundle\Model\Client;
use Trikoder\Bundle\OAuth2Bundle\Service\CredentialsRevoker\DoctrineCredentialsRevoker;
use FOS\RestBundle\Controller\Annotations\Get;
use FOS\RestBundle\Controller\Annotations\Post;
use FOS\RestBundle\Controller\Annotations\Patch;
use FOS\RestBundle\Controller\Annotations\Delete;
class UserRESTController extends AbstractFOSRestController {
private $resetPasswordHelper;
public function __construct(ResetPasswordHelperInterface $resetPasswordHelper)
{
$this->resetPasswordHelper = $resetPasswordHelper;
}
/**
* @Get("/api/user")
*/
public function getAction(Request $request, EntityManagerInterface $em, UserManager $userManager, GamificationManager $gamificationManager, Pool $pool)
{
$user = $this->getUser();
if (!$user->getDeletedAt()) {
$request->setLocale($user->getLocale());
$featured = $user->getImage();
$image = "/fakepath";
if ($featured) {
$provider = $pool->getProvider($featured->getProviderName());
$format = $provider->getFormatName($featured, "square");
$image = $provider->generatePublicUrl($featured, $format);
}
$image = $userManager->getBase64FromImage($image);
if (!$image) {
$image = $request->getSchemeAndHttpHost() . "/build/images/avatar-default.png";
}
$response = array("user" => $user);
$response["image"] = $image;
$badgesHistory = $em->getRepository(Badge::class)->getBadgesHistory($user);
$badgesFormatted = array();
$today = new DateTime();
foreach ($badgesHistory as $badge) {
$skill = $badge->getSkill();
$firstFeedback = $em->getRepository(Feedback::class)->getFirstFeedbackOnSkill($user, $skill, $today);
$lastFeedback = $em->getRepository(Feedback::class)->getLastFeedbackOnSkill($user, $skill, $today);
$start = new DateTime();
$end = new DateTime();
if ($firstFeedback) {
$start = $firstFeedback->getCreatedAt();
}
if ($lastFeedback) {
$end = $lastFeedback->getAnsweredAt();
}
$baseUrl = $request->getSchemeAndHttpHost();
$badgeUrl = $baseUrl.'/badges/'.$user->getId().'/baked/' .$badge->getToken().'-badge-baked.png'; // Baked badge PNG
$badgesFormatted[] = array(
"id" => $badge->getId(),
"user" => $badge->getUser(),
"skill" => $badge->getSkill(),
"createdAt" => $badge->getCreatedAt(),
"token" => $badge->getToken(),
"badgeUrl" => $badgeUrl,
"start" => $start,
"end" => $end,
'recommendations' => $userManager->getUserSkillActiveRecommendations($user, $badge)
);
}
$response["gamification"]["badgesHistory"] = $badgesFormatted;
$response["gamification"]["myskills"]["statistics"] = $userManager->getStatistics($user, $user->getLocale());
// Compute total strengths & weaknesses
$totalStrengths = array();
$totalWeaknesses = array();
foreach ($response["gamification"]["myskills"]["statistics"]['all'] as $skillStat) {
if (isset($skillStat['strengths'])) {
$totalStrengths = array_merge($totalStrengths, $skillStat['strengths']);
}
if (isset($skillStat['strengths'])) {
$totalWeaknesses = array_merge($totalWeaknesses, $skillStat['weaknesses']);
}
}
$totalStrengthsCumul = array();
$totalWeaknessesCumul = array();
foreach ($totalStrengths as $strength) {
if (isset($totalStrengthsCumul[$strength['tag']])) {
$totalStrengthsCumul[$strength['tag']]['count'] += $strength["count"];
} else {
$totalStrengthsCumul[$strength['tag']] = array('tag' => $strength['tag'], 'count' => $strength["count"]);
}
}
foreach ($totalWeaknesses as $weakness) {
if (isset($totalWeaknessesCumul[$weakness['tag']])) {
$totalWeaknessesCumul[$weakness['tag']]['count'] += $weakness["count"];
} else {
$totalWeaknessesCumul[$weakness['tag']] = array('tag' => $weakness['tag'], 'count' => $weakness["count"]);
}
}
$computedStrengthsWeaknesses = $userManager->computeStrengthsWeaknesses($totalStrengthsCumul, $totalWeaknessesCumul);
$totalStrengthsCumul = $computedStrengthsWeaknesses['strengths'];
$totalWeaknessesCumul = $computedStrengthsWeaknesses['weaknesses'];
// Desc sort
usort($totalStrengthsCumul, function ($first, $second) {
return $first['count'] < $second['count'];
});
usort($totalWeaknessesCumul, function ($first, $second) {
return $first['count'] < $second['count'];
});
$response['gamification']['strengthsWeaknessesCumul']['strengths'] = array_slice($totalStrengthsCumul, 0, 5);
$response['gamification']['strengthsWeaknessesCumul']['weaknesses'] = array_slice($totalWeaknessesCumul, 0, 5);;
$totalGoodBehaviors = array();
$totalMediumBehaviors = array();
$totalBadBehaviors = array();
foreach ($response['gamification']['myskills']['statistics']['all'] as &$skillStat) {
//Total Behaviors
$skillGoodBehavior = array("title" => $skillStat['skill']->getTitle());
$skillMediumBehavior = array("title" => $skillStat['skill']->getTitle());
$skillBadBehavior = array("title" => $skillStat['skill']->getTitle());
$worstScore = 5;
$worstBehavior = null;
foreach ($skillStat['scores'] as $score) {
if ($score['average'] < 3.9) {
$skillBadBehavior['behaviors'][] = array('title' => $score['question']->getBehavior(), 'score' => $score['average']);
}
if ($score['average'] >= 3.9 && $score['average'] < 4.2) {
$skillMediumBehavior['behaviors'][] = array('title' => $score['question']->getBehavior(), 'score' => $score['average']);
}
if ($score['average'] >= 4.2) {
$skillGoodBehavior['behaviors'][] = array('title' => $score['question']->getBehavior(), 'score' => $score['average']);
}
//Get worst behavior
if ($score['average'] < $worstScore) {
$worstScore = $score['average'];
$worstBehavior = array('title' => $score['question']->getBehavior(), 'score' => $score['average']);
}
}
if (!isset($skillBadBehavior['behaviors']) && isset($worstBehavior)) {
// Add worst behavior in bad
$skillBadBehavior['behaviors'][] = $worstBehavior;
// Remove worst behavior from medium or good behaviors
if (isset($skillMediumBehavior['behaviors'])) {
for ($i = 0; $i < count($skillMediumBehavior['behaviors']); $i++) {
if ($skillMediumBehavior['behaviors'][$i]['title'] == $worstBehavior['title'] && $skillMediumBehavior['behaviors'][$i]['score'] == $worstBehavior['score']) {
// Remove the element
unset($skillMediumBehavior['behaviors'][$i]);
}
}
}
if (isset($skillGoodBehavior['behaviors'])) {
for ($i = 0; $i < count($skillGoodBehavior['behaviors']); $i++) {
if ($skillGoodBehavior['behaviors'][$i]['title'] == $worstBehavior['title'] && $skillGoodBehavior['behaviors'][$i]['score'] == $worstBehavior['score']) {
// Remove the element
unset($skillGoodBehavior['behaviors'][$i]);
}
}
}
}
$totalGoodBehaviors[] = $skillGoodBehavior;
$totalMediumBehaviors[] = $skillMediumBehavior;
$totalBadBehaviors[] = $skillBadBehavior;
//Quality Index
$qualityIndex = $gamificationManager->getCOSSQualityIndex($user, $skillStat['skill']);
$skillStat['quality'] = $qualityIndex;
$skillStat['missingSuperiorFeedbacks'] = $qualityIndex['missingSuperiorFeedbacks'];
$skillStat['missingPairFeedbacks'] = $qualityIndex['missingPairFeedbacks'];
$skillStat['missingGuestFeedbacks'] = $qualityIndex['missingGuestFeedbacks'];
$skillStat['missingAllFeedbacks'] = $qualityIndex['missingAllFeedbacks'];
}
foreach ($totalGoodBehaviors as $i => $behavior) {
if (!isset($behavior['behaviors'])) {
unset($totalGoodBehaviors[$i]);
}
}
foreach ($totalMediumBehaviors as $i => $behavior) {
if (!isset($behavior['behaviors'])) {
unset($totalMediumBehaviors[$i]);
}
}
foreach ($totalBadBehaviors as $i => $behavior) {
if (!isset($behavior['behaviors'])) {
unset($totalBadBehaviors[$i]);
}
}
$totalGoodBehaviors = array_values($totalGoodBehaviors);
$totalMediumBehaviors = array_values($totalMediumBehaviors);
$totalBadBehaviors = array_values($totalBadBehaviors);
if (empty($totalBadBehaviors)) {
$switchedArrays = $gamificationManager->switchMediumToBadBehavior($totalMediumBehaviors, $totalBadBehaviors);
$totalMediumBehaviors = $switchedArrays['totalMediumBehaviors'];
$totalBadBehaviors = $switchedArrays['totalBadBehaviors'];
}
$response['gamification']['behaviors']['good'] = $totalGoodBehaviors;
$response['gamification']['behaviors']['medium'] = $totalMediumBehaviors;
$response['gamification']['behaviors']['bad'] = $totalBadBehaviors;
$activeWeeksNumber = 0;
$response["gamification"]["maxActiveWeeks"] = $activeWeeksNumber;
$contactsCount = 0;
$response["gamification"]["contactsCount"] = $contactsCount;
$response["alreadyRequested"] = $userManager->getAlreadyRequested($user);
$response["minRecipient"] = 5;
$response["minRecipientRequestedSkill"] = 3;
$response["requestedSkill"] = array();
/** @var Feedback $fb */
foreach ($user->getSentFeedbacks() as $fb) {
if ($fb->getSkill() && !$fb->getSelfEvaluation() && !in_array($fb->getSkill()->getId(), $response["requestedSkill"]) && !$fb->getResetted()) {
$response["requestedSkill"][] = $fb->getSkill()->getId();
}
}
$senders = array();
$sentFeedbacks = $em->getRepository(Feedback::class)->getSentFeedbacks($user);
//Handle old app versions before optimization
foreach ($sentFeedbacks as &$feedback) {
$feedback['skill'] = array('id' => $feedback['skill']);
}
$autoFeedbacks = $em->getRepository(Feedback::class)->findBy(array("recipient" => $user, "selfEvaluation" => true));
// Remove autoFeedbacks of unselected skills
$skillsIds = array();
foreach ($user->getSkills() as $skill){
$skillsIds[] = $skill->getId();
}
foreach ($autoFeedbacks as $key => $autoFeedback) {
if (!in_array($autoFeedback->getSkill()->getId(), $skillsIds, true)) {
unset($autoFeedbacks[$key]);
}
}
$autoFeedbacks = array_values($autoFeedbacks);
if ($user->getLocale() != "fr") {
foreach ($autoFeedbacks as $autoFb) {
$tagsFr = $autoFb->getSkill()->translate('fr')->getTags();
$tagsUserLanguage = $autoFb->getSkill()->translate($user->getLocale(), 'false')->getTags();
if ($autoFb->getStrengths() != null) {
$strengths = array();
$keys = array();
foreach ($autoFb->getStrengths() as $strength) {
$keys[] = array_search($strength, $tagsFr);
}
$translatedStrengths = array();
foreach ($keys as $key) {
$translatedStrengths[] = $tagsUserLanguage[$key];
}
foreach ($autoFb->getStrengths() as $i => $strength) {
$strengths[] = $translatedStrengths[$i];
}
$autoFb->{'strengthsTranslated'} = $strengths;
}
if ($autoFb->getWeaknesses() != null) {
$weaknesses = array();
$keys = array();
foreach ($autoFb->getWeaknesses() as $weakness) {
$keys[] = array_search($weakness, $tagsFr);
}
$translatedWeaknesses = array();
foreach ($keys as $key) {
$translatedWeaknesses[] = $tagsUserLanguage[$key];
}
foreach ($autoFb->getWeaknesses() as $i => $weakness) {
$weaknesses[] = $translatedWeaknesses[$i];
}
$autoFb->{'weaknessesTranslated'} = $weaknesses;
}
}
}
$response["feedbacks"] = array(
'sent' => $sentFeedbacks,
'auto' => $autoFeedbacks,
'unread_answers' => $userManager->getFeedbackAnswersCountSinceLastDashboardUpdate($user),
'unread_answers_by_skill' => $userManager->getFeedbackAnswersBySkillSinceLastDashboardUpdate($user)
);
/* RequestLog */
$log = new RequestLog();
$log->setUser($user);
$log->setEndpoint($request->getPathInfo());
$em->persist($log);
$em->flush();
/* RequestLog */
$user->setLastLogin(new DateTime());
$em->persist($user);
$em->flush();
return View::create($response, 200);
} else {
return View::create(array("deleted" => "true"), 401);
}
}
/**
* @Post("/api/forgottenpassword")
*/
public function postForgottenpasswordAction(Request $request, EntityManagerInterface $entityManager, TranslatorInterface $translator, MailerInterface $mailer){
$email = $request->request->get('email',false);
if(!$email){
return View::create(array("error" => "Invalid email"), 400);
}
/** @var $user UserInterface */
$user = $entityManager->getRepository(User::class)->findOneBy(array('email' => $email));
if($user){
$request->setLocale($user->getLocale());
try {
$resetToken = $this->resetPasswordHelper->generateResetToken($user);
} catch (ResetPasswordExceptionInterface $e) {
return View::create(array("success" => "OK"), 200);
}
$subject = $translator->trans(
"Réinitialisation de votre mot de passe",array(),'UserBundle'
);
$email = (new TemplatedEmail())
->from(new Address('noreply@globalcoss.com', 'COSS'))
->to($user->getEmail())
->subject($subject)
->htmlTemplate('CossBundle/reset_password/email.html.twig')
->context([
'resetToken' => $resetToken,
'resetType' => 'app'
])
;
$mailer->send($email);
// Store the token object in session for retrieval in check-email route.
$session = $request->getSession();
$session->set('ResetPasswordToken', $resetToken);
return View::create(array("success" => "OK"), 200);
} else {
return View::create(array("success" => "OK"), 200);
}
}
/**
* @Get("/api/cgu")
*/
public function getCguAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$html = $this->renderView(
'CossBundle/cgu.html.twig',
array('locale' => $user->getLocale(),
)
);
return View::create(array("html" => $html), 200);
}
/**
* @Get("/api/pol_conf")
*/
public function getPolConfAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$html = $this->renderView(
'CossBundle/pol_conf.html.twig',
array('locale' => $user->getLocale(),
)
);
return View::create(array("html" => $html), 200);
}
/**
* @Get("/api/user/onboarding/cgv")
*/
public function getOnboardingCgvAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$user->setOnboardingCgvDate(new DateTime());
$em->persist($user);
$em->flush();
return View::create(array("success" => "OK"), 200);
}
/**
* @Get("/api/user/onboarding/rules")
*/
public function getOnboardingRulesAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$user->setOnboardingRulesDate(new DateTime());
$em->persist($user);
$em->flush();
return View::create(array("success" => "OK"), 200);
}
/**
* @Get("/api/user/onboarding/info")
*/
public function getOnboardingUserInfoAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$user->setOnboardingUserInfoFinished(true);
$em->persist($user);
$em->flush();
return View::create(array("success" => "OK"), 200);
}
/**
* @Get("/api/user/onboarding/skills")
*/
public function getOnboardingSelectSkillsAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$user->setOnboardingSelectSkillsFinished(true);
$em->persist($user);
$em->flush();
return View::create(array("success" => "OK"), 200);
}
/**
* @Get("/api/user/onboarding/recipients")
*/
public function getOnboardingSelectRecipientsAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$user->setOnboardingSelectRecipientsFinished(true);
$em->persist($user);
$em->flush();
return View::create(array("success" => "OK"), 200);
}
/**
* @Get("/api/user/onboarding/finished")
*/
public function getOnboardingFinishedAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$user->setOnboardingFinished(true);
$em->persist($user);
$em->flush();
return $this->forward('App\Controller\ApiBundle\UserRESTController::getAction');
}
/**
* @Get("/api/user/history")
*/
public function getHistoryAction(Request $request, EntityManagerInterface $em){
$user = $this->getUser();
$request->setLocale($user->getLocale());
$suggestions = array();
$recipients = $em->getRepository(Recipient::class)->findExistingRecipients($user);
foreach ($recipients as $recipient){
$recipient = array(
"id" => $recipient->getId(),
"firstname" => $recipient->getUser()->getFirstname(),
"lastname" => $recipient->getUser()->getLastname(),
"email" => $recipient->getUser()->getEmail(),
"type" => $recipient->getType(),
"title" => $recipient->getTitle(),
"company" => $recipient->getUser()->getCompany(),
"status" => $recipient->getStatus(),
"sources" => $recipient->getSources(),
"last_recall_date" => $recipient->getLastRecallDate()
);
$suggestions[] = $recipient;
}
return View::create(array("suggestions" => $suggestions), 200);
}
/**
* @Patch("/api/user")
*/
public function patchAction(Request $request, EntityManagerInterface $em, MediaManager $mediaManager, UserManager $userManager, UserPasswordHasherInterface $passwordHasher){
$user = $this->getUser();
$request->setLocale($user->getLocale());
$firstname = $request->request->get('firstname',false);
$lastname = $request->request->get('lastname',false);
$company = $request->request->get('company',false);
$jobTitle = $request->request->get('jobTitle',false);
$password = $request->request->get('password',false);
$locale = $request->request->get('locale',false);
$image = $request->request->get('image',false);
if($firstname){
$user->setFirstname($firstname);
}
if($lastname){
$user->setLastname($lastname);
}
if($company){
$user->setCompany($company);
}
if($jobTitle){
$user->setJobTitle($jobTitle);
}
if($password){
$token = $request->request->get('currentPassword');
$hashedPassword = $passwordHasher->hashPassword(
$user,
$password
);
$user->setPassword($hashedPassword);
}
if($image){
$data = explode(",",$image);
$media = $userManager->getMediaFromBase64($data[0], $data[1], "image_" . $user->getId());
$mediaManager->save($media);
$em->persist($media);
$user->setImage($media);
}
if($locale)
$user->setLocale($locale);
$em->persist($user);
$em->flush();
return $this->forward('App\Controller\ApiBundle\UserRESTController::getAction');
}
/**
* @Get("/api/user/rightnesses/update")
*/
function updateUsersRightnessAction(EntityManagerInterface $em, UserManager $userManager)
{
$users = $em->getRepository(User::class)->findAll();
foreach($users as $user){
$user->setRightness($userManager->getUserRightness($user));
$em->persist($user);
}
$em->flush();
return View::create(array(),200);
}
/**
* @Get("/api/user/dashboard/access")
*/
function updateLastDashboardAccessAction(Request $request, EntityManagerInterface $entityManager){
$user = $this->getUser();
$user->setLastDashboardAccess(new DateTime());
$entityManager->persist($user);
$entityManager->flush();
return View::create(array(),200);
}
/**
* @Get("/api/check-update")
*/
function checkUpdateAction(Request $request, ParameterBagInterface $parameterBag){
return View::create(array("androidMinVersion" => $parameterBag->get('app_min_version_android'), "iosMinVersion" => $parameterBag->get('app_min_version_ios')));
}
/**
* @Get("/api/getcredentials")
*/
function getCredentialsAction(Request $request, EntityManagerInterface $entityManager){
$apiCredentials = $entityManager->getRepository(Client::class)->findOneBy(array('active' => true));
return View::create(array("clientId" => $apiCredentials->getIdentifier(), "clientSecret" => $apiCredentials->getSecret()));
}
/**
* @Post("/api/check/saml")
*/
public function checkSamlAction(Request $request, EntityManagerInterface $entityManager, CossManager $cossManager, SessionInterface $session)
{
$matricule = $request->request->get('matricule');
$source = $request->request->get('source');
if($matricule){
$user = $entityManager->getRepository(User::class)->findOneBy(array('matricule' => $matricule));
if($user){
$school = $user->getSchool();
if($school){
if($source === "app"){
if($school->getSamlEntityFront()){
$entityId = $school->getSamlEntityFront();
$samlLoginUrl = $request->getSchemeAndHttpHost().$this->generateUrl('lightsaml_sp.login', [
'idp' => $entityId,
]);
return View::create(array("link" => $samlLoginUrl, "status" => "true"), 200);
} else {
return View::create(array("status" => "false"), 200);
}
} elseif ($source === "client"){
if($school->getSamlEntityBack()){
$entityId = $school->getSamlEntityBack();
$samlLoginUrl = $request->getSchemeAndHttpHost().$this->generateUrl('lightsaml_sp.login', [
'idp' => $entityId,
]);
return View::create(array("link" => $samlLoginUrl, "status" => "true"), 200);
} else {
return View::create(array("status" => "false"), 200);
}
} else {
return View::create(array("status" => "false"), 200);
}
} else {
return View::create(array("status" => "false"), 200);
}
} else {
return View::create(array("status" => "false"), 200);
}
} else {
return View::create(array("status" => "false"), 200);
}
}
/**
* @Get("/api/saml/logged")
*/
public function samlLoggedAction(Request $request, EntityManagerInterface $entityManager)
{
$session = $request->getSession();
$email = $session->get('saml_user');
$password = $session->get('saml_password');
$source = $session->get('saml_source');
// TODO CHANGER URLS AVEC B2C
$user = $entityManager->getRepository(User::class)->findOneBy(array('email' => $email));
if($user){
if($source == 'app'){
return $this->redirect("https://app.globalcoss.com?saml=true&email=".$user->getEmail()."&token=".$password);
}
if($source == 'client'){
return $this->redirect("https://manager.globalcoss.com");
}
} else {
return $this->redirect("https://app.globalcoss.com?saml=false");
}
}
/**
* @Post("/api/platform/used")
*/
public function platformUsedAction(Request $request, EntityManagerInterface $entityManager)
{
$user = $this->getUser();
$platform = $request->request->get('platform');
if($user->getPlatform() != 'mobile'){
if($platform == "browser"){
$user->setPlatform('browser');
} elseif($platform == "mobile") {
$user->setPlatform('mobile');
}
}
$entityManager->persist($user);
$entityManager->flush();
return View::create(array(), 200);
}
/**
* @Get("/api/revoke-tokens")
*/
public function revokeTokensAction(Request $request, DoctrineCredentialsRevoker $doctrineCredentialsRevoker)
{
$user = $this->getUser();
$doctrineCredentialsRevoker->revokeCredentialsForUser($user);
return View::create(array(), 200);
}
/**
* @Post("/api/badges/linkedin/{token}")
*/
public function newLinkedInBadgesAction(Request $request, $token)
{
$link = $this->generateUrl('badges_detail', array('token' => $token), UrlGeneratorInterface::ABSOLUTE_URL);
return View::create(array('link' => $link), 200);
}
/**
* @Get("/api/badges/email/{token}")
*/
public function sendBadgesEmailAction(Request $request, $token, EntityManagerInterface $entityManager, UserManager $userManager, MailerManager $mailerManager)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$badge = $entityManager->getRepository(Badge::class)->findBy(array('token' => $token));
if($badge){
$badge = $badge[0];
} else {
return View::create(array("error" => "Invalid token"), 400);
}
$skill = $badge->getSkill();
$average = $userManager->getUserSkillAverage($user, $skill, $user->getLocale());
if($average){
$link = $this->generateUrl('badges_detail', array('token' => $token), UrlGeneratorInterface::ABSOLUTE_URL);
$badgeImagePath = __DIR__ . '/../../../public/badges/'.$badge->getUser()->getId().'/'. $badge->getToken().'-badge.png';
$now = new \DateTime();
$mailerManager->sendBadgesEmail($user, $link, array('link' => $badgeImagePath, 'skill' => $skill->getTitle(), 'name' => "badge-".$skill->getTitle().'-'.$now->format('d-m-Y').'.png'));
return View::create(array(), 200);
} else {
return View::create(array(), 400);
}
}
/**
* @Get("/api/badges/delete/{token}")
*/
public function deleteBadgesAction(Request $request, $token, EntityManagerInterface $entityManager)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$badges = $entityManager->getRepository(Badge::class)->findBy(array('token' => $token));
if($badges){
$badges = $badges[0];
} else {
return View::create(array("error" => "Invalid token"), 400);
}
$badges->setStatus(BadgeRepository::STATUS_INACTIVE);
$entityManager->persist($badges);
$entityManager->flush();
return View::create(array(), 200);
}
/**
* @Patch("/api/recipients/{id}")
*/
public function saveRecipientAction(Request $request, EntityManagerInterface $em, UserPasswordHasherInterface $passwordHasher, $id=null)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
if(in_array('ROLE_COSS_USER', $user->getRoles())) {
$firstname = $request->request->get('firstname',"");
$lastname = $request->request->get('lastname',"");
$email = $request->request->get('email',"");
$type = $request->request->get('type',"");
$title = $request->request->get('title',"");
$company = $request->request->get('company',"");
$sources = $request->request->get('sources',array());
if($type == "SUPERIOR" || $type == "superior"){
$formattedType = RecipientRepository::SUPERIOR_RECIPIENT;
} elseif ($type == "PAIR" || $type == "pair"){
$formattedType = RecipientRepository::PAIR_RECIPIENT;
}elseif ($type == "GUEST" || $type == "guest"){
$formattedType = RecipientRepository::GUEST_RECIPIENT;
} else {
$formattedType = RecipientRepository::GUEST_RECIPIENT;
}
if($id){
$existingRecipients = $em->getRepository(Recipient::class)->findExistingRecipients($user);
$recipient = $em->getRepository(Recipient::class)->find($id);
foreach ($existingRecipients as $existingRecipient){
if($existingRecipient->getId() === $recipient->getId()){
$recipient->setType($formattedType);
$recipient->setTitle($title);
$recipient->setCompany($company);
$recipient->setSources($sources);
$recipient->getUser()->setEmail($email);
$recipient->getUser()->setFirstname($firstname);
$recipient->getUser()->setLastname($lastname);
$em->persist($recipient->getUser());
$em->persist($recipient);
}
}
} else {
$existingUser = $em->getRepository(User::class)->findOneBy(array('email' => $email));
if(!$existingUser){
$u = new User();
$u->setFirstname($firstname);
$u->setLastname($lastname);
if (!$firstname || $firstname == "") {
$u->setFirstname($lastname);
}
if (!$lastname || $lastname == "") {
$u->setLastname($firstname);
}
$u->setEmail($email);
$u->setUsername($email);
$u->setLocale($user->getLocale());
$plainpassword = substr( str_shuffle( 'abcdefghjklmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789' ), 0, 10 );
$password = $passwordHasher->hashPassword(
$u,
$plainpassword
);
$u->setPassword($password);
$em->persist($u);
$em->flush();
} else {
$u = $existingUser;
// Update fields if guest user
if(!in_array('ROLE_COSS_USER', $u->getRoles())){
$u->setFirstname($firstname);
$u->setLastname($lastname);
$em->persist($u);
}
}
$newRecipient = new Recipient();
$newRecipient->setAppUser($user);
$newRecipient->setUser($u);
$newRecipient->setStatus(RecipientRepository::STATUS_PENDING);
$newRecipient->setType($formattedType);
$newRecipient->setTitle($title);
$newRecipient->setCompany($company);
$newRecipient->setSources($sources);
$em->persist($newRecipient);
}
$em->flush();
if(isset($newRecipient)){
$recipient = $newRecipient;
}
$recipientFormatted = array(
"id" => $recipient->getId(),
"firstname" => $recipient->getUser()->getFirstname(),
"lastname" => $recipient->getUser()->getLastname(),
"email" => $recipient->getUser()->getEmail(),
"type" => $recipient->getType(),
"title" => $recipient->getTitle(),
"company" => $recipient->getCompany(),
"status" => $recipient->getStatus(),
"sources" => $recipient->getSources(),
"last_recall_date" => $recipient->getLastRecallDate()
);
return View::create($recipientFormatted, 200);
} else {
return View::create(array(), 400);
}
}
/**
* @Delete("/api/recipients/{id}")
*/
public function deleteRecipientAction(Request $request, EntityManagerInterface $em, $id=null)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
if(in_array('ROLE_COSS_USER', $user->getRoles())) {
if($id){
$existingRecipients = $em->getRepository(Recipient::class)->findExistingRecipients($user);
$recipient = $em->getRepository(Recipient::class)->find($id);
foreach ($existingRecipients as $existingRecipient){
if($existingRecipient->getId() === $recipient->getId()){
$em->remove($recipient);
}
}
}
return View::create(array(), 200);
} else {
return View::create(array(), 400);
}
}
/**
* @Patch("/api/update/feedback/count")
*/
public function updateFeedbackCountAction(Request $request, EntityManagerInterface $em)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$user->setNewFeedbackCount(0);
$em->persist($user);
$em->flush();
return View::create(array(), 200);
}
/**
* @Patch("/api/update/badge/count")
*/
public function updateBadgeCountAction(Request $request, EntityManagerInterface $em)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$user->setNewBadgeCount(0);
$em->persist($user);
$em->flush();
return View::create(array(), 200);
}
/**
* @Patch("/api/choose/skillspath")
*/
public function chooseSkillsPathAction(Request $request, EntityManagerInterface $em)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$skillsPathId = $request->request->get('skills_path_id',false);
$skillsPath = $em->getRepository(SkillsPath::class)->find($skillsPathId);
if($skillsPath){
$user->setSkillsPath($skillsPath);
}
foreach ($user->getSkills() as $s){
$user->removeSkill($s);
}
$em->persist($user);
$em->flush();
return View::create(array(), 200);
}
/**
* @Post("/api/check/licence/access")
*/
public function checkLicenceAccessAction(Request $request)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$today = new DateTime();
if(!$user->getLicenceStartDate() || !$user->getLicenceEndDate()){
$request->getSession()->invalidate();
return View::create(array("access" => "false"), 400);
} else {
if($user->getLicenceStartDate() <= $today && $user->getLicenceEndDate() >= $today){
return View::create(array("access" => "true"), 200);
} else {
if($user->getLicenceStartDate() >= $today){
$request->getSession()->invalidate();
return View::create(array("access" => "false"), 400);
} else {
if($user->getLicenceEndDate() <= $today){
if($user->getBadgesAccess()){
return View::create(array("access" => "expired"), 200);
} else {
$request->getSession()->invalidate();
return View::create(array("access" => "false"), 400);
}
} else {
return View::create(array("access" => "true"), 200);
}
}
}
}
}
/**
* @Patch("/api/recall/validator")
*/
public function recallValidatorAction(Request $request, EntityManagerInterface $em, MailerManager $mailerManager)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
if($user->getValidator()){
$lastValidatorRecall = $user->getLastValidatorRecall();
$now = new DateTime();
if ($lastValidatorRecall) {
$lastValidatorRecall->modify('+12 hour');
}
if (!$lastValidatorRecall || $now >= $lastValidatorRecall) {
if(!$lastValidatorRecall){
$mailerManager->sendRecipientListChanged($user->getValidator(), $user);
} else {
$mailerManager->sendRecipientListChangedRecall($user->getValidator(), $user);
}
$user->setLastValidatorRecall(new DateTime());
$em->persist($user);
$em->flush();
return View::create(array('status' => 'email_sent'), 200);
} else {
return View::create(array('status' => 'not_available'), 200);
}
} else {
$lastCossRecall = $user->getLastCossRecall();
$now = new DateTime();
if ($lastCossRecall) {
$lastCossRecall->modify('+12 hour');
}
if (!$lastCossRecall || $now >= $lastCossRecall) {
$mailerManager->sendCOSSRecipientListChanged($user);
$user->setLastCossRecall(new DateTime());
$em->persist($user);
$em->flush();
return View::create(array('status' => 'email_sent'), 200);
} else {
return View::create(array('status' => 'not_available'), 200);
}
}
}
/**
* @Get("/api/recall/recipients")
*/
public function recallRecipientsAction(Request $request, EntityManagerInterface $em, MailerManager $mailerManager)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$recipients = $em->getRepository(Recipient::class)->findExistingRecipients($user);
foreach ($recipients as $recipient){
$yesterday = new DateTime();
$yesterday->modify("-1 day");
if($recipient->getLastRecallDate() <= $yesterday){
$mailerManager->sendFeedbackRecap($recipient->getUser(), 'recall');
}
}
return View::create(array(), 200);
}
/**
* @Patch("/api/recommendation/{id}")
*/
public function patchRecommendationAction(Request $request, EntityManagerInterface $em, $id)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$recommendation = $em->getRepository(Recommendation::class)->find($id);
if($recommendation) {
$action = $request->request->get('action');
if($action){
switch($action){
case "accept":
$recommendation->setStatus(RecommendationRepository::STATUS_ACCEPTED);
$em->persist($recommendation);
$em->flush();
break;
case "delete":
$em->remove($recommendation);
$em->flush();
break;
default:
return View::create(array(), 400);
break;
}
return View::create(array('status' => 'recommendation_saved'), 200);
} else {
return View::create(array(), 400);
}
} else {
return View::create(array(), 400);
}
}
/**
* @Get("/api/open/badge/class/{token}", name="open_badge_class")
*/
public function getBadgeClass($token, EntityManagerInterface $entityManager)
{
// Fetch badge details from the database
$badges = $entityManager->getRepository(Badge::class)->findBy(array('token' => $token));
if ($badges) {
$badge = $badges[0];
$skill = $badge->getSkill();
$publicLink = $this->generateUrl('badges_detail', array('token' => $token), UrlGeneratorInterface::ABSOLUTE_URL);
$jsonLink = $this->generateUrl('open_badge_class', array('token' => $token), UrlGeneratorInterface::ABSOLUTE_URL);
$issuerLink = $this->generateUrl('open_badge_issuer', array(), UrlGeneratorInterface::ABSOLUTE_URL);
$imageLink = $this->generateUrl('open_badge_bake', array('token' => $token), UrlGeneratorInterface::ABSOLUTE_URL);
$badgeJson = [
"@context" => "https://w3id.org/openbadges/v2",
"type" => "BadgeClass",
"id" => $jsonLink,
"name" => $skill->getTitle(),
"description" => $skill->getDescription() ? $skill->getDescription() : "Pas de description",
"issuer" => $issuerLink,
"criteria" => $publicLink,
"image" => $imageLink
];
return new JsonResponse($badgeJson);
}
return new JsonResponse(array());
}
/**
* @Get("/api/open/badge/issuer", name="open_badge_issuer")
*/
public function getBadgeIssuer()
{
$issuerJsonLink = $this->generateUrl('open_badge_issuer', array(), UrlGeneratorInterface::ABSOLUTE_URL);
$issuerJson = [
"@context" => "https://w3id.org/openbadges/v2",
"type" => "Issuer",
"id" => $issuerJsonLink,
"name" => "COSS",
"url" => "https://globalcoss.com",
"email" => "contact@globalcoss.com"
];
return new JsonResponse($issuerJson);
}
/**
* @Get("/api/open/badge/assertion/{token}", name="open_badge_assertion")
*/
public function getBadgeAssertion($token, EntityManagerInterface $entityManager, CossManager $cossManager)
{
// Fetch badge details from the database
$badges = $entityManager->getRepository(Badge::class)->findBy(array('token' => $token));
if ($badges) {
$badge = $badges[0];
$badgeJson = $cossManager->getOpenBadgeJson($badge);
return new JsonResponse($badgeJson);
}
return new JsonResponse(array());
}
/**
* @Get("/api/open/badge/bake/{token}", name="open_badge_bake")
*/
public function openBadgeBake($token, EntityManagerInterface $entityManager, CossManager $cossManager, UserManager $userManager, ParameterBagInterface $parameterBag)
{
// Fetch badge details from the database
$badges = $entityManager->getRepository(Badge::class)->findBy(array('token' => $token));
if ($badges) {
$badge = $badges[0];
$skill = $badge->getSkill();
$projectDir = $parameterBag->get('kernel.project_dir');
$outputPngPath = $projectDir . '/public/badges/'.$badge->getUser()->getId().'/baked/' . $badge->getToken().'-badge-baked.png'; // Baked badge PNG
if(!file_exists($outputPngPath)){
$image = $cossManager->bakeOpenBadge($badge, $skill, $outputPngPath);
if($image){
$response = new Response();
$response->headers->set('Content-Type', 'image/png');
$response->setContent($image);
return $response;
} else {
return new Response('Failed to bake the badge', Response::HTTP_INTERNAL_SERVER_ERROR);
}
} else {
try{
$image = new Imagick($outputPngPath);
$response = new Response();
$response->headers->set('Content-Type', 'image/png');
$response->setContent($image->getImageBlob());
return $response;
} catch(ImagickException $e){
return new Response('Failed to open the badge', Response::HTTP_INTERNAL_SERVER_ERROR);
}
}
} else {
return new Response('No badge found', Response::HTTP_INTERNAL_SERVER_ERROR);
}
}
/**
* @Get("/api/faq")
*/
public function getFAQAction(Request $request, EntityManagerInterface $entityManager)
{
$user = $this->getUser();
$request->setLocale($user->getLocale());
$faq = $entityManager->getRepository(FAQQuestion::class)->findBy(array(), array('sortOrder' => 'ASC'));
return View::create(array('data' => $faq));
}
}

src/Controller/ApiBundle/UserRESTController.php line 659