CppCliInterop.h

// This file was generated automatically using GenerateAPIDefinition.ps1
// Do not manually alter this file - instead modify the template and re-build the project
#pragma once
 
#include <chrono>
#include <string>
#include <unordered_map>
#include <vector>
#include <ppltasks.h>
 
#ifdef CPPCLIINTEROP_EXPORTS
#define MT_CONNECTOR_EXPORT __declspec(dllexport)
#else
#define MT_CONNECTOR_EXPORT __declspec(dllimport)
#endif

namespace MineTrustConnector
{
    class MT_CONNECTOR_EXPORT CppCliInterop
    {
    public:
        enum class LogEvent
        {
            AllFilesUpToDate = 1000,
            SyncStarted = 1001,
            SyncCompleted = 1002,
            ReplicationStarted = 1003,
            ReplicationComplete = 1004,
            VersionLocked = 1005,
            PackageDisabled = 1006,
            ProcessOwnedLockRemoved = 1007,
            PackageVersionCreated = 1008,
            PackageDeleted = 1009,
            PackageArchived = 1010,
            PackageRestored = 1011,
            FileUploaded = 1100,
            FileDownloaded = 1101,
            FileUpdatedLocally = 1102,
            FileUpdatedOnServer = 1103,
            FileRemovedOnServer = 1104,
            FileReplicated = 1105,
            FileDiscarded = 1106,
            FileCheckedOut = 1107,
            FileCheckedIn = 1108,
            FileUncheckedOut = 1109,
            FileChangesDiscarded = 1110,
            FileVersionsCleanedUp = 1111,
            FileUploadInProgress = 1112,
            FileDownloadInProgress = 1113,
            PreparingFileUpload = 1114,
            Initialising = 2000,
            ConnectionEstablished = 2001,
            ConnectionLost = 2002,
            GracefulShutdown = 2003,
            ServiceError = 2004,
            ServerRegistered = 2005,
            AccessTokenSuccess = 2006,
            PackageEnabled = 2007,
            ServiceUIDMismatch = 2008,
            PackageAutoEnableUndetermined = 2009,
            ClientCompatibilityError = 2010,
            PackagePreviouslyDeleted = 2011,
            SSLErrorDetected = 2012,
            GeneralSyncError = 4000,
            GeneralReplicationError = 4001,
            Unauthorized = 4002,
            PackageConfigurationNotFound = 4003,
            AccessTokenRequired = 4004,
            ServerRegistrationFailed = 4005,
            LockPackageFailed = 4006,
            UnlockPackageFailed = 4007,
            EnablePackageFailed = 4008,
            UpdateLocalFailed = 4009,
            UpdateServerFailed = 4010,
            PackageValidationFailed = 4011,
            FileConflict = 4012,
            CreateVersionFailed = 4013,
            PackageDeletionFailed = 4014,
            PrintDiagnosticsFailed = 4015,
            AccessForbidden = 4016,
        };

        struct IncludeConfiguration
        {
            std::string packageUID;
            std::vector<std::string> files;
            std::vector<std::string> extensions;
            std::unordered_map<std::string, std::string> tags;
            std::string retention;
        };
        
        struct PackageConfiguration
        {
            static MT_CONNECTOR_EXPORT const std::string SHARED_PACKAGE_VISIBILITY;
            static MT_CONNECTOR_EXPORT const std::string PRIVATE_PACKAGE_VISIBILITY;
            std::string filePath;
            bool enabled = false;
            std::string displayName;
            std::string packageUID;
            std::string serverUrl;
            std::string localRoot;
            std::string mineTrustRoot;
            std::vector<std::string> tagNamingPatterns;
            std::vector<IncludeConfiguration> include;
            std::vector<std::string> exclude;
            int targetVersion = 0;
            bool exclusiveCheckOut = false;
            std::string owner;
            std::string visibility;
            std::string filter;
        };
        
        struct PackageMetrics
        {
            int totalFiles = 0;
            int localFiles = 0;
            int percentageDownloaded = 0;
        };
        
        struct ConfigSchemaItem
        {
            ConfigSchemaItem* parent;
            std::string value;
            std::vector<ConfigSchemaItem> children;
            std::string fullPath;
        };
        
        struct ConfigSchema
        {
            std::string root;
            std::vector<ConfigSchemaItem> items;
        };
        
        struct LocalTagRecord
        {
            std::string name;
            std::string value;
            std::unique_ptr<int> folderID;
        };
        
        struct LocalFileRecord
        {
            std::string name;
            std::string breadcrumb;
            std::vector<LocalTagRecord> tags;
            std::unique_ptr<int> fileID;
            std::string localFilePath;
        };
        
        struct MTConnectorEvent
        {
            LogEvent eventId;
            std::chrono::system_clock::time_point time;
            std::string message;
            std::unique_ptr<int64_t> recordId;
            int level = 0;
            std::string filePath;
            std::string packageUID;
            std::unordered_map<std::string, std::string> eventArgs;
        };

        static bool LoadPackageConfiguration(const std::string& packageUID, PackageConfiguration& instance);
        static bool SavePackageConfiguration(const PackageConfiguration& instance);

        enum class RegisterServerResultCodes
        {
            Success = 0,
            ServerAlreadyRegistered = 1,
            GeneralError = 2,
            IncompatibleClient = 3
        };

        static RegisterServerResultCodes RegisterServer(const std::string& serverURL, bool showUI = false);
        static concurrency::task<RegisterServerResultCodes> RegisterServerTask(const std::string& serverURL, bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
        enum class EnablePackageResultCodes
        {
            Success = 0,
            PackageConfigurationNotFound = 1,
            PackageAlreadyEnabled = 2,
            PackagePreviouslyDeleted = 3,
            ServerURLNotValid = 4,
            GeneralError = 5,
            IncompatibleClient = 6
        };

        static EnablePackageResultCodes EnablePackage(const std::string& packageUID, const std::string& localRoot = "", const std::string& serverURL = "", bool showUI = false);
        static concurrency::task<EnablePackageResultCodes> EnablePackageTask(const std::string& packageUID, const std::string& localRoot = "", const std::string& serverURL = "", bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
        enum class CreateVersionResultCodes
        {
            Success = 0,
            PackageConfigurationNotFound = 1,
            GeneralError = 2,
            IncompatibleClient = 3
        };

        static CreateVersionResultCodes CreateVersion(const std::string& packageUID, const std::string& comment = "", bool showUI = false);
        static concurrency::task<CreateVersionResultCodes> CreateVersionTask(const std::string& packageUID, const std::string& comment = "", bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
        enum class LockPackageResultCodes
        {
            Success = 0,
            PackageConfigurationNotFound = 1,
            PackageAlreadyLocked = 2,
            FilesCheckedOutElsewhere = 3,
            ProcessNotFound = 4,
            PackageNotEnabled = 5,
            PackageProcessing = 6,
            GeneralError = 7,
            IncompatibleClient = 8
        };

        static LockPackageResultCodes LockPackage(const std::string& packageUID, const int& ownerProcess = 0, bool showUI = false);
        static concurrency::task<LockPackageResultCodes> LockPackageTask(const std::string& packageUID, const int& ownerProcess = 0, bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
        enum class UnlockPackageResultCodes
        {
            Success = 0,
            PackageConfigurationNotFound = 1,
            PackageNotLocked = 2,
            GeneralError = 3,
            IncompatibleClient = 4
        };

        static UnlockPackageResultCodes UnlockPackage(const std::string& packageUID, bool discardChanges = false, bool showUI = false);
        static concurrency::task<UnlockPackageResultCodes> UnlockPackageTask(const std::string& packageUID, bool discardChanges = false, bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
        enum class SyncNowResultCodes
        {
            Success = 0,
            PackageConfigurationNotFound = 1,
            PackageNotEnabled = 2,
            PackageLocked = 3,
            GeneralError = 4,
            IncompatibleClient = 5
        };

        static SyncNowResultCodes SyncNow(const std::string& packageUID, bool showUI = false);
        static concurrency::task<SyncNowResultCodes> SyncNowTask(const std::string& packageUID, bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
        enum class UpdateServerResultCodes
        {
            Success = 0,
            PackageConfigurationNotFound = 1,
            LocalFileNotFound = 2,
            ServerFileNotFound = 3,
            ServerFileCheckedOut = 4,
            GeneralError = 5,
            IncompatibleClient = 6
        };

        static UpdateServerResultCodes UpdateServer(const std::string& packageUID, const std::string& filePath, bool showUI = false);
        static concurrency::task<UpdateServerResultCodes> UpdateServerTask(const std::string& packageUID, const std::string& filePath, bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
        enum class UpdateLocalResultCodes
        {
            Success = 0,
            PackageConfigurationNotFound = 1,
            LocalFileNotFound = 2,
            ServerFileNotFound = 3,
            GeneralError = 4,
            IncompatibleClient = 5
        };

        static UpdateLocalResultCodes UpdateLocal(const std::string& packageUID, const std::string& filePath, bool showUI = false);
        static concurrency::task<UpdateLocalResultCodes> UpdateLocalTask(const std::string& packageUID, const std::string& filePath, bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
        enum class PrintDiagnosticsResultCodes
        {
            Success = 0,
            GeneralError = 1,
            IncompatibleClient = 2
        };

        static PrintDiagnosticsResultCodes PrintDiagnostics(bool showUI = false);
        static concurrency::task<PrintDiagnosticsResultCodes> PrintDiagnosticsTask(bool showUI = false, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());

        static std::vector<std::string> ListServerURLs();

        static std::vector<PackageConfiguration> ListServerConfigurations();

        static std::vector<PackageConfiguration> ListPackageConfigurations();

        static std::vector<PackageConfiguration> FindPackageConfigurations(const std::string& jsonPath, const std::string& testValue, bool negate = false);

        [[deprecated("Use FindTags and FindFiles instead")]]
        static std::unordered_map<std::string, std::vector<std::string>> FindPackageConfigurationItems(const std::string& tagName, const std::string& tagValue);

        [[deprecated("Use FindTags and FindFiles instead")]]
        static std::unordered_map<std::string, std::vector<std::string>> FindPackageConfigurationItems(const std::unordered_map<std::string, std::string>& tagCriteria);

        static std::vector<LocalTagRecord> FindTags(const std::string& nameFilter = "", const std::string& valueFilter = "", const std::string& serviceUID = "", bool fuzzyMatch = false);

        static std::vector<LocalFileRecord> FindFiles(const std::string& tagName, const std::string& tagValue, const std::string& serviceUID = "", bool fuzzyMatch = false);

        static std::vector<LocalFileRecord> FindFiles(const std::unordered_map<std::string, std::string>& tagCriteria, const std::string& serviceUID = "", bool fuzzyMatch = false);

        static std::vector<std::string> GetDeletedPackages(const std::string& serviceUID = "");

        static std::vector<std::string> GetArchivedPackages(const std::string& serviceUID = "");

        static std::string GetShellExtensionName();

        static PackageMetrics LoadPackageMetrics(const std::string& packageUID, const std::string& serviceUID = "");

        static ConfigSchema LoadConfigSchema(const std::string& root);

        static std::vector<std::string> GetPermittedValues(const std::string& configPath);

        static bool IsMineTrustConnectorInstalled();

        static bool IsMineTrustConnectorRunning();
 
        struct RegistrationWrapperImpl;
        using RegistrationWrapper = std::unique_ptr<RegistrationWrapperImpl, void(*)(RegistrationWrapperImpl*)>;

        static RegistrationWrapper RegisterEvents(std::function<void(const MTConnectorEvent&)> callback, const std::list<LogEvent>& eventIDs = {});

        static std::vector<std::string> EnumerateLocalContents(const std::string& packageUID);

        static std::vector<std::string> EnumerateLocalFilesByTag(const std::string& packageUID, const std::string& tagName, const std::string& tagValue);

        static bool IsInScope(const std::string& packageUID, const std::string& localFilePath);

        static void IncludeInPackage(PackageConfiguration& instance, const std::string& localFilePath, std::function<void(IncludeConfiguration&)> configureInclusion);

        static void ExcludeFromPackage(PackageConfiguration& instance, const std::string& localFilePath);

        static void TagFile(PackageConfiguration& instance, const std::string& localFilePath, const std::string& tagName, const std::string& tagValue);

        static concurrency::task<void> ReceiveFiles(const std::vector<LocalFileRecord>& selection, std::function<void(const std::vector<LocalFileRecord>&)> filesReceivedCallback, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());

        static concurrency::task<void> SendFiles(const std::vector<LocalFileRecord>& selection, std::function<PackageConfiguration(const LocalFileRecord&)> packageSelectionCallback, concurrency::cancellation_token cancel = concurrency::cancellation_token::none());
    };
}