desktop/source/deployment/manager/dp_commandenvironments.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <com/sun/star/deployment/VersionException.hpp>
  22 #include <com/sun/star/deployment/LicenseException.hpp>
  23 #include <com/sun/star/deployment/InstallException.hpp>
  24 #include <com/sun/star/deployment/DependencyException.hpp>
  25 #include <com/sun/star/deployment/PlatformException.hpp>
  26 #include <com/sun/star/task/XInteractionApprove.hpp>
  27 #include <utility>
  28 #include "dp_commandenvironments.hxx"
  29 #include <osl/diagnose.h>
  30
  31 namespace deployment = css::deployment;
  32 namespace task = css::task;
  33 namespace ucb = css::ucb;
  34 namespace uno = css::uno;
  35
  36 using css::uno::Reference;
  37
  38 namespace dp_manager {
  39
  40 BaseCommandEnv::BaseCommandEnv()
  41 {
  42 }
  43
  44 BaseCommandEnv::BaseCommandEnv(
  45     Reference< task::XInteractionHandler> const & handler)
  46     : m_forwardHandler(handler)
  47 {
  48 }
  49
  50 BaseCommandEnv::~BaseCommandEnv()
  51 {
  52 }
  53 // XCommandEnvironment
  54
  55 Reference<task::XInteractionHandler> BaseCommandEnv::getInteractionHandler()
  56 {
  57     return this;
  58 }
  59
  60
  61 Reference<ucb::XProgressHandler> BaseCommandEnv::getProgressHandler()
  62 {
  63     return this;
  64 }
  65
  66 void BaseCommandEnv::handle(
  67     Reference< task::XInteractionRequest> const & /*xRequest*/ )
  68 {
  69 }
  70
  71 void BaseCommandEnv::handle_(bool approve,
  72                              Reference< task::XInteractionRequest> const & xRequest )
  73 {
  74     if (!approve)
  75     {
  76         //not handled so far -> forwarding
  77         if (m_forwardHandler.is())
  78             m_forwardHandler->handle(xRequest);
  79         else
  80             return; //cannot handle
  81     }
  82     else
  83     {
  84         // select:
  85         for (auto& xContinuation : xRequest->getContinuations())
  86         {
  87             Reference<task::XInteractionApprove> xInteractionApprove(xContinuation, uno::UNO_QUERY);
  88             if (xInteractionApprove.is())
  89             {
  90                 xInteractionApprove->select();
  91                 // don't query again for ongoing continuations:
  92                 break;
  93             }
  94         }
  95     }
  96
  97 }
  98
  99 // XProgressHandler
 100 void BaseCommandEnv::push( uno::Any const & /*Status*/ )
 101 {
 102 }
 103
 104 void BaseCommandEnv::update( uno::Any const & /*Status */)
 105 {
 106 }
 107
 108 void BaseCommandEnv::pop()
 109 {
 110 }
 111
 112
 113 TmpRepositoryCommandEnv::TmpRepositoryCommandEnv()
 114 {
 115 }
 116
 117 TmpRepositoryCommandEnv::TmpRepositoryCommandEnv(
 118     css::uno::Reference< css::task::XInteractionHandler> const & handler):
 119     BaseCommandEnv(handler)
 120 {
 121 }
 122 // XInteractionHandler
 123 void TmpRepositoryCommandEnv::handle(
 124     Reference< task::XInteractionRequest> const & xRequest )
 125 {
 126     uno::Any request( xRequest->getRequest() );
 127     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 128
 129     deployment::VersionException verExc;
 130     deployment::LicenseException licExc;
 131     deployment::InstallException instExc;
 132
 133     bool approve = false;
 134
 135     if ((request >>= verExc)
 136         || (request >>= licExc)
 137         || (request >>= instExc))
 138     {
 139         approve = true;
 140     }
 141
 142     handle_(approve, xRequest);
 143 }
 144
 145
 146 LicenseCommandEnv::LicenseCommandEnv(
 147     css::uno::Reference< css::task::XInteractionHandler> const & handler,
 148     bool bSuppressLicense,
 149     OUString repository):
 150     BaseCommandEnv(handler), m_repository(std::move(repository)),
 151     m_bSuppressLicense(bSuppressLicense)
 152 {
 153 }
 154 // XInteractionHandler
 155 void LicenseCommandEnv::handle(
 156     Reference< task::XInteractionRequest> const & xRequest )
 157 {
 158     uno::Any request( xRequest->getRequest() );
 159     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 160
 161     deployment::LicenseException licExc;
 162
 163     bool approve = false;
 164
 165     if (request >>= licExc)
 166     {
 167         if (m_bSuppressLicense
 168             || m_repository == "bundled"
 169             || licExc.AcceptBy == "admin")
 170         {
 171             //always approve in bundled case, because we do not support
 172             //showing licenses anyway.
 173             //The "admin" already accepted the license when installing the
 174             // shared extension
 175             approve = true;
 176         }
 177     }
 178
 179     handle_(approve, xRequest);
 180 }
 181
 182
 183 NoLicenseCommandEnv::NoLicenseCommandEnv(
 184     css::uno::Reference< css::task::XInteractionHandler> const & handler):
 185     BaseCommandEnv(handler)
 186 {
 187 }
 188 // XInteractionHandler
 189 void NoLicenseCommandEnv::handle(
 190     Reference< task::XInteractionRequest> const & xRequest )
 191 {
 192     uno::Any request( xRequest->getRequest() );
 193     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 194
 195     deployment::LicenseException licExc;
 196
 197     bool approve = false;
 198
 199     if (request >>= licExc)
 200     {
 201         approve = true;
 202     }
 203     handle_(approve, xRequest);
 204 }
 205
 206 SilentCheckPrerequisitesCommandEnv::SilentCheckPrerequisitesCommandEnv()
 207 {
 208 }
 209
 210 void SilentCheckPrerequisitesCommandEnv::handle(
 211        Reference< task::XInteractionRequest> const & xRequest )
 212 {
 213     uno::Any request( xRequest->getRequest() );
 214     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 215
 216     deployment::LicenseException licExc;
 217     deployment::PlatformException platformExc;
 218     deployment::DependencyException depExc;
 219
 220     if (request >>= licExc)
 221     {
 222         handle_(true, xRequest); // approve = true
 223     }
 224     else if ((request >>= platformExc)
 225              || (request >>= depExc))
 226     {
 227         m_Exception = std::move(request);
 228     }
 229     else
 230     {
 231         m_UnknownException = std::move(request);
 232     }
 233 }
 234
 235 }
 236
 237 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */