Pimcore is maybe one of the most structured and flexible content management system(CMS) currently existing out there on the vast amount of Opensource CMS platforms. With Pimcore you will be able to build every type of website you need to without the use of any additional modules to the base setup of the platform. This makes it the most dedicated and most security reliable platform you can find on the market these days.

Considering its purpose, it is often compared to platforms like WordPress, Magento or Shopify. Having familiarity with WordPress, I tried to compare them to get a better understanding of the Pimcore platform itself.

It resulted in a conclusion that, unlike WordPress, where you can build a basic site without a development notice, Pimcore is not an “out-of-the-box” solution. It is rather a platform, built for developers, to enable them a rapid application development by providing them a set of tools for building standard features of one CMS, DAM, PIM and Commerce solution.

For example, when creating an e-commerce system, usually you would build a data store to hold information about your products, you would provide an API on top of that, and, to allow managing the data, you would build an administration UI for the users.Well, software like Pimcore will already have that functionality provided for you (and much more) so you can focus on building other custom features of your application.

ANY data management

Pimcore stands out as a platform that can manage any digital data. Before stepping into the real examples, it’s important to know about the three main parts of the digital content you manage with Pimcore: Documents, Assets, and Objects.

Documents

In simple words, documents represent pages. Following the well-known MVC pattern, each document can be associated with the desired controller, action, and template.

Assets

The purpose of the assets is quite self-explanatory. They store digital files, such as images, videos, pdfs, and others, with their corresponding metadata.

Objects

Objects allow management of the structured data, such as products, categories, customers, blog posts, etc. With the familiarity of object-orientated programming, the concept of objects should be relatively easy to understand.Having a basic idea of the Pimcore platform, the next step was to try it out in practice.

Installing Pimcore manually

Pimcore is one of the best Content Management Systems(CMS) currently available under Opensource licenses. If you have chosen the application and you are wondering how to install it, in this tutorial we will cover the basic manual installation procedure in few easy to follow steps.

Examining the directory structure

After the successful installation, we have a new project generated. First thing I wanted to check was the directory structure to be able to know how to navigate through the code. As Pimcore is based on a Symfony framework, it follows the best practices of the Symfony directory structure. Here’s the summary of the quick project structure overview:

/app/ – contains configuration files shared templates and translations. Here you can also find the main entry point of the Symfony application configuration which is the AppKernel class.

/bin/ – is the place for the executable files (e.g. /bin/console) where you can also store your own custom scripts.

/src/ – is where you will spend most of your time as this the place for your own PHP code (controllers, services, models, event listeners, etc.)

/var/ – contains private generated files (symfony cache, logs, versions, etc.). For example, when you create a data object class through the administration (which we’ll be shown later in the post), the Pimcore will generate the code for the class with getters and setters under the /var/classes folder.

/vendor/ – stores 3rdparty dependencies (like the one installed by the composer).

/web/ – is public document root (statics, assets) on which we pointed our host.

Examining the database

The next thing I was curious about was the database structure. The initial Pimcore installation counts around 200 tables, so I wanted to understand the structure to be able to find the correct data when needed.

Also, having the database knowledge, you will be able to know what is going on under the hood. The structure contained most of the default tables created during the Pimcore installation. Here are some tables that caught my attention:

classes – stores object classes with ID and class name.

objects – is a table for all objects in the system with their metadata like id, class name, parent, etc.

assets – stores assets (e.g., images) with system metadata.

documents – table for documents, folders, links, emails, and snippets of the document area with meta and configuration data.

dependencies – stores dependencies between objects, assets, and documents.

versions – stores versions of objects, assets, and documents while the actual data is serialized and written to disk under the /var/versions directory.

users – contains backend users. Here you will find your user information set in the Pimcore installation process.

cache – table for data, stored in a serialized form, used by the default Pimcore cache. Another table used by the cache to store tags for cache entries is cache_tags.

Furthermore, there are also dynamically created tables which get created and modified during the object data model configuration. For example, when you create a new object class in the Pimcore administration, several tables are added to the database. These tables have a numerical suffix which represents the number (id) of the object class. Some of the created tables/views are:

object_(id) – is actually a database view which joins object_store_(id) and objects table.

object_store_(id) – is the primary storage table of an object class. This table contains all data without any relations or external dependencies.

object_relations_(id) – table contains data of fields with their relations to the objects, assets, or documents.

object_query_(id) – is the table which should be used for retrieving data, including inherited data.

Pimcore works with this table.

Examining cache

Pimcore caches almost everything in order to boost performance.By the default settings, Pimcore uses the table caching system by reusing the Doctrine connection to write the cache into the cache and cache_tags tables in the database.

Every Pimcore element (document, asset, object) gets cached as a serialized object and written to disk under the /var/cache directory. As stated in the documentation, you can configure your cache to use Redis or implement a custom cache pool.

Let’s build something (finally)

After going through the Pimcore basics, I was ready to step into the administration and learn more by building something real.  To be able to follow up with me, you should have Pimcore e-commerce skeleton installed. The selected skeleton already comes with an advance demo shop which showcases the main Pimcore’s e-commerce features.

To demonstrate some Pimcore features mentioned in this article, we will fit in with a simple example which should provide a solid ground for starting your Pimcore development journey.

Let’s say we have a webshop that sells products of multiple brands, the final goal of this example is to:

• display all brands in a menu dropdown
• on a brand selection, render a brand page having the brand products listed.

Let’s begin.

Creating a Brand class in Pimcore

To store Brand information, we need a data object, so the first thing we will do is to create a brand-new Brand class. In the Pimcore administration, do the following:

• Go to the Settings -> Data Objects -> Classes.
• Click “Add” and type the name of the class

A Brand class we’ll be created with an assigned unique identifier. Under the classes panel, click on the class to add some class properties. In Pimcore, the class structure is organized with panel types and other layout elements used for designing the user interface of object instances view.

To design our simple class, we will do the following:

• Right click on the General Settings -> Add Layout Component -> Panel. We’ll call it Layout as default.
• Next, right click on the Layout -> Add Data Component -> Text -> Input to add a first property “Name”.
• Our brand will have a logo, so we’ll add another property “Logo” by right clicking to Layout -> Add Data Component -> Media -> Image. A simple structure should look like this:

Now that we have the Brand class ready let’s go to the Product class to add a relation to it.In Pimcore e-commerce skeleton, the Product class already exists and, under the Base data panel, it has a “brand” property on it.

By clicking on the property, we see the following:

The type of the property is “many-to-one” relation type. If you scroll down, you will see that it allows only objects, but there is no specific object selected.

We will change that as follows:

• Select our previously created Brand class.
• To enable the property to be visible in the administration interface, uncheck the “Invisible” checkbox.
• Save the class.

Our simple class structure is now ready and we can create some brand instances.

First, we will prepare our brand logos by uploading images under the Assets so we will do the following:

• Create “brands” folder by right-clicking on the Assets -> Folder.
• Upload a brand logo by right-clicking to “brands” directory -> Upload Files. For this example, we recommend uploading the image of 250×250 pixels.

Having the logo ready, under the Data Objects section, we can create a brand instance:

• Create “brands” folder by right-clicking on the Home -> Folder.
• Create a brand by right-clicking to “brands” directory -> Add Object -> Brand and typing the name of the brand.

After the creation, we’ll do this:

• Populate the Name and logo properties (you can drag-and-drop the logo from the Assets)
• Save & Publish the brand.

Following the same principle, you can add a couple of more logos and brands, and name them as you wish. When you’re done, you should have something like this:

The last thing to do in the Object section is to assign our brands to the selected products. You can create your own products (like you created brands) or you can reuse some of the existing products that Pimcore e-commerce demo/skeleton already includes.For simplicity, we will select several unpublished products under the /products/products/apparel/running/fw12_13 directory and do the following:

• Assign them a brand by drag-and-drop the desired brand to the brand field.
• Save & Publish them.

Next, we need a document page which will render our brands and products. Under the documents section, you can do this:

Right click on the “en” document -> Add Page -> Contentpage. In the appearing pop-up, we will name it “Brands”.

Before saving and publishing we will add some document properties which will use us later in our code logic. Under the document Navigation & Properties tab do the following:

• In “Predefined Properties” dropdown, select the “Hide left navigation” option. This will add a “leftNavHide” property of the Boolean type set to true. Since we created our document as a content page, it will use the Pimcore layout which you can find under /app/Resources/views/ directory as the layout.html.php file. By default, the layout displays left side navigation, but for our page, we want to hide it, and we can do it using the leftNavHide property.
• Add a custom property “globalRootBrand” of the type object, and drag-and-drop the “brands” directory from the Object section into the value column.
• Add a custom property “templateType” and call it “brand”.
• Save & Publish the document.

The document properties should look like this:

Now we have the assets, objects, and document ready. Time has come to move to the code and fetch our brands to display them in a menu drop down.

Under /app/Resources/views/ directory, in the earlier mentioned layout.html.php file, find where the $mainNavigation is rendering and place the following code in its function parameter:

You can see that we are using previously set document properties by checking if the templateType is “brand” and if the globalRootBrand property is set.

Then, we are looping through the “brands” directory children, which are our brands, and we are dynamically creating brand pages while setting the name, identifier and the page uri.

We learned earlier that Pimcore documents follow the MVC pattern. Therefore, to render a brand document, we need to create a brand controller and a view for it. Starting from the controller, you can create a BrandController class under the /src/AppBundle/Controller directory and add the following code:

The BrandController class has detailAction which accepts the brand identifier as a parameter. In the action, we fetch a brand by its identifier and all products which have that specific brand set.

Then, we are passing products and brand to the view by setting them as properties to the $this-view object. Notice that we are using the Symfony set a dynamic route which will point to our action.

To create a view, under the /app/Resources/views directory create a “Brand” directory and a detail.html.php file in it. Following the Symfony naming convention, the detailAction of the Brand controller will expect the detail view under the Brand folder to render it. Place the following code to the view:

The view extends the layout.html.php where, among other things, the menu navigation is defined. Skipping the html and css parts, we will focus on explaining the main logic. We are rendering the brand logo by calling getThumbnail method on the asset object $logo.To render products, we are looping through the products and rendering the product.html.php template which, in Pimcore e-commerce demo/skeleton, exists under the /app/Resources/views/Shop/list/ directory.

Finally, if you navigate to your Pimcore local domain, you should see a Brands option in the menu. If you hover it, all the brands you created are listed as sub menu options. On brand selection, a brand page is rendered showing your brand logo and the associated products.

The final screen should be similar to this:

Backing up Pimcore manually

As every other web application Pimcore requires regular backup to be performed. The backup routine is something you should indeed consider as this will save your website in case of some issued due to the modifications you are implementing. The backup routine includes two steps which we will explain in details in the next few lines of this tutorial.

<dbname>s1intfco_pimc24</dbname>

<params>
      <host>localhost</host>
      <username>s1intfco_pimc24</username>
      <password>pass123</password>
      <dbname>s1intfco_pimc24</dbname>
      <port>3306</port>
</params>

-Pimcore is a powerful and robust Zend Framework based PHP content management system (WCMS) for creating and managing digital content and assets.Besides being a full-featured open-source WCMS system, pimcore is the first and premier PHP open source enterprise product information management framework (PIM) available.

Home Page

Login 

Dashboard

General Page

Documents Page

Here are some of the key features the platform include and you will be provided with:

• Web Content Management – One place to manage them all. The flexibility of the platform offers outstanding digital experience whether you are managing your pages, assets or if you are building your own custom classes and contents. You have it all conveniently structure under the incredible admin interface of the platform.
• Digital Asset management – Wondering how to track all of your images and digital media contents on your website. Wonder no more, as Pimcore have it all – central repository for all the digital assets you have and their meta-data. Whether it is an Office document, pdf file, image or even a video you will be able to upload and manage it on every page you would like to.
• Integrated multi-channel E-Commerce – Pimcore is flexible to the point when you can even create your online store using the integrated tools and features.

With Pimcore you can build your personal website in the way it will look professional using the included features and also the flexibility the code of the application provides. That is right, you can manage and manipulate the code of the application like controllers, actions views which are part of the MVC model the application fully supports.

This allows not only to build a website but to build an application which is using the structure of all the Enterprise level applications. No matter if you would like to build a blog, online shop or company website, no matter if you would like to sell a product or you would like to promote that product and represent it to the society, Pimcore has it all.

-Major Features of Pimcore

• Web-Content Management
  The biggest challenge for a content management system is to make it really easy and user-friendly for the editors to manage web content. Within pimcore almost all editing is done by using the drag-and-drop features of the rich administration interface, which is powered by well-known ExtJS framework.
• Asset Management
  Managing digital assets within pimcore is really easy, flexible and intuitive. It is a web-based, open source digital asset management module which has been designed to give your editors easy and fast access to print as well as web ready assets for website embedding or for content distribution.
• Product Information Management
  Product Information Management is the base technology for providing product information in a multi-channel and cross-media environment. Pimcore is the first and premier PHP open source enterprise product information management framework (PIM) available.
  

How to use Pimcore