Datasets:

gorkemsevinc
/

european-language-grid

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 5.64k rows

text; stringlengths 5 32.6k
a soy portlet is an extension of liferay's mvc portlet framework. access to all the mvc portlet functionality you are familiar with, plus the added bonus of using soy templates for writing your front-end. an easy templating language that also lets you use metaljs components. all these benefits and more, soy portlets can be a good front-end tool to have you can learn about liferay mvc portlets in the creating an mvc portlet this section covers how to implement a soy portlet.;;
when using liferay's mvc framework, you can create resource urls in your jsps to retrieve images, xml, or any other kind of resource from a liferay instance. resource url then invokes the corresponding mvc resource command class mvcresourcecommand that processes the resource request and response first, use the tag to create the resource url in a jsp. for example, the login portlet's file defines the following resource url for retrieving a captcha image during when the resource url is triggered, the matching mvcresourcecommand class processes the resource request and response. the latter may save you time, since it already implements mvcresourcecommand also, it's a good idea to name your mvcresourcecommand class after the resource it handles, and suffix it with mvcresourcecommand. resource command class matching the preceding captcha resource url in the login in an application with several mvc command classes, this will help differentiate them your mvcresourcecommand class must also have a annotation like set the property url to your portlet's internal id, and the property url to the value of the id property in your jsp's matching resourceurl. to register the component in the osgi container as using the mvcresourcecommand class, you must set the service as a real-world example, consider the login portlet's captchamvcresourcecommand class find this class in the liferay source code in the annotation, note that url has two different this lets multiple portlets use the same component. the portlet ids are defined as constants in the also note that the url property setting logincaptcha matches the resourceurl's id setting shown earlier in this tutorial, and that the service property is set to url the captchamvcresourcecommand class implements the mvcresourcecommand interface with only a single method serveresource. resource request and response via the url.resourcerequest and though you don't have to create such a helper class, doing so often simplifies your code now you know how to use mvcresourcecommand to process resources in your;;
if you're here, that means you know that mvcrendercommand s are used to respond to portlet render urls, and you want to know how to create and use mvc render if you just want to learn about liferay's mvc portlet framework in general, that information is in a separate article to use mvc render commands, you need these things what is it you want to do when a portlet render url is invoked? mvcrendercommandname parameter, direct the request to an mvcrendercommand some mvcrendercommand s will simply render a particular jsp. sometimes you'll want to add logic to render a certain jsp based on one or more if there's an error caught following the call to url in the code above, the url is rendered. if the call is returned without an exception being caught, url is rendered how does a request get directed to your mvc render command? you can generate a render url for your portlet using the to invoke your mvc render command from the render url, you need to specify the parameter mvcrendercommandname with the same value as your for example, you can create a url that directs the user to a page with a form for editing an entry like this in a jsp now the request will contain a parameter named mvcrendercommandname. the proper mvc render command, the osgi runtime needs to have a url property with a matching value in order to respond to a particular render url, you need an mvcrendercommand component that with two properties using the above properties as an example, any portlet render url for the portlet that includes a parameter called mvcrendercommand with the value helloeditentry will be handled by this mvcrendercommand the component must also publish a url service to the osgi here's a basic component that publishes an mvc render command one command can be used by one portlet, as the example above shows. one command can be used for multiple portlets by adding more url entries in the property list. can invoke the mvc command class by adding more url entries. you're really feeling wild, you can specify multiple portlets and multiple command urls in the same command component, like this as you can see, mvc render commands are flexible and very easy to implement;;
liferay's mvc framework lets you split your portlet's action methods into this can be very helpful in portlets that have many actions. each action url in your portlet's jsps then calls the appropriate action class first, use the tag to create the action url in your jsp. for example, the edit blog entry action in liferay's blogs app is defined in the when the action url is triggered, the matching action class processes the implement the action by creating a class that implements the to avoid writing oodles of boilerplate code, your mvcactioncommand class should extend the basemvcactioncommand instead of implementing mvcactioncommand directly. class already implements mvcactioncommand and provides many useful method naming your mvcactioncommand class after the action it for example, if your action edits some kind of entry, you could name its class editentrymvcactioncommand your mvcactioncommand class must also have a annotation like the set the property url to your portlet's internal id, and the property url to the value of the name property in to register the component in the osgi container as using the mvcactioncommand class, you must set the service property to for example, this is the annotation for the blogs app's editentrymvcactioncommand class note that you can use multiple url values to indicate the component works with multiple portlets in your mvcactioncommand class, process the action by overriding the this method takes url.actionrequest and url.actionresponse parameters that you can your mvcactioncommand class should also contain any other code required to implement your action. mvcactioncommand class, see the blogs app's editentrymvcactioncommand;;
"you're convinced that liferay's mvc framework is right for you, and you want to learn how to configure it along the way you'll want to know how to call services from your controller and how to pass information from the view layer to the controller keep in mind that you can take two paths with your liferay mvc portlet if you have a small application that won't be heavy on controller logic maybe just a couple of action methods, you can put all your controller code in the -portlet class. needs lots of actions, complex render logic to implement, or maybe even some resource serving code, consider breaking the controller into mvc action command classes, mvc render command classes, and mvc resource command classes in this tutorial you'll learn to implement a liferay mvc portlet with all the controller code in the -portlet class as a naming convention, the module with your controller code and view layer is a very basic web module might look of course you're not tied to the use of gradle or bndtools to build your however, you do need a jar with the proper osgi headers defined, which is easily done if you provide a url file. built with maven and gradle, you can check out the tutorial on at a minimum, you should specify the bundle symbolic name and the bundle version providing a human readable bundle name is also if you don't specify a bundle-symbolicname, one will be generated from the project's directory path, which is suitable for many cases. bundle symbolic name yourself, it's a nice convention to use the root package name as the bundle symbolic name using the osgi declarative services component model makes it easy to publish service implementations to the osgi runtime. in this case an implementation of the url.portlet service must be published. annotation in the portlet class is itself an extension of url.portlet, you've provided the right implementation. component needs to be fleshed out with some properties some of those properties might look familiar to you if you've developed liferay mvc portlets before liferay dxp 7.0. that's because they correspond with the xml attributes you used to specify in url, url, to find a list of all the liferay-specific attributes you can specify as properties in your portlet components, check out this is still maintained as a dtd to keep compatibility with the jsr-168 and consider the element from the above link as an example. specify that property in your component, use this syntax in your property list the properties namespaced with url.... are elements of the also note that it is possible to create nested categories using the categories is to write out the category path starting with the root and separating each category in descending order by the use of . liferay's dtd files can be found you can publish this portlet component, but it doesn't do anything yet. implement the controller code next in mvc, your controller receives requests from the front end, and it receives it's responsible for sending that data to the right front end view so it can be displayed to the user, and it's responsible for taking data the user entered in the front end and passing it to the right back for this reason, it needs a way to process requests from the front end and respond to them appropriately, and it needs a way to determine the appropriate front end view to pass data back to the user for data coming from the user to the back end, liferay's mvc portlet framework offers you two ways to do this. one of these is designed for smaller applications, and the other is designed for larger applications. learn about processing requests in smaller applications. learn about how data is rendered from the back end to the user. requests in larger applications, see the tutorials mvc action command, but read these after you finish this one, so you can understand how the whole if you have a small application, you can implement all your controller code in your portlet class the same one you annotated with , which acts as for processing requests, you use action methods. here's what an action method might look like in this action method, the url.actionrequest object is used to retrieve two pieces of information that are needed to call the addguestbook service, which is the point of the method. is used to store a success message. if an exception is thrown, it's caught, and is used to store the exception message. setrenderparameter method on the actionresponse. url if a guestbook could not be added, by setting the mvcpath this parameter is a convention in liferay's mvcportlet framework that denotes the next view that should be displayed to the user so what might a render method look like? first, note that implementing render logic might not be necessary at all. note the init-param properties you set in with these, you're directing the default rendering to your url. template-path property tells the mvc framework where your jsp files live. the above example, means that the jsp files are located in your project's that's why it's important to follow liferay's standard folder structure, outlined above. here's the path of a hypothetical web in this case, the url file is found at and that's the default view of the application. called, the initialization parameters you specify are read and used to direct throughout the controller, you can render a different view jsp file by setting the render parameter mvcpath, like this in some cases, the uses of initialization parameters and render parameters obviates the need for additional render logic. however, it's often necessary to provide additional render logic. to do this, override the render method. with render logic, you're providing the view layer with information to display the data properly to the user. in this case, there's some information needed at the outset, and then there's some logic in the if statements that determine if there are any guestbooks that can be displayed. if there are guestbooks in the database, the id that's first in the list retrieved via the getguestbooks method should be this is accomplished by passing the appropriate id to the renderrequest using the setattirbute method. executed before the default render method, the method concludes by calling note are you wondering how to call service builder services in liferay dxp 7.0? refer to the tutorial on finding and invoking liferay services for a more detailed explanation. in short, obtain a reference to the service by annotating a setter method with the declarative services annotation and set the service object as a private variable once done, you can call the service's methods in the portlet class's render method action methods, and even in your jsps, you can use a handy utility class called to retrieve parameters from an actionrequest or a renderrequest in the above example, the parameter was set into an action request in a jsp you can also set attributes into the request using the method to read the attribute in a jsp, use the method to set parameters into the response in your controller code, you can use the passing information back and forth from your view and controller is important, but there's more to the view layer than that you now know how to extend liferay's mvcportlet to write controller code and register a component in the osgi runtime. you also need a view layer, of course, to guide your app's styling so it matches liferay's. about some of liferay's taglibs, refer to the tutorial applying lexicon styles to your app. this section will briefly cover how to get your view layer working, from organizing your imports in one jsp file, to configuring urls that direct processing to your code in the portlet class it's a good practice to put all your java imports, tag library declarations, and variable initializations into an url file. create your web module, these taglib declarations and initializations are automatically added to your url make sure you include the url in your other jsp files you can, if necessary, write java code in your jsps using scriptlets. an attribute into the request in your controller you can reference it in your jsp by calling the url to construct a url that calls the render method of your controller, you can you create a variable to hold the generated url with the var attribute. then you can set any parameters you need using the portletparam tag. mvcpath parameter is used to direct to another jsp. you can then use the var value to invoke the url in your jsp code, perhaps in a button or navigation bar item action urls can be similarly created with the portlet taglib the name of the action url should match the action method name in your portlet class; that's all liferay's mvc framework needs in order to know that the action method of the same name should run when this action url is invoked. var attribute like you did the var attribute in the render url; to call the action url in your jsp code, whether it's in an icon, a button, or somewhere as you can see, with liferay mvc it's pretty easy to make your controller talk this tutorial should get you up and running with a liferay mvc web module, but there's more to know about creating an app in liferay. here are a few useful jumping off";;
"web apps in liferay dxp are called portlets. process requests and generate responses. in the response, the portlet returns content e.g. html, xhtml for display in browsers. ok, besides the funky name, how are portlets different from other types of web one key difference is that portlets run in when you're writing a portlet application, you only need to worry about that application the rest of the pagethe navigation, the top banner, and any other global component of the interfaceis handled by other another difference is that portlets run only in a portal server, portlets can therefore use the portal's existing support for user management, authentication, permissions, page management, and this frees you to focus on developing the portlet's core functionality. many ways, writing your application as a portlet is easier than writing a portlets can be placed on pages by users or portal administrators, who can place several different portlets on a single page. for example, a page in a community site could have a calendar portlet for community events, an announcements portlet for important announcements, and a bookmarks portlet for links of and because the portal controls page layout, you can reposition and resize one or more portlets on a page without altering any doing all this in other types of web apps would require manual alternatively, a single portlet can take up an entire page if it's the only app you need on that page. for example, a message boards or wiki portlet is best suited on its own page. in short, portlets alleviate many of the traditional pain points associated with developing web apps figure 1 you can place multiple portlets on a single page what's more, portals and portlets are standards-based. first defined portal and portlet behavior. refined and built on jsr-168, while maintaining backwards compatibility, to define features like inter-portlet communication ipc and more. released java portlet specification 3.0 continues portal and portlet evolution. liferay leads in this space by having a so what do these specifications define? we won't bore you with the gory details; if that's what you want you can read the specifications. however, how portlets differ from other types of servlet-based web apps. portlets handle requests in multiple phases. each portlet phase executes different operations compared to servlets, portlets also have some other key differences. portlets only render a portion of a page, tags like,, and and because you don't know the portlet's page ahead of time, you can't create portlet urls directly. instead, the portlet api gives you methods to create portlet urls programmatically. have direct access to the url.servletrequest, they can't read query parameters directly from a url. the portlet specification only provides a mechanism for a portlet to read its own url parameters or those declared as liferay dxp does, however, provide utility methods that can access the servletrequest and query parameters. portlet filter available for each phase in the portlet lifecycle. filters are similar to servlet filters in that they allow request and response portlets also differ from servlets by having distinct modes and window states. modes distinguish the portlet's current function most modern applications use view mode only portlet window states control the amount of space a portlet takes up on a page. window states mimic window behavior in a traditional desktop environment when you develop portlets for liferay dxp, you can leverage all the features defined by the portlet specification. depending on how you develop and package your portlet, however, it may not be able to run on other portal containers. may now be saying, hold on a minute! liferay dxp is standards-compliant, but it contains some sweeteners in the form of apis designed to make developers' lives for example, liferay dxp contains an that makes it simpler to implement mvc in your portlet. is only available in liferay's portal. without modification, a portlet that uses this framework won't run if deployed to a non-liferay portal container. though, that we don't force you to use liferay dxp's mvc framework or any of its for example, you can develop your portlet with strictly standards-compliant frameworks and apis, package it in a war file, and then deploy it on any standards-compliant portal container liferay dxp also contains an osgi runtime. this means that you don't have to develop and deploy your portlet as a traditional war file; you can do so as osgi we recommend the latter, so you can take advantage of the modularity features inherent in osgi. for a detailed description of these note, however, that liferay dxp portlets you develop as osgi modules won't run on other portlet containers that lack an osgi runtime. modularity are so great that we still recommend you develop your portlets as with that said, you can use a variety of technologies to develop portlets that have you ever heard the saying, there's more than one way to it's gross, but it's probably true. liferay dxp doesn't force you to use a single tool or set of tools to develop portlets. how to develop portlets using the following frameworks and techniques";;
this section focuses on liferay sample extensions. extensions by visiting the extensions folder corresponding to your preferred the following samples are documented visit a particular sample page to learn more!;
the simulation panel app provides new functionality in's simulation when deploying this sample with no customizations, the simulation sample feature is provided in the simulation menu with four options figure 1 a simulation panel app adds new functionality to the simulation menu this sample leverages the panelapp interface as an osgi service via the there are also two properties provided via the annotation the simulation panel app extends the which provides a skeletal implementation of the jsps, however, are not the only way to provide frontend functionality to your panel categoriesapps. class implementing panelapp to use other technologies, such as freemarker to learn more about liferay portal's product navigation using panel categories for more information on extending the simulation menu, see the there are three different versions of this sample, each built with a different;;
this section focuses on liferay npm sample portlets built with gradle. view these samples by visiting the folder in the liferay-blade-samples github repository the following npm samples are documented note the minifier fails on liferay dxp 7.0 when jsdoc is present in a this process may take a long time, depending on the number of files that require an update visit a particular sample page to learn more!;;
the kotlin portlet sample provides an input form that accepts a name. submitting a name, the portlet renders a greeting message figure 1 after saving the inputted name, it's is displayed as a greeting on the portlet page this sample highlights the use of the kotlin programming language in conjunction with liferay's mvc framework. specifically, this sample leverages the processaction... method to process the inputted text i.e., name. is set as an attribute in the url class using an actionrequest and then is retrieved in the jsp using a renderrequest this sample is built with the following build tools;;
the greedy policy option sample provides two portlets that can be added to a liferay dxp page greedy portlet and reluctant portlet figure 1 the greedy policy option app provides two portlets that only print text. you'll dive deeper later to discover their interesting capabilities involving services these two portlets do not provide anything useful out-of-the-box. however, very effective at demonstrating the ability to reference services using greedy and reluctant policy options. you'll learn how to do this later this sample provides two modules referencing services using greedy and reluctant service-reference provides an osgi service interface called someservice, a default implementation of it, and portlets that refer to one portlet refers to new higher ranked instances of the the other portlet is reluctant to use new higher ranked instances and continues to use its bound service. portlet can, however, be configured dynamically to use other service higher-ranked-service has a higher ranked someservice implementation here are each module's file structures here are the things you can learn using the sample modules binding a component's service reference to the highest ranked service instance that's available initially deploying a module with a higher ranked service instance for binding to greedy references immediately configuring a component to reference a different service instance dynamically let's walk through the demonstration on deploying a component that references a service, it binds to the highest ranking service instance that matches its target filter if specified the portlet classes refer to instances of interface someservice. dosomething method returns a string when module's portlets refer to defaultsomeservice, they display the string the reluctantportlet class's someservice reference's policy option is the this policy option keeps the reference bound to its current service instance unless that instance stops or the reference is reconfigured to refer to a different service instance the reluctantportlet's method doview sets render request attribute dosomething to the value returned from the someservice instance's dosomething method e.g., defaultservice returns i am default! the greedyportlet class is similar to reluctantportlet, except its someservice reference's policy option is static and greedy i.e., the greedy policy option lets the component switch to using a higher ranked someservice instance if one becomes active in the system. demonstrates this portlet switching to a higher ranked service it's time to see this module's portlets and service in action stop module higher-ranked-service if it's active deploy the service-reference module add the reluctant portlet from the add applications the portlet displays the message someservice says i am default!whose latter part comes from the render request attribute set by the figure 2 reluctant portlet displays the message someservice says i am default! add the greedy portlet from the add applications the portlet displays the message someservice says i am better, use me!. both portlets are referencing a defaultservice instance figure 3 greedy portlet displays the message someservice says i am better, use me! since defaultservice is the only active someservice instance in the system, the portlets refer to it for their someservice fields the defaultservice and portlets reluctant portlet and greedy portlet are let's activate a higher ranked someservice instance and see how the module higher-ranked-service provides a someservice implementation called higherrankedservice's service ranking is 100 that's 100 more than defaultservice's ranking 0. the string i am better, use me! reluctant portlet continues displaying message someservice says i am better, it's reluctant to unbind from the defaultservice instance and bind to the newly activated higherrankedservice service greedy portlet displays a new message someservice says i am better, use me!. the part of the message i am better, use me! comes from the higherrankedservice instance to which it refers figure 4 the greedy portlet is using a higherrankedservice instance next, learn how to bind the reluctant portlet to a higherrankedservice the reluctant portlet is currently bound to a defaultservice instance. reluctant to unbind from it and bind to a different service. configuration administration lets you reconfigure service references to filter on and bind to different service instances the service-reference module's configuration files and configure the reluctantportlet component to use a higherrankedservice the service configuration filters on a service whose url is note for deploying to liferay dxp de 7.0 fix pack 8 or later or liferay ce portal 7.0 ga4 or later, use file with suffix.config. here are the steps to reconfigure reluctantportlet to use figure 5 reluctant portlet is using the higherrankedservice instance instead of a defaultservice instance reluctant portlet is using higherrankedservice instance instead of a you've configured reluctant portlet to use a there are three different versions of this sample, each built with a different;;
this section focuses on liferay sample applications. apps by visiting the apps folder corresponding to your preferred build tool the following samples are documented visit a particular sample page to learn more!;
note this section of articles does not provide documentation for all sample projects residing in the liferay-blade-samples repo. for these samples is in progress and will grow over time liferay provides sample projects that target different integration points in github repository and can be easily copypasted to your local environment. sample projects are grouped into three different parent folders based on the build tools used to generate them note the liferay workspace folder stores war-type samples in a separate the gradle and maven tool folders mix war samples with the other sample types for more information on these sample projects, visit the;;
"portletmvc4spring is a way to develop portlets using the spring framework and the model view controller mvc pattern. while the spring framework supports developing servlet-based web applications using portletmvc4spring supports developing portlet-based applications using mvc. liferay dxp portlets with features like these you'll learn these things about portletmvc4spring developing a portlet using portletmvc4spring demonstrates creating and deploying a portlet using portletmvc4spring annotation-based controller development shows how to implement controllers using plain old java objects pojos and annotations background the portletmvc4spring project began as spring portlet mvc and when the project was pruned from version 5.0.x of the spring framework under it became necessary to fork and rename the project. improve and maintain the project for compatibility with the latest versions of the spring framework and the portlet api adopted spring portlet mvc in march of 2019 and the project was renamed to if you're familiar with spring web mvc, it's helpful to compare it with portlet workflow differs from servlet workflow because a request to the portlet can have two distinct phases the actionphase and the actionphase is executed only once and is where any back-end changes or actions occur, such as making changes in a database. renderphase presents the portlet's content to the user each time the display thus for a single request, the actionphase is executed only once, but the renderphase may be executed multiple times. requires a clean separation between the activities that modify the system's persistent state and the activities that generate content. specification added two more phases the event phase and the resource phase, both of which are supported by annotation-driven dispatching portletmvc4spring provides annotations that support requests from the render, action, event, and resource serving portlet phases; spring web mvc provides only where a spring web mvc controller might have a single handler method annotated with, an equivalent portletmvc4spring controller might have multiple handler methods, each using one of the phase annotations,,, or the portletmvc4spring framework uses a dispatcherportlet that dispatches requests to handlers, with configurable handler mappings and view resolution, just as the dispatcherservlet in the web framework does note for more information on portlets, portlet specifications, and how portlets differ from servlets, see liferay also provides full-featured sample portlets that demonstrate using jsp they exercise many features that form-based portlet applications typically require figure 1 this portletmvc4spring portlet enables users to enter job applications. it uses the spring features mentioned above and handles requests from multiple portlet phases the samples are available here now that you have a basic understanding of portletmvc4spring portlets and how they compare to spring web mvc applications, it's time to develop a";;
to continue developing a portlet to use spring framework version 5.0 onward, migrate it from spring portlet mvc to in your url or url descriptor, use the spring framework version 5.1.x artifacts by replacing dependencies on the spring-webmvc-portlet artifact with the in your url descriptor, replace uses of replace uses of the spring portlet mvc class with the portletmvc4spring portletrequestmappinghandleradapter uses the handlermethod infrastructure that spring web mvc if you specified annotationmethodhandleradapter as a in a spring also address these bean property changes with this new one from portletmvc4spring note alternatively, you can use the native portlet 3.0 file upload support that portletmvc4spring provides by setting the portletmultipartresolver element's class to remove these dependencies from your url or url throughout your project, replace all uses of the you migrated your project from spring portlet mvc to;;
portletmvc4spring provides several annotations for mapping requests to controller classes and controller methods the following table describes some annotation examples the table below describes some annotation examples.;
liferay dxp started off as a portal server, designed to serve java-based web applications called portlets see jsr 168, portlets process requests and generate responses like any other web application. one key difference, however, between portlets and other web apps is that portlets run in a portion of the web page. when you're writing a portlet application, you need only worry about that application the rest of the pagethe navigation, the top banner, and any other global components of the interfaceis handled by other components. portlets run only in a portal server. they use the portal's existing support for user management, authentication, permissions, page management, and more. frees you to focus on developing the portlet's core functionality. writing your application as a portlet is easier than writing a standalone many portlets can be placed on a single page by users if they have permission for example, a page in a community site could have a calendar portlet for community events, an announcements portlet for important announcements, and a bookmarks portlet for links of interest to the community. you can drag and drop to reposition and resize portlets on a page without alternatively, a single portlet can take up an entire page if it's the only app you need on that page. or wikis with complex user interfaces are best suited on their own pages. short, portlets alleviate many of the traditional pain points associated with figure 1 you can place multiple portlets on a single page portlets handle requests in multiple phases. each portlet phase executes different operations compared to servlets, portlets also have some other key differences. portlets only render a portion of a page, tags like,, and and because you don't know the portlet's page ahead of time, you can't create portlet urls directly. instead, the portlet api gives you methods to create portlet urls programmatically. have direct access to the url.servletrequest, they can't read query parameters directly from a url. the portlet specification provides a mechanism for a portlet to read only its own url parameters or those declared as liferay dxp does, however, provide utility methods that can access the servletrequest and query parameters. portlet filter available for each phase in the portlet lifecycle. filters are similar to servlet filters in that they allow request and response portlets also differ from servlets by having distinct modes and window states. modes distinguish the portlet's current function most modern applications use view mode only portlet window states control the amount of space a portlet takes on a page. window states mimic window behavior in a traditional desktop environment on liferay dxp involve portlets. the javascript-based widgets use liferay's js portlet extender behind the scenes and the java-based web front-ends are all of the web front-end types vary in their support of model view controller mvc, and modularity, giving you plenty of good options;;
a portletmvc4spring application has these descriptors, spring contexts, and properties files in its web-inf folder examples of each file are provided and portlet-specific content is highlighted the servlet container processes the url. this file specifies the servlet that render's the portlet and the portlet application's context, servlet, the element gives the path to the portlet application context the and elements set the servlet and the internal location for its views converts portlet requests into servlet requests and enables the view to be rendered using the spring web mvc infrastructure and the infrastructure's renderers for jsp, thymeleaf, velocity, and more the filter and filter mappings are set to forward and include servlet views as a listener is configured for processing the application's contexts liferay's project archetypes generate all this boilerplate code the url file describes the portlet application to the portlet this application has one portlet named portlet1 the is internal and the is shown to users. specifies the portlet's java class important all portletmvc4spring portlets must specify the element must declare the mime type that the portlet templates the sets the path to the portlet's localized java message for example, the element refers to properties at the element lists the portlet's titles and reserved keyword the elements declare default user roles the portlet prevents cross-site request forgery csrf the liferay-specific portlet descriptor is next the url file applies liferay-specific settings that provide this element associates an icon with the portlet and indicates that name-spaced parameters aren't required the elements associate the portlet with default liferay dxp user the url applies display characteristics to the portlet. example, this descriptor associates the portlet with a widget category in it's time to look at the application contexts this context applies to all of the application's portlets. specify view resolvers, resource bundles, security beans, proxies, and more. the view resolver bean above handles jspx view templates. view templates, for example, you could specify these beans the context's springsecurityportletconfigurer bean facilitates using spring you can also designate contexts for each portlet in the application beans specific to a portlet, go in the portlet's context. the easiest way to develop portletmvc4spring portlets, you should specify mvc annotation scanning in the portlet context the portlet context naming convention is portlet-name url. associate your portlet with its own context, edit your application's url file and add an element that maps the element to the portlet's context what's left is to describe your application package this file specifies the application's name, version, java package importsexports, and osgi metadata. here's an example package properties file it uses this osgi metadata header to on deploying the portlet application war file, the adds the specified osgi metadata to the resulting web application bundle wab that's deployed to liferay's runtime framework you've successfully toured the portletmvc4spring configuration;;
portletmvc4spring portlets are packaged in wars. liferay provide maven archetypes for creating projects configured to use jspjspx and thymeleaf templates. their commands are listed below. the portletmvc4spring project structure follows the commands generating portletmvc4spring portlet projects that use jspx and the maven commands generate a project that includes model and controller classes, view templates, a resource bundle, a stylesheet, and more. spring contexts and configuration files set portletmvc4spring development essentials.;;
mvcrendercommand s are classes that respond to if your render logic is simple and you want to implement all of your render logic in your portlet class, see writing mvc portlet controller logic is complex or you want clean separation between render paths, use each render url in your portlet's jsps invokes an appropriate render command class sample render url invokes an mvc render command named bladerender name the render url via its named the render url and mvcrendercommand class demonstrated later map to the mvcrendercommandname value assign the's var attribute a variable name to assign the render url variable var to a ui component. triggers the ui component, the mvcrendercommand class that matches the render url handles the render request for example, the render url with the variable bladerender triggers on users clicking this button create a class that implements the set a url property to your portlet's internal id set a url property to your tag register your class as an mvcrendercommand service by setting the note, you can apply mvc command classes to multiple portlets by setting a url property for each portlet and apply mvc command classes to multiple command names by setting an url property for each command name. url properties and url properties apply it to two specific portlets and two specific command names implement your render logic in a method that overrides some mvcrendercommand s, such as the one below, always as you can see, mvc render commands are easy to implement and can respond to multiple command names for multiple portlets;;
liferay's mvc portlet framework enables you to handle this facilitates managing action logic in portlets that each action url in your portlet's jsps invokes an appropriate name the action url via its name attribute. assign the var attribute a variable name assign the action url variable var to a ui component. for example, the sample's greeturl action url variable triggers on submitting this form create a class that implements the the latter may save you time, since it already implements tip naming your mvcactioncommand class after the action it performs makes the action mappings more obvious for maintaining the code. for example, if your action class edits some kind of entry, you could name its class editentrymvcactioncommand. if your application has several mvc command classes, naming them this way helps differentiate them set a url property to your portlet's internal id note, you can apply mvc command classes to multiple portlets by setting a url property for each portlet. url properties in this component apply it to three set the url property to your tag's this maps your class to the action url of the same name register your class as an mvcactioncommand service by setting the implement your action logic by overriding the appropriate method of the class you're implementing or extending implementations override the processaction method extensions override the doprocessaction method here's an example of overriding mvcactioncommand's processaction method. this action logic gets the name parameter from the actionrequest and adds it to the session messages and to an actionrequest attribute you've created an mvcactioncommand that handles your portlet;;
this section briefly covers how to get your view layer working, from organizing your imports in one jsp file, to creating urls that direct processing to note as you create jsps, you can apply clay styles to your app to match liferay's apps liferay's practice puts all java imports, tag library declarations, and variable initializations into a jsp called url. to create a module based on the mvc-portlet project template, these taglib declarations and initializations are added automatically to your url here are the tag libraries it gives you these tags make portlet and liferay objects available implicit java variables that reference the objects available are limited to those available in for details, see the defineobjects tag in jsr-286 implicit java variables that to use all that the url has, include it in your other jsps a jsp uses render urls to display other pages and action urls to invoke a render url attached to a ui component action displays another page. example, this render url displays the jsp url here's how to use a render url name the render url via a var attribute in the tag. the tag constructs the url and assigns it to the for example, this render url is assigned to the variable named as sub-element to the tag, add a tag with the following attributes namemvcpath your controller's render method forwards processing to the jsp at the path specified in the value value url the path to the jsp to render. to invoke the render url, assign its variable var to a ui component action, such as a button or navigation bar item action invoking the ui component causes the controller's render method to display the action methods are different because they invoke an action i.e., code, rather for example, this action url invokes a controller method called dosomething and passes a parameter called redirect. the redirect parameter contains the path of the jsp to render after invoking here's how to use an action url add a name and var attribute to the. tag constructs the url and assigns it to the var name controller action to invoke var variable to assign the action url to tag that has the following attributes nameredirect tells the portlet to redirect to the jsp associated with value url redirects the user to this jsp path after replace the value url with your jsp to invoke the action url, assign its variable var to a ui component your portlet is ready for action communication between a smaller application's view layer and controller;;
in mvc, your controller is a traffic director it provides data to the right front-end view for display to the user, and it takes data the user entered in the front-end and passes it to the right back-end service. controller must process requests from the front-end, and it must determine the right front-end view to pass data back to the user if you have a small application that's not heavy on controller logic, you can put all your controller code in the -portlet class. needs lots of actions, complex render logic to implement, or maybe even some resource serving code, consider breaking the controller into mvc render here you'll implement controller logic for small applications, where all the controller code is in the -portlet class. start with creating action methods your portlet class can act as your controller by itself and process requests this action method has one job call a service to add a guestbook. succeeds, the message guestbookadded is associated with the request and if an exception is thrown, it's caught, and the class name is associated with and the response is set to render url. render parameter is a liferay mvcportlet framework convention that denotes the next view to render to the user while action methods respond to user actions, render logic determines the view here's how mvc portlet determines which view to render. properties you set in your component the template-path property tells the mvc framework where your jsp files live. in the above example, means that the jsp files are in your project's root that's why it's important to follow liferay's standard the view-template property directs the default rendering to here's the path of a hypothetical web module's resource folder based on that resource folder, the url file is found at and that's the application's default view. e.g., your portlet's override of url is called, liferay reads the initialization parameters you specify and directs rendering to the default jsp. throughout the controller, you can render different views jsp files by setting you can avoid render logic by using initialization parameters and render parameters, but most of the time you'll override the portlet's render method. this render logic provides the view layer with data to display to the user. render method above sets the render request attribute guestbookid with the if guestbooks exist, it chooses the first. otherwise, it creates a guestbook and sets it to display. passes the render request and render response objects to the base class via its note are you wondering how to call in short, obtain a reference to the service by annotating one of your fields of that service type with the once done, you can call the service's methods before venturing into the view layer, the next section demonstrates ways to pass information between the controller and view layers facilitates retrieving parameters from an actionrequest for example, this jsp passes a parameter named guestbookid in an action the tag's name attribute maps the action url to a controller action method named dosomething. triggering an action url invokes the corresponding method in the controller the controller's dosomething method referenced in this example gets the guestbookid parameter value from the actionrequest to pass information back to the view layer, the controller code can set render the code above sets a parameter called mvcpath to jsp path url. this causes the controller's render method to redirect the user to that jsp your controller class can also set attributes into response objects using the jsps can use java code in scriptlets to interact with the request object passing information back and forth from your view and controller is important, but there's more to the view layer than that.;;
generating mvc portlet projects is a snap using liferay's project templates. here you'll generate an mvc portlet project and deploy the portlet to liferay dxp here's the resulting folder structure for an mvc portlet class named mymvcportlet in a base package url the maven-generated project includes a url file and does not include the gradle-specific files, but otherwise is exactly the same here's the resulting mvc portlet class annotation and service url attribute makes the class an osgi declarative services component that provides the the immediate true attribute activates the service immediately set any portlet configuration or liferay portlet configuration values using url. and url. annotation properties url. and url. annotation properties here are the example component's properties url activates the component immediately when its bundle installs srcmainresourcesmeta-infresources where the templates reside url mymvcportletkeys.mymvc the portlet's unique url.language sets the portlet's to the contentlanguage.properties files in the url,user makes the liferay dxp virtual instance's power user and user roles available for defining the note to opt-in to portlet 3.0 features, set the component property the portlet renders content via the view template deploy the project using your build by building the project jar and copying it to the deploy folder in your the mvc portlet is now available in the liferay dxp ui, in the widget category you figure 1 the example portlet shows a message defined by the language property url from yourmvc! in the url file congratulations on creating and deploying an mvc portlet!;;
if you're an experienced developer, this is not the first time you've heard if there are so many implementations of mvc frameworks in java, why did liferay create yet another one? you'll see that liferay mvc portlet provides these benefits the liferay mvc portlet framework is light and easy to use. template generates a fully configured and working project here, you'll learn how mvcportlet works by covering these topics review how each layer of the liferay mvc portlet framework helps you separate the concerns of your application in mvc, there are three layers, and you can probably guess what they are model the model layer holds the application data and logic for manipulating view the view layer contains logic for displaying data controller the middle man in the mvc pattern, the controller contains logic for passing the data back and forth between the view and the model layers liferay dxp's applications are divided into multiple discrete modules. model layer is generated into a service and an api module. the view and the controller layers share a module, generating the skeleton for a multi-module service builder-driven mvc saves you lots of time and gets you started on the more important and interesting, if we're being honest development work in a larger application, your -portlet class can become monstrous and unwieldy if it holds all of the controller logic. liferay provides mvc command classes to there must be some confusing configuration files to keep everything wired together and working properly, right? wrong it's all easily managed in the whether or not you plan to split up the controller into mvc command classes, the portlet annotation configures the portlet. the url property is required. combinations to the correct portlet liferay dxp uses the name to create the portlet's id there can be some confusion over exactly what kind of url implementation you're publishing with a component. import that, and not, for example, defines all the liferay-specific attributes you can specify as properties in consider the element from the above link as an example. to specify that property in your component, use this syntax in your property the properties namespaced with url. are elements of the in simpler applications, you don't use mvc commands. as you've seen, liferay's mvc portlet framework gives you a well-structured controller layer that takes very little time to implement. to get into the details of creating an mvc portlet application, continue with;;
"running an existing vue app on liferay dxp makes the app available as a widget for using on site pages. but this doesn't give you access to the bundler and its various loaders to develop your project further in liferay dxp. to have access to all of liferay dxp's features, you must use the liferay js generator and liferay npm bundler to merge your files into a portlet bundle, update your static resource paths, and deploy the steps below demonstrate how to prepare a vue app that uses single file components .vue files with multiple views figure 1 vue apps like this guestbook app are easy to deploy, and they look great in liferay dxp note if you have a tree of components expressed as.vue templates, only the root one will be available as a true amd module using npm, install the liferay js generator generate a vue based portlet bundle project select vue based portlet and opt for generating sample code. copy your app files, matching the types listed below, into your new project if you have internal css included with tags in your.vue the modified build script further down import all custom css files i.e. css not included in.vue files through the css file default is url your bundle's url file sets for your portlet. update any static resource references to use the web-context value declared in your project's.npmbundlerrc file. here's an example image resource merge your entry module with url, following these steps to note components must be loaded dynamically to attach to the portlet's the dom is determined at runtime when the portlet's page is import vue from' url'; so you don't have to process this is imported by default at the top of remove the sample content from the main function i.e. the node constant and its use, and replace it with your router code make these updates to the new vue instance your updated configuration should look like this your entry module url should look like this merge your app url file's dependencies and devdependencies into the project's url, and replace the babel-cli and babel-preset-env dev dependencies with the newer cli 7.0.0 and preset-env 7.4.2 packages instead. update the.babelrc file to use preset-env instead of if you're using.vue files, replace the build script in the url with the one below to use vue-cli-service. vue-cli to access the main entrypoint for the app url in the example below and combines all the vue templates and js files into one single file named url and generates an url file for any internal css included with tags in.vue files update the main entry of the url to match the new file name specified in the previous step finally, deploy your portlet bundle your vue app is deployed and now available as a widget that you the liferay-npm-bundler confirms the deployment the liferay dxp console confirms your bundle started find your widget by selecting the add icon and navigating to widgets and the category you specified to the liferay bundle generator sample is the default category";;
running an existing react app on liferay dxp makes the app available as a widget for using on site pages. you can adapt your existing react app, but this doesn't give you access to the bundler and its various loaders to develop your project further in liferay dxp. to have access to all of liferay dxp's features, you must use the liferay js generator and liferay npm bundler to merge your files into a portlet bundle, update your static resource paths, and deploy figure 1 apps like this guestbook app are easy to migrate to liferay dxp using npm, install the liferay js generator generate a react based portlet bundle project for deploying your app to select react based portlet and opt for generating sample code. copy your app files, matching the types listed below, into your new project update any static resource references to use the web-context value declared in your project's.npmbundlerrc file, and remove any imports for for example, if you have an image file called url in your assets folder, you would use the format below. folder is not included in the path here's an example image resource merge your entry module with url, configuring it to dynamically note components must be loaded dynamically to attach to the portlet's the dom is determined at run time when the portlet's page is place your code inside the main function render your app inside the portletelementid element that is passed in this is required to render the react app inside your entry module url should look like this merge your app url file's dependencies and devdependencies your react app is deployed and now available as a widget that the liferay npm bundler confirms the deployment the liferay dxp console confirms your bundle started to find your widget, click the add icon navigate to widgets and then the category you specified to the liferay bundle generator sample is the default category;;
running an existing angular app on liferay dxp makes the app available as a widget for using on site pages. you can adapt your existing angular app, but this doesn't give you access to the bundler and its various loaders to develop your project further in liferay dxp. to have access to all of liferay dxp's features, you must use the liferay js generator and liferay npm bundler to merge your files into a portlet bundle, adapt your routes and css, and deploy your figure 1 apps like this guestbook app are easy to migrate to liferay dxp using npm, install the liferay js generator generate an angular-based portlet bundle project for deploying your app to select angular based portlet and opt for generating sample code. copy your app files, matching the types listed below, into your new project update your component class templateurl s to use the web-context value declared in your project's.npmbundlerrc file. import all component css files through the css file default is url your bundle's url file sets for your portlet. remove selector and styleurls properties from your component in your routing module's decorator, configure the router option this tells angular to use client-side routing in the form of...route, which prevents client-side parameters i.e., anything after from being sent back to liferay dxp for example, your routing module class decorator might look like also in your routing module, export your view components for your root module discussed next to use. merge your root module with url, configuring it to note components must be loaded dynamically to attach to the portlet's the dom is determined at run time when the portlet's page is import the routingcomponents constant and the app routing module class specify the base href for the router to use in the navigation urls declare the routingcomponents constant in your decorator make sure your bootstrap property has no components. components are loaded dynamically using the entrycomponents array the empty ngdobootstrap method nullifies the default your root module url should look like this merge your app url file's dependencies and devdependencies note to work around build errors caused by the rxjs dependency, set the dependency to version 6.0.0. your angular app is deployed and now available as a widget that the liferay npm bundler confirms the deployment the liferay dxp console confirms your bundle started to find your widget, select the add icon navigate to widgets and then the category you specified to the liferay bundle generator sample is the default category;;
if you already have an application, you can deploy it on if you plan to write a new application and deploy it on liferay dxp, you can use the frameworks you know along with the build tools gradle, maven you know. liferay also offers its own development framework called mvc portlet that it when you want to integrate with and frameworks such as permissions, assets, and indexers, you'll find that these easily and seamlessly blend with your application to provide a great user regardless of your development strategy for applications, you'll find liferay dxp to be a flexible platform that supports anything you need to write liferay gives you a head start on developing and deploying apps that use these popular java and javascript-based technologies note the reference section describes for creating uis using other technologies angular, react, and vue applications are written the same as you would outside of the liferay js generator creates a portlet bundle project for developing and deploying each type of app. project comes with npm commands for building, testing, and deploying the app. packages the app's dependencies including javascript packages, deploys the bundle as a jar, and installs the bundle to liferay dxp's run time environment, making your app available as a widget you can also develop web front-ends using java ee standards. portlet 3.0 standard which is backwards-compatible with the portlet 2.0 standard from the java community process jcp. framework has benefits you may wish to consider bean portlet is the only framework containing all of the portlet 3 features if you're a javaserver faces jsf developer, the supports deploying jsf web apps as portlets without writing portlet-specific it also contains innovative features that make it possible to leverage the power of jsf 2.x inside a portlet application if spring is your thing, spring portlet mvc portlets are easy to configure and you can continue using spring features, including spring beans and spring dependency injection last but not least, liferay mvc portlet continues to be a favorite with experienced liferay developers, and makes portlet development easy for liferay it leverages osgi declarative services ds for injecting dependencies and defining configurable extension points. and liferay-written apps use ds, gaining experience with ds helps you develop liferay dxp extensions and customizations. seamlessly with many liferay frameworks, such as mvc commands, service builder, no matter which development framework you choose, you'll be able to get an app if you have an existing app that uses one the frameworks described above, your first step is to deploy it to liferay dxp. most deployments involve configuration steps that you can complete in an hour or less you can also build apps from scratch using the tools you like or leveraging liferay provides templates for creating all kinds of apps and samples that you can examine and modify to fit your needs once your app is functional, you can improve your app by integrating it with liferay provides frameworks that integrate these features fast. apps on liferay dxp, you'll enjoy using what you know, discover frameworks and tools that boost your productivity, and have fun creating rich, full-featured if you're experienced with developing one of the listed app types, feel free to otherwise, angular widgets is next.;;
many of these steps are similar to configuring liferay dxp as a saml identity as a reminder, a single liferay dxp installation can be configured as a saml identify provider or as a saml service provider but not as both. already set up one liferay dxp installation as a saml identity provider, use a different liferay dxp installation as a saml service provider note if you're using a third party idp with liferay dxp as the sp, all messages coming from the idp must be signed. if they're not, an error message appears and communication between the idp and liferay dxp fails install the liferay saml 2.0 provider app. successfully deployed, look for the saml admin entry in the configuration to begin configuring liferay dxp to use saml, you must select a saml role for liferay dxp and you need to choose an entity id. enter liferaysamlsp if you're setting up an example alternatively, choose your own entity id. click save and a new section entitled certificate and private key appears the certificate and private key section is for creating a keystore for saml. click create certificate and enter the following information when you enter all the required information, click save after you clicked save, check that you can view information about your after you create a keystore, additional options this tab enables or disables saml idp and manages the required keystore service provider this tab manages basic and advanced configurations for identity provider connection this tab manages connections to the idp. there can be only one idp connection note that these options are different than if you were setting up liferay dxp as next, you need to configure an identity provider connection. identity provider connection tab. enter a name for the identity provider, enter its entity id, and enter its metadata url. followed the previous instructions and configured a separate liferay dxp installation as an identify provider, you'd enter the following information important the liferay saml 2.0 provider app supports using either a url to a saml idp metadata file or an actual uploaded saml metadata the value entered in the metadata url field will only be persisted to the database when there is one entered metadata url and there otherwise, liferay dxp keeps the original this behavior ensures that once a metadata url has been specified, there will always be a metadata url saved in the this way, if a portal administrator forgets the previously entered metadata url or its format, he or she can simply look at the displayed metadata url and either choose to modify the displayed metadata url or to overwrite the previously saved metadata url by specifying a metadata xml currently, the saml provider app does not provide a way to clear the saml idp metadata url or metadata xml file fields using the control if you really need to clear these fields, it's possible but not recommended to delete the contents of the saml idp metadata url and metadata xml file columns of the samlspidpconnection table of liferay dxp's finally, after you save your certificate and private key information and configure an identity provider connection, check the enabled box at the top of the general tab and click save. liferay dxp is now a saml service provider! note that the saml service provider session is tied to the normal session on session expiration on the application server terminates the session on the service provider but does not initiate single logout a saml keystore has been generated verify the connection to the idp entity id the same name of the idp. if the idp is another liferay dxp instance, then it is the same name as the above example metadata url the idp's metadata as a url or as an xml file if the idp is another liferay dxp instance, ensure its corresponding service provider connection for this sp is enabled on the general tab, the enabled checkbox has been checked once enabled checkbox has been checked, the service provider's metadata if you'd like to configure liferay dxp's saml service provider settings, navigate to the service provider tab of the saml admin portlet the service provider tab includes these options require assertion signature? when this box is checked, saml assertions must be individually signed in addition to the entire saml message note individual assertions need not be signed as long as the saml response the sp and idp should always communicate over to have encryption at the transport level if you believe man-in-the-middle attacks are possible, the saml response can be the only reason to sign the assertions is if the saml response is not in this case, assertions should not only be signed but also encrypted clock skew clock skew is a tolerance in milliseconds used by the service provider for verifying expiration of messages and assertions. to mitigate time differences between the clocks of the identity provider and this usually only matters when assertions have been made ldap import enabled when this box is checked, user information is imported from the configured ldap connection based on the resolved nameid. connections can be configured from instance settings sign authn requests when this box is checked, the authnrequest is signed even if the identity provider metadata indicates that it's not required sign metadata when this box is checked, the metadata xml file is signed ssl required when this box is checked, any saml messages that are not sent this does not affect how urls are generated if you'd like to configure liferay dxp's saml identity provider settings, navigate to the identity provider connection tab of the saml admin portlet name the name of the identity provider with which to connect entity id the identity provider's entity id. entity id declared in the identity provider metadata force authn when this box is checked, the service provider asks the identity provider to re-authenticate the user before verifying the user metadata you can either provide a url to the identity provider metadata xml file or you can manually upload it. if you provide a url, the xml file is automatically retrieved and periodically polled for updates. update interval in system settings by modifying the url property which specifies a number of seconds. if fetching the metadata xml file by url fails, you can't enable the identity if the metadata is inaccessible via url, you can upload the in this case, the metadata xml file is not updated name identifier format choose the name identifier format used in the saml this should be set according to what the service provider expects to for liferay service providers, any selection other than email address indicates that the name identifier refers to screen name. any special meaning to liferay identity providers. by the name identifier attribute attribute mapping the attribute mapping is done from the attribute name or friendly name in the saml response to the liferay dxp attribute name. if you want to map a response attribute named mail to the liferay dxp attribute emailaddress, you'd enter the following mapping available liferay dxp attributes are emailaddress, screenname, firstname, lastname, modifieddate, and uuid keep alive url if users are logged into several liferay dxp sp instances via a liferay dxp idp, their sessions can be kept alive as long as they keep a browser configure this only if the idp is liferay dxp. is host namecportalsamlkeepalive. configure this url the same way, but point back to this sp save your changes when you are finished configuring the liferay dxp instance as a there is no need to restart the server and the changes will be the previous two sections explained how to use the saml 2.0 provider app's control panel interface to configure liferay dxp as an identity provider or as a service provider. such configurations should only be made through the saml control panel interface and not via properties. of the liferay saml 2.0 provider app are not available as properties limitation the liferay saml app can only be used with a single virtual technically, this means that in the saml metadata for liferay dxp, only one binding can be added in this form if you want to use the liferay saml 2.0 provider app as an sso solution for a clustered liferay dxp environment, follow the steps in this section. proceeding, make sure that the following assumptions apply to your scenario if you're running a multi-node cluster behind a load balancer, follow these steps to enable all the nodes as sps before you begin, consider the type of keystore manager you want your cluster to to select a keystore manager, go to control panel system settings are filesystem keystore manager and document library keystore manager all nodes in the cluster should be configured to use the same keystore manager if using the filesystem keystore manager the default configure each node of your liferay dxp service provider using the instructions of the previous section copy the keystore file liferay home url, by default from the first liferay dxp node to the remaining liferay dxp nodes. java keystore that's created by the saml provider app. contains the valid or self-signed certificate managed by the saml provider verify that the service provider metadata has been generated to be used either as a url or an xml file. the metadata is the same for all nodes because of the same database back-end. the idp's request goes through the at this point, all the liferay dxp nodes have the same saml sp configuration and each of them can respond to web requests and handle the saml protocol. to test your sso solution, sign into liferay dxp via your load balancer, navigate to a few pages of a few different sites, and then log out if using the document library keystore manager, skip step 3 because the keystore file is stored in the database shared by all the nodes now you know how to configure liferay dxp either as a saml identity provider you also know how to configure saml in a;;
"liferay support does not recommend or endorse specific third-party products over others. liferay is not responsible for any instructions herein or referenced regarding these products. any implementation of these principles is the responsibility of the subscriber this article documents a proof of concept for setting up a digital experience platform dxp instance as a saml service provider sp connected to microsoft active directory federated service adfs as an identity provider idp. this implementation enables users to execute a single sign on sso action from liferay dxp this article is a general checklist and proof of concept implementation. administrators should always consult third-party documentation pertaining to adfs before starting this process for demonstration purposes, we used apache tomcat as our application server; some of the steps are for tomcat 8.0 or 9.0 but can still be adapted for other application servers as a best practice, we discovered that ip addresses could not be used as an alias. rather, it was necessary to create an alias, or reuse a generic host name, in the hosts file it is necessary to enable in the application server documentation already exists to guide administrators in configuring liferay dxp as a saml service provider. obviously, remember to deploy the appropriate saml connector to the dxp instance first there are few things to note when it comes with integrating liferay dxp with adfs perhaps this is the most critical step where the sp's metadata is imported into adfs. there is a cr rule and a tr rule which dictate the trust relationship and ldap mappings when creating a tr rule, enter the following requests from adfs to liferay must be signed the samlresponsesignature messageandassertion must be added to the relying party trust. that way, the dxp sp instance can accept both signed messages and assertions as valid responses once adfs and liferay dxp are active, you can verify that they are indeed connected by using an sp initiated sso. in the dxp instance, click the sign in link. this should redirect into adfs.";;
"this article sets forth the permissions rules for managing message boards categories and threads. one question is whether the system is granular enough to allow users to delete only category threads for which category the role is assigned, and not other category threads anyone with the delete permission can delete the contents of an entire category, including individual threads, and any other category they have permissions to manage. in other words, this is all or nothing to demonstrate, create a site role called forum moderator with the following permissions at this point, a site role has been created just for moderating message boards. assign a user other than the omni-admin to this role. if there are any categories and threads, the forum moderator role is able to delete any category, subcategory, or thread lastly, recall that asset permissions in liferay dxp and legacy portal 6.2 have always been set at the role level, not individual users. the only way to allow more granular control is to have multiple roles with different permissions for different categories; moderator one has permissions for only categories 1-4 and its messages, while moderator two has permissions for categories 5-6, and moderator three has permissions for only categories 7-10, etc.";;
how many times have you had to start over from scratch? times as you've started a new project, because each time you have to write not only the code to build the project, but also the underlying code that supports it's never a good feeling to have to write the same kind of code but each new project that you do after a while can feel like that you're writing a new set of database tables, a new api, a new set of css classes and html, a new set of javascript functions wouldn't it be great if there was a platform that provided a baseline set of features that gave you a head start on all that repetitive code? lets you get right to the features of your app or site, rather than making you start over every time with the basic building blocks? liferay dxp offers you a complete platform for building web apps, mobile apps, and web services quickly, using features and frameworks designed for rapid development, good performance, and ease of use. there, and it's built as a robust container for applications that you can put together in far less time than you would from scratch it also ships with a default set of common applications you can make use of right away web experience management, collaboration applications such as forums and wikis, documents and media, blogs, and more. designed to be customized, as is the system itself. include your own functionality, and this is no hack because of liferay's extensible design, customization is by design in short, liferay was written by developers for developers, to help you get your work done faster and more easily, to take the drudgery out of web and mobile app development, so that writing code becomes enjoyable again one of the most often cited best characteristics of liferay is how versatile it can be used to build websites of all sorts, from very large websites with hundreds of thousands of articles, to smaller, highly dynamic and this includes public sites, internal sites like intranets, or mixed environments like collaboration platforms developers often choose liferay for one of these cases and quickly find that it is a great fit for completely different projects liferay dxp is based on the java platform and can be extended by adding new applications, customizing existing applications, modifying its behavior, or you can do this with any programming language the jvm supports, such as java itself, scala, jruby, jython, groovy, and others. liferay dxp is lightweight, can be deployed to a variety of java ee containers and app servers, and it supports a variety of databases. be customized, you can add support for more app servers or databases without modifying its source code just develop and deploy a module with the features speaking of code and deploying, here are some of the most common ways of expanding or customizing liferay dxp's features the liferay platform can be used as a headless platform to develop web or mobile apps with any technology of your choice angular, react, backbone, cocoa, as a web integration layer, leveraging technologies such as portlets to allow several applications to coexist on the same web page.;;
when you drag and drop pages under link to url type pages, it appears as if the structure changes, but after refreshing the browser, the page order is not saved this is a known issue, and the reason that this does not work is because link to url page types cannot be configured as parents of other pages. please bear in mind that in liferay dxp 7.0 and 7.1 lps-89111 clarifies the intended behavior in dxp 7.0 - this is resolved starting in fix pack de-71 when trying to drag a page underneath the link to url page, an error message will appear a page cannot become a child of a page that is not parentable in dxp 7.1 - this is resolved starting in fix pack dxp-7 when trying to drag a page into the link to url page, this action will not be possible.;;
there is a known issue with ios safari while using url, which is an api that liferay uses. issues outside of liferay can be found at this issue will make it impossible to remove the web content display portlet from a page when using safari on ios the only solution within liferay is to disable spa within the portal. this can be done by setting this property in your url please be aware that disabling spa can increase page load times on your portal for more information on spa within liferay, please read introduction to liferay development;;
this article documents a bug in the search container with any list of selectable items. it was discovered that site administrators could not assign a site role if that site role is not listed on the first page. roles that were listed on the second pages were subsequently deselected when more site roles were assigned to a user. this bug is found in all liferay platforms the root cause for this error is because while implementing pagination improves performance by having requests and processes query in parts of the whole data set, there is a downside on the client side. using the same example of site roles, on the client side, the information on subsequent pages 2, 3, or 4, is simply not available yet. information is thus requested and then displayed only when the user navigates to those pages unfortunately, at this time, there is no easy fix without changing how liferay dxp implements pagination or risk major performance issues now, assign a site role to a member other than test test select site roles 6, 7, and 8 on page 2 the expectation at this point is that if more site roles are assigned to the same user, all site roles will be listed in the site roles and teams column on the right. however, this is where the bug is most evident. the next few steps illustrates this notice that the other site roles assigned are not listed and in fact have become deselected if checking the assign site roles window again as noted above, there is no easy fix yet. however, liferay engineering is very much aware of the bug and is working on a permanent fix that will be available in a service pack or fix pack in the near future. that said, there are several short term solutions and workarounds the first workaround is to change the pagination on the assign site roles window from 20 to 30 entries. the three sites site roles 6, 7, and 8 which used to be listed on the second page are now all one one page. selecting them again then clicking done successfully assigns all five site roles to the user test two one limitation of this workaround is that it works only for that particular window at that particular time. if the window is closed and reopened, the values go back to the default 20 entries per page. to make this change more permanent, in the url, enter the following url. this increases the number of displayed entries to 50. this is more of a best practices solution than a configuration issue. ideally and truly depending on each customer's specific business needs, consider just how many site roles are needed and whether the permissions granted need to be so granular. although liferay dxp and portal allow up to 200 entries to be displayed per page, in reality, sometimes fewer is better.;;
there are a few different types of statuses within the workflow of a support ticket in help center. below is an overview of the 3 categories of statuses you will encounter on a ticket when you create a support ticket in help center, you will be asked for details on your system status. the first value you will provide pertains to the environment this will then prompt you to provide the status of the system in question note in help center, a ticket will automatically be assigned a priority level based on the information you provided in the system status field when creating the ticket below is a chart that shows how the system status corresponds to a priority level severely impacted or inoperable unstable with periodic interruptions functioning with limited capabilities fully functional with observed errors once your ticket has been submitted, a liferay support team member will provide acknowledgement of receipt within 1 business day the system status descriptions are based on the severity levels defined in the enterprise services agreement appendix note high, normal, low in help center correspond to critical, major, minor in the agreement. the severity level for a particular incident is a part of the ongoing discussion between you and liferay support, and may be adjusted as necessary once you've created a ticket, you will be able to easily track its progress by looking at its status these are the different status labels for a ticket, and what they mean note tickets with a solved status will automatically be closed after 28 days without any comments. while closed tickets cannot be reopened, you can always create a follow-up ticket on the issue, if needed there is also a sub-status field that your cse will use while working on your ticket. this field gives more specific information on the current steps in-progress on an open ticket here are the sub-statuses you might see on your ticket for any questions, please contact us at email.;;
this tutorial guides you through the process of upgrading your 6.2 theme to run while you're at it, you should leverage theme improvements, including support for sass, bootstrap 3, and lexicon liferay's this tutorial demonstrates upgrading a liferay portal 6.2 theme upgrades involve these steps as an example, this tutorial applies the steps to a liferay portal 6.2 theme called the lunar resort themedeveloped in the liferay portal 6.2 learning path developing a liferay theme. it's similar to many liferay portal 6.2 themes as it extends the styled theme, adding configurable settings and incorporating a responsive design that leverages font awesome icons and bootstrap. contains its original source code figure 1 the lunar resort example theme upgraded in this tutorial uses a clean, minimal design before upgrading a theme, consider migrating the theme to use the liferay js theme toolkit, such as those created with the liferay theme generator. liferay dxp 7.0 doesn't require this migration, but the liferay js theme toolkit's gulp upgrade task automates many upgrade steps. theme toolkit can also leverage exclusive new features, such as the liferay theme generator's sub-generators, and if you migrate your theme, return here afterward to upgrade it no matter the environment in which you're developing your theme, this tutorial explains everything required to upgrade it. the easiest option is to use the liferay js theme toolkit's gulp upgrade task, so you'll see that first. see all upgrade steps, in case you want to run them manually a liferay portal 6.2 theme can be upgraded to liferay dxp 7.0, regardless of its project environment liferay js theme toolkit, plugins sdk, maven, etc.. that's been migrated to use the liferay js theme toolkit can leverage the gulp if you're not going to leverage liferay js theme toolkit, skip to the updating project metadata section here's what the upgrade task does the upgrade task automatically upgrades css code that it can identify. everything else, it suggests manual upgrades that you can make here are the steps for using the theme gulp upgrade task in your theme's root directory, run this command note an upgraded theme can be restored to its original state by the task continues upgrading css files, prompting you to update css file for liferay dxp 7.0, sass files should use the.scss extension and file names for sass partials should start with an underscore e.g., url . upgrade task prompts you for each css file to rename the upgrade task makes a best effort to upgrade the theme's bootstrap code from for other areas of the code it suspects might need updates, it logs suggestions covered later. the task also reports changes that may affect a breaking change is a code modification between versions of liferay dxp that might be incompatible with existing plugins, including themes. the number of breaking changes, but couldn't avoid some. the theme's gulp upgrade command and the in liferay developer studio identify and address these changes the gulp upgrade task jump-starts the upgrade process, but it doesn't complete the rest of this tutorial explains all the theme upgrade steps, regardless of whether the gulp upgrade task performs them. steps the upgrade task performs even if you've already executed the upgrade task, it's best to learn all the steps and make sure they're applied to your theme the next step is to update the theme's metadata if you're developing your theme in an environment other than the plugins sdk, a theme's liferay version must be updated to 7.0.0 for the theme to run on if you're using the plugins sdk, open the url file and change the liferay-versions property value to 7.0.0 if you're using the liferay js theme toolkit, open the as the dtd and 7.0.0 as the compatibility version your theme's liferay version references are updated for liferay dxp 7.0. liferay dxp 7.0's ui improvements required these css-related changes the theme upgrade process involves conforming to these changes in this section, you'll update your theme's css to leverage the styling start with updating css file names for sass although sass was available in liferay portal 6.2, only sass partial files followed the note the gulp upgrade task renames sass files automatically for each css file you've modified in your theme, except url and url, change its suffix from.css to.scss then prepend an underscore to all sass partial file names for example, rename url to url here are the lunar resort theme's renamed css files refer to the theme reference guide for a complete list of expected theme css files next, the css rules must be updated to use bootstrap 3 syntax liferay dxp 7.0 uses bootstrap 3's css rule syntax. leverage bootstrap 3 features and improvements if your theme does not use the liferay js theme toolkit, you can refer to the migrating from 2.x to 3.0 guide for updating css rules to bootstrap 3 if your theme uses the liferay js theme toolkit, the gulp upgrade task reports automatic css updates and suggested manual updates. the task log for the lunar resort theme for each update performed and suggested, the task reports a file name and line since bootstrap 3 adopts the box-sizing border-box property for all elements and pseudo-elements e.g.,before andafter , padding no longer affects describes the box sizing changes. consider the padding updates the upgrade note for individual elements, you can overwrite the box-sizing border-box rule with box-sizing content-box in all css rules that use padding, make sure to update the width and height for example, examine the height value change in this css rule from the lunar after updating your theme's css rules, you should update its css responsiveness respond-to mixins for css responsiveness. follow these steps to update css replace all respond-to mixins with corresponding media for example, here is a responsiveness update to the lunar resort's the new media query media-querynull, breakpointtablet - 1 replaces the old mixin respond-tophone, tablet the liferay js theme toolkit's gulp upgrade task generates a file the file provides deprecated compass mixins that your consider upgrading your use of these mixins. the url file if you're using any of its mixins, but delete if you're not using any of the mixins, delete the you've updated the theme's responsiveness. next, you'll update its font awesome liferay dxp uses font awesome icons extensively. theme's design incorporates font awesome icons in its social media links figure 2 font awesome icons facilitate creating social media links the icons are easy to use in themes too in liferay portal 6.2, the css file url defined the font awesome icon paths. liferay dxp 7.0, the sass file url defines them note in liferay dxp 7.0, the url file holds the lexicon-base style describes all the liferay dxp theme files the top of the url file must start with the font awesome icons if you modified the url file in your liferay portal 6.2 theme, add these font awesome imports to the top of it next, you'll update the theme templates liferay dxp 7.0 theme templates are essentially the same as liferay portal 6.2 theme velocity templates are now deprecated in favor of freemarker templates the dockbar has been replaced and reorganized into a set of three distinct key reasons for using freemarker templates and deprecating velocity templates freemarker is developed and maintained regularly, while velocity is no longer freemarker is faster and supports more sophisticated macros freemarker supports using taglibs directly rather than requiring a method you can pass body content to them, parameters, etc the menus that replace the dockbar supports a more flexible and responsive design for creating better user experiences you should start by addressing the velocity templates. have been deprecated, you should convert your velocity theme templates to if you're using the liferay js theme toolkit, the gulp upgrade command reports the required theme template changes in the log for example, here is the command's output for the lunar resort theme for all the theme's templates, it suggests replacement code for deprecated code next, you'll learn how to update various theme templates to liferay dxp 7.0. didn't modify any theme templates, you can skip these sections the first one to update is the url theme template. customize url, you can skip this section in freemarker templates, the new syntax for including taglibs lets you use them directly rather than accessing them via the theme variable. described in the breaking changes all modified url theme templates must be open your modified url file and replace the following 6.2 directives with the corresponding 7.0 directives freemarker theme variable replacements replace the following link type the liferay-uiquick-access tag provides a keyboard shortcut to the page's replace all dockbar references with control menu references the dockbar was an all-in-one component that contained the page administration menus and the userportal administration menus. since been split and reorganized into three menus the product menu manage site and page navigation, content, settings and pages for the current site, and navigate to user account settings, the control menu configure and add content to the page and view the the user personal bar display notifications and the user's avatar and figure 3 the dockbar was removed in liferay dxp 7.0 and must be replaced with the new control menu the new design enhances the user experience by providing clear and if you used the split dockbar in your liferay portal 6.2 theme, remove dockbar-split from for example, remove dockbar-split from. remove the page title code shown below rather than include the page title on every page, it was decided that this decision should be left up to developers. modularization in themes, this feature can easily be implemented however you to ensure navigation is only rendered when there are pages, wrap the statement as demonstrated below finally, replace content div elements e.g.,... with html 5 section elements the div element works but the section element is more accurate and provides better accessibility for screen readers for example, here's a new content section element to support accessibility, consider adding an h1 element like the one note the liferay js theme toolkit's gulp upgrade command reports suggested theme template changes if you modified the navigation template for your theme, follow the steps in the follow these steps to update your modified url file element, add the following hidden heading for accessibility screen readers to access the layout, add the following variable declaration below the this variable grabs the layout for navigation. this variable to retrieve an icon for the navigation menu next to retrieve an icon for the navigation menu, replace the url the navigation template is updated that covers most, if not all, of the required theme template changes. if you modified any other freemarker theme templates, you can compare them with templates in the unstyled theme. and if your theme uses the liferay js theme toolkit, refer to the suggested changes that the gulp upgrade command reports after updating the theme templates, you can update your theme's resources liferay's resources importer is now an osgi module in liferay's web experience since the suite is bundled with liferay dxp, developers no longer need to download the resources importer separately api changes and upgrades to bootstrap 3 affect the following resources importer this section shows you how to update these components note the example lunar resort theme's resources importer web content articles have been modified to avoid known issue lps-64859. articles in the liferay portal 6.2 theme link to pages in the site's layout. and article import order, the links cause a null pointer exception. this issue with the example theme, the offending links have been removed from start updating the plugin properties for the resources importer if you're upgrading a plugins sdk theme, follow these instructions to update make the following updates to the theme's url remove the required-deployment-contexts property the plugin no longer needs this property as the resources importer is now an built-in and deployed with liferay dxp 7.0 since the group model class's fully-qualified class name has changed, replace the resources-importer-target-class-name property's value with the now that the resources importer's properties are configured properly, you can update your theme's web content all liferay dxp 7.0 web content articles must be written in xml and have a structure article creation requires a structure and article content follow these steps to update your web content in the resources-importerjournalarticles folder, create a subfolder, for example basicwebcontent, to hold the basic html articles move all basic html articles into the folder you just created in step 1 in the resources-importerjournaltemplates and resources-importerjournalstructures folders, create a subfolder with the same name as the folder you created in step 1 for the web content to work properly, the articles, structure, and template in previous liferay versions, article structures were written in xml. create a file structure-name.json, for example url, in the structure subfolder you created in the previous step for web content articles that use complicated structures and templates, create the structures and templates in liferay dxp in the json file you just created, add a json structure for the web content. for example, you can use a json structure like the one below for basic web this structure identifies the articles' language and field settings and specifies a name value to identify the content. in the template subfolder you created in step 3 e.g., freemarker template file e.g., template-folder-name.ftl and add a method in it to get the article's data for example, this method accesses content from the variable named content you've created the basic web content structure and template follow this pattern for basic web content articles you convert from html to for example, the 2 column url lunar resort article's html content should be converted to an xml file e.g., 2 column url whose content looks like this liferay dxp 7.0's migration from bootstrap 2 to bootstrap 3 requires that you replace all div element class attribute values of bootstrap 2 format spannumber with values that use the bootstrap 3 format device-size can be xs, sm, md, or lg. md works for most cases. explains the bootstrap 3 grid system continuing with the 2 column url article example, here is its that's all that is needed for most basic web content articles. following along with the lunar resort example, the updated xml articles are in the zip file's resources-importerjournalarticlesbasic web content folder note although liferay portal 6.2 used alloyui 2.0.x, liferay dxp 7.0 uses alloyui 3.0.x. as a result, you may need to update your code that uses alloyui. alloyui's examples and api docs next, you must update your resources importer's sitemap file in liferay portal 6.2, portlet ids were incremental numbers. the new ids are intuitive and unique. your url file with the new portlet ids some of common portlet ids are specified in the url example in the importing resources with a theme you can also retrieve a portlet's id from the ui in the portlet's options menu, select look and feel configuration figure 4 you can find the portlet id in the the look and feel configuration menu select the advanced styling tab the portlet id value is listed in the blue box figure 5 the portlet id is listed within the blue box in the advanced styling tab lists all the default portlet ids next, you can learn how to update your theme's ui to follow lexicon design liferay dxp 7.0 uses lexicon, a web implementation of liferay's lexicon experience language. the lexicon experience language provides styling guidelines and best practices while lexicon's css, html, and javascript components enable developers to build fully-realized uis quickly and effectively. demonstrates how to apply lexicon to a form for example, this is the liferay portal 6.2 lunar resort's reservation form the html code above uses bootstrap 2's markup and css classes here's the lunar resort form updated to lexicon the lexicon updates applied to the form are as follows you can apply similar lexicon design patterns to your theme's html files you've updated your theme to liferay dxp 7.0! you can deploy it from your theme liferay js theme toolkit-based project now your users can continue enjoying the visual styles you've created in your migrating a theme to liferay dxp 7.0 upgrading to liferay dxp 7.0 docs7-0deploy-knowledgebasedupgrading-to-liferay-7;;
all portlet plugin types developed for liferay portal 6 can be upgraded and upgrading most portlets involves these steps liferay's upgrade planner helps you adapt your code to liferay dxp 7.0's api. and resolving a portlet's dependencies is straightforward. you finish the above steps, you can deploy your portlet to liferay dxp the portlet upgrade tutorials show you how to upgrade the following common the tutorials provide example portlet source code from before and after each tutorial's steps were applied to the example you can refer to example code as you upgrade your portlet let's get your portlet running on liferay dxp 7.0!;;
becoming familiar with a platform as large and fully featured as liferay is a you learn the ins and outs of what it can do, the tips and best practices of the experts, and you work your way through the apis. this, you become more and more familiar with how things work, become more proficient with the platform as you multiply successes on it, and start to think in terms of how you'd solve problems most effectively using the tools the eventually, if you use it long enough, it can seem like an old friend that's ready to stand by you and help you succeed in your projects liferay dxp 7.0 was designed as an enhancement that builds off of what you already its upgrade planner and this tutorial seriesor learning pathhelp get your existing plugins running on liferay dxp 7.0 right away. after you upgrade your plugins, you can build and deploy liferay dxp 7.0 has exciting improvements for developers too. shows you how to leverage them. since you already know previous versions of liferay portal, you're several steps ahead of everybody else this learning path describes the benefits of liferay dxp 7.0 for developers compared to previous versions, the architectural improvements, the benefits that modularity brings, and how to develop modules and how they differ from you'll see all the options for leveraging new developer features, learn the pros and cons of each, and examine steps for optimizing in the end, we believe you'll both want to adopt liferay dxp 7.0, and you'll see note if you want to learn about liferay dxp 7.0's architectural improvements, osgi and modularity, and tooling improvements, read on. interested in upgrading your plugins first, skip to planning plugin upgrades and optimizations you'll start by seeing the familiar, good things that remain the same and then examine what's changed the most since liferay portal 6.;;
"this article documents the limitations for resolving potential startup performance issues when deploying custom themes and portlets in dxp 7.0. note the limitations are found only in 7.0 when using dxp 7.x, some developers noticed that after deploying their custom theme or portlet, the platform would take a long time to start. they noticed there was no resource cache like the ones in liferay portal to handle css file creation. recall that sass was implemented in portal 6.2 to help manage css files but also had potential errors despite the potential issues with sass and jruby in the legacy portal, you might have expected to see something similar in dxp where css files are processed when users are browsing at runtime. one major difference between liferay portal 6.2 and dxp 7.0 is most notably because of how sass is handled. see the links in the additional information section for more information in dxp 7.0 dxp 7.0 functions in the following way the overall result generating the.sass-cache values do not add additional delays when visiting the pages and there is little else that can be done to improve performance. no other settings are required to speed up the process for building or deploying modules remember that there are other factors that affect overall performance, such as time to pre-compile jsps, minification, whether spa is enabled, the app server cache, or connecting to ldap. also keep in mind that there are other ways to improve performance; perhaps increasing the number of nodes in a cluster, jvm settings such as garbage collection, or tuning the load balancer.";;
sometimes you want to use a database other than liferay dxp's. data source must be defined in url or configured as a jndi this tutorial shows how to connect specify the database and data source in your url create a spring bean that points to the data source set your entity's data source to the liferaydatasource alias note all entities defined in a service builder module's url file are bound to the same data source. binding different entities to different data sources requires defining the entities in separate service builder modules and configuring each of the modules to use a different data source in your url file, specify the same arbitrary data source name for all of the entities, a unique table name for each entity, and a database column name for each column. note the example's tag attributes data-source the liferaydatasource alias url specifies also note that your entity's s must have a db-name attribute set to the column name create the database per the database specification in your url next, use portal properties to set your data source if the application server defines the data source using jndi, skip this step. otherwise, specify the data source in a url file. distinguish it from liferay's default data source by giving it a prefix other this example uses prefix url. to do this, create a parent context extension e.g., url in your in your traditional portlet's web-infsrcmeta-infparent folder. folder if it doesn't exist already note since liferay dxp 7.1 fix pack 3 included in service pack 1 and liferay portal 7.1 ce ga2, the spring extender uses two application contexts for this lets liferay dxp register extender services earlier and separately from the service builder services and allows disabling features in the parent application context that may no longer be if you're using a prior version of liferay dxp 7.1, put your parent context extension e.g., url in your service builder module's srcmainresourcesmeta-infspring folder or in your traditional portlet's a data source factory spring bean for the data source. jndi specify an arbitrary property prefix and prepend the prefix to a portal properties specify a property prefix that matches the prefix e.g., url. you used in url a liferay data source bean that refers to the data source factory spring bean an alias for the liferay data source bean here's an example url that points to a jndi data source the liferaydatasourcefactory above refers to a jndi data source named if the data source is in a url file, the bean requires only a propertyprefix property that matches the data the data source bean liferaydatasource is overridden with one that refers to the liferaydatasourcefactory bean. the override affects this bundle module or the alias extdatasource refers to the liferaydatasource data source bean note to use an external data source in multiple service builder bundles, you must override the liferaydatasource bean in each bundle in your url file, set your entity's data source to the liferaydatasource alias you specified in your url file. also note that your entity's s must have a db-name attribute set to now your service builder services use the data source. use the services in your business logic as you always have regardless of the underlying data source you've connected service builder to your external data source connecting to jndi data sources running service builder and understanding the generated code business logic with service builder;;
this is no longer an issue with 7.1 fp10 recently, lps-85683 was implemented in liferay dxp 7.1's core infrastructure and can be deployed by applying dxp 7.1 fix pack 3. lps-85683 detailed a project where liferay core engineers refactored the spring extender to allow for subsequent incremental improvements in the core with the overall goal to improve performance. this was done by splitting the application context into parent the extender's spring files and child the service builder service's spring files. by making this change, we can register the extender services earlier and separately from the service builder services and in the future disable some of the unused features in the parent application context however, at the same time, this caused specifically any customized modules connecting to an external data source that are being added via spring beans using liferay's spring extender to stop working after applying fix pack 3. you should first read the tutorial connecting service builder to external databases to get the setup instructions before continuing this is a jndi blade sample that demonstrate how the url is used to connect to another external data source url.1gradleappsservice-builderjndi n ote this affects only liferay dxp 7.1 as noted earlier, this is because the application context was split into parent the extender's spring files and child the service builder service's spring files.;;
this article documents a known issue causing the instance activation service to be disabled by default when an lcs token is regenerated. the issue occurs for lcs tokens that have been created before january 17th 2019 if lcs admins regenerate the lcs token with instance activation disabled, and proceed to use that token in their liferay instance, the server will connect to lcs without activating. as a result, the liferay instance can be unregistered before regenerating a token, instance activation can be manually enabled by lcs admins to ensure there is no change in the registration status of the connected liferay instances if a token was unintentionally regenerated with instance activation disabled, lcs admins need to enable this service and regenerate the token again. in the meantime, if the liferay instances were previously registered, they will enter a 30-day grace period. brand new installations will be locked until the new token is in use note optional instance activation is not available for lcs tokens that have been generated prior to january 17th 2019. these tokens will continue to validate a server's subscription in all cases, regardless of the lcs client version lcs client 4.2 or lower performed in all cases lcs client 5.0 or higher performed if enabled by lcs admin instance activation default selection is the same as the existing selection activating your liferay dxp server with lcs;;
this article documents a list of known issues that exist in liferay commerce liferay commerce contains the following known issues, which will either be resolved through workarounds or in future commerce releases. see our downloads page for the latest liferay commerce downloads.;;
this reference article is for customers who design and troubleshoot their web pages using liferay dxp's adaptive media functionality. frequently, content creators inspect their web pages using tools built into their browser for various reasons. they want to see that all their web elements are functioning as intended or to ensure their pages are in compliance with industry standards for example, section 508 and wcag. it should not be a surprise when some image srcset may look different after using the native adaptive media widget once the status bar reaches 100, the embedded image inside the web content article's preview will be resized 1000px next, go to a site and view this article it was noted that when the mouse is hovering over an image to expose the source media, even though the srcset shows 1000px, the image's original dimensions may appear. likewise, when using a toggle to change different simulated views based on which device mobile or desktop, the thumbnail preview will change size the issue is not in the adaptive media portlet but the browser. the developer tools made available in firefox and chrome have their own settings which do not affect the settings in dxp. if you look at the screenshot below, you will see that the preview size is set to 1000px. this is the same as what was configured earlier designing and troubleshooting web pages can be a tedious process. web designers can be assured that liferay's adaptive media portlet is there to generate a uniform set of thumbnails based on prescribed width and height.;;
in the default liferay portal, we have a property called url or osgi configuration properties in 7.1 that allows administrators to restrict the types of files that may be uploaded however, this configuration does not apply to the separate knowledge base portlet, and there currently is no method to restrict certain file types from being uploaded into the knowledge base there is a feature request related to this issue that you can follow for future releases of the product;;
http cookies are small bits of data that are sent by the web application but stored locally in the browser. this lets the application use the cookie to pass information between pages and store variable information. the web application controls what information is stored in a cookie and how it is used typical types of information stored in cookies are session identifiers, personalization and customization information, and in rare cases even usernames to enable automated logins liferay stores two different types of cookies as follows only live in the browser's memory, and never stored anywhere. when the browser closes, the cookie is permanently lost from this point on. hence it gets destroyed when the browser session ends stored on the browser's hard drive. by default, liferay sets the max-age of the cookies at one year note one year is the max-age for these cookies, this doesn't mean these cookies will last for one year. these cookies actually will live as long as the browser. but rememberme will last for one year if the user doesn't uncheck remember me all cookies are set by the server via the set-cookie http header. a browser knows to store that cookie as a persistent cookie when it finds the keyword'expires' followed by a date in the future. if there is no'expires' tag, or if the specified date has already passed, then the browser will keep the cookie in browser memory only as a session cookie list of cookies liferay has set it is a boolean value, tells the portal if cookies are enabled or not used for user session identification, user authentication, remembering user language preference, and managing user sessions. the last cookie lfrsessionstate10196 is user session, 10196 is current userid. it is the state of the current session, the value is the date-time of login expires when the browser session ends unique identifier for the visitor's company. it's the id of the current instance session type of cookie if the user unchecks the remember me option the default expiration value of cookies is one year when the user checks the remember me option the default expiration value of cookies is one year if the user checks the remember me option it is encrypted login authenticate info, default authenticate type is an email address. so this cookie is encrypted of the user email address this cookie would be stored if the user checks the remember me option the default expiration value of cookies is one year jsessionid is an id generated by servlet containers like tomcat or jetty and used for session management in the j2ee web application for http protocol the id is sent to the client either within a cookie default or as part of the url called url rewriting, used only if cookies are disabled on the browser jsessionid expires a session, that means when the session expires or the browser is closed or the user logout, jsessionid will expire a value of 31536000 signifies a lifespan of one year in number of seconds. also, set this to the maximum age in a number of seconds of the browser cookie that enables the remember me feature. adjusting this value will modify the expiration date of all cookies relating to the authenticated session password, login, id, etc.. this functionality gives the ability for users to stay logged in for longer periods of time without needing to re-authenticate also to control third-party cookies, you can adjust your browser settings. however, doing so will likely mean that our site might not work as you would expect for example, liferay marketplace portlet is unable to load the store and other marketplace pages if 3rd party cookies are enabled. there is a marketplace unavailable error message after a while. feature request for reference url;;
"changes made to a site template can be propagated to sites whose page sets are when you create a site based on a site template with the enable propagation of changes from the site template box checked this to configure propagation of changes select the site from the sites dropdown in the menu by selecting the navigate to the configuration site settings page and uncheck or recheck the enable propagation of changes from the site template checkbox in this section, you'll learn about the propagation of changes from site templates to sites and discuss the options available to site administrators and if a site's page set has been created from a site template and the propagation of changes from the site template is enabled, site administrators can add new pages but cannot remove or reorder the pages imported from the site template. a site has both pages imported from a site template and custom site pages, the site template pages always appear first in the site page hierarchy; custom pages added by site administrators appear after the site template pages. template administrators can remove, reorder, or add site template pages. administrators can add or remove custom site pages. site pages as long as they're all positioned after the site template pages. template administrators cannot add, remove, or reorder custom site pages note pages containing a fragment e.g., cannot propagate changes after a site is first created based on a site if a site administrator changes a page that was imported from a site template and refreshes the page, the following information icon in the control menu with the following message figure 1 you can click the information icon to view important information about your site template if the site administrator clicks the reset changes button, changes are propagated from the site template page to the corresponding site page that was imported from the site template. clicking the reset changes button makes two first, changes made by site administrators to the second, changes made by site template administrators to the site template page are applied to the site page. changes button only resets one page. if multiple site pages have been modified and you'd like to re-apply the site template pages to them, you'll need to click the reset changes button for each page site template administrators can set preferences for apps on site template when a liferay administrator creates a site from a site template, the app preferences are copied from the site template's apps, overriding any default app when merging site template and site changes e.g., when resetting, app preferences are copied from site template apps to site apps. preferences or local app preferences which don't refer to ids are overwritten in some cases, merging site template and site changes fails. pages from a site template cannot be propagated because their friendly urls are in conflict, liferay dxp could try to continuously merge the site changes. of entering into an infinite loop of merge fails, liferay dxp stops the merge after several unsuccessful attempts. liferay dxp, however, doesn't stop there your merge is temporarily paused, you're given an indication of the current merge fail, and then you have the opportunity to fix your merge conflicts. you've squared away your conflict, navigate to your site's site administration configuration site settings and click the reset and figure 2 this type of warning is given when there are friendly url conflicts with site template pages the reset and propagate button resets the merge fail count and attempts to propagate your site changes again. this process gives you the opportunity to detect and fix a merge fail when problems arise. be done with page template merges, which follows similar steps site administrators can also add data to site template applications. example, site template administrators can add the wiki app to a site template page and use the wiki to create lots of articles. creates a site from a site template, data is copied from the site template's the preferences of the site's apps are updated with the for example, if a site is created from a site template that has a wiki app with lots of wiki articles, the wiki articles are copied from the site template's scope to the site's scope and the site's wiki app is updated with the ids of the copied wiki articles important app data, fragment-based pages, related resources, and permissions on resources are only copied from a site template to a site when that site is first created based on the template. entities are propagated to the site after the site is created. such changes propagated to a site by the reset or reset and propagate for example, consider a site template administrator who includes a message boards app as part of a site template. categories and configures permissions over the actions of the categories. first time a site is created based on the site template, the categories app data and related permissions are copied to the site. administrator adds, removes, or deletes some categories, however, such changes now that you've learned how site templates work, you'll learn how to share site";;
web content templates allow the use of liferay taglibs for creating common front-end ui components in your web content. please note that by default, templates are cached to improve its performance, meaning that taglibs may not function correctly if included in the template's script this is a known limitation, and the implementation of lps-94656 makes this clear in the template's help text. if you are using taglibs within a template, please make sure that the cacheable checkbox is unchecked.;;
this article describes how content and display pages created by using a site template behave differently from widget pages when a propagation happens unlike widget pages where changes are propagated if the propagation of changes is enabled, content and display pages do not propagate the changes after the site template is modified actually, content and display pages behave like app data, that is, they are only copied at the time of creating the site therefore, successive changes in the content and display pages of the site template will not be reflected in the respective pages of the site for more information, see propagating changes from site templates to sites;;
with the implementation of lps-96064, it is possible to use data providers when liferay dxp 7.1 or 7.2 is setup to go through a proxy server the only caveat is data providers that require authentication will still not work. in such a case, no data will be retrieved and liferay will silently throw a 403 error. this error can be seen in the logs if these classes are set to the following log levels in summary, if your data provider does not require authentication, it will work behind a proxy.;;
struts is a stable, widely adopted framework that implements the model view if you have a struts portlet for liferay portal 6.2, you can upgrade it to liferay dxp 7.0 upgrading struts portlets to liferay dxp 7.0 is easier than you might think. liferay dxp lets you continue working with struts portlets as java ee web on deploying a struts portlet web application archive war, liferay dxp's web application bundle wab generator creates an osgi module bundle for the portlet and installs it to liferay's osgi framework. portlet behaves just as it did in 6.2 on your liferay dxp 7.0 site this tutorial demonstrates how to upgrade a portlet that uses the struts 1 framework and refers to liferay's sample struts portlet sample struts as sample struts uses several struts features to show page navigation, action and actionform controller classes, exceptions, and figure 1 the sample struts portlet's charts compare fictitious soft drink survey results here are the sample portlet's characteristics you can follow this tutorial to upgrade your struts portlet. can examine the sample struts portlet source code from before and after its here's the sample struts portlet's folder structure upgrading a struts portlet involves these steps adapt the code to liferay 7.0's api identifies code affected by the new api, explains the api changes and how to adapt to them, and in many cases, provides options for adapting the code adapting the sample struts portlet's code is straightforward. the liferay portal 6.2 sample struts portlet depends on liferay portal to provide required third-party libraries and tag library definitions tlds. portal-dependency-jars and portal-dependency-tlds properties in the portlet's url specifies them resolving the tag libraries is easy liferay dxp 7.0 continues to provide many of the same tlds liferay portal 6.2 provided if the liferay dxp 7.0 application's web-inftld folder contains a tld you need, add it to your portlet's portal-dependency-tlds property in the if the folder doesn't contain the tld, find the tld on the web, download it, and add it to your portlet's web-inftld third-party libraries listed as portal-dependency-jars in a 6.x portlet's url file might not be provided by liferay dxp 7.0. liferay dxp has replaced some of liferay dxp 7.0 exposes exports java packages instead of sharing jar content if you need packages liferay dxp doesn't export, you can find and download the artifact jar that provides them and add it to your portlet's here are steps for resolving the sample struts portlet's java package liferay dxp doesn't export antlr packages. url with newer jar url from liferay dxp doesn't export packages from url. portlet's jar file url with these jars from portlet's jar file url with the following ones from the import-packages heading in the url lists the following jar files sample struts requires. module exports packages from these jars, add their names to the portal-dependency-jars property in the portlet's add all the rest of the jars the sample struts portlet depends on to the the following table summarizes the sample portlet's java dependency resolution sample struts portlet's dependency resolution for more details on resolving dependencies, see the tutorial resolving a plugin's dependencies you've resolved the sample struts portlet's dependencies. to true default forces calls to url. although this improves performance by avoiding unnecessary fall-backs, it can cause attribute lookup problems in struts portlets. your sites, makes sure to set the portal property deploy the struts portlet as you normally would. indicating the following portlet status deploying the sample struts portlet produces these messages the struts portlet is available on your liferay dxp instance congratulations on upgrading your struts portlet to liferay dxp 7.0!;;
apache struts 1.x has been included in liferay dxp 7.0. apache struts 1.x reached its end of product life in 2013. what is liferay's stance towards continuing to use apache struts in current and future versions liferay's products only utilize a limited set of struts 1.x's capabilities and thus not all reported vulnerabilities apply to liferay's products. liferay has been supporting and patching struts 1.x on its own since 2013. specifically, liferay has been fixing security vulnerabilities found in struts 1.x when those vulnerabilities pose a security vulnerability to liferay's products liferay product team has decided not to use apache struts 2.x in the upcoming version of liferay dxp 7.2 lps-75763 . see the information below specific to your product version regarding apache struts 1.x apache struts 1.x has been completely removed from dxp 7.2. some of the liferay dxp code still contains the word struts. however, liferay dxp 7.2 does not have any dependencies on the apache struts libraries beginning with dxp 7.1 fix pack 3 and higher, apache struts has been partially removed from the platform. apache portal bridges was removed from util-bridges. apache's struts-el, struts-extras, struts-taglib, struts-tiles libraries have also been removed. other apache struts dependencies such as the struts-core library have not been removed. specifically, the only feature used within apache struts 1.x is the struts action and action configuration capabilities. struts' action form, tag libraries, tiles, and other related capabilities are not utilized custom modules which attempt to leverage apache struts through liferay dxp will have to call any struts classes directly or include third-party dependencies in their module beginning with dxp 7.0 fix pack 59 and higher, struts has been partially removed from the platform. however, this should not cause any negative impact for customers who install fix pack 59 regardless of your apache struts implementation developers using apache struts in their custom modules may be affected by this change. it depends on whether they are using struts actions within a portlet or have created a struts portlet. the partial removal will break struts portlet dependencies since the required third-party libraries are unavailable in the liferay dxp system. there should be no impact if developers are using struts actions. see this article for more information about updating a struts portlet and upgrading portlet plugins.;;
question how are liferay dxp 7.0 and 7.1, and liferay portal, affected by the following vulnerabilities for customers on liferay dxp 7.0 and 7.1, the vulnerabilities affect primarily liferay portal 6.2. the fixes are already incorporated into the dxp platform concerning cve-2016-1182, liferay dxp does not use struts validation messages concerning cve-2016-1181 and a related issue cve-2015-0899, liferay dxp and portal are not vulnerable because the two products do not use struts forms and do not store them inside the session a possible fix may break some custom applications because support for struts validation output messages has been removed.;;
after setting url to disable autocomplete for user login information, the browser still permits users to save passwords or use password managers to manage password autocomplete or autofill this is due to a lack of consensus andor rejection of the autocompleteoff form property from the major browser development teams o ne of the top user-complaints about our html forms autocomplete feature is it doesn't work-- i don't see any of my previously entered text. when debugging such cases, we usually find that the site has explicitly disabled the feature using the provided attribute, but of course, users have no idea that the site has done so and simply assume that ie is buggy. in my experience, when features are hidden or replaced, users will usually blame the browser, not the website in this case, the team decided that keeping the user in control was of paramount importance i wanted to give a heads up that now, by default, chrome ignores autocomplete'off' for password fields. this allows the password manager to give more power to users to manage their credentials on websites. it is the security team's view that this is very important for user security by allowing users to have unique and more complex passwords for websites firefox bug report that was marked as fixed autocompleteoff does two things a prevents us from automatically filling in already-saved data for formsfields that have the attribute b prevents us from saving new data for formsfields that have the attribute this behavior is a concession to sites that think password managers are harmful and thus want to prevent them from being effective. in aggregate, i think those sites are generally wrong, and shouldn't have that much control over our behavior i think we should investigate removing support for autocompleteoff entirely, or at least the portion of it that prevents us from saving passwords to summarize, several of these major browser teams felt that sites that disabled autocomplete took away the agency of users to handle and manage passwords for themselves. because of this, there has been a large push to remove or change this functionality. in future releases, the url property will be slated for removal from liferay.;;
the audience targeting section of the configuration section of the site administration area of the menu allows you to manage user segments and figure 1 click on configuration audience targeting in site administration to manage user segments and campaigns for a site a user segment represents a subset of the total group of portal users logged in a user segment is defined by one or more rules that users must match to belong to that user segment. once the user segment is created, only users who visit the applicable sites are added to it. all the rules that have been deployed appear under the rules heading. rule to the right to apply the rule to the user segment. applied, you can adjust the rule's parameters. for example, once the gender rule has been applied, you can select male or female. applied, you can select an older than value and a younger than value. example, you could define a women over 30 user segment by applying the gender rule and selecting female, and applying the age rule and setting the older some rules are also instantiable, meaning you can apply more than one of the same type of rule to a user segment. this allows you to create scenarios where you need to segment your audience based on actions that might occur multiple times e.g., visiting multiple pages, viewing multiple banners, having several once you've customized the rules for the new user segment, entered a name and, optionally, a description, click save to actually create the user segment figure 2 after applying the rule, click the rule to explandcollapse it once you've created a user segment, you can open its summary view, which displays relevant data and configurations figure 3 select a pre-existing user segment to view its summary page to configure permissions for creating, editing, and deleting user segments, visit the users roles section of the control panel. actions define permissions button corresponding to the role you'd like to configure permissions for, and search for audience targeting both user segments and campaigns are inherited in your site hierarchy. therefore, user segments and campaigns defined in the global scope will be user segments and campaigns created in a site will be available to all of its child sites custom rules can be created by developers and deployed as osgi plugins. creating new audience targeting rule types these are some of the rules that are included with the app by default the score points rule assigns 1 point to a user each time the user views a page or content that's been categorized under the user segment to which the rule has once a user exceeds the configured threshold, the user matches for example, suppose that your website is about sports and you have pages and content about basketball, tennis, and soccer. your audience into three user segments basketball fans, tennis fans, and soccer fans in order to display the most relevant content to them on your site's front after creating these three user segments using the score points rule with a threshold of, say, 20, you should appropriately categorize the content which would be most relevant to each user segment. for example, apply the basketball fans user segment to content about basketball, apply the tennis fans user segment to content about tennis, etc. now, every time a user even a guest user visits a page or views a piece of content categorized for a user segment to which the score points rule has been applied, the user will start accumulating once the user has accumulated enough points, the user will belong to the after a user has visited more than 20 pages or pieces of content related to basketball, the user will belong to the basketball fans user segment. once the user belongs to a user segment, you can use that information to direct more relevant information to the user in your website using the user segment each new user segment that's created can be used to categorize pages or content. the audience targeting app adds a new user segment select button to the seo section of pages and metadata section for assets. assign one or more site-scoped or global user segments to the content. categorization has mainly two purposes figure 4 pages and content can be categorized for user segments you don't have to create categories for each of your user segments. segments are distinct from regular vocabularies. pages and assets contain distinct select buttons for user segments and regular another way to display user segments is through the asset publisher app. enable the asset publisher to retrieve assets that have matching categorization with the user segments of the current user. this enhances the asset publisher to only display relevant content to the user. navigate to the asset publisher's options and select the audience targeting option. figure 5 enabling the user segments filter retrieves assets that match the current user's user segments next, you'll learn about managing user segment reports when managing user segments, you can select the user segment name and then select the reports tab to see the list of reports available for each user click the report name to view the report or actions reports display a summary of interesting information for example, the content views report shows the asset that's been most viewed by users that belong to the user segment figure 6 this report displays what pages the user segment has visited reports also display which users belonged to a user segment. administrator know which users of the site qualified to the particular user liferay dxp provides a convenient way to export a list of user segment simply click the user report you're interested in and select the this downloads a csv file with the list of users additional reports can be created by developers and deployed as osgi plugins. see the reporting user behavior with audience targeting reports are generated daily by default. to generate a new report when currently viewing a report, click on the update button from the options icon next, you'll discover how to use your user segments in a campaign.;;
the navigation menu widget lets you add navigation wherever you need it. you can place the widget on a page and then select a menu and style for the menu you are displaying. this widget provides a template list menu which can display multiple layers of the menus in a vertical list please note that only list menu was designed for multiple child pages to be shown. please feel free to create a custom display template if you would like to implement new designs.;
this article documents a limitation when viewing content based on a user segment in the audience targeting app that uses the physical screen size attributes as a mobile device rule. it was discovered that users could not view any content created with this set of conditions. this means that the liferay instance cannot detect desktop devices if the rule uses physical size attribute after the content has been created, in the tests, it was discovered that the segmented content for such conditions did not display when on a desktop device it was also discovered that even using a third party'user-agent' browser add-on such as chrome's user-agent switcher, the content was still not viewable the reason why user-agent switchers are not viable workarounds is because they typically do not contain information regarding the physical size of devices. rather, they usually contain information related to the web browser or os being used, or screen resolutions, not the physical dimensions of the monitor or laptop. see below for the technical specifications. the limitation is found in 51degrees' implementation. note 51degrees is a third party detection tool used by liferay dxp used to validate mobile device rules. regardless of whether the user has a user-agent app or not, 51degrees' mobile detection device does not detect the physical dimensions due to the various hardware options. in other words, it cannot differentiate between a 17 monitor and a 19 monitor that have the same screen resolution. instead, the mobile device rules track the screen resolution for example 1920x1080, 1440x900 which are known values the second option could be close enough to the actual sizes for most standard desktop monitors and the larger laptops for more general information about creating user segments, here is the managing user segments article refers to the screen width of the device in millimetres. this property will return'unknown' for desktops or for devices which do not have an integrated screen.;;
modifying the time zone settings at the jvm level url or url in tomcat will affect all of the processes run in that jvm this article describes several known issues that may be experienced if the time zone is not set to gmt at the jvm level when the time zone is not set to gmt at jvm level, the start date and end date of the all day events exported from the calendar portlet might display the incorrect date after the exported.ics files are imported to microsoft outlook. the root cause is that changing the time zone at the jvm level will cause the portal to wrongly calculate the start date and end date of the all day events also, another related issue can be found at lps-33526 when the time zone is not set to gmt at jvm level, for example, it is configured to url europeberlin, the web contents created using structures that have the date fields will display incorrect dates after publishing after publication, see that the date is set to the day before the one set in step 5 in summary, each date stored in the portal's database is must be stored in gmt time. when the portal needs to display one stored date to the end users, the portal then calculates the display date based on the current date of the application server this date is affected by the configured jvm level time zone and the stored gmt format date. in order to make sure the display date is calculated correctly, the time zone must be configured to gmt at the jvm level. otherwise, it will result in incorrect time zone offset and then cause the display date to be wrongly calculated and displayed.;;
please read about the following important changes in liferay portal 6.2 ee fix packs before installing please note this fix pack requires java 8 lsv-636 resolves a critical security vulnerability with url lsv-600 resolves a critical security vulnerability with ldap credentials please note due to the fixes made under lsv-399, this fix pack requires java 8 lsv-545 resolves a critical remote code execution rce vulnerability via json web services jsonws lsv-535 resolves a critical security sql injection vulnerability that exists in the asset framework lsv-399 resolves a critical security vulnerability with apache tika lpe-16655 resolves a critical security vulnerability with remote code execution via deserialization of json data lpe-16614 resolves a critical security vulnerability with workflow definitions being used to gain access to information in a different site or virtual instance as well as the operating system lpe-16514 resolves a critical security vulnerability with remote code execution using web contentddm templates by updating the following url lpe-15645 removes the utilities swfupload and videoplayer. this change removes outdated code no longer being used in the platform and avoids future security issues from outdated flash movies. anyone who is using the swfupload alloyui module or any of the associated swfuploadf.swf and url flash movies will be affected we recommend users switch to new standard ways of uploading media such as alloyui's own a.uploader to manage uploads consistently across browsers. for audiovideo reproduction, use alloyui's a.audio and a.video lpe-11551 deprecates the method url and changes its logic as suggested in the javadoc documentation, getsummaryportletrequest, portletresponse should be used instead. if a new class is created to extend baseassetrenderer, it might be necessary to overwrite url, portletresponse because the formerly referenced deprecated method will be called. this will result in an unsupportedoperationexception lps-71163 reverts changes made in lps-67445 to resolve a security vulnerability found with permissions. please note that this revert changes the error message to be shown in the ui as not found instead of forbidden lpe-14846 changes the way that liferay stores and renders ddm date fields. the ddm date fields will now be stored and rendered using utc timezone regardless of the configured timezone in url jvm parameter. in order to update the old templates and ensure that all dates are rendered in utc, a verify process should be executed. if the url has been changed to a non gmt value, a groovy script must be executed to update those values to utc please navigate to this knowledge base article for further instructions lpe-14929 changes the table mapper cache from explicit excluding to explicit including, which means the cache is disabled for mapping tables by default. this may cause a large performance impact for some users in order to avoid this, please manually set the property url to include mapping table names in url file if you continue to experience performance degradation, please remove the usersroles, from the mapping table names.;;
this article describes how to deploy patches to liferay in a variety of environments. the steps are seperated by application servers and based on the patching process that was used prior to 6.0sp2 where we introduced the patching-tool, hot-fixes and fixpacks installation tip i found that deploying liferay via command line worked better than through the gui. the easiest way to do this is to navigate to cglassfishhomeglassfishbin, place your url file, then type asadmin deploy url. input your windows password and it should deploy!;;
reference the table below for an overview of what is included in liferay portal 6.2 ee service packs.;
"this article documents a common performance issue related to running too many cpu intensive tasks within liferay dxp 7.0. continue reading to discover the necessary information about this issue and how to navigate through it the following are some of the more common causes and solutions some subscribers may encounter a performance issue when many cpu intensive tasks are running at the same time. this is a generalized pattern that could come from a variety of use cases. depending on the severity of the issue being faced, the thread dump may contain anywhere from tens to hundreds of threads working on such tasks. customers will see higher cpu usage and slower response times, and in rare cases, the liferay platform will become seemingly unresponsive please review the following information regarding the more common causes, and the subsequent solutions the minifier will attempt to minify css and javascript resources before sending them to the browser. this action will save network bandwidth as it will result in smaller files. however, it entails a performance penalty on the cpu minifier is enabled by default but can be turned off by setting the below property in the url url in a thread dump, we would notice this issue if we were seeing the following string dozens, or in some cases, hundreds of times here is another occurrence from the same thread dump using spotify's online thread dump analyzer in such cases, notice that the exact stacktrace may be different. since all these threads are executing, they are at different stages of their lives all of them waiting for cpu time to be able to progress which leads to resource starvation the solution to this is to evaluate whether css and javascript minification is needed. if minification is necessary, then further resources may be needed. subscribers should consider clustering the platform use or use additional resources by caching by web servers or offloading static content to cdn servers. if minification is not needed, then simply turning it off via the aforementioned url property should ease the stress on the on the cpu the stripfilter is similar to the minifier in that the end result is smaller files in exchange for cpu usage. see the comment for liferay portal 6.2 the strip filter will remove blank lines from the outputted content. this will speed up page rendering for users that are on dial up. we recommend turning this off from the start because there is no real benefit compared to the cost on the cpu. removing new lines from the response should save some space. however, gzipping the content is very efficient and it does not really matter whether there is newlines in a file or not except in extreme edge cases. furthermore, the time it takes for the browser to load a page is only affected minutely; the majority of time taken to load a page is spent waiting on resources to be downloaded anyway this means that there is no benefit of doing this for the network nor for the end user and yet it has performance impact on the cpu to find such threads, just search for the string url. - if there are more than five occurrences in any given thread dumps, be aware that your response time is suffering because of this. included below the top of a stack trace that is actually executing the stripfilter the gzipfilter's job is to compress the response going back to the browser to save on bandwidth and, ultimately, page load times. it is controlled by the below property the gzipfilter was introduced earlier when discussing the stripfilter's impact; in that section, it was stated that having the stripfilter enabled is not needed because the gzipping the response is more beneficial anyway. the choice of the word gzipping instead of gzipfilter is intentional; if at all possible, liferay recommends alternative ways of gzipping the content. for example, apache's moddeflate has the benefit of being on another box which allows another server's cpu work on compressing the response. the gzipfilter is hard to catch as its main job is to compress everything once the response is ready. therefore, the execution process is visible by seeing gzip related java classes executing at the end and a gzipresponse1 object being locked, for example as mentioned, our recommendation is turning the gzipfilter off and relying on other services if possible, even if there are currently no performance issues caused by or related to gzipfilter comparing passwords is done by hashing the password that the user specified in the form, then comparing it with the already hashed and saved password in the database. by default, the liferay platform uses a computational heavy algorithm pbkdf2 with hmac sha1 with 160 bit hashes and 128,000 rounds below is the portal property that sets the encryption algorithm the reason it has such a toll on the cpu is because of the way it works. it uses a pseudo-random function on the input text plus a salt to create -bit hashes default 160, then repeats it times default 128,000. as a result, many users logging in at the same time could potentially lock up the portal for a while until the cpu can handle all the requests. below is the top of a stack trace from a thread working on a user login seeing multiple threads, like this one, working on encrypting the password is an indication that the liferay platform is suffering and users will report or have already reported long wait times when they are trying to log in there are a few solutions to this issue.";;
this article documents a common performance issue related to thread contention within liferay dxp 7.0. read below for the necessary information about this issue and how to navigate through it thread contention is when there are multiple threads waiting to lock the same object. this can get out of hand as the time it takes for a thread to acquire the lock grows with the number of threads waiting for the lock. this is made worse by the fact that the jvm does not utilize a fifo system when awarding the lock to one of the waiting threads it chooses one based on some criteria, and for our purposes that may as well be random symptoms depend on the the severity of the thread contention. if there are only a couple of threads affected, then we may only see slower response times. if hundreds are affected, then the liferay platform may as well be completely unresponsive here is an example from logging in this case, log4j is waiting to lock a rootlogger object and its execution is suspended e.g. state is not runnable until the lock is acquired. if searching for the id 0x0000..., it might display that a lot of other threads are also waiting on the same object if there are over a dozen or even hundreds of threads trying to call log4j's url and are waiting to lock the same object, it is definitely a thread contention issue spotify's online thread dump analyzer summarizes this result neatly it is a thread contention issue if a lot of threads are waiting to lock objects, and this state persists throughout multiple thread dumps possible solutions to these issues are;;
this article documents a common performance issue related to insufficient resources within liferay dxp 7.0. read below for the necessary information about this issue and how to navigate through it often, servers have to multi-task because they are running not just a liferay platform, but other applications as well. for example, sometimes the database is on the same machine or a web server. other times the server may be hosting other applications, such as elasticsearch in an insufficient system resources situation, this is when the application is slow. this does not happen because the application is actually slow, but because it is not getting all the resources that it needs from the underlying server. in other words, it has to wait for the processor, hard drive or network to be able to continue serving individual requests one indicator is when the server's cpu has a high utilization but there is no sign of activity in thread dumps or according to pidstat one of the other indicators that the liferay platform is waiting for resources is if we see that'real' time is higher than usr and sys combined normally, real time is less than user and sys combined, as it measures wall time whereas usr and sys measure cpu time. if we have a process that spends 1 second in 4 processes, then it is possible that usr time will be 4s whereas real stays at 1s. we can see this kind of information from garbage collector logs or pidstat. system administrators should investigate server performance, specifically what other processes are running and how much resources they are consuming. lastly, consider whether other applications can be moved to different servers.;;
this article documents the circumstances for when properties in the url are not working correctly. this article also discusses common causes for the properties in the url not taking effect and provides instruction on the proper ways to configure the file, as well as where to place it, to ensure that the properties set in url are implemented correctly any settings saved while in the control panel user interface will be saved to the database, and therefore, take precedence over any url configurations for a reference of all properties within the liferay platform, take a look at the url file. this file is located inside the url. in addition to what properties are available, most properties will have an explanation of what they do and what values you are able to set. you may also find the url on our javadocs pages the url can be configured perfectly, but if it is not located in a place that the portal can detect then it will not take effect. there are two places to put the url as the liferay platform is starting up, the property files being loaded will be displayed right before the database connection. note if the default liferayhome was changed, please be sure to specify the value of to the directory that will form the base path of the module framework having multiple copies of the same property will cause the liferay platform to use all of those values and this will very likely cause issues. for example, this property will control if the host name of the liferay portal server will show the valid values are either true or false if there are multiple copies of url, even if both are set to be true, then liferay portal will read this as true, true in the database. since this is not a valid value, this property will not take effect keep in mind that it is also possible to include other property files other than the url using the include-and-override property. it is important to note that the include-and-override properties are loaded in the order that they are listed. for example, if properties in url are set at one value and the same property set to another value in url, the url will override the url because url is loaded after url if there are additional property files, make sure that there aren't any conflicting or duplicate properties if you misspell url, then the liferay platform will not read the file and its contents will be ignored. another common mistake on windows that can happen is if the file extensions are hidden from the filename. so if you create a new text file as url, it will actually be url and also will not be read by the liferay platform.;;
"this article documents a known issue when building a theme in dxp 7.1, using developer studio 3.3 theme build fails with the following exception one possible workaround is to add the compatmixins; property to url";;
this article documents a known issue for customers using ckeditor in liferay digital experience platform 7.0 when editing content that uses ckeditorsuch as a message board threadon a microsoft edge browser, you might notice that the cursor cannot be placed at the end of the subject line. unfortunately, this is a known issue that has surfaced with the ckeditor that is included out of the box ootb with liferay digital enterprise 7.0 ensure that url has been set in the url file. that way, the liferay platform uses ckeditor and not alloyeditor as the default editor several workarounds are available for this issue see edge loses selection position when focused the first time for more information on the ckeditor updates.;;
this article documents a known issue with png files that are uploaded to document library not displaying in ie11 with a dom7009 unable to decode image at url in the console as a security measure, and to prevent malicious scripts from being executed in browsers, liferay sends the x-content-type-options nosniff http header to protect against mime sniffing this behavior is known, and intended, since internet explorer 8 according to microsoft's documentation to summarize, the script and stylesheet elements will reject responses with incorrect mime types if the server sends the response header x-content-type-options nosniff there are two options to resolve this behavior. please be aware of the potential risks that are at hand when either of these two options are being set and proceed at your own discretion disable x-content-type-options nosniff being sent from liferay define the exact urls that will allow for unhindered mime sniffing;;
this article documents a known issue with internet explorer 9 ie9 when accessing the liferay digital experience platform 7.0. upon accessing the browser page webguesthome, the page is blank as shown in the image below microsoft ended support for internet explorer 9 after january 12, 2016. users are advised to upgrade to microsoft edge which is supported by microsoft and on the liferay dxp 7.0 compatibility matrix in the meantime, customers have the following options;;
as many liferay subscribers use lightweight directory access protocol ldap to manage their users, this article is intended to address a variety of issues surrounding the liferay-ldap configuration. this includes import, ldap in a cluster, indexing, multiple domains, and more when is an ldap user imported into liferay? there are three ways that ldap users can be imported intoupdated in liferay import upon user logging into liferay. for most users, this setting will be sufficient mass import on startup url with this option selected, liferay will update all users from ldap when the portal starts up. this can be helpful in some cases, but keep in mind that with a large number of users this can make start-up a slower, more resource-intensive process. as the name implies, this will allow the portal to constantly update users every x minutes. this can be helpful if you want all users constantly updated. again, though, with a large number of users this can be extremely resource-intensive the above property is set to the default, that being 10 minutes. note it is recommended that users do not turn both interval and startup importing at the same time. this is likely to cause multiple imports at the same time which is a highly undesirable occurrence. to avoid mass simultaneous imports which can slow the system to a halt, cluster the quartz job with url, and disable import on startup however, the quartz property has been deprecated in liferay portal 6.1.x ee and 6.2.x ee. if data in the index is not correct, this could cause issues with an ldap import as liferay checks for user information on the index before creating or updating user information. a likely symptom iof this would be a nosuchuserexception or duplicate screennames. re-indexing will alleviate many of these issues. how do i turn on logging for ldap? there are two methods for turning on logging for ldap- the first is a temporary setting while the second will remain even after a server restart navigate to control panel - server administration - log levels. find comliferayportalsecurityldap and change the level to debug add change the following value to your url file for more information on setting up a url file see the article at url with option 2, the setting sticks during server restarts can i import ldap users from multiple domains?;;
this article describes the issue with setting url portal property preventing all documents and media file uploads, including using the multiple filder uploader add the following to your url found in the liferay home directory notice that the upload is rejected and a message stating, please enter a value with a valid extension is shown this fix is included in the portal 6.2 sp9 from liferay help center.;;
this article describes known issues that have been encountered when publishing large files using remote staging known issue invalid checksum for lar file error when the staging server transfers the lar file in smaller chunks to the live environment, the assemble order is not guaranteed there, and this will cause errors in the staging process lps-47637 the process fails with the following error message the publication process did not start due to validation errors. the process will mark the chunks when splitting the lar so it can be assembled in the correct order. this issue has been fixed and is already available on the portal downloads page also in liferay portal 6.2 ee sp7 and above known issue cannot publish to remote site if lar is over 2.15 gb when the staging process encounters a file that is bigger than 2.15 gb, it will break the file into chunks to make the transfer work as expected. however, the position value isn't being updated correctly during the process, which creates a corrupted zip file see lps-52303 for more information please specify a lar file to import the solution which updates the position value correctly only exists on the master branch currently. while a fix pack is not available, please submit a help center ticket and ask for a temporary hotfix that contains the fix for lps-52303.;;
before the portal-84-6210 fixpack, the ddmtemplate editor ui was missing the cacheable checkbox. this issue caused each ddmtemplate that was saved into the db to not be cached. this article provides a solution to a potential heavy performance drop casued by xml parsing and template processing each time an article is displayed portal 6.2 ee fix pack portal-83 and below to resolve this problem, apply fix pack portal-84 or the latest version. after applying the fix pack, the formerly saved ddmtemplates should be opened, set to be cacheable and resaved. if you are unsure whether your system is affected or not, please execute the following steps if you see your custom ddmtemplates in the results then you are facing this problem to measure how much of a problem it can cause, just take a look at the following cache as mbean url.journalcontent if you hit pages where caching could be done, the misses counter increases and you will see plenty of cache misses instead of hits with heavy load, the difference between page load times can be 50-80 faster when using this fix. in addition, remember to update the ddmtemplates to be cacheable see lps-48693 for more information.;;
liferay portal 5.2 is a platform for creating effective business applications and solutions. it offers a robust feature set, impressive scalability, time-saving development tools, and a flexible, scalable architecture that is open source developed and enterprise refined download the attachment to access the admin guide.;;
liferay portal 6.0 is a platform for creating effective business applications and solutions. it offers a robust feature set, impressive scalability, time-saving development tools, support for over 30 languages, and a flexible, scalable architecture that is open source developed and enterprise refined download the attachment to access the admin guide.;;
this article documents a known issue with adding categories, tags or related assets to files in the document and media library. when you try to do this, a new version of the document is not created and the time stamp is not updated with the introduction of lps-37702 document-management-10-6130, changes to categories, tags and related assets are not reflected in the document version. therefore, if these are updated, a new version will not be created and the time stamp will not be updated if there is a need to make sure all changes made to the files in the doc and media portlet result in a new version, you can set url as a reference, here is the url;;
while social office was previously available as a separate application that could be installed on liferay portal ee, many of the components that were present in social office are now included within liferay dxp 7.0. this means that social office no longer requires a separate installation, upgrade and support path most of the social office to liferay dxp 7.0 upgrade process is completed by the standard liferay upgrade procedure. there are just a couple additional steps that need to be completed after the standard liferay dxp 7.0 upgrade process is finished in order for social office to work with liferay dxp 7.0 please navigate to the upgrading social office article for information on where the social office features are available and important installation instructions.;;
this article documents a known issue with elasticsearch operating mode when switching from remote to embedded operation. any changes in configuration do not take effect unless the elasticsearch module is restarted on the server. also, when going from default embedded to remote configurations do not seemingly get used until the elasticsearch module is restarted in gogo shell expected result the log file for remote elasticsearch has evidence of use, reindecing, searching, etc. please subscribe to the article to be notified of the latest updates on fixes and workarounds for this issue remote es log now should have signs of it operating see lps-65459 for more information and the latest status on the issue.;;
after upgrading from liferay portal version 5.2 ee sp4 to 6.2 ee, backslashes in the screen name are not allowed when using the liberal screen name validator. in portal 5.2, backslashes were allowed in the screen name the ability to add backslashes in the screen name was never an intended behavior, as only alphanumeric characters, dashes, periods, and underscores should be allowed. the unintended functionality of allowing backslashes in the screen name was fixed on lps-24601.;;
liferay support does not recommend or endorse specific third-party products over others. liferay is not responsible for any instructions herein or referenced regarding these products. any implementation of these principles is the responsibility of the subscriber this article is a legacy article. it applies to previous versions of the liferay product. while the article is no longer maintained, the information may still be applicable this is a guide for using and setting up the document library in liferay portal 5.2 and 6.0. the goal is to give you adequate information about the document library so that it can be properly evaluated andor utilized by default, liferay 5.2 and 6.0 is configured to use the filesystemhook, which stores files on a local file system repository. you can change the hook or storage method by selecting a different dl hook option using this property url.advancedfilesystemhook - the advancedfilesystemhook distributes the files into multiple directories and thus circumvents filesystem limitations. liferay does not implement any file level locking, so use this only if you're using a san that supports file locking most modern ones do but check your san documentation to be sure. the path for storing your documents is set also set using the url property in the url. url.filesystemhook - this is the default hook in 5.2ee and 6.0ee. use this hook for a single server liferay installation where you want your files stored on a file system. the path for storing your documents is set using the url property in the url. url.s3hook - use this hook for storing your documents using amazon's simple storage service. if using this hook, there are additional settings that must be configured in the url. url.documentumhook - use this hook for storing your documents using documentum. this hook is configured through the deployment of the documentum-hook plugin. the documentum-hook plugin is only supported on liferay enterprise edition. if using this hook, there are additional settings that must be configured in the url and url files. url.jcrhook - this is a jcr-170 compliant hook. this hook can be used for small deployments when you don't have a san to store files. jackrabbit does not take care of file locking issues when storing on a file system, so for clustered environments, use jackrabbit in conjuction with a transactional database. there are several jcr properties in the url and additional configuration is done through the url url if you do choose this option, be sure to use a transactional database how do you know whether you are sharing the document library file repository successfully? using two nodes, node1 and node2, you can do a simple test. in node1, upload a file to document library. now go to node2 to see if the file can be downloaded. if you can't download the file for any reason, you need to recheck your setup the migration tool exists starting in 5.2ee sp3, so if you are on an earlier version of liferay, you would need to upgrade. if you switch document library hooks without a proper migration, your previously uploaded files will not be accessible before you go into production, you should decide whether there is a possibility of clustering. if there is, you should select a document library hook that is suitable for a clustered environment so that you don't have to worry about migration. for example, you would not want to use filesystemhook since this hook stores files exclusively on the local file system and cannot be used for a clustered environment. avoid switching between document library hooks when you have already started uploading files. the result would be losing the files you uploaded on the previously used hook. if the files are physically stored on the database or on a file system, you should be careful never to edit these files. the document library stores the path of the physical file on the database, so when you change the name or path of the phyical files or directories, then the document library won't be able to locate the file the document library generally stores file data in two places, the database and the filesystem. metadata including the file's path to the actual file location on the filesystem is stored in the database see dl tables. the physical file is stored on the filesystem in a directory structure dependent on the type of document library hook you utilize;;
this article is a legacy article. it applies to previous versions of the liferay product. while the article is no longer maintained, the information may still be applicable when attempting to use the core search portlet within the liferay portal, the results displayed do not include knowledge base articles by default, knowledge base articles are not not included within the search results. this is because the knowledge base plugin is not a part of the default liferay core plugins in order to include knowledge base articles within the results of the global search, please perform the following;;
this article outlines a specific known issue that exists within liferay portal 6.2 ee sp9 and provides a link to follow its resolution. at the time of release, there is one notable known issue with liferay portal 6.2 ee sp9. in this version of liferay, the thumbnail images of folders may appear below center from where they should appear update to the latest service pack sp20 or apply fix pack portal-156 this issue is logged as lps-51862;;
this article documents a known issue in lpe-15180 where users are able to access web content functions without proper permissions. this vulnerability was fixed by the portal-143-6210 fix pack. however, this fix was limited to only newly created web content to patch this issue in existing web content, users should execute the groovy script attached below. as a best practice, please test the script in a non-production environment.;;
liferay support does not recommend or endorse specific third-party products over others. liferay is not responsible for any instructions herein or referenced regarding these products. any implementation of these principles is the responsibility of the subscriber this article documents a known issue with the ckeditor when liferay portal 6.2 ee is deployed on weblogic 12.1.1 the web content article is not saved and the user is directed to a web content page with empty fields. note that this behavior may also occur with other components that use ckeditor e.g. blogs, message boards, etc. this issue arises because of a bug in this particular version of the weblogic application server. please note that this issue is no longer present in weblogic 12.1.2.;;
this article addresses a known issue with liferay portal 6.2 ee. the issue is that web content displayed in the asset publisher portlet is not being updated after editing. as a reference, please see lps-42282 as a workaround, add the following line to your environment's url file status this issue has been fixed in the web-content-3 fix pack.;;
"this article helps troubleshooting mysql when executing the verifyprocess. small max jdbc connection pool causes jdbc connection exhaustion if the verifyprocess is executed concurrently; when a user has a max tomcat jdbc connection pool size configured or defined as less than the numbers of the models in some of the verifyprocess suite, the tomcat jdbc connection pool exhaustion might happen once the verifyprocess is executed concurrently this could happen during the upgrade from earlier liferay portal version to liferay portal 6.2, or if user has the url property set with -1 as its value below are the ones from the verify process suite that has the models defined in url.verifyprocess, there is a method doverify with code snippet as follow when the required amount of models from the verify suite exceed the threshold defined by url property , based on below code from above snippet, the verify process will try to run concurrently this process then will try to get the amount of jdbc connection threads based on the models of that verify suite to accomondate the concurrency in order to complete the verifying of that suite. usually if jdbc connection threads pool is at default value or has relatively high value ex. a typical production level it will not be a problem. however if customer has a small max jdbc connection pool e.g. 15 max jdbc connection threads, once the models amount exceeds the max jdbc connection pool max size, it will cause the verification process to hang and portal will be unresponsive.";;
this article outlines a known issue that exists in kaleo forms ee 2.1.0 for liferay 6.2 and includes a link to the respective ticket for more up-to-date progress on the particular issue note the following issue is related to the use of kaleo forms ee 2.1.0. the corresponding ticket is listed with the known issue further information on this particular issue can be found in the link to the ticket itself.;
"this article outlines a practical suggestion in the case of publishing updated content permissions from a staging environment to a remote live environment. following this suggestion will ensure that the updated permissions are indeed published to live due to the nature of how remote live staging detects changes in content for publishing to live, content must be touched an update must be saved on that content for the content to be flagged and pushed to live upon publication when changing permissions for a web content in remote live staging, make sure to touch the piece of content to flag it as modified. this will ensure that a re-publish occurs on the newly permissioned content please note that this only applies to remote live staging; local live staging does not require the republishing of content to enact permissions change this discrepancy has been resolved in liferay portal 7.0";;
n order for liferay sync to function properly, the application will need access to the liferay portal. in many environments, this is a straightforward connection. in some, however, the local firewall may result in the inability for liferay sync to work with the portal if the firewall is causing the issue, the following urls will need to be allowed through the firewall in order for liferay sync to be able to access the portal;;
liferay support does not recommend or endorse specific third-party products over others. liferay is not responsible for any instructions herein or referenced regarding these products. any implementation of these principles is the responsibility of the subscriber this is a guide for setting up and using the document and media library in liferay portal 6.1 and 6.2. the goal is to give adequate information so that it can be properly evaluated andor utilized by default, liferay portal 6.1 and 6.2 are configured to use the filesystemstore, which stores files on a local file system repository. you can change the store or storage method by selecting a different document library store option using this property url the advancedfilesystemstore distributes the files into multiple directories and thus circumvents filesystem limitations. this store can be used for small and large deployments in a clustered or non-clustered environment. liferay does not implement any file level locking, so use this only if you're using a san that supports file locking most modern ones do but check your san documentation to be sure. the path for storing your documents is set also set using the url property in the url. the advancedfilesystemstore's code base is created and maintained by liferay if a san is not available, and files need to be persisted in the database, another option in a clustered environment would be dbstore. the dbstore's code base is created and maintained by liferay this is the default store in 6.1ee and 6.2 ee. use this store for a single server liferay installation where you want your files stored on a file system. the path for storing your documents is set using the url property in the url. there may be performance limitations on clustered or larger deployments. the filesystemstore's code base is created and maintained by liferay use this store for storing your documents using amazon's simple storage service. if using this store, there are additional settings that must be configured in the url this is a jcr-170 compliant store. the only feature of jcrstore is the ability to store files on the database. this is a jcr-170 compliant store that can be used for small deployments when you don't have a san to store files. jackrabbit does not take care of file locking issues when storing on a file system, so for clustered environments, use jackrabbit in conjuction with a transactional database. there are several jcr properties in the url and additional configuration is done through the url url if you do choose this option, be sure to use a transactional database. there may be performance impacts surrounding jcrstore on larger deployments. jackrabbit's code base is created and maintained by apache how do you know whether you are sharing the document library file repository successfully? using two nodes, node1 and node2, you can do a simple test. in node1, upload a file to document library. now go to node2 to see if the file can be downloaded. if you can see the file, and if the document library folder that you've specified via url for instance contains corresponding data, then the setup is correct. if you can't download the file for any reason, however, you need to recheck your setup if you switch dl stores without a proper migration, your previously uploaded files will not be accessible before you go into production, you should decide whether there is a possibility of clustering. if there is, you should select a document library store that is suitable for a clustered environment so that you don't have to worry about migration. for example, you would not want to use filesystemstore since this store stores files exclusively on the local file system and cannot be used for a clustered environment. avoid switching between document library stores when you have already started uploading files. the result would be losing the files you uploaded on the previously used store if the files are physically stored on the database or on a file system, you should be careful never to edit these files. the document library stores the path of the physical file on the database, so when you change the name or path of the phyical files or directories, then the document library won't be able to locate the file the document media and library generally stores file data in two places, the database and the filesystem. metadata including the file's path to the actual file location on the filesystem is stored in the database see dl tables. the physical file is stored either on the filesystem or in the database, dependent on the type of document library store you utilize.;;
"as many customers use the liferay document library to store the bulk of their documents, a natural question arises pertaining to the data; namely, how much is too much? while this depends heavily on the specific environments, this article aims to answer the question for a generic environment. liferay software will not place a constraint on the document library. any performance constraints will lie in the application server or database. many liferay customers have large document libraries without any trouble from the liferay platform file upload size and maximum file size are controlled through the ui and through the portal properties described below. please review all configurations and properties to determine those most appropriate for the expected use case.";;
this article describes several cases in which a user can receive a password policy here are several use-cases outlining how password policies are applied in liferay portal when a user and all organizations that the user is a member of don't have a password policy, then the default policy is given to the user if the user has no password policy but an organization the user is a member of does have a password policy, then the organization's password policy is given to the user if a user is a member of multiple organizations with more than one of those organizations having a password policy, then the first such organization found by liferay will impose its password policy on the user if the user has been assigned a password policy and an organization the user is a member of has a password policy, then the user's password policy is applied password policies are not inherited among parent and child organizations due to performance concerns. child organizations are assigned the default password policy rather than the password policy of parent organizations.;;
permission to the wiki can be set in the following levels this can cause some confusion because you can have permissions for certain users, however they can still be denied access depending on the rest of the permissions. the best way to work with this is to double check permissions at all levels to make sure that every user is experiencing the correct settings can be changed in the control panel wiki section. lets you change the permissions for who has access to specific wiki nodes can be modified for each portlet in the portlet configurations. here, the permissions for who has access to the portlet andor certain aspects of that portlet can be modified can be modified in control panel users and organizations. allows you to give permission to specific users. keep in mind, though, that tweaks at the other permission levels may need to be made to provide the user access for example, if the user has permissions to access wiki nodes, but the wiki portlet placed on a page does not provide view permissions to all users, then the user does not necessarily have access to view the wiki node in the the wiki portlet on that page each individual page also has its own permissions that can be modified in the control panel site pages permissions. this modifies who has permissions on specific pages permissions in liferay official documentation 6.2 ee working with wiki's in liferay official documentation 6.2 ee;;
liferay's wiki portlet, like the message boards portlet, is a full-featured wiki application which has all of the features you would expect in a state of again, though, it has the benefit of being able to take advantage of all of the features of the liferay platform. integrated with liferay's user management, tagging, and security features basically, a wiki is an application which allows users to collaboratively build a repository of information. implementations of this idea, the most famous of which is wikipedia. is a full online encyclopedia developed collaboratively by users from all over another example would be liferay's wiki, which is used for collaborative documentation of the community edition of liferay portal a wiki application allows users to create and edit documents and link them to to accomplish this, a special form of markup is used which is unfortunately, the proliferation of many different wiki applications resulted in slightly different syntax for wikitext in the various products, as each new wiki tried to focus on new features that other for that reason, a project called wikicreole was started. this project resulted in the release of wikicreole 1.0 in 2007, which is an attempt to define a standard wiki markup that all wikis can support rather than define another wikitext syntax, liferay's wiki portlet supports this syntax is a best-of-breed wiki syntax and should be familiar to users of other wikis. the portlet provides a handy cheat sheet for the syntax on the page editing form, with a link to the full documentation if you wish to use some of wikicreole's advanced features the wiki portlet works just like the other portlets developed by liferay. the portlet to a page using the add applications menu and then click configuration in the portlet's options menu in the wiki portlet's title bar. you'll see some options are likely to be familiar to you by now such as sharing the application with websites, facebook, google gadgets, etc. you will also notice that the communication tab has some additional options not seen in the figure 9.23 for each of the public parameters in this portlet, it is possible to ignore the values coming from other portlets or to read the value from another parameter the communication tab of the configuration window allows you to configure communication across portlets, using predefined public render parameters. here you can modify six public render parameters categoryid, nodeid, nodename, ignore the values for this parameter that come from other portlets. example, the wiki portlet can be used along with the tags navigation when a user clicks on a tag in the tags navigation portlet, the wiki shows a list of pages with that tag. in some cases an administrator may want the wiki portlet to always show the front page independently of any tag navigation done through other portlets. this can be achieved by checking the ignore check box so that the values of the parameter coming from those other read the value of a parameter from another portlet. very powerful option that allows portlets to communicate without for example, imagine that the wiki portlet is used to publish information about certain countries. portlet that allows browsing countries for administrative reasons was written we could associate to this second portlet a public render parameter called country to designate the name of the country. this procedure, we can cause the wiki to show the information from the country being browsed through in the other portlet. you can do this here for the wiki by setting the value for the title parameter to be read from the country once you have set the options the way you want them, click save the wiki portlet can contain many wikis. by default, it contains only one, to manage wikis, navigate to your site's site administration content page and select wiki. this page allows you to add, modify, and the main wiki has already been added for you at the top of this screen is a permissions button. to define which roles have access to create wikis. specific role for creating wikis, you can click the box in the add node column and then click submit, and that role will have access to create new clicking the add wiki button prompts you to enter a name and description for you can also set up some default permissions. new wiki, it appears in a list at the top of the main page of the wiki portlet next to each wiki in the list of wiki nodes is an actions button. edit lets you edit the name and description of the wiki permissions lets you define what roles can add attachments to wiki pages, add pages to the wiki, delete pages, import pages to the wiki, set permissions on the wiki, subscribe to the wiki, update existing pages, and view the wiki import pages allows you to import data from other wikis. migrate off of another wiki which you may be using and use the liferay wiki you might wish to do this if you are migrating your site from a set of disparate applications i.e. a separate forum, a separate wiki, a separate content management system to liferay, which provides all of these features. currently, mediawiki is the only wiki that is supported, but others are likely rss opens a new page where you can subscribe to an rss feed using live bookmarks, yahoo, or a chosen application from your machine subscribe allows you to subscribe to a wiki node, and any time a page is added or updated liferay will send you an email informing you what happened move to the recycle bin moves the wiki node to the recycle bin view removed attachments displays attachments that have been removed from to go back to your wiki, navigate back to the wiki portlet you added to your then click the options configuration button, which contains several other options which you may have seen on other portlets the display settings tab gives you several options for how the wiki should be and enable comment ratings are similar to the same options in other portlets. they give you the ability to set how you want users to interact with wiki documents a little, a lot, or not at all. option lets you choose the application display template for your portlet. this, you can set which wikis are visible in the wiki portlet by default and you might host two wikis on a given site, exposing one to the public and keeping the other private for site members the email from, page added email, and page updated email tabs are similar to the ones for notification email settings for other portlets, allowing you to customize who wiki emails come from and the format and text of the email that is sent when a page is added or updated finally, the wiki portlet also supports rss feeds as the other collaboration portlets do, and you can configure its options in the rss tab by default, there is one page added to your wiki, called frontpage. started adding data to your wiki, click the edit link. you can now begin to add content to the page. convenient show syntax help link which can help with the wiki syntax. use this syntax to format your wiki pages. consider, for example, the following this would produce the following wiki page figure 9.25 by using the syntax help guide, you can format your wiki headings and text this adds a simple heading, a paragraph of text, and several links to the page. since the pages behind these links have not been created yet, clicking one of those links takes you to an editing screen to create the page. screen looks just like the one you used previously when you wrote the front liferay displays a notice at the top of the page stating that the page does not exist yet, and that you are creating it right now. is very easy to create wiki pages. all you have to do is create a link from an note that at the top of the screen you can select from the creole wiki format and the html editor that comes with liferay. that you stick with the creole format, as it allows for a much cleaner separation of content and code. if you want all of your users to use the creole format, you can disable the html format using the url file. see chapter 14 for details about how to configure this at the bottom of the page editing screen, you can select categorization to add the tags link your wiki to categories. you can create categories using the site administration page, in the content categories section. are hierarchical lists of headings under which you can create wiki pages. allows you to organize your content in a more formal fashion when viewing a page, you can view its details by clicking the details link which appears in the top right of the page. there are several tabs which organize all of the the details tab shows various statistics about the page, and also allows you to perform some actions on the page title displays the title of the page format displays the format for the page either creole, html, or latest version displays the latest version of the page. automatically keeps track of page versions whenever a page has been edited created by displays the user who created the page last changed by displays the user who last modified the page attachments displays the number of attachments to the page convert to offers different conversion formats for the wiki page doc, odt, rss subscription displays links which allow you to subscribe to the page as an rss feed in three formats rss 1.0, rss 2.0, and atom 1.0 email subscription contains links allowing you to subscribe to the entire advanced actions contains links allowing you to modify the permissions on the page, make a copy of the page, move rename the page, or move the page to this tab shows a list of all of the versions of the wiki page since it was you can revert a page back to a previous state and you can also compare the differences between versions by selecting the versions and then clicking the compare versions button the next two tabs are for incoming and outgoing links. you can use this tab to examine how this page links to other pages and how other pages link back to this page the last tab is for attachments. you can attach any file to the wiki. mostly used to attach images to wiki articles which can then be referenced in referencing them using the proper wikicreole syntax renders the image inline, which is a nice way to include illustrations in your wiki documents at the top of the portlet is a list of links which allow you to navigate around simply click on the wiki's name to begin browsing that wiki. this is a set of navigation links recent changes takes you to a page which shows all of the recently updated all pages takes you to a flat, alphabetical list of all pages currently orphan pages takes you to a list of pages that have no links to them. can happen if you take a link out of a wiki page in an edit without realizing it's the only link to a certain page. this area allows you to review wiki pages that are orphaned in this way so that you can re-link to them or delete them from the wiki if they are no longer relevant draft pages takes you to a list of pages which have not yet been users can edit pages and save their changes as drafts. back later to finish their page changes and publish them once they have been search allows you to a term here and click the search button to search if the search term is not found, a link will be displayed which allows you to create a new wiki page on the topic for which you the wiki portlet is another full-featured liferay application with all of the features you expect from a state of the art wiki.;;
all of liferay's portlets support liferay's robust, fine-grained permissions some higher level permissions can be configured in the permissions tab of the portlet configuration dialog box. you can grant roles permission to add the portlet to a page, configure the portlet, or view the portlet. permissions, go to the configuration menu and click on permissions. shows you a table of roles defined in the portal. certain permissions to different roles. click save after you've made your beyond this, specific permissions are generally defined for specific for example, the message boards portlet contains a ban user this makes no sense in the context of another portlet, say, the we'll go over permissions for specific applications in the sections for those applications. for now, let's move on to sharing;;
in compliance to the european union cookie directive, please see the following articles in reference to cookies that liferay has set upon at login these lines can also be added to your url file to stop these cookies from occuring;;
when running liferay portal's patching tool with ibm j9 as the java version with multiple hotfixes, the patching-tool info command, and other patching tool commands may fail the root cause of this issue is that the fix pack xml descriptor is not properly read when many hotfixesfix packs are stored in the patching-toolpatches folder to resolve this issue, ensure that only the latest fix packhotfix is inside the patching-toolpatches folder. this will allow the xml descriptor to be read properly by the ibm jdk.;;
this article documents a known issue where users cannot log in to the sync client if both saml and oauth are enabled. as a result, a uthentication fails with a blank screen on sync client. repeated warning messages will print out in the server console relay state exceeds 80 bytes, some application may not support this currently we have a workaround to resolve this issue. please add the following filter in liferayhome url you will observe the user can sign in to the sync client successfully and only one warning message shows up in the server console lps-76246 is raised to provide a permanent fix if using the latest version of the liferay saml 2.0 app, fix pack de-32 or higher is required. see this article important changes and support information for liferay connector to saml 2.0 version 3.1.0 and later.;;

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.