Laterex/webnaplo-gulbaba-api
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* logger added

Browse Source 
* calendar view in maintenance
* $year filter support in xlsx and maintenance
This commit is contained in:
Danyi Dávid
2018-11-19 16:48:12 +01:00
parent b906e360bf
commit 4d52d4b575
13 changed files with 392 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/App/ConfigProvider.php
View File

@@ -42,6 +42,7 @@ class ConfigProvider
'factories' => [
Handler\MaintenanceHandler::class => Handler\MaintenanceFactory::class,
Handler\MaintenanceUpcomingHandler::class => Handler\MaintenanceUpcomingFactory::class,
Handler\MaintenanceCalendarHandler::class => Handler\MaintenanceCalendarFactory::class,
Handler\Auth\AuthHandler::class => Handler\Auth\AuthFactory::class,
Handler\User\UserHandler::class => Handler\User\UserFactory::class,

19
src/App/Handler/MaintenanceCalendarFactory.php Normal file
View File

@@ -0,0 +1,19 @@
<?php
namespace App\Handler;
use App\Service\MaintenanceManagerService;
use Interop\Container\ContainerInterface;
class MaintenanceCalendarFactory
{
/**
* @param ContainerInterface $container
* @return MaintenanceCalendarHandler
*/
public function __invoke(ContainerInterface $container): MaintenanceCalendarHandler
{
$maintenanceManagerService = $container->get(MaintenanceManagerService::class);
return new MaintenanceCalendarHandler($maintenanceManagerService);
}
}

34
src/App/Handler/MaintenanceCalendarHandler.php Normal file
View File

@@ -0,0 +1,34 @@
<?php
namespace App\Handler;
use ApiLibs\AbstractHandler\CrudHandler;
use App\Service\MaintenanceManagerService;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Zend\Diactoros\Response\JsonResponse;
class MaintenanceCalendarHandler extends CrudHandler
{
/** @var MaintenanceManagerService */
private $maintenanceManagerService;
public function __construct(MaintenanceManagerService $maintenanceManagerService)
{
$this->maintenanceManagerService = $maintenanceManagerService;
}
/**
* Renew auth token
*
* @param ServerRequestInterface $request
* @return ResponseInterface
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
public function getList(ServerRequestInterface $request): ResponseInterface
{
$year = (int)$request->getAttribute('year', date("Y"));
return new JsonResponse($this->maintenanceManagerService->getCalendarMaintenanceList($year));
}
}

10
src/App/Handler/MaintenanceHandler.php
View File

@@ -26,7 +26,8 @@ class MaintenanceHandler extends CrudHandler
*/
public function getList(ServerRequestInterface $request): ResponseInterface
{
return new JsonResponse($this->maintenanceManagerService->getMaintenanceList()->getValues());
$year = (int)$request->getAttribute('year', date("Y"));
return new JsonResponse($this->maintenanceManagerService->getMaintenanceList($year)->getValues());
}
/**
@@ -39,7 +40,8 @@ class MaintenanceHandler extends CrudHandler
public function get(ServerRequestInterface $request): ResponseInterface
{
$hash = $request->getAttribute(self::IDENTIFIER_NAME);
return new JsonResponse($this->maintenanceManagerService->get($hash));
$year = (int)$request->getAttribute('year', date("Y"));
return new JsonResponse($this->maintenanceManagerService->get($hash, $year));
}
/**
@@ -53,7 +55,7 @@ class MaintenanceHandler extends CrudHandler
{
$hash = $request->getAttribute(self::IDENTIFIER_NAME);
$data = $this->getRequestData($request);
$jwt = $request->getAttribute('token');
return new JsonResponse($this->maintenanceManagerService->update($hash, $data, $jwt->uid));
$token = $request->getAttribute('token');
return new JsonResponse($this->maintenanceManagerService->update($hash, $data, $token['uid']));
}
}

3
src/App/Handler/MaintenanceUpcomingHandler.php
View File

@@ -26,6 +26,7 @@ class MaintenanceUpcomingHandler extends CrudHandler
*/
public function getList(ServerRequestInterface $request): ResponseInterface
{
return new JsonResponse($this->maintenanceManagerService->getUpcomingMaintenanceList()->getValues());
$year = (int)$request->getAttribute('year', date("Y"));
return new JsonResponse($this->maintenanceManagerService->getUpcomingMaintenanceList($year)->getValues());
}
}

136
src/App/Service/MaintenanceManagerService.php
View File

@@ -25,29 +25,36 @@ class MaintenanceManagerService
/** @var UserService */
private $userService;
/** @var int */
private $year;
public function __construct(
EntityManager $em,
DoctrineObject $hydrator,
XlsxParserService $xlsxParserService,
UserService $userService
) {
// $this->year = date("Y");
$this->year = 2018;
$this->em = $em;
$this->hydrator = $hydrator;
$this->xlsxParserService = $xlsxParserService;
$this->userService = $userService;
}
public function getMaintenanceList(): ArrayCollection
/**
* @param int $year
* @return ArrayCollection
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
public function getMaintenanceList(int $year): ArrayCollection
{
return $this->getUpdatedXlsxData();
return $this->getUpdatedXlsxData($year);
}
public function getUpcomingMaintenanceList(): ArrayCollection
/**
* @param int $year
* @return ArrayCollection
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
public function getUpcomingMaintenanceList(int $year): ArrayCollection
{
$firstDayOfThisWeek = new \DateTime("@" . strtotime(sprintf("-%s days", date("N") - 0)));
$firstDayOfThisWeek
@@ -55,7 +62,7 @@ class MaintenanceManagerService
->setTime(0, 0);
$twoWeeksFromNow = (clone $firstDayOfThisWeek)->add(\DateInterval::createFromDateString("+14 days"));
$deviceGroups = $this->getUpdatedXlsxData();
$deviceGroups = $this->getUpdatedXlsxData($year);
foreach ($deviceGroups as $deviceGroup) {
/** @var DeviceGroup $deviceGroup */
@@ -82,15 +89,57 @@ class MaintenanceManagerService
}
/**
* @return DeviceGroup[]|ArrayCollection
* @param $year
* @return array
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
private function getUpdatedXlsxData()
public function getCalendarMaintenanceList($year): array
{
$result = [];
$deviceGroups = $this->getUpdatedXlsxData($year);
foreach ($deviceGroups as $deviceGroup) {
/** @var DeviceGroup $deviceGroup */
foreach ($deviceGroup->getDevices() as $device) {
foreach ($device->getTasks() as $task) {
$result[$task->getMonth()][] = [
'id' => $task->getHash(),
'state' => $task->getState(),
'month' => $task->getMonth(),
'start' => $task->getShouldStartAt()->format("Y-m-d"),
'finish' => $task->getShouldBeDoneBy()->format("Y-m-d"),
'group' => $deviceGroup->getName(),
'device' => [
'name' => $device->getName(),
'count' => $device->getCount(),
'work' => $device->getWorkDescription(),
],
];
}
}
// $devices = $deviceGroup->getDevices()->filter(function (Device $device) {
// return count($device->getTasks());
// });
// $deviceGroup->setDevices($devices);
}
return array_values($result);
}
/**
* @param $year
* @return DeviceGroup[]|ArrayCollection
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
private function getUpdatedXlsxData($year)
{
/** @var DeviceGroup[] $loadedCacheData */
$loadedCacheData = $this->xlsxParserService->getXlsxData();
$loadedCacheData = $this->xlsxParserService->getXlsxData($year);
/** @var Maintenance[] $dbMaintenances */
$dbMaintenances = $this->getMaintenancesInYear($this->year);
$dbMaintenances = $this->getMaintenancesInYear($year);
foreach ($dbMaintenances as $maintenance) {
foreach ($loadedCacheData as &$deviceGroup) {
foreach ($deviceGroup->getDevices() as &$device) {
@@ -105,6 +154,10 @@ class MaintenanceManagerService
return $loadedCacheData;
}
/**
* @param $year
* @return array
*/
public function getMaintenancesInYear($year): array
{
$qb = $this->em->createQueryBuilder();
@@ -120,16 +173,19 @@ class MaintenanceManagerService
/**
* @param string $hash
* @param int $year
* @return Maintenance
* @throws \Doctrine\ORM\ORMException
* @throws \Doctrine\ORM\OptimisticLockException
* @throws \Doctrine\ORM\TransactionRequiredException
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
public function get(string $hash): Maintenance
public function get(string $hash, int $year): Maintenance
{
/** @var Maintenance $maintenance */
if (null == ($maintenance = $this->em->find(Maintenance::class, $hash))) {
$maintenance = $this->initMaintenanceInDatabase($hash);
$maintenance = $this->initMaintenanceInDatabase($hash, $year);
}
return $maintenance;
}
@@ -142,10 +198,12 @@ class MaintenanceManagerService
* @throws \Doctrine\ORM\ORMException
* @throws \Doctrine\ORM\OptimisticLockException
* @throws \Doctrine\ORM\TransactionRequiredException
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
public function update(string $hash, $data, int $uid): Maintenance
{
$maintenance = $this->get($hash);
$maintenance = $this->get($hash, (int)$data['year']);
/** @var Maintenance $maintenance */
$maintenance = $this->hydrator->hydrate($data, $maintenance);
if (null == $maintenance->getStartedBy()) {
@@ -163,43 +221,17 @@ class MaintenanceManagerService
/**
* @param string $id
* @param string $state
* @param int $uid
* @param $year
* @return Maintenance
* @throws \Doctrine\ORM\ORMException
* @throws \Doctrine\ORM\OptimisticLockException
* @throws \Doctrine\ORM\TransactionRequiredException
* @deprecated
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
public function setStatus(string $id, string $state, int $uid): Maintenance
{
$user = $this->userService->get($uid);
$maintenance = $this->get($id);
$maintenance->setState($state);
switch ($state) {
case "wip":
$maintenance->setWorkStarted(new \DateTime())
->setWorksheetNumber($this->generateWorksheetId($maintenance->getShouldStartAt()->format("Y")))
->setStartedBy($user);
break;
case "fin":
$maintenance->setWorkFinished(new \DateTime())
->setFinishedBy($user);
break;
}
$this->em->flush();
return $maintenance;
}
/**
* @param string $id
* @return Maintenance
* @throws \Doctrine\ORM\OptimisticLockException
*/
private function initMaintenanceInDatabase(string $id): Maintenance
private function initMaintenanceInDatabase(string $id, $year): Maintenance
{
$taskFound = null;
$loadedCacheData = $this->getUpdatedXlsxData();
$loadedCacheData = $this->getUpdatedXlsxData($year);
foreach ($loadedCacheData as $deviceGroup) {
foreach ($deviceGroup->getDevices() as $device) {
foreach ($device->getTasks() as $task) {
@@ -218,7 +250,7 @@ class MaintenanceManagerService
->setResponsible($taskFound->getDevice()->getResponsible())
->setCount($taskFound->getDevice()->getCount())
->setWorkDescription($taskFound->getDevice()->getWorkDescription())
->setYear($this->year)
->setYear($year)
->setMonth($taskFound->getMonth())
->setWeek($taskFound->getWeek())
->setWorkerCount($taskFound->getWorkerCount())
@@ -231,20 +263,20 @@ class MaintenanceManagerService
}
/**
* @param $workSheetYear
* @return string
*/
private function generateWorksheetId($year): string
private function generateWorksheetId($workSheetYear): string
{
$yearsFaultCount = $this->em->createQueryBuilder()
->select('count(f.hash)')
->from(Maintenance::class, 'f')
->where('YEAR(f.shouldStartAt) = :thisYear')
// ->andWhere('f.shouldStartAt IS NOT null')
->andWhere('f.worksheetNumber IS NOT null')
->setParameter('thisYear', $year)
->setParameter('thisYear', $workSheetYear)
->getQuery()
->setHydrationMode(Query::HYDRATE_SINGLE_SCALAR)
->execute();
return sprintf("%s/%s", $this->year, $yearsFaultCount+1);
return sprintf("%s/%s", $workSheetYear, $yearsFaultCount+1);
}
}

73
src/App/Service/XlsxParserService.php
View File

@@ -15,24 +15,15 @@ class XlsxParserService
const XLSX_FILE_NAME = 'data/user-upload/webnaplo_%s.xlsx';
const XLSX_CACHE_FILE = 'data/cache/xlsx-full-cache_%s.dat';
/**
* @var DeviceGroup[]|ArrayCollection
*/
/** @var DeviceGroup[]|ArrayCollection */
private $deviceGroups;
/**
* @var int
*/
private $year;
/**
* XlsxParserService constructor.
*/
public function __construct()
{
$this->deviceGroups = new ArrayCollection();
$this->year = date("Y");
// $this->year = 2018;
}
/**
@@ -60,46 +51,55 @@ class XlsxParserService
}
/**
* @param int $year
* @return ArrayCollection|Maintenance[]
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
public function getXlsxData(): ArrayCollection
public function getXlsxData(int $year): ArrayCollection
{
if (!file_exists($this->getXlsxFileName())) {
if (!file_exists($this->getXlsxFileName($year))) {
return new ArrayCollection();
}
if (!file_exists($this->getTimestampFileName()) ||
!file_exists($this->getCacheFileName()) ||
file_get_contents($this->getTimestampFileName()) < filemtime($this->getXlsxFileName())
if (!file_exists($this->getTimestampFileName($year)) ||
!file_exists($this->getCacheFileName($year)) ||
file_get_contents($this->getTimestampFileName($year)) < filemtime($this->getXlsxFileName($year))
) {
$this->rebuildCache();
$this->rebuildCache($year);
}
/** @var ArrayCollection|DeviceGroup[] $loadedCacheData */
$loadedCacheData = unserialize(file_get_contents($this->getCacheFileName()));
$loadedCacheData = unserialize(file_get_contents($this->getCacheFileName($year)));
return $loadedCacheData;
}
private function rebuildCache()
/**
* @param int $year
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
private function rebuildCache(int $year)
{
$mtime = filemtime($this->getXlsxFileName());
$parsedXlsxData = $this->parseXlsx();
file_put_contents($this->getCacheFileName(), serialize($parsedXlsxData));
file_put_contents($this->getTimestampFileName(), $mtime);
$mtime = filemtime($this->getXlsxFileName($year));
$parsedXlsxData = $this->parseXlsx($year);
file_put_contents($this->getCacheFileName($year), serialize($parsedXlsxData));
file_put_contents($this->getTimestampFileName($year), $mtime);
}
/**
* @param int $year
* @return ArrayCollection
* @throws \PHPExcel_Exception
* @throws \PHPExcel_Reader_Exception
*/
public function parseXlsx(): ArrayCollection
public function parseXlsx(int $year): ArrayCollection
{
$objPHPExcel = \PHPExcel_IOFactory::load($this->getXlsxFileName());
$objPHPExcel = \PHPExcel_IOFactory::load($this->getXlsxFileName($year));
$sheet = $objPHPExcel->getSheetByName(self::XLSX_SHEET_NAME);
$totalRows = $sheet->getHighestRow();
$monthColumns = $this->year == 2018
$monthColumns = $year == 2018
? range(43, 58)
: range(11, 58);
$rowCursor = 7;
@@ -146,11 +146,11 @@ class XlsxParserService
$weekDataCell = $sheet->getCellByColumnAndRow($column, $rowCursor);
if ($weekDataCell->getValue() != "") {
$month = floor(($column - 11) / 4 + 1);
$firstDayOfFirstWeek = $this->getFirstWeekOfMonth($month);
$firstDayOfFirstWeek = $this->getFirstWeekOfMonth($year, $month);
$week = ($column - 11) % 4 + 1;
$task = new DeviceMaintenanceTask($device);
$task->setYear($this->year)
$task->setYear($year)
->setMonth($month)
->setWeek($week)
->setShouldStartAt($firstDayOfFirstWeek->add(
@@ -183,12 +183,13 @@ class XlsxParserService
}
/**
* @param int $year
* @param int $month
* @return \DateTime
*/
private function getFirstWeekOfMonth(int $month): \DateTime
private function getFirstWeekOfMonth(int $year, int $month): \DateTime
{
$firstDayOfMonth = mktime(0, 0, 0, $month, 1, $this->year);
$firstDayOfMonth = mktime(0, 0, 0, $month, 1, $year);
$weekDayOfFirst = date("N", $firstDayOfMonth);
if ($weekDayOfFirst == 2) {
@@ -203,24 +204,24 @@ class XlsxParserService
return new \DateTime(sprintf(
"%s-%s-%s",
$this->year,
$year,
$month,
$firstWeekMonday
));
}
private function getCacheFileName(): string
private function getCacheFileName(int $year): string
{
return sprintf(self::XLSX_CACHE_FILE, $this->year);
return sprintf(self::XLSX_CACHE_FILE, $year);
}
private function getTimestampFileName(): string
private function getTimestampFileName(int $year): string
{
return sprintf(self::XLSX_TIMESTAMP, $this->year);
return sprintf(self::XLSX_TIMESTAMP, $year);
}
private function getXlsxFileName(): string
private function getXlsxFileName(int $year): string
{
return sprintf(self::XLSX_FILE_NAME, $this->year);
return sprintf(self::XLSX_FILE_NAME, $year);
}
}