317 lines
12 KiB
Java
Executable File
317 lines
12 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2001-2004 Red Hat Inc. All Rights Reserved.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public License
|
|
* as published by the Free Software Foundation; either version 2.1 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
package com.arsdigita.cms;
|
|
|
|
import com.arsdigita.cms.dispatcher.ContentItemDispatcher;
|
|
import com.arsdigita.persistence.DataOperation;
|
|
import com.arsdigita.persistence.Session;
|
|
import com.arsdigita.persistence.SessionManager;
|
|
import com.arsdigita.mimetypes.MimeType;
|
|
|
|
|
|
/**
|
|
* A default implementation of {@link
|
|
* com.arsdigita.cms.TemplateManager template manager}.
|
|
*
|
|
* @author Karl Goldstein (karlg@arsdigita.com)
|
|
* @version $Id: DefaultTemplateManager.java 287 2005-02-22 00:29:02Z sskracic $
|
|
*/
|
|
public class DefaultTemplateManager implements TemplateManager {
|
|
|
|
private static final String SECTION_ID = "sectionID";
|
|
private static final String TYPE_ID = "typeID";
|
|
private static final String USE_CONTEXT = "useContext";
|
|
private static final String NEW_DEFAULT_ID = "newDefaultID";
|
|
private static final String MIME_TYPE_STRING = "mimeTypeString";
|
|
private static final String OP_SET_DEFAULT =
|
|
"com.arsdigita.cms.setDefaultTemplate";
|
|
private static final String OP_SET_DEFAULT_NO_MIME_TYPE =
|
|
"com.arsdigita.cms.setDefaultTemplateNullMimeType";
|
|
|
|
private static final DefaultTemplateManager m_instance =
|
|
new DefaultTemplateManager();
|
|
|
|
/**
|
|
* Construct a new template manager
|
|
*/
|
|
public DefaultTemplateManager() {}
|
|
|
|
/**
|
|
* Assign a template to the item in the given context. Overrides
|
|
* any previous template assignment.
|
|
*
|
|
* @param item the content item
|
|
* @param template the template to be assigned
|
|
* @param context the use context for the template, such as "public" or
|
|
* "abridged".
|
|
*/
|
|
public void addTemplate(ContentItem item, Template template,
|
|
String context, MimeType mimeType) {
|
|
ItemTemplateMapping m =
|
|
ItemTemplateMapping.getMapping(item, context, mimeType);
|
|
if(m == null) {
|
|
m = new ItemTemplateMapping();
|
|
m.setContentItem(item);
|
|
m.setUseContext(context);
|
|
}
|
|
m.setTemplate(template);
|
|
m.save();
|
|
}
|
|
|
|
public void addTemplate(ContentItem item, Template template, String context) {
|
|
addTemplate(item, template, context, template.getMimeType());
|
|
}
|
|
|
|
/**
|
|
* Unassign a template from the item in the given context. Do nothing if the
|
|
* template is not assigned to the item.
|
|
*
|
|
* @param item the content item
|
|
* @param template the template to be unassigned
|
|
* @param context the use context for the template, such as "public" or
|
|
* "abridged".
|
|
*/
|
|
public void removeTemplate(ContentItem item, Template template,
|
|
String context) {
|
|
ItemTemplateMapping m =
|
|
ItemTemplateMapping.getMapping(item, context, template);
|
|
if (m != null) {
|
|
m.delete();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a template to the given content type for the given content section.
|
|
* The template could be used to render any item of the content type
|
|
*
|
|
* @param section the content section to which the template will belong
|
|
* @param type the content type to which the template will belong
|
|
* @param template the template to be added
|
|
* @param context the use context for the template, such as "public" or
|
|
* "abridged".
|
|
* @param isDefault if true, new content items of the given type will
|
|
* use this template by default when they are rendered within the specified
|
|
* use context
|
|
*/
|
|
public void addTemplate (ContentSection section, ContentType type,
|
|
Template template, String context,
|
|
boolean isDefault) {
|
|
SectionTemplateMapping m = new SectionTemplateMapping();
|
|
if(template.getParent() == null) {
|
|
template.setParent(section.getTemplatesFolder());
|
|
template.setContentSection(section);
|
|
template.save();
|
|
}
|
|
m.setContentSection(section);
|
|
m.setContentType(type);
|
|
m.setUseContext(context);
|
|
m.setTemplate(template);
|
|
m.setDefault(isDefault ? Boolean.TRUE : Boolean.FALSE);
|
|
m.save();
|
|
}
|
|
|
|
/**
|
|
* Designate the given template as the default template within its use context.
|
|
* new content items of the given type will use this template by default when
|
|
* they are rendered within the use context. Note that {@link #addTemplate} must
|
|
* first be called to actually add the template to.
|
|
*
|
|
* @param section the content section where the template resides
|
|
* @param type the content type to which the template belongs
|
|
* @param template the template which will be made default
|
|
* @param useContext the use context in which the template will be made default
|
|
*/
|
|
public void setDefaultTemplate (ContentSection section, ContentType type,
|
|
Template template, String useContext) {
|
|
Session s = SessionManager.getSession();
|
|
DataOperation op = null;
|
|
if (template.getMimeType() != null) {
|
|
op = s.retrieveDataOperation(OP_SET_DEFAULT);
|
|
op.setParameter(MIME_TYPE_STRING,
|
|
template.getMimeType().getMimeType());
|
|
} else {
|
|
op = s.retrieveDataOperation(OP_SET_DEFAULT_NO_MIME_TYPE);
|
|
}
|
|
op.setParameter(SECTION_ID, section.getID());
|
|
op.setParameter(TYPE_ID, type.getID());
|
|
op.setParameter(USE_CONTEXT, useContext);
|
|
op.setParameter(NEW_DEFAULT_ID, template.getID());
|
|
op.execute();
|
|
|
|
//update the ContentItemDispatcher cache
|
|
ContentItemDispatcher.cachePut(section, type, template);
|
|
}
|
|
|
|
/**
|
|
* Add a template to the given content type for the given content section.
|
|
* The template could be used to render any item of the content type.
|
|
* If the given context for the section contains no templates,
|
|
* the new template will be made the default.
|
|
*
|
|
* @param section the content section to which the template will belong
|
|
* @param type the content type to which the template will belong
|
|
* @param template the template to be added
|
|
* @param context the use context for the template, such as "public" or
|
|
* "abridged".
|
|
*/
|
|
public void addTemplate(ContentSection section, ContentType type,
|
|
Template template, String context) {
|
|
|
|
TemplateCollection c = getTemplates(section, type, context);
|
|
boolean hasNext = c.next();
|
|
if(hasNext) c.close();
|
|
addTemplate(section, type, template, context, !hasNext);
|
|
}
|
|
|
|
/**
|
|
* Remove the specified template from the content type in the given
|
|
* context. Do nothing if no such template is associated.
|
|
*
|
|
* @param section the content section to which the template belongs
|
|
* @param type the content type to which the template belongs
|
|
* @param template the template to be removed
|
|
* @param context the use context for the template, such as "public" or
|
|
* "abridged".
|
|
*/
|
|
public void removeTemplate(ContentSection section, ContentType type,
|
|
Template template, String context) {
|
|
SectionTemplateMapping m =
|
|
SectionTemplateMapping.getMapping(section, type, template, context);
|
|
if(m!=null)
|
|
m.delete();
|
|
}
|
|
|
|
/**
|
|
* Retrieve a template for the item in the given use context.
|
|
*
|
|
* @param item the content item
|
|
* @param context the use context for the template, such as "public" or
|
|
* "abridged".
|
|
* @return the template assigned to the item in the given context,
|
|
* or null if no such template is assigned
|
|
*/
|
|
public Template getTemplate(ContentItem item, String context) {
|
|
ItemTemplateMapping m = ItemTemplateMapping.getMapping(item, context);
|
|
if(m == null) return null;
|
|
return m.getTemplate();
|
|
}
|
|
|
|
/**
|
|
* Retrieve all templates for the content item
|
|
*
|
|
* @param item the content item
|
|
* @return a {@link TemplateCollection} of all the templates assigned
|
|
* to the item
|
|
*/
|
|
public TemplateCollection getTemplates(ContentItem item) {
|
|
return ItemTemplateMapping.getTemplates(item);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a collection of all use contexts for the item,
|
|
* along with the templates assigned to each use context (if any).
|
|
* Unlike {@link #getTemplates(ContentItem)}, the collection returned
|
|
* by this method will include all use contexts for an item, even
|
|
* those use contexts to which no template is yet assigned.
|
|
*
|
|
* @param item the content item
|
|
* @return a {@link TemplateCollection} of all the templates assigned
|
|
* to the item
|
|
*/
|
|
public TemplateCollection getUseContexts(ContentItem item) {
|
|
return ItemTemplateMapping.getUseContexts(item);
|
|
}
|
|
|
|
/**
|
|
* Retrieve all use context/mime type combinations along with
|
|
* possibly null template for the item in that pair. This
|
|
* returns one row for each use context/mime type pair. So, you
|
|
* could get 4 rows if there is public/jsp, public/xsl,
|
|
* alternate/jsp, and alternate/xsl. This is because there can be
|
|
* one template per context/mime-type pair
|
|
*/
|
|
public ItemTemplateCollection getContextsWithTypes(ContentItem item) {
|
|
return ItemTemplateMapping.getContextsWithTypes(item);
|
|
}
|
|
|
|
/**
|
|
* Get the default template for the given section, type and
|
|
* use context
|
|
*
|
|
* @param section the content section to which the template belongs
|
|
* @param type the content type to which the template belongs
|
|
* @param context the use context for the template, such as "public" or
|
|
* "abridged".
|
|
* @return the default template for the given section, type and context,
|
|
* or null if no such template exists
|
|
*
|
|
*/
|
|
public Template getDefaultTemplate(ContentSection section,
|
|
ContentType type, String context) {
|
|
return SectionTemplateMapping.getDefaultTemplate(section, type, context);
|
|
}
|
|
|
|
/**
|
|
* Get the default template for the given section, type and
|
|
* use context
|
|
*
|
|
* @param section the content section to which the template belongs
|
|
* @param type the content type to which the template belongs
|
|
* @param context the use context for the template, such as "public" or
|
|
* "abridged".
|
|
* @return the default template for the given section, type and context,
|
|
* or null if no such template exists
|
|
*
|
|
*/
|
|
public Template getDefaultTemplate(ContentSection section,
|
|
ContentType type, String context,
|
|
MimeType mimeType) {
|
|
return SectionTemplateMapping.getDefaultTemplate
|
|
(section, type, context, mimeType);
|
|
}
|
|
|
|
/**
|
|
* Get all the templates within the given section and type
|
|
*
|
|
* @param section the content section
|
|
* @param type the content type
|
|
* @return a collection of templates for the given section, type and
|
|
* context; an empty collection if there are no such templates
|
|
*/
|
|
public TemplateCollection getTemplates(ContentSection section,
|
|
ContentType type) {
|
|
return SectionTemplateMapping.getTemplates(section, type);
|
|
}
|
|
|
|
/**
|
|
* Get all the templates within the given section, type and
|
|
* context
|
|
*
|
|
* @param section the content section
|
|
* @param type the content type
|
|
* @param context the use context
|
|
* @return a collection of templates for the given section, type and
|
|
* context; an empty collection if there are no such templates
|
|
*/
|
|
public TemplateCollection getTemplates(ContentSection section,
|
|
ContentType type, String context) {
|
|
return SectionTemplateMapping.getTemplates(section, type, context);
|
|
}
|
|
}
|