first commit

plugins/stCeneoPlugin/lib/model/Ceneo.php

@@ -0,0 +1,16 @@
+<?php
+
+/**
+ * Subclass for representing a row from the 'st_ceneo' table.
+ *
+ * 
+ *
+ * @package plugins.stCeneoPlugin.lib.model
+ */ 
+class Ceneo extends BaseCeneo
+{
+    public function getAdminGeneratorTitle()
+    {
+        return $this->getProduct()->getName();
+    }
+}

plugins/stCeneoPlugin/lib/model/CeneoPeer.php

@@ -0,0 +1,91 @@
+<?php
+
+class CeneoPeer extends BaseCeneoPeer {
+
+    public static function retrieveByProduct(Product $product)
+    {
+        $c = new Criteria();
+        $c->add(self::PRODUCT_ID, $product->getId());
+
+        return self::doSelectOne($c);
+    }
+
+    public static function doSelectRightJoinProduct(Criteria $c, $con = null)
+    {
+        $c = clone $c;
+
+        if ($c->getDbName() == Propel::getDefaultDB()) {
+            $c->setDbName(self::DATABASE_NAME);
+        }
+
+        self::addSelectColumns($c);
+
+        ProductPeer::addSelectColumns($c);
+
+        $c->addJoin(self::PRODUCT_ID, ProductPeer::ID, Criteria::RIGHT_JOIN);
+        $criterion = $c->getNewCriterion(self::PRODUCT_ID, null, Criteria::ISNULL);
+        $criterion->addOr($c->getNewCriterion(self::PRODUCT_ID, null, Criteria::ISNOTNULL));
+        $c->add($criterion);
+
+        $rs = self::doSelectRs($c, $con);
+
+        if (self::$hydrateMethod) {
+            return call_user_func(self::$hydrateMethod, $rs);
+        }
+
+        $results = array();
+
+        while ($rs->next()) {
+
+            $obj1 = new Ceneo();
+            $startcol = $obj1->hydrate($rs);
+
+            $obj2 = new Product();
+            $obj2->hydrate($rs, $startcol);
+            $obj2->addCeneo($obj1);
+
+            if (null === $obj1->getId()) {
+                $obj1->setId($obj2->getId());
+                $obj1->resetModified();
+            }
+
+            $results[] = self::$postHydrateMethod ? call_user_func(self::$postHydrateMethod, $obj1) : $obj1;
+        }
+
+        return $results;
+    }
+
+    public static function doCountRightJoinProduct(Criteria $c, $con = null)
+    {
+        $c = clone $c;
+        $c->clearSelectColumns()->clearOrderByColumns();
+        $c->addSelectColumn('COUNT(*)');
+        $c->addJoin(self::PRODUCT_ID, ProductPeer::ID, Criteria::RIGHT_JOIN);
+        $criterion = $c->getNewCriterion(self::PRODUCT_ID, null, Criteria::ISNULL);
+        $criterion->addOr($c->getNewCriterion(self::PRODUCT_ID, null, Criteria::ISNOTNULL));
+        $c->add($criterion);
+
+        $rs = self::doSelectRS($c);
+
+        return $rs && $rs->next() ? $rs->getInt(1) : 0;
+    }
+
+    public static function isCeneoActive($product)
+    {
+        $c = new Criteria();
+        $c->add(CeneoPeer::ACTIVE, 1);
+        $c->add(CeneoPeer::PRODUCT_ID, $product->getId());
+
+        if (CeneoPeer::doSelectOne($c)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public static function doSelectJoinProduct(Criteria $c, $con = null)
+    {
+        return parent::doSelectJoinProduct($c, $con);
+    }
+
+}

plugins/stCeneoPlugin/lib/model/map/CeneoMapBuilder.php

@@ -0,0 +1,80 @@
+<?php
+
+
+/**
+ * This class adds structure of 'st_ceneo' table to 'propel' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    plugins.stCeneoPlugin.lib.model.map
+ */
+class CeneoMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'plugins.stCeneoPlugin.lib.model.map.CeneoMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('propel');
+
+		$tMap = $this->dbMap->addTable('st_ceneo');
+		$tMap->setPhpName('Ceneo');
+
+		$tMap->setUseIdGenerator(true);
+
+		$tMap->addColumn('CREATED_AT', 'CreatedAt', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('UPDATED_AT', 'UpdatedAt', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addPrimaryKey('ID', 'Id', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addForeignKey('PRODUCT_ID', 'ProductId', 'int', CreoleTypes::INTEGER, 'st_product', 'ID', true, null);
+
+		$tMap->addColumn('ACTIVE', 'Active', 'boolean', CreoleTypes::BOOLEAN, true, null);
+
+		$tMap->addColumn('DESCRIPTION', 'Description', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('IS_BASKET', 'IsBasket', 'boolean', CreoleTypes::BOOLEAN, false, null);
+
+	} // doBuild()
+
+} // CeneoMapBuilder

plugins/stCeneoPlugin/lib/model/om/BaseCeneoPeer.php

@@ -0,0 +1,866 @@
+<?php
+
+/**
+ * Base static class for performing query and update operations on the 'st_ceneo' table.
+ *
+ * 
+ *
+ * @package    plugins.stCeneoPlugin.lib.model.om
+ */
+abstract class BaseCeneoPeer {
+
+	/** the default database name for this class */
+	const DATABASE_NAME = 'propel';
+
+	/** the table name for this class */
+	const TABLE_NAME = 'st_ceneo';
+
+	/** A class that can be returned by this peer. */
+	const CLASS_DEFAULT = 'plugins.stCeneoPlugin.lib.model.Ceneo';
+
+	/** The total number of columns. */
+	const NUM_COLUMNS = 7;
+
+	/** The number of lazy-loaded columns. */
+	const NUM_LAZY_LOAD_COLUMNS = 0;
+
+
+	/** the column name for the CREATED_AT field */
+	const CREATED_AT = 'st_ceneo.CREATED_AT';
+
+	/** the column name for the UPDATED_AT field */
+	const UPDATED_AT = 'st_ceneo.UPDATED_AT';
+
+	/** the column name for the ID field */
+	const ID = 'st_ceneo.ID';
+
+	/** the column name for the PRODUCT_ID field */
+	const PRODUCT_ID = 'st_ceneo.PRODUCT_ID';
+
+	/** the column name for the ACTIVE field */
+	const ACTIVE = 'st_ceneo.ACTIVE';
+
+	/** the column name for the DESCRIPTION field */
+	const DESCRIPTION = 'st_ceneo.DESCRIPTION';
+
+	/** the column name for the IS_BASKET field */
+	const IS_BASKET = 'st_ceneo.IS_BASKET';
+
+	/** The PHP to DB Name Mapping */
+	private static $phpNameMap = null;
+
+
+	/**
+	 * holds an array of fieldnames
+	 *
+	 * first dimension keys are the type constants
+	 * e.g. self::$fieldNames[self::TYPE_PHPNAME][0] = 'Id'
+	 */
+	private static $fieldNames = array (
+		BasePeer::TYPE_PHPNAME => array ('CreatedAt', 'UpdatedAt', 'Id', 'ProductId', 'Active', 'Description', 'IsBasket', ),
+		BasePeer::TYPE_COLNAME => array (CeneoPeer::CREATED_AT, CeneoPeer::UPDATED_AT, CeneoPeer::ID, CeneoPeer::PRODUCT_ID, CeneoPeer::ACTIVE, CeneoPeer::DESCRIPTION, CeneoPeer::IS_BASKET, ),
+		BasePeer::TYPE_FIELDNAME => array ('created_at', 'updated_at', 'id', 'product_id', 'active', 'description', 'is_basket', ),
+		BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, )
+	);
+
+	/**
+	 * holds an array of keys for quick access to the fieldnames array
+	 *
+	 * first dimension keys are the type constants
+	 * e.g. self::$fieldNames[BasePeer::TYPE_PHPNAME]['Id'] = 0
+	 */
+	private static $fieldKeys = array (
+		BasePeer::TYPE_PHPNAME => array ('CreatedAt' => 0, 'UpdatedAt' => 1, 'Id' => 2, 'ProductId' => 3, 'Active' => 4, 'Description' => 5, 'IsBasket' => 6, ),
+		BasePeer::TYPE_COLNAME => array (CeneoPeer::CREATED_AT => 0, CeneoPeer::UPDATED_AT => 1, CeneoPeer::ID => 2, CeneoPeer::PRODUCT_ID => 3, CeneoPeer::ACTIVE => 4, CeneoPeer::DESCRIPTION => 5, CeneoPeer::IS_BASKET => 6, ),
+		BasePeer::TYPE_FIELDNAME => array ('created_at' => 0, 'updated_at' => 1, 'id' => 2, 'product_id' => 3, 'active' => 4, 'description' => 5, 'is_basket' => 6, ),
+		BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, )
+	);
+
+         protected static $hydrateMethod = null;
+
+         protected static $postHydrateMethod = null;
+
+         public static function setHydrateMethod($callback)
+         {
+            self::$hydrateMethod = $callback;
+         }
+
+         public static function setPostHydrateMethod($callback)
+         {
+            self::$postHydrateMethod = $callback;
+         }
+
+	/**
+	 * @return     MapBuilder the map builder for this peer
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function getMapBuilder()
+	{
+		return BasePeer::getMapBuilder('plugins.stCeneoPlugin.lib.model.map.CeneoMapBuilder');
+	}
+	/**
+	 * Gets a map (hash) of PHP names to DB column names.
+	 *
+	 * @return     array The PHP to DB name map for this peer
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 * @deprecated Use the getFieldNames() and translateFieldName() methods instead of this.
+	 */
+	public static function getPhpNameMap()
+	{
+		if (self::$phpNameMap === null) {
+			$map = CeneoPeer::getTableMap();
+			$columns = $map->getColumns();
+			$nameMap = array();
+			foreach ($columns as $column) {
+				$nameMap[$column->getPhpName()] = $column->getColumnName();
+			}
+			self::$phpNameMap = $nameMap;
+		}
+		return self::$phpNameMap;
+	}
+	/**
+	 * Translates a fieldname to another type
+	 *
+	 * @param      string $name field name
+	 * @param      string $fromType One of the class type constants TYPE_PHPNAME,
+	 *                         TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM
+	 * @param      string $toType   One of the class type constants
+	 * @return     string translated name of the field.
+	 */
+	static public function translateFieldName($name, $fromType, $toType)
+	{
+		$toNames = self::getFieldNames($toType);
+		$key = isset(self::$fieldKeys[$fromType][$name]) ? self::$fieldKeys[$fromType][$name] : null;
+		if ($key === null) {
+			throw new PropelException("'$name' could not be found in the field names of type '$fromType'. These are: " . print_r(self::$fieldKeys[$fromType], true));
+		}
+		return $toNames[$key];
+	}
+
+	/**
+	 * Returns an array of of field names.
+	 *
+	 * @param      string $type The type of fieldnames to return:
+	 *                      One of the class type constants TYPE_PHPNAME,
+	 *                      TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM
+	 * @return     array A list of field names
+	 */
+
+	static public function getFieldNames($type = BasePeer::TYPE_PHPNAME)
+	{
+		if (!array_key_exists($type, self::$fieldNames)) {
+			throw new PropelException('Method getFieldNames() expects the parameter $type to be one of the class constants TYPE_PHPNAME, TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM. ' . $type . ' was given.');
+		}
+		return self::$fieldNames[$type];
+	}
+
+	/**
+	 * Convenience method which changes table.column to alias.column.
+	 *
+	 * Using this method you can maintain SQL abstraction while using column aliases.
+	 * <code>
+	 *		$c->addAlias("alias1", TablePeer::TABLE_NAME);
+	 *		$c->addJoin(TablePeer::alias("alias1", TablePeer::PRIMARY_KEY_COLUMN), TablePeer::PRIMARY_KEY_COLUMN);
+	 * </code>
+	 * @param      string $alias The alias for the current table.
+	 * @param      string $column The column name for current table. (i.e. CeneoPeer::COLUMN_NAME).
+	 * @return     string
+	 */
+	public static function alias($alias, $column)
+	{
+		return str_replace(CeneoPeer::TABLE_NAME.'.', $alias.'.', $column);
+	}
+
+	/**
+	 * Add all the columns needed to create a new object.
+	 *
+	 * Note: any columns that were marked with lazyLoad="true" in the
+	 * XML schema will not be added to the select list and only loaded
+	 * on demand.
+	 *
+	 * @param      criteria object containing the columns to add.
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function addSelectColumns(Criteria $criteria)
+	{
+
+		$criteria->addSelectColumn(CeneoPeer::CREATED_AT);
+
+		$criteria->addSelectColumn(CeneoPeer::UPDATED_AT);
+
+		$criteria->addSelectColumn(CeneoPeer::ID);
+
+		$criteria->addSelectColumn(CeneoPeer::PRODUCT_ID);
+
+		$criteria->addSelectColumn(CeneoPeer::ACTIVE);
+
+		$criteria->addSelectColumn(CeneoPeer::DESCRIPTION);
+
+		$criteria->addSelectColumn(CeneoPeer::IS_BASKET);
+
+
+		if (stEventDispatcher::getInstance()->getListeners('CeneoPeer.postAddSelectColumns')) {
+			stEventDispatcher::getInstance()->notify(new sfEvent($criteria, 'CeneoPeer.postAddSelectColumns'));
+		}
+	}
+
+	const COUNT = 'COUNT(st_ceneo.ID)';
+	const COUNT_DISTINCT = 'COUNT(DISTINCT st_ceneo.ID)';
+
+	/**
+	 * Returns the number of rows matching criteria.
+	 *
+	 * @param      Criteria $criteria
+	 * @param      boolean $distinct Whether to select only distinct columns (You can also set DISTINCT modifier in Criteria).
+	 * @param      Connection $con
+	 * @return     int Number of matching rows.
+	 */
+	public static function doCount(Criteria $criteria, $distinct = false, $con = null)
+	{
+		// we're going to modify criteria, so copy it first
+		$criteria = clone $criteria;
+
+		// clear out anything that might confuse the ORDER BY clause
+		$criteria->clearSelectColumns()->clearOrderByColumns();
+		if ($distinct || in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
+			$criteria->addSelectColumn(CeneoPeer::COUNT_DISTINCT);
+		} else {
+			$criteria->addSelectColumn(CeneoPeer::COUNT);
+		}
+
+		// just in case we're grouping: add those columns to the select statement
+		foreach($criteria->getGroupByColumns() as $column)
+		{
+			$criteria->addSelectColumn($column);
+		}
+
+		$rs = CeneoPeer::doSelectRS($criteria, $con);
+		if ($rs->next()) {
+			return $rs->getInt(1);
+		} else {
+			// no rows returned; we infer that means 0 matches.
+			return 0;
+		}
+	}
+	/**
+	 * Method to select one object from the DB.
+	 *
+	 * @param      Criteria $criteria object used to create the SELECT statement.
+	 * @param      Connection $con
+	 * @return     Ceneo
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function doSelectOne(Criteria $criteria, $con = null)
+	{
+		$critcopy = clone $criteria;
+		$critcopy->setLimit(1);
+		$objects = CeneoPeer::doSelect($critcopy, $con);
+		if ($objects) {
+			return $objects[0];
+		}
+		return null;
+	}
+	/**
+	 * Method to do selects.
+	 *
+	 * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
+	 * @param      Connection $con
+	 * @return     Ceneo[]
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function doSelect(Criteria $criteria, $con = null)
+	{
+		return CeneoPeer::populateObjects(CeneoPeer::doSelectRS($criteria, $con));
+	}
+	/**
+	 * Prepares the Criteria object and uses the parent doSelect()
+	 * method to get a ResultSet.
+	 *
+	 * Use this method directly if you want to just get the resultset
+	 * (instead of an array of objects).
+	 *
+	 * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
+	 * @param      Connection $con the connection to use
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 * @return     ResultSet The resultset object with numerically-indexed fields.
+	 * @see        BasePeer::doSelect()
+	 */
+	public static function doSelectRS(Criteria $criteria, $con = null)
+	{
+		if ($con === null) {
+			$con = Propel::getConnection(self::DATABASE_NAME);
+		}
+
+		if (!$criteria->getSelectColumns()) {
+			$criteria = clone $criteria;
+			CeneoPeer::addSelectColumns($criteria);
+		}
+
+		if (stEventDispatcher::getInstance()->getListeners('BasePeer.preDoSelectRs')) {
+			stEventDispatcher::getInstance()->notify(new sfEvent($criteria, 'BasePeer.preDoSelectRs'));
+		}
+
+		// Set the correct dbName
+		$criteria->setDbName(self::DATABASE_NAME);
+
+		// BasePeer returns a Creole ResultSet, set to return
+		// rows indexed numerically.
+		$rs =  BasePeer::doSelect($criteria, $con);
+
+		if (stEventDispatcher::getInstance()->getListeners('BasePeer.postDoSelectRs')) {
+			stEventDispatcher::getInstance()->notify(new sfEvent($rs, 'BasePeer.postDoSelectRs'));
+		}		
+
+		return $rs;
+	}
+	/**
+	 * The returned array will contain objects of the default type or
+	 * objects that inherit from the default.
+	 *
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function populateObjects(ResultSet $rs)
+	{
+		
+            if (self::$hydrateMethod)
+            {
+               return call_user_func(self::$hydrateMethod, $rs);
+            }
+            $results = array();
+	
+		// set the class once to avoid overhead in the loop
+		$cls = CeneoPeer::getOMClass();
+		$cls = Propel::import($cls);
+		// populate the object(s)
+		while($rs->next()) {
+		
+			$obj = new $cls();
+			$obj->hydrate($rs);
+			$results[] = self::$postHydrateMethod ? call_user_func(self::$postHydrateMethod, $obj) : $obj;
+			
+		}
+		return $results;
+	}
+
+	/**
+	 * Returns the number of rows matching criteria, joining the related Product table
+	 *
+	 * @param      Criteria $c
+	 * @param      boolean $distinct Whether to select only distinct columns (You can also set DISTINCT modifier in Criteria).
+	 * @param      Connection $con
+	 * @return     int Number of matching rows.
+	 */
+	public static function doCountJoinProduct(Criteria $criteria, $distinct = false, $con = null)
+	{
+		// we're going to modify criteria, so copy it first
+		$criteria = clone $criteria;
+
+		// clear out anything that might confuse the ORDER BY clause
+		$criteria->clearSelectColumns()->clearOrderByColumns();
+		if ($distinct || in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
+			$criteria->addSelectColumn(CeneoPeer::COUNT_DISTINCT);
+		} else {
+			$criteria->addSelectColumn(CeneoPeer::COUNT);
+		}
+
+		// just in case we're grouping: add those columns to the select statement
+		foreach($criteria->getGroupByColumns() as $column)
+		{
+			$criteria->addSelectColumn($column);
+		}
+
+		$criteria->addJoin(CeneoPeer::PRODUCT_ID, ProductPeer::ID);
+
+		$rs = CeneoPeer::doSelectRS($criteria, $con);
+		if ($rs->next()) {
+			return $rs->getInt(1);
+		} else {
+			// no rows returned; we infer that means 0 matches.
+			return 0;
+		}
+	}
+
+
+	/**
+	 * Selects a collection of Ceneo objects pre-filled with their Product objects.
+	 *
+	 * @return     Ceneo[] Array of Ceneo objects.
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function doSelectJoinProduct(Criteria $c, $con = null)
+	{
+		$c = clone $c;
+
+		// Set the correct dbName if it has not been overridden
+		if ($c->getDbName() == Propel::getDefaultDB()) {
+			$c->setDbName(self::DATABASE_NAME);
+		}
+
+		CeneoPeer::addSelectColumns($c);
+
+		ProductPeer::addSelectColumns($c);
+
+		$c->addJoin(CeneoPeer::PRODUCT_ID, ProductPeer::ID);
+		$rs = CeneoPeer::doSelectRs($c, $con);
+                   
+                if (self::$hydrateMethod)
+                {
+                   return call_user_func(self::$hydrateMethod, $rs);
+                }                   
+
+		$results = array();
+
+		while($rs->next()) {
+
+			$obj1 = new Ceneo();
+			$startcol = $obj1->hydrate($rs);
+                        if ($obj1->getProductId())
+                        {
+
+			   $obj2 = new Product();
+			   $obj2->hydrate($rs, $startcol);
+                           $obj2->addCeneo($obj1);
+                        }
+			$results[] = self::$postHydrateMethod ? call_user_func(self::$postHydrateMethod, $obj1) : $obj1;;
+		}
+		return $results;
+	}
+
+
+	/**
+	 * Returns the number of rows matching criteria, joining all related tables
+	 *
+	 * @param      Criteria $c
+	 * @param      boolean $distinct Whether to select only distinct columns (You can also set DISTINCT modifier in Criteria).
+	 * @param      Connection $con
+	 * @return     int Number of matching rows.
+	 */
+	public static function doCountJoinAll(Criteria $criteria, $distinct = false, $con = null)
+	{
+		$criteria = clone $criteria;
+
+		// clear out anything that might confuse the ORDER BY clause
+		$criteria->clearSelectColumns()->clearOrderByColumns();
+		if ($distinct || in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
+			$criteria->addSelectColumn(CeneoPeer::COUNT_DISTINCT);
+		} else {
+			$criteria->addSelectColumn(CeneoPeer::COUNT);
+		}
+
+		// just in case we're grouping: add those columns to the select statement
+		foreach($criteria->getGroupByColumns() as $column)
+		{
+			$criteria->addSelectColumn($column);
+		}
+
+		$criteria->addJoin(CeneoPeer::PRODUCT_ID, ProductPeer::ID);
+
+		$rs = CeneoPeer::doSelectRS($criteria, $con);
+		if ($rs->next()) {
+			return $rs->getInt(1);
+		} else {
+			// no rows returned; we infer that means 0 matches.
+			return 0;
+		}
+	}
+
+
+	/**
+	 * Selects a collection of Ceneo objects pre-filled with all related objects.
+	 *
+	 * @return     Ceneo[]
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function doSelectJoinAll(Criteria $c, $con = null)
+	{
+		$c = clone $c;
+
+		// Set the correct dbName if it has not been overridden
+		if ($c->getDbName() == Propel::getDefaultDB()) {
+			$c->setDbName(self::DATABASE_NAME);
+		}
+
+		CeneoPeer::addSelectColumns($c);
+		$startcol2 = (CeneoPeer::NUM_COLUMNS - CeneoPeer::NUM_LAZY_LOAD_COLUMNS) + 1;
+
+		ProductPeer::addSelectColumns($c);
+		$startcol3 = $startcol2 + ProductPeer::NUM_COLUMNS;
+
+		$c->addJoin(CeneoPeer::PRODUCT_ID, ProductPeer::ID);
+
+		$rs = BasePeer::doSelect($c, $con);
+		
+            if (self::$hydrateMethod)
+            {
+               return call_user_func(self::$hydrateMethod, $rs);
+            }
+            $results = array();
+
+		while($rs->next()) {
+
+			$omClass = CeneoPeer::getOMClass();
+
+
+			$cls = Propel::import($omClass);
+			$obj1 = new $cls();
+			$obj1->hydrate($rs);
+
+
+				// Add objects for joined Product rows
+	
+			$omClass = ProductPeer::getOMClass();
+
+
+			$cls = Propel::import($omClass);
+			$obj2 = new $cls();
+			$obj2->hydrate($rs, $startcol2);
+
+			$newObject = true;
+			for ($j=0, $resCount=count($results); $j < $resCount; $j++) {
+				$temp_obj1 = $results[$j];
+				$temp_obj2 = $temp_obj1->getProduct(); // CHECKME
+				if (null !== $temp_obj2 && $temp_obj2->getPrimaryKey() === $obj2->getPrimaryKey()) {
+					$newObject = false;
+					$temp_obj2->addCeneo($obj1); // CHECKME
+					break;
+				}
+			}
+
+			if ($newObject) {
+				$obj2->initCeneos();
+				$obj2->addCeneo($obj1);
+			}
+
+			$results[] = self::$postHydrateMethod ? call_user_func(self::$postHydrateMethod, $obj1) : $obj1;
+		}
+		return $results;
+	}
+
+	/**
+	 * Returns the TableMap related to this peer.
+	 * This method is not needed for general use but a specific application could have a need.
+	 * @return     TableMap
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function getTableMap()
+	{
+		return Propel::getDatabaseMap(self::DATABASE_NAME)->getTable(self::TABLE_NAME);
+	}
+
+	/**
+	 * The class that the Peer will make instances of.
+	 *
+	 * This uses a dot-path notation which is tranalted into a path
+	 * relative to a location on the PHP include_path.
+	 * (e.g. path.to.MyClass -> 'path/to/MyClass.php')
+	 *
+	 * @return     string path.to.ClassName
+	 */
+	public static function getOMClass()
+	{
+		return CeneoPeer::CLASS_DEFAULT;
+	}
+
+	/**
+	 * Method perform an INSERT on the database, given a Ceneo or Criteria object.
+	 *
+	 * @param      mixed $values Criteria or Ceneo object containing data that is used to create the INSERT statement.
+	 * @param      Connection $con the connection to use
+	 * @return     mixed The new primary key.
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function doInsert($values, $con = null)
+	{
+
+    foreach (sfMixer::getCallables('BaseCeneoPeer:doInsert:pre') as $callable)
+    {
+      $ret = call_user_func($callable, 'BaseCeneoPeer', $values, $con);
+      if (false !== $ret)
+      {
+        return $ret;
+      }
+    }
+
+
+		if ($con === null) {
+			$con = Propel::getConnection(self::DATABASE_NAME);
+		}
+
+		if ($values instanceof Criteria) {
+			$criteria = clone $values; // rename for clarity
+		} else {
+			$criteria = $values->buildCriteria(); // build Criteria from Ceneo object
+		}
+
+		$criteria->remove(CeneoPeer::ID); // remove pkey col since this table uses auto-increment
+
+
+		// Set the correct dbName
+		$criteria->setDbName(self::DATABASE_NAME);
+
+		try {
+			// use transaction because $criteria could contain info
+			// for more than one table (I guess, conceivably)
+			$con->begin();
+			$pk = BasePeer::doInsert($criteria, $con);
+			$con->commit();
+		} catch(PropelException $e) {
+			$con->rollback();
+			throw $e;
+		}
+
+		
+    foreach (sfMixer::getCallables('BaseCeneoPeer:doInsert:post') as $callable)
+    {
+      call_user_func($callable, 'BaseCeneoPeer', $values, $con, $pk);
+    }
+
+    return $pk;
+	}
+
+	/**
+	 * Method perform an UPDATE on the database, given a Ceneo or Criteria object.
+	 *
+	 * @param      mixed $values Criteria or Ceneo object containing data that is used to create the UPDATE statement.
+	 * @param      Connection $con The connection to use (specify Connection object to exert more control over transactions).
+	 * @return     int The number of affected rows (if supported by underlying database driver).
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function doUpdate($values, $con = null)
+	{
+
+    foreach (sfMixer::getCallables('BaseCeneoPeer:doUpdate:pre') as $callable)
+    {
+      $ret = call_user_func($callable, 'BaseCeneoPeer', $values, $con);
+      if (false !== $ret)
+      {
+        return $ret;
+      }
+    }
+
+
+		if ($con === null) {
+			$con = Propel::getConnection(self::DATABASE_NAME);
+		}
+
+		$selectCriteria = new Criteria(self::DATABASE_NAME);
+
+		if ($values instanceof Criteria) {
+			$criteria = clone $values; // rename for clarity
+
+			$comparison = $criteria->getComparison(CeneoPeer::ID);
+			$selectCriteria->add(CeneoPeer::ID, $criteria->remove(CeneoPeer::ID), $comparison);
+
+		} else { // $values is Ceneo object
+			$criteria = $values->buildCriteria(); // gets full criteria
+			$selectCriteria = $values->buildPkeyCriteria(); // gets criteria w/ primary key(s)
+		}
+
+		// set the correct dbName
+		$criteria->setDbName(self::DATABASE_NAME);
+
+		$ret = BasePeer::doUpdate($selectCriteria, $criteria, $con);
+	
+
+    foreach (sfMixer::getCallables('BaseCeneoPeer:doUpdate:post') as $callable)
+    {
+      call_user_func($callable, 'BaseCeneoPeer', $values, $con, $ret);
+    }
+
+    return $ret;
+  }
+
+	/**
+	 * Method to DELETE all rows from the st_ceneo table.
+	 *
+	 * @return     int The number of affected rows (if supported by underlying database driver).
+	 */
+	public static function doDeleteAll($con = null)
+	{
+		if ($con === null) {
+			$con = Propel::getConnection(self::DATABASE_NAME);
+		}
+		$affectedRows = 0; // initialize var to track total num of affected rows
+		try {
+			// use transaction because $criteria could contain info
+			// for more than one table or we could emulating ON DELETE CASCADE, etc.
+			$con->begin();
+			$affectedRows += BasePeer::doDeleteAll(CeneoPeer::TABLE_NAME, $con);
+			$con->commit();
+			return $affectedRows;
+		} catch (PropelException $e) {
+			$con->rollback();
+			throw $e;
+		}
+	}
+
+	/**
+	 * Method perform a DELETE on the database, given a Ceneo or Criteria object OR a primary key value.
+	 *
+	 * @param      mixed $values Criteria or Ceneo object or primary key or array of primary keys
+	 *              which is used to create the DELETE statement
+	 * @param      Connection $con the connection to use
+	 * @return     int 	The number of affected rows (if supported by underlying database driver).  This includes CASCADE-related rows
+	 *				if supported by native driver or if emulated using Propel.
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	 public static function doDelete($values, $con = null)
+	 {
+		if ($con === null) {
+			$con = Propel::getConnection(CeneoPeer::DATABASE_NAME);
+		}
+
+		if ($values instanceof Criteria) {
+			$criteria = clone $values; // rename for clarity
+		} elseif ($values instanceof Ceneo) {
+
+			$criteria = $values->buildPkeyCriteria();
+		} else {
+			// it must be the primary key
+			$criteria = new Criteria(self::DATABASE_NAME);
+			$criteria->add(CeneoPeer::ID, (array) $values, Criteria::IN);
+		}
+
+		// Set the correct dbName
+		$criteria->setDbName(self::DATABASE_NAME);
+
+		$affectedRows = 0; // initialize var to track total num of affected rows
+
+		try {
+			// use transaction because $criteria could contain info
+			// for more than one table or we could emulating ON DELETE CASCADE, etc.
+			$con->begin();
+			
+			$affectedRows += BasePeer::doDelete($criteria, $con);
+			$con->commit();
+			return $affectedRows;
+		} catch (PropelException $e) {
+			$con->rollback();
+			throw $e;
+		}
+	}
+
+	/**
+	 * Validates all modified columns of given Ceneo object.
+	 * If parameter $columns is either a single column name or an array of column names
+	 * than only those columns are validated.
+	 *
+	 * NOTICE: This does not apply to primary or foreign keys for now.
+	 *
+	 * @param      Ceneo $obj The object to validate.
+	 * @param      mixed $cols Column name or array of column names.
+	 *
+	 * @return     mixed TRUE if all columns are valid or the error message of the first invalid column.
+	 */
+	public static function doValidate(Ceneo $obj, $cols = null)
+	{
+		$columns = array();
+
+		if ($cols) {
+			$dbMap = Propel::getDatabaseMap(CeneoPeer::DATABASE_NAME);
+			$tableMap = $dbMap->getTable(CeneoPeer::TABLE_NAME);
+
+			if (! is_array($cols)) {
+				$cols = array($cols);
+			}
+
+			foreach($cols as $colName) {
+				if ($tableMap->containsColumn($colName)) {
+					$get = 'get' . $tableMap->getColumn($colName)->getPhpName();
+					$columns[$colName] = $obj->$get();
+				}
+			}
+		} else {
+
+		}
+
+		$res =  BasePeer::doValidate(CeneoPeer::DATABASE_NAME, CeneoPeer::TABLE_NAME, $columns);
+    if ($res !== true) {
+        $request = sfContext::getInstance()->getRequest();
+        foreach ($res as $failed) {
+            $col = CeneoPeer::translateFieldname($failed->getColumn(), BasePeer::TYPE_COLNAME, BasePeer::TYPE_PHPNAME);
+            $request->setError($col, $failed->getMessage());
+        }
+    }
+
+    return $res;
+	}
+
+	/**
+	 * Retrieve a single object by pkey.
+	 *
+	 * @param      mixed $pk the primary key.
+	 * @param      Connection $con the connection to use
+	 * @return     Ceneo
+	 */
+	public static function retrieveByPK($pk, $con = null)
+	{
+		if ($con === null) {
+			$con = Propel::getConnection(self::DATABASE_NAME);
+		}
+
+		$criteria = new Criteria(CeneoPeer::DATABASE_NAME);
+
+		$criteria->add(CeneoPeer::ID, $pk);
+
+
+		$v = CeneoPeer::doSelect($criteria, $con);
+
+		return !empty($v) > 0 ? $v[0] : null;
+	}
+
+	/**
+	 * Retrieve multiple objects by pkey.
+	 *
+	 * @param      array $pks List of primary keys
+	 * @param      Connection $con the connection to use
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 * @return Ceneo[]
+	 */
+	public static function retrieveByPKs($pks, $con = null)
+	{
+		if ($con === null) {
+			$con = Propel::getConnection(self::DATABASE_NAME);
+		}
+
+		$objs = null;
+		if (empty($pks)) {
+			$objs = array();
+		} else {
+			$criteria = new Criteria();
+			$criteria->add(CeneoPeer::ID, $pks, Criteria::IN);
+			$objs = CeneoPeer::doSelect($criteria, $con);
+		}
+		return $objs;
+	}
+
+} // BaseCeneoPeer
+
+// static code to register the map builder for this Peer with the main Propel class
+if (Propel::isInit()) {
+	// the MapBuilder classes register themselves with Propel during initialization
+	// so we need to load them here.
+	try {
+		BaseCeneoPeer::getMapBuilder();
+	} catch (Exception $e) {
+		Propel::log('Could not initialize Peer: ' . $e->getMessage(), Propel::LOG_ERR);
+	}
+} else {
+	// even if Propel is not yet initialized, the map builder class can be registered
+	// now and then it will be loaded when Propel initializes.
+	Propel::registerMapBuilder('plugins.stCeneoPlugin.lib.model.map.CeneoMapBuilder');
+}

plugins/stCeneoPlugin/lib/stCeneo.class.php

@@ -0,0 +1,313 @@
+<?php
+/**
+ * SOTESHOP/stCeneoPlugin
+ *
+ * Ten plik należy do aplikacji stCeneoPlugin opartej na licencji (Professional License SOTE). 
+ * Nie zmieniaj tego pliku, jeśli chcesz korzystać z automatycznych aktualizacji oprogramowania. 
+ * Jeśli chcesz wprowadzać swoje modyfikacje do programu, zapoznaj się z dokumentacją, jak zmieniać 
+ * oprogramowanie bez zmiany kodu bazowego http://www.sote.pl/modifications
+ *
+ * @package     stCeneoPlugin
+ * @subpackage  libs
+ * @copyright   SOTE (www.sote.pl)
+ * @license     http://www.sote.pl/license/sote (Professional License SOTE)
+ * @version     $Id: stCeneo.class.php 16419 2011-12-08 13:05:55Z michal $
+ * @author      Michal Prochowski <michal.prochowski@sote.pl>
+ */
+
+/**
+ * Klasa stCeneo
+ *
+ * @package     stCeneoPlugin
+ * @subpackage  libs
+ */
+class stCeneo extends stPriceCompareGenerateFile implements stPriceCompareGenerateFileInterface
+{    
+    
+    /**
+     * Konstruktor
+     */
+    public function __construct()
+    {
+        parent::__construct(__CLASS__);         
+    }
+
+    /**
+     * Generowanie nagłówka pliku
+     *
+     * @return string
+     */
+    protected function getFileHead()
+    {
+        $content = xml_open_tag('?xml version="1.0" encoding="UTF-8"?');
+        $content.= xml_open_tag('offers xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1"');
+        return $content;
+    }
+
+    /**
+     * Generowanie zawartości pliku
+     *
+     * @param $step integer numer kroku
+     * @return string
+     */
+    protected function getFileBody($step)
+    {
+        $priceCompareProducts = $this->getProducts($step);
+		
+		$url_product_params = "";
+
+		
+		if (is_dir(sfConfig::get('sf_plugins_dir')."/appAdsTrackerPlugin")) {
+
+			$config = stConfig::getInstance(sfContext::getInstance(), 'appAdsTrackerBackend');
+
+			if ($config->get("is_active")==1) {
+
+				$c = new Criteria();
+				$c->add(AdsTrackerListPeer::IS_ACTIVE, 1);
+				$c->add(AdsTrackerListPeer::PLUGIN_NAME, "ceneo");
+				$ceneo_ads = AdsTrackerListPeer::doSelectOne($c);
+
+				if ($ceneo_ads) {
+					$url_product_params = "?hash=".$ceneo_ads->getHash();
+				}
+			}
+
+		}		
+
+        $content = "";
+        foreach ($priceCompareProducts as $priceCompareProduct)
+        {
+            $parsedProduct = new stPriceCompareProductParser($priceCompareProduct->getProduct());
+
+            if ($parsedProduct->checkProduct())
+            {
+				
+                $this->product = $priceCompareProduct->getProduct();
+                $this->price = $parsedProduct->getPrice();
+                stEventDispatcher::getInstance()->notify(new sfEvent($this, 'stCeneoPlugin.stCeneoChangePrice', array()));
+
+                $productContent = xml_cdata_tag('cat', $parsedProduct->getCategory());
+                $productContent.= xml_cdata_tag('name', $parsedProduct->getName());
+                $productContent.= xml_tag('imgs', xml_tag('main', null, array('url' => $parsedProduct->getPhoto())));
+
+                if ($this->getConfig('description_type') == 'full') $productContent.= xml_cdata_tag('desc', $parsedProduct->getDescription());
+                elseif ($this->getConfig('description_type') == 'short') $productContent.= xml_cdata_tag('desc', $parsedProduct->getShortDescription());
+
+                $attributeContent = '';
+                if ($parsedProduct->hasProducer())
+                {
+                    $attributeContent.= xml_cdata_tag('a', $parsedProduct->getProducer(true), array('name' => 'Producent'));
+                }
+
+                if ($this->getConfig('use_product_code') == true)
+                    $attributeContent.= xml_cdata_tag('a', $parsedProduct->getCode(), array('name' => 'Kod producenta'));
+                elseif($this->getConfig('use_man_code') == true)
+                    $attributeContent.= xml_cdata_tag('a', $parsedProduct->getManCode(), array('name' => 'Kod producenta'));
+
+                if ($this->getConfig('use_ean_code') == true)
+                {
+                    $attributeContent.= xml_cdata_tag('a', $parsedProduct->getManCode(), array('name' => 'EAN'));
+                }
+                if ($this->getConfig('use_isbn_code') == true)
+                {
+                	$attributeContent.= xml_cdata_tag('a', $parsedProduct->getManCode(), array('name' => 'ISBN'));
+                }
+                if ($this->getConfig('use_attribute') == true)
+                {
+                                             
+                    $variants = appProductAttributeVariantPeer::doSelectArrayWithAttribyteByProduct($priceCompareProduct->getProduct(), 'pl_PL');
+                    $attributes = appProductAttributePeer::doSelectArrayByProduct($priceCompareProduct->getProduct(), 'pl_PL');                
+                    
+                    if($attributes){ 
+                      
+                        foreach ($attributes as $id => $attribute) {                                                    
+                            
+                            $variantss = "";            
+                            $elements = count($variants[$id]);            
+                            $i = 1;
+                            
+                            foreach ($variants[$id] as $variant)
+                            {                            
+                                $variantss .= $variant['value'];                                                        
+                                
+                                if($elements>1){
+                                    if($elements!=$i){
+                                        $variantss .= ", ";
+                                    }                                                                                                                                                                               
+                                }
+                                                            
+                                $i++;                 
+                            }                                                
+                            
+                            if ($attribute['type'] == 'C' ){
+                                 
+                                $color_wariants = "";            
+                                $color_elements = count($variants[$id]);            
+                                $d = 1;
+
+                                foreach ($variants[$id] as $variant){
+                                
+                                    $color_wariants .= $variant['name'];                                                        
+                                    
+                                    if($color_elements>1){
+                                        if($color_elements!=$d){
+                                            $color_wariants .= "/";
+                                        }                                                                     
+                                    }                                   
+                                    $d++; 
+                                }
+                                if($color_wariants){
+                                $attributeContent.= xml_cdata_tag('a', $color_wariants, array('name' => $attribute['name']));
+                                }
+
+                            }
+
+
+                            if ($attribute[type] == 'B' ){
+                                
+                                if(isset($variants[$id]) && !empty($variants[$id])){
+                                    $variantss = "Tak";
+                                }else{
+                                    $variantss = "Nie";
+                                }                            
+                            }    
+                            
+                            if ($attribute[type] != 'C' ){                        
+                                $attributeContent.= xml_cdata_tag('a', $variantss, array('name' => $attribute[name]));                                                        
+                            }                                                                     
+                             
+                                
+                        }
+                   
+                    } 
+
+                }   
+                
+                
+                $attributeContent = stEventDispatcher::getInstance()->filter(new sfEvent($this, 'stCeneoPlugin.stCeneoAttributesContent', array('product' => $this->product)), $attributeContent)->getReturnValue();
+
+                $productContent.= xml_tag('attrs', $attributeContent);
+
+                $oParameters = array();
+                $oParameters['id'] = $parsedProduct->getId();
+				$oParameters['url'] = $parsedProduct->getUrl().$url_product_params;
+                $oParameters['price'] = $this->price;
+                
+                
+                $c = new Criteria();
+                $c->add(CeneoPeer::PRODUCT_ID, $parsedProduct->getId());
+                $object = CeneoPeer::doSelectOne($c);
+                
+                if($object->getIsBasket()==1){
+                    $oParameters['basket'] = 1;    
+                }else{
+                    $oParameters['basket'] = 0;
+                }
+                
+                $avail = $parsedProduct->getPriceCompareAvailability($this, 99);
+                $oParameters['avail'] = ($avail == 0)? 99 : $avail;
+                if ($parsedProduct->hasWeight()) $oParameters['weight'] = $parsedProduct->getWeight();
+                if ($this->getConfig('use_stock') && $parsedProduct->hasStock() && $parsedProduct->getStock() >= 0) $oParameters['stock'] = floor($parsedProduct->getStock());
+
+                if ($this->getConfig('stock_zero')==1 && $parsedProduct->getStock() == 0){
+                    $content.= "";    
+                }else{
+                    $content.= xml_tag('o', $productContent, $oParameters);    
+                }
+    
+                
+                
+    
+                
+            }
+            unset($parsedProduct);
+            
+            if ($this->isCLI())
+            {
+                usleep(250000);    
+            }
+        }
+
+        return $content;
+    }
+
+    /**
+     * Generowanie stopki pliku
+     *
+     * @return string
+     */
+    protected function getFileFoot()
+    {
+        return xml_close_tag('offers');
+    }
+
+    /**
+     * Pobieranie infromacji o porównywarce podczas eksportu
+     *
+     * @param $object object
+     * @return integer
+     */
+    static public function getProduct($object = null)
+    {
+        return stPriceCompareGenerateFile::getProductForExport(__CLASS__, $object);
+    }
+
+    /**
+     * Ustawianie infromacji o porównywarce podczas importu
+     *
+     * @param $object object
+     * @param $value integer
+     * @return boolean
+     */
+    static public function setProduct($object = null, $active = 0)
+    {
+        return stPriceCompareGenerateFile::setProductForImport(__CLASS__, $object, $active);
+    }
+    
+
+    static public function getIsBasket($object = null)
+    {
+        $c = new Criteria();
+        $c->add(CeneoPeer::PRODUCT_ID, $object->getId());
+        $ceneo = CeneoPeer::doSelectOne($c);
+        
+        return $ceneo && $ceneo->getIsBasket();                                                    
+        
+    }
+
+
+    static public function setIsBasket($object = null, $is_basket = 0)
+    {
+
+        $c = new Criteria();
+        $c->add(CeneoPeer::PRODUCT_ID, $object->getId());
+        $ceneo = CeneoPeer::doSelectOne($c);
+        
+        if($ceneo){
+            
+            $ceneo->setIsBasket($is_basket);
+            $ceneo->save();
+            return $is_basket;
+            
+        }else{
+                
+             $ceneo = new stCeneo();             
+             $ceneo->setProductId($object->getId());
+             $ceneo->setIsBasket($is_basket);
+             $ceneo->save();   
+                                 
+             return $ceneo->getIsBasket();        
+        }
+    }
+
+    /**
+     * Pobieranie informacji o statusach dostępności Ceneo
+     *
+     * @return array
+     */
+    static public function getCeneoAvailabilities()
+    {
+        return array(1 => __('produkt dostępny'), 3 => __('produkt dostępny do trzech dni'), 7 => __("produkt dostępny do tygodnia"), 14 => __("produkt dostępny powyżej tygodnia"), 99 => __('sprawdź dostępność w sklepie'));
+    }
+}

plugins/stCeneoPlugin/lib/stCeneoPluginListener.class.php

@@ -0,0 +1,43 @@
+<?php
+/** 
+ * SOTESHOP/stCeneoPlugin 
+ * 
+ * Ten plik należy do aplikacji stCeneoPlugin opartej na licencji (Professional License SOTE). 
+ * Nie zmieniaj tego pliku, jeśli chcesz korzystać z automatycznych aktualizacji oprogramowania. 
+ * Jeśli chcesz wprowadzać swoje modyfikacje do programu, zapoznaj się z dokumentacją, jak zmieniać 
+ * oprogramowanie bez zmiany kodu bazowego http://www.sote.pl/modifications
+ * 
+ * @package     stCeneoPlugin
+ * @subpackage  libs
+ * @copyright   SOTE (www.sote.pl)
+ * @license     http://www.sote.pl/license/sote (Professional License SOTE)
+ * @version     $Id: stCeneoPluginListener.class.php 9523 2010-11-26 11:25:33Z michal $
+ * @author      Piotr Halas <piotr.halas@sote.pl>
+ */
+ 
+/** 
+ * Klasa stCeneoPluginListener
+ *
+ * @package     stCeneoPlugin
+ * @subpackage  libs
+ */
+class stCeneoPluginListener
+{
+    /** 
+     * Dodaje konfiugracje do importu/eksportu produktu
+     *
+     * @param       sfEvent     $event
+     */
+    public static function generate(sfEvent $event)
+    {
+        // możemy wywoływać podaną metodę wielokrotnie co powoduje dołączenie kolejnych plików
+        $event->getSubject()->attachAdminGeneratorFile('stCeneoPlugin', 'stCeneoInProduct.yml');
+    }
+
+    public static function preExecuteBasketIndex(sfEvent $event, $ok = false) {
+        if (stConfig::getInstance('stCeneoBackend')->get('trusted_opinion_on'))
+            stCompatibilityOpinion::setOpinionService('Ceneo');
+    return $ok;
+    }
+    
+}

plugins/stCeneoPlugin/lib/stCeneoTask.class.php

@@ -0,0 +1,37 @@
+<?php
+
+class stCeneoTask extends stTask
+{
+    protected $ceneo;
+    
+    public function initialize()
+    {                
+        $this->ceneo = new stCeneo();
+        $this->ceneo->setCLI($this->isCLI());
+    }
+    
+    /**
+     * W tej metodzie zwracamy ile rekordów/danych zamierzamy wykonać
+     */
+    public function count(): int
+    {                
+        return $this->ceneo->getStepsCount();
+    }
+    
+    public function started() {
+        $this->ceneo->init();
+    }
+
+    public function finished() {
+        $this->ceneo->close();
+    }
+
+    /**
+     * W tej metodzie wykonujemy swoje operacje na danych
+     * 
+     */
+    public function execute(int $offset): int
+    {        
+        return $this->ceneo->generate($offset);                         
+    }
+}