Server/SourceFiles/Services/FileService.cpp - master - Shymer123/LumenServer

Server/SourceFiles/Services/FileService.cpp
219 строк6 KB
Shymer123
fixed the build via Docker, now everything is going correctly.
26 июн 2026, 18:02
26 июн 2026, 18:0217a48df
#include "FileService.h"
#include "Core/System/ConfigPaths.h"
#include "Data/Mappers/FileMapper.h"
#include "Core/Utils/FileUtils.h"
#include <fstream>
#include <filesystem>
#include <utility>

namespace Services {

    FileService::FileService(Storage::Db::Repositories::FileRepository& fileRepo)
        : m_fileRepo(fileRepo)
    {}

    void FileService::startUploadSession(const Data::Models::FileAttachment& baseInfo, const std::string& checksum)
    {
        std::lock_guard<std::mutex> lock(m_mutex);

        std::string fileId = baseInfo.id;

        Data::Models::FileTransferInfo transferInfo;
        transferInfo.baseInfo = baseInfo;
        transferInfo.checksum = checksum;

        m_uploadFiles[fileId] = transferInfo;
    }

    bool FileService::uploadChunk(const std::string& fileId, int64_t offset, size_t length,
                                  const std::vector<std::byte>& data)
    {
        std::lock_guard<std::mutex> lock(m_mutex);

        if(m_uploadFiles.find(fileId) == m_uploadFiles.end())
        {
            return false;
        }

        auto& transferInfo = m_uploadFiles[fileId];
        if(transferInfo.isCompleted())
        {
            return false;
        }

        std::string filePath = getFilePath(fileId);
        std::ofstream file(filePath, std::ios::binary | std::ios::in | std::ios::out);

        if(!file)
        {
            return false;
        }

        file.seekp(offset, std::ios::beg);
        file.write(reinterpret_cast<const char*>(data.data()), length);
        file.close();

        transferInfo.bytesReceived += length;

        return true;
    }

    FileService::FileOperationResult FileService::completeUpload(const std::string& fileId)
    {
        std::lock_guard<std::mutex> lock(m_mutex);

        FileOperationResult result;
        result.fileId = fileId;

        if(m_uploadFiles.find(fileId) == m_uploadFiles.end())
        {
            result.errorMessage = "file not found";
            return result;
        }

        auto& session = m_uploadFiles[fileId];
        if(!session.isCompleted())
        {
            result.errorMessage = "incomplete download";
            return result;
        }

        std::string actualChecksum = Core::Utils::FileUtils::calculateChecksum(getFilePath(fileId));
        if(actualChecksum != session.checksum)
        {
            result.errorMessage = "checksum mismatch";
            return result;
        }

        result.success = true;
        m_uploadFiles.erase(fileId);

        return result;
    }

    bool FileService::cancelUpload(const std::string& fileId)
    {
        std::lock_guard<std::mutex> lock(m_mutex);

        if(m_uploadFiles.find(fileId) == m_uploadFiles.end())
        {
            return false;
        }

        std::string filePath = getFilePath(fileId);
        if(std::filesystem::exists(filePath))
        {
            std::filesystem::remove(filePath);
        }

        m_uploadFiles.erase(fileId);

        return true;
    }

    Data::Models::FileTransferInfo FileService::startDownloadSession(const std::string& fileId)
    {
        std::lock_guard<std::mutex> lock(m_mutex);

        std::string filePath = getFilePath(fileId);
        if(!std::filesystem::exists(filePath))
        {
            throw std::runtime_error("File not found");
        }

        Data::Models::FileTransferInfo transferInfo;
        transferInfo.baseInfo = getFileInfo(fileId);
        transferInfo.checksum = Core::Utils::FileUtils::calculateChecksum(filePath);

        return transferInfo;
    }

    std::vector<std::byte> FileService::downloadChunk(const std::string& fileId, size_t offset, size_t length)
    {
        std::string filePath = getFilePath(fileId);
        std::ifstream file(filePath, std::ios::binary);
        size_t fileSize = std::filesystem::file_size(filePath);

        if(!file)
        {
            throw std::runtime_error("File not found");
        }

        file.seekg(offset, std::ios::beg);
        if (offset >= fileSize) {
            throw std::runtime_error("offset out of range");
        }

        size_t bytesToRead = std::min(length, fileSize - offset);

        std::vector<std::byte> chunk(bytesToRead);
        file.read(reinterpret_cast<char*>(chunk.data()), bytesToRead);
        chunk.resize(file.gcount());

        return chunk;
    }

    Data::Models::FileAttachment FileService::getFileInfo(const std::string& fileId) const
    {
        std::string filePath = getFilePath(fileId);

        if(!std::filesystem::exists(filePath))
        {
            throw std::runtime_error("File not found");
        }

        Data::Models::FileAttachment info;
        info.id = fileId;
        info.size = std::filesystem::file_size(filePath);

        return info;
    }

    Data::Models::FileTransferInfo FileService::getUploadStatus(const std::string& fileId)
    {
        std::lock_guard<std::mutex> lock(m_mutex);

        if(m_uploadFiles.find(fileId) == m_uploadFiles.end())
        {
            throw std::runtime_error("Upload session not found");
        }

        return m_uploadFiles.at(fileId);
    }

    bool FileService::saveFileMeta(const Data::Models::FileAttachment& model,
                                   const std::string& messageId,
                                   const std::string& storagePath)
    {
        auto entity = Data::Mappers::FileMapper::toEntity(model, messageId, storagePath);
        return m_fileRepo.saveFileMetadata(entity);
    }

    std::vector<Data::Models::FileAttachment> FileService::getFilesByMessageId(const std::string& messageId)
    {
        auto entities = m_fileRepo.getFilesByMessageId(messageId);

        std::vector<Data::Models::FileAttachment> result;

        if(!entities) return result;

        result.reserve(entities->size());

        for(const auto& e : std::as_const(*entities))
        {
            result.push_back(Data::Mappers::FileMapper::toModel(e));
        }
        return result;
    }

    bool FileService::deleteFile(const std::string& fileId)
    {
        return m_fileRepo.deleteFile(fileId);
    }

    std::string FileService::getFilePath(const std::string& fileId) const
    {
        return Core::System::ConfigPaths::filesDir() + "/" + fileId + ".bin";
    }

} // namespace Services