/**
* @param Segment $segment
*/
public function __construct(Segment $segment)
{
$this->columns = [];
$definition = json_decode($segment->getDefinition(), true);
if (!is_null($definition)) {
$this->initialize($definition);
}
}
/**
* @param bool|string $entity
* @param array|bool $definition
* @param bool|int $identifier
*
* @return Segment
*/
public function getSegment($entity = false, $definition = false, $identifier = false)
{
$segment = new Segment();
$segment->setEntity(false === $entity ? self::TEST_ENTITY : $entity);
$segment->setDefinition(json_encode(false === $definition ? $this->getDefaultDefinition() : $definition));
$refProperty = new \ReflectionProperty(get_class($segment), 'id');
$refProperty->setAccessible(true);
$refProperty->setValue($segment, false === $identifier ? self::TEST_IDENTIFIER : $identifier);
return $segment;
}
/**
* {@inheritdoc}
*/
public function getQueryBuilder(Segment $segment)
{
$converter = new SegmentQueryConverter($this->manager, $this->virtualFieldProvider, $this->doctrine, $this->restrictionBuilder);
if ($this->virtualRelationProvider) {
$converter->setVirtualRelationProvider($this->virtualRelationProvider);
}
/** @var EntityManager $em */
$em = $this->doctrine->getManagerForClass($segment->getEntity());
$qb = $converter->convert(new RestrictionSegmentProxy($segment, $em));
return $qb;
}
public function testLifecycleCallbacks()
{
$segment = new Segment();
$segment->beforeSave();
$this->assertInstanceOf('\\DateTime', $segment->getCreatedAt());
$this->assertInstanceOf('\\DateTime', $segment->getUpdatedAt());
$this->assertEquals($segment->getCreatedAt(), $segment->getUpdatedAt());
$segment = new Segment();
$segment->doUpdate();
$this->assertEmpty($segment->getCreatedAt());
$this->assertInstanceOf('\\DateTime', $segment->getUpdatedAt());
}
/**
* Runs static repository restriction query and stores it state into snapshot entity
*
* @param Segment $segment
*
* @throws \LogicException
* @throws \Exception
*/
public function run(Segment $segment)
{
if ($segment->getType()->getName() !== SegmentType::TYPE_STATIC) {
throw new \LogicException('Only static segments could have snapshots.');
}
$this->em->getRepository('OroSegmentBundle:SegmentSnapshot')->removeBySegment($segment);
$qb = $this->dynamicSegmentQB->build($segment);
$iterator = new BufferedQueryResultIterator($qb);
$writeCount = 0;
try {
$this->em->beginTransaction();
$this->em->clear(ClassUtils::getClass($segment));
foreach ($iterator as $data) {
// only not composite identifiers are supported
$id = reset($data);
$writeCount++;
/** @var Segment $reference */
$reference = $this->em->getReference(ClassUtils::getClass($segment), $segment->getId());
$snapshot = new SegmentSnapshot($reference);
$snapshot->setEntityId($id);
$this->toWrite[] = $snapshot;
if (0 === $writeCount % $this->batchSize) {
$this->write($this->toWrite);
$this->toWrite = [];
}
}
if (count($this->toWrite) > 0) {
$this->write($this->toWrite);
}
$this->em->commit();
} catch (\Exception $exception) {
$this->em->rollback();
throw $exception;
}
$segment = $this->em->merge($segment);
$segment->setLastRun(new \DateTime('now', new \DateTimeZone('UTC')));
$this->em->persist($segment);
$this->em->flush();
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
/** @var User $user */
$user = $manager->getRepository('OroUserBundle:User')->findOneByUsername('admin');
$organization = $manager->getRepository('OroOrganizationBundle:Organization')->getFirst();
foreach ($this->data as $data) {
$entity = new Segment();
$type = $manager->getRepository('OroSegmentBundle:SegmentType')->find($data['type']);
$entity->setType($type);
$entity->setDefinition(json_encode($data['definition']));
$entity->setOrganization($organization);
$entity->setOwner($user->getBusinessUnits()->first());
$this->setEntityPropertyValues($entity, $data, ['reference', 'type', 'definition']);
$this->setReference($data['reference'], $entity);
$manager->persist($entity);
}
$manager->flush();
}
/**
* Limit segment data by segment's organization
*
* @param Segment $segment
* @param QueryBuilder $qb
*/
protected function applyOrganizationLimit(Segment $segment, QueryBuilder $qb)
{
$organizationField = $this->ownershipMetadataProvider->getMetadata($segment->getEntity())->getGlobalOwnerFieldName();
if ($organizationField) {
$qb->andWhere(sprintf('%s.%s = %s', $qb->getRootAliases()[0], $organizationField, $segment->getOrganization()->getId()));
}
}
/**
* {inheritdoc}
*/
public function build(Segment $segment)
{
$converter = new SegmentQueryConverter($this->manager, $this->virtualFieldProvider, $this->doctrine, $this->restrictionBuilder);
$qb = $converter->convert(new RestrictionSegmentProxy($segment, $this->doctrine->getManagerForClass($segment->getEntity())));
return $qb->getQuery();
}
/**
* @param Segment $segment
* @param null|string $mixin
* @return DatagridInterface
*/
protected function getSegmentDataGrid(Segment $segment, $mixin = null)
{
$dataGridName = $segment->getGridPrefix() . $segment->getId();
$resultKey = $dataGridName . $mixin;
if (empty($this->dataGrid[$resultKey])) {
$gridParameters = array(PagerInterface::PAGER_ROOT_PARAM => array(PagerInterface::DISABLED_PARAM => true));
if ($mixin) {
$gridParameters['grid-mixin'] = $mixin;
}
$this->dataGrid[$resultKey] = $this->dataGridManager->getDatagrid($dataGridName, $gridParameters);
}
return $this->dataGrid[$resultKey];
}
public function testStaticApply()
{
$staticSegmentStub = new Segment();
$staticSegmentStub->setType(new SegmentType(SegmentType::TYPE_STATIC));
$staticSegmentStub->setEntity('Oro\\Bundle\\SegmentBundle\\Tests\\Unit\\Stub\\Entity\\CmsUser');
$filterData = ['value' => $staticSegmentStub];
$em = $this->getEM();
$qb = $em->createQueryBuilder()->select(['t1.name'])->from('OroSegmentBundle:CmsUser', 't1');
$queryBuilder = new QueryBuilder($em);
$queryBuilder->select(['ts1.id'])->from('OroSegmentBundle:SegmentSnapshot', 'ts1')->andWhere('ts1.segmentId = :segment')->setParameter('segment', self::TEST_PARAM_VALUE);
$ds = new OrmFilterDatasourceAdapter($qb);
$this->staticSegmentQueryBuilder->expects(static::once())->method('getQueryBuilder')->with($staticSegmentStub)->will(static::returnValue($queryBuilder));
$this->filter->init('someName', [FilterUtility::DATA_NAME_KEY => self::TEST_FIELD_NAME]);
$this->filter->apply($ds, $filterData);
$expectedResult = ['SELECT t1.name FROM OroSegmentBundle:CmsUser t1 WHERE', 'EXISTS(SELECT ts1.id FROM OroSegmentBundle:SegmentSnapshot ts1 ' . 'WHERE ts1.segmentId = :segment AND ts1.integerEntityId = t1.id)'];
$expectedResult = implode(' ', $expectedResult);
static::assertEquals($expectedResult, $ds->getQueryBuilder()->getDQL());
$params = $ds->getQueryBuilder()->getParameters();
static::assertCount(1, $params, 'Should pass params to main query builder');
static::assertEquals(self::TEST_PARAM_VALUE, $params[0]->getValue());
}
/**
* Set this segment definition in YAML format
*
* @param string $definition
*/
public function setDefinition($definition)
{
if ($this->segment) {
$this->segment->setDefinition($definition);
}
}
/**
* @param QueryBuilder $queryBuilder
* @param Segment $segment
*
* @return string
*/
protected function getIdentityFieldWithAlias(QueryBuilder $queryBuilder, Segment $segment)
{
$tableAliases = $queryBuilder->getRootAliases();
$em = $queryBuilder->getEntityManager();
$entityMetadata = $em->getClassMetadata($segment->getEntity());
$idField = $entityMetadata->getSingleIdentifierFieldName();
if ($this->isDynamic($segment)) {
return $tableAliases[0] . '.' . $idField;
}
$idFieldType = $entityMetadata->getTypeOfField($idField);
$fieldToSelect = SegmentSnapshot::ENTITY_REF_FIELD;
if ($idFieldType == 'integer') {
$fieldToSelect = SegmentSnapshot::ENTITY_REF_INTEGER_FIELD;
}
return $tableAliases[0] . '.' . $fieldToSelect;
}
public function testStaticApply()
{
$staticSegmentStub = new Segment();
$staticSegmentStub->setType(new SegmentType(SegmentType::TYPE_STATIC));
$filterData = ['value' => $staticSegmentStub];
$subquery = 'SELECT ts1.entity_id FROM OroSegmentBundle:SegmentSnapshot ts1 WHERE ts1.segmentId = :segment';
$em = $this->getTestEntityManager();
$qb = new QueryBuilder($em);
$qb->select(['t1.name'])->from('OroSegmentBundle:CmsUser', 't1');
$ds = new OrmFilterDatasourceAdapter($qb);
$query = new Query($em);
$query->setDQL($subquery);
$query->setParameter('segment', $staticSegmentStub);
$this->staticSegmentQueryBuilder->expects($this->once())->method('build')->with($staticSegmentStub)->will($this->returnValue($query));
$this->filter->init('someName', [FilterUtility::DATA_NAME_KEY => self::TEST_FIELD_NAME]);
$this->filter->apply($ds, $filterData);
$expectedResult = ['SELECT t1.name FROM OroSegmentBundle:CmsUser t1 WHERE t1.id', 'IN(SELECT ts1.entity_id FROM OroSegmentBundle:SegmentSnapshot ts1 WHERE ts1.segmentId = :segment)'];
$expectedResult = implode(' ', $expectedResult);
$this->assertEquals($expectedResult, $ds->getQueryBuilder()->getDQL());
$params = $ds->getQueryBuilder()->getParameters();
$this->assertCount(1, $params, 'Should pass params to main query builder');
$this->assertEquals($staticSegmentStub, $params[0]->getValue());
}
public function load(ObjectManager $manager)
{
$staticType = $manager->getRepository('OroSegmentBundle:SegmentType')->find(SegmentType::TYPE_STATIC);
if (!$staticType) {
$staticType = new SegmentType(SegmentType::TYPE_STATIC);
$staticType->setLabel('Static');
$manager->persist($staticType);
}
$dynamicType = $manager->getRepository('OroSegmentBundle:SegmentType')->find(SegmentType::TYPE_DYNAMIC);
if (!$dynamicType) {
$dynamicType = new SegmentType(SegmentType::TYPE_DYNAMIC);
$dynamicType->setLabel('Dynamic');
$manager->persist($dynamicType);
}
$organisation = $manager->getRepository('OroOrganizationBundle:Organization')->getFirst();
$owner = $manager->getRepository('OroOrganizationBundle:BusinessUnit')->findOneBy(array('name' => 'Test'));
if (!$owner) {
$owner = new BusinessUnit();
$owner->setName('Test');
$owner->setOrganization($organisation);
$manager->persist($owner);
}
for ($i = 1; $i <= self::COUNT; $i++) {
$definition = array('columns' => array('func' => null, 'label' => 'label' . $i, 'name' => '', 'sorting' => ''), 'filters' => array());
$entity = new Segment();
$entity->setCreatedAt(new \DateTime('now'));
$entity->setDefinition(json_encode($definition));
$entity->setDescription('description_' . $i);
$entity->setEntity('Oro\\Bundle\\TestFrameworkBundle\\Entity\\WorkflowAwareEntity');
$entity->setLastRun(new \DateTime('now'));
$entity->setName('segment_' . $i);
$entity->setOwner($owner);
$entity->setType(rand(0, 100) % 2 ? $staticType : $dynamicType);
$entity->setUpdatedAt(new \DateTime('now'));
$entity->setOrganization($organisation);
$manager->persist($entity);
}
$manager->flush();
}
/**
* Get SELECT query builder for retrieving entity identifiers from snapshot
*
* @param Segment $segment
* @return \Doctrine\ORM\QueryBuilder
*/
public function getIdentifiersSelectQueryBuilder(Segment $segment)
{
$entityMetadata = $this->getEntityManager()->getClassMetadata($segment->getEntity());
$idField = $entityMetadata->getSingleIdentifierFieldName();
$idFieldType = $entityMetadata->getTypeOfField($idField);
if ($idFieldType == 'integer') {
$fieldToSelect = 'CAST(snp.entityId as int)';
} else {
$fieldToSelect = 'snp.entityId';
}
$qb = $this->createQueryBuilder('snp')->select($fieldToSelect)->where('snp.segment = :segment')->setParameter('segment', $segment);
return $qb;
}
/**
* @param MarketingList $marketingList
*/
protected function processSegment(MarketingList $marketingList)
{
$requestData = $this->request->get($this->form->getName());
$segment = $marketingList->getSegment();
if (!$segment) {
$segment = new Segment();
}
$segmentName = $this->translator->trans('orocrm.marketinglist.segment', ['%name%' => $marketingList->getName()]);
$segment->setName($segmentName)->setEntity($marketingList->getEntity())->setType($this->getSegmentTypeByMarketingListType($marketingList->getType()))->setDefinition($requestData['definition'])->setOwner($marketingList->getOwner()->getOwner());
$marketingList->setSegment($segment);
}
/**
* Get SELECT query builder for retrieving entity identifiers from snapshot
*
* @param Segment $segment
* @return \Doctrine\ORM\QueryBuilder
*/
public function getIdentifiersSelectQueryBuilder(Segment $segment)
{
$entityMetadata = $this->getEntityManager()->getClassMetadata($segment->getEntity());
$idField = $entityMetadata->getSingleIdentifierFieldName();
$idFieldType = $entityMetadata->getTypeOfField($idField);
$fieldToSelect = SegmentSnapshot::ENTITY_REF_FIELD;
if ($idFieldType == 'integer') {
$fieldToSelect = SegmentSnapshot::ENTITY_REF_INTEGER_FIELD;
}
$fieldToSelect = sprintf('snp.%s', $fieldToSelect);
$qb = $this->createQueryBuilder('snp')->select($fieldToSelect)->where('snp.segment = :segment')->setParameter('segment', $segment);
return $qb;
}
protected function generateSegments($count)
{
$segments = array();
for ($i = 0; $i < $count; $i++) {
$segment = new Segment();
$segment->setName('test_' . $i);
$segments[] = $segment;
}
return $segments;
}
