lib/composer/BartBundle/src/VisualMedia/ComponentBundle/Element/widgets/ComponentsComponent.php line 33

Open in your IDE?
  1. <?php
  2. namespace VisualMedia\ComponentBundle\Element\widgets;
  4. use VisualMedia\ComponentBundle\Element\Component;
  5. use VisualMedia\PageBundle\Entity\BasePage;
  6. use VisualMedia\BartBundle\Element\backend\layout\ButtonElement;
  7. use VisualMedia\ComponentBundle\Element\widgets\page\RowComponent;
  8. use VisualMedia\ComponentBundle\Element\widgets\page\ColumnComponent;
  9. use VisualMedia\BartBundle\Entity\RootEntity;
  10. use VisualMedia\ComponentBundle\Element\Element;
  11. use VisualMedia\ComponentBundle\Model\ComponentEntityModel;
  12. use VisualMedia\ComponentBundle\Element\WidgetHolder;
  13. use VisualMedia\ComponentBundle\Element\WidgetComponent;
  14. use VisualMedia\ComponentBundle\Element\widgets\page\GlobalComponent;
  15. use VisualMedia\BartBundle\Controller\RootController;
  16. use VisualMedia\ComponentBundle\Element\components\ui\FlashMessageElement;
  17. use VisualMedia\ComponentBundle\Element\components\backend\AdminToolbarElement;
  19. class ComponentsComponent extends Component{
  20.     public $entity = false;
  21.     protected $components = array();
  22.     protected static $widgets = false;
  23.     public $componentType = "group";
  24.     public $added = [];
  25.     public $componentField = "components";
  26.     public $message = false;
  27.     public $admintoolbar = false;
  28.     public $modus = "client";
  29.     public $hasChanges = false;
  30.     public static $page = false;
  32.     public function initialize(){
  33.         if(RootController::isPermitted('ROLE_SUPER_ADMIN')){
  34.             $this->modus = RootController::getSession()->get("edit_components_modus") ?? "super_admin";
  35.         }
  37.     }
  39.     public function setPage($entity){
  40.         if(get_class($entity)== BasePage::class){
  41.             static::$page = $entity;
  42.         }
  43.         else{
  44.             static::$page = false;
  45.         }
  46.     }
  48.     public static function createComponents($entity, $componentField = false){
  49.         
  51.         //$entity->components = str_replace("BartPageBundle","ComponentBundle",$entity->components);
  54.         $component = new ComponentsComponent();
  55.         $component->setPage($entity);
  56.         if($componentField) $component->componentField = $componentField;
  58.         if(strpos(get_class($entity),"BasePage")>0){
  59.             $component->componentType = "page";
  60.         }
  62.         $component->id = "components_".$entity->id;
  63.         $component->object = $entity;
  64.         $component->entity = $entity;
  65.         $components = [];
  67.         if($entity->{$component->componentField}){
  68.             $components = json_decode($entity->{$component->componentField},true);
  69.             $components = Element::fromArray($components);
  70.             if(!is_array($components)) $components = [$components];
  71.             //dd($components);
  72.             $component->elements = $components;
  73.         }
  74.         else{
  75.             //$component->fillDummy();
  76.             //$entity->{$component->componentField} = json_encode($component->elements);
  77.             //$em = RootEntity::$doctrine->getManager();
  78.             //$em->persist($entity);
  79.             //$em->flush();
  80.             
  81.         }
  82.         //dd($components);
  83.         return $component;
  85.     }
  87.     public function loadEntity($entity = false){
  88.         if($entity) $this->entity = $entity;
  90.         if($this->entity->{$this->componentField}){
  91.             $components = json_decode($this->entity->{$this->componentField},true);
  92.             $components = Element::fromArray($components);
  93.             if(!is_array($components)) $components = [$components];
  94.             $this->elements = $components;
  95.         }
  97.     }
  99.     public function editElement($id){
  100.         $element = $this->getElement($id);
  101.         dd($element);
  103.     }
  105.     public function getElement($id){
  106.         if(count($this->components)==0){
  107.             $this->explodeComponents();
  108.         }
  109.         if(isset($this->components[$id])){
  110.             return $this->components[$id];
  111.         }
  112.         return false;
  113.     }
  115.     public function deleteElement($id){
  116.         foreach($this->elements as $rowkey => $row){
  117.             if($row->id == $id){
  118.                 array_splice($this->elements,$rowkey,1);
  119.                 return;
  120.             }
  121.             else{
  122.                 foreach($row->elements as $colkey => $col){
  123.                     if($col->id == $id){
  124.                         array_splice($row->elements,$colkey,1);
  125.                         return;
  126.                     }
  127.                     else{
  128.                         foreach($col->elements as $compkey => $comp){
  129.                             if($comp->id==$id){
  130.                                 array_splice($col->elements,$compkey,1);
  131.                                 return;
  132.                             }
  133.                             else{
  134.                                 foreach($comp->elements as $compkey1 => $comp1){
  135.                                     if($comp1->id==$id){
  136.                                         array_splice($comp->elements,$compkey1,1);
  137.                                         return;
  138.                                     }
  139.                                     else{
  142.                                     }
  143.                                 }
  146.                             }
  147.                         }
  148.                     }
  149.                 }
  150.             }
  151.         }
  152.     }
  154.     public static function getWidgets(){
  155.         if(!static::$widgets){
  156.             static::$widgets = ComponentEntityModel::getAllComponents(false);
  157.         }
  158.         return static::$widgets;
  159.     }
  161.     public function setComponents($components){
  162.         //dd($components);
  163.         $elements = $this->getEmptyComponents();
  164.         $this->elements = [];
  165.         foreach($components as $rowItem){
  166.             if($rowItem->id != "new"){
  167.                 //dd($this->components);
  168.                 $row = $this->components[$rowItem->id];
  169.                 foreach($rowItem->elements as $colItem){
  170.                     if($colItem->id!="new"){
  171.                         $col = $this->components[$colItem->id];
  172.                         foreach($colItem->elements as $compItem){
  173.                             if($compItem->id!="new"){
  174.                                 $comp = $this->components[$compItem->id];
  175.                                 $col->elements[] = $comp;
  176.                             }
  177.                             else{
  178.                                 $this->addNew($compItem, $col);
  179.                             }
  180.                         }
  181.                         $row->elements[] = $col;
  182.                     }
  183.                     else{
  184.                         $this->addNew($colItem, $row);
  185.                     }
  186.                 }
  187.                 $this->elements[] = $row;
  188.             }
  189.             else{
  190.                 $this->addNew($rowItem, $this);
  191.             }
  192.         }
  193.         return $this->elements;
  194.     }
  196.     public function addComponents($components, $elements = false, $item = false){
  198.         $added = [];
  199.         $root = false;
  200.         if(!$item){
  201.             $item = $this;
  202.             $root = true;
  203.         }
  204.         if(!$elements){
  205.             $elements = $this->getEmptyComponents();
  206.             $this->elements = [];
  207.         }
  209.         foreach($components as $comp){
  211.             if($comp->id!="new"){
  212.                 //dd($components,$this->components);
  213.                 if(!isset($this->components[$comp->id])){
  214.                     //dd($comp->id, $comp);
  215.                 }
  216.                 $component = $this->components[$comp->id];
  217.                 $this->addComponents($comp->elements,$elements,$component);
  218.                 $item->elements[] = $component;
  220.             }
  221.             else{
  222.                 $adding = $this->addNew($comp,$item);
  223.                 $added[] = $adding->id;
  225.             }
  226.         }
  227.         if($root){
  228.             return $this->elements;
  229.         }
  230.     }
  232.     public function addNew($element, $parent = false){
  233.         $widget = static::getWidgets()[$element->type];
  234.         //dd($widget);
  235.         $cls = $widget->classname;
  237.         $el = new $cls();
  239.         if($parent){
  240.             if($element->type=="Group"){
  241.                 if(isset($parent->behaviour)){
  242.                     switch($parent->behaviour){
  243.                         case "row":
  244.                             $el->behaviour = "col";
  245.                             break;
  246.                         case "col":
  247.                             $el->behaviour = "component";
  248.                             break;
  249.                         default:
  250.                             $el->behaviour = "row";
  253.                     }
  254.                 }
  255.                 else{
  256.                     $el->behaviour = "container";
  257.                 }
  259.             }
  260.             $parent->elements[] = $el;
  261.         }
  263.         $this->fillDefault($el, $element);
  265.         $this->added[] = $el->id;
  266.         return $el;
  269.     }
  271.     public function fillDefault($element, $data = false){
  272.         switch($element->type){
  273.             case "ContainerComponent":
  274.                 $child = new RowComponent();
  275.                 $this->fillDefault($child);
  276.                 $element->elements[] = $child;
  277.                 break;
  278.             case "RowComponent":
  280.                 if($data && isset($data->data) && strpos($data->data,"_")>0){
  281.                     $cols = explode("_",$data->data);
  282.                     foreach($cols as $width){
  283.                         $child = new ColumnComponent();
  285.                         $child->setWidth($width);
  286.                         $this->fillDefault($child);
  287.                         $element->elements[] = $child;
  288.                     }
  289.                 }
  290.                 else{
  291.                     $child = new ColumnComponent();
  292.                     $this->fillDefault($child);
  293.                     $element->elements[] = $child;
  294.                 }
  296.                 break;
  298.         }
  299.     }
  301.     public function explodeComponents($element = false){
  302.         $root = false;
  303.         if($element===false){
  304.             $root = true;
  305.             $element = $this;
  306.             $this->components = [];
  307.         }
  308.         else{
  309.             $this->components[$element->id] = $element;
  310.         }
  312.         foreach($element->elements as $component){
  313.             $this->explodeComponents($component);
  314.         }
  315.         return  $this->components;
  317.     }
  319.     public function getEmptyComponents(){
  320.         $comps = $this->explodeComponents();
  321.         $result = [];
  322.         foreach($comps as $id => $comp){
  323.             $comp->elements = [];
  324.             $result[$id] = $comp;
  325.         }
  326.         return $result;
  327.     }
  329.     public function fillDummy(){
  330.         //for($i = 0;$i<1;$i++){
  331.         //    $row = new RowComponent();
  332.         //    for($j=0;$j<1;$j++){
  333.         //        $column = new ColumnComponent();
  334.         //        //$element = new Component();
  335.         //        //$column->addElement($element);
  336.         //        $row->addElement($column);
  337.         //    }
  338.         //    $this->addElement($row);
  339.         //}
  340.     }
  342.     public function manageHtml(){
  343.         //$this->getBuffer();
  344.         return $this->manageTwig();
  345.     }
  347.     public static function addToForm(&$form, &$entity, $componentsComponent = false){
  348.         $form->addFormField("tab_components","Componenten",'tab');
  349.         if($componentsComponent){
  350.             $components = $componentsComponent;
  351.         }
  352.         else{
  353.             $components = ComponentsComponent::createComponents($entity);
  354.         }
  355.         //$children = $components->getComponents();
  356.         $items = ComponentEntityModel::getAllComponents();
  357.         $holder = new WidgetHolder();
  358.         //dd($this->getModus());
  359.         //$holder->modus = $this->getModus();
  360.         $holder->addWidgets($items);
  361.         $components->widgetHolder = $holder;
  362.         $html = $components->manageTwig();
  363.         $form->addFormField("components_row","Componenten","htmlrow", ["value" => $html]);
  365.     }
  367.     public function process(){
  368.         if(isset($_POST['components_action'])){
  369.             $action = $_POST['components_action'];
  371.             if($action=="drop"){
  373.                 $components = json_decode($_POST['components']);
  374.                 $this->addComponents($components);
  375.                 //dd($this);
  376.             }
  377.             else if($action=="delete"){
  378.                 $this->deleteElement($_POST['component']);
  379.             }
  380.             else if($action=="save_data"){
  382.                 $component = $this->findElement($_POST['components_id']);
  384.                 if($component->type=="GlobalComponent" && isset($_POST['global_id']) && $_POST['global_id']=="dissolve"){
  385.                     $data = GlobalComponent::getContents($component->global_id);
  386.                     $data->id = uniqid();
  387.                     $this->replaceElement($data,$component);
  388.                 }
  389.                 else{
  390.                     $ignore = ["components_"];
  391.                     foreach($_POST as $key => $value){
  392.                         $ignoreMe = false;
  393.                         foreach($ignore as $not){
  394.                             if(substr($key,0,strlen($not))===$not)$ignoreMe = true;
  395.                         }
  396.                         if(!$ignoreMe && $key){
  397.                             //dump($key, $value, $component, $_POST);
  398.                             $component->$key = $value;
  399.                         }
  400.                     }
  401.                 }
  402.                 $edited = $this->findElement($_POST['components_id']);
  403.             }
  404.             else if($action=="edit_element"){
  406.                 $component = $this->findElement($_POST['id']);
  408.                 if($component && isset($_POST['field']) && isset($_POST['value'])){
  409.                     $component->{$_POST['field']} = $_POST['value'];
  410.                 }
  411.                 //$this->replaceElement($component);
  412.                 $edited = $this->findElement($_POST['id']);
  413.                 //dd($edited);
  414.             }
  415.             else if($action=="config_component"){
  416.                 $component = $this->findElement($_POST['components_id']);
  417.                 //dd($_POST, $component);
  418.                 if($_POST['template_name']){
  419.                     //create as static template
  420.                     $template = GlobalComponent::findGlobalComponentByName($_POST['template_name'],true);
  421.                     $template->setComponent($component);
  422.                     //dd($template->getComponent());
  423.                     $template->saveToDatabase();
  424.                     $this->replaceElement($template,$component);
  425.                     //dd($template);
  427.                 }
  428.                 else if(substr($_POST['className'],1)!=$component->className){
  429.                     $component = $component->changeType($_POST['className']);
  430.                     $this->replaceElement($component);
  431.                 }
  432.             }
  433.             $this->entity->components = json_encode($this->elements);
  434.             //dd($this->entity);
  435.             $this->setBuffer();
  437.         }
  439.     }
  441.     public function manageTwig(){
  443.         $this->admintoolbar = new AdminToolbarElement(["componentsComponent" => $this]);
  444.         $this->getBuffer();
  445.         //dd($this->admintoolbar);
  447.         //dd($this);
  448.         return parent::manageTwig();
  450.     }
  452.     public function setModus(){
  454.     }
  456.     public function getBuffer(){
  457.         //return;
  458.         $buffer = ComponentBuffer::get($this->entity);
  460.         if($buffer){
  461.             if($this->entity->components !== $buffer->componentString || $this->hasChanges){
  462.                 $this->hasChanges = true;
  463.                 if($this->admintoolbar){
  464.                     $this->admintoolbar->addButton("?action=Origineel herstellen","Origineel herstellen",'','a',["secondaryClass" => "btn-delete"]);
  465.                     $this->admintoolbar->message = "Er zijn onopgeslagen wijzigingen";
  466.                     $this->admintoolbar->classes[] = "alert alert-danger";
  467.                 }
  468.                 $this->entity->components = $buffer->componentString;
  469.                 $this->loadEntity();
  470.             }
  471.         }
  472.         else{
  473.             ComponentBuffer::set($this->entity);
  474.         }
  475.     }
  477.     public function setBuffer(){
  478.         ComponentBuffer::set($this->entity);
  479.     }
  481.     public function saveBuffer($manager = null){
  482.         if(isset($this->entity) && isset($this->entity->id) && $this->entity->id>0){
  483.             if(!$manager){
  484.                 $manager = RootEntity::$doctrine->getManagerForClass(get_class($this->entity));
  485.             }
  486.             $this->getBuffer();
  487.             $manager->persist($this->entity);
  488.             $this->setBuffer();
  489.             $manager->flush();
  490.         }
  492.     }
  494.     public static function processPost(&$entity, $componentsComponent = false, $manager = false){
  495.         //dd(":p");
  496.         if(isset($_POST['components_action'])){
  497.             $action = $_POST['components_action'];
  498.             if($componentsComponent){
  499.                 $pc = $componentsComponent;
  500.             }
  501.             else{
  502.                 $pc = static::createComponents($entity);
  503.             }
  505.             if($action=="drop"){
  506.                 $components = json_decode($_POST['components']);
  507.                 //dd($components);
  508.                 $pc->addComponents($components);
  510.             }
  511.             else if($action=="delete"){
  512.                 $pc->deleteElement($_POST['component']);
  513.             }
  514.             else if($action=="save_data"){
  515.                 $component = $pc->findElement($_POST['components_id']);
  516.                 if($component->type=="GlobalComponent" && isset($_POST['global_id']) && $_POST['global_id']=="dissolve"){
  517.                     $data = GlobalComponent::getContents($component->global_id);
  518.                     $data->id = uniqid();
  519.                     $pc->replaceElement($data,$component);
  520.                 }
  521.                 else{
  522.                     $ignore = ["components_"];
  523.                     foreach($_POST as $key => $value){
  524.                         $ignoreMe = false;
  525.                         foreach($ignore as $not){
  526.                             if(substr($key,0,strlen($not))===$not)$ignoreMe = true;
  527.                         }
  528.                         if(!$ignoreMe && $key){
  529.                             //dump($key, $value, $component, $_POST);
  530.                             $component->$key = $value;
  531.                         }
  532.                     }
  533.                 }
  534.                 $edited = $pc->findElement($_POST['components_id']);
  535.             }
  536.             else if($action=="config_component"){
  537.                 $component = $pc->findElement($_POST['components_id']);
  538.                 if($_POST['template_name']){
  539.                     //create as static template
  540.                     $template = GlobalComponent::findGlobalComponentByName($_POST['template_name'],true);
  541.                     $template->setComponent($component);
  542.                     $template->saveToDatabase();
  543.                     $pc->replaceElement($template,$component);
  545.                 }
  546.                 else if(substr($_POST['className'],1)!=$component->className){
  547.                     $component = $component->changeType($_POST['className']);
  548.                     $pc->replaceElement($component);
  549.                 }
  550.             }
  551.             //dd($entity);
  552.             $entity->components = json_encode($pc->elements);
  553.             if(!$manager){
  554.                 $manager = RootEntity::$doctrine->getManager();
  555.             }
  556.             $manager->persist($entity);
  557.             $manager->getUnitOfWork()->scheduleForUpdate($entity);
  558.             $manager->flush();
  559.             return true;
  560.         }
  561.         return false;
  562.     }
  564. }
  567. class ComponentBuffer{
  568.     public $entityName;
  569.     public $entityId;
  570.     public $componentString;
  572.     public function __construct($entity, $componentField = "components"){
  573.         $this->entityName = get_class($entity);
  574.         $this->entityId = $entity->id;
  575.         $this->componentString = $entity->{$componentField};
  576.     }
  578.     public static function set($entity){
  579.         $item = new ComponentBuffer($entity);
  581.         RootController::$requestStack->getSession()->set("edit_components", json_encode($item));
  582.         return $item;
  584.     }
  586.     public static function get($entity){
  587.         $item = new ComponentBuffer($entity);
  588.         $buffer = RootController::$requestStack->getSession()->get("edit_components");
  589.         $buffer = json_decode($buffer,true);
  590.         if(isset($buffer['entityId']) && $buffer['entityId']==$entity->id && isset($buffer['entityName']) && $buffer['entityName']===get_class($entity)){
  591.             $item->componentString = $buffer['componentString'];
  592.             return $item;
  593.         }
  594.         //dump($buffer);
  595.         return false;
  597.     }
  599. }
  601. ?>