jobdata.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#include <sal/config.h>
 
#include <string_view>
 
#include <jobs/configaccess.hxx>
#include <jobs/jobdata.hxx>
#include <classes/converter.hxx>
 
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/beans/XMultiHierarchicalPropertySet.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
 
#include <tools/wldcrd.hxx>
#include <unotools/configpaths.hxx>
#include <utility>
#include <vcl/svapp.hxx>
 
namespace framework{
 
JobData::JobData( css::uno::Reference< css::uno::XComponentContext > xContext )
    : m_xContext    (std::move(xContext                    ))
{
    // share code for member initialization with defaults!
    impl_reset();
}
 
JobData::JobData( const JobData& rCopy )
{
    // use the copy operator to share the same code
    *this = rCopy;
}
 
JobData& JobData::operator=( const JobData& rCopy )
{
    // Please don't copy the uno service manager reference.
    // That can change the uno context, which isn't a good idea!
    m_eMode                = rCopy.m_eMode;
    m_eEnvironment         = rCopy.m_eEnvironment;
    m_sAlias               = rCopy.m_sAlias;
    m_sService             = rCopy.m_sService;
    m_sContext             = rCopy.m_sContext;
    m_sEvent               = rCopy.m_sEvent;
    m_lArguments           = rCopy.m_lArguments;
    return *this;
}
 
JobData::~JobData()
{
    impl_reset();
}
 
void JobData::setAlias( const OUString& sAlias )
{
    // delete all old information! Otherwise we mix it with the new one ...
    impl_reset();
 
    // take over the new information
    m_sAlias   = sAlias;
    m_eMode    = E_ALIAS;
 
    // try to open the configuration set of this job directly and get a property access to it
    // We open it readonly here
    ConfigAccess aConfig(
        m_xContext,
        ("/org.openoffice.Office.Jobs/Jobs/"
         + utl::wrapConfigurationElementName(m_sAlias)));
    aConfig.open(ConfigAccess::E_READONLY);
    if (aConfig.getMode()==ConfigAccess::E_CLOSED)
    {
        impl_reset();
        return;
    }
 
    css::uno::Reference< css::beans::XPropertySet > xJobProperties(aConfig.cfg(), css::uno::UNO_QUERY);
    if (xJobProperties.is())
    {
        css::uno::Any aValue;
 
        // read uno implementation name
        aValue   = xJobProperties->getPropertyValue("Service");
        aValue >>= m_sService;
 
        // read module context list
        aValue   = xJobProperties->getPropertyValue("Context");
        aValue >>= m_sContext;
 
        // read whole argument list
        aValue = xJobProperties->getPropertyValue("Arguments");
        css::uno::Reference< css::container::XNameAccess > xArgumentList;
        if (
            (aValue >>= xArgumentList)  &&
            (xArgumentList.is()      )
           )
        {
            css::uno::Sequence< OUString > lArgumentNames = xArgumentList->getElementNames();
            sal_Int32                             nCount         = lArgumentNames.getLength();
            m_lArguments.resize(nCount);
            for (sal_Int32 i=0; i<nCount; ++i)
            {
                m_lArguments[i].Name  = lArgumentNames[i];
                m_lArguments[i].Value = xArgumentList->getByName(m_lArguments[i].Name);
            }
        }
    }
 
    aConfig.close();
}
 
void JobData::setService( const OUString& sService )
{
    // delete all old information! Otherwise we mix it with the new one ...
    impl_reset();
    // take over the new information
    m_sService = sService;
    m_eMode    = E_SERVICE;
}
 
void JobData::setEvent( const OUString& sEvent ,
                        const OUString& sAlias )
{
    // share code to read all job properties!
    setAlias(sAlias);
 
    // take over the new information - which differ against set one of method setAlias()!
    m_sEvent = sEvent;
    m_eMode  = E_EVENT;
}
 
void JobData::setJobConfig( std::vector< css::beans::NamedValue >&& lArguments )
{
    // update member
    m_lArguments = std::move(lArguments);
 
    // update the configuration ... if possible!
    if (m_eMode!=E_ALIAS)
        return;
 
    // It doesn't matter if this config object was already opened before.
    // It doesn nothing here then ... or it change the mode automatically, if
    // it was opened using another one before.
    ConfigAccess aConfig(
        m_xContext,
        ("/org.openoffice.Office.Jobs/Jobs/"
         + utl::wrapConfigurationElementName(m_sAlias)));
    aConfig.open(ConfigAccess::E_READWRITE);
    if (aConfig.getMode()==ConfigAccess::E_CLOSED)
        return;
 
    css::uno::Reference< css::beans::XMultiHierarchicalPropertySet > xArgumentList(aConfig.cfg(), css::uno::UNO_QUERY);
    if (xArgumentList.is())
    {
        sal_Int32                             nCount = m_lArguments.size();
        css::uno::Sequence< OUString > lNames (nCount);
        auto lNamesRange = asNonConstRange(lNames);
        css::uno::Sequence< css::uno::Any >   lValues(nCount);
        auto lValuesRange = asNonConstRange(lValues);
 
        for (sal_Int32 i=0; i<nCount; ++i)
        {
            lNamesRange [i] = m_lArguments[i].Name;
            lValuesRange[i] = m_lArguments[i].Value;
        }
 
        xArgumentList->setHierarchicalPropertyValues(lNames, lValues);
    }
    aConfig.close();
}
 
void JobData::setEnvironment( EEnvironment eEnvironment )
{
    m_eEnvironment = eEnvironment;
}
 
JobData::EMode JobData::getMode() const
{
    return m_eMode;
}
 
JobData::EEnvironment JobData::getEnvironment() const
{
    return m_eEnvironment;
}
 
OUString JobData::getEnvironmentDescriptor() const
{
    OUString sDescriptor;
    switch(m_eEnvironment)
    {
        case E_EXECUTION :
            sDescriptor = "EXECUTOR";
            break;
 
        case E_DISPATCH :
            sDescriptor = "DISPATCH";
            break;
 
        case E_DOCUMENTEVENT :
            sDescriptor = "DOCUMENTEVENT";
            break;
        default:
            break;
    }
    return sDescriptor;
}
 
OUString JobData::getService() const
{
    return m_sService;
}
 
OUString JobData::getEvent() const
{
    return m_sEvent;
}
 
std::vector< css::beans::NamedValue > JobData::getJobConfig() const
{
    return m_lArguments;
}
 
css::uno::Sequence< css::beans::NamedValue > JobData::getConfig() const
{
    css::uno::Sequence< css::beans::NamedValue > lConfig;
    if (m_eMode==E_ALIAS)
    {
        lConfig = { { "Alias", css::uno::Any(m_sAlias) },
                    { "Service", css::uno::Any(m_sService) },
                    { "Context", css::uno::Any(m_sContext) } };
    }
    return lConfig;
}
 
bool JobData::hasConfig() const
{
    return (m_eMode==E_ALIAS || m_eMode==E_EVENT);
}
 
void JobData::disableJob()
{
    // No configuration - not used from EXECUTOR and not triggered from an event => no chance!
    if (m_eMode!=E_EVENT)
        return;
 
    // update the configuration
    // It doesn't matter if this config object was already opened before.
    // It doesn nothing here then ... or it change the mode automatically, if
    // it was opened using another one before.
    ConfigAccess aConfig(
        m_xContext,
        ("/org.openoffice.Office.Jobs/Events/"
         + utl::wrapConfigurationElementName(m_sEvent) + "/JobList/"
         + utl::wrapConfigurationElementName(m_sAlias)));
    aConfig.open(ConfigAccess::E_READWRITE);
    if (aConfig.getMode()==ConfigAccess::E_CLOSED)
        return;
 
    css::uno::Reference< css::beans::XPropertySet > xPropSet(aConfig.cfg(), css::uno::UNO_QUERY);
    if (xPropSet.is())
    {
        // Convert and write the user timestamp to the configuration.
        css::uno::Any aValue;
        aValue <<= Converter::convert_DateTime2ISO8601(DateTime( DateTime::SYSTEM));
        xPropSet->setPropertyValue("UserTime", aValue);
    }
 
    aConfig.close();
}
 
static bool isEnabled( std::u16string_view sAdminTime ,
                    std::u16string_view sUserTime  )
{
    /*Attention!
        To prevent interpreting of TriGraphs inside next const string value,
        we have to encode all '?' signs. Otherwise e.g. "??-" will be translated
        to "~" ...
     */
    WildCard aISOPattern(u"\?\?\?\?-\?\?-\?\?*");
 
    bool bValidAdmin = aISOPattern.Matches(sAdminTime);
    bool bValidUser  = aISOPattern.Matches(sUserTime );
 
    // We check for "isEnabled()" here only.
    // Note further: ISO8601 formatted strings can be compared as strings directly!
    //               FIXME: this is not true! "T1215" is the same time as "T12:15" or "T121500"
    return (
            (!bValidAdmin && !bValidUser                         ) ||
            ( bValidAdmin &&  bValidUser && sAdminTime>=sUserTime)
           );
}
 
void JobData::appendEnabledJobsForEvent( const css::uno::Reference< css::uno::XComponentContext >&              rxContext,
                                         const OUString&                                                 sEvent ,
                                               ::std::vector< JobData::TJob2DocEventBinding >& lJobs  )
{
    std::vector< OUString > lAdditionalJobs = JobData::getEnabledJobsForEvent(rxContext, sEvent);
    sal_Int32                c               = lAdditionalJobs.size();
    sal_Int32                i               = 0;
 
    for (i=0; i<c; ++i)
    {
        JobData::TJob2DocEventBinding aBinding(lAdditionalJobs[i], sEvent);
        lJobs.push_back(aBinding);
    }
}
 
bool JobData::hasCorrectContext(std::u16string_view rModuleIdent) const
{
    sal_Int32 nContextLen  = m_sContext.getLength();
    sal_Int32 nModuleIdLen = rModuleIdent.size();
 
    if ( nContextLen == 0 )
        return true;
 
    if ( nModuleIdLen > 0 )
    {
        sal_Int32 nIndex = m_sContext.indexOf( rModuleIdent );
        if ( nIndex >= 0 && ( nIndex+nModuleIdLen <= nContextLen ))
        {
            std::u16string_view sContextModule = m_sContext.subView( nIndex, nModuleIdLen );
            return sContextModule == rModuleIdent;
        }
    }
 
    return false;
}
 
std::vector< OUString > JobData::getEnabledJobsForEvent( const css::uno::Reference< css::uno::XComponentContext >& rxContext,
                                                                       std::u16string_view                                sEvent )
{
    // create a config access to "/org.openoffice.Office.Jobs/Events"
    ConfigAccess aConfig(rxContext, "/org.openoffice.Office.Jobs/Events");
    aConfig.open(ConfigAccess::E_READONLY);
    if (aConfig.getMode()==ConfigAccess::E_CLOSED)
        return std::vector< OUString >();
 
    css::uno::Reference< css::container::XHierarchicalNameAccess > xEventRegistry(aConfig.cfg(), css::uno::UNO_QUERY);
    if (!xEventRegistry.is())
        return std::vector< OUString >();
 
    // check if the given event exist inside list of registered ones
    OUString sPath(OUString::Concat(sEvent) + "/JobList");
    if (!xEventRegistry->hasByHierarchicalName(sPath))
        return std::vector< OUString >();
 
    // step to the job list, which is a child of the event node inside cfg
    // e.g. "/org.openoffice.Office.Jobs/Events/<event name>/JobList"
    css::uno::Any aJobList = xEventRegistry->getByHierarchicalName(sPath);
    css::uno::Reference< css::container::XNameAccess > xJobList;
    if (!(aJobList >>= xJobList) || !xJobList.is())
        return std::vector< OUString >();
 
    // get all alias names of jobs, which are part of this job list
    // But Some of them can be disabled by its timestamp values.
    // We create an additional job name list with the same size, then the original list...
    // step over all job entries... check her timestamps... and put only job names to the
    // destination list, which represent an enabled job.
    const css::uno::Sequence< OUString > lAllJobs = xJobList->getElementNames();
    sal_Int32 c = lAllJobs.getLength();
 
    std::vector< OUString > lEnabledJobs(c);
    sal_Int32 d = 0;
 
    for (OUString const & jobName : lAllJobs)
    {
        css::uno::Reference< css::beans::XPropertySet > xJob;
        if (
            !(xJobList->getByName(jobName) >>= xJob) ||
            !(xJob.is()     )
           )
        {
           continue;
        }
 
        OUString sAdminTime;
        xJob->getPropertyValue("AdminTime") >>= sAdminTime;
 
        OUString sUserTime;
        xJob->getPropertyValue("UserTime") >>= sUserTime;
 
        if (!isEnabled(sAdminTime, sUserTime))
            continue;
 
        lEnabledJobs[d] = jobName;
        ++d;
    }
    lEnabledJobs.resize(d);
 
    aConfig.close();
 
    return lEnabledJobs;
}
 
void JobData::impl_reset()
{
    m_eMode        = E_UNKNOWN_MODE;
    m_eEnvironment = E_UNKNOWN_ENVIRONMENT;
    m_sAlias.clear();
    m_sService.clear();
    m_sContext.clear();
    m_sEvent.clear();
    m_lArguments.clear();
}
 
} // namespace framework
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */