18#include <wx/filename.h>
20#include <rapidjson/document.h>
21#include <rapidjson/writer.h>
45 return "audio/x-wavpack";
46 else if (ext ==
"flac")
47 return "audio/x-flac";
48 else if (ext ==
"mp3")
55 const wxString& filePath,
const wxString& projectName,
bool isPublic)
57 rapidjson::Document document;
60 const wxFileName fileName(filePath);
66 mimeType.data(), mimeType.length(), document.GetAllocator()),
67 document.GetAllocator());
71 if (!downloadMime.empty())
76 downloadMime.data(), downloadMime.length(),
77 document.GetAllocator()),
78 document.GetAllocator());
85 rapidjson::Value(
name.data(),
name.length(), document.GetAllocator()),
86 document.GetAllocator());
90 rapidjson::Value(
static_cast<int64_t
>(fileName.GetSize().GetValue())),
91 document.GetAllocator());
94 "public", rapidjson::Value(isPublic), document.GetAllocator());
96 rapidjson::StringBuffer buffer;
97 rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
98 document.Accept(writer);
100 return std::string(buffer.GetString());
105 rapidjson::Document document;
106 document.SetObject();
109 "progress", rapidjson::Value(current /
static_cast<double>(total) * 100.0),
110 document.GetAllocator());
112 rapidjson::StringBuffer buffer;
113 rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
114 document.Accept(writer);
116 return std::string(buffer.GetString());
121 rapidjson::StringStream stream(payloadText.c_str());
122 rapidjson::Document document;
124 document.ParseStream(stream);
126 if (!document.IsObject())
129 assert(document.IsObject());
135 auto readInt = [&document](
const char*
name) {
136 return document.HasMember(
name) && document[
name].IsInt() ?
137 document[
name].GetInt() :
141 auto readString = [&document](
const char*
name) ->
const char*
143 return document.HasMember(
name) && document[
name].IsString() ?
144 document[
name].GetString() :
148 payload.
code = readInt(
"code");
149 payload.
status = readInt(
"status");
151 payload.
name = readString(
"name");
152 payload.
message = readString(
"message");
154 if (document.HasMember(
"errors") && document[
"errors"].IsObject())
156 for (
auto& err : document[
"errors"].GetObject ())
158 if (!err.value.IsString())
162 err.name.GetString(), err.value.GetString());
175 std::enable_shared_from_this<UploadOperation>
179 wxString projectName,
bool isPublic,
182 : mServiceConfig(serviceConfig)
183 , mFileName(
std::move(fileName))
184 , mProjectName(
std::move(projectName))
185 , mIsPublic(isPublic)
186 , mCompletedCallback(
std::move(completedCallback))
187 , mProgressCallback(
std::move(progressCallback))
212 using Clock = std::chrono::steady_clock;
225 if (!mAuthToken.empty())
231 if (!language.empty())
240 std::lock_guard<std::mutex> lock(mStatusMutex);
244 std::lock_guard<std::mutex> callbacksLock(mCallbacksMutex);
246 if (mCompletedCallback)
252 mProgressCallback = {};
253 mCompletedCallback = {};
259 std::lock_guard<std::mutex> lock(mStatusMutex);
263 std::lock_guard<std::mutex> callbacksLock(mCallbacksMutex);
265 if (mCompletedCallback)
273 mProgressCallback = {};
274 mCompletedCallback = {};
289 mAuthToken = std::string(authToken);
290 SetRequiredHeaders(request);
294 std::lock_guard<std::mutex> lock(mStatusMutex);
301 request, payload.data(), payload.size());
303 mActiveResponse = response;
305 response->setRequestFinishedCallback(
306 [response, sharedThis = shared_from_this(),
this](
auto) {
307 auto responseCode = response->getHTTPCode();
309 if (responseCode == 201)
311 HandleUploadPolicy(response->readAll<std::string>());
313 else if (responseCode == 401)
317 response->readAll<std::string>());
319 else if (responseCode == 422)
323 response->readAll<std::string>());
329 response->readAll<std::string>());
338 rapidjson::Document document;
339 document.Parse(uploadPolicyJSON.data(), uploadPolicyJSON.length());
342 !document.HasMember(
"url") || !document.HasMember(
"success") ||
343 !document.HasMember(
"fail") || !document.HasMember(
"progress"))
352 auto form = std::make_unique<MultipartData>();
354 if (document.HasMember(
"fields"))
356 const auto& fields = document[
"fields"];
358 for (
auto it = fields.MemberBegin(); it != fields.MemberEnd(); ++it)
359 form->Add(it->name.GetString(), it->value.GetString());
362 const auto fileField =
363 document.HasMember(
"field") ? document[
"field"].GetString() :
"file";
365 const wxFileName
name { mFileName };
383 const auto url = document[
"url"].GetString();
385 mSuccessUrl = document[
"success"].GetString();
386 mFailureUrl = document[
"fail"].GetString();
387 mProgressUrl = document[
"progress"].GetString();
389 if (document.HasMember(
"extra"))
391 const auto& extra = document[
"extra"];
393 mAudioID = extra[
"audio"][
"id"].GetString();
394 mAudioSlug = extra[
"audio"][
"slug"].GetString();
396 if (extra.HasMember(
"token"))
397 mUploadToken = extra[
"token"].GetString();
400 const auto encType = document.HasMember(
"enctype") ?
401 document[
"enctype"].GetString() :
402 "multipart/form-data";
411 std::lock_guard<std::mutex> lock(mStatusMutex);
419 mActiveResponse = response;
421 response->setRequestFinishedCallback(
422 [response, sharedThis = shared_from_this(),
this](
auto)
424 HandleS3UploadCompleted(response);
427 response->setUploadProgressCallback(
428 [response, sharedThis = shared_from_this(),
429 this](
auto current,
auto total)
430 { HandleUploadProgress(current, total); });
436 std::lock_guard<std::mutex> callbacksLock(mCallbacksMutex);
438 if (mProgressCallback)
439 mProgressCallback(current, total);
442 const auto now = Clock::now();
446 mLastProgressReportTime = now;
458 std::lock_guard<std::mutex> lock(mStatusMutex);
464 request, payload.data(), payload.size());
466 response->setRequestFinishedCallback([response](
auto) {});
474 const auto responseCode = response->getHTTPCode();
477 responseCode == 200 || responseCode == 201 || responseCode == 204;
479 Request request(success ? mSuccessUrl : mFailureUrl);
480 SetRequiredHeaders(request);
482 std::lock_guard<std::mutex> lock(mStatusMutex);
490 mActiveResponse = finalResponse;
492 finalResponse->setRequestFinishedCallback(
493 [finalResponse, sharedThis = shared_from_this(),
this, success](
auto)
495 const auto httpCode = finalResponse->getHTTPCode();
496 if (success && httpCode >= 200 && httpCode < 300)
504 finalResponse->readAll<std::string>());
510 std::lock_guard<std::mutex> lock(mStatusMutex);
517 std::lock_guard<std::mutex> lock(mStatusMutex);
525 if (
auto activeResponse = mActiveResponse.lock())
526 activeResponse->abort();
529 std::lock_guard<std::mutex> callbacksLock(mCallbacksMutex);
531 if (mCompletedCallback)
534 mCompletedCallback = {};
535 mProgressCallback = {};
545 auto url = mServiceConfig.
GetAPIUrl(
"/audio");
546 url +=
"/" + mAudioID +
"?token=" + mUploadToken;
551 response->setRequestFinishedCallback(
561 : mServiceConfig(config), mOAuthService(service)
566 const wxString& fileName,
const wxString& projectName,
bool isPublic,
569 if (!wxFileExists(fileName))
571 if (completedCallback)
578 auto operation = std::make_shared<AudiocomUploadOperation>(
580 std::move(completedCallback), std::move(progressCallback));
583 { operation->InitiateUpload(authToken); });
591 std::shared_ptr<UploadOperation> operation)
592 : mOperation(
std::move(operation))
603UploadOperationHandle::operator bool() const noexcept
605 return mOperation !=
nullptr;
617 if (!wxDirExists(tempPath))
626 tempPath,
XO(
"Cannot proceed to upload.")))
629 return tempPath +
"/cloud/";
637 if (!wxDirExists(tempPath))
642 wxDir::GetAllFiles(tempPath, &files, {}, wxDIR_FILES);
644 for (
const auto& file : files)
Declare abstract class AudacityException, some often-used subclasses, and GuardedCall.
Declare functions to perform UTF-8 to std::wstring conversions.
const TranslatableString name
Declare an interface for HTTP response.
Declare a class for performing HTTP requests.
Declare a class for constructing HTTP requests.
Subscription Subscribe(Callback callback)
Connect a callback to the Publisher; later-connected are called earlier.
Request & setHeader(const std::string &name, std::string value)
Service responsible for OAuth authentication against the audio.com service.
void ValidateAuth(std::function< void(std::string_view)> completedHandler)
Attempt to authorize the user.
Configuration for the audio.com.
std::string GetAcceptLanguageValue() const
Returns the preferred language.
std::string GetAPIUrl(std::string_view apiURI) const
Helper to construct the full URLs for the API.
std::chrono::milliseconds GetProgressCallbackTimeout() const
Timeout between progress callbacks.
MimeType GetDownloadMime() const
Return the mime type server should store the file. This is a requirement from audiocom.
A unique_ptr like class that holds a pointer to UploadOperation.
UploadOperationHandle()=default
UploadOperation * operator->() const noexcept
std::shared_ptr< UploadOperation > mOperation
Class used to track the upload operation.
virtual ~UploadOperation()
std::function< void(uint64_t current, uint64_t total)> ProgressCallback
OAuthService & mOAuthService
UploadOperationHandle Upload(const wxString &fileName, const wxString &projectName, bool isPublic, CompletedCallback completedCallback, ProgressCallback progressCallback)
Uploads the file to audio.com.
const ServiceConfig & mServiceConfig
UploadService(const ServiceConfig &config, OAuthService &service)
std::function< void(const UploadOperationCompleted &)> CompletedCallback
FILES_API bool WritableLocationCheck(const FilePath &path, const TranslatableString &message)
Check location on writable access and return true if checked successfully.
FILES_API const FilePath & DefaultTempDir()
FILES_API Observer::Publisher< FilePath > & GetTempPathObserver()
FrameStatistics & GetInstance() noexcept
const std::string ApplicationJson
std::string ToUTF8(const std::wstring &wstr)
std::string GetProgressPayload(uint64_t current, uint64_t total)
UploadFailedPayload ParseUploadFailedMessage(const std::string &payloadText)
std::string_view DeduceMimeType(const wxString &ext)
const auto tempChangedSubscription
std::string GetUploadRequestPayload(const wxString &filePath, const wxString &projectName, bool isPublic)
wxString GetUploadTempPath()
const ServiceConfig & GetServiceConfig()
Returns the instance of the ServiceConfig.
This structure represents an upload error as returned by the server.
std::vector< AdditionalError > additionalErrors
Result
Result of the upload.
@ FileNotFound
Specified file is not found.
@ InvalidData
audio.com has failed to understand what Audacity wants
@ Success
Upload was successful.
@ Aborted
Upload was aborted by the user.
@ UnexpectedResponse
Audacity has failed to understand audio.com response.
@ UploadFailed
Upload failed for some other reason.
@ Unauthorized
Authorization is required.
This structure represents the payload associated with successful upload.
void HandleS3UploadCompleted(std::shared_ptr< audacity::network_manager::IResponse > response)
AudiocomUploadOperation(const ServiceConfig &serviceConfig, wxString fileName, wxString projectName, bool isPublic, UploadService::CompletedCallback completedCallback, UploadService::ProgressCallback progressCallback)
const ServiceConfig & mServiceConfig
void Abort() override
Abort the upload, if running.
UploadService::ProgressCallback mProgressCallback
void SetRequiredHeaders(audacity::network_manager::Request &request) const
UploadService::CompletedCallback mCompletedCallback
std::mutex mCallbacksMutex
void HandleUploadProgress(uint64_t current, uint64_t total)
const wxString mProjectName
void FailPromise(UploadOperationCompleted::Result result, std::string errorMessage)
void DiscardResult() override
Clock::time_point mLastProgressReportTime
bool IsCompleted() override
Returns true if the upload is finished.
std::chrono::steady_clock Clock
std::weak_ptr< audacity::network_manager::IResponse > mActiveResponse
void HandleUploadPolicy(std::string uploadPolicyJSON)
void InitiateUpload(std::string_view authToken)