winget-cli

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README | LICENSE

Interface_0_3.cpp (6198B)

      1 // Copyright (c) Microsoft Corporation.
      2 // Licensed under the MIT License.
      3 #include "pch.h"
      4 #include "Interface.h"
      5 #include "Database/Schema/0_1/SetInfoTable.h"
      6 #include "Database/Schema/0_2/QueueTable.h"
      7 #include "StatusItemTable.h"
      8 #include "ChangeListenerTable.h"
      9 #include <winget/SQLiteMetadataTable.h>
     10 
     11 using namespace AppInstaller::SQLite;
     12 using namespace AppInstaller::Utility;
     13 
     14 namespace winrt::Microsoft::Management::Configuration::implementation::Database::Schema::V0_3
     15 {
     16     static constexpr AppInstaller::SQLite::Version s_InterfaceVersion{ 0, 3 };
     17 
     18     const AppInstaller::SQLite::Version& Interface::GetSchemaVersion()
     19     {
     20         return s_InterfaceVersion;
     21     }
     22 
     23     void Interface::InitializeDatabase()
     24     {
     25         V0_2::Interface::InitializeDatabase();
     26 
     27         Savepoint savepoint = Savepoint::Create(*m_storage, "InitializeDatabase_0_3");
     28         MigrateFrom0_2();
     29         savepoint.Commit();
     30     }
     31 
     32     void Interface::RemoveSet(AppInstaller::SQLite::rowid_t target)
     33     {
     34         Savepoint savepoint = Savepoint::Create(*m_storage, "RemoveSet_0_3");
     35 
     36         V0_2::Interface::RemoveSet(target);
     37 
     38         StatusItemTable statusItemTable(*m_storage);
     39         statusItemTable.RemoveForSet(target);
     40 
     41         savepoint.Commit();
     42     }
     43 
     44     bool Interface::MigrateFrom(IConfigurationDatabase* current)
     45     {
     46         auto currentSchemaVersion = current->GetSchemaVersion();
     47         if (currentSchemaVersion < s_InterfaceVersion)
     48         {
     49             if (V0_2::Interface::MigrateFrom(current))
     50             {
     51                 Savepoint savepoint = Savepoint::Create(*m_storage, "MigrateFrom0_2");
     52 
     53                 MigrateFrom0_2();
     54                 s_InterfaceVersion.SetSchemaVersion(*m_storage);
     55 
     56                 savepoint.Commit();
     57 
     58                 return true;
     59             }
     60         }
     61         else if (currentSchemaVersion == s_InterfaceVersion)
     62         {
     63             return true;
     64         }
     65 
     66         return false;
     67     }
     68 
     69     void Interface::AddQueueItem(const GUID& instanceIdentifier, const std::string& objectName)
     70     {
     71         V0_2::QueueTable queueTable(*m_storage);
     72         queueTable.AddQueueItemWithProcess(instanceIdentifier, objectName);
     73     }
     74 
     75     std::vector<std::tuple<GUID, std::string, std::chrono::system_clock::time_point, DWORD, bool>> Interface::GetQueueItems()
     76     {
     77         V0_2::QueueTable queueTable(*m_storage);
     78         return queueTable.GetQueueItemsWithProcess();
     79     }
     80 
     81     void Interface::MigrateFrom0_2()
     82     {
     83         V0_2::QueueTable queueTable(*m_storage);
     84         queueTable.AddProcessColumn();
     85 
     86         ChangeListenerTable changeListenerTable(*m_storage);
     87         changeListenerTable.Create();
     88 
     89         StatusItemTable statusItemTable(*m_storage);
     90         statusItemTable.Create();
     91     }
     92 
     93     std::vector<IConfigurationDatabase::StatusItemTuple> Interface::GetStatusSince(int64_t changeIdentifier)
     94     {
     95         StatusItemTable statusItemTable(*m_storage);
     96         return statusItemTable.GetStatusSince(changeIdentifier);
     97     }
     98 
     99     std::tuple<int64_t, std::vector<IConfigurationDatabase::StatusItemTuple>> Interface::GetStatusBaseline()
    100     {
    101         StatusItemTable statusItemTable(*m_storage);
    102         return statusItemTable.GetStatusBaseline();
    103     }
    104 
    105     void Interface::AddListener(const std::string& objectName)
    106     {
    107         ChangeListenerTable changeListenerTable(*m_storage);
    108         changeListenerTable.AddChangeListener(objectName);
    109     }
    110 
    111     void Interface::RemoveListener(const std::string& objectName)
    112     {
    113         ChangeListenerTable changeListenerTable(*m_storage);
    114         changeListenerTable.RemoveChangeListener(objectName);
    115     }
    116 
    117     std::vector<std::tuple<std::string, std::chrono::system_clock::time_point, DWORD>> Interface::GetChangeListeners()
    118     {
    119         ChangeListenerTable changeListenerTable(*m_storage);
    120         return changeListenerTable.GetChangeListeners();
    121     }
    122 
    123     void Interface::UpdateSetState(const guid& setInstanceIdentifier, ConfigurationSetState state)
    124     {
    125         StatusItemTable statusItemTable(*m_storage);
    126         statusItemTable.UpdateSetState(setInstanceIdentifier, state);
    127     }
    128 
    129     void Interface::UpdateSetInQueue(const guid& setInstanceIdentifier, bool inQueue)
    130     {
    131         StatusItemTable statusItemTable(*m_storage);
    132         statusItemTable.UpdateSetInQueue(setInstanceIdentifier, inQueue);
    133     }
    134 
    135     void Interface::UpdateUnitState(const guid& setInstanceIdentifier, const ConfigurationSetChangeDataPtr& changeData)
    136     {
    137         StatusItemTable statusItemTable(*m_storage);
    138         statusItemTable.UpdateUnitState(setInstanceIdentifier, changeData);
    139     }
    140 
    141     ConfigurationSetState Interface::GetSetState(const guid& instanceIdentifier)
    142     {
    143         StatusItemTable statusItemTable(*m_storage);
    144         return statusItemTable.GetSetState(instanceIdentifier);
    145     }
    146 
    147     std::chrono::system_clock::time_point Interface::GetSetFirstApply(const guid& instanceIdentifier)
    148     {
    149         V0_1::SetInfoTable setInfoTable(*m_storage);
    150         return setInfoTable.GetSetFirstApply(instanceIdentifier);
    151     }
    152 
    153     std::chrono::system_clock::time_point Interface::GetSetApplyBegun(const guid& instanceIdentifier)
    154     {
    155         StatusItemTable statusItemTable(*m_storage);
    156         return statusItemTable.GetSetApplyBegun(instanceIdentifier);
    157     }
    158 
    159     std::chrono::system_clock::time_point Interface::GetSetApplyEnded(const guid& instanceIdentifier)
    160     {
    161         StatusItemTable statusItemTable(*m_storage);
    162         return statusItemTable.GetSetApplyEnded(instanceIdentifier);
    163     }
    164 
    165     ConfigurationUnitState Interface::GetUnitState(const guid& instanceIdentifier)
    166     {
    167         StatusItemTable statusItemTable(*m_storage);
    168         return statusItemTable.GetUnitState(instanceIdentifier);
    169     }
    170 
    171     std::optional<std::tuple<HRESULT, std::string, std::string, ConfigurationUnitResultSource>> Interface::GetUnitResultInformation(const guid& instanceIdentifier)
    172     {
    173         StatusItemTable statusItemTable(*m_storage);
    174         return statusItemTable.GetUnitResultInformation(instanceIdentifier);
    175     }
    176 }