MTConnectorSDK.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 MT_CONNECTOR_CPP_EXPORTS
#define MT_CONNECTOR_EXPORT __declspec(dllexport)
#else
#define MT_CONNECTOR_EXPORT __declspec(dllimport)
#endif

namespace MTConnectorSDK
{
    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,
        FileNoLongerExists = 1115,
        FileCheckedOutElsewhere = 1116,
        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;
    };

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

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

    MT_CONNECTOR_EXPORT RegisterServerResultCodes RegisterServer(const std::string& serverURL, bool showUI = false);
    MT_CONNECTOR_EXPORT 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
    };

    MT_CONNECTOR_EXPORT EnablePackageResultCodes EnablePackage(const std::string& packageUID, const std::string& localRoot = "", const std::string& serverURL = "", bool showUI = false);
    MT_CONNECTOR_EXPORT 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,
        InsufficientPermissions = 2,
        GeneralError = 3,
        IncompatibleClient = 4
    };

    MT_CONNECTOR_EXPORT CreateVersionResultCodes CreateVersion(const std::string& packageUID, const std::string& comment = "", bool showUI = false);
    MT_CONNECTOR_EXPORT 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,
        InsufficientPermissions = 7,
        GeneralError = 8,
        IncompatibleClient = 9
    };

    MT_CONNECTOR_EXPORT LockPackageResultCodes LockPackage(const std::string& packageUID, const int& ownerProcess = 0, bool showUI = false);
    MT_CONNECTOR_EXPORT 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
    };

    MT_CONNECTOR_EXPORT UnlockPackageResultCodes UnlockPackage(const std::string& packageUID, bool discardChanges = false, bool showUI = false);
    MT_CONNECTOR_EXPORT 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
    };

    MT_CONNECTOR_EXPORT SyncNowResultCodes SyncNow(const std::string& packageUID, bool showUI = false);
    MT_CONNECTOR_EXPORT 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
    };

    MT_CONNECTOR_EXPORT UpdateServerResultCodes UpdateServer(const std::string& packageUID, const std::string& filePath, bool showUI = false);
    MT_CONNECTOR_EXPORT 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
    };

    MT_CONNECTOR_EXPORT UpdateLocalResultCodes UpdateLocal(const std::string& packageUID, const std::string& filePath, bool showUI = false);
    MT_CONNECTOR_EXPORT 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
    };

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

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

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

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

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

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

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

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

    MT_CONNECTOR_EXPORT std::vector<LocalFileRecord> EvaluateFilter(const std::string& filter, const std::string& packageUID = "", const std::string& serviceUID = "");

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

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

    MT_CONNECTOR_EXPORT std::string GetShellExtensionName();

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

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

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

    MT_CONNECTOR_EXPORT bool IsMineTrustConnectorInstalled();

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

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

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

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

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

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

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

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

    MT_CONNECTOR_EXPORT void RemoveTag(PackageConfiguration& instance, const std::string& localFilePath, const std::string& tagName);

    MT_CONNECTOR_EXPORT 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());

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