This project does not seem to handle request data directly as such no vulnerable execution paths were found.
include
, or for example
via PHP's auto-loading mechanism.
These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
1 | <?php |
||
2 | |||
3 | namespace Victoire\Bundle\SeoBundle\Entity; |
||
4 | |||
5 | use Doctrine\ORM\Mapping as ORM; |
||
6 | use Knp\DoctrineBehaviors\Model\Translatable\Translatable; |
||
7 | use Symfony\Component\PropertyAccess\PropertyAccess; |
||
8 | use Symfony\Component\Validator\Constraints as Assert; |
||
9 | use Victoire\Bundle\CoreBundle\Entity\View; |
||
10 | |||
11 | /** |
||
12 | * PageSeo. |
||
13 | * |
||
14 | * @ORM\Table("vic_page_seo") |
||
15 | * @ORM\Entity() |
||
16 | */ |
||
17 | class PageSeo |
||
18 | { |
||
19 | use \Gedmo\Timestampable\Traits\TimestampableEntity; |
||
20 | use Translatable; |
||
21 | |||
22 | /** |
||
23 | * @var int |
||
24 | * |
||
25 | * @ORM\Column(name="id", type="integer") |
||
26 | * @ORM\Id |
||
27 | * @ORM\GeneratedValue(strategy="AUTO") |
||
28 | */ |
||
29 | protected $id; |
||
30 | |||
31 | /** |
||
32 | * @var string |
||
33 | * |
||
34 | * @deprecated Remove Doctrine mapping |
||
35 | * |
||
36 | * @ORM\Column(name="meta_title", type="string", nullable=true) |
||
37 | * @Assert\Length(max = 65) |
||
38 | */ |
||
39 | protected $metaTitle; |
||
40 | |||
41 | /** |
||
42 | * @var string |
||
43 | * |
||
44 | * @deprecated Remove Doctrine mapping |
||
45 | * |
||
46 | * @ORM\Column(name="meta_description", type="string", length=255, nullable=true) |
||
47 | * @Assert\Length(max = 155) |
||
48 | */ |
||
49 | protected $metaDescription; |
||
50 | |||
51 | /** |
||
52 | * @var string |
||
53 | * |
||
54 | * @deprecated Remove Doctrine mapping |
||
55 | * |
||
56 | * @ORM\Column(name="rel_author", type="string", length=255, nullable=true) |
||
57 | */ |
||
58 | protected $relAuthor; |
||
59 | |||
60 | /** |
||
61 | * @var string |
||
62 | * |
||
63 | * @deprecated Remove Doctrine mapping |
||
64 | * |
||
65 | * @ORM\Column(name="rel_publisher", type="string", length=255, nullable=true) |
||
66 | */ |
||
67 | protected $relPublisher; |
||
68 | |||
69 | /** |
||
70 | * @var string |
||
71 | * |
||
72 | * @deprecated Remove Doctrine mapping |
||
73 | * |
||
74 | * @ORM\Column(name="ogTitle", type="string", length=255, nullable=true) |
||
75 | */ |
||
76 | protected $ogTitle; |
||
77 | |||
78 | /** |
||
79 | * @var string |
||
80 | * |
||
81 | * @deprecated Remove Doctrine mapping |
||
82 | * |
||
83 | * @ORM\Column(name="ogType", type="string", length=255, nullable=true) |
||
84 | */ |
||
85 | protected $ogType; |
||
86 | |||
87 | /** |
||
88 | * @var string |
||
89 | * |
||
90 | * @deprecated Remove Doctrine mapping |
||
91 | * |
||
92 | * @ORM\ManyToOne(targetEntity="\Victoire\Bundle\MediaBundle\Entity\Media") |
||
93 | * @ORM\JoinColumn(name="ogImage_id", referencedColumnName="id", onDelete="SET NULL") |
||
94 | */ |
||
95 | protected $ogImage; |
||
96 | |||
97 | /** |
||
98 | * @var string |
||
99 | * |
||
100 | * @deprecated Remove Doctrine mapping |
||
101 | * |
||
102 | * @ORM\Column(name="ogUrl", type="string", length=255, nullable=true) |
||
103 | */ |
||
104 | protected $ogUrl; |
||
105 | |||
106 | /** |
||
107 | * @var text |
||
108 | * |
||
109 | * @deprecated Remove Doctrine mapping |
||
110 | * |
||
111 | * @ORM\Column(name="ogDescription", type="text", nullable=true) |
||
112 | */ |
||
113 | protected $ogDescription; |
||
114 | |||
115 | /** |
||
116 | * @var string |
||
117 | * |
||
118 | * @deprecated Remove Doctrine mapping |
||
119 | * |
||
120 | * @ORM\Column(name="fbAdmins", type="string", length=255, nullable=true) |
||
121 | */ |
||
122 | protected $fbAdmins; |
||
123 | |||
124 | /** |
||
125 | * @var string |
||
126 | * |
||
127 | * @deprecated Remove Doctrine mapping |
||
128 | * |
||
129 | * @ORM\Column(name="twitterCard", type="string", length=255, nullable=true) |
||
130 | */ |
||
131 | protected $twitterCard = 'summary'; |
||
132 | |||
133 | /** |
||
134 | * @var string |
||
135 | * |
||
136 | * @deprecated Remove Doctrine mapping |
||
137 | * |
||
138 | * @ORM\Column(name="twitterUrl", type="string", length=255, nullable=true) |
||
139 | * @Assert\Length(max = 15) |
||
140 | */ |
||
141 | protected $twitterUrl; |
||
142 | |||
143 | /** |
||
144 | * @var string |
||
145 | * |
||
146 | * @deprecated Remove Doctrine mapping |
||
147 | * |
||
148 | * @ORM\Column(name="twitterCreator", type="string", length=255, nullable=true) |
||
149 | * @Assert\Length(max = 15) |
||
150 | */ |
||
151 | protected $twitterCreator; |
||
152 | |||
153 | /** |
||
154 | * @var string |
||
155 | * |
||
156 | * @deprecated Remove Doctrine mapping |
||
157 | * |
||
158 | * @ORM\Column(name="twitterTitle", type="string", length=255, nullable=true) |
||
159 | * @Assert\Length(max = 70) |
||
160 | */ |
||
161 | protected $twitterTitle; |
||
162 | |||
163 | /** |
||
164 | * @var string |
||
165 | * |
||
166 | * @deprecated Remove Doctrine mapping |
||
167 | * |
||
168 | * @ORM\Column(name="twitterDescription", type="string", length=255, nullable=true) |
||
169 | * @Assert\Length(max = 200) |
||
170 | */ |
||
171 | protected $twitterDescription; |
||
172 | |||
173 | /** |
||
174 | * @var string |
||
175 | * |
||
176 | * @deprecated Remove Doctrine mapping |
||
177 | * |
||
178 | * @ORM\ManyToOne(targetEntity="\Victoire\Bundle\MediaBundle\Entity\Media") |
||
179 | * @ORM\JoinColumn(name="twitterImage_id", referencedColumnName="id", onDelete="SET NULL") |
||
180 | */ |
||
181 | protected $twitterImage; |
||
182 | |||
183 | /** |
||
184 | * @var string |
||
185 | * |
||
186 | * @deprecated Remove Doctrine mapping |
||
187 | * |
||
188 | * @ORM\Column(name="schemaPageType", type="string", length=255, nullable=true) |
||
189 | */ |
||
190 | protected $schemaPageType; |
||
191 | |||
192 | /** |
||
193 | * @var string |
||
194 | * |
||
195 | * @deprecated Remove Doctrine mapping |
||
196 | * |
||
197 | * @ORM\Column(name="schemaName", type="string", length=255, nullable=true) |
||
198 | */ |
||
199 | protected $schemaName; |
||
200 | |||
201 | /** |
||
202 | * @var string |
||
203 | * |
||
204 | * @deprecated Remove Doctrine mapping |
||
205 | * |
||
206 | * @ORM\Column(name="schemaDescription", type="string", length=255, nullable=true) |
||
207 | */ |
||
208 | protected $schemaDescription; |
||
209 | |||
210 | /** |
||
211 | * @var string |
||
212 | * |
||
213 | * @deprecated Remove Doctrine mapping |
||
214 | * |
||
215 | * @ORM\ManyToOne(targetEntity="\Victoire\Bundle\MediaBundle\Entity\Media") |
||
216 | * @ORM\JoinColumn(name="schemaImage_id", referencedColumnName="id", onDelete="SET NULL") |
||
217 | */ |
||
218 | protected $schemaImage; |
||
219 | |||
220 | /** |
||
221 | * @var string |
||
222 | * |
||
223 | * @deprecated Remove Doctrine mapping |
||
224 | * |
||
225 | * @ORM\Column(name="meta_robots_index", type="string", length=255, nullable=true) |
||
226 | */ |
||
227 | protected $metaRobotsIndex; |
||
228 | |||
229 | /** |
||
230 | * @var string |
||
231 | * |
||
232 | * @deprecated Remove Doctrine mapping |
||
233 | * |
||
234 | * @ORM\Column(name="meta_robots_follow", type="string", length=255, nullable=true) |
||
235 | */ |
||
236 | protected $metaRobotsFollow; |
||
237 | |||
238 | /** |
||
239 | * @var string |
||
240 | * |
||
241 | * @deprecated Remove Doctrine mapping |
||
242 | * |
||
243 | * @ORM\Column(name="meta_robots_advanced", type="string", length=255, nullable=true) |
||
244 | */ |
||
245 | protected $metaRobotsAdvanced; |
||
246 | |||
247 | /** |
||
248 | * @var bool |
||
249 | * |
||
250 | * @deprecated Remove Doctrine mapping |
||
251 | * |
||
252 | * @ORM\Column(name="sitemap_indexed", type="boolean", nullable=true) |
||
253 | */ |
||
254 | protected $sitemapIndexed; |
||
255 | |||
256 | /** |
||
257 | * @var float |
||
258 | * |
||
259 | * @deprecated Remove Doctrine mapping |
||
260 | * |
||
261 | * @ORM\Column(name="sitemap_priority", type="float", nullable=true) |
||
262 | */ |
||
263 | protected $sitemapPriority; |
||
264 | |||
265 | /** |
||
266 | * @var string |
||
267 | * |
||
268 | * @deprecated Remove Doctrine mapping |
||
269 | * |
||
270 | * @ORM\Column(name="sitemap_changeFreq", type="string", length=20, nullable=true, options={"default" = "monthly"}) |
||
271 | */ |
||
272 | protected $sitemapChangeFreq = 'monthly'; |
||
273 | |||
274 | /** |
||
275 | * @var string |
||
276 | * |
||
277 | * @deprecated Remove Doctrine mapping |
||
278 | * |
||
279 | * @ORM\Column(name="rel_canonical", type="string", length=255, nullable=true) |
||
280 | */ |
||
281 | protected $relCanonical; |
||
282 | |||
283 | /** |
||
284 | * @var string |
||
285 | * |
||
286 | * @deprecated Remove Doctrine mapping |
||
287 | * |
||
288 | * @ORM\Column(name="keyword", type="string", length=255, nullable=true) |
||
289 | */ |
||
290 | protected $keyword; |
||
291 | |||
292 | /** |
||
293 | * @var string |
||
294 | * |
||
295 | * @deprecated Remove Doctrine mapping |
||
296 | * |
||
297 | * @ORM\ManyToOne( |
||
298 | * targetEntity="\Victoire\Bundle\PageBundle\Entity\Page", |
||
299 | * inversedBy="referers", |
||
300 | * cascade={"persist"} |
||
301 | * ) |
||
302 | * @ORM\JoinColumn(name="redirect_to", referencedColumnName="id", onDelete="SET NULL") |
||
303 | */ |
||
304 | protected $redirectTo; |
||
305 | |||
306 | /** |
||
307 | * {@inheritdoc} |
||
308 | */ |
||
309 | public static function getTranslationEntityClass() |
||
310 | { |
||
311 | return '\\Victoire\\Bundle\\SeoBundle\\Entity\PageSeoTranslation'; |
||
312 | } |
||
313 | |||
314 | /** |
||
0 ignored issues
–
show
introduced
by
![]() |
|||
315 | * Set redirectTo w/ proxy. |
||
316 | * |
||
317 | * @param View $redirectTo |
||
318 | * |
||
319 | * @return PageSeo |
||
320 | */ |
||
321 | public function setRedirectTo(View $redirectTo, $locale = null) |
||
322 | { |
||
323 | $this->translate($locale, false)->setRedirectTo($redirectTo); |
||
0 ignored issues
–
show
It seems like
setRedirectTo() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
324 | $this->mergeNewTranslations(); |
||
325 | |||
326 | return $this; |
||
327 | } |
||
328 | |||
329 | /** |
||
330 | * Get redirectTo w/ proxy. |
||
331 | * |
||
332 | * @return string |
||
333 | */ |
||
334 | public function getRedirectTo() |
||
335 | { |
||
336 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getRedirectTo'); |
||
337 | } |
||
338 | |||
339 | /** |
||
0 ignored issues
–
show
|
|||
340 | * Set metaTitle w/ proxy. |
||
341 | * |
||
342 | * @param string $metaTitle |
||
343 | * |
||
344 | * @return PageSeo |
||
345 | */ |
||
346 | public function setMetaTitle($metaTitle, $locale = null) |
||
347 | { |
||
348 | $this->translate($locale, false)->setMetaTitle($metaTitle); |
||
0 ignored issues
–
show
It seems like
setMetaTitle() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
349 | $this->mergeNewTranslations(); |
||
350 | |||
351 | return $this; |
||
352 | } |
||
353 | |||
354 | /** |
||
355 | * Get metaTitle w/ proxy. |
||
356 | * |
||
357 | * @return string |
||
358 | */ |
||
359 | public function getMetaTitle() |
||
360 | { |
||
361 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getMetaTitle'); |
||
362 | } |
||
363 | |||
364 | /** |
||
0 ignored issues
–
show
|
|||
365 | * Set metaDescription w/ proxy. |
||
366 | * |
||
367 | * @param string $metaDescription |
||
368 | * |
||
369 | * @return PageSeo |
||
370 | */ |
||
371 | public function setMetaDescription($metaDescription, $locale = null) |
||
372 | { |
||
373 | $this->translate($locale, false)->setMetaDescription($metaDescription); |
||
0 ignored issues
–
show
It seems like
setMetaDescription() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
374 | $this->mergeNewTranslations(); |
||
375 | |||
376 | return $this; |
||
377 | } |
||
378 | |||
379 | /** |
||
380 | * Get metaDescription w/ proxy. |
||
381 | * |
||
382 | * @return string |
||
383 | */ |
||
384 | public function getMetaDescription() |
||
385 | { |
||
386 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getMetaDescription'); |
||
387 | } |
||
388 | |||
389 | /** |
||
0 ignored issues
–
show
|
|||
390 | * Set relAuthor w/ proxy. |
||
391 | * |
||
392 | * @param string $relAuthor |
||
393 | * |
||
394 | * @return PageSeo |
||
395 | */ |
||
396 | public function setRelAuthor($relAuthor, $locale = null) |
||
397 | { |
||
398 | $this->translate($locale, false)->setRelAuthor($relAuthor); |
||
0 ignored issues
–
show
It seems like
setRelAuthor() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
399 | $this->mergeNewTranslations(); |
||
400 | |||
401 | return $this; |
||
402 | } |
||
403 | |||
404 | /** |
||
405 | * Get relAuthor w/ proxy. |
||
406 | * |
||
407 | * @return string |
||
408 | */ |
||
409 | public function getRelAuthor() |
||
410 | { |
||
411 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getRelAuthor'); |
||
412 | } |
||
413 | |||
414 | /** |
||
0 ignored issues
–
show
|
|||
415 | * Set relPublisher w/ proxy. |
||
416 | * |
||
417 | * @param string $relPublisher |
||
418 | * |
||
419 | * @return PageSeo |
||
420 | */ |
||
421 | public function setRelPublisher($relPublisher, $locale = null) |
||
422 | { |
||
423 | $this->translate($locale, false)->setRelPublisher($relPublisher); |
||
0 ignored issues
–
show
It seems like
setRelPublisher() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
424 | $this->mergeNewTranslations(); |
||
425 | |||
426 | return $this; |
||
427 | } |
||
428 | |||
429 | /** |
||
430 | * Get relPublisher w/ proxy. |
||
431 | * |
||
432 | * @return string |
||
433 | */ |
||
434 | public function getRelPublisher() |
||
435 | { |
||
436 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getRelPublisher'); |
||
437 | } |
||
438 | |||
439 | /** |
||
0 ignored issues
–
show
|
|||
440 | * Set ogTitle w/ proxy. |
||
441 | * |
||
442 | * @param string $ogTitle |
||
443 | * |
||
444 | * @return PageSeo |
||
445 | */ |
||
446 | public function setOgTitle($ogTitle, $locale = null) |
||
447 | { |
||
448 | $this->translate($locale, false)->setOgTitle($ogTitle); |
||
0 ignored issues
–
show
It seems like
setOgTitle() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
449 | $this->mergeNewTranslations(); |
||
450 | |||
451 | return $this; |
||
452 | } |
||
453 | |||
454 | /** |
||
455 | * Get ogTitle w/ proxy. |
||
456 | * |
||
457 | * @return string |
||
458 | */ |
||
459 | public function getOgTitle() |
||
460 | { |
||
461 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getOgTitle'); |
||
462 | } |
||
463 | |||
464 | /** |
||
0 ignored issues
–
show
|
|||
465 | * Set ogType w/ proxy. |
||
466 | * |
||
467 | * @param string $ogType |
||
468 | * |
||
469 | * @return PageSeo |
||
470 | */ |
||
471 | public function setOgType($ogType, $locale = null) |
||
472 | { |
||
473 | $this->translate($locale, false)->setOgType($ogType); |
||
0 ignored issues
–
show
It seems like
setOgType() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
474 | $this->mergeNewTranslations(); |
||
475 | |||
476 | return $this; |
||
477 | } |
||
478 | |||
479 | /** |
||
480 | * Get ogType w/ proxy. |
||
481 | * |
||
482 | * @return string |
||
483 | */ |
||
484 | public function getOgType() |
||
485 | { |
||
486 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getOgType'); |
||
487 | } |
||
488 | |||
489 | /** |
||
0 ignored issues
–
show
|
|||
490 | * Set ogImage w/ proxy. |
||
491 | * |
||
492 | * @param Image $ogImage |
||
493 | * |
||
494 | * @return PageSeo |
||
495 | */ |
||
496 | public function setOgImage($ogImage, $locale = null) |
||
497 | { |
||
498 | $this->translate($locale, false)->setOgImage($ogImage); |
||
0 ignored issues
–
show
It seems like
setOgImage() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
499 | $this->mergeNewTranslations(); |
||
500 | |||
501 | return $this; |
||
502 | } |
||
503 | |||
504 | /** |
||
505 | * Get ogImage w/ proxy. |
||
506 | * |
||
507 | * @return string |
||
508 | */ |
||
509 | public function getOgImage() |
||
510 | { |
||
511 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getOgImage'); |
||
512 | } |
||
513 | |||
514 | /** |
||
0 ignored issues
–
show
|
|||
515 | * Set ogUrl w/ proxy. |
||
516 | * |
||
517 | * @param string $ogUrl |
||
518 | * |
||
519 | * @return PageSeo |
||
520 | */ |
||
521 | public function setOgUrl($ogUrl, $locale = null) |
||
522 | { |
||
523 | $this->translate($locale, false)->setOgUrl($ogUrl); |
||
0 ignored issues
–
show
It seems like
setOgUrl() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
524 | $this->mergeNewTranslations(); |
||
525 | |||
526 | return $this; |
||
527 | } |
||
528 | |||
529 | /** |
||
530 | * Get ogUrl w/ proxy. |
||
531 | * |
||
532 | * @return string |
||
533 | */ |
||
534 | public function getOgUrl() |
||
535 | { |
||
536 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getOgUrl'); |
||
537 | } |
||
538 | |||
539 | /** |
||
0 ignored issues
–
show
|
|||
540 | * Set ogDescription w/ proxy. |
||
541 | * |
||
542 | * @param string $ogDescription |
||
543 | * |
||
544 | * @return PageSeo |
||
545 | */ |
||
546 | public function setOgDescription($ogDescription, $locale = null) |
||
547 | { |
||
548 | $this->translate($locale, false)->setOgDescription($ogDescription); |
||
0 ignored issues
–
show
It seems like
setOgDescription() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
549 | $this->mergeNewTranslations(); |
||
550 | |||
551 | return $this; |
||
552 | } |
||
553 | |||
554 | /** |
||
555 | * Get ogDescription w/ proxy. |
||
556 | * |
||
557 | * @return string |
||
558 | */ |
||
559 | public function getOgDescription() |
||
560 | { |
||
561 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getOgDescription'); |
||
562 | } |
||
563 | |||
564 | /** |
||
0 ignored issues
–
show
|
|||
565 | * Set fbAdmins w/ proxy. |
||
566 | * |
||
567 | * @param string $fbAdmins |
||
568 | * |
||
569 | * @return PageSeo |
||
570 | */ |
||
571 | public function setFbAdmins($fbAdmins, $locale = null) |
||
572 | { |
||
573 | $this->translate($locale, false)->setFbAdmins($fbAdmins); |
||
0 ignored issues
–
show
It seems like
setFbAdmins() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
574 | $this->mergeNewTranslations(); |
||
575 | |||
576 | return $this; |
||
577 | } |
||
578 | |||
579 | /** |
||
580 | * Get fbAdmins w/ proxy. |
||
581 | * |
||
582 | * @return string |
||
583 | */ |
||
584 | public function getFbAdmins() |
||
585 | { |
||
586 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getFbAdmins'); |
||
587 | } |
||
588 | |||
589 | /** |
||
0 ignored issues
–
show
|
|||
590 | * Set twitterCard w/ proxy. |
||
591 | * |
||
592 | * @param string $twitterCard |
||
593 | * |
||
594 | * @return PageSeo |
||
595 | */ |
||
596 | public function setTwitterCard($twitterCard, $locale = null) |
||
597 | { |
||
598 | $this->translate($locale, false)->setTwitterCard($twitterCard); |
||
0 ignored issues
–
show
It seems like
setTwitterCard() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
599 | $this->mergeNewTranslations(); |
||
600 | |||
601 | return $this; |
||
602 | } |
||
603 | |||
604 | /** |
||
605 | * Get twitterCard w/ proxy. |
||
606 | * |
||
607 | * @return string |
||
608 | */ |
||
609 | public function getTwitterCard() |
||
610 | { |
||
611 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getTwitterCard'); |
||
612 | } |
||
613 | |||
614 | /** |
||
0 ignored issues
–
show
|
|||
615 | * Set twitterUrl w/ proxy. |
||
616 | * |
||
617 | * @param string $twitterUrl |
||
618 | * |
||
619 | * @return PageSeo |
||
620 | */ |
||
621 | public function setTwitterUrl($twitterUrl, $locale = null) |
||
622 | { |
||
623 | $this->translate($locale, false)->setTwitterUrl($twitterUrl); |
||
0 ignored issues
–
show
It seems like
setTwitterUrl() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
624 | $this->mergeNewTranslations(); |
||
625 | |||
626 | return $this; |
||
627 | } |
||
628 | |||
629 | /** |
||
630 | * Get twitterUrl w/ proxy. |
||
631 | * |
||
632 | * @return string |
||
633 | */ |
||
634 | public function getTwitterUrl() |
||
635 | { |
||
636 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getTwitterUrl'); |
||
637 | } |
||
638 | |||
639 | /** |
||
0 ignored issues
–
show
|
|||
640 | * Set twitterCreator w/ proxy. |
||
641 | * |
||
642 | * @param string $twitterCreator |
||
643 | * |
||
644 | * @return PageSeo |
||
645 | */ |
||
646 | public function setTwitterCreator($twitterCreator, $locale = null) |
||
647 | { |
||
648 | $this->translate($locale, false)->setTwitterCreator($twitterCreator); |
||
0 ignored issues
–
show
It seems like
setTwitterCreator() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
649 | $this->mergeNewTranslations(); |
||
650 | |||
651 | return $this; |
||
652 | } |
||
653 | |||
654 | /** |
||
655 | * Get twitterCreator w/ proxy. |
||
656 | * |
||
657 | * @return string |
||
658 | */ |
||
659 | public function getTwitterCreator() |
||
660 | { |
||
661 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getTwitterCreator'); |
||
662 | } |
||
663 | |||
664 | /** |
||
0 ignored issues
–
show
|
|||
665 | * Set twitterTitle w/ proxy. |
||
666 | * |
||
667 | * @param string $twitterTitle |
||
668 | * |
||
669 | * @return PageSeo |
||
670 | */ |
||
671 | public function setTwitterTitle($twitterTitle, $locale = null) |
||
672 | { |
||
673 | $this->translate($locale, false)->setTwitterTitle($twitterTitle); |
||
0 ignored issues
–
show
It seems like
setTwitterTitle() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
674 | $this->mergeNewTranslations(); |
||
675 | |||
676 | return $this; |
||
677 | } |
||
678 | |||
679 | /** |
||
680 | * Get twitterTitle w/ proxy. |
||
681 | * |
||
682 | * @return string |
||
683 | */ |
||
684 | public function getTwitterTitle() |
||
685 | { |
||
686 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getTwitterTitle'); |
||
687 | } |
||
688 | |||
689 | /** |
||
0 ignored issues
–
show
|
|||
690 | * Set twitterDescription w/ proxy. |
||
691 | * |
||
692 | * @param string $twitterDescription |
||
693 | * |
||
694 | * @return PageSeo |
||
695 | */ |
||
696 | public function setTwitterDescription($twitterDescription, $locale = null) |
||
697 | { |
||
698 | $this->translate($locale, false)->setTwitterDescription($twitterDescription); |
||
0 ignored issues
–
show
It seems like
setTwitterDescription() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
699 | $this->mergeNewTranslations(); |
||
700 | |||
701 | return $this; |
||
702 | } |
||
703 | |||
704 | /** |
||
705 | * Get twitterDescription w/ proxy. |
||
706 | * |
||
707 | * @return string |
||
708 | */ |
||
709 | public function getTwitterDescription() |
||
710 | { |
||
711 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getTwitterDescription'); |
||
712 | } |
||
713 | |||
714 | /** |
||
0 ignored issues
–
show
|
|||
715 | * Set twitterImage w/ proxy. |
||
716 | * |
||
717 | * @param Image $twitterImage |
||
718 | * |
||
719 | * @return PageSeo |
||
720 | */ |
||
721 | public function setTwitterImage($twitterImage, $locale = null) |
||
722 | { |
||
723 | $this->translate($locale, false)->setTwitterImage($twitterImage); |
||
0 ignored issues
–
show
It seems like
setTwitterImage() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
724 | $this->mergeNewTranslations(); |
||
725 | |||
726 | return $this; |
||
727 | } |
||
728 | |||
729 | /** |
||
730 | * Get twitterImage w/ proxy. |
||
731 | * |
||
732 | * @return string |
||
733 | */ |
||
734 | public function getTwitterImage() |
||
735 | { |
||
736 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getTwitterImage'); |
||
737 | } |
||
738 | |||
739 | /** |
||
0 ignored issues
–
show
|
|||
740 | * Set schemaPageType w/ proxy. |
||
741 | * |
||
742 | * @param string $schemaPageType |
||
743 | * |
||
744 | * @return PageSeo |
||
745 | */ |
||
746 | public function setSchemaPageType($schemaPageType, $locale = null) |
||
747 | { |
||
748 | $this->translate($locale, false)->setSchemaPageType($schemaPageType); |
||
0 ignored issues
–
show
It seems like
setSchemaPageType() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
749 | $this->mergeNewTranslations(); |
||
750 | |||
751 | return $this; |
||
752 | } |
||
753 | |||
754 | /** |
||
755 | * Get schemaPageType w/ proxy. |
||
756 | * |
||
757 | * @return string |
||
758 | */ |
||
759 | public function getSchemaPageType() |
||
760 | { |
||
761 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getSchemaPageType'); |
||
762 | } |
||
763 | |||
764 | /** |
||
0 ignored issues
–
show
|
|||
765 | * Set schemaName w/ proxy. |
||
766 | * |
||
767 | * @param string $schemaName |
||
768 | * |
||
769 | * @return PageSeo |
||
770 | */ |
||
771 | public function setSchemaName($schemaName, $locale = null) |
||
772 | { |
||
773 | $this->translate($locale, false)->setSchemaName($schemaName); |
||
0 ignored issues
–
show
It seems like
setSchemaName() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
774 | $this->mergeNewTranslations(); |
||
775 | |||
776 | return $this; |
||
777 | } |
||
778 | |||
779 | /** |
||
780 | * Get schemaName w/ proxy. |
||
781 | * |
||
782 | * @return string |
||
783 | */ |
||
784 | public function getSchemaName() |
||
785 | { |
||
786 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getSchemaName'); |
||
787 | } |
||
788 | |||
789 | /** |
||
0 ignored issues
–
show
|
|||
790 | * Set schemaDescription w/ proxy. |
||
791 | * |
||
792 | * @param string $schemaDescription |
||
793 | * |
||
794 | * @return PageSeo |
||
795 | */ |
||
796 | public function setSchemaDescription($schemaDescription, $locale = null) |
||
797 | { |
||
798 | $this->translate($locale, false)->setSchemaDescription($schemaDescription); |
||
0 ignored issues
–
show
It seems like
setSchemaDescription() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
799 | $this->mergeNewTranslations(); |
||
800 | |||
801 | return $this; |
||
802 | } |
||
803 | |||
804 | /** |
||
805 | * Get schemaDescription w/ proxy. |
||
806 | * |
||
807 | * @return string |
||
808 | */ |
||
809 | public function getSchemaDescription() |
||
810 | { |
||
811 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getSchemaDescription'); |
||
812 | } |
||
813 | |||
814 | /** |
||
0 ignored issues
–
show
|
|||
815 | * Set schemaImage w/ proxy. |
||
816 | * |
||
817 | * @param Image $schemaImage |
||
818 | * |
||
819 | * @return PageSeo |
||
820 | */ |
||
821 | public function setSchemaImage($schemaImage, $locale = null) |
||
822 | { |
||
823 | $this->translate($locale, false)->setSchemaImage($schemaImage); |
||
0 ignored issues
–
show
It seems like
setSchemaImage() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
824 | $this->mergeNewTranslations(); |
||
825 | |||
826 | return $this; |
||
827 | } |
||
828 | |||
829 | /** |
||
830 | * Get schemaImage w/ proxy. |
||
831 | * |
||
832 | * @return string |
||
833 | */ |
||
834 | public function getSchemaImage() |
||
835 | { |
||
836 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getSchemaImage'); |
||
837 | } |
||
838 | |||
839 | /** |
||
0 ignored issues
–
show
|
|||
840 | * Set metaRobotsIndex w/ proxy. |
||
841 | * |
||
842 | * @param string $metaRobotsIndex |
||
843 | * |
||
844 | * @return PageSeo |
||
845 | */ |
||
846 | public function setMetaRobotsIndex($metaRobotsIndex, $locale = null) |
||
847 | { |
||
848 | $this->translate($locale, false)->setMetaRobotsIndex($metaRobotsIndex); |
||
0 ignored issues
–
show
It seems like
setMetaRobotsIndex() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
849 | $this->mergeNewTranslations(); |
||
850 | |||
851 | return $this; |
||
852 | } |
||
853 | |||
854 | /** |
||
855 | * Get metaRobotsIndex w/ proxy. |
||
856 | * |
||
857 | * @return string |
||
858 | */ |
||
859 | public function getMetaRobotsIndex() |
||
860 | { |
||
861 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getMetaRobotsIndex'); |
||
862 | } |
||
863 | |||
864 | /** |
||
0 ignored issues
–
show
|
|||
865 | * Set metaRobotsFollow w/ proxy. |
||
866 | * |
||
867 | * @param string $metaRobotsFollow |
||
868 | * |
||
869 | * @return PageSeo |
||
870 | */ |
||
871 | public function setMetaRobotsFollow($metaRobotsFollow, $locale = null) |
||
872 | { |
||
873 | $this->translate($locale, false)->setMetaRobotsFollow($metaRobotsFollow); |
||
0 ignored issues
–
show
It seems like
setMetaRobotsFollow() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
874 | $this->mergeNewTranslations(); |
||
875 | |||
876 | return $this; |
||
877 | } |
||
878 | |||
879 | /** |
||
880 | * Get metaRobotsFollow w/ proxy. |
||
881 | * |
||
882 | * @return string |
||
883 | */ |
||
884 | public function getMetaRobotsFollow() |
||
885 | { |
||
886 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getMetaRobotsFollow'); |
||
887 | } |
||
888 | |||
889 | /** |
||
0 ignored issues
–
show
|
|||
890 | * Set metaRobotsAdvanced w/ proxy. |
||
891 | * |
||
892 | * @param string $metaRobotsAdvanced |
||
893 | * |
||
894 | * @return PageSeo |
||
895 | */ |
||
896 | public function setMetaRobotsAdvanced($metaRobotsAdvanced, $locale = null) |
||
897 | { |
||
898 | $this->translate($locale, false)->setMetaRobotsAdvanced($metaRobotsAdvanced); |
||
0 ignored issues
–
show
It seems like
setMetaRobotsAdvanced() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
899 | $this->mergeNewTranslations(); |
||
900 | |||
901 | return $this; |
||
902 | } |
||
903 | |||
904 | /** |
||
905 | * Get metaRobotsAdvanced w/ proxy. |
||
906 | * |
||
907 | * @return string |
||
908 | */ |
||
909 | public function getMetaRobotsAdvanced() |
||
910 | { |
||
911 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getMetaRobotsAdvanced'); |
||
912 | } |
||
913 | |||
914 | /** |
||
0 ignored issues
–
show
|
|||
915 | * Set sitemapIndexed w/ proxy. |
||
916 | * |
||
917 | * @param bool $sitemapIndexed |
||
918 | * |
||
919 | * @return PageSeo |
||
920 | */ |
||
921 | public function setSitemapIndexed($sitemapIndexed, $locale = null) |
||
922 | { |
||
923 | $this->translate($locale, false)->setSitemapIndexed($sitemapIndexed); |
||
0 ignored issues
–
show
It seems like
setSitemapIndexed() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
924 | $this->mergeNewTranslations(); |
||
925 | |||
926 | return $this; |
||
927 | } |
||
928 | |||
929 | /** |
||
930 | * Get sitemapIndexed. |
||
931 | * |
||
932 | * @return bool |
||
933 | */ |
||
934 | public function isSitemapIndexed() |
||
935 | { |
||
936 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'isSitemapIndexed'); |
||
937 | } |
||
938 | |||
939 | /** |
||
0 ignored issues
–
show
|
|||
940 | * Set sitemapPriority w/ proxy. |
||
941 | * |
||
942 | * @param float $sitemapPriority |
||
943 | * |
||
944 | * @return PageSeo |
||
945 | */ |
||
946 | public function setSitemapPriority($sitemapPriority, $locale = null) |
||
947 | { |
||
948 | $this->translate($locale, false)->setSitemapPriority($sitemapPriority); |
||
0 ignored issues
–
show
It seems like
setSitemapPriority() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
949 | $this->mergeNewTranslations(); |
||
950 | |||
951 | return $this; |
||
952 | } |
||
953 | |||
954 | /** |
||
955 | * Get sitemapPriority w/ proxy. |
||
956 | * |
||
957 | * @return float |
||
958 | */ |
||
959 | public function getSitemapPriority() |
||
960 | { |
||
961 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getSitemapPriority'); |
||
962 | } |
||
963 | |||
964 | /** |
||
0 ignored issues
–
show
|
|||
965 | * Set sitemapChangeFreq w/ proxy. |
||
966 | * |
||
967 | * @param float $sitemapChangeFreq |
||
968 | * |
||
969 | * @return PageSeo |
||
970 | */ |
||
971 | public function setSitemapChangeFreq($sitemapChangeFreq, $locale = null) |
||
972 | { |
||
973 | $this->translate($locale, false)->setSitemapChangeFreq($sitemapChangeFreq); |
||
0 ignored issues
–
show
It seems like
setSitemapChangeFreq() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
974 | $this->mergeNewTranslations(); |
||
975 | |||
976 | return $this; |
||
977 | } |
||
978 | |||
979 | /** |
||
980 | * Get sitemapChangeFreq w/ proxy. |
||
981 | * |
||
982 | * @return float |
||
983 | */ |
||
984 | public function getSitemapChangeFreq() |
||
985 | { |
||
986 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getSitemapChangeFreq'); |
||
987 | } |
||
988 | |||
989 | /** |
||
0 ignored issues
–
show
|
|||
990 | * Set relCanonical w/ proxy. |
||
991 | * |
||
992 | * @param string $relCanonical |
||
993 | * |
||
994 | * @return PageSeo |
||
995 | */ |
||
996 | public function setRelCanonical($relCanonical, $locale = null) |
||
997 | { |
||
998 | $this->translate($locale, false)->setRelCanonical($relCanonical); |
||
0 ignored issues
–
show
It seems like
setRelCanonical() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
999 | $this->mergeNewTranslations(); |
||
1000 | |||
1001 | return $this; |
||
1002 | } |
||
1003 | |||
1004 | /** |
||
1005 | * Get relCanonical w/ proxy. |
||
1006 | * |
||
1007 | * @return string |
||
1008 | */ |
||
1009 | public function getRelCanonical() |
||
1010 | { |
||
1011 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getRelCanonical'); |
||
1012 | } |
||
1013 | |||
1014 | /** |
||
1015 | * Set keyword w/ proxy. |
||
1016 | * |
||
1017 | * @param string $keyword |
||
1018 | * @param null $locale |
||
1019 | * |
||
1020 | * @return PageSeo |
||
1021 | */ |
||
1022 | public function setKeyword($keyword, $locale = null) |
||
1023 | { |
||
1024 | $this->translate($locale, false)->setKeyword($keyword); |
||
0 ignored issues
–
show
It seems like
setKeyword() must be provided by classes using this trait. How about adding it as abstract method to this trait?
This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable {
public function equalIds(Idable $other) {
return $this->getId() === $other->getId();
}
}
The trait Adding the ![]() |
|||
1025 | $this->mergeNewTranslations(); |
||
1026 | |||
1027 | return $this; |
||
1028 | } |
||
1029 | |||
1030 | /** |
||
1031 | * Get keyword w/ proxy. |
||
1032 | * |
||
1033 | * @return string |
||
1034 | */ |
||
1035 | public function getKeyword() |
||
1036 | { |
||
1037 | return PropertyAccess::createPropertyAccessor()->getValue($this->translate(null, false), 'getKeyword'); |
||
1038 | } |
||
1039 | } |
||
1040 |