I have to migrate TYPO3 6.2 websites to 8.7. Some websites use custom pibase extensions, do I need to redevelop them with Extbase ?
All previous answers have been correct but some words from a TYPO3 core team member: There are no plans to drop the support of "pibase" in the core. It is absolutely ok to use that API even though it does not provide much help to developers.
However I recommend to use at least fluid standalone to be able to create nice templates without all those ### stuff.
you don't need to redevelop these extensions, but you might need to change the call to core functions.
In 6.2 you still could use the old class names like t3lib.
These class names are available only with compatibility layer (together with a lot of delay).
For the future you need to use namespaces (and the correct new classes). You also should use namespaces for your own classes.
Depending on your used functions you might need to replace some calls with the newer functions as some functions got deprecated meanwhile.
You don't need to redevelop these extensions.
Just you need to change some TYPO3 core function like t3lib_div t3lib_BEfunc t3lib_parsehtml t3lib_extMgm and more..
Please see complete example here : See more details
Related
Since Typo3 v10, one should use the context API instead of $GLOBALS['TSFE'].
I read this (https://docs.typo3.org/m/typo3/reference-coreapi/10.4/en-us/ApiOverview/Context/Index.html), but can not understand how to come from here to GLOBALS['TSFE']->id...
I simply do not understand how...
Can someone post an example how to get $GLOBALS['TSFE']->id?
In all current TYPO3 versions $GLOBALS['TSFE']->id is still available and the way to go in most cases.
There has been a change in where it's initialized though, so it might be it's not available (anymore) in your case. If that's the case you'll have to add more information about where you want to use it.
For a new extension in Typo3 i need to know how the functionality seen in this picture can be realised in TCA and how to implement it? It would be great to know how it is called. Icant find it anywhere and i think this is a core functionality because the same feature is used in TemplaVoila too. The current installed Typo3 Version is 4.5 (LTS). I have no idea how to start. Please help me.
best regards
flow
The feature is called Inline Relational Record Editing, short IRRE. The TCA-type is "inline".
I am searching for a good source for understanding the userFunc = tx_extbase_core_bootstrap->run magic incantation.
The seemingly autoritative documentation on forge (http://forge.typo3.org/projects/typo3v4-mvc/wiki/Documentation) starts off with non-functional links ("400 - Invalid action parameter" from git.typo3.org) and seems dated, pointing to articles with the newest date in late 2011.
The API doc at http://typo3.org/api/typo3cms/class_t_y_p_o3_1_1_c_m_s_1_1_extbase_1_1_core_1_1_bootstrap.html#a890c7dde66b4a9462983759de4d9576a is rather sparse as to what the "TS configuration array" might contain. It also seems a little odd to list two sets of arguments and two different return informations, it is almost as if two methods were concatenated in one entry. Trying to follow the source code leads to initilializeConfiguration where it seems to hand over control to some general routine.
There is a revision e6c08008 committed "over a year ago" which claims to have updated the docs to the current URL, which is supposed to be http://api.typo3.org/extbase/current/ - but this only leads to a page with lots of classes and blank frames with no content. This is the URL that is offered in my copy downloaded a few months ago as well.
So: Where might it be that I can learn how to utilize this extbase bootstrap run method? Source code is fine, but I am not able to determine where the config is actually digested.
The Extbase bootstrap can be used to use an Extbase plugin via TypoScript. Which configuration is needed to achieve that (using TYPO3 6.x) can be seen here:
Assign plugin in typoscript
This may also be a source - the Fluid and Extbase book, unfortunately not all chapters are translated to english yet (and it is based on TYPO3 4.x):
http://docs.typo3.org/typo3cms/ExtbaseGuide/singlehtml/#bootstrap
This is covering the SwitchableControllerActions:
http://forge.typo3.org/projects/typo3v4-mvc/wiki/Dispatcher_rework
Use Extbase Plugin in TypoScript
What is to be understood by "Fluid powered TYPO3" (as stated by http://fedext.net/) and what are its benefits for the integration?
Are there other modern templating approaches for TYPO3 6.x that would be best practice to switch to now?
I don't understand the different systems that are around at the moment and I need some clarification.
The background of the question, what I am looking for:
Don't use Templavoila
Keep it simple, little coding overhead
That's why I still use markers!
Enable Custom content items in the backend like FCEs in TV
Foment "structured content" approach in TYPO3: predefined inputs and detailed rendering vs. "Anything goes" like in css_styled_content
And what about https://github.com/Ecodev/bootstrap_package ? Is it recommendable?
Although this question is fairly old by now (I didn't see it until now) and you probably already found out more about what Fluid Powered TYPO3 offers:
The features you ask for (TV-style FCEs, low coding overhead and especially the last one which is more regarding the process than the tool) are exactly what Fluid Powered TYPO3 is all about:
We provide simple ways to get page and content templates recognised by TYPO3 and made available to use by the site's content editors.
We use a common API approach (which is built on top of TYPO3's TCA/TCEforms) which you can use in both page and content templates to add custom fields (as an example: create a field to set the color of the site's header or configure a content element to have a blue background, and so on).
We use Fluid which is (as Michael already stated) a superb rendering engine.
But this is just a small part of the possibilities you have with the extensions (currently there are 20 - no, really, 20) which all provide different feature sets: there's the ViewHelper library VHS which you can use with any type of Fluid template, there's fluidpages, fluidcontent and fluidbackend which lets you place template files in a recognised path and made available to use without further hassle, there's view which lets you use overlay paths for plugin templateRootPaths (example: override only one template file from EXT:news without having to copy all template files from EXT:news). There's builder which can generate extensions, ViewHelper unit test classes, test your Fluid templates and more. There's tool which contains a range of Extbase Service-type classes that you can use in your own Extbase plugins. There's fluidwidget which is a great base for complex Fluid Widgets. You've got side utilities like *extbase_realurl* which can generate automatic realurl rules for any Extbase plugin. And there's schemaker which can let you create your own XSD schemas for your own ViewHelpers (or any version of for example fluid itself, or VHS, or flux etc.).
And there is more than this. Simply put, we offer you every tool you need to create every type of site, template or plugin. Our tools have one primary focus: efficiency.
It sounds like a huge mouthful but it isn't as complicated as it seems. Usually you will start off by using three or four of the extensions and their purpose is quite clear: Flux allows you to add the form fields which content editors use to configure content, pages and plugin instances; VHS provides a large number of multipurpose VieWHelpers to use whenever you need more than just those included with Fluid. And then one or both of fluidcontent and fluidpages which are -very- simple in that all they do is allow you to use template files as content elements or page templates.
There is quite a bit to get used to - this is true of any framework - but we spent a lot of effort on making the API the same across the line, which means anything you learn in one context (for example page templates) you can use in others (like content templates and backend modules).
If you want to save time and be consistent when creating content, pages and plugins, Fluid Powered TYPO3 (which is the umbrella name for all those twenty-something extensions) will do exactly that for you.
I can recommend taking a few minutes to read the new tour I published on fedext.net - the URL is http://fedext.net/tour/form-api.html - it primarily speaks to developers who've touched on Extbase and Fluid earlier, but even if you're used to "just" working with TYPO3 the main points should make sense.
And if you need more details than this you are welcome to find us on Github or on IRC (#typo3 on Freenet). We're always happy to help new users.
Cheers,
Claus aka. NamelessCoder
Fluid offers a much cleaner approach of dividing template logic from display logic and controller logic. Your result will be structured much better when using the possibilities fluid and the mentioned extensions like vhs provide (like layouts and partials).
The usage is actually very simple but can still be combined with the oldschool marker approach (you can do things like <f:cObject typoscriptObjectPath="lib.marks.MAIN-MENU"/>). If you need more flexibility in the backend like in TV, you (of course) have to code some things yourself.
The easiest way is to use an extension which is created by modelling it in the backend to fit your custom needs, but you can also adjust the rendering of pages and/or default content elements by using typoscript and the fields given (like pages.layout, header_layout, section_frame and so on).
So you always have the choice between detailed inputs (extbase extension objects) and using the TYPO3 default things like page properties and RTE config in combination with some typoscript magic (css_styled_content).
So as a conclusion I strongly recommend using fluid templates and additional extensions like vhs as they provide a lot of (additional) power and reusable templates while still let you use markers if you want to. Personally, I also prefer to enhance or limit the RTE in the backend in favor of writing too much special code for an FCE-like result.
BTW: There are very good autocomplete features by using the DTDs/XSDs from fedext.net in your IDE which made my template programming much faster (like 25%).
SOLUTION
Inline Relational Record Editing is the answer. Handy stuff.
For Documentation
:)
QUESTION
I created a front-end plugin using extension builder in TYPO3 6.1.0. For this plugin, extension builder of course generates few default forms in the backend. However, my intention is to have the forms customized. My plugin has 3 tables related it and all these have to be integrated to be inputted from one common form, than having individual forms, which is not ideal.
Do I configure my TCA stuff for this ?.. If so, please suggest me some good tutorials on that.
Or will using FlexForm do the trick ?...also please suggest some good tutorials.
I also checked out Flux, but did not quite understand the architecture of it.
Thank You :)
EDIT:
I want forms to give the user to fill in records. Lets say I have an extension for creating Calendar Events. I need a form, in the TYPO3 backend, through which an administrator can add events and its details.