vendor\project-biz\database-bundle\src\Database\GenericRepositoryOptions.php line 61

Open in your IDE?
  1. <?php
  2. namespace ProjectBiz\DatabaseBundle\Database;
  3. /**
  4.  * The GenericRepositoryOptions class is responsible for the auto-configuration of
  5.  * a GenericRepository. It checks which special tables are present in a table
  6.  * and builds the corresponding configuration.
  7.  */
  8. class GenericRepositoryOptions
  9. {
  10.     // Magic columns
  11.     const cCreatedAtColumnName '_initialized_Date';
  12.     const cCreatedByColumnName '_initialized_LINK_User_ID';
  13.     const cModifiedAtColumnName '_Last_Change';
  14.     const cModifiedByColumnName '_Last_LINK_User_ID';
  15.     const cVersionColumnName '_VersionID';
  16.     const cReleaseColumnName '_[a-zA-Z]+_ReleaseID$';
  17.     const cReleaseColumnLinkName '\w+LINK_\w+_ReleaseID$';
  18.     const cAncestorColumnName '_LINK_Ancestor_ID';
  19.     const cLogColumnName '_Log';
  20.     const cQInfoColumnName '_QInfo';
  21.     const cDeletedColumnName '_Deleted';
  22.     const cArchivedColumnName '_Archived';
  23.     const cLockedAtColumnName '_Lock_Date';
  24.     const cLockedByColumnName '_Lock_LINK_User_ID';
  25.     const cPasswordColumnName '_Password';
  26.     const cManSortColumnName '_manSort';
  27.     const cChooseProjectlist '_LINK_ChooseProjectlist_ID';
  28.     const cPermissions '_Permissions';
  29.     const cReadRecordRights '_Read_Record_Rights';
  30.     const cWriteRecordRights '_Write_Record_Rights';
  31.     const cOwner '_Owner_Link_User_ID';
  32.     // Feature Flags
  33.     protected $tableHelper;
  34.     protected $options;
  35.     private $useModificationTimestamp false;
  36.     private $useCreationTimestamp false;
  37.     private $useVersioning false;
  38.     private $useRelease false;
  39.     private $useReleaseLink false;
  40.     private $useLog false;
  41.     private $useDeleted false;
  42.     private $useArchived false;
  43.     private $useQInfo false;
  44.     private $useLocking false;
  45.     private $usePassword false;
  46.     private $useManSort false;
  47.     private $useChooseProjectlist false;
  48.     private $usePermissions false;
  49.     private $useReadRecordRights false;
  50.     private $useWriteRecordRights false;
  51.     private $useOwner false;
  52.     private $systemColumns = [];
  53.     private $autoColumns = []; // Automatically computed columns, Ignored when comparing objects for equality
  54.     public function __construct(TableInfoInterface $tableInfo, array $options = [])
  55.     {
  56.         $this->tableInfo $tableInfo;
  57.         $this->options   $this->buildOptions($options);
  58.         if (isset($this->options['system_columns'])) {
  59.             $this->systemColumns array_unique(array_merge($this->systemColumns$this->options['system_columns']));
  60.         }
  61.         $this->systemColumns[] = $this->options['primary_key'];
  62.         // All auto-columns are system-columns
  63.         $this->systemColumns array_unique(array_merge($this->systemColumns$this->autoColumns));
  64.     }
  65.     // Query used features
  66.     protected function buildOptions($options)
  67.     {
  68.         $columns         $this->tableInfo->getColumns();
  69.         $tablename       $this->tableInfo->getTablename();
  70.         $requiredColumns = isset($options['required_columns'])?$options['required_columns']:[];
  71.         if (!isset($options['primary_key'])) {
  72.             $options['primary_key'] = $this->tableInfo->getPrimaryKey();
  73.         }
  74.         if (!isset($options['preventAutoModificationTimestamp'])) {
  75.             if (!isset($options['modified_at'])) {
  76.                 if (in_array($tablename self::cModifiedAtColumnName$columns)) {
  77.                     $options['modified_at'] = $tablename self::cModifiedAtColumnName;
  78.                 }
  79.             }
  80.             if (!isset($options['modified_by'])) {
  81.                 if (in_array($tablename self::cModifiedByColumnName$columns)) {
  82.                     $options['modified_by'] = $tablename self::cModifiedByColumnName;
  83.                 }
  84.             }
  85.             if (isset($options['modified_at']) && isset($options['modified_by'])) {
  86.                 $this->useModificationTimestamp true;
  87.                 //$this->columnsWriteMasked[] = $options['modified_at'];
  88.                 //$this->columnsWriteMasked[] = $options['modified_by'];
  89.                 $this->autoColumns[] = $options['modified_at'];
  90.                 $this->autoColumns[] = $options['modified_by'];
  91.             }
  92.         }
  93.         if (!isset($options['preventAutoCreationTimestamp'])) {
  94.             if (!isset($options['created_at'])) {
  95.                 if (in_array($tablename self::cCreatedAtColumnName$columns)) {
  96.                     $options['created_at'] = $tablename self::cCreatedAtColumnName;
  97.                 }
  98.             }
  99.             if (!isset($options['created_by'])) {
  100.                 if (in_array($tablename self::cCreatedByColumnName$columns)) {
  101.                     $options['created_by'] = $tablename self::cCreatedByColumnName;
  102.                 }
  103.             }
  104.             if (isset($options['created_at']) && isset($options['created_by'])) {
  105.                 $this->useCreationTimestamp true;
  106.                 //$this->columnsWriteMasked[] = $options['created_at'];
  107.                 //$this->columnsWriteMasked[] = $options['created_by'];
  108.                 $this->autoColumns[] = $options['created_at'];
  109.                 $this->autoColumns[] = $options['created_by'];
  110.             }
  111.         }
  112.         if (!isset($options['preventAutoVersioning'])) {
  113.             if (!isset($options['version'])) {
  114.                 if (in_array($tablename self::cVersionColumnName$columns)) {
  115.                     $options['version'] = $tablename self::cVersionColumnName;
  116.                 }
  117.             }
  118.             if (!isset($options['ancestor'])) {
  119.                 if (in_array($tablename self::cAncestorColumnName$columns)) {
  120.                     $options['ancestor'] = $tablename self::cAncestorColumnName;
  121.                 }
  122.             }
  123.             if (!isset($options['release'])) {
  124.                 /*
  125.                  * Get the name of the column with pattern *_ReleaseID
  126.                  */
  127.                 $options['release'] = preg_grep('/' $tablename self::cReleaseColumnName '/'$columns);
  128.             }
  129.             if (!isset($options['releaseLink'])) {
  130.                 /*
  131.                  * Get the name of the column with pattern *_LINK_*_ReleaseID
  132.                  */
  133.                 {
  134.                     $releaseLinks preg_grep('/' self::cReleaseColumnLinkName '/'$columns);
  135.                     if(count($releaseLinks) > 0) {
  136.                         $options['releaseLink'] = current($releaseLinks);
  137.                     }
  138.                 }
  139.             }
  140.             if (isset($options['version']) && isset($options['ancestor'])) {
  141.                $this->useVersioning false;
  142.               
  143.                if  ($tablename<>'vDocumentFile') {
  144.                   $this->useVersioning true;
  145.                   $this->autoColumns[] = $options['version'];
  146.                   $this->autoColumns[] = $options['ancestor'];
  147.                }
  148.                //var Test
  149.                 //$this->columnsWriteMasked[] = $options['version'];
  150.                 //$this->columnsWriteMasked[] = $options['ancestor'];
  151.             }
  152.             if (isset($options['release']) && count($options['release']) > 0) {
  153.                 $this->useRelease true;
  154.                 foreach ($options['release'] as $releaseColumn) {
  155.                     $this->autoColumns[] = $releaseColumn;
  156.                 }
  157.             }
  158.             if (isset($options['releaseLink'])) {
  159.                 $this->useReleaseLink true;
  160.                 $this->autoColumns[] = $options['releaseLink'];
  161.             }
  162.         }
  163.         if (!isset($options['preventAutoLog'])) {
  164.             if (!isset($options['log'])) {
  165.                 if (in_array($tablename self::cLogColumnName$columns)) {
  166.                     $options['log'] = [$tablename self::cLogColumnName];
  167.                 }
  168.             }
  169.             if (isset($options['log'])) {
  170.                 $this->useLog true;
  171.             }
  172.         }
  173.         if (!isset($options['preventAutoPassword'])) {
  174.             if (!isset($options['password'])) {
  175.                 if (in_array($tablename self::cPasswordColumnName$columns)) {
  176.                     $options['password'] = [$tablename self::cPasswordColumnName];
  177.                 }
  178.             }
  179.             if (isset($options['password'])) {
  180.                 $this->usePassword true;
  181.             }
  182.         }
  183.         if (!isset($options['preventAutoDeleted'])) {
  184.             if (!isset($options['deleted'])) {
  185.                 if (in_array($tablename self::cDeletedColumnName$columns)) {
  186.                     $options['deleted'] = $tablename self::cDeletedColumnName;
  187.                 }
  188.             }
  189.             if (isset($options['deleted'])) {
  190.                 $this->useDeleted true;
  191.                 //$this->columnsWriteMasked[] = $options['deleted'];
  192.                 $this->systemColumns[] = $options['deleted'];
  193.             }
  194.         }
  195.         if (!isset($options['preventAutoArchive'])) {
  196.             if (!isset($options['archived'])) {
  197.                 if (in_array($tablename self::cArchivedColumnName$columns)) {
  198.                     $options['archived'] = $tablename self::cArchivedColumnName;
  199.                 }
  200.             }
  201.             if (isset($options['archived'])) {
  202.                 $this->useArchived true;
  203.                 //$this->columnsWriteMasked[] = $options['deleted'];
  204.                 $this->systemColumns[] = $options['archived'];
  205.             }
  206.         }
  207.         if (!isset($options['preventAutoQInfo'])) {
  208.             if (!isset($options['qinfo'])) {
  209.                 if (in_array($tablename self::cQInfoColumnName$columns)) {
  210.                     $options['qinfo'] = $tablename self::cQInfoColumnName;
  211.                 }
  212.             }
  213.             if (isset($options['qinfo'])) {
  214.                 $this->useQInfo true;
  215.             }
  216.         }
  217.         if (!isset($options['preventAutoLocking'])) {
  218.             if (!isset($options['locked_at'])) {
  219.                 if (in_array($tablename self::cLockedAtColumnName$columns)) {
  220.                     $options['locked_at'] = $tablename self::cLockedAtColumnName;
  221.                 }
  222.             }
  223.             if (!isset($options['locked_by'])) {
  224.                 if (in_array($tablename self::cLockedByColumnName$columns)) {
  225.                     $options['locked_by'] = $tablename self::cLockedByColumnName;
  226.                 }
  227.             }
  228.             if (isset($options['locked_at']) && isset($options['locked_by'])) {
  229.                 $this->useLocking true;
  230.                 //$this->columnsWriteMasked[] = $options['locked_at'];
  231.                 //$this->columnsWriteMasked[] = $options['locked_by'];
  232.                 $this->systemColumns[] = $options['locked_at'];
  233.                 $this->systemColumns[] = $options['locked_by'];
  234.             }
  235.         }
  236.         if (!isset($options['preventManSort'])) {
  237.             if (!isset($options['man_sort'])) {
  238.                 if (in_array($tablename self::cManSortColumnName$columns)) {
  239.                     $options['man_sort'] = $tablename self::cManSortColumnName;
  240.                 }
  241.             }
  242.             if (!isset($options['man_sort_set'])) {
  243.                 $options['man_sort_set'] = [];
  244.             }
  245.             if (isset($options['man_sort'])) {
  246.                 $this->useManSort  true;
  247.                 $requiredColumns[] = $options['man_sort'];
  248.             }
  249.         }
  250.         if (!isset($options['preventChooseProjectlist'])) {
  251.             if (!isset($options['choose_projectlist'])) {
  252.                 if (in_array($tablename self::cChooseProjectlist$columns)) {
  253.                     $options['choose_projectlist'] = $tablename self::cChooseProjectlist;
  254.                 }
  255.             }
  256.             if (isset($options['choose_projectlist'])) {
  257.                 $this->useChooseProjectlist true;
  258.             }
  259.         }
  260.         if (!isset($options['preventPermissions'])) {
  261.             if (!isset($options['permissions'])) {
  262.                 if (in_array($tablename self::cPermissions$columns)) {
  263.                     $options['permissions'] = $tablename self::cPermissions;
  264.                 }
  265.             }
  266.             if (isset($options['permissions'])) {
  267.                 $this->usePermissions true;
  268.             }
  269.         }
  270.         if (!isset($options['preventReadRecordRights'])) {
  271.             if (!isset($options['read_record_rights'])) {
  272.                 if (in_array($tablename self::cReadRecordRights$columns)) {
  273.                     $options['read_record_rights'] = $tablename self::cReadRecordRights;
  274.                 }
  275.             }
  276.             if (isset($options['read_record_rights'])) {
  277.                 $this->useReadRecordRights true;
  278.               //  $this->systemColumns[] = $options['read_record_rights'];
  279.             }
  280.         }
  281.         if (!isset($options['preventWriteRecordRights'])) {
  282.             if (!isset($options['write_record_rights'])) {
  283.                 if (in_array($tablename self::cWriteRecordRights$columns)) {
  284.                     $options['write_record_rights'] = $tablename self::cWriteRecordRights;
  285.                 }
  286.             }
  287.             if (isset($options['write_record_rights'])) {
  288.                 $this->useWriteRecordRights true;
  289.               //  $this->systemColumns[] = $options['write_record_rights'];
  290.             }
  291.         }
  292.         if (!isset($options['preventOwner'])) {
  293.             if (!isset($options['owner'])) {
  294.                 if (in_array($tablename self::cOwner$columns)) {
  295.                     $options['owner'] = $tablename self::cOwner;
  296.                 }
  297.             }
  298.             if (isset($options['owner'])) {
  299.                 $this->useOwner true;
  300.             }
  301.         }
  302.         if (count($requiredColumns) > 0) {
  303.             $options['required_columns'] = $requiredColumns;
  304.         }
  305.         return $options;
  306.     }
  307.     public function useModificationTimestamp()
  308.     {
  309.         return $this->useModificationTimestamp;
  310.     }
  311.     public function useCreationTimestamp()
  312.     {
  313.         return $this->useCreationTimestamp;
  314.     }
  315.     public function useVersioning()
  316.     {
  317.         return $this->useVersioning;
  318.     }
  319.     public function useRelease()
  320.     {
  321.         return $this->useRelease;
  322.     }
  323.     public function useReleaseLink()
  324.     {
  325.         return $this->useReleaseLink;
  326.     }
  327.     public function useLog()
  328.     {
  329.         return $this->useLog;
  330.     }
  331.     public function useDeleted()
  332.     {
  333.         return $this->useDeleted;
  334.     }
  335.     public function useArchived()
  336.     {
  337.         return $this->useArchived;
  338.     }
  339.     public function useQInfo()
  340.     {
  341.         return $this->useQInfo;
  342.     }
  343.     public function useLocking()
  344.     {
  345.         return $this->useLocking;
  346.     }
  347.     public function usePassword()
  348.     {
  349.         return $this->usePassword;
  350.     }
  351.     public function useManSort()
  352.     {
  353.         return $this->useManSort;
  354.     }
  355.     public function useChooseProjectList()
  356.     {
  357.         return $this->useChooseProjectlist;
  358.     }
  359.     public function usePermissions()
  360.     {
  361.         return $this->usePermissions;
  362.     }
  363.     public function useReadRecordRights()
  364.     {
  365.         return $this->useReadRecordRights;
  366.     }
  367.     public function useWriteRecordRights()
  368.     {
  369.         return $this->useWriteRecordRights;
  370.     }
  371.     public function useOwner()
  372.     {
  373.         return $this->useOwner;
  374.     }
  375.     public function getVersionColumn()
  376.     {
  377.         return $this->options['version'];
  378.     }
  379.     public function getAncestorColumn()
  380.     {
  381.         return $this->options['ancestor'];
  382.     }
  383.     public function getReleaseColumns()
  384.     {
  385.         return $this->options['release'];
  386.     }
  387.     public function getReleaseLinkColumn()
  388.     {
  389.         return $this->options['releaseLink'];
  390.     }
  391.     public function getModifiedAtColumn()
  392.     {
  393.         return $this->options['modified_at'];
  394.     }
  395.     public function getModifiedByColumn()
  396.     {
  397.         return $this->options['modified_by'];
  398.     }
  399.     public function getCreatedAtColumn()
  400.     {
  401.         return $this->options['created_at'];
  402.     }
  403.     public function getCreatedByColumn()
  404.     {
  405.         return $this->options['created_by'];
  406.     }
  407.     public function getDeletedColumn()
  408.     {
  409.         return $this->options['deleted'];
  410.     }
  411.     public function getArchivedColumn()
  412.     {
  413.         return $this->options['archived'];
  414.     }
  415.     public function getQInfoColumn()
  416.     {
  417.         return $this->options['qinfo'];
  418.     }
  419.     public function getLockedByColumn()
  420.     {
  421.         return $this->options['locked_by'];
  422.     }
  423.     public function getLockedAtColumn()
  424.     {
  425.         return $this->options['locked_at'];
  426.     }
  427.     public function getManSortColumn()
  428.     {
  429.         return $this->options['man_sort'];
  430.     }
  431.     public function getManSortSetColumns()
  432.     {
  433.         return $this->options['man_sort_set'];
  434.     }
  435.     public function getChooseProjectlistColumn()
  436.     {
  437.         return $this->options['choose_projectlist'];
  438.     }
  439.     public function getPermissionsColumn()
  440.     {
  441.         return $this->options['permissions'];
  442.     }
  443.     public function getReadRecordRightsColumn()
  444.     {
  445.         return $this->options['read_record_rights'];
  446.     }
  447.     public function getWriteRecordRightsColumn()
  448.     {
  449.         return $this->options['write_record_rights'];
  450.     }
  451.     public function getOwnerColumn()
  452.     {
  453.         return $this->options['owner'];
  454.     }
  455.     public function hasLogHeader($index)
  456.     {
  457.         return isset($this->options['log-headers']) && (count($this->options['log-headers']) > $index);
  458.     }
  459.     /**
  460.      * @param $index
  461.      *
  462.      * @return \ProjectBiz\PortalBundle\Service\LogHeaderInterface
  463.      */
  464.     public function getLogHeader($index)
  465.     {
  466.         return $this->options['log-headers'][$index];
  467.     }
  468.     public function isLogColumn($column)
  469.     {
  470.         return in_array($column$this->getLogColumns());
  471.     }
  472.     public function getLogColumns()
  473.     {
  474.         return $this->options['log'];
  475.     }
  476.     public function isPasswordColumn($column)
  477.     {
  478.         return in_array($column$this->getPasswordColumns());
  479.     }
  480.     public function getPasswordColumns()
  481.     {
  482.         return $this->options['password'];
  483.     }
  484.     public function getOption($name)
  485.     {
  486.         return isset($this->options[$name])?$this->options[$name]:null;
  487.     }
  488.     public function getSystemColumns()
  489.     {
  490.         return $this->systemColumns;
  491.     }
  492.     public function getAutoColumns()
  493.     {
  494.         return $this->autoColumns;
  495.     }
  496.     public function isSystemColumn($column)
  497.     {
  498.         return in_array($column$this->systemColumns);
  499.     }
  500.     public function isAutoColumn($column)
  501.     {
  502.         return in_array($column$this->autoColumns);
  503.     }
  504. }