/*
* This program is free software; you can redistribute it and/or modify it under the
* terms of the GNU General Public License, version 2 as published by the Free Software
* Foundation.
*
* You should have received a copy of the GNU General Public License along with this
* program; if not, you can obtain a copy at http://www.gnu.org/licenses/gpl-2.0.html
* or from the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* This program 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 General Public License for more details.
*
*
* Copyright 2005-2008 Pentaho Corporation. All rights reserved.
*
* @created Oct 7, 2005
* @author James Dixon
*/
package org.pentaho.platform.repository.subscription;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.pentaho.commons.connection.IPentahoResultSet;
import org.pentaho.platform.api.engine.ICacheManager;
import org.pentaho.platform.api.engine.IPentahoSession;
import org.pentaho.platform.api.engine.ISubscriptionScheduler;
import org.pentaho.platform.api.engine.SubscriptionSchedulerException;
import org.pentaho.platform.api.repository.IContentItem;
import org.pentaho.platform.api.repository.IContentItemFile;
import org.pentaho.platform.api.repository.IContentLocation;
import org.pentaho.platform.api.repository.IContentRepository;
import org.pentaho.platform.api.repository.ISchedule;
import org.pentaho.platform.api.repository.ISubscribeContent;
import org.pentaho.platform.api.repository.ISubscription;
import org.pentaho.platform.api.repository.ISubscriptionRepository;
import org.pentaho.platform.api.repository.SubscriptionRepositoryCheckedException;
import org.pentaho.platform.api.repository.SubscriptionRepositoryException;
import org.pentaho.platform.engine.core.solution.ActionInfo;
import org.pentaho.platform.engine.core.system.PentahoSystem;
import org.pentaho.platform.repository.hibernate.HibernateUtil;
import org.pentaho.platform.repository.messages.Messages;
import org.pentaho.platform.util.UUIDUtil;
public class SubscriptionRepository implements ISubscriptionRepository {
private static final byte[] SyncLock = new byte[0];
private static final Log logger = LogFactory.getLog(SubscriptionRepository.class);
private static final ISubscriptionScheduler subscriptionScheduler = PentahoSystem.get(ISubscriptionScheduler.class, null);
public Log getLogger() {
return SubscriptionRepository.logger;
}
public SubscriptionRepository() {
super();
}
// TODO sbarkdull, this needs to be modified to support repeat count, repeat interval, start date and end date.
public Element importSchedules(final Document doc) {
Element resultElement = DocumentHelper.createElement("importSchedulesResults"); //$NON-NLS-1$
if (doc == null) {
Element ele = resultElement
.addElement("message").addText(Messages.getInstance().getString("PRO_SUBSCRIPTREP.DOCUMENT_IS_NULL")); //$NON-NLS-1$ //$NON-NLS-2$
ele.addAttribute("result", "ERROR"); //$NON-NLS-1$ //$NON-NLS-2$
return (resultElement);
}
List scheduleNodes = doc.selectNodes("//schedules/*"); //$NON-NLS-1$
if (scheduleNodes.size() == 0) {
Element ele = resultElement
.addElement("message").addText(Messages.getInstance().getString("PRO_SUBSCRIPTREP.NO_SCHEDULES_DEFINED")); //$NON-NLS-1$ //$NON-NLS-2$
ele.addAttribute("result", "WARNING"); //$NON-NLS-1$ //$NON-NLS-2$
return (resultElement);
}
synchronized (SubscriptionRepository.SyncLock) {
Node scheduleNode = null;
String schedName, schedDesc, schedRef, cronString, schedGroup;
ISchedule aSchedule;
// List schedList;
try {
SubscriptionRepository.logger.info(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.USER_IMPORT_PROCESSING_SCHEDULES", Integer.toString(scheduleNodes.size()))); //$NON-NLS-1$
for (int i = 0; i < scheduleNodes.size(); i++) {
scheduleNode = (Node) scheduleNodes.get(i);
schedRef = scheduleNode.selectSingleNode("@ref").getText(); //$NON-NLS-1$
schedName = scheduleNode.selectSingleNode("@name").getText(); //$NON-NLS-1$
schedDesc = scheduleNode.selectSingleNode("@description").getText(); //$NON-NLS-1$
schedGroup = scheduleNode.selectSingleNode("@group").getText(); //$NON-NLS-1$
cronString = scheduleNode.getText();
try {
aSchedule = getScheduleByScheduleReference(schedRef);
if (aSchedule != null) {
aSchedule.setCronString(cronString);
aSchedule.setDescription(schedDesc);
aSchedule.setGroup(schedGroup);
aSchedule.setTitle(schedName);
resultElement.addElement("modified").addText(schedRef); //$NON-NLS-1$
SubscriptionRepository.logger.info(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.MODIFIED_SUBSCRIPTION_SCHEDULE", schedRef)); //$NON-NLS-1$
} else {
aSchedule = addCronSchedule(schedName, schedRef, schedDesc, cronString, schedGroup, null, null );
resultElement.addElement("added").addText(schedRef); //$NON-NLS-1$
SubscriptionRepository.logger.info(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.ADDED_SUBSCRIPTION_SCHEDULE", schedRef)); //$NON-NLS-1$
}
SubscriptionRepository.subscriptionScheduler.getCronSummary(cronString); // Throws an exception if invalid
} catch (Exception e) {
resultElement
.addElement("message").addText(Messages.getInstance().getString("PRO_SUBSCRIPTREP.ERROR_OCCURRED_WITH_SCHEDULE", schedRef, e.getLocalizedMessage())); //$NON-NLS-1$ //$NON-NLS-2$
SubscriptionRepository.logger.warn(
Messages.getInstance().getString("PRO_SUBSCRIPTREP.EXCEPTION_WITH_SCHEDULE", schedRef), e); //$NON-NLS-1$
}
}
} catch (Exception e) {
Element ele = resultElement
.addElement("message").addText(Messages.getInstance().getString("PRO_SUBSCRIPTREP.ERROR_PROCESSING_IMPORTS") + e.getLocalizedMessage()); //$NON-NLS-1$ //$NON-NLS-2$
ele.addAttribute("result", "ERROR"); //$NON-NLS-1$ //$NON-NLS-2$
SubscriptionRepository.logger.error(Messages.getInstance().getString("PRO_SUBSCRIPTREP.EXCEPTION_PROCESSING_IMPORTS"), e); //$NON-NLS-1$
return (resultElement);
}
}
return (resultElement);
}
public Element importContent(final Document doc) {
Element resultElement = DocumentHelper.createElement("importContentResults"); //$NON-NLS-1$
if (doc == null) {
Element ele = resultElement
.addElement("message").addText(Messages.getInstance().getString("PRO_SUBSCRIPTREP.DOCUMENT_IS_NULL")); //$NON-NLS-1$ //$NON-NLS-2$
ele.addAttribute("result", "ERROR"); //$NON-NLS-1$//$NON-NLS-2$
return (resultElement);
}
List contentNodes = doc.selectNodes("//subscription-content/*"); //$NON-NLS-1$
if (contentNodes.size() == 0) {
Element ele = resultElement
.addElement("message").addText(Messages.getInstance().getString("PRO_SUBSCRIPTREP.NO_SCHEDULES_DEFINED")); //$NON-NLS-1$ //$NON-NLS-2$
ele.addAttribute("result", "WARNING"); //$NON-NLS-1$//$NON-NLS-2$
return (resultElement);
}
synchronized (SubscriptionRepository.SyncLock) {
Node contentNode = null;
Node tempNode = null;
String actionRef, contentType, allowAllSchedules;
ISubscribeContent subscribeContent = null;
List schedList = getSchedules();
Map scheduleMap = new HashMap();
Map groupMap = new HashMap();
for (int j = 0; j < schedList.size(); ++j) {
Schedule aSchedule = (Schedule) schedList.get(j);
scheduleMap.put(aSchedule.getScheduleReference(), aSchedule);
List groupList = (List) groupMap.get(aSchedule.getGroup());
if (groupList == null) {
groupList = new ArrayList();
groupMap.put(aSchedule.getGroup(), groupList);
}
groupList.add(aSchedule);
}
try {
SubscriptionRepository.logger.info(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.USER_PROCESSING_CONTENT_NODES", Integer.toString(contentNodes.size()))); //$NON-NLS-1$
for (int i = 0; i < contentNodes.size(); i++) {
contentNode = (Node) contentNodes.get(i);
actionRef = contentNode.selectSingleNode("@action").getText(); //$NON-NLS-1$
contentType = contentNode.selectSingleNode("@type").getText(); //$NON-NLS-1$
tempNode = contentNode.selectSingleNode("@allowAllSchedules"); //$NON-NLS-1$
if (tempNode != null) {
allowAllSchedules = tempNode.getText();
} else {
allowAllSchedules = "false"; //$NON-NLS-1$
}
try {
subscribeContent = getContentByActionReference(actionRef);
if (subscribeContent != null) {
subscribeContent.setType(contentType);
resultElement.addElement("modified").addText(actionRef); //$NON-NLS-1$
SubscriptionRepository.logger.info(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.MODIFIED_SUBSCRIPTION_CONTENT", actionRef)); //$NON-NLS-1$
} else {
subscribeContent = addContent(actionRef, contentType);
resultElement.addElement("added").addText(actionRef); //$NON-NLS-1$
SubscriptionRepository.logger.info(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.ADDED_SUBSCRIPTION_CONTENT", actionRef)); //$NON-NLS-1$
}
} catch (Exception e) {
resultElement
.addElement("message").addText(Messages.getInstance().getString("PRO_SUBSCRIPTREP.ERROR_WITH_CONTENT", actionRef, e.getLocalizedMessage())); //$NON-NLS-1$ //$NON-NLS-2$
SubscriptionRepository.logger.warn(
Messages.getInstance().getString("PRO_SUBSCRIPTREP.ERROR_WITH_CONTENT_LOG", actionRef), e); //$NON-NLS-1$
}
List contentSchedules = new ArrayList();
if ("true".equalsIgnoreCase(allowAllSchedules)) { //$NON-NLS-1$
contentSchedules.addAll(schedList);
} else {
List suppliedSchedules = contentNode.selectNodes("schedule"); //$NON-NLS-1$
if (suppliedSchedules != null) {
for (int j = 0; j < suppliedSchedules.size(); j++) {
tempNode = (Node) suppliedSchedules.get(j);
String schName = tempNode.getText();
if (schName != null) {
Object aSchedule = scheduleMap.get(schName);
if (aSchedule != null) {
contentSchedules.add(aSchedule);
}
}
}
}
List suppliedGroups = contentNode.selectNodes("group"); //$NON-NLS-1$
if (suppliedGroups != null) {
for (int j = 0; j < suppliedGroups.size(); j++) {
tempNode = (Node) suppliedGroups.get(j);
String grpName = tempNode.getText();
if (grpName != null) {
List groupList = (List) groupMap.get(grpName);
if (groupList != null) {
contentSchedules.addAll(groupList);
}
}
}
}
}
HibernateUtil.beginTransaction(); // Need to do this or the schedules don't get saved if the content item is new
subscribeContent.setSchedules(contentSchedules);
HibernateUtil.commitTransaction();
}
} catch (Exception e) {
Element ele = resultElement
.addElement("message").addText(Messages.getInstance().getString("PRO_SUBSCRIPTREP.ERROR_PROCESSING_IMPORTS") + e.getLocalizedMessage()); //$NON-NLS-1$ //$NON-NLS-2$
ele.addAttribute("result", "ERROR"); //$NON-NLS-1$ //$NON-NLS-2$
SubscriptionRepository.logger.error(Messages.getInstance().getString("PRO_SUBSCRIPTREP.EXCEPTION_PROCESSING_IMPORTS"), e); //$NON-NLS-1$
return (resultElement);
}
}
return (resultElement);
}
public boolean addSubscription(final ISubscription subscription) {
if ((subscription.getId() != null) && (subscription.getTitle() != null)) {
// commented by sbarkdull HibernateUtil.beginTransaction();
Session session = HibernateUtil.getSession();
session.save(subscription);
// subscriptionMap.put( subscription.getId(), subscription );
// commented by sbarkdull HibernateUtil.commitTransaction();
return true;
} else {
// TODO log an error
return false;
}
}
@SuppressWarnings("unchecked")
public List<ISubscription> getSubscriptionsForSchedule(final ISchedule schedule) {
if (schedule == null) {
return new ArrayList<ISubscription>();
}
Session session = HibernateUtil.getSession();
Query qry = session.getNamedQuery(
"org.pentaho.platform.repository.subscription.Schedule.findSubscriptionsBySchedule").setCacheable(true); //$NON-NLS-1$
qry.setEntity("schedule", schedule); //$NON-NLS-1$
return qry.list();
}
public List<ISubscription> getSubscriptionsForSchedule(final String scheduleId) {
return getSubscriptionsForSchedule(this.getScheduleByScheduleReference(scheduleId));
}
public IPentahoResultSet getSubscriptions(final String scheduleId, final IPentahoSession session,
final String solution, final String path, final String action, final String parameterNames[]) {
IPentahoResultSet results = new SubscriptionResultSet(scheduleId, session, parameterNames, solution, path, action);
return results;
}
public void addContent(final ISubscribeContent content) {
if (getContentByActionReference(content.getActionReference()) != null) {
throw new SubscriptionRepositoryException(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.ACTION_SEQUENCE_ALREADY_EXISTS", content.getActionReference())); //$NON-NLS-1$
}
// commented by sbarkdull HibernateUtil.beginTransaction();
Session session = HibernateUtil.getSession();
session.save(content);
// commented by sbarkdull HibernateUtil.commitTransaction();
clearSessionCaches();
}
public void deleteContent(final ISubscribeContent content) {
// commented by wseyler HibernateUtil.beginTransaction();
Session session = HibernateUtil.getSession();
session.delete(content);
// commented by wseyler HibernateUtil.commitTransaction();
clearSessionCaches();
}
private void clearSessionCaches() {
ICacheManager cm = PentahoSystem.getCacheManager( null ); // TODO sbarkdull, need to get real session in here
if (cm != null) {
//cm.killSessionCaches();
// TODO Need to find a way for kill all session caches
cm.killSessionCaches();
}
}
public ISubscribeContent addContent(final String actionRef, final String contentType) {
ISubscribeContent newContent = new SubscribeContent(UUIDUtil.getUUIDAsString(), actionRef, contentType);
addContent(newContent);
return (newContent);
}
/**
* For each action sequence path in the actionRefs array, if there is not already
* content in the subscription repository for that action sequence, add it. If the
* content is already in the subscription repository, do nothing.
* Return the a list of the content that is associated with each action sequence
* in the actionRefs parameter, regardless of if it was newly added, or already
* existed.
*/
public List<ISubscribeContent> addContent(final String actionRefs[]) throws SubscriptionRepositoryCheckedException {
List<ISubscribeContent> newContents = new ArrayList<ISubscribeContent>();
List<ISubscribeContent> allContent = getAllContent();
Map<String, ISubscribeContent> existingContentActionRef = new HashMap<String, ISubscribeContent>();
for ( ISubscribeContent content : allContent ) {
existingContentActionRef.put( content.getActionReference(), content );
}
for ( String actionRef : actionRefs ) {
if ( !existingContentActionRef.containsKey( actionRef ) ) {
ISubscribeContent newContent = addContent( actionRef, "" ); //$NON-NLS-1$
newContents.add( newContent );
} else {
newContents.add( existingContentActionRef.get( actionRef) );
}
}
return newContents;
}
/**
* If an action sequence currently in the subscription repository is not
* in the actionRefs array parameter, remove it from the subscription repository.
* If an action sequence in the actionRefs array is not already in the subscription
* repository, add it to the subscription repository. If the action sequence in the
* actionRefs array is already in the subscription repository, do nothing.
*/
public void setContent(final String actionRefs[]) throws Exception {
List<String> keepList = new ArrayList<String>(Arrays.asList(actionRefs)); // Strings
List<ISubscribeContent> allContent = getAllContent();
List<ISubscribeContent> deleteList = new ArrayList<ISubscribeContent>(); // SubscribeContent
for ( ISubscribeContent content : allContent ) {
if (keepList.contains(content.getActionReference())) {
keepList.remove(content.getActionReference());
} else {
deleteList.add(content);
}
}
for (int i = 0; i < keepList.size(); ++i) {
addContent((String) keepList.get(i), ""); //$NON-NLS-1$
}
for (int i = 0; i < deleteList.size(); ++i) {
deleteSubscribeContent((SubscribeContent) deleteList.get(i));
}
}
public ISubscribeContent editContent(final String contentId, final String actionRef, final String contentType) {
ISubscribeContent oldCont = getContentById(contentId);
if (oldCont != null) {
// Any null values keep previous values
if (actionRef != null) {
oldCont.setActionReference(actionRef);
}
if (contentType != null) {
oldCont.setType(contentType);
}
return (oldCont);
}
return (null);
}
public boolean deleteContentForSchedule(final String contentId, final String schedId) throws SubscriptionRepositoryCheckedException {
ISubscribeContent content = getContentById(contentId);
ISchedule sched = getSchedule(schedId);
return (deleteContentForSchedule(content, sched));
}
// maybe this should be called deleteScheduleFromContent?
public boolean deleteContentForSchedule(final ISubscribeContent content, final ISchedule sched) throws SubscriptionRepositoryCheckedException {
if (content == null) {
return (false);
}
return (content.removeSchedule(sched));
}
public boolean addContentForSchedule(final String contentId, final String schedId) throws SubscriptionRepositoryCheckedException {
ISubscribeContent content = getContentById(contentId);
ISchedule sched = getSchedule(schedId);
return (addContentForSchedule(content, sched));
}
public boolean addContentForSchedule(final ISubscribeContent content, final ISchedule sched) throws SubscriptionRepositoryCheckedException {
if (content == null) {
return (false);
}
content.addSchedule(sched);
return (true);
}
public void setSchedulesForContent(final String scheduleId[], final String contentId) throws Exception {
ISubscribeContent content = getContentById(contentId);
List schedList = new ArrayList();
for (String element : scheduleId) {
ISchedule sched = getSchedule(element);
if (sched != null) {
schedList.add(sched);
}
}
content.setSchedules(schedList);
}
public void addContentForSchedule(final String contentIds[], final String schedId) throws SubscriptionRepositoryCheckedException {
ISchedule sched = getSchedule(schedId);
for (String contentId : contentIds) {
ISubscribeContent content = getContentById(contentId);
addContentForSchedule(content, sched);
}
}
public void setContentForSchedule(final String contentIds[], final String schedId) throws Exception {
ISchedule sched = getSchedule(schedId);
List<ISubscribeContent> allContent = getAllContent();
for (String contentId : contentIds) {
ISubscribeContent content = getContentById(contentId);
addContentForSchedule(content, sched);
allContent.remove(content);
}
for (int i = 0; i < allContent.size(); ++i) {
SubscribeContent content = (SubscribeContent) allContent.get(i);
deleteContentForSchedule(content, sched);
}
}
public ISubscribeContent getContentById(final String theId) {
Session session = HibernateUtil.getSession();
try {
return (ISubscribeContent) session.get(SubscribeContent.class, theId);
} catch (HibernateException ex) {
throw new SubscriptionRepositoryException(Messages.getInstance().getErrorString(
"PRO_SUBSCRIPTREP.ERROR_0001_GETTING_SUBSCRIPTION", theId), ex); //$NON-NLS-1$
}
}
@SuppressWarnings("unchecked")
public List<ISubscribeContent> getAllContent() {
Session session = HibernateUtil.getSession();
Query qry = session
.getNamedQuery("org.pentaho.platform.repository.subscription.SubscribeContent.getAllContent").setCacheable(true); //$NON-NLS-1$
return qry.list();
}
public ISubscribeContent getContentByActionReference(final String actionReference) {
Session session = HibernateUtil.getSession();
Query qry = session
.getNamedQuery(
"org.pentaho.platform.repository.subscription.SubscribeContent.findSubscriptionContentByActionRef").setCacheable(true); //$NON-NLS-1$
qry.setString("searchTerm", actionReference); //$NON-NLS-1$
Object rtn = null;
try {
rtn = qry.uniqueResult();
} catch (Exception ignored) {
// sbarkdull, added the logging statement, original author believed the exception can be ignored.
logger.error( "Exception being ignored: ", ignored ); //$NON-NLS-1$
}
return (SubscribeContent) rtn;
}
@SuppressWarnings("unchecked")
public List<ISubscribeContent> getContentBySchedule(final ISchedule schedule) {
Session session = HibernateUtil.getSession();
Query qry = session.getNamedQuery(
"org.pentaho.platform.repository.subscription.SubscribeContent.findContentBySchedule").setCacheable(true); //$NON-NLS-1$
qry.setParameter("schedule", schedule); //$NON-NLS-1$
return (qry.list());
}
public Document getUserSubscriptions(final String user, final String contentId, final IPentahoSession session) {
Document document = DocumentHelper.createDocument();
Element subscriptionsNode = document.addElement("subscriptions"); //$NON-NLS-1$
addSubscriptionsToDocument(user, contentId, subscriptionsNode, null, session);
return document;
}
public void deleteUserSubscriptions(final String user) {
//
Session session = HibernateUtil.getSession();
Query qry = session
.getNamedQuery("org.pentaho.platform.repository.subscription.Subscription.findUserSubscriptionsForDeletion").setCacheable(true); //$NON-NLS-1$
qry.setString("searchUser", user); //$NON-NLS-1$
SubscriptionRepository.logger.warn(Messages.getInstance().getErrorString("PRO_SUBSCRIPTREP.USER_REMOVING_USER", user)); //$NON-NLS-1$
List subscriptions = qry.list();
Subscription subscriptToDelete = null;
for (int i = 0; i < subscriptions.size(); i++) {
subscriptToDelete = (Subscription) subscriptions.get(i);
HibernateUtil.makeTransient(subscriptToDelete);
}
HibernateUtil.flushSession();
}
@SuppressWarnings("unchecked")
public List<ISubscription> getUserSubscriptionsToContentReference(final String user, final String contentId) {
Session session = HibernateUtil.getSession();
ISubscribeContent content = this.getContentByActionReference(contentId);
if (content == null) {
return new ArrayList<ISubscription>();
}
Query qry = session
.getNamedQuery("org.pentaho.platform.repository.subscription.Subscription.findUserSubscriptions").setCacheable(true); //$NON-NLS-1$
qry.setString("searchUser", user); //$NON-NLS-1$
qry.setEntity("searchContent", content); //$NON-NLS-1$
return qry.list();
}
@SuppressWarnings("unchecked")
public List<ISubscription> getUserSubscriptions(final String user) {
Session session = HibernateUtil.getSession();
Query qry = session.getNamedQuery(
"org.pentaho.platform.repository.subscription.Subscription.findAllUserSubscriptions").setCacheable(true); //$NON-NLS-1$
qry.setString("searchUser", user); //$NON-NLS-1$
return qry.list();
}
@SuppressWarnings("unchecked")
public List<ISubscription> getAllSubscriptions() {
Session session = HibernateUtil.getSession();
Query qry = session
.getNamedQuery("org.pentaho.platform.repository.subscription.Subscription.getAllSubscriptions").setCacheable(true); //$NON-NLS-1$
return qry.list();
}
public void addSubscriptionsToDocument(final String user, final String contentId, final Element subscriptionsNode,
final String editId, final IPentahoSession session) {
List<ISubscription> userSubsToContent = getUserSubscriptionsToContentReference(user, contentId);
if (userSubsToContent == null) {
return;
}
for (int i = 0; i < userSubsToContent.size(); i++) {
ISubscription subscription = userSubsToContent.get(i);
addSubscriptionToDocument(subscription, subscriptionsNode, editId, session);
}
}
/**
* Returns true if the subscription name is unique for the user/contentId
*
* @param Name
* the schedule name to check for uniqueness
* @param user
* the user that owns the schedules
* @param contentId
* The action sequence separated by slashes
* @return
*/
public boolean checkUniqueSubscriptionName(final String name, final String user, final String contentId) {
if (name == null) {
return true;
}
List userSubsToContent = getUserSubscriptionsToContentReference(user, contentId);
if (userSubsToContent == null) {
return true;
}
for (int i = 0; i < userSubsToContent.size(); i++) {
Subscription subscription = (Subscription) userSubsToContent.get(i);
if (name.equals(subscription.getTitle())) {
return false;
}
}
return true;
}
public void addSchedulesToDocument(final String user, final String contentId, final Element schedulesNode,
final String editId) {
// now see if there are schedules
ISubscribeContent content = this.getContentByActionReference(contentId);
if (content == null) {
return;
}
List schedules = content.getSchedules();
Iterator scheduleIterator = schedules.iterator();
Schedule schedule;
while (scheduleIterator.hasNext()) {
schedule = (Schedule) scheduleIterator.next();
if (schedule != null) {
Element scheduleNode = schedulesNode.addElement("schedule"); //$NON-NLS-1$
scheduleNode.addElement("id").setText(schedule.getId()); //$NON-NLS-1$
scheduleNode.addElement("title").setText(schedule.getTitle()); //$NON-NLS-1$
scheduleNode.addElement("group").setText(schedule.getGroup()); //$NON-NLS-1$
scheduleNode.addElement("schedRef").setText(schedule.getScheduleReference()); //$NON-NLS-1$
// see if this schedule is currently selected
/*
* if( selectedSchedules.contains( schedule.getId() ) ) {
* scheduleNode.addAttribute( "selected", "true" );
* //$NON-NLS-1$//$NON-NLS-2$ }
*/
}
}
}
public void addSubscriptionToDocument(final ISubscription subscription, final Element subscriptionsNode,
final String editId, final IPentahoSession session) {
Element node = subscriptionsNode.addElement("subscription"); //$NON-NLS-1$
if (subscription.getTitle() == null) {
node.addElement("title").setText("Unknown"); //$NON-NLS-1$ //$NON-NLS-2$
} else {
node.addElement("title").setText(subscription.getTitle()); //$NON-NLS-1$
}
node.addElement("content-id").setText(subscription.getContent().getId()); //$NON-NLS-1$
node.addElement("id").setText(subscription.getId()); //$NON-NLS-1$
node.addElement("user").setText(subscription.getUser()); //$NON-NLS-1$
if ((editId != null) && editId.equals(subscription.getId())) {
node.addAttribute("edit", "true"); //$NON-NLS-1$//$NON-NLS-2$
}
int type = subscription.getType();
switch (type) {
case Subscription.TYPE_PERSONAL:
node.addElement("type").setText("personal");break; //$NON-NLS-1$ //$NON-NLS-2$
case Subscription.TYPE_GROUP:
node.addElement("type").setText("group");break; //$NON-NLS-1$ //$NON-NLS-2$
case Subscription.TYPE_ROLE:
node.addElement("type").setText("role");break; //$NON-NLS-1$ //$NON-NLS-2$
}
Map parameters = subscription.getParameters();
Iterator parameterIterator = parameters.keySet().iterator();
Element parametersNode = node.addElement("parameters"); //$NON-NLS-1$
while (parameterIterator.hasNext()) {
String name = (String) parameterIterator.next();
Object value = parameters.get(name);
Element parameterNode = parametersNode.addElement("parameter"); //$NON-NLS-1$
parameterNode.addElement("name").setText(name); //$NON-NLS-1$
parameterNode.addElement("value").setText(value.toString()); //$NON-NLS-1$
}
// now add the archives
IContentItem contentItem = getContentItem(subscription.getId(), session);
if (contentItem != null) {
List contentFiles = contentItem.getFileVersions();
if ((contentFiles != null) && (contentFiles.size() > 0)) {
Element archivesNode = node.addElement("archives"); //$NON-NLS-1$
Iterator contentFileIterator = contentFiles.iterator();
while (contentFileIterator.hasNext()) {
IContentItemFile file = (IContentItemFile) contentFileIterator.next();
Date date = file.getFileDateTime();
// TODO make this format driven from configuration
SimpleDateFormat format = new SimpleDateFormat("MM-dd-yyyy hh:mm aa"); //$NON-NLS-1$
String fileId = file.getId();
Element archiveNode = archivesNode.addElement("archive"); //$NON-NLS-1$
archiveNode.addElement("id").setText(fileId); //$NON-NLS-1$
archiveNode.addElement("date").setText(format.format(date)); //$NON-NLS-1$
archiveNode.addElement("size").setText(Long.toString(file.getFileSize())); //$NON-NLS-1$
archiveNode.addElement("mimetype").setText(contentItem.getMimeType()); //$NON-NLS-1$
}
}
}
}
public ISubscription getSubscriptionById(final String theId) {
Session session = HibernateUtil.getSession();
try {
return (ISubscription) session.get(Subscription.class, theId);
} catch (HibernateException ex) {
throw new SubscriptionRepositoryException(Messages.getInstance().getErrorString(
"PRO_SUBSCRIPTREP.ERROR_0001_GETTING_SUBSCRIPTION", theId), ex); //$NON-NLS-1$
}
}
public ISubscription getSubscription(final String subscriptionId, final IPentahoSession session) {
if (session == null) {
// TODO surface an error
return null;
}
if (!session.isAuthenticated()) {
// TODO surface an error
return null;
}
ISubscription subscription = getSubscriptionById(subscriptionId);
if (subscription == null) {
// TODO surface an error
return null;
}
if (subscription.getUser().equals(session.getName())) {
return subscription;
}
// TODO surface an error
return null;
}
public void init(final IPentahoSession session) {
HibernateUtil.beginTransaction();
}
public List<ISchedule> getSchedules() {
Session session = HibernateUtil.getSession();
Query qry = session
.getNamedQuery("org.pentaho.platform.repository.subscription.Schedule.getAllSchedules").setCacheable(true); //$NON-NLS-1$
return qry.list();
}
public List<ISchedule> syncSchedules() throws Exception {
return (SubscriptionRepository.subscriptionScheduler.syncSchedule(getSchedules()));
}
public List<ISchedule> getSchedulesByTitle(final String title) {
Session session = HibernateUtil.getSession();
Query qry = session
.getNamedQuery("org.pentaho.platform.repository.subscription.Schedule.findScheduleByTitle").setCacheable(true); //$NON-NLS-1$
qry.setString("searchTerm", title); //$NON-NLS-1$
return qry.list();
}
public ISchedule getScheduleByScheduleReference(final String scheduleReference) {
Session session = HibernateUtil.getSession();
Query qry = session
.getNamedQuery("org.pentaho.platform.repository.subscription.Schedule.findSchedulesByReference").setCacheable(true); //$NON-NLS-1$
qry.setString("searchTerm", scheduleReference); //$NON-NLS-1$
return (Schedule) qry.uniqueResult();
}
public boolean deleteSubscription(final String subscriptionId, final IPentahoSession session) {
if (session == null) {
return false;
}
if (!session.isAuthenticated()) {
return false;
}
ISubscription subscription = getSubscription(subscriptionId, session);
if (subscription == null) {
// TODO throw a warning here
return false;
}
if (subscription.getUser().equals(session.getName())) {
HibernateUtil.makeTransient(subscription);
return true;
} else {
// TODO throw an error here
return false;
}
}
public boolean deleteSubscription(final String subscriptionId) throws SubscriptionRepositoryCheckedException {
ISubscription subscription = getSubscriptionById(subscriptionId);
if (subscription == null) {
throw new SubscriptionRepositoryException(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.SUBSCRIPTION_ID_NOT_FOUND", subscriptionId)); //$NON-NLS-1$ }
}
HibernateUtil.makeTransient(subscription);
return true;
}
public boolean deleteSubscriptionForSchedule(final ISubscription subscription, final ISchedule sched) throws SubscriptionRepositoryCheckedException {
return subscription.deleteSchedule( sched );
}
public boolean deleteSchedule(final ISchedule sched) throws SubscriptionRepositoryCheckedException {
if (sched == null) {
return (false);
}
List<ISubscribeContent> contentList = getContentBySchedule(sched);
for ( ISubscribeContent content : contentList ) {
deleteContentForSchedule(content, sched);
}
HibernateUtil.makeTransient(sched);
HibernateUtil.flushSession();
try {
SubscriptionRepository.subscriptionScheduler.syncSchedule(sched.getScheduleReference(), null);
} catch (SubscriptionSchedulerException e) {
HibernateUtil.rollbackTransaction();
throw new SubscriptionRepositoryCheckedException( "Failed to delete schedule with name "
+ sched.getScheduleReference() + " and id " + sched.getId(), e );
}
return true;
}
public boolean deleteScheduleById(final String scheduleId) throws SubscriptionRepositoryCheckedException {
ISchedule sched = getSchedule(scheduleId);
if (sched == null) {
throw new SubscriptionRepositoryCheckedException(Messages.getInstance()
.getString("PRO_SUBSCRIPTREP.SCHEDULE_ID_NOT_FOUND", scheduleId)); //$NON-NLS-1$ }
}
return deleteSchedule(sched);
}
public boolean deleteSubscribeContent(final ISubscribeContent subContent) throws SubscriptionSchedulerException {
HibernateUtil.makeTransient(subContent);
HibernateUtil.flushSession();
clearSessionCaches();
return true;
}
public boolean deleteSubscribeContentById(final String subContentId) throws SubscriptionSchedulerException {
ISubscribeContent content = getContentById(subContentId);
return deleteSubscribeContent(content);
}
public void addSchedule(final ISchedule schedule) throws SubscriptionRepositoryCheckedException {
if (getScheduleByScheduleReference(schedule.getScheduleReference()) != null) {
throw new SubscriptionRepositoryCheckedException(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.SCHEDULE_REF_NOT_UNIQUE_ADD", schedule.getScheduleReference())); //$NON-NLS-1$
}
// commented by sbarkdull HibernateUtil.beginTransaction();
Session session = HibernateUtil.getSession();
session.save(schedule);
try {
SubscriptionRepository.subscriptionScheduler.syncSchedule(null, schedule);
// commented by sbarkdull HibernateUtil.commitTransaction();
} catch (SubscriptionSchedulerException e) {
// TODO sbarkdull, at this point the transaction needs to be aborted, but how!!!
HibernateUtil.rollbackTransaction();
throw new SubscriptionRepositoryCheckedException( "", e ); // TODO sbarkdull, error msg? //$NON-NLS-1$
}
}
public ISchedule addCronSchedule(final String title, final String scheduleRef, final String description,
final String cronString, final String group, Date startDate, Date endDate ) throws SubscriptionRepositoryCheckedException {
Schedule newSched = new Schedule(UUIDUtil.getUUIDAsString(), title, scheduleRef, description, cronString, group, startDate, endDate );
addSchedule(newSched);
return (newSched);
}
public ISchedule addRepeatSchedule(String title, String scheduleRef, String description, Integer repeatCount, Integer repeatInterval, String group,
Date startDate, Date endDate )
throws SubscriptionRepositoryCheckedException {
Schedule newSched = new Schedule(UUIDUtil.getUUIDAsString(), title, scheduleRef, description, repeatCount, repeatInterval, group, startDate, endDate );
addSchedule(newSched);
return newSched;
}
public ISchedule editCronSchedule(final String id, final String title, final String scheduleRef,
final String description, final String cronString, final String group, Date startDate, Date endDate ) throws SubscriptionRepositoryCheckedException {
ISchedule oldSched = getSchedule(id);
if (oldSched != null) {
String oldScheduleReference = oldSched.getScheduleReference();
// Any null values keep previous values
if (scheduleRef != null) {
if ((!oldScheduleReference.equals(scheduleRef)) && (getScheduleByScheduleReference(scheduleRef) != null)) {
throw new SubscriptionRepositoryException(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.SCHEDULE_REF_NOT_UNIQUE_EDIT", scheduleRef)); //$NON-NLS-1$
}
oldSched.setScheduleReference(scheduleRef);
}
if (title != null) {
oldSched.setTitle(title);
}
if (description != null) {
oldSched.setDescription(description);
}
if (cronString != null) {
oldSched.setCronString(cronString);
}
if (group != null) {
oldSched.setGroup(group);
}
oldSched.setStartDate( startDate );
oldSched.setEndDate( endDate );
try {
SubscriptionRepository.subscriptionScheduler.syncSchedule(oldScheduleReference, oldSched);
} catch (SubscriptionSchedulerException ex) {
throw new SubscriptionRepositoryException(Messages.getInstance().getString("PRO_SUBSCRIPTREP.CANNOT_EDIT_SCHEDULE", id), ex); //$NON-NLS-1$
}
return (oldSched);
}
return (null);
}
public ISchedule editRepeatSchedule(final String id, final String title, final String scheduleRef,
final String description, final Integer repeatCount, final Integer repeatInterval, final String group, Date startDate, Date endDate ) throws SubscriptionRepositoryCheckedException {
ISchedule oldSched = getSchedule(id);
if (oldSched != null) {
String oldScheduleReference = oldSched.getScheduleReference();
// Any null values keep previous values
if (scheduleRef != null) {
if ((!oldScheduleReference.equals(scheduleRef)) && (getScheduleByScheduleReference(scheduleRef) != null)) {
throw new SubscriptionRepositoryException(Messages.getInstance().getString(
"PRO_SUBSCRIPTREP.SCHEDULE_REF_NOT_UNIQUE_EDIT", scheduleRef)); //$NON-NLS-1$
}
oldSched.setScheduleReference(scheduleRef);
}
if (title != null) {
oldSched.setTitle(title);
}
if (description != null) {
oldSched.setDescription(description);
}
oldSched.setRepeatCount( repeatCount);
if (repeatInterval != null) {
oldSched.setRepeatInterval( repeatInterval);
}
if (group != null) {
oldSched.setGroup(group);
}
oldSched.setStartDate( startDate );
oldSched.setEndDate( endDate );
try {
SubscriptionRepository.subscriptionScheduler.syncSchedule(oldScheduleReference, oldSched);
} catch (SubscriptionSchedulerException ex) {
throw new SubscriptionRepositoryException(Messages.getInstance().getString("PRO_SUBSCRIPTREP.CANNOT_EDIT_SCHEDULE", id), ex); //$NON-NLS-1$
}
return (oldSched);
}
return (null);
}
public ISchedule getSchedule(final String scheduleId) {
// return (Schedule) scheduleMap.get( scheduleId );
Session session = HibernateUtil.getSession();
try {
return (Schedule) session.get(Schedule.class, scheduleId);
} catch (HibernateException ex) {
throw new SubscriptionRepositoryException(Messages.getInstance().getErrorString(
"PRO_SUBSCRIPTREP.ERROR_0002_GETTING_SCHEDULE", scheduleId), ex); //$NON-NLS-1$
}
}
public List getSubscriptionArchives(final String subscriptionName, final IPentahoSession session) {
IContentItem contentItem = getContentItem(subscriptionName, session);
if (contentItem == null) {
// we have no archived versions
return null;
}
return contentItem.getFileVersions();
}
public IContentItem getContentItem(final String subscriptionName, final IPentahoSession session) {
ISubscriptionRepository subscriptionRepository = PentahoSystem.get(ISubscriptionRepository.class, session);
ISubscription subscription = subscriptionRepository.getSubscription(subscriptionName, session);
if (subscription == null) {
// TODO surface an error
return null;
}
ISubscribeContent content = subscription.getContent();
Map subscriptionParameters = subscription.getParameters();
ActionInfo contentInfo = ActionInfo.parseActionString(content.getActionReference());
// String solutionName = contentInfo[0];
// String actionPath = contentInfo[1];
String actionName = (String) subscriptionParameters.get("action"); //$NON-NLS-1$
if (actionName == null) {
actionName = contentInfo.getActionName();
}
IContentItem contentItem = getContentItem(actionName, subscriptionName, null, null, session, contentInfo
.getSolutionName(), contentInfo.getPath(), false);
if (contentItem == null) {
return null;
}
return contentItem;
}
public IContentItem getContentItem(final String contentName, final String subscriptionName, final String mimeType,
final String extension, final IPentahoSession session, final String solutionName, final String solutionPath,
final boolean allowCreate) {
// get an output stream to hand to the caller
IContentRepository contentRepository = PentahoSystem.get(IContentRepository.class, session);
if (contentRepository == null) {
// error(
// Messages.getInstance().getErrorString("RuntimeContext.ERROR_0024_NO_CONTENT_REPOSITORY")
// ); //$NON-NLS-1$
return null;
}
String contentPath = SubscriptionHelper.getSubscriptionOutputLocation(solutionName, solutionPath, contentName);
// Find the location if it's already there.
IContentLocation contentLocation = null;
try {
contentLocation = contentRepository.getContentLocationByPath(contentPath);
} catch (Exception ex) {
// ignored
}
if ((contentLocation == null) && allowCreate) {
contentLocation = contentRepository.newContentLocation(contentPath, subscriptionName, subscriptionName,
solutionName, true);
}
if (contentLocation == null) {
// error(
// Messages.getInstance().getErrorString("RuntimeContext.ERROR_0025_INVALID_CONTENT_LOCATION")
// ); //$NON-NLS-1$
return null;
}
// Get the content item from the location - if it's there.
IContentItem contentItem = null;
try {
contentItem = contentLocation.getContentItemByName(subscriptionName);
} catch (Exception ex) {
// Ignored
}
if ((contentItem == null) && allowCreate) {
contentItem = contentLocation.newContentItem(subscriptionName, contentName, extension, mimeType, null,
IContentItem.WRITEMODE_KEEPVERSIONS);
}
return contentItem;
}
}