iberbox.h

Go to the documentation of this file.

#ifndef IBERBOX_H
#define IBERBOX_H

#include <atomic>
#include <memory.h>

#include "iberbox/config.h"
#include "iberbox/task.h"
#include "iberbox/action.h"
#include "iberbox/node.h"
#include "iberbox/events.h"
#include "iberbox/user.h"
#include "iberbox/crash.h"

#ifdef USE_SCAPIX
#include <scapix/bridge/object.h>
#endif

namespace iberbox {

class IberboxSettings
#ifdef USE_SCAPIX
    : public scapix::bridge::object<IberboxSettings>
#endif
{
public:
    IberboxSettings();
    IberboxSettings(const std::string &workingDirectory);
    virtual ~IberboxSettings();

    void setWorkingDirectory(const std::string &path);
    std::string getWorkingDirectory();

    void setUserAgent(const std::string &userAgent);
    std::string getUserAgent();

private:
    std::string mWorkingDirectory;
    std::string mUserAgent;
};

#ifdef USE_SCAPIX

typedef std::shared_ptr<IberboxSettings> IberboxSettingsType;
#else

typedef IberboxSettings * IberboxSettingsType;
#endif

class Loop;
class ApiClient;
class CallbackDispatcher;
class Iberbox
#ifdef USE_SCAPIX
    : public scapix::bridge::object<Iberbox>, public ActionListener
#else
    : public ActionListener
#endif
{
public:
    enum SortOrderType
    {
        SORT_ORDER_SIZE_R = -6,
        SORT_ORDER_MODIFICATION_TIME_R,
        SORT_ORDER_CREATION_TIME_R,
        SORT_ORDER_ALPHABETICAL_R,
        SORT_ORDER_NATURAL_R,
        SORT_ORDER_DEFAULT_R,
        SORT_ORDER_NONE = 0,
        SORT_ORDER_DEFAULT,
        SORT_ORDER_NATURAL,
        SORT_ORDER_ALPHABETICAL,
        SORT_ORDER_CREATION_TIME,
        SORT_ORDER_MODIFICATION_TIME,
        SORT_ORDER_SIZE,
        SORT_ORDER_LAST
    };

    enum LogLevelType
    {
        LOG_LEVEL_TRACE = 0,
        LOG_LEVEL_DEBUG = 1,
        LOG_LEVEL_INFO = 2,
        LOG_LEVEL_WARN = 3,
        LOG_LEVEL_ERROR = 4,
        LOG_LEVEL_CRITICAL = 5,
        LOG_LEVEL_OFF = 6
    };

    enum CryptoSchemeType
    {
        AES256_CRYPTO_SCHEME = 0,
        AES128_CRYPTO_SCHEME = 2
    };

    static void globalInit(const std::string &appId, int appVersion);
    static void globalCleanup();
    static void enableCrashHandler(std::function<void (std::string, std::string)> callback);

    static void setLogLevel(int logLevel);

    static int getLogLevel();

    Iberbox(TaskManagerType taskManager = nullptr, IberboxSettingsType settings = nullptr);
    virtual ~Iberbox();
    
    int test();
    void inviteEmail(const std::string &email, ActionListenerType listener = nullptr);
    void verifyEmail(const std::string &email, const std::string &firstName, const std::string &lastName, ActionListenerType listener = nullptr);
    void createAccount(const std::string &registrationId, const std::string &name, const std::string &lastName,
                       const std::string &email, const std::string &password,
                       int pin, ActionListenerType listener = nullptr);
    void createAccountWithCoupon(const std::string &registrationId, const std::string &name, const std::string &lastName,
                       const std::string &email, const std::string &password, int pin, const std::string &coupon,
                       ActionListenerType listener = nullptr);
    void createAccountWithPlan(const std::string &registrationId, const std::string &name, const std::string &lastName,
                       const std::string &email, const std::string &password, int pin, const std::string &coupon, int planId,
                       ActionListenerType listener = nullptr);
    void createAccountForCurrentUser(const std::string &coupon, ActionListenerType listener = nullptr);
    void forgotPassword(const std::string &email, ActionListenerType listener = nullptr);
    void changePassword(const std::string &password, ActionListenerType listener = nullptr);
    void getRecoveryKey(ActionListenerType listener = nullptr);
    void generate2faUrl(ActionListenerType listener = nullptr);
    void enable2fa(int code, ActionListenerType listener = nullptr);
    void disable2fa(int code, ActionListenerType listener = nullptr);
    void login2fa(const std::string &login, const std::string &password, int code, ActionListenerType listener = nullptr);
    void testRequest(ActionListenerType listener = nullptr);
    void loginIntoAccount(const std::string &login, const std::string &password, AccountHandle account, ActionListenerType listener = nullptr);
    void loginIntoAccount2fa(const std::string &login, const std::string &password, int code, AccountHandle accountHandle, ActionListenerType listener = nullptr);
    void login(const std::string &login, const std::string &password, ActionListenerType listener = nullptr);
    void checkPassword(const std::string &password, ActionListenerType listener = nullptr);
    void resumeSession(const std::string &session, ActionListenerType listener = nullptr);
    void newSession(ActionListenerType listener = nullptr);
    void newSessionIntoAccount(AccountHandle accountHandle, ActionListenerType listener = nullptr);
    void recoverAccount(const std::string &recoveryId, const std::string &login, const std::string &recoveryKey, int pin, ActionListenerType listener = nullptr);
    void recoverAccount2fa(const std::string &recoveryId, const std::string &login, const std::string &recoveryKey, int pin, int code, ActionListenerType listener = nullptr);

    void deleteAccount(const std::string &reason, ActionListenerType listener = nullptr);

    void getNodes(ActionListenerType listener = nullptr);
    void logout(ActionListenerType listener = nullptr);
    void currentEmail(ActionListenerType listener = nullptr);
    void getRootNodes(ActionListenerType listener = nullptr);
    void getRootNode(int type, ActionListenerType listener = nullptr);
    void getChildren(NodeHandle id, ActionListenerType listener = nullptr);
    void getChildFiles(NodeHandle id, ActionListenerType listener = nullptr);
    void getChildFolders(NodeHandle id, ActionListenerType listener = nullptr);
    void getSortedChildren(NodeHandle id, int sortOrder = SORT_ORDER_DEFAULT, ActionListenerType listener = nullptr);
    void getSortedChildFiles(NodeHandle id, int sortOrder = SORT_ORDER_DEFAULT, ActionListenerType listener = nullptr);
    void getSortedChildFolders(NodeHandle id, int sortOrder = SORT_ORDER_DEFAULT, ActionListenerType listener = nullptr);
    void getNodeById(NodeHandle id, ActionListenerType listener = nullptr);
    void getNodeByPath(const std::string &path, ActionListenerType listener = nullptr);
    void getNodePath(NodeHandle id,  ActionListenerType listener = nullptr);
    void createFolder(NodeHandle parent, const std::string &name, ActionListenerType listener = nullptr);
    void deleteNode(NodeHandle node, ActionListenerType listener = nullptr);
    void deleteNodePermanently(NodeHandle node, ActionListenerType listener = nullptr);
    void renameNode(NodeHandle node, const std::string &name, ActionListenerType listener = nullptr);
    void setNodeTag(NodeHandle node, unsigned char tag, ActionListenerType listener = nullptr);
    void toggleFolderSync(NodeHandle node, ActionListenerType listener = nullptr);
    void moveNode(NodeHandle node, NodeHandle parent, ActionListenerType listener = nullptr);
    void copyNode(NodeHandle node, NodeHandle parent, ActionListenerType listener = nullptr);
    void getOpenSecrets(ActionListenerType listener = nullptr);
    void createSecret(const std::string &name, const std::string &password, ActionListenerType listener = nullptr);
    void openSecret(const std::string &name, const std::string &password, ActionListenerType listener = nullptr);
    void closeSecret(NodeHandle secretHandle, ActionListenerType listener = nullptr);
    void updateSecret(NodeHandle secretHandle, const std::string &name, const std::string &password, ActionListenerType listener = nullptr);
    void getSecretRecoveryKey(NodeHandle secretHandle, ActionListenerType listener = nullptr);
    void recoverSecret(const std::string &recoveryKey, const std::string &newName, const std::string &newPassword, ActionListenerType listener = nullptr);
    void deleteSecret(NodeHandle secretHandle, ActionListenerType listener = nullptr);
    void createLink(NodeHandle node, ActionListenerType listener = nullptr);

    void createSharedDriveLink(NodeHandle node, int accessLevel, ActionListenerType listener = nullptr);

    void deleteLink(const std::string &link, ActionListenerType listener = nullptr);

    void getLinkInfo(const std::string &link, ActionListenerType listener = nullptr);
    void getUserInfo(ActionListenerType listener = nullptr);
    void getPublicUserInfo(UserHandle user, ActionListenerType listener = nullptr);
    void getAccountInfo(ActionListenerType listener = nullptr);
    void getPublicAccountInfo(AccountHandle account, ActionListenerType listener = nullptr);
    void getPublicAccountInfoByLink(const std::string &link, ActionListenerType listener = nullptr);
    void setAccountCryptoScheme(int cryptoScheme, ActionListenerType listener = nullptr);

    void setInvoicingAddress(const std::string &companyName, const std::string &companyAddress, const std::string &companyAddress2,
                             const std::string &companyID, ActionListenerType listener = nullptr);
    void getInvoicingInfo(ActionListenerType listener = nullptr);
    void downloadInvoice(int invoiceId, const std::string &path, ActionListenerType listener = nullptr);
    void getSessionInfo(ActionListenerType listener = nullptr);
    void logEvent(int eventId, ActionListenerType listener = nullptr);
    void logEventData(int eventId, const std::string &message, ActionListenerType listener = nullptr);
    void testProxy(const std::string &url, const std::string &user,
                   const std::string &password, ActionListenerType listener = nullptr);
    void removeProxy(ActionListenerType listener = nullptr);
    void setProxy(const std::string &url, ActionListenerType listener = nullptr);
    void setAuthProxy(const std::string &url, const std::string &user,
                      const std::string &password, ActionListenerType listener = nullptr);
    void upload(const std::string &file, NodeHandle parent, ActionListenerType listener = nullptr);

    void uploadWithCustomData(const std::string &file, NodeHandle parent, const std::string &customData, ActionListenerType listener = nullptr);

    void download(NodeHandle node, const std::string &parent, ActionListenerType listener = nullptr);

    void downloadWithCustomData(NodeHandle node, const std::string &parent, const std::string &customData, ActionListenerType listener = nullptr);

    void downloadLink(const std::string &link, const std::string &parent, ActionListenerType listener = nullptr);

    void downloadLinkWithCustomData(const std::string &link, const std::string &parent, const std::string &customData, ActionListenerType listener = nullptr);

    void downloadZip(NodeHandle node, const std::string &parent, ActionListenerType listener = nullptr);

    void downloadZipWithCustomData(NodeHandle node, const std::string &parent, const std::string &customData, ActionListenerType listener = nullptr);

    void getTransfers(ActionListenerType listener = nullptr);
    void getUnfinishedTransfers(int type, ActionListenerType listener = nullptr);
    void getTransfersByType(int type, ActionListenerType listener = nullptr);
    void getTransfersByStatus(int type, int status, ActionListenerType listener = nullptr);
    void clearFinishedTransfers(ActionListenerType listener = nullptr);
    void clearFinishedTransfersByType(int type, ActionListenerType listener = nullptr);
    void clearFinishedTransferByTag(int tag, ActionListenerType listener = nullptr);
    void cancelTransfers(ActionListenerType listener = nullptr);
    void cancelTransfersByType(int type, ActionListenerType listener = nullptr);
    void cancelTransferByTag(int tag, ActionListenerType listener = nullptr);
    void setUploadSpeedLimit(int kbps, ActionListenerType listener = nullptr);
    void setDownloadSpeedLimit(int kbps, ActionListenerType listener = nullptr);
    void getUploadSpeedLimit(ActionListenerType listener = nullptr);
    void getDownloadSpeedLimit(ActionListenerType listener = nullptr);
    void readNode(NodeHandle file, unsigned long startPositon, unsigned long size, ActionListenerType listener = nullptr);
    void readLink(const std::string &link, unsigned long startPositon, unsigned long size, ActionListenerType listener = nullptr);
    void uploadMetadata(const std::string &file, NodeHandle node, int metadataType, ActionListenerType listener = nullptr);
    void downloadMetadata(NodeHandle node, int metadataType, const std::string &parent, ActionListenerType listener = nullptr);
    void downloadPublicMetadata(const std::string &metadataInfo, int metadataType, const std::string &parent, ActionListenerType listener = nullptr);
    void registerDevice(const std::string &name, ActionListenerType listener = nullptr);
    void selectDevice(NodeHandle deviceId, ActionListenerType listener = nullptr);
    void getCurrentDevice(ActionListenerType listener = nullptr);
    void getDeviceByName(const std::string &name, ActionListenerType listener = nullptr);
    void getDeviceById(NodeHandle deviceId, ActionListenerType listener = nullptr);
    void getDevices(ActionListenerType listener = nullptr);
    void renameDevice(NodeHandle deviceId, const std::string &newName, ActionListenerType listener = nullptr);
    void deleteDevice(NodeHandle deviceId, ActionListenerType listener = nullptr);
    void getBackupByName(NodeHandle deviceId, const std::string &name, ActionListenerType listener = nullptr);
    void getBackupById(NodeHandle backupId, ActionListenerType listener = nullptr);
    void getActiveBackups(ActionListenerType listener = nullptr);
    void getBackups(NodeHandle deviceId, ActionListenerType listener = nullptr);
    void createBackup(const std::string &name, unsigned long startTime, const std::string cronExpr, const std::string &localPath,
                      int maxSnapshots, int status, ActionListenerType listener = nullptr);
    void renameBackup(NodeHandle backupId, const std::string &newName, ActionListenerType listener = nullptr);
    void changeBackupSchedule(NodeHandle backupId, unsigned long startTime, std::string cronExpr, ActionListenerType listener = nullptr);
    void changeBackupPath(NodeHandle backupId, const std::string &localPath, ActionListenerType listener = nullptr);
    void modifyBackup(NodeHandle backupId, const std::string &name, unsigned long startTime, const std::string cronExpr, const std::string &localPath,
                      int maxSnapshots, int status, ActionListenerType listener = nullptr);
    void changeBackupStatus(NodeHandle backupId, int status, ActionListenerType listener = nullptr);
    void deleteBackup(NodeHandle backupId, ActionListenerType listener = nullptr);
    void authorizeBackup(NodeHandle backupId, ActionListenerType listener = nullptr);
    void deauthorizeBackup(NodeHandle backupId, ActionListenerType listener = nullptr);
    void getSnapshots(NodeHandle backupId, ActionListenerType listener = nullptr);
    void getNextSnapshots(ActionListenerType listener = nullptr);
    void getNextSnapshotsForDevice(NodeHandle deviceId, ActionListenerType listener = nullptr);
    void getNextSnapshotsForBackup(NodeHandle backupId, int count, ActionListenerType listener = nullptr);
    void getNextSnapshotsForAccount(ActionListenerType listener = nullptr);
    void getNextSnapshotsForSchedule(unsigned long startTime, const std::string cronExpr, int count, ActionListenerType listener = nullptr);
    void getLastSnapshots(ActionListenerType listener = nullptr);
    void getLastSnapshotsForDevice(NodeHandle deviceId, ActionListenerType listener = nullptr);
    void getLastSnapshotsForBackup(NodeHandle backupId, int count, ActionListenerType listener = nullptr);
    void getLastSnapshotsForAccount(ActionListenerType listener = nullptr);
    void createInbox(const std::string &name, const std::string &message, ActionListenerType listener = nullptr);
    void setInboxInfo(NodeHandle inboxHandle, const std::string &name, const std::string &message, ActionListenerType listener = nullptr);
    void getInboxInfo(const std::string &inboxLink, ActionListenerType listener = nullptr);
    void getExternalInbox(ActionListenerType listener = nullptr);
    void startRecord(const std::string &inboxLink, ActionListenerType listener = nullptr);
    void resumeRecord(const std::string &newRecordLink, ActionListenerType listener = nullptr);
    void setRecordInfo(const std::string &contactInfo, const std::string &subject, const std::string &message, ActionListenerType listener = nullptr);

    void setEmailRecordInfo(const std::string &from, const std::string &to, const std::string &subject, const std::string &message, ActionListenerType listener = nullptr);

    void uploadToRecord(const std::string &file, ActionListenerType listener = nullptr);
    void removeFromRecord(NodeHandle fileHandle, ActionListenerType listener = nullptr);
    void finishRecord(ActionListenerType listener = nullptr);
    void finishRecordWithRecipient(const std::string &recipient, ActionListenerType listener = nullptr);
    void removeRecord(ActionListenerType listener = nullptr);
    void getRecordInfo(const std::string &recordLink, ActionListenerType listener = nullptr);
    void setRecordStatus(NodeHandle record, unsigned char status, ActionListenerType listener = nullptr);
    void getSubscriptionOptions(ActionListenerType listener = nullptr);
    void getSubscriptionOptionsWithFeatures(int features, ActionListenerType listener = nullptr);
    void setSubscription(int subscriptionId, ActionListenerType listener = nullptr);
    void getPaymentInfo(int subscriptionId, ActionListenerType listener = nullptr);
    void removePaymentMethod(ActionListenerType listener = nullptr);
    void loginLink(const std::string &folderLink, ActionListenerType listener = nullptr);
    void logoutLink(ActionListenerType listener = nullptr);
    void generateUpdate(const std::string &appName, int version,
                        const std::string &platform, const std::string &updateFolder,
                        const std::string &updateUrl, const std::string &changelog,
                        const std::string &outputFile, const std::string &privateKey,
                        ActionListenerType listener = nullptr);
    void checkUpdate(const std::string &appName, int version, ActionListenerType listener = nullptr);
    void downloadUpdate(const std::string &appName, int version, const std::string &downloadFolder, const std::string &installFolder, ActionListenerType listener = nullptr);
    void installUpdate(const std::string &appName, int version, const std::string &downloadFolder, const std::string &installFolder, ActionListenerType listener = nullptr);

    void getReferralsInfo(ActionListenerType listener = nullptr);
    void getBalancesInfo(ActionListenerType listener = nullptr);
    void getCouponInfo(const std::string &coupon, ActionListenerType listener = nullptr);
    void getAccountCoupons(ActionListenerType listener = nullptr);
    void createResellerCoupon(const std::string &email = std::string(), ActionListenerType listener = nullptr);
    void createResellerCouponWithPlan(int planId, const std::string &email = std::string(), ActionListenerType listener = nullptr);
    void deleteCoupon(int id, ActionListenerType listener = nullptr);
    void addResellerCodeAsPaymentMethod(const std::string &code, ActionListenerType listener = nullptr);
    void addDirectDebitAsPaymentMethod(const std::string &iban, const std::string &holder, ActionListenerType listener = nullptr);
    void addBankTransferAsPaymentMethod(ActionListenerType listener = nullptr);

    void createJoinLink(const std::string &email, ActionListenerType listener = nullptr);

    void createJoinLinkWithAccessLevel(const std::string &email, int accessLevel, ActionListenerType listener = nullptr);

    void checkJoinLink(const std::string &link, const std::string &email, ActionListenerType listener = nullptr);
    void joinAccountWithCurrentUser(AccountHandle account, const std::string &accountKey, ActionListenerType listener = nullptr);
    void joinAccount(AccountHandle account, const std::string &accountKey, const std::string &registrationId,
                    const std::string &name, const std::string &lastName, const std::string &email,
                    const std::string &password, int pin, ActionListenerType listener = nullptr);
    void setDefaultAccount(AccountHandle account, ActionListenerType listener = nullptr);
    void revokeAccountAccessOfCurrentUser(ActionListenerType listener = nullptr);
    void revokeAccountAccess(UserHandle user, ActionListenerType listener = nullptr);
    void addContact(NodeHandle account, const std::string &contactName, ActionListenerType listener = nullptr);
    void modifyContact(NodeHandle contact, const std::string &contactName, ActionListenerType listener = nullptr);
    void removeContact(NodeHandle contact, ActionListenerType listener = nullptr);
    void saveInbox(NodeHandle contact, const std::string &inboxLink, const std::string &outboxName, ActionListenerType listener = nullptr);
    void modifySavedInbox(NodeHandle outbox, const std::string &outboxName, ActionListenerType listener = nullptr);
    void removeSavedInbox(NodeHandle outbox, ActionListenerType listener = nullptr);
    void saveSentRecord(NodeHandle outbox, const std::string &recordLink, ActionListenerType listener = nullptr);

    void setAccessLevel(UserHandle user, int accessLevel, ActionListenerType listener = nullptr);
    void createSharedDrive(const std::string &name, ActionListenerType listener = nullptr);
    void createVirtuallyNestedSharedDrive(NodeHandle parent, const std::string &name, ActionListenerType listener = nullptr);
    void nestSharedDrive(NodeHandle sharedDrive, NodeHandle parent, ActionListenerType listener = nullptr);
    void unnestSharedDrive(NodeHandle sharedDrive, ActionListenerType listener = nullptr);
    void deleteSharedDrive(NodeHandle sharedDrive, ActionListenerType listener = nullptr);
    void getSharedDriveInfo(NodeHandle sharedDrive, ActionListenerType listener = nullptr);
    void getSharedDrives(ActionListenerType listener = nullptr);
    void shareDriveWithAccountByLink(NodeHandle sharedDrive, const std::string &accountLink, ActionListenerType listener = nullptr);
    void shareDriveWithAccountByLinkWithAccessLevel(NodeHandle sharedDrive, const std::string &accountLink, int accessLevel, ActionListenerType listener = nullptr);
    void shareDriveWithAccount(NodeHandle sharedDrive, AccountHandle account, ActionListenerType listener = nullptr);
    void shareDriveWithAccountAndAccessLevel(NodeHandle sharedDrive, AccountHandle account, int accessLevel, ActionListenerType listener = nullptr);
    void unshareDriveWithAccount(NodeHandle sharedDrive, AccountHandle account, ActionListenerType listener = nullptr);
    void archiveSharedDrive(NodeHandle sharedDrive, ActionListenerType listener = nullptr);
    void unarchiveSharedDrive(NodeHandle sharedDrive, ActionListenerType listener = nullptr);
    void getMeetingAccess(NodeHandle sharedDrive, ActionListenerType listener = nullptr);
    void getAccountLog(unsigned short page = 1, ActionListenerType listener = nullptr);
    void verifyHash(const std::string base64Hash, const std::string filePath, ActionListenerType listener = nullptr);
    void getNoticeCredentials(ActionListenerType listener = nullptr);
    void sendCrashReport(const std::string &file, ActionListenerType listener = nullptr);
    void addEventListener(EventListenerType listener);
    void removeEventListener(EventListenerType listener);
    void addActionListener(ActionListenerType listener);
    void removeActionListener(ActionListenerType listener);
    virtual void onActionFinish(Action action) override;

protected:
    static bool mInitialized;
    static std::string mAppId;
    static int mAppVersion;
    static CrashManager *mCrashManager;
    CallbackDispatcher *mCallbackDispatcher;
    ApiClient *mClient;
    Loop *mLoop;
};

}

#endif // IBERBOX