ServerActions.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2020, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: NDEVRServerActions
File: OWLFactory
Included in API: True
Author(s): tyler.parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/String.h>
#include <NDEVR/PasswordString.h>
#include <NDEVR/DynamicPointer.h>
#include <NDEVR/TimeSpan.h>
#include <NDEVR/BinaryFile.h>
namespace NDEVR
{
    class InfoPipe;
    class StringView;
    struct NDEVRServerInfo;
    class TranslatedString;
    struct ServerCommandReturn
    {
        enum ReturnCode : uint04
        {
            e_success = 0
            , e_invalid_packet
            , e_invalid_credentials
            , e_user_not_found
            , e_resource_not_found
            , e_permission_denied
            , e_unknown_error
            , e_too_many_requests
            , e_already_exists
            , e_database_error
            , e_awaiting_approval
            , e_invalid_resource_id
            , e_retry_soon
            , e_not_supported
            , e_server_too_new
            , e_server_too_old
            , e_client_too_new
            , e_client_too_old
            , e_timeout
        };
        ServerCommandReturn(ReturnCode code)
            : return_code(code)
        {
        }
        ServerCommandReturn(ReturnCode code, const StringView& msg)
            : return_code(code)
            , return_message(msg)
        {}
        bool success() const
        {
            return return_code == e_success;
        }
        NDEVRSERVERCLIENT_API TranslatedString returnMessage() const;
        ReturnCode return_code;             
        String return_message;              
    };

    struct ServerMainInfo
    {
        String server_name;                 
        String admin_email;                 
        uint08 version = 1748456343U;       
        bool auto_approve_users = false;    
    };
    class PublicPrivateKey;
    struct ServerCredentials
    {
        String username;                    
        UUID encoded_user_password;         
        sint04 user_id = Constant<sint04>::Invalid; 
        String ip_address;                  
        bool credentials_validated = false; 
    };

    struct ResourceID
    {
        String resource_name;               
        sint04 resource_id = Constant<sint04>::Invalid; 
        sint04 resource_owner = Constant<sint04>::Invalid; 
        sint04 resource_version = Constant<sint04>::Invalid; 
    };

    struct ResourceSearchString : public ServerCredentials
    {
        String name_search_regex;           
        String description_search_regex;    
        String category_search_regex;       
        String mime_type_search_regex;      
        Buffer<sint04> resource_owners_white_list;  
        Buffer<sint04> resource_owners_black_list;  
        Buffer<sint04> resource_ids_white_list;     
        Buffer<sint04> resource_ids_black_list;     
        Buffer<UUID> library_ids_black_list;        
        Buffer<UUID> library_ids_white_list;        
        Buffer<TimeSpan> accessed_time_span;        
        Buffer<TimeSpan> edited_time_span;          
        Buffer<TimeSpan> created_time_span;         
    };

    struct EncodedMessage
    {
        sint04 user_id = Constant<sint04>::Invalid;     
        sint04 resource_id = Constant<sint04>::Invalid;     
        sint04 version_id = Constant<sint04>::Invalid;      
        HighCapacityBuffer<uint01> header;                  
        HighCapacityBuffer<uint01> message;                 
        Time time;                                          
    };

    struct ServerPermission : public ServerCredentials, public ResourceID
    {
        Buffer<EncodedMessage> user_permissions;            
        String permission_name;                         
        UUID link_password = Constant<UUID>::Invalid;   
        HighCapacityBuffer<uint01> encoded_resource_password; 
        HighCapacityBuffer<uint01> encoded_decrypt_password;  
        HighCapacityBuffer<uint01> encoded_link_password;     
        sint04 permission_id = Constant<sint04>::Invalid;   
        sint04 permission_owner_id = Constant<sint04>::Invalid; 
        TimeSpan lifespan = Constant<TimeSpan>::Invalid;    
        bool has_write_permissions = false;                 
        bool has_edit_permissions = false;                  
        bool allow_tree = false;                            
        bool allow_export = false;                          
        bool allow_measure = false;                         
        bool is_public = false;                             
        bool share_owner_info = false;                      
        bool link_shared = false;                           
        bool permission_read_validated = false;             
        bool permission_write_validated = false;            
    };

    struct ServerUserInfo : public ServerCredentials
    {
        String phone_number;                
        String email;                       
        Buffer<uint01> public_key;          
        Buffer<uint01> encoded_private_key; 
        bool is_public = false;             
    };

    struct ServerResourceInfo : public ResourceID
    {
        String mime_type;                   
        Buffer<uint01> icon;                
        String resource_info;               
        String categories;                  
        File cached_data;                   
        Time creation_time = Constant<Time>::Invalid;   
        Time modified_time = Constant<Time>::Invalid;   
        Time access_time = Constant<Time>::Invalid;     
        uint08 resource_size = Constant<uint08>::Invalid; 
    };
    class BinaryFile;
    class NDEVRSERVERCLIENT_API ServerActions
    {
    public:
        virtual ~ServerActions() {};
        //virtual ServerCommandReturn getUserInfo(ServerCredentials& credentials, ServerUserInfo& info) = 0;
        virtual ServerCommandReturn updateUserInfo(ServerCredentials& old_credentials, ServerUserInfo& new_credentials) = 0;
        virtual ServerCommandReturn getUserInfo(ServerCredentials& credentials, ServerUserInfo& new_credentials) = 0;
        virtual ServerCommandReturn addUser(ServerUserInfo& info) = 0;
        virtual ServerCommandReturn setUserActive(ServerCredentials& info, bool active) = 0;
        virtual ServerCommandReturn checkPermission(ServerPermission& resource, bool write_permission) = 0;
        virtual ServerCommandReturn deleteResource(ServerPermission& resource) = 0;
        virtual ServerCommandReturn deletePermission(ServerPermission& password) = 0;
        virtual ServerCommandReturn addMessages(ServerPermission& permission, Buffer<EncodedMessage>& message) = 0;
        virtual ServerCommandReturn getMessages(ServerPermission& permission, Buffer<EncodedMessage>& messages, TimeSpan span) = 0;
        virtual ServerCommandReturn getResource(ServerPermission& permission, ServerResourceInfo& Resource, bool download_preview, bool download_contents) = 0;
        virtual ServerCommandReturn getResourceVersions(Buffer<ServerResourceInfo>& versions, ServerPermission& permission, bool download_preview) = 0;
        virtual ServerCommandReturn addPermission(ServerPermission& our_permission, ServerPermission& new_permission) = 0;
        virtual ServerCommandReturn addResource(ServerPermission& permission, ServerResourceInfo& Resource) = 0;
        virtual ServerCommandReturn addOrUpdateLibaryObject(ServerPermission& credentials, UUID id, ServerResourceInfo& resource) = 0;
        virtual ServerCommandReturn getLibaryObject(ServerCredentials& credentials, UUID id, ServerResourceInfo& resource, bool download_preview, bool download_contents) = 0;
        virtual ServerCommandReturn getLibaryObjects(ServerCredentials& credentials, Buffer<ServerResourceInfo>& resources, bool download_preview) = 0;
        virtual ServerCommandReturn getUsers(Buffer<ServerUserInfo>& users, ServerCredentials& credentials, bool active = true, bool inactive = false, bool awaiting_aproval = false) = 0;
        virtual ServerCommandReturn getResourcePermissions(Buffer<ServerPermission>& permissions, ServerPermission& Resource) = 0;
        virtual ServerCommandReturn getOwnedResources(Buffer<ServerResourceInfo>& resources, ServerCredentials& credentials, bool download_preview) = 0;
        virtual ServerCommandReturn getSharedResources(Buffer<ServerResourceInfo>& resources, ServerCredentials& resource, bool download_preview) = 0;
        virtual ServerCommandReturn forceUserActive(ServerCredentials&, bool) { return ServerCommandReturn::e_not_supported; };
        virtual bool open(NDEVRServerInfo& info) = 0;
        virtual void logAction(const ServerCredentials&, const ServerCommandReturn&, uint04) {};
        virtual void close() = 0;
 
        static void EncodeCredentials(const ServerCredentials& credentials, BinaryFile& encoding);
        static void DecodeCredentials(ServerCredentials& credentials, BinaryFile& encoding);
        static void EncodeEncodedMessage(const EncodedMessage& message, BinaryFile& encoding);
        static void DecodeEncodedMessage(EncodedMessage& message, BinaryFile& encoding);
        static void EncodeEncodedMessages(const Buffer<EncodedMessage>& message, BinaryFile& encoding);
        static void DecodeEncodedMessages(Buffer<EncodedMessage>& message, BinaryFile& encoding);
        static void EncodeResourceInfo(const ServerResourceInfo& credentials, BinaryFile& encoding, bool decode_data);
        static void DecodeResourceInfo(ServerResourceInfo& credentials, BinaryFile& encoding, bool decode_data);
        static void EncodeResourceInfo(const Buffer<ServerResourceInfo>& files, BinaryFile& encoding, bool encode_data);
        static void DecodeResourceInfo(Buffer<ServerResourceInfo>& files, BinaryFile& encoding, bool decode_data);
        static void EncodeResourcePermission(const ServerPermission& password, BinaryFile& encoding, bool encode_credentials = true);
        static void DecodeResourcePermission(ServerPermission& password, BinaryFile& encoding, bool decode_credentials = true);
        static void EncodeResourcePermissions(const Buffer<ServerPermission>& permissions, BinaryFile& encoding);
        static void DecodeResourcePermissions(Buffer<ServerPermission>& permissions, BinaryFile& encoding);
        static void EncodeServerResponse(const ServerCommandReturn& response, BinaryFile& encoding);
        static void DecodeServerResponse(ServerCommandReturn& response, BinaryFile& encoding);
        static void EncodeUserInfo(const ServerUserInfo& info, BinaryFile& encoding);
        static void DecodeUserInfo(ServerUserInfo& info, BinaryFile& encoding);
        static void EncodeServerInfo(const ServerMainInfo& info, BinaryFile& encoding);
        static void DecodeServerInfo(ServerMainInfo& info, BinaryFile& encoding);
    };
}