1: <?php
  2: 
  3: /**
  4:  * This file contains CONTENIDO content functions.
  5:  *
  6:  * Please add only stuff which is relevant for the frontend
  7:  * AND the backend. This file should NOT contain any backend editing
  8:  * functions to improve frontend performance:
  9:  *
 10:  * @package          Core
 11:  * @subpackage       Backend
 12:  * @author           Willi Man
 13:  * @author           Timo Hummel
 14:  * @copyright        four for business AG <www.4fb.de>
 15:  * @license          http://www.contenido.org/license/LIZENZ.txt
 16:  * @link             http://www.4fb.de
 17:  * @link             http://www.contenido.org
 18:  */
 19: 
 20: defined('CON_FRAMEWORK') || die('Illegal call: Missing framework initialization - request aborted.');
 21: 
 22: /**
 23:  * Generates the code for one article
 24:  *
 25:  * @param int $idcat
 26:  *         Id of category
 27:  * @param int $idart
 28:  *         Id of article
 29:  * @param int $lang
 30:  *         Id of language
 31:  * @param int $client
 32:  *         Id of client
 33:  * @param int $layout [optional]
 34:  *         Layout-ID of alternate Layout (if false, use associated layout)
 35:  * @param bool $save [optional]
 36:  *         Flag to persist generated code in database
 37:  * @param bool $contype [optional]
 38:  *         Flag to enable/disable replacement of CMS_TAGS[].
 39:  * @param bool $editable [optional]
 40:  *         deprecated?
 41:  * @param int|NULL $version [optional]
 42:  *         version number if article is a revision, else NULL;
 43:  * @return string
 44:  *         The generated code or "0601" if neither article
 45:  *         nor category configuration was found.
 46:  */
 47: function conGenerateCode($idcat, $idart, $lang, $client, $layout = false, $save = true, $contype = true, $editable = false, $version = NULL) {
 48:     global $cfg, $frontend_debug;
 49: 
 50:     // @todo make generator configurable
 51:     $codeGen = cCodeGeneratorFactory::getInstance($cfg['code_generator']['name']);
 52:     if (isset($frontend_debug) && is_array($frontend_debug)) {
 53:         $codeGen->setFrontendDebugOptions($frontend_debug);
 54:     }
 55: 
 56:     $code = $codeGen->generate($idcat, $idart, $lang, $client, $layout, $save, $contype, $editable, $version);
 57: 
 58:     // execute CEC hook
 59:     $code = cApiCecHook::executeAndReturn('Contenido.Content.conGenerateCode', $code);
 60: 
 61:     return $code;
 62: }
 63: 
 64: /**
 65:  * Returns the idartlang for a given article and language
 66:  *
 67:  * @param int $idart
 68:  *         ID of the article
 69:  * @param int $idlang
 70:  *         ID of the language
 71:  * @return mixed
 72:  *         idartlang of the article or false if nothing was found
 73:  */
 74: function getArtLang($idart, $idlang) {
 75:     $oArtLangColl = new cApiArticleLanguageCollection();
 76:     $idartlang = $oArtLangColl->getIdByArticleIdAndLanguageId($idart, $idlang);
 77:     return ($idartlang) ? $idartlang : false;
 78: }
 79: 
 80: /**
 81:  * Returns all available meta tag types
 82:  *
 83:  * @return array
 84:  *         Assoziative meta tags list
 85:  */
 86: function conGetAvailableMetaTagTypes() {
 87:     $oMetaTypeColl = new cApiMetaTypeCollection();
 88:     $oMetaTypeColl->select();
 89:     $aMetaTypes = array();
 90: 
 91:     while (($oMetaType = $oMetaTypeColl->next()) !== false) {
 92:         $rs = $oMetaType->toArray();
 93:         $aMetaTypes[$rs['idmetatype']] = array(
 94:             'metatype' => $rs['metatype'],
 95:             'fieldtype' => $rs['fieldtype'],
 96:             'maxlength' => $rs['maxlength'],
 97:             'fieldname' => $rs['fieldname'],
 98:             'idmetatype' => $rs["idmetatype"]
 99:         );
100:     }
101: 
102:     return $aMetaTypes;
103: }
104: 
105: /**
106:  * Get the meta tag value or its version for a specific article
107:  *
108:  * @param int $idartlang
109:  *         ID of the article
110:  * @param int $idmetatype
111:  *         Metatype-ID
112:  * @param int $version
113:  *         version number
114:  * @return string
115:  */
116: function conGetMetaValue($idartlang, $idmetatype, $version  = NULL) {
117:     static $oMetaTagColl = NULL;
118:     static $metaTagVersionColl = NULL;
119: 
120:     if ($version ==  NULL) {
121:         if (!isset($oMetaTagColl)) {
122:             $oMetaTagColl = new cApiMetaTagCollection();
123:         }
124: 
125:         if ((int) $idartlang <= 0) {
126:             return '';
127:         }
128: 
129:         $oMetaTag = $oMetaTagColl->fetchByArtLangAndMetaType($idartlang, $idmetatype);
130:         if (is_object($oMetaTag)) {
131:             return stripslashes($oMetaTag->get('metavalue'));
132:         } else {
133:             return '';
134:         }
135:     } else if (is_numeric ($version)) {
136:         if (!isset($metaTagVersionColl)) {
137:             $metaTagVersionColl = new cApiMetaTagVersionCollection();
138:         }
139: 
140:         if ((int) $idartlang <= 0) {
141:             return '';
142:         }
143: 
144:         $metaTagVersion = $metaTagVersionColl->fetchByArtLangMetaTypeAndVersion($idartlang, $idmetatype, $version);
145:         if (is_object($metaTagVersion)) {
146:             return stripslashes($metaTagVersion->get('metavalue'));
147:         } else {
148:             return '';
149:         }
150: 
151:     }
152: }
153: 
154: /**
155:  * Set the meta tag value or its version for a specific article.
156:  *
157:  * @param int $idartlang
158:  *         ID of the article
159:  * @param int $idmetatype
160:  *         Metatype-ID
161:  * @param string $value
162:  *         Value of the meta tag
163:  * @param int $version
164:  *         version number
165:  * @return bool
166:  *         whether the meta value has been saved successfully
167:  */
168: function conSetMetaValue($idartlang, $idmetatype, $value, $version = NULL) {
169:     static $metaTagColl = NULL;
170:     //$ids[] = array ();
171:     $versioning = new cContentVersioning();
172: 
173:     if (!isset($metaTagColl)) {
174:         $metaTagColl = new cApiMetaTagCollection();
175:     }
176:     //echo "version0:";var_export($version);
177:     $metaTag = $metaTagColl->fetchByArtLangAndMetaType($idartlang, $idmetatype);
178: 
179:     // check if the original version already has been saved
180:     //$where = 'idartlang = ' . $idartlang . ' AND idmetatype = ' . $idmetatype . '';
181:     //$metaTagVersionColl = new cApiMetaTagVersionCollection();
182:     //$ids = $metaTagVersionColl->getIdsByWhereClause($where);
183: 
184:     switch ($versioning->getState()) {
185:         case 'simple':
186:             // if its only a robot-update, only update and don't create a version
187:             if ($version == NULL) {
188:                 if (is_object($metaTag)) {
189:                     $return = $metaTag->updateMetaValue($value);
190:                     return $return;
191:                 } else {
192:                     $metaTag = $metaTagColl->create($idartlang, $idmetatype, $value);
193:                     return true;
194:                 }
195:             }
196: 
197:             // get metatagid
198:             if (is_object($metaTag)) {
199:                 $idmetatag = $metaTag->get('idmetatag');
200:                 //$valueTemp = $metaTag->getField('value');
201:             }
202: 
203:             // safe original version if nothing has been versioned yet
204:          /*   foreach ($ids AS $key => $id) {
205:                 $metaTagTemp = new cApiMetaTagVersion();
206:                 if ($metaTagTemp->getField('idmetatype') == 7) {
207:                     unset($ids[$key]);
208:                 }
209:             }
210: 
211:             if (empty($ids)) {
212:                     $metaTagVersionParameters = array(
213:                         'idmetatag' => $idmetatag,
214:                         'idartlang' => $idartlang,
215:                         'idmetatype' => $idmetatype,
216:                         'value' => $valueTemp,
217:                         'version' => $version
218:                     );
219:                     $versioning->createMetaTagVersion($metaTagVersionParameters);
220: 
221:                     // create new article version for the change
222:                     $artLang = new cApiArticleLanguage(cSecurity::toInteger($idartlang));
223:                     $artLangVersion = $versioning->createArticleLanguageVersion($artLang->toArray());
224:                     $version = $artLangVersion->getField('version');
225:             }
226:             echo "version1:";var_export($version);*/
227:             // update article
228:             $artLang = new cApiArticleLanguage($idartlang);
229:             $artLang->set('lastmodified', date('Y-m-d H:i:s'));
230:             $artLang->store();
231:             // update or create meta tag
232:             if (is_object($metaTag)) {
233:                 $return = $metaTag->updateMetaValue($value);
234: 
235:             } else {
236:                 $metaTag = $metaTagColl->create($idartlang, $idmetatype, $value);
237:             }
238: 
239:             // create meta tag version
240:             $metaTagVersionParameters = array(
241:                 'idmetatag' => $idmetatag,
242:                 'idartlang' => $idartlang,
243:                 'idmetatype' => $idmetatype,
244:                 'value' => $value,
245:                 'version' => $version
246:             );
247:             $versioning->createMetaTagVersion($metaTagVersionParameters);
248:             //echo "version2:";var_export($version);echo "<hr>";
249:             break;
250:         case 'disabled':
251:             // update article
252:             $artLang = new cApiArticleLanguage($idartlang);
253:             $artLang->set('lastmodified', date('Y-m-d H:i:s'));
254:             $artLang->store();
255:             //update meta tag
256:             if (is_object($metaTag)) {
257:                 $return = $metaTag->updateMetaValue($value);
258:                 return $return;
259: 
260:             } else {
261:                 $metaTag = $metaTagColl->create($idartlang, $idmetatype, $value);
262:                 return true;
263: 
264:             }
265: 
266:             break;
267:         case 'advanced':
268:             if ($version == NULL) {
269:                 if (is_object($metaTag)) {
270:                     $return = $metaTag->updateMetaValue($value);
271:                 } else {
272:                     $metaTag = $metaTagColl->create($idartlang, $idmetatype, $value);
273:                 }
274:                 $version = 1;
275:             }
276: 
277:             if (is_object($metaTag)) {
278:                 $idmetatag = $metaTag->get('idmetatag');
279:             }
280:             $metaTagVersionParameters = array(
281:                 'idmetatag' => $idmetatag,
282:                 'idartlang' => $idartlang,
283:                 'idmetatype' => $idmetatype,
284:                 'value' => $value,
285:                 'version' => $version
286:             );
287:             $versioning->createMetaTagVersion($metaTagVersionParameters);
288: 
289:             break;
290:         default:
291:             break;
292: 
293:     }
294: 
295: }
296: 
297: /**
298:  * (Re-)generate keywords for all articles of a given client (with specified language)
299:  *
300:  * @param int $client
301:  *         Client
302:  * @param int $lang
303:  *         Language of a client
304:  * @deprecated [2014-07-24]
305:  *         Not used anymore
306:  */
307: function conGenerateKeywords($client, $lang) {
308:     $cfg = cRegistry::getConfig();
309: 
310:     static $oDB = NULL;
311:     if (!isset($oDB)) {
312:         $oDB = cRegistry::getDb();
313:     }
314: 
315:     // cms types to be excluded from indexing
316:     $options = $cfg['search_index']['excluded_content_types'];
317: 
318:     $sql = 'SELECT a.idart, b.idartlang FROM ' . $cfg['tab']['art'] . ' AS a, ' . $cfg['tab']['art_lang'] . ' AS b
319:             WHERE a.idart=b.idart AND a.idclient=' . (int) $client . ' AND b.idlang=' . (int) $lang;
320: 
321:     $oDB->query($sql);
322: 
323:     $aArticles = array();
324:     while ($oDB->nextRecord()) {
325:         $aArticles[$oDB->f('idart')] = $oDB->f('idartlang');
326:     }
327: 
328:     foreach ($aArticles as $artid => $artlangid) {
329:         $aContent = conGetContentFromArticle($artlangid);
330:         if (count($aContent) > 0) {
331:             $oIndex = new cSearchIndex($oDB);
332:             $oIndex->start($artid, $aContent, 'auto', $options);
333:         }
334:     }
335: }
336: 
337: /**
338:  * Get content from article by article language.
339:  *
340:  * @param int $iIdArtLang
341:  *         ArticleLanguageId of an article (idartlang)
342:  * @return array
343:  *         Array with content of an article indexed by content-types as follows:
344:  *         - $arr[type][typeid] = value;
345:  */
346: function conGetContentFromArticle($iIdArtLang) {
347:     global $cfg;
348: 
349:     static $oDB = NULL;
350:     if (!isset($oDB)) {
351:         $oDB = cRegistry::getDb();
352:     }
353: 
354:     $aContent = array();
355: 
356:     $sql = 'SELECT * FROM ' . $cfg['tab']['content'] . ' AS A, ' . $cfg['tab']['art_lang'] . ' AS B, ' . $cfg['tab']['type'] . ' AS C
357:             WHERE A.idtype=C.idtype AND A.idartlang=B.idartlang AND A.idartlang=' . (int) $iIdArtLang;
358:     $oDB->query($sql);
359:     while ($oDB->nextRecord()) {
360:         $aContent[$oDB->f('type')][$oDB->f('typeid')] = $oDB->f('value');
361:     }
362: 
363:     return $aContent;
364: }
365: 
366: /**
367:  * Returns list of all container with configured modules by template id
368:  *
369:  * @param int $idtpl
370:  *         Template id
371:  * @return array
372:  *         Assoziative array where the key is the number and value the module id
373:  */
374: function conGetUsedModules($idtpl) {
375:     $modules = array();
376: 
377:     $oContainerColl = new cApiContainerCollection();
378:     $oContainerColl->select('idtpl = ' . (int) $idtpl, '', 'number ASC');
379:     while (($oContainer = $oContainerColl->next()) !== false) {
380:         $modules[(int) $oContainer->get('number')] = (int) $oContainer->get('idmod');
381:     }
382: 
383:     return $modules;
384: }
385: 
386: /**
387:  * Returns list of all configured container configurations by template configuration id
388:  *
389:  * @param int $idtplcfg
390:  *         Template configuration id
391:  * @return array
392:  *         Assoziative array where the key is the number
393:  *         and value the container configuration.
394:  */
395: function conGetContainerConfiguration($idtplcfg) {
396:     $containerConfColl = new cApiContainerConfigurationCollection();
397:     return $containerConfColl->getByTemplateConfiguration($idtplcfg);
398: }
399: 
400: /**
401:  * Returns category article id
402:  *
403:  * @param int $idcat
404:  * @param int $idart
405:  * @return int|NULL
406:  */
407: function conGetCategoryArticleId($idcat, $idart) {
408:     global $cfg, $db;
409: 
410:     // Get idcatart, we need this to retrieve the template configuration
411:     $sql = 'SELECT idcatart FROM `%s` WHERE idcat = %d AND idart = %d';
412:     $sql = $db->prepare($sql, $cfg['tab']['cat_art'], $idcat, $idart);
413:     $db->query($sql);
414: 
415:     return ($db->nextRecord()) ? $db->f('idcatart') : NULL;
416: }
417: 
418: /**
419:  * Returns template configuration id for a configured article.
420:  *
421:  * @param int $idart
422:  * @param int $idcat
423:  *         NOT used
424:  * @param int $lang
425:  * @param int $client
426:  * @return int|NULL
427:  */
428: function conGetTemplateConfigurationIdForArticle($idart, $idcat, $lang, $client) {
429:     global $cfg, $db;
430: 
431:     // Retrieve template configuration id
432:     $sql = "SELECT a.idtplcfg AS idtplcfg FROM `%s` AS a, `%s` AS b WHERE a.idart = %d "
433:          . "AND a.idlang = %d AND b.idart = a.idart AND b.idclient = %d";
434:     $sql = $db->prepare($sql, $cfg['tab']['art_lang'], $cfg['tab']['art'], $idart, $lang, $client);
435:     $db->query($sql);
436: 
437:     return ($db->nextRecord()) ? $db->f('idtplcfg') : NULL;
438: }
439: 
440: /**
441:  * Returns template configuration id for a configured category
442:  *
443:  * @param int $idcat
444:  * @param int $lang
445:  * @param int $client
446:  * @return int|NULL
447:  */
448: function conGetTemplateConfigurationIdForCategory($idcat, $lang, $client) {
449:     global $cfg, $db;
450: 
451:     // Retrieve template configuration id
452:     $sql = "SELECT a.idtplcfg AS idtplcfg FROM `%s` AS a, `%s` AS b WHERE a.idcat = %d AND "
453:          . "a.idlang = %d AND b.idcat = a.idcat AND b.idclient = %d";
454:     $sql = $db->prepare($sql, $cfg['tab']['cat_lang'], $cfg['tab']['cat'], $idcat, $lang, $client);
455:     $db->query($sql);
456: 
457:     return ($db->nextRecord()) ? $db->f('idtplcfg') : NULL;
458: }
459: