/**
* Set the field value, to a content according the content structure
*
* @param structure The content structure
* @param contentlet The content
* @param fieldName The field name
* @param value The field value
* @throws DotDataException
*/
private static void setField(
Structure structure, Contentlet contentlet, String fieldName, String[] values)
throws DotDataException {
Field field = structure.getFieldVar(fieldName);
String value = "";
if (UtilMethods.isSet(field) && APILocator.getFieldAPI().valueSettable(field)) {
try {
if (field.getFieldType().equals(Field.FieldType.HOST_OR_FOLDER.toString())) {
value = VelocityUtil.cleanVelocity(values[0]);
Host host =
APILocator.getHostAPI().find(value, APILocator.getUserAPI().getSystemUser(), false);
if (host != null && InodeUtils.isSet(host.getIdentifier())) {
contentlet.setHost(host.getIdentifier());
contentlet.setFolder(FolderAPI.SYSTEM_FOLDER);
} else {
Folder folder =
APILocator.getFolderAPI()
.find(value, APILocator.getUserAPI().getSystemUser(), false);
if (folder != null && InodeUtils.isSet(folder.getInode())) {
contentlet.setHost(folder.getHostId());
contentlet.setFolder(folder.getInode());
}
}
} else if (field.getFieldType().equals(Field.FieldType.MULTI_SELECT.toString())
|| field.getFieldType().equals(Field.FieldType.CHECKBOX.toString())) {
if (field.getFieldContentlet().startsWith("float")
|| field.getFieldContentlet().startsWith("integer")) {
value = values[0];
} else {
for (String temp : values) {
value = temp + "," + value;
}
}
} else if (field.getFieldType().equals(Field.FieldType.DATE.toString())) {
value = VelocityUtil.cleanVelocity(values[0]);
if (value instanceof String) {
value = value + " 00:00:00";
}
} else {
value = VelocityUtil.cleanVelocity(values[0]);
}
conAPI.setContentletProperty(contentlet, field, value);
} catch (Exception e) {
Logger.debug(SubmitContentUtil.class, e.getMessage());
}
}
}
@SuppressWarnings("unchecked")
public File saveFile(
File newFile, java.io.File dataFile, Folder parentFolder, Identifier identifier)
throws DotDataException {
boolean localTransation = false;
try {
localTransation = DbConnectionFactory.getConnection().getAutoCommit();
if (localTransation) {
HibernateUtil.startTransaction();
}
// old working file
File oldFile = null;
// if new identifier
if (identifier == null || !InodeUtils.isSet(identifier.getInode())) {
identifier = APILocator.getIdentifierAPI().createNew(newFile, parentFolder);
newFile.setIdentifier(identifier.getInode());
HibernateUtil.save(newFile);
APILocator.getVersionableAPI().setWorking(newFile);
saveFileData(newFile, null, dataFile);
} else {
APILocator.getVersionableAPI().removeLive(identifier.getId());
}
if (UtilMethods.isSet(dataFile)) {
HibernateUtil.save(newFile);
saveFileData(newFile, null, dataFile);
}
if (oldFile != null && InodeUtils.isSet(oldFile.getInode())) {
APILocator.getFileAPI().invalidateCache(oldFile);
fileCache.remove(oldFile);
WorkingCache.removeAssetFromCache(oldFile);
}
LiveCache.removeAssetFromCache(newFile);
if (newFile.isLive()) {
LiveCache.addToLiveAssetToCache(newFile);
}
WorkingCache.addToWorkingAssetToCache(newFile);
if (localTransation) {
HibernateUtil.commitTransaction();
}
} catch (Exception e) {
if (localTransation) {
HibernateUtil.rollbackTransaction();
}
throw new DotDataException(e.getMessage(), e);
}
return newFile;
}
/**
* Method that will verify if a given template title is already used by another template
*
* @param title template title to verify
* @param templateInode template inode in case we are editing a template, null or empty in case of
* a new template
* @param hostIdentifier current host identifier
* @return
* @throws DotDataException
* @throws SystemException
* @throws PortalException
* @throws DotSecurityException
*/
public boolean duplicatedTitle(String title, String templateInode, String hostIdentifier)
throws DotDataException, SystemException, PortalException, DotSecurityException {
HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
User user = userWebAPI.getLoggedInUser(req);
boolean respectFrontendRoles = userWebAPI.isLoggedToFrontend(req);
// Getting the current host
Host host = hostAPI.find(hostIdentifier, user, respectFrontendRoles);
// The template name must be unique
Template foundTemplate =
FactoryLocator.getTemplateFactory().findWorkingTemplateByName(title, host);
boolean duplicatedTitle = false;
if (foundTemplate != null && InodeUtils.isSet(foundTemplate.getInode())) {
if (!UtilMethods.isSet(templateInode)) {
duplicatedTitle = true;
} else {
if (!foundTemplate.getInode().equals(templateInode)) {
duplicatedTitle = true;
}
}
}
return duplicatedTitle;
}
@SuppressWarnings("deprecation")
private void _loadForm(ActionForm form, ActionRequest req, ActionResponse res) {
try {
StructureForm structureForm = (StructureForm) form;
Structure structure = (Structure) req.getAttribute(WebKeys.Structure.STRUCTURE);
BeanUtils.copyProperties(structureForm, structure);
structureForm.setFields(structure.getFields());
if (structure.getReviewInterval() != null) {
String interval = structure.getReviewInterval();
Pattern p = Pattern.compile("(\\d+)([dmy])");
Matcher m = p.matcher(interval);
boolean b = m.matches();
if (b) {
structureForm.setReviewContent(true);
String g1 = m.group(1);
String g2 = m.group(2);
structureForm.setReviewIntervalNum(g1);
structureForm.setReviewIntervalSelect(g2);
}
}
if (UtilMethods.isSet(structure.getDetailPage())) {
Identifier ident = APILocator.getIdentifierAPI().find(structure.getDetailPage());
HTMLPage page = HTMLPageFactory.getLiveHTMLPageByIdentifier(ident);
if (InodeUtils.isSet(page.getInode())) {
structureForm.setDetailPage(page.getIdentifier());
}
}
} catch (Exception ex) {
Logger.debug(EditStructureAction.class, ex.toString());
}
}
@SuppressWarnings("deprecation")
private Structure _loadStructure(ActionForm form, ActionRequest req, ActionResponse res)
throws ActionException, DotDataException {
User user = _getUser(req);
Structure structure = new Structure();
String inodeString = req.getParameter("inode");
if (InodeUtils.isSet(inodeString)) {
/*
* long inode = Long.parseLong(inodeString); if (inode != 0) {
* structure = StructureFactory.getStructureByInode(inode); }
*/
if (InodeUtils.isSet(inodeString)) {
structure = StructureFactory.getStructureByInode(inodeString);
}
}
req.setAttribute(WebKeys.Structure.STRUCTURE, structure);
boolean searchable = false;
List<Field> fields = structure.getFields();
for (Field f : fields) {
if (f.isIndexed()) {
searchable = true;
break;
}
}
if (!searchable && InodeUtils.isSet(structure.getInode())) {
String message = "warning.structure.notsearchable";
SessionMessages.add(req, "message", message);
}
if (structure.isFixed()) {
String message = "warning.object.isfixed";
SessionMessages.add(req, "message", message);
}
// Checking permissions
_checkUserPermissions(structure, user, PermissionAPI.PERMISSION_READ);
return structure;
}
public File get(String inode) throws DotStateException, DotDataException, DotSecurityException {
File file = fileCache.get(inode);
if ((file == null) || !InodeUtils.isSet(file.getInode())) {
file = (File) HibernateUtil.load(File.class, inode);
fileCache.add(file);
WorkingCache.removeAssetFromCache(file);
WorkingCache.addToWorkingAssetToCache(file);
LiveCache.removeAssetFromCache(file);
if (file.isLive()) {
LiveCache.addToLiveAssetToCache(file);
}
}
return file;
}
/**
* Retrieves the event object from storage
*
* @param mapping
* @param form
* @param config
* @param req
* @param res
* @param user
* @throws DotSecurityException
* @throws DotDataException
* @throws DotSecurityException
* @throws DotDataException
* @throws ParseException
* @throws NumberFormatException
*/
private void retrieveEvent(
ActionMapping mapping,
ActionForm form,
PortletConfig config,
ActionRequest req,
ActionResponse res,
String command,
User user)
throws DotDataException, DotSecurityException, ParseException {
Contentlet contentlet = (Contentlet) req.getAttribute(WebKeys.CONTENTLET_EDIT);
if (InodeUtils.isSet(contentlet.getInode())) {
Event ev = eventAPI.findbyInode(contentlet.getInode(), user, false);
req.setAttribute(WebKeys.EVENT_EDIT, ev);
} else {
EventForm eventForm = (EventForm) form;
eventForm.setRecurrenceEndsDate(new Date());
eventForm.setRecurrenceOccurs("never");
eventForm.setRecurrenceDayOfMonth("");
eventForm.setNoEndDate(false);
eventForm.setRecurrenceInterval(1);
eventForm.setRecurrenceIntervalDaily(1);
eventForm.setRecurrenceIntervalWeekly(1);
eventForm.setRecurrenceIntervalMonthly(1);
eventForm.setRecurrenceIntervalYearly(1);
String[] daysOfWeekRecurrence = {
String.valueOf(Calendar.MONDAY),
String.valueOf(Calendar.TUESDAY),
String.valueOf(Calendar.WEDNESDAY),
String.valueOf(Calendar.THURSDAY),
String.valueOf(Calendar.FRIDAY),
String.valueOf(Calendar.SATURDAY),
String.valueOf(Calendar.SUNDAY)
};
eventForm.setRecurrenceDaysOfWeek(daysOfWeekRecurrence);
eventForm.setRecurrenceDayOfWeek(1);
eventForm.setRecurrenceMonthOfYear(1);
eventForm.setRecurrenceWeekOfMonth(1);
eventForm.setSpecificDayOfMonthRecY("1");
eventForm.setSpecificMonthOfYearRecY("1");
eventForm.setSpecificDate(false);
req.setAttribute(WebKeys.EVENT_EDIT, new Event());
}
}
public File getFileByURI(String uri, String hostId, boolean live)
throws DotDataException, DotSecurityException {
// uri = uri.replaceAll(Config.getStringProperty("VIRTUAL_FILE_PREFIX"), "");
Logger.debug(FileFactory.class, "getFileByURI=" + uri);
Host host =
APILocator.getHostAPI().find(hostId, APILocator.getUserAPI().getSystemUser(), false);
Identifier id = APILocator.getIdentifierAPI().find(host, uri);
if (id != null && InodeUtils.isSet(id.getId())) {
return (live)
? (File)
APILocator.getVersionableAPI()
.findLiveVersion(id, APILocator.getUserAPI().getSystemUser(), false)
: (File)
APILocator.getVersionableAPI()
.findWorkingVersion(id, APILocator.getUserAPI().getSystemUser(), false);
} else {
return null;
}
}
private boolean isArchive(HttpServletRequest request)
throws PortalException, SystemException, DotDataException, DotSecurityException {
String uri = request.getRequestURI();
uri = UtilMethods.cleanURI(uri);
Host host = null;
String hostId = "";
/*
* String pageHostId = request.getParameter("host_id"); if (pageHostId
* != null) { try { hostId = Long.parseLong(pageHostId); } catch
* (Exception ex) { } }
*/
hostId = request.getParameter("host_id");
if (!InodeUtils.isSet(hostId)) {
host = hostWebAPI.getCurrentHost(request);
hostId = host.getIdentifier();
} else {
User user =
(com.liferay.portal.model.User)
request.getSession().getAttribute(com.dotmarketing.util.WebKeys.CMS_USER);
if (user == null) {
user = com.liferay.portal.util.PortalUtil.getUser(request);
}
host = hostWebAPI.find(hostId, user, true);
}
// Getting the identifier from the uri
Identifier id = APILocator.getIdentifierAPI().find(host, uri);
request.setAttribute("idInode", String.valueOf(id.getInode()));
HTMLPage htmlPage =
(HTMLPage)
APILocator.getVersionableAPI()
.findWorkingVersion(id, APILocator.getUserAPI().getSystemUser(), false);
boolean isArchived = htmlPage.isDeleted();
return isArchived;
}
@SuppressWarnings("unchecked")
protected void doEditMode(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String uri = request.getRequestURI();
uri = UtilMethods.cleanURI(uri);
Host host = hostWebAPI.getCurrentHost(request);
StringBuilder preExecuteCode = new StringBuilder();
Boolean widgetPreExecute = false;
// Getting the user to check the permissions
com.liferay.portal.model.User backendUser = null;
try {
backendUser = com.liferay.portal.util.PortalUtil.getUser(request);
} catch (Exception nsue) {
Logger.warn(this, "Exception trying getUser: "******"idInode", String.valueOf(id.getInode()));
Logger.debug(VelocityServlet.class, "VELOCITY HTML INODE=" + id.getInode());
Template template = null;
Template hostVariablesTemplate = null;
// creates the context where to place the variables
response.setContentType(CHARSET);
Context context = VelocityUtil.getWebContext(request, response);
HTMLPage htmlPage =
(HTMLPage)
APILocator.getVersionableAPI()
.findWorkingVersion(id, APILocator.getUserAPI().getSystemUser(), false);
HTMLPageAPI htmlPageAPI = APILocator.getHTMLPageAPI();
// to check user has permission to write on this page
boolean hasAddChildrenPermOverHTMLPage =
permissionAPI.doesUserHavePermission(htmlPage, PERMISSION_CAN_ADD_CHILDREN, backendUser);
boolean hasWritePermOverHTMLPage =
permissionAPI.doesUserHavePermission(htmlPage, PERMISSION_WRITE, backendUser);
boolean hasPublishPermOverHTMLPage =
permissionAPI.doesUserHavePermission(htmlPage, PERMISSION_PUBLISH, backendUser);
context.put("ADD_CHILDREN_HTMLPAGE_PERMISSION", new Boolean(hasAddChildrenPermOverHTMLPage));
context.put("EDIT_HTMLPAGE_PERMISSION", new Boolean(hasWritePermOverHTMLPage));
context.put("PUBLISH_HTMLPAGE_PERMISSION", new Boolean(hasPublishPermOverHTMLPage));
context.put("canAddForm", new Boolean(LicenseUtil.getLevel() > 199 ? true : false));
context.put("canViewDiff", new Boolean(LicenseUtil.getLevel() > 199 ? true : false));
boolean canUserWriteOnTemplate =
permissionAPI.doesUserHavePermission(
htmlPageAPI.getTemplateForWorkingHTMLPage(htmlPage), PERMISSION_WRITE, backendUser)
&& portletAPI.hasTemplateManagerRights(backendUser);
context.put("EDIT_TEMPLATE_PERMISSION", canUserWriteOnTemplate);
com.dotmarketing.portlets.templates.model.Template cmsTemplate =
com.dotmarketing.portlets.htmlpages.factories.HTMLPageFactory.getHTMLPageTemplate(
htmlPage, true);
if (cmsTemplate == null) { // DOTCMS-4051
cmsTemplate = new com.dotmarketing.portlets.templates.model.Template();
Logger.debug(VelocityServlet.class, "HTMLPAGE TEMPLATE NOT FOUND");
}
Identifier templateIdentifier = APILocator.getIdentifierAPI().find(cmsTemplate);
Logger.debug(VelocityServlet.class, "VELOCITY TEMPLATE INODE=" + cmsTemplate.getInode());
VelocityUtil.makeBackendContext(
context, htmlPage, cmsTemplate.getInode(), id.getURI(), request, true, true, false, host);
// added to show tabs
context.put("previewPage", "1");
// get the containers for the page and stick them in context
List<Container> containers =
APILocator.getTemplateAPI()
.getContainersInTemplate(cmsTemplate, APILocator.getUserAPI().getSystemUser(), false);
for (Container c : containers) {
context.put(
String.valueOf("container" + c.getIdentifier()),
"/working/"
+ c.getIdentifier()
+ "."
+ Config.getStringProperty("VELOCITY_CONTAINER_EXTENSION"));
boolean hasWritePermissionOnContainer =
permissionAPI.doesUserHavePermission(c, PERMISSION_WRITE, backendUser, false)
&& portletAPI.hasContainerManagerRights(backendUser);
boolean hasReadPermissionOnContainer =
permissionAPI.doesUserHavePermission(c, PERMISSION_READ, backendUser, false);
context.put("EDIT_CONTAINER_PERMISSION" + c.getIdentifier(), hasWritePermissionOnContainer);
if (Config.getBooleanProperty("SIMPLE_PAGE_CONTENT_PERMISSIONING", true))
context.put("USE_CONTAINER_PERMISSION" + c.getIdentifier(), true);
else
context.put("USE_CONTAINER_PERMISSION" + c.getIdentifier(), hasReadPermissionOnContainer);
// to check user has permission to write this container
Structure st = (Structure) InodeFactory.getInode(c.getStructureInode(), Structure.class);
boolean hasWritePermOverTheStructure =
permissionAPI.doesUserHavePermission(st, PERMISSION_WRITE, backendUser);
context.put(
"ADD_CONTENT_PERMISSION" + c.getIdentifier(), new Boolean(hasWritePermOverTheStructure));
Logger.debug(
VelocityServlet.class,
String.valueOf("container" + c.getIdentifier())
+ "=/working/"
+ c.getIdentifier()
+ "."
+ Config.getStringProperty("VELOCITY_CONTAINER_EXTENSION"));
String sort = (c.getSortContentletsBy() == null) ? "tree_order" : c.getSortContentletsBy();
List<Contentlet> contentlets = null;
boolean staticContainer = !UtilMethods.isSet(c.getLuceneQuery());
// get contentlets only for main frame
if (request.getParameter("mainFrame") != null) {
if (staticContainer) {
Logger.debug(VelocityServlet.class, "Static Container!!!!");
Logger.debug(
VelocityServlet.class, "html=" + htmlPage.getInode() + " container=" + c.getInode());
// The container doesn't have categories
Identifier idenHtmlPage = APILocator.getIdentifierAPI().find(htmlPage);
Identifier idenContainer = APILocator.getIdentifierAPI().find(c);
contentlets =
conAPI.findPageContentlets(
idenHtmlPage.getInode(),
idenContainer.getInode(),
sort,
true,
-1,
backendUser,
true);
Logger.debug(
VelocityServlet.class,
"Getting contentlets for language="
+ (String)
request
.getSession()
.getAttribute(com.dotmarketing.util.WebKeys.HTMLPAGE_LANGUAGE)
+ " contentlets ="
+ contentlets.size());
} else {
String luceneQuery = c.getLuceneQuery();
int limit = c.getMaxContentlets();
String sortBy = c.getSortContentletsBy();
int offset = 0;
contentlets = conAPI.search(luceneQuery, limit, offset, sortBy, backendUser, true);
}
if (UtilMethods.isSet(contentlets) && contentlets.size() > 0) {
Set<String> contentletIdentList = new HashSet<String>();
List<Contentlet> contentletsFilter = new ArrayList<Contentlet>();
for (Contentlet cont : contentlets) {
if (!contentletIdentList.contains(cont.getIdentifier())) {
contentletIdentList.add(cont.getIdentifier());
contentletsFilter.add(cont);
}
}
contentlets = contentletsFilter;
}
List<String> contentletList = new ArrayList<String>();
if (contentlets != null) {
Iterator<Contentlet> iter = contentlets.iterator();
int count = 0;
while (iter.hasNext() && (count < c.getMaxContentlets())) {
count++;
Contentlet contentlet = (Contentlet) iter.next();
Identifier contentletIdentifier = APILocator.getIdentifierAPI().find(contentlet);
boolean hasWritePermOverContentlet =
permissionAPI.doesUserHavePermission(contentlet, PERMISSION_WRITE, backendUser);
context.put(
"EDIT_CONTENT_PERMISSION" + contentletIdentifier.getInode(),
new Boolean(hasWritePermOverContentlet));
contentletList.add(String.valueOf(contentletIdentifier.getInode()));
Logger.debug(this, "Adding contentlet=" + contentletIdentifier.getInode());
Structure contStructure = contentlet.getStructure();
if (contStructure.getStructureType() == Structure.STRUCTURE_TYPE_WIDGET) {
Field field = contStructure.getFieldVar("widgetPreexecute");
if (field != null && UtilMethods.isSet(field.getValues())) {
preExecuteCode.append(field.getValues().trim() + "\n");
widgetPreExecute = true;
}
}
}
}
// sets contentletlist with all the files to load per
// container
context.put("contentletList" + c.getIdentifier(), contentletList);
context.put("totalSize" + c.getIdentifier(), new Integer(contentletList.size()));
// ### Add the structure fake contentlet ###
if (contentletList.size() == 0) {
Structure structure = ContainerFactory.getContainerStructure(c);
contentletList.add(structure.getInode() + "");
// sets contentletlist with all the files to load per
// container
context.remove("contentletList" + c.getIdentifier());
context.remove("totalSize" + c.getIdentifier());
// http://jira.dotmarketing.net/browse/DOTCMS-2876
context.put("contentletList" + c.getIdentifier(), new long[0]);
context.put("totalSize" + c.getIdentifier(), 0);
}
// ### END Add the structure fake contentlet ###
}
}
Logger.debug(
VelocityServlet.class,
"Before finding template: /working/"
+ templateIdentifier.getInode()
+ "."
+ Config.getStringProperty("VELOCITY_TEMPLATE_EXTENSION"));
Logger.debug(
VelocityServlet.class,
"Velocity directory:"
+ VelocityUtil.getEngine().getProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH));
if (request.getParameter("leftMenu") != null) {
/*
* try to get the messages from the session
*/
List<String> list = new ArrayList<String>();
if (SessionMessages.contains(request, "message")) {
list.add((String) SessionMessages.get(request, "message"));
SessionMessages.clear(request);
}
if (SessionMessages.contains(request, "custommessage")) {
list.add((String) SessionMessages.get(request, "custommessage"));
SessionMessages.clear(request);
}
if (list.size() > 0) {
ArrayList<String> mymessages = new ArrayList<String>();
Iterator<String> it = list.iterator();
while (it.hasNext()) {
try {
String message = (String) it.next();
Company comp = PublicCompanyFactory.getDefaultCompany();
mymessages.add(LanguageUtil.get(comp.getCompanyId(), backendUser.getLocale(), message));
} catch (Exception e) {
}
}
context.put("vmessages", mymessages);
}
template = VelocityUtil.getEngine().getTemplate("/preview_left_menu.vl");
} else if (request.getParameter("mainFrame") != null) {
hostVariablesTemplate =
VelocityUtil.getEngine()
.getTemplate(
"/working/"
+ host.getIdentifier()
+ "."
+ Config.getStringProperty("VELOCITY_HOST_EXTENSION"));
template =
VelocityUtil.getEngine()
.getTemplate(
"/working/"
+ templateIdentifier.getInode()
+ "."
+ Config.getStringProperty("VELOCITY_TEMPLATE_EXTENSION"));
} else {
// Return a resource not found right away if the page is not found,
// not try to load the frames
if (!InodeUtils.isSet(templateIdentifier.getInode())) throw new ResourceNotFoundException("");
template = VelocityUtil.getEngine().getTemplate("/preview_mode.vl");
}
PrintWriter out = response.getWriter();
request.setAttribute("velocityContext", context);
try {
if (widgetPreExecute) {
VelocityUtil.getEngine().evaluate(context, out, "", preExecuteCode.toString());
}
if (hostVariablesTemplate != null) hostVariablesTemplate.merge(context, out);
template.merge(context, out);
} catch (ParseErrorException e) {
out.append(e.getMessage());
}
}
public void processAction(
ActionMapping mapping,
ActionForm form,
PortletConfig config,
ActionRequest req,
ActionResponse res)
throws Exception {
String cmd = req.getParameter("cmd");
String subcmd = ParamUtil.getString(req, "subcmd");
String referer =
(req.getParameter("referer") != null)
? URLDecoder.decode(req.getParameter("referer"), "UTF-8")
: "/c";
Logger.debug(DirectorAction.class, "DirectorAction :: referer=" + referer);
// wraps request to get session object
ActionRequestImpl reqImpl = (ActionRequestImpl) req;
HttpServletRequest httpReq = reqImpl.getHttpServletRequest();
// gets the session object for the messages
HttpSession session = httpReq.getSession();
Logger.debug(DirectorAction.class, "I'm inside the Director cmd = " + cmd);
Logger.debug(DirectorAction.class, "I'm inside the Director subcmd = " + subcmd);
Logger.debug(DirectorAction.class, "I'm inside the Director referer = " + referer);
// get the user
User user = _getUser(req);
// to order menu items
if (cmd != null && cmd.equals("orderMenu")) {
Logger.debug(DirectorAction.class, "Director :: orderMenu");
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/folders/order_menu"});
params.put("path", new String[] {req.getParameter("path")});
params.put("pagePath", new String[] {req.getParameter("pagePath")});
if (req.getParameter("openAll") != null) {
params.put("openAll", new String[] {req.getParameter("openAll")});
}
params.put("hostId", new String[] {req.getParameter("hostId")});
params.put("referer", new String[] {referer});
params.put("startLevel", new String[] {req.getParameter("startLevel")});
params.put("depth", new String[] {req.getParameter("depth")});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("orderContentlets")) {
Logger.debug(DirectorAction.class, "Director :: orderContentlet");
Container container =
(Container) InodeFactory.getInode(req.getParameter("containerId"), Container.class);
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("pageId"), HTMLPage.class);
boolean hasReadPermissionOnContainer =
perAPI.doesUserHavePermission(container, PERMISSION_READ, user, false);
boolean hasWritePermissionOnPage =
perAPI.doesUserHavePermission(htmlPage, PERMISSION_WRITE, user, false);
if (!hasReadPermissionOnContainer || !hasWritePermissionOnPage) {
throw new DotSecurityException(
"User has no permission to reorder content on container = "
+ req.getParameter("container")
+ " on page = "
+ req.getParameter("htmlPage"));
}
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/contentlet/order_contentlets"});
params.put("containerId", new String[] {req.getParameter("containerId")});
params.put("pageId", new String[] {req.getParameter("pageId")});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("newHTMLPage")) {
Logger.debug(DirectorAction.class, "Director :: editHTMLPage");
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/htmlpages/edit_htmlpage"});
params.put("cmd", new String[] {"edit"});
params.put("inode", new String[] {"0"});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("editHTMLPage")) {
Logger.debug(DirectorAction.class, "Director :: editHTMLPage");
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
Identifier identifier = APILocator.getIdentifierAPI().find(htmlPage);
// gets the current working asset
WebAsset workingHTMLPage =
(WebAsset)
APILocator.getVersionableAPI()
.findWorkingVersion(identifier, APILocator.getUserAPI().getSystemUser(), false);
if ("unlockHTMLPage".equals(subcmd)) {
WebAssetFactory.unLockAsset(workingHTMLPage);
}
if (workingHTMLPage.isLocked() && !workingHTMLPage.getModUser().equals(user.getUserId())) {
req.setAttribute(WebKeys.HTMLPAGE_EDIT, workingHTMLPage);
setForward(req, "portlet.ext.director.unlock_htmlpage");
return;
} else if (workingHTMLPage.isLocked()) {
// it's locked by the same user
WebAssetFactory.unLockAsset(workingHTMLPage);
}
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/htmlpages/edit_htmlpage"});
params.put("cmd", new String[] {"edit"});
params.put("inode", new String[] {workingHTMLPage.getInode() + ""});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("viewStatistics")) {
Logger.debug(DirectorAction.class, "Director :: editHTMLPage");
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/htmlpageviews/view_htmlpage_views"});
params.put("htmlpage", new String[] {htmlPage.getInode() + ""});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getRenderURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("editFile")) {
Logger.debug(DirectorAction.class, "Director :: editFile");
String fileAssetInode = "";
if (UtilMethods.isSet(req.getParameter("file"))) fileAssetInode = req.getParameter("file");
else return;
Identifier identifier = APILocator.getIdentifierAPI().findFromInode(fileAssetInode);
if (identifier.getAssetType().equals("contentlet")) {
try {
Contentlet cont = APILocator.getContentletAPI().find(fileAssetInode, user, false);
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/contentlet/edit_contentlet"});
params.put("cmd", new String[] {"edit"});
params.put("inode", new String[] {cont.getInode() + ""});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
} catch (DotSecurityException e) {
Logger.error(this, e.getMessage());
return;
}
} else {
try {
// gets the current working asset
WebAsset workingFile =
(WebAsset)
APILocator.getVersionableAPI()
.findWorkingVersion(
identifier, APILocator.getUserAPI().getSystemUser(), false);
if ("unlockFile".equals(subcmd)) {
WebAssetFactory.unLockAsset(workingFile);
}
if (workingFile.isLocked() && !workingFile.getModUser().equals(user.getUserId())) {
req.setAttribute(WebKeys.FILE_EDIT, workingFile);
setForward(req, "portlet.ext.director.unlock_file");
return;
} else if (workingFile.isLocked()) {
// it's locked by the same user
WebAssetFactory.unLockAsset(workingFile);
}
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/files/edit_file"});
params.put("cmd", new String[] {"edit"});
params.put("inode", new String[] {workingFile.getInode() + ""});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
} catch (DotStateException e) {
Logger.error(this, e.getMessage());
return;
} catch (DotSecurityException e) {
Logger.error(this, e.getMessage());
return;
}
}
return;
}
if (cmd != null && cmd.equals("editTemplate")) {
Logger.debug(DirectorAction.class, "Director :: editTemplate");
HTMLPage htmlPage = new HTMLPage();
WebAsset workingTemplate = new Template();
if (req.getParameter("htmlPage") != null) {
htmlPage = (HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
workingTemplate = HTMLPageFactory.getHTMLPageTemplate(htmlPage, true);
} else if (req.getParameter("template") != null) {
workingTemplate =
(Template) InodeFactory.getInode(req.getParameter("template"), Template.class);
}
if ("unlockTemplate".equals(subcmd)) {
WebAssetFactory.unLockAsset(workingTemplate);
}
if (workingTemplate.isLocked() && !workingTemplate.getModUser().equals(user.getUserId())) {
req.setAttribute(WebKeys.HTMLPAGE_EDIT, htmlPage);
req.setAttribute(WebKeys.TEMPLATE_EDIT, workingTemplate);
setForward(req, "portlet.ext.director.unlock_template");
return;
} else if (workingTemplate.isLocked()) {
// it's locked by the same user
WebAssetFactory.unLockAsset(workingTemplate);
}
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/templates/edit_template"});
params.put("cmd", new String[] {"edit"});
params.put("inode", new String[] {workingTemplate.getInode() + ""});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("publishHTMLPage")) {
Logger.debug(DirectorAction.class, "Director :: publishHTMLPage");
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/htmlpages/publish_htmlpages"});
params.put("cmd", new String[] {"prepublish"});
params.put("publishInode", new String[] {htmlPage.getInode() + ""});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("editContainer")) {
Logger.debug(DirectorAction.class, "Director :: editContainer" + subcmd);
Container container =
(Container) InodeFactory.getInode(req.getParameter("container"), Container.class);
Identifier identifier = APILocator.getIdentifierAPI().find(container);
// gets the current working asset
WebAsset workingContainer =
(WebAsset)
APILocator.getVersionableAPI()
.findWorkingVersion(identifier, APILocator.getUserAPI().getSystemUser(), false);
if ("unlockContainer".equals(subcmd)) {
WebAssetFactory.unLockAsset(workingContainer);
}
if (workingContainer.isLocked() && !workingContainer.getModUser().equals(user.getUserId())) {
req.setAttribute(WebKeys.CONTAINER_EDIT, workingContainer);
setForward(req, "portlet.ext.director.unlock_container");
return;
} else if (workingContainer.isLocked()) {
// it's locked by the same user
WebAssetFactory.unLockAsset(workingContainer);
}
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/containers/edit_container"});
params.put("cmd", new String[] {"edit"});
params.put("inode", new String[] {workingContainer.getInode() + ""});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("editLink")) {
Logger.debug(DirectorAction.class, "Director :: editLink");
String popup = req.getParameter("popup");
Link link = (Link) InodeFactory.getInode(req.getParameter("link"), Link.class);
Identifier identifier = APILocator.getIdentifierAPI().find(link);
// gets the current working asset
WebAsset workingLink =
(WebAsset)
APILocator.getVersionableAPI()
.findWorkingVersion(identifier, APILocator.getUserAPI().getSystemUser(), false);
if ("unlockLink".equals(subcmd)) {
WebAssetFactory.unLockAsset(workingLink);
}
if (workingLink.isLocked() && !workingLink.getModUser().equals(user.getUserId())) {
req.setAttribute(WebKeys.LINK_EDIT, workingLink);
if (UtilMethods.isSet(popup)) {
Logger.debug(DirectorAction.class, "Going to SIX I have popup!!!!!!!!!!!!!!!!");
setForward(req, "portlet.ext.director.unlock_popup_link");
return;
} else {
Logger.debug(DirectorAction.class, "Going to FIVE I dont have popup!!!!!!!!!!!!!!!!");
setForward(req, "portlet.ext.director.unlock_link");
return;
}
} else if (workingLink.isLocked()) {
// it's locked by the same user
WebAssetFactory.unLockAsset(workingLink);
}
String popURL = "";
if (UtilMethods.isSet(popup)) {
popURL = "_popup";
}
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/links/edit_link"});
params.put("cmd", new String[] {"edit"});
params.put("inode", new String[] {workingLink.getInode() + ""});
params.put("popup", new String[] {popup});
params.put("referer", new String[] {referer});
params.put(
"child",
new String[] {(req.getParameter("child") != null) ? req.getParameter("child") : ""});
params.put(
"page_width",
new String[] {
(req.getParameter("page_width") != null) ? req.getParameter("page_width") : ""
});
params.put(
"browse",
new String[] {(req.getParameter("browse") != null) ? req.getParameter("browse") : ""});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
if (cmd != null && cmd.equals("addChild")) {
try {
Logger.debug(DirectorAction.class, "Director :: addChild");
HibernateUtil.startTransaction();
Contentlet contentlet = new Contentlet();
String cInode = req.getParameter("contentlet");
if (InodeUtils.isSet(cInode)) {
contentlet = conAPI.find(cInode, user, true);
}
Container container =
(Container) InodeFactory.getInode(req.getParameter("container"), Container.class);
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
boolean hasPermissionOnContainer =
perAPI.doesUserHavePermission(container, PERMISSION_READ, user, false);
if (Config.getBooleanProperty("SIMPLE_PAGE_CONTENT_PERMISSIONING", true))
hasPermissionOnContainer = true;
boolean hasPermissionsOnPage =
perAPI.doesUserHavePermission(htmlPage, PERMISSION_CAN_ADD_CHILDREN, user, false);
boolean duplicateContentCheck = false;
if (!hasPermissionOnContainer || !hasPermissionsOnPage) {
throw new DotSecurityException(
"User has no permission to add content on container = "
+ req.getParameter("container")
+ " on page = "
+ req.getParameter("htmlPage"));
}
Identifier identifier = APILocator.getIdentifierAPI().find(contentlet);
Identifier htmlPageIdentifier = APILocator.getIdentifierAPI().find(htmlPage);
Identifier containerIdentifier = APILocator.getIdentifierAPI().find(container);
if (InodeUtils.isSet(identifier.getInode())
&& InodeUtils.isSet(htmlPageIdentifier.getInode())
&& InodeUtils.isSet(containerIdentifier.getInode())) {
MultiTree mTree =
new MultiTree(
htmlPageIdentifier.getInode(),
containerIdentifier.getInode(),
identifier.getInode());
java.util.List<MultiTree> treeList = MultiTreeFactory.getMultiTree(htmlPage, container);
for (int i = 0; i < treeList.size(); i++) {
if (treeList.get(i).getChild().equals(identifier.getInode())) {
duplicateContentCheck = true;
session.setAttribute(
"duplicatedErrorMessage",
"Content already exists in the same container on the page");
}
}
if (!duplicateContentCheck) {
MultiTreeFactory.saveMultiTree(mTree);
// Updating the last mod user and last mod date of the page
htmlPage.setModDate(new Date());
htmlPage.setModUser(user.getUserId());
HibernateUtil.saveOrUpdate(htmlPage);
}
} else {
Logger.error(
this,
"Error found trying to associate the contentlet inode: "
+ contentlet.getInode()
+ "(iden: "
+ identifier.getInode()
+ ") "
+ "to the container: "
+ container.getInode()
+ "(iden: "
+ containerIdentifier.getInode()
+ ") "
+ "of the page: "
+ htmlPage.getInode()
+ "(iden: "
+ htmlPageIdentifier.getInode()
+ ") "
+ "the system was unable to find some the identifiers (tree error?)!");
}
} catch (DotRuntimeException e) {
Logger.error(this, "Unable to add content to page", e);
} finally {
try {
HibernateUtil.commitTransaction();
} catch (Exception e) {
session.setAttribute(
"duplicatedErrorMessage", "Content already exists in the same container on the page");
// res.sendRedirect(referer);
}
}
_sendToReferral(req, res, referer);
return;
}
if (cmd != null && cmd.equals("removeChild")) {
try {
Logger.debug(DirectorAction.class, "Director :: removeChild");
HibernateUtil.startTransaction();
Contentlet contentlet = new Contentlet();
String cInode = req.getParameter("contentlet");
if (InodeUtils.isSet(cInode)) {
contentlet = conAPI.find(cInode, user, true);
}
Container container =
(Container) InodeFactory.getInode(req.getParameter("container"), Container.class);
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
boolean hasPermissionOnPage =
perAPI.doesUserHavePermission(htmlPage, PERMISSION_CAN_ADD_CHILDREN, user, false);
boolean hasPermissionOnContainer =
perAPI.doesUserHavePermission(container, PERMISSION_READ, user, false);
if (Config.getBooleanProperty("SIMPLE_PAGE_CONTENT_PERMISSIONING", true))
hasPermissionOnContainer = true;
if (!hasPermissionOnContainer || !hasPermissionOnPage) {
throw new DotSecurityException(
"User has no permission to remove content from container = "
+ req.getParameter("container")
+ " on page = "
+ req.getParameter("htmlPage"));
}
Identifier identifier = APILocator.getIdentifierAPI().find(contentlet);
Logger.debug(
DirectorAction.class,
"Identifier of Contentlet to be removed=" + identifier.getInode());
Contentlet contentletWorking =
conAPI.findContentletByIdentifier(
identifier.getInode(), false, contentlet.getLanguageId(), user, true);
Contentlet liveContentlet =
conAPI.findContentletByIdentifier(
identifier.getInode(), false, contentlet.getLanguageId(), user, true);
Logger.debug(
DirectorAction.class,
"\n\nContentlet Working to be removed=" + contentletWorking.getInode());
Identifier htmlPageIdentifier = APILocator.getIdentifierAPI().find(htmlPage);
Identifier containerIdentifier = APILocator.getIdentifierAPI().find(container);
MultiTree multiTree =
MultiTreeFactory.getMultiTree(htmlPageIdentifier, containerIdentifier, identifier);
Logger.debug(DirectorAction.class, "multiTree=" + multiTree);
MultiTreeFactory.deleteMultiTree(multiTree);
// Updating the last mod user and last mod date of the page
htmlPage.setModDate(new Date());
htmlPage.setModUser(user.getUserId());
HibernateUtil.saveOrUpdate(htmlPage);
} catch (DotRuntimeException e) {
Logger.error(this, "Unable to remove content from page", e);
} finally {
HibernateUtil.commitTransaction();
}
_sendToReferral(req, res, referer);
return;
}
if (cmd != null && cmd.equals("makeHomePage")) {
Logger.debug(DirectorAction.class, "Director :: makeHomePage");
if (InodeUtils.isSet(req.getParameter("htmlPage"))) {
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
Folder folder = APILocator.getFolderAPI().findParentFolder(htmlPage, user, false);
UserPreference up =
UserPreferencesFactory.getUserPreferenceValue(
user.getUserId(), WebKeys.USER_PREFERENCE_HOME_PAGE);
if (up.getId() > 0) {
up.setValue(htmlPage.getURI(folder));
} else {
up.setUserId(user.getUserId());
up.setPreference(WebKeys.USER_PREFERENCE_HOME_PAGE);
up.setValue(htmlPage.getURI(folder));
}
UserPreferencesFactory.saveUserPreference(up);
} else {
// the user clicked on set with no page that means unsetting the page
UserPreferencesFactory.deleteUserPreference(
user.getUserId(), WebKeys.USER_PREFERENCE_HOME_PAGE);
}
_sendToReferral(req, res, referer);
return;
}
if (cmd != null && cmd.equals("moveUp")) {
Logger.debug(DirectorAction.class, "Director :: moveUp");
Contentlet contentlet = new Contentlet();
String cInode = req.getParameter("contentlet");
if (InodeUtils.isSet(cInode)) {
contentlet = conAPI.find(cInode, user, true);
}
Container container =
(Container) InodeFactory.getInode(req.getParameter("container"), Container.class);
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
boolean hasPermissionOnPage =
perAPI.doesUserHavePermission(htmlPage, PERMISSION_CAN_ADD_CHILDREN, user, false);
boolean hasPermissionOnContainer =
perAPI.doesUserHavePermission(container, PERMISSION_READ, user, false);
if (Config.getBooleanProperty("SIMPLE_PAGE_CONTENT_PERMISSIONING", true))
hasPermissionOnContainer = true;
if (!hasPermissionOnContainer || !hasPermissionOnPage) {
throw new DotSecurityException(
"User has no permission to reorder content on container = "
+ req.getParameter("container")
+ " on page = "
+ req.getParameter("htmlPage"));
}
String staticContainer = req.getParameter("static");
Logger.debug(DirectorAction.class, "staticContainer=" + staticContainer);
java.util.List cletList = new ArrayList();
String sort =
(container.getSortContentletsBy() == null)
? "tree_order"
: container.getSortContentletsBy();
Identifier idenHtmlPage = APILocator.getIdentifierAPI().find(htmlPage);
Identifier idenContainer = APILocator.getIdentifierAPI().find(container);
cletList =
conAPI.findPageContentlets(
idenHtmlPage.getInode(),
idenContainer.getInode(),
sort,
true,
contentlet.getLanguageId(),
user,
false);
Logger.debug(DirectorAction.class, "Number of contentlets = " + cletList.size());
int newPosition = cletList.indexOf(contentlet) - 1;
if (newPosition >= 0) {
idenContainer = APILocator.getIdentifierAPI().find(container);
idenHtmlPage = APILocator.getIdentifierAPI().find(htmlPage);
int x = 0;
Iterator i = cletList.iterator();
while (i.hasNext()) {
Identifier iden;
MultiTree multiTree;
Contentlet c = (Contentlet) i.next();
Logger.debug(DirectorAction.class, "Contentlet inode = " + c.getInode());
if (newPosition == x) {
iden = APILocator.getIdentifierAPI().find(contentlet);
multiTree = MultiTreeFactory.getMultiTree(idenHtmlPage, idenContainer, iden);
multiTree.setTreeOrder(x);
MultiTreeFactory.saveMultiTree(multiTree);
x++;
}
if (!c.getInode().equalsIgnoreCase(contentlet.getInode())) {
iden = APILocator.getIdentifierAPI().find(c);
multiTree = MultiTreeFactory.getMultiTree(idenHtmlPage, idenContainer, iden);
multiTree.setTreeOrder(x);
MultiTreeFactory.saveMultiTree(multiTree);
x++;
}
}
}
_sendToReferral(req, res, referer);
return;
}
if (cmd != null && cmd.equals("moveDown")) {
Logger.debug(DirectorAction.class, "Director :: moveDown");
Contentlet contentlet = new Contentlet();
String cInode = req.getParameter("contentlet");
if (InodeUtils.isSet(cInode)) {
contentlet = conAPI.find(cInode, user, true);
}
Container container =
(Container) InodeFactory.getInode(req.getParameter("container"), Container.class);
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
String staticContainer = req.getParameter("static");
boolean hasPermissionOnPage =
perAPI.doesUserHavePermission(htmlPage, PERMISSION_CAN_ADD_CHILDREN, user, false);
boolean hasPermissionOnContainer =
perAPI.doesUserHavePermission(container, PERMISSION_READ, user, false);
if (Config.getBooleanProperty("SIMPLE_PAGE_CONTENT_PERMISSIONING", true))
hasPermissionOnContainer = true;
if (!hasPermissionOnContainer || !hasPermissionOnPage) {
throw new DotSecurityException(
"User has no permission to reorder content on container = "
+ req.getParameter("container")
+ " on page = "
+ req.getParameter("htmlPage"));
}
Logger.debug(DirectorAction.class, "staticContainer=" + staticContainer);
java.util.List cletList = new ArrayList();
String sort =
(container.getSortContentletsBy() == null)
? "tree_order"
: container.getSortContentletsBy();
Identifier idenHtmlPage = APILocator.getIdentifierAPI().find(htmlPage);
Identifier idenContainer = APILocator.getIdentifierAPI().find(container);
cletList =
conAPI.findPageContentlets(
idenHtmlPage.getInode(),
idenContainer.getInode(),
sort,
true,
contentlet.getLanguageId(),
user,
false);
Logger.debug(DirectorAction.class, "Number of contentlets = " + cletList.size());
int newPosition = cletList.indexOf(contentlet) + 1;
if (newPosition < cletList.size()) {
idenContainer = APILocator.getIdentifierAPI().find(container);
idenHtmlPage = APILocator.getIdentifierAPI().find(htmlPage);
int x = 0;
Iterator i = cletList.iterator();
while (i.hasNext()) {
Identifier iden;
MultiTree multiTree;
Contentlet c = (Contentlet) i.next();
Logger.debug(DirectorAction.class, "Contentlet inode = " + c.getInode());
if (!c.getInode().equalsIgnoreCase(contentlet.getInode())) {
iden = APILocator.getIdentifierAPI().find(c);
multiTree = MultiTreeFactory.getMultiTree(idenHtmlPage, idenContainer, iden);
multiTree.setTreeOrder(x);
MultiTreeFactory.saveMultiTree(multiTree);
x++;
}
if (newPosition == x) {
iden = APILocator.getIdentifierAPI().find(contentlet);
multiTree = MultiTreeFactory.getMultiTree(idenHtmlPage, idenContainer, iden);
multiTree.setTreeOrder(x);
MultiTreeFactory.saveMultiTree(multiTree);
x++;
}
}
}
_sendToReferral(req, res, referer);
return;
}
if (cmd != null && cmd.equals("unlock")) {
Logger.debug(DirectorAction.class, "Director :: unlock Contentlet");
Contentlet contentlet = new Contentlet();
String cInode = req.getParameter("contentlet");
if (InodeUtils.isSet(cInode)) {
contentlet = conAPI.find(cInode, user, true);
}
conAPI.unlock(contentlet, user, true);
}
if (cmd != null && cmd.equals("createForm")) {
Logger.debug(DirectorAction.class, "Director :: createForrm");
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/structure/edit_structure"});
params.put("structureType", new String[] {Integer.toString(Structure.STRUCTURE_TYPE_FORM)});
params.put("cmd", new String[] {"null"});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
Contentlet contentlet = new Contentlet();
String cInode = req.getParameter("contentlet");
if (InodeUtils.isSet(cInode)) {
contentlet = conAPI.find(cInode, user, true);
}
if (contentlet == null) {
throw new DotStateException("Trying to edit an invalid contentlet - inode:" + cInode);
}
Container container =
(Container) InodeFactory.getInode(req.getParameter("container"), Container.class);
HTMLPage htmlPage =
(HTMLPage) InodeFactory.getInode(req.getParameter("htmlPage"), HTMLPage.class);
Logger.debug(DirectorAction.class, "contentlet=" + contentlet.getInode());
String contentletInode = "";
if (InodeUtils.isSet(contentlet.getInode())) {
Identifier identifier = APILocator.getIdentifierAPI().find(contentlet);
// gets the current working asset
Contentlet workingContentlet =
conAPI.findContentletByIdentifier(
identifier.getInode(), false, contentlet.getLanguageId(), user, false);
Logger.debug(DirectorAction.class, "workingContentlet=" + workingContentlet.getInode());
Logger.debug(
DirectorAction.class, "workingContentlet.getModUser()=" + workingContentlet.getModUser());
Logger.debug(
DirectorAction.class, "workingContentlet.isLocked()=" + workingContentlet.isLocked());
contentletInode = workingContentlet.getInode();
} else {
contentletInode = contentlet.getInode();
}
Logger.debug(DirectorAction.class, "Director :: Edit Contentlet");
java.util.Map params = new java.util.HashMap();
params.put("struts_action", new String[] {"/ext/contentlet/edit_contentlet"});
String cmdAux = (cmd.equals("newedit") ? cmd : "edit");
params.put("cmd", new String[] {cmdAux});
params.put("htmlpage_inode", new String[] {htmlPage.getInode() + ""});
params.put("contentcontainer_inode", new String[] {container.getInode() + ""});
params.put("inode", new String[] {contentletInode + ""});
if (InodeUtils.isSet(req.getParameter("selectedStructure"))) {
params.put("selectedStructure", new String[] {req.getParameter("selectedStructure") + ""});
}
params.put(
"lang",
new String[] {(req.getParameter("language") != null) ? req.getParameter("language") : ""});
params.put("referer", new String[] {referer});
String af =
com.dotmarketing.util.PortletURLUtil.getActionURL(
httpReq, WindowState.MAXIMIZED.toString(), params);
_sendToReferral(req, res, af);
return;
}
private void _saveStructure(ActionForm form, ActionRequest req, ActionResponse res) {
try {
boolean newStructure = false;
StructureForm structureForm = (StructureForm) form;
Structure structure = (Structure) req.getAttribute(WebKeys.Structure.STRUCTURE);
User user = _getUser(req);
HttpServletRequest httpReq = ((ActionRequestImpl) req).getHttpServletRequest();
if (!UtilMethods.isSet(structureForm.getHost())
&& (!UtilMethods.isSet(structureForm.getFolder())
|| structureForm.getFolder().equals("SYSTEM_FOLDER"))) {
throw new DotDataException(LanguageUtil.get(user, "Host-or-folder-is-required"));
}
// Checking permissions
_checkWritePermissions(structure, user, httpReq);
// Check if another structure with the same name exist
String auxStructureName = structureForm.getName();
auxStructureName = (auxStructureName != null ? auxStructureName.trim() : "");
@SuppressWarnings("deprecation")
Structure auxStructure = StructureCache.getStructureByType(auxStructureName);
if (InodeUtils.isSet(auxStructure.getInode())
&& !auxStructure.getInode().equalsIgnoreCase(structure.getInode())) {
throw new DotDataException(
LanguageUtil.get(user, "There-is-another-structure-with-the-same-name"));
}
Arrays.sort(reservedStructureNames);
if (!InodeUtils.isSet(structureForm.getInode())
&& (Arrays.binarySearch(reservedStructureNames, auxStructureName) >= 0)) {
throw new DotDataException("Invalid Reserved Structure Name : " + auxStructureName);
}
// Validate if is a new structure and if the name hasn't change
if (!InodeUtils.isSet(structure.getInode())) {
newStructure = true;
} else {
String structureName = structure.getName();
String structureFormName = structureForm.getName();
if (UtilMethods.isSet(structureName)
&& UtilMethods.isSet(structureFormName)
&& !structureName.equals(structureFormName)
&& !structure.isFixed()) {
StructureCache.removeStructure(structure);
}
}
// If the structure is fixed the name cannot be changed
if (structure.isFixed()) {
structureForm.setName(structure.getName());
}
// if I'm editing a structure the structureType couldn't not be
// change
if (UtilMethods.isSet(structure.getInode()) && InodeUtils.isSet(structure.getInode())) {
// reset the structure type to it's original value
structureForm.setStructureType(structure.getStructureType());
}
if (UtilMethods.isSet(structure.getVelocityVarName())) {
structureForm.setVelocityVarName(structure.getVelocityVarName());
}
if (UtilMethods.isSet(structureForm.getHost())) {
if (!structureForm.getHost().equals(Host.SYSTEM_HOST)
&& hostAPI.findSystemHost().getIdentifier().equals(structureForm.getHost())) {
structureForm.setHost(Host.SYSTEM_HOST);
}
structureForm.setFolder("SYSTEM_FOLDER");
} else if (UtilMethods.isSet(structureForm.getFolder())) {
structureForm.setHost(folderAPI.find(structureForm.getFolder(), user, false).getHostId());
}
if (UtilMethods.isSet(structureForm.getHost())
&& (!UtilMethods.isSet(structureForm.getFolder())
|| structureForm.getFolder().equals("SYSTEM_FOLDER"))) {
Host host = hostAPI.find(structureForm.getHost(), user, false);
if (host != null) {
if (structure.getStructureType() == Structure.STRUCTURE_TYPE_FORM) {
if (!perAPI.doesUserHavePermissions(
host,
"PARENT:"
+ PermissionAPI.PERMISSION_CAN_ADD_CHILDREN
+ ", STRUCTURES:"
+ PermissionAPI.PERMISSION_PUBLISH,
user)) {
throw new DotDataException(
LanguageUtil.get(
user, "User-does-not-have-add-children-permission-on-host-folder"));
}
} else {
if (!perAPI.doesUserHavePermission(
host, PermissionAPI.PERMISSION_CAN_ADD_CHILDREN, user)) {
throw new DotDataException(
LanguageUtil.get(
user, "User-does-not-have-add-children-permission-on-host-folder"));
}
}
}
}
if (UtilMethods.isSet(structureForm.getFolder())
&& !structureForm.getFolder().equals("SYSTEM_FOLDER")) {
Folder folder = folderAPI.find(structureForm.getFolder(), user, false);
if (folder != null) {
if (structure.getStructureType() == Structure.STRUCTURE_TYPE_FORM) {
if (!perAPI.doesUserHavePermissions(
folder,
"PARENT:"
+ PermissionAPI.PERMISSION_CAN_ADD_CHILDREN
+ ", STRUCTURES:"
+ PermissionAPI.PERMISSION_PUBLISH,
user)) {
throw new DotDataException(
LanguageUtil.get(
user, "User-does-not-have-add-children-permission-on-host-folder"));
}
} else {
if (!perAPI.doesUserHavePermission(
folder, PermissionAPI.PERMISSION_CAN_ADD_CHILDREN, user)) {
throw new DotDataException(
LanguageUtil.get(
user, "User-does-not-have-add-children-permission-on-host-folder"));
}
}
}
}
BeanUtils.copyProperties(structure, structureForm);
// if htmlpage doesn't exist page id should be an identifier. Should
// be refactored once we get identifierAPI/HTMLPage API done
String pageDetail = structureForm.getDetailPage();
if (newStructure) {
String structureVelocityName =
VelocityUtil.convertToVelocityVariable(structure.getName(), true);
List<String> velocityvarnames = StructureFactory.getAllVelocityVariablesNames();
int found = 0;
if (VelocityUtil.isNotAllowedVelocityVariableName(structureVelocityName)) {
found++;
}
for (String velvar : velocityvarnames) {
if (velvar != null) {
if (structureVelocityName.equalsIgnoreCase(velvar)) {
found++;
} else if (velvar.toLowerCase().contains(structureVelocityName.toLowerCase())) {
String number = velvar.substring(structureVelocityName.length());
if (RegEX.contains(number, "^[0-9]+$")) {
found++;
}
}
}
}
if (found > 0) {
structureVelocityName = structureVelocityName + Integer.toString(found);
}
structure.setVelocityVarName(structureVelocityName);
}
if (UtilMethods.isSet(pageDetail)) {
structure.setDetailPage(pageDetail);
}
// Saving interval review properties
if (structureForm.isReviewContent()) {
structure.setReviewInterval(
structureForm.getReviewIntervalNum() + structureForm.getReviewIntervalSelect());
} else {
structure.setReviewInterval(null);
structure.setReviewerRole(null);
}
// If there is no default structure this would be
Structure defaultStructure = StructureFactory.getDefaultStructure();
if (!InodeUtils.isSet(defaultStructure.getInode())) {
structure.setDefaultStructure(true);
}
if (newStructure) {
structure.setFixed(false);
structure.setOwner(user.getUserId());
}
// validate iit is a form structure set it as system by default
if (structureForm.getStructureType() == Structure.STRUCTURE_TYPE_FORM) {
structure.setSystem(true);
}
StructureFactory.saveStructure(structure);
structureForm.setUrlMapPattern(structure.getUrlMapPattern());
WorkflowScheme scheme = APILocator.getWorkflowAPI().findSchemeForStruct(structure);
String schemeId = req.getParameter("workflowScheme");
if (scheme != null && UtilMethods.isSet(schemeId) && !schemeId.equals(scheme.getId())) {
scheme = APILocator.getWorkflowAPI().findScheme(schemeId);
APILocator.getWorkflowAPI().saveSchemeForStruct(structure, scheme);
}
// if the structure is a widget we need to add the base fields.
if (newStructure && structureForm.getStructureType() == Structure.STRUCTURE_TYPE_WIDGET) {
wAPI.createBaseWidgetFields(structure);
}
// if the structure is a form we need to add the base fields.
if (newStructure && structureForm.getStructureType() == Structure.STRUCTURE_TYPE_FORM) {
fAPI.createBaseFormFields(structure);
}
// if the structure is a form we need to add the base fields.
if (newStructure && structureForm.getStructureType() == Structure.STRUCTURE_TYPE_FILEASSET) {
APILocator.getFileAssetAPI().createBaseFileAssetFields(structure);
}
if (!newStructure) {
perAPI.resetPermissionReferences(structure);
}
// Saving the structure in cache
StructureCache.removeStructure(structure);
StructureCache.addStructure(structure);
StructureServices.removeStructureFile(structure);
String message = "message.structure.savestructure";
if (structure.getStructureType() == 3) {
message = "message.form.saveform";
}
SessionMessages.add(req, "message", message);
AdminLogger.log(
EditStructureAction.class,
"_saveStructure",
"Structure saved : " + structure.getName(),
user);
} catch (Exception ex) {
Logger.error(this.getClass(), ex.toString());
String message = ex.toString();
SessionMessages.add(req, "error", message);
}
}
public Map<String, Object> saveEvent(List<String> formData, boolean isAutoSave, boolean isCheckin)
throws LanguageException, PortalException, SystemException, DotDataException,
DotSecurityException, java.text.ParseException {
HibernateUtil.startTransaction();
ContentletWebAPI contentletWebAPI = WebAPILocator.getContentletWebAPI();
int tempCount =
0; // To store multiple values opposite to a name. Ex: selected permissions & categories
String newInode = "";
String referer = "";
String language = "";
String strutsAction = "";
String recurrenceDaysOfWeek = "";
Map<String, Object> contentletFormData = new HashMap<String, Object>();
Map<String, Object> callbackData = new HashMap<String, Object>();
List<String> saveContentErrors = new ArrayList<String>();
HttpServletRequest req = WebContextFactory.get().getHttpServletRequest();
User user = com.liferay.portal.util.PortalUtil.getUser((HttpServletRequest) req);
List<Field> fields =
com.dotmarketing.cache.FieldsCache.getFieldsByStructureInode(
eventAPI.getEventStructure().getInode());
String titleField = "";
String urlTitleField = "";
String urlTitleFieldValue = "";
String titleFieldValue = "";
for (Field field : fields) {
if (field.getVelocityVarName().equals("urlTitle")) {
urlTitleField = field.getFieldContentlet();
}
if (field.getVelocityVarName().equals("title")) {
titleField = field.getFieldContentlet();
}
if (UtilMethods.isSet(titleField) && UtilMethods.isSet(urlTitleField)) {
break;
}
}
// get the struts_action from the form data
for (Iterator<String> iterator = formData.iterator(); iterator.hasNext(); ) {
String element = iterator.next();
if (element != null) {
String elementName =
element.substring(0, element.indexOf(WebKeys.CONTENTLET_FORM_NAME_VALUE_SEPARATOR));
if (elementName.startsWith("_EXT") && elementName.endsWith("cmd")) {
strutsAction = elementName.substring(0, elementName.indexOf("cmd"));
break;
}
}
}
// Storing form data into map.
for (Iterator<String> iterator = formData.iterator(); iterator.hasNext(); ) {
String element = iterator.next();
if (!com.dotmarketing.util.UtilMethods.isSet(element)) continue;
String elementName =
element.substring(0, element.indexOf(WebKeys.CONTENTLET_FORM_NAME_VALUE_SEPARATOR));
Object elementValue =
element.substring(
element.indexOf(WebKeys.CONTENTLET_FORM_NAME_VALUE_SEPARATOR)
+ WebKeys.CONTENTLET_FORM_NAME_VALUE_SEPARATOR.length());
if (element.startsWith(strutsAction))
elementName =
elementName.substring(elementName.indexOf(strutsAction) + strutsAction.length());
// Placed increments as Map holds unique keys.
if (elementName.equals("read")
|| elementName.equals("write")
|| elementName.equals("publish")) {
tempCount++;
elementName = "selected_permission_" + tempCount + elementName;
}
if (elementName.equals(titleField)) {
titleFieldValue = (String) elementValue;
}
if (elementName.equals(urlTitleField)) {
urlTitleFieldValue = (String) elementValue;
}
if (elementName.equals("categories")) {
tempCount++;
elementName = elementName + tempCount + "_";
}
// http://jira.dotmarketing.net/browse/DOTCMS-3232
if (elementName.equalsIgnoreCase("hostId")) {
callbackData.put("hostOrFolder", true);
}
if (elementName.startsWith("binary")) {
String binaryFileValue = (String) elementValue;
if (UtilMethods.isSet(binaryFileValue) && !binaryFileValue.equals("---removed---")) {
binaryFileValue = ContentletUtil.sanitizeFileName(binaryFileValue);
File binaryFile =
new File(
APILocator.getFileAPI().getRealAssetPathTmpBinary()
+ File.separator
+ user.getUserId()
+ File.separator
+ elementName
+ File.separator
+ binaryFileValue);
if (binaryFile.exists()) binaryFile.delete();
elementValue = binaryFile;
} else {
elementValue = null;
}
}
if (!UtilMethods.isSet(elementName)) continue;
if (elementValue == null) elementValue = "";
if (elementName.equals("referer")) referer = (String) elementValue;
if (elementName.equals("languageId")) language = (String) elementValue;
if (elementName.equals("recurrenceDaysOfWeek")) {
recurrenceDaysOfWeek = recurrenceDaysOfWeek + elementValue + ",";
}
contentletFormData.put(elementName, elementValue);
}
contentletFormData.put("recurrenceDaysOfWeek", recurrenceDaysOfWeek);
if (!UtilMethods.isSet(urlTitleFieldValue) && UtilMethods.isSet(titleFieldValue)) {
urlTitleFieldValue = titleFieldValue.toLowerCase();
urlTitleFieldValue = urlTitleFieldValue.replace("/^\\s+|\\s+$/g", "");
urlTitleFieldValue = urlTitleFieldValue.replace("/[^a-zA-Z 0-9]+/g", " ");
urlTitleFieldValue = urlTitleFieldValue.replace("/\\s/g", "-");
while (urlTitleFieldValue.indexOf("--") > -1) {
urlTitleFieldValue = urlTitleFieldValue.replace("--", "-");
}
contentletFormData.put(urlTitleField, urlTitleFieldValue);
}
String d1 = (String) contentletFormData.get("date1");
String d2 = (String) contentletFormData.get("date2");
String d3 = (String) contentletFormData.get("recurrenceEnds");
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");
DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd");
Date eventStartDate = null;
Date eventEndDate = null;
Date recurrenceEndDate = null;
try {
eventStartDate = df.parse(d1);
eventEndDate = df.parse(d2);
if (UtilMethods.isSet(d3)) {
recurrenceEndDate = df2.parse(d3);
}
} catch (java.text.ParseException e1) {
}
Boolean cont = true;
if (eventEndDate.before(eventStartDate)) {
String errorString = LanguageUtil.get(user, "message.event.endate.before.stardate");
saveContentErrors.add(errorString);
}
if (!contentletFormData.get("recurrenceOccurs").toString().equals("never")) {
if (contentletFormData.get("noEndDate") == null
|| !Boolean.parseBoolean(contentletFormData.get("noEndDate").toString())) {
if (recurrenceEndDate != null && recurrenceEndDate.before(eventStartDate)) {
String errorString =
LanguageUtil.get(user, "message.event.recurrence.endate.before.stardate");
saveContentErrors.add(errorString);
}
}
}
Calendar start = Calendar.getInstance();
start.setTime(eventStartDate);
Calendar end = Calendar.getInstance();
end.setTime(eventEndDate);
if (!contentletFormData.get("recurrenceOccurs").toString().equals("never")) {
if (end.after(start)
&& (end.get(Calendar.DAY_OF_MONTH) > start.get(Calendar.DAY_OF_MONTH)
|| end.get(Calendar.MONTH) > start.get(Calendar.MONTH)
|| end.get(Calendar.YEAR) > start.get(Calendar.YEAR))) {
contentletFormData.put("recurrenceOccurs", "never");
}
}
if (Boolean.parseBoolean(contentletFormData.get("recurrenceChanged").toString())) {
if (!UtilMethods.isSet(contentletFormData.get("recurrenceInterval"))) {
String errorString = LanguageUtil.get(user, "message.event.recurrence.invalid.interval");
saveContentErrors.add(errorString);
} else {
try {
Long.valueOf((String) contentletFormData.get("recurrenceInterval"));
} catch (NumberFormatException nfe) {
String errorString = LanguageUtil.get(user, "message.event.recurrence.invalid.interval");
saveContentErrors.add(errorString);
}
}
if (contentletFormData.get("recurrenceOccurs").toString().equals("monthly")) {
if (Boolean.parseBoolean(contentletFormData.get("isSpecificDate").toString())
&& !UtilMethods.isSet((String) contentletFormData.get("recurrenceDayOfMonth"))) {
String errorString =
LanguageUtil.get(user, "message.event.recurrence.invalid.dayofmonth");
saveContentErrors.add(errorString);
}
if (Boolean.parseBoolean(contentletFormData.get("isSpecificDate").toString())
&& UtilMethods.isSet((String) contentletFormData.get("recurrenceDayOfMonth"))) {
try {
Long.valueOf((String) contentletFormData.get("recurrenceDayOfMonth"));
} catch (Exception e) {
String errorString =
LanguageUtil.get(user, "message.event.recurrence.invalid.dayofmonth");
saveContentErrors.add(errorString);
}
} else {
contentletFormData.put("recurrenceDayOfMonth", "0");
}
}
if (contentletFormData.get("recurrenceOccurs").toString().equals("annually")) {
if (Boolean.parseBoolean(contentletFormData.get("isSpecificDate").toString())
&& !UtilMethods.isSet((String) contentletFormData.get("specificDayOfMonthRecY"))
&& !UtilMethods.isSet((String) contentletFormData.get("specificMonthOfYearRecY"))) {
String errorString = LanguageUtil.get(user, "message.event.recurrence.invalid.date");
saveContentErrors.add(errorString);
}
if (Boolean.parseBoolean(contentletFormData.get("isSpecificDate").toString())
&& UtilMethods.isSet((String) contentletFormData.get("specificDayOfMonthRecY"))
&& UtilMethods.isSet((String) contentletFormData.get("specificMonthOfYearRecY"))) {
try {
Long.valueOf((String) contentletFormData.get("specificDayOfMonthRecY"));
contentletFormData.put(
"recurrenceDayOfMonth", (String) contentletFormData.get("specificDayOfMonthRecY"));
} catch (Exception e) {
String errorString =
LanguageUtil.get(user, "message.event.recurrence.invalid.dayofmonth");
saveContentErrors.add(errorString);
}
try {
Long.valueOf((String) contentletFormData.get("specificMonthOfYearRecY"));
contentletFormData.put(
"recurrenceMonthOfYear",
(String) contentletFormData.get("specificMonthOfYearRecY"));
} catch (Exception e) {
String errorString =
LanguageUtil.get(user, "message.event.recurrence.invalid.monthofyear");
saveContentErrors.add(errorString);
}
} else {
contentletFormData.put("recurrenceDayOfMonth", "0");
}
}
}
if (!contentletFormData.get("recurrenceOccurs").toString().equals("never")) {
if (contentletFormData.get("noEndDate") == null
|| (contentletFormData.get("noEndDate") != null
&& !Boolean.parseBoolean(contentletFormData.get("noEndDate").toString()))) {
if (!UtilMethods.isSet((String) contentletFormData.get("recurrenceEnds"))) {
String errorString = LanguageUtil.get(user, "message.event.recurrence.invalid.enddate");
saveContentErrors.add(errorString);
} else {
try {
eventRecurrenceEndDateF.parse((String) contentletFormData.get("recurrenceEnds"));
} catch (Exception e) {
String errorString = LanguageUtil.get(user, "message.event.recurrence.invalid.enddate");
saveContentErrors.add(errorString);
}
}
}
}
// http://jira.dotmarketing.net/browse/DOTCMS-6327
if (!contentletFormData.get("recurrenceOccurs").toString().equals("never")) {
if (contentletFormData.get("noEndDate") == null
|| !Boolean.parseBoolean(contentletFormData.get("noEndDate").toString())) {
Integer interval =
UtilMethods.isSet((String) contentletFormData.get("recurrenceInterval"))
? Integer.valueOf((String) contentletFormData.get("recurrenceInterval"))
: null;
Integer recurrenceWeekOfMonth =
UtilMethods.isSet((String) contentletFormData.get("recurrenceWeekOfMonth"))
? Integer.valueOf((String) contentletFormData.get("recurrenceWeekOfMonth"))
: null;
Integer recurrenceDayOfWeek =
UtilMethods.isSet((String) contentletFormData.get("recurrenceDayOfWeek"))
? Integer.valueOf((String) contentletFormData.get("recurrenceDayOfWeek"))
: null;
Integer recurrenceMonthOfYear =
UtilMethods.isSet((String) contentletFormData.get("recurrenceMonthOfYear"))
? Integer.valueOf((String) contentletFormData.get("recurrenceMonthOfYear"))
: null;
Integer recurrenceDayOfMonth =
UtilMethods.isSet((String) contentletFormData.get("recurrenceDayOfMonth"))
? Integer.valueOf((String) contentletFormData.get("recurrenceDayOfMonth"))
: null;
Occurrency occurency =
Occurrency.findOcurrency((String) contentletFormData.get("recurrenceOccurs"));
if (occurency != null) {
Calendar firstOccurence =
RecurrenceUtil.calculateFirstOccurence(
eventStartDate,
interval,
occurency,
recurrenceDaysOfWeek,
recurrenceWeekOfMonth,
recurrenceDayOfWeek,
recurrenceMonthOfYear,
recurrenceDayOfMonth);
if (recurrenceEndDate.before(firstOccurence.getTime())) {
String errorString =
LanguageUtil.get(user, "message.event.recurrence.before.occurence");
saveContentErrors.add(errorString);
}
}
}
}
try {
if (cont && (saveContentErrors == null || saveContentErrors.isEmpty())) {
newInode = contentletWebAPI.saveContent(contentletFormData, isAutoSave, isCheckin, user);
}
} catch (DotContentletValidationException ve) {
if (ve.hasRequiredErrors()) {
List<Field> reqs =
ve.getNotValidFields().get(DotContentletValidationException.VALIDATION_FAILED_REQUIRED);
for (Field field : reqs) {
String errorString = LanguageUtil.get(user, "message.contentlet.required");
errorString = errorString.replace("{0}", field.getFieldName());
saveContentErrors.add(errorString);
}
}
if (ve.hasLengthErrors()) {
List<Field> reqs =
ve.getNotValidFields()
.get(DotContentletValidationException.VALIDATION_FAILED_MAXLENGTH);
for (Field field : reqs) {
String errorString = LanguageUtil.get(user, "message.contentlet.maxlength");
errorString = errorString.replace("{0}", field.getFieldName());
errorString = errorString.replace("{1}", "225");
saveContentErrors.add(errorString);
}
}
if (ve.hasPatternErrors()) {
List<Field> reqs =
ve.getNotValidFields().get(DotContentletValidationException.VALIDATION_FAILED_PATTERN);
for (Field field : reqs) {
String errorString = LanguageUtil.get(user, "message.contentlet.format");
errorString = errorString.replace("{0}", field.getFieldName());
saveContentErrors.add(errorString);
}
}
if (ve.hasRelationshipErrors()) {
StringBuffer sb = new StringBuffer("<br>");
Map<String, Map<Relationship, List<Contentlet>>> notValidRelationships =
ve.getNotValidRelationship();
Set<String> auxKeys = notValidRelationships.keySet();
for (String key : auxKeys) {
String errorMessage = "";
if (key.equals(DotContentletValidationException.VALIDATION_FAILED_REQUIRED_REL)) {
errorMessage = "<b>Required Relationship</b>";
} else if (key.equals(
DotContentletValidationException.VALIDATION_FAILED_INVALID_REL_CONTENT)) {
errorMessage = "<b>Invalid Relationship-Contentlet</b>";
} else if (key.equals(DotContentletValidationException.VALIDATION_FAILED_BAD_REL)) {
errorMessage = "<b>Bad Relationship</b>";
}
sb.append(errorMessage + ":<br>");
Map<Relationship, List<Contentlet>> relationshipContentlets =
notValidRelationships.get(key);
for (Entry<Relationship, List<Contentlet>> relationship :
relationshipContentlets.entrySet()) {
sb.append(relationship.getKey().getRelationTypeValue() + ", ");
}
sb.append("<br>");
}
sb.append("<br>");
// need to update message to support multiple relationship validation errors
String errorString = LanguageUtil.get(user, "message.relationship.required_ext");
errorString = errorString.replace("{0}", sb.toString());
saveContentErrors.add(errorString);
}
if (ve.hasUniqueErrors()) {
List<Field> reqs =
ve.getNotValidFields().get(DotContentletValidationException.VALIDATION_FAILED_UNIQUE);
for (Field field : reqs) {
String errorString = LanguageUtil.get(user, "message.contentlet.unique");
errorString = errorString.replace("{0}", field.getFieldName());
saveContentErrors.add(errorString);
}
}
if (ve.getMessage()
.contains(
"The content form submission data id different from the content which is trying to be edited")) {
String errorString = LanguageUtil.get(user, "message.contentlet.invalid.form");
saveContentErrors.add(errorString);
}
} catch (DotSecurityException dse) {
String errorString = LanguageUtil.get(user, "message.insufficient.permissions.to.save");
saveContentErrors.add(errorString);
} catch (Exception e) {
if (e.getMessage().equals(Constants.COMMON_ERROR)) {
String errorString = LanguageUtil.get(user, "message.contentlet.save.error");
saveContentErrors.add(errorString);
SessionMessages.clear(req.getSession());
} else {
saveContentErrors.add(e.getLocalizedMessage());
}
} finally {
if (!isAutoSave && (saveContentErrors != null && saveContentErrors.size() > 0)) {
callbackData.put("saveContentErrors", saveContentErrors);
SessionMessages.clear(req.getSession());
}
}
if (InodeUtils.isSet(newInode)) callbackData.put("contentletInode", newInode);
if (!isAutoSave && (saveContentErrors == null || saveContentErrors.size() == 0)) {
Logger.debug(this, "AFTER PUBLISH LANGUAGE=" + language);
if (UtilMethods.isSet(language) && referer.indexOf("language") > -1) {
Logger.debug(this, "Replacing referer language=" + referer);
referer =
referer.replaceAll(
"language=([0-9])*",
com.dotmarketing.util.WebKeys.HTMLPAGE_LANGUAGE + "=" + language);
Logger.debug(this, "Referer after being replaced=" + referer);
}
}
boolean savingRecurrence = false;
callbackData.put("referer", referer);
HibernateUtil.commitTransaction();
if (UtilMethods.isSet(newInode) && !savingRecurrence) {
if (!contAPI.isInodeIndexed(newInode)) {
Logger.error(this, "Timed out while waiting for index to return");
}
}
return callbackData;
}
public Map<String, Object> disconnectEvent(String inode, String startDateStr, String endDateStr)
throws DotRuntimeException, PortalException, SystemException, DotDataException,
DotSecurityException, java.text.ParseException {
WebContext ctx = WebContextFactory.get();
HttpServletRequest request = ctx.getHttpServletRequest();
// Retrieving the current user
User user = userAPI.getLoggedInUser(request);
boolean respectFrontendRoles = true;
Map<String, Object> eventMap = new HashMap<String, Object>();
List<String> disconnectEventErrors = new ArrayList<String>();
String inodeStr = (InodeUtils.isSet(inode) ? inode : "");
Contentlet contentlet = new Contentlet();
if (InodeUtils.isSet(inodeStr)) {
contentlet = contAPI.find(inodeStr, user, false);
}
if (InodeUtils.isSet(contentlet.getInode())) {
Event ev = null;
try {
ev = eventAPI.find(contentlet.getIdentifier(), false, user, respectFrontendRoles);
} catch (Exception e) {
disconnectEventErrors.add(e.getLocalizedMessage());
} finally {
if (disconnectEventErrors.size() > 0) {
eventMap.put("disconnectEventErrors", disconnectEventErrors);
}
}
if (ev != null) {
Date startDate = null;
Date endDate = null;
try {
if (UtilMethods.isSet(startDateStr)) {
String date = dateFormat.format(dateFormat2.parse(startDateStr));
startDate = dateFormat.parse(date);
}
if (UtilMethods.isSet(endDateStr)) {
String date = dateFormat.format(dateFormat2.parse(endDateStr));
endDate = dateFormat.parse(date);
}
} catch (java.text.ParseException pe) {
disconnectEventErrors.add(pe.getLocalizedMessage());
} finally {
if (disconnectEventErrors.size() > 0) {
eventMap.put("disconnectEventErrors", disconnectEventErrors);
}
}
if (startDate != null && endDate != null) {
Calendar originalStartDate = Calendar.getInstance();
Calendar originalEndDate = Calendar.getInstance();
Calendar newStartDate = Calendar.getInstance();
Calendar newEndDate = Calendar.getInstance();
originalStartDate.setTime(ev.getStartDate());
originalEndDate.setTime(ev.getEndDate());
newStartDate.setTime(startDate);
newEndDate.setTime(endDate);
originalStartDate.set(Calendar.YEAR, newStartDate.get(Calendar.YEAR));
originalStartDate.set(Calendar.MONTH, newStartDate.get(Calendar.MONTH));
originalStartDate.set(Calendar.DAY_OF_MONTH, newStartDate.get(Calendar.DAY_OF_MONTH));
originalEndDate.set(Calendar.YEAR, newEndDate.get(Calendar.YEAR));
originalEndDate.set(Calendar.MONTH, newEndDate.get(Calendar.MONTH));
originalEndDate.set(Calendar.DAY_OF_MONTH, newEndDate.get(Calendar.DAY_OF_MONTH));
Event newEvent = null;
try {
boolean autoCom = false;
try {
autoCom = DbConnectionFactory.getConnection().getAutoCommit();
} catch (Exception e) {
throw new DotDataException(e.getMessage());
}
if (autoCom) {
HibernateUtil.startTransaction();
}
newEvent =
eventAPI.disconnectEvent(
ev, user, originalStartDate.getTime(), originalEndDate.getTime());
eventMap = newEvent.getMap();
// Loading categories
List<Map<String, Object>> categoryMaps = new ArrayList<Map<String, Object>>();
List<Category> eventCategories =
categoryAPI.getParents(newEvent, user, respectFrontendRoles);
for (Category cat : eventCategories) {
categoryMaps.add(cat.getMap());
}
eventMap.put("categories", categoryMaps);
eventMap.put("rating", RatingAPI.getAverageRating(newEvent.getIdentifier()));
eventMap.put("votes", RatingAPI.getRatingVotesNumber(newEvent.getIdentifier()));
eventMap.put(
"hasReadPermission",
perAPI.doesUserHavePermission(
newEvent, PermissionAPI.PERMISSION_READ, user, respectFrontendRoles));
eventMap.put(
"hasWritePermission",
perAPI.doesUserHavePermission(
newEvent, PermissionAPI.PERMISSION_WRITE, user, respectFrontendRoles));
eventMap.put(
"hasPublishPermission",
perAPI.doesUserHavePermission(
newEvent, PermissionAPI.PERMISSION_PUBLISH, user, respectFrontendRoles));
eventMap.put(
"readPermission",
perAPI.doesUserHavePermission(
newEvent, PermissionAPI.PERMISSION_READ, user, respectFrontendRoles));
eventMap.put(
"writePermission",
perAPI.doesUserHavePermission(
newEvent, PermissionAPI.PERMISSION_WRITE, user, respectFrontendRoles));
eventMap.put(
"publishPermission",
perAPI.doesUserHavePermission(
newEvent, PermissionAPI.PERMISSION_PUBLISH, user, respectFrontendRoles));
eventMap.put("isDisconnected", UtilMethods.isSet(newEvent.getDisconnectedFrom()));
CommentsWebAPI cAPI = new CommentsWebAPI();
cAPI.setUser(user);
cAPI.setRespectFrontendRoles(respectFrontendRoles);
eventMap.put("commentsCount", cAPI.getCommentsCount(newEvent.getInode()));
HibernateUtil.commitTransaction();
} catch (Exception e) {
HibernateUtil.rollbackTransaction();
disconnectEventErrors.add(e.getLocalizedMessage());
} finally {
if (disconnectEventErrors.size() > 0) {
eventMap.put("disconnectEventErrors", disconnectEventErrors);
}
}
}
}
}
return eventMap;
}
@SuppressWarnings("unchecked")
public static InputStream buildStream(HTMLPage htmlPage, Identifier identifier, boolean EDIT_MODE)
throws DotDataException, DotSecurityException {
String folderPath = (!EDIT_MODE) ? "live/" : "working/";
InputStream result;
StringBuilder sb = new StringBuilder();
ContentletAPI conAPI = APILocator.getContentletAPI();
Template cmsTemplate =
com.dotmarketing.portlets.htmlpages.factories.HTMLPageFactory.getHTMLPageTemplate(
htmlPage, EDIT_MODE);
if (cmsTemplate == null || !InodeUtils.isSet(cmsTemplate.getInode())) {
Logger.error(
This.class,
"PAGE DOES NOT HAVE A VALID TEMPLATE (template unpublished?) : page id "
+ htmlPage.getIdentifier()
+ ":"
+ identifier.getURI());
}
// gets pageChannel for this path
java.util.StringTokenizer st =
new java.util.StringTokenizer(String.valueOf(identifier.getURI()), "/");
String pageChannel = null;
if (st.hasMoreTokens()) {
pageChannel = st.nextToken();
}
// set the page cache var
if (htmlPage.getCacheTTL() > 0 && LicenseUtil.getLevel() > 99) {
sb.append("#set($dotPageCacheDate = \"").append(new java.util.Date()).append("\")");
sb.append("#set($dotPageCacheTTL = \"").append(htmlPage.getCacheTTL()).append("\")");
}
// set the host variables
HTMLPageAPI htmlPageAPI = APILocator.getHTMLPageAPI();
Host host = htmlPageAPI.getParentHost(htmlPage);
sb.append("#if(!$doNotParseTemplate)");
sb.append("$velutil.mergeTemplate('")
.append(folderPath)
.append(host.getIdentifier())
.append(".")
.append(Config.getStringProperty("VELOCITY_HOST_EXTENSION"))
.append("')");
sb.append(" #end ");
// creates the context where to place the variables
// Build a context to pass to the page
sb.append("#if(!$doNotSetPageInfo)");
sb.append("#set ( $quote = '\"' )");
sb.append("#set ($HTMLPAGE_INODE = \"")
.append(String.valueOf(htmlPage.getInode()))
.append("\" )");
sb.append("#set ($HTMLPAGE_IDENTIFIER = \"")
.append(String.valueOf(htmlPage.getIdentifier()))
.append("\" )");
sb.append("#set ($HTMLPAGE_TITLE = \"")
.append(UtilMethods.espaceForVelocity(htmlPage.getTitle()))
.append("\" )");
sb.append(
"#set ($HTMLPAGE_FRIENDLY_NAME = \""
+ UtilMethods.espaceForVelocity(htmlPage.getFriendlyName()))
.append("\" )");
sb.append("#set ($TEMPLATE_INODE = \"")
.append(String.valueOf(cmsTemplate.getInode()))
.append("\" )");
sb.append("#set ($HTMLPAGE_META = \"")
.append(UtilMethods.espaceForVelocity(htmlPage.getMetadata()))
.append("\" )");
sb.append("#set ($HTMLPAGE_META = \"#fixBreaks($HTMLPAGE_META)\")");
sb.append("#set ($HTMLPAGE_DESCRIPTION = \"")
.append(UtilMethods.espaceForVelocity(htmlPage.getSeoDescription()))
.append("\" )");
sb.append("#set ($HTMLPAGE_DESCRIPTION = \"#fixBreaks($HTMLPAGE_DESCRIPTION)\")");
sb.append("#set ($HTMLPAGE_KEYWORDS = \"")
.append(UtilMethods.espaceForVelocity(htmlPage.getSeoKeywords()))
.append("\" )");
sb.append("#set ($HTMLPAGE_KEYWORDS = \"#fixBreaks($HTMLPAGE_KEYWORDS)\")");
sb.append("#set ($HTMLPAGE_SECURE = \"")
.append(String.valueOf(htmlPage.isHttpsRequired()))
.append("\" )");
sb.append("#set ($VTLSERVLET_URI = \"")
.append(UtilMethods.encodeURIComponent(identifier.getURI()))
.append("\" )");
sb.append("#set ($HTMLPAGE_REDIRECT = \"")
.append(UtilMethods.espaceForVelocity(htmlPage.getRedirect()))
.append("\" )");
sb.append("#set ($pageTitle = \"")
.append(UtilMethods.espaceForVelocity(htmlPage.getTitle()))
.append("\" )");
sb.append("#set ($pageChannel = \"").append(pageChannel).append("\" )");
sb.append("#set ($friendlyName = \"")
.append(UtilMethods.espaceForVelocity(htmlPage.getFriendlyName()))
.append("\" )");
Date moddate = null;
if (UtilMethods.isSet(htmlPage.getModDate())) {
moddate = htmlPage.getModDate();
} else {
moddate = htmlPage.getStartDate();
}
moddate = new Timestamp(moddate.getTime());
sb.append("#set ($HTML_PAGE_LAST_MOD_DATE= $date.toDate(\"yyyy-MM-dd HH:mm:ss.SSS\", \"")
.append(moddate)
.append("\"))");
sb.append("#set ($HTMLPAGE_MOD_DATE= $date.toDate(\"yyyy-MM-dd HH:mm:ss.SSS\", \"")
.append(moddate)
.append("\"))");
sb.append(" #end ");
// get the containers for the page and stick them in context
// List identifiers = InodeFactory.getChildrenClass(cmsTemplate, Identifier.class);
List<Container> containerList =
APILocator.getTemplateAPI()
.getContainersInTemplate(cmsTemplate, APILocator.getUserAPI().getSystemUser(), false);
Iterator i = containerList.iterator();
while (i.hasNext()) {
Container ident = (Container) i.next();
Container c = null;
if (EDIT_MODE) {
c =
(Container)
APILocator.getVersionableAPI()
.findWorkingVersion(
ident.getIdentifier(), APILocator.getUserAPI().getSystemUser(), false);
} else {
c =
(Container)
APILocator.getVersionableAPI()
.findLiveVersion(
ident.getIdentifier(), APILocator.getUserAPI().getSystemUser(), false);
}
// sets container to load the container file
sb.append("#set ($container")
.append(ident.getIdentifier())
.append(" = \"")
.append(folderPath)
.append(ident.getIdentifier())
.append(".")
.append(Config.getStringProperty("VELOCITY_CONTAINER_EXTENSION"))
.append("\" )");
String sort = (c.getSortContentletsBy() == null) ? "tree_order" : c.getSortContentletsBy();
boolean dynamicContainer = UtilMethods.isSet(c.getLuceneQuery());
int langCounter = 0;
List<Contentlet> contentlets = new ArrayList<Contentlet>();
List<Contentlet> contentletsFull = new ArrayList<Contentlet>();
if (!dynamicContainer) {
Identifier idenHtmlPage = APILocator.getIdentifierAPI().find(htmlPage);
Identifier idenContainer = APILocator.getIdentifierAPI().find(c);
// The container doesn't have categories
try {
contentlets =
conAPI.findPageContentlets(
idenHtmlPage.getId(),
idenContainer.getId(),
sort,
EDIT_MODE,
-1,
APILocator.getUserAPI().getSystemUser(),
false);
if (EDIT_MODE) contentletsFull = contentlets;
else
contentletsFull =
conAPI.findPageContentlets(
idenHtmlPage.getId(),
idenContainer.getId(),
sort,
true,
-1,
APILocator.getUserAPI().getSystemUser(),
false);
} catch (Exception e) {
Logger.error(PageServices.class, "Unable to retrive contentlets on page", e);
}
Logger.debug(
PageServices.class,
"HTMLPage= "
+ htmlPage.getInode()
+ " Container="
+ c.getInode()
+ " Language=-1 Contentlets="
+ contentlets.size());
}
// this is to filter the contentlets list removing the repited identifiers
if (contentlets.size() > 0) {
Set<String> contentletIdentList = new HashSet<String>();
List<Contentlet> contentletsFilter = new ArrayList<Contentlet>();
for (Contentlet cont : contentlets) {
if (!contentletIdentList.contains(cont.getIdentifier())) {
contentletIdentList.add(cont.getIdentifier());
contentletsFilter.add(cont);
}
}
contentlets = contentletsFilter;
}
if (contentletsFull.size() > 0) {
Set<String> contentletIdentList = new HashSet<String>();
List<Contentlet> contentletsFilter = new ArrayList<Contentlet>();
for (Contentlet cont : contentletsFull) {
if (!contentletIdentList.contains(cont.getIdentifier())) {
contentletIdentList.add(cont.getIdentifier());
contentletsFilter.add(cont);
}
}
contentletsFull = contentletsFilter;
}
StringBuilder widgetpree = new StringBuilder();
StringBuilder widgetpreeFull = new StringBuilder();
StringBuilder contentletList = new StringBuilder();
int count = 0;
for (Contentlet contentlet : contentlets) {
contentletList
.append(count == 0 ? "" : ",")
.append('"')
.append(contentlet.getIdentifier())
.append('"');
if (contentlet.getStructure().getStructureType() == Structure.STRUCTURE_TYPE_WIDGET) {
Field field = contentlet.getStructure().getFieldVar("widgetPreexecute");
if (field != null && UtilMethods.isSet(field.getValues()))
widgetpree.append(field.getValues().trim());
}
if (++count >= c.getMaxContentlets()) break;
}
StringBuilder contentletListFull = new StringBuilder();
int countFull = 0;
for (Contentlet contentlet : contentletsFull) {
contentletListFull
.append(countFull == 0 ? "" : ",")
.append('"')
.append(contentlet.getIdentifier())
.append('"');
if (contentlet.getStructure().getStructureType() == Structure.STRUCTURE_TYPE_WIDGET) {
Field field = contentlet.getStructure().getFieldVar("widgetPreexecute");
if (field != null && UtilMethods.isSet(field.getValues()))
widgetpreeFull.append(field.getValues().trim());
}
if (++countFull >= c.getMaxContentlets()) break;
}
sb.append("#if($request.session.getAttribute(\"tm_date\"))");
sb.append(widgetpreeFull);
sb.append("#set ($contentletList")
.append(ident.getIdentifier())
.append(" = [")
.append(contentletListFull.toString())
.append("] )");
sb.append("#set ($totalSize")
.append(ident.getIdentifier())
.append("=")
.append(countFull)
.append(")");
sb.append("#else ");
sb.append(widgetpree);
sb.append("#set ($contentletList")
.append(ident.getIdentifier())
.append(" = [")
.append(contentletList.toString())
.append("] )");
sb.append("#set ($totalSize")
.append(ident.getIdentifier())
.append("=")
.append(count)
.append(")");
sb.append("#end ");
langCounter++;
}
if (htmlPage.isHttpsRequired()) {
sb.append(" #if(!$ADMIN_MODE && !$request.isSecure())");
sb.append(" #if($request.getQueryString())");
sb.append(
" #set ($REDIRECT_URL = \"https://${request.getServerName()}$request.getAttribute('javax.servlet.forward.request_uri')?$request.getQueryString()\")");
sb.append(" #else ");
sb.append(
" #set ($REDIRECT_URL = \"https://${request.getServerName()}$request.getAttribute('javax.servlet.forward.request_uri')\")");
sb.append(" #end ");
sb.append(" $response.sendRedirect(\"$REDIRECT_URL\")");
sb.append(" #end ");
}
sb.append("#if($HTMLPAGE_REDIRECT != \"\")");
sb.append(" $response.sendRedirect(\"$HTMLPAGE_REDIRECT\")");
sb.append("#end");
Identifier iden = APILocator.getIdentifierAPI().find(cmsTemplate);
sb.append("#if(!$doNotParseTemplate)");
if (cmsTemplate.isDrawed()) { // We have a designed template
// Setting some theme variables
sb.append("#set ($dotTheme = $templatetool.theme(\"")
.append(cmsTemplate.getTheme())
.append("\",\"")
.append(host.getIdentifier())
.append("\"))");
sb.append("#set ($dotThemeLayout = $templatetool.themeLayout(\"")
.append(cmsTemplate.getInode())
.append("\" ))");
// Merging our template
sb.append("$velutil.mergeTemplate(\"$dotTheme.templatePath\")");
} else {
sb.append("$velutil.mergeTemplate('")
.append(folderPath)
.append(iden.getInode())
.append(".")
.append(Config.getStringProperty("VELOCITY_TEMPLATE_EXTENSION"))
.append("')");
}
sb.append("#end");
try {
if (Config.getBooleanProperty("SHOW_VELOCITYFILES", false)) {
String realFolderPath =
(!EDIT_MODE) ? "live" + java.io.File.separator : "working" + java.io.File.separator;
String velocityRootPath = Config.getStringProperty("VELOCITY_ROOT");
String filePath =
realFolderPath
+ identifier.getInode()
+ "."
+ Config.getStringProperty("VELOCITY_HTMLPAGE_EXTENSION");
if (velocityRootPath.startsWith("/WEB-INF")) {
velocityRootPath = com.liferay.util.FileUtil.getRealPath(velocityRootPath);
}
velocityRootPath += java.io.File.separator;
java.io.BufferedOutputStream tmpOut =
new java.io.BufferedOutputStream(
new java.io.FileOutputStream(
new java.io.File(
ConfigUtils.getDynamicVelocityPath() + java.io.File.separator + filePath)));
// Specify a proper character encoding
OutputStreamWriter out =
new OutputStreamWriter(tmpOut, UtilMethods.getCharsetConfiguration());
out.write(sb.toString());
out.flush();
out.close();
tmpOut.close();
}
} catch (Exception e) {
Logger.error(PageServices.class, e.toString(), e);
}
try {
result = new ByteArrayInputStream(sb.toString().getBytes("UTF-8"));
} catch (UnsupportedEncodingException e1) {
result = new ByteArrayInputStream(sb.toString().getBytes());
Logger.error(ContainerServices.class, e1.getMessage(), e1);
}
return result;
}
/**
* This method will copy the file data from file to version if version is not null and version
* inode > 0 and will replace current file data if newData passed is not null
*
* @param file
* @param version
* @param newData
* @throws IOException
* @throws Exception
*/
public void saveFileData(File file, File destination, java.io.File newDataFile)
throws IOException {
String fileName = file.getFileName();
// This was added for http://jira.dotmarketing.net/browse/DOTCMS-5390
// but this breaks the original intent of the
// method. See the doc for the method above. Caused
// http://jira.dotmarketing.net/browse/DOTCMS-5539 so commented out.
// if(newDataFile ==null || newDataFile.length() ==0){
// throw new
// DotStateException("Null or 0 lenght java.io.file passed in for file:"
// + file.getInode());
// }
String assetsPath = APILocator.getFileAPI().getRealAssetsRootPath();
new java.io.File(assetsPath).mkdir();
// creates the new file as
// inode{1}/inode{2}/inode.file_extension
java.io.File workingFile = getAssetIOFile(file);
// http://jira.dotmarketing.net/browse/DOTCMS-1873
// To clear velocity cache
DotResourceCache vc = CacheLocator.getVeloctyResourceCache();
vc.remove(ResourceManager.RESOURCE_TEMPLATE + workingFile.getPath());
// If a new version was created, we move the current data to the new
// version
if (destination != null && InodeUtils.isSet(destination.getInode())) {
java.io.File newVersionFile = getAssetIOFile(destination);
// FileUtil.copyFile(workingFile, newVersionFile);
FileUtils.copyFile(workingFile, newVersionFile);
// FileInputStream is = new FileInputStream(workingFile);
// FileChannel channelFrom = is.getChannel();
// java.io.File newVersionFile = getAssetIOFile(destination);
// FileChannel channelTo = new
// FileOutputStream(newVersionFile).getChannel();
// channelFrom.transferTo(0, channelFrom.size(), channelTo);
// channelTo.force(false);
// channelTo.close();
// channelFrom.close();
}
if (newDataFile != null) {
// Saving the new working data
FileUtils.copyFile(newDataFile, workingFile);
file.setSize((int) newDataFile.length());
// checks if it's an image
if (UtilMethods.isImage(fileName)) {
InputStream in = null;
try {
// gets image height
in = new BufferedInputStream(new FileInputStream(workingFile));
byte[] imageData = new byte[in.available()];
in.read(imageData);
Image image = Toolkit.getDefaultToolkit().createImage(imageData);
MediaTracker mediaTracker = new MediaTracker(new Container());
mediaTracker.addImage(image, 0);
mediaTracker.waitForID(0);
int imageWidth = image.getWidth(null);
int imageHeight = image.getHeight(null);
in.close();
in = null;
// gets image width
file.setHeight(imageHeight);
file.setWidth(imageWidth);
} catch (Exception e) {
Logger.error(
FileFactory.class, "Unable to read image " + workingFile + " : " + e.getMessage());
throw new IOException(e);
} finally {
if (in != null) {
try {
in.close();
} catch (Exception e) {
Logger.error(FileFactory.class, "Unable to close image " + e.getMessage());
}
}
}
}
// Wiping out the thumbnails and resized versions
// http://jira.dotmarketing.net/browse/DOTCMS-5911
String inode = file.getInode();
if (UtilMethods.isSet(inode)) {
String realAssetPath = APILocator.getFileAPI().getRealAssetPath();
java.io.File tumbnailDir =
new java.io.File(
realAssetPath
+ java.io.File.separator
+ "dotGenerated"
+ java.io.File.separator
+ inode.charAt(0)
+ java.io.File.separator
+ inode.charAt(1));
if (tumbnailDir != null) {
java.io.File[] files = tumbnailDir.listFiles();
if (files != null) {
for (java.io.File iofile : files) {
try {
if (iofile.getName().startsWith("dotGenerated_")) {
iofile.delete();
}
} catch (SecurityException e) {
Logger.error(
FileFactory.class,
"EditFileAction._saveWorkingFileData(): "
+ iofile.getName()
+ " cannot be erased. Please check the file permissions.");
} catch (Exception e) {
Logger.error(
FileFactory.class, "EditFileAction._saveWorkingFileData(): " + e.getMessage());
}
}
}
}
}
}
}
/**
* Moves a file into the given directory OR host
*
* @param file File to be moved
* @param parent Destination Folder
* @param host Destination Host
* @return true if move success, false otherwise
* @throws DotDataException
* @throws DotStateException
* @throws DotSecurityException
*/
private Boolean moveFile(File file, Folder parent, Host host)
throws DotStateException, DotDataException, DotSecurityException {
HostAPI hostAPI = APILocator.getHostAPI();
// Find file identifier
Identifier identifier = com.dotmarketing.business.APILocator.getIdentifierAPI().find(file);
// gets working container
File workingWebAsset =
(File)
APILocator.getVersionableAPI()
.findWorkingVersion(identifier, APILocator.getUserAPI().getSystemUser(), false);
// gets live container
File liveWebAsset =
(File)
APILocator.getVersionableAPI()
.findLiveVersion(identifier, APILocator.getUserAPI().getSystemUser(), false);
// checks if another identifer with the same name exists in the same
Boolean fileNameExists;
if (parent != null) {
fileNameExists = fileNameExists(parent, file.getFileName());
} else {
fileNameExists =
fileNameExists(APILocator.getFolderAPI().findSystemFolder(), file.getFileName());
}
if (fileNameExists) {
return false;
}
// assets cache
if ((liveWebAsset != null) && (InodeUtils.isSet(liveWebAsset.getInode()))) {
LiveCache.removeAssetFromCache(liveWebAsset);
}
WorkingCache.removeAssetFromCache(workingWebAsset);
// gets old parent
Folder oldParent =
APILocator.getFolderAPI()
.findParentFolder(workingWebAsset, APILocator.getUserAPI().getSystemUser(), false);
/*oldParent.deleteChild(workingWebAsset);
if ((liveWebAsset != null) && (InodeUtils.isSet(liveWebAsset.getInode()))) {
oldParent.deleteChild(liveWebAsset);
}
//add new Parent
parent.addChild(workingWebAsset);
if ((liveWebAsset != null) && (InodeUtils.isSet(liveWebAsset.getInode()))) {
parent.addChild(liveWebAsset);
}*/
// gets identifier for this webasset and changes the uri and persists it
User systemUser;
try {
systemUser = APILocator.getUserAPI().getSystemUser();
if (host == null) {
host = hostAPI.findParentHost(parent, systemUser, false);
}
} catch (DotDataException e) {
Logger.error(FileFactory.class, e.getMessage(), e);
throw new DotRuntimeException(e.getMessage(), e);
} catch (DotSecurityException e) {
Logger.error(FileFactory.class, e.getMessage(), e);
throw new DotRuntimeException(e.getMessage(), e);
}
identifier.setHostId(host.getIdentifier());
identifier.setURI(parent != null ? workingWebAsset.getURI(parent) : workingWebAsset.getURI());
// HibernateUtil.saveOrUpdate(identifier);
APILocator.getIdentifierAPI().save(identifier);
if (UtilMethods.isSet(liveWebAsset))
CacheLocator.getIdentifierCache().removeFromCacheByVersionable(liveWebAsset);
// IdentifierCache.addAssetToIdentifierCache(liveWebAsset);
// Add to Preview and Live Cache
if ((liveWebAsset != null) && (InodeUtils.isSet(liveWebAsset.getInode()))) {
LiveCache.removeAssetFromCache(liveWebAsset);
LiveCache.addToLiveAssetToCache(liveWebAsset);
}
WorkingCache.removeAssetFromCache(workingWebAsset);
WorkingCache.addToWorkingAssetToCache(workingWebAsset);
if (file.isShowOnMenu()) {
// existing folder with different show on menu ... need to regenerate menu
if (parent != null) {
RefreshMenus.deleteMenu(oldParent, parent);
CacheLocator.getNavToolCache().removeNav(parent.getHostId(), parent.getInode());
} else {
RefreshMenus.deleteMenu(oldParent);
}
CacheLocator.getNavToolCache().removeNav(oldParent.getHostId(), oldParent.getInode());
}
return true;
}
public void doLiveMode(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String uri = URLDecoder.decode(request.getRequestURI(), UtilMethods.getCharsetConfiguration());
uri = UtilMethods.cleanURI(uri);
Host host = hostWebAPI.getCurrentHost(request);
// Map with all identifier inodes for a given uri.
String idInode = APILocator.getIdentifierAPI().find(host, uri).getInode();
// Checking the path is really live using the livecache
String cachedUri = LiveCache.getPathFromCache(uri, host);
// if we still have nothing.
if (!InodeUtils.isSet(idInode) || cachedUri == null) {
throw new ResourceNotFoundException(
String.format("Resource %s not found in Live mode!", uri));
}
response.setContentType(CHARSET);
request.setAttribute("idInode", String.valueOf(idInode));
Logger.debug(VelocityServlet.class, "VELOCITY HTML INODE=" + idInode);
/*
* JIRA http://jira.dotmarketing.net/browse/DOTCMS-4659
//Set long lived cookie regardless of who this is */
String _dotCMSID =
UtilMethods.getCookieValue(
request.getCookies(), com.dotmarketing.util.WebKeys.LONG_LIVED_DOTCMS_ID_COOKIE);
if (!UtilMethods.isSet(_dotCMSID)) {
// create unique generator engine
Cookie idCookie = CookieUtil.createCookie();
response.addCookie(idCookie);
}
com.liferay.portal.model.User user = null;
HttpSession session = request.getSession(false);
try {
if (session != null)
user =
(com.liferay.portal.model.User)
session.getAttribute(com.dotmarketing.util.WebKeys.CMS_USER);
} catch (Exception nsue) {
Logger.warn(this, "Exception trying to getUser: "******"Page Permissions for URI=" + uri);
HTMLPage page = null;
try {
// we get the page and check permissions below
page =
APILocator.getHTMLPageAPI()
.loadLivePageById(idInode, APILocator.getUserAPI().getSystemUser(), false);
} catch (Exception e) {
Logger.error(
HTMLPageWebAPI.class,
"unable to load live version of page: " + idInode + " because " + e.getMessage());
return;
}
// Check if the page is visible by a CMS Anonymous role
if (!permissionAPI.doesUserHavePermission(page, PERMISSION_READ, user, true)) {
// this page is protected. not anonymous access
/**
* ***************************************************************** If we need to redirect
* someone somewhere to login before seeing a page, we need to edit the /portal/401.jsp page
* to sendRedirect the user to the proper login page. We are not using the REDIRECT_TO_LOGIN
* variable in the config any longer.
* ****************************************************************
*/
if (!signedIn) {
// No need for the below LAST_PATH attribute on the front end
// http://jira.dotmarketing.net/browse/DOTCMS-2675
// request.getSession().setAttribute(WebKeys.LAST_PATH,
// new ObjectValuePair(uri, request.getParameterMap()));
request.getSession().setAttribute(com.dotmarketing.util.WebKeys.REDIRECT_AFTER_LOGIN, uri);
Logger.debug(
VelocityServlet.class,
"VELOCITY CHECKING PERMISSION: Page doesn't have anonymous access" + uri);
Logger.debug(VelocityServlet.class, "401 URI = " + uri);
Logger.debug(VelocityServlet.class, "Unauthorized URI = " + uri);
response.sendError(401, "The requested page/file is unauthorized");
return;
} else if (!permissionAPI
.getReadRoles(ident)
.contains(APILocator.getRoleAPI().loadLoggedinSiteRole())) {
// user is logged in need to check user permissions
Logger.debug(VelocityServlet.class, "VELOCITY CHECKING PERMISSION: User signed in");
// check user permissions on this asset
if (!permissionAPI.doesUserHavePermission(ident, PERMISSION_READ, user, true)) {
// the user doesn't have permissions to see this page
// go to unauthorized page
Logger.warn(
VelocityServlet.class,
"VELOCITY CHECKING PERMISSION: Page doesn't have any access for this user");
response.sendError(403, "The requested page/file is forbidden");
return;
}
}
}
Logger.debug(VelocityServlet.class, "Recording the ClickStream");
if (Config.getBooleanProperty("ENABLE_CLICKSTREAM_TRACKING", false)) {
if (user != null) {
UserProxy userProxy =
com.dotmarketing.business.APILocator.getUserProxyAPI()
.getUserProxy(user, APILocator.getUserAPI().getSystemUser(), false);
if (!userProxy.isNoclicktracking()) {
ClickstreamFactory.addRequest(
(HttpServletRequest) request, ((HttpServletResponse) response), host);
}
} else {
ClickstreamFactory.addRequest(
(HttpServletRequest) request, ((HttpServletResponse) response), host);
}
}
// Begin Page Caching
boolean buildCache = false;
String key = getPageCacheKey(request);
if (key != null) {
String cachedPage = CacheLocator.getBlockDirectiveCache().get(key, (int) page.getCacheTTL());
if (cachedPage == null
|| "refresh".equals(request.getParameter("dotcache"))
|| "refresh".equals(request.getAttribute("dotcache"))
|| "refresh".equals(request.getSession().getAttribute("dotcache"))) {
// build cached response
buildCache = true;
} else {
// have cached response and are not refreshing, send it
response.getWriter().write(cachedPage);
return;
}
}
Writer out =
(buildCache) ? new StringWriter(4096) : new VelocityFilterWriter(response.getWriter());
// get the context from the requst if possible
Context context = VelocityUtil.getWebContext(request, response);
request.setAttribute("velocityContext", context);
Logger.debug(VelocityServlet.class, "HTMLPage Identifier:" + idInode);
try {
VelocityUtil.getEngine()
.getTemplate("/live/" + idInode + "." + VELOCITY_HTMLPAGE_EXTENSION)
.merge(context, out);
} catch (ParseErrorException e) {
// out.append(e.getMessage());
}
context = null;
if (buildCache) {
String trimmedPage = out.toString().trim();
response.getWriter().write(trimmedPage);
response.getWriter().close();
synchronized (key) {
String x = CacheLocator.getBlockDirectiveCache().get(key, (int) page.getCacheTTL());
if (x != null) {
return;
}
CacheLocator.getBlockDirectiveCache()
.add(getPageCacheKey(request), trimmedPage, (int) page.getCacheTTL());
}
} else {
out.close();
}
}
/**
* Returns the inode.
*
* @return String
*/
public String getInode() {
if (InodeUtils.isSet(inode)) return inode;
return "";
}
private void createAccount(WebForm form, HttpServletRequest request) throws Exception {
User user =
APILocator.getUserAPI()
.loadByUserByEmail(form.getEmail(), APILocator.getUserAPI().getSystemUser(), false);
User defaultUser = APILocator.getUserAPI().getDefaultUser();
Date today = new Date();
if (user.isNew() || (!user.isNew() && user.getLastLoginDate() == null)) {
// ### CREATE USER ###
Company company = PublicCompanyFactory.getDefaultCompany();
user.setEmailAddress(form.getEmail().trim().toLowerCase());
user.setFirstName(form.getFirstName() == null ? "" : form.getFirstName());
user.setMiddleName(form.getMiddleName() == null ? "" : form.getMiddleName());
user.setLastName(form.getLastName() == null ? "" : form.getLastName());
user.setNickName("");
user.setCompanyId(company.getCompanyId());
user.setPasswordEncrypted(true);
user.setGreeting("Welcome, " + user.getFullName() + "!");
// Set defaults values
if (user.isNew()) {
// if it's a new user we set random password
String pass = PublicEncryptionFactory.getRandomPassword();
user.setPassword(PublicEncryptionFactory.digestString(pass));
user.setLanguageId(defaultUser.getLanguageId());
user.setTimeZoneId(defaultUser.getTimeZoneId());
user.setSkinId(defaultUser.getSkinId());
user.setDottedSkins(defaultUser.isDottedSkins());
user.setRoundedSkins(defaultUser.isRoundedSkins());
user.setResolution(defaultUser.getResolution());
user.setRefreshRate(defaultUser.getRefreshRate());
user.setLayoutIds("");
user.setActive(true);
user.setCreateDate(today);
}
APILocator.getUserAPI().save(user, APILocator.getUserAPI().getSystemUser(), false);
// ### END CREATE USER ###
// ### CREATE USER_PROXY ###
UserProxy userProxy =
com.dotmarketing.business.APILocator.getUserProxyAPI()
.getUserProxy(user.getUserId(), APILocator.getUserAPI().getSystemUser(), false);
userProxy.setPrefix("");
userProxy.setTitle(form.getTitle());
userProxy.setOrganization(form.getOrganization());
userProxy.setUserId(user.getUserId());
com.dotmarketing.business.APILocator.getUserProxyAPI()
.saveUserProxy(userProxy, APILocator.getUserAPI().getSystemUser(), false);
// ### END CRETE USER_PROXY ###
// saving user inode on web form
form.setUserInode(userProxy.getInode());
if (UtilMethods.isSet(form.getFormType())) {
HibernateUtil.saveOrUpdate(form);
}
///// WE CAN DO THIS! BUT WE NEED TO ADD CATEGORIES TO WEBFORM AND ALSO CHANGE THE PROCESSES
// THAT
//// CREATE THE EXCEL DOWNLOAD FROM WEB FORMS. I DIDN'T ADD IT SO I COMMENTED THIS CODE FOR
// NOW
// get the old categories, wipe them out
/*
List<Category> categories = InodeFactory.getParentsOfClass(userProxy, Category.class);
for (int i = 0; i < categories.size(); i++) {
categories.get(i).deleteChild(userProxy);
}
*/
// Save the new categories
/*String[] arr = form.getCategories();
if (arr != null) {
for (int i = 0; i < arr.length; i++) {
Category node = (Category) InodeFactory.getInode(arr[i], Category.class);
node.addChild(userProxy);
}
}*/
// ### CREATE ADDRESS ###
try {
List<Address> addresses = PublicAddressFactory.getAddressesByUserId(user.getUserId());
Address address =
(addresses.size() > 0 ? addresses.get(0) : PublicAddressFactory.getInstance());
address.setStreet1(form.getAddress1() == null ? "" : form.getAddress1());
address.setStreet2(form.getAddress2() == null ? "" : form.getAddress2());
address.setCity(form.getCity() == null ? "" : form.getCity());
address.setState(form.getState() == null ? "" : form.getState());
address.setZip(form.getZip() == null ? "" : form.getZip());
String phone = form.getPhone();
address.setPhone(phone == null ? "" : phone);
address.setUserId(user.getUserId());
address.setCompanyId(company.getCompanyId());
PublicAddressFactory.save(address);
} catch (Exception ex) {
Logger.error(this, ex.getMessage(), ex);
}
Role defaultRole =
com.dotmarketing.business.APILocator.getRoleAPI()
.loadRoleByKey(Config.getStringProperty("CMS_VIEWER_ROLE"));
String roleId = defaultRole.getId();
if (InodeUtils.isSet(roleId)) {
com.dotmarketing.business.APILocator.getRoleAPI().addRoleToUser(roleId, user);
}
}
// ### END CREATE ADDRESS ###
// ### BUILD THE USER COMMENT ###
addUserComments(user.getUserId(), form, request);
// ### END BUILD THE USER COMMENT ###
/* associate user with their clickstream request */
if (Config.getBooleanProperty("ENABLE_CLICKSTREAM_TRACKING", false)) {
ClickstreamFactory.setClickStreamUser(user.getUserId(), request);
}
}
