1 #ifndef SEAFILE_CLIENT_API_REQUESTS_H 2 #define SEAFILE_CLIENT_API_REQUESTS_H 3 4 #include <QMap> 5 #include <QScopedPointer> 6 #include <vector> 7 8 #include "account.h" 9 #include "api-request.h" 10 #include "contact-share-info.h" 11 #include "server-repo.h" 12 #include "server-repo.h" 13 14 class QNetworkReply; 15 class QImage; 16 class QStringList; 17 18 class ServerRepo; 19 class Account; 20 class StarredItem; 21 class SeafEvent; 22 class CommitDetails; 23 24 class PingServerRequest : public SeafileApiRequest 25 { 26 Q_OBJECT 27 public: 28 PingServerRequest(const QUrl& serverAddr); 29 30 protected slots: 31 void requestSuccess(QNetworkReply& reply); 32 33 signals: 34 void success(); 35 36 private: 37 Q_DISABLE_COPY(PingServerRequest) 38 }; 39 40 class LoginRequest : public SeafileApiRequest 41 { 42 Q_OBJECT 43 44 public: 45 LoginRequest(const QUrl& serverAddr, 46 const QString& username, 47 const QString& password, 48 const QString& computer_name); 49 50 protected slots: 51 void requestSuccess(QNetworkReply& reply); 52 53 signals: 54 void success(const QString& token, const QString& s2fa_token); 55 56 private: 57 Q_DISABLE_COPY(LoginRequest) 58 }; 59 60 61 class ListReposRequest : public SeafileApiRequest 62 { 63 Q_OBJECT 64 65 public: 66 explicit ListReposRequest(const Account& account); 67 68 protected slots: 69 void requestSuccess(QNetworkReply& reply); 70 71 signals: 72 void success(const std::vector<ServerRepo>& repos); 73 74 private: 75 Q_DISABLE_COPY(ListReposRequest) 76 }; 77 78 79 class RepoDownloadInfo 80 { 81 public: 82 int repo_version; 83 QString email; 84 QString token; 85 QString repo_id; 86 QString repo_name; 87 bool encrypted; 88 bool readonly; 89 int enc_version; 90 QString magic; 91 QString random_key; 92 QString more_info; 93 94 static RepoDownloadInfo fromDict(QMap<QString, QVariant>& dict, 95 const QUrl& url, 96 bool read_only); 97 }; 98 99 class DownloadRepoRequest : public SeafileApiRequest 100 { 101 Q_OBJECT 102 103 public: 104 explicit DownloadRepoRequest(const Account& account, 105 const QString& repo_id, 106 bool read_only); 107 108 protected slots: 109 void requestSuccess(QNetworkReply& reply); 110 111 signals: 112 void success(const RepoDownloadInfo& info); 113 114 private: 115 Q_DISABLE_COPY(DownloadRepoRequest) 116 117 bool read_only_; 118 }; 119 120 class GetRepoRequest : public SeafileApiRequest 121 { 122 Q_OBJECT 123 124 public: 125 explicit GetRepoRequest(const Account& account, const QString& repoid); 126 const QString& repoid() 127 { 128 return repoid_; 129 } 130 131 protected slots: 132 void requestSuccess(QNetworkReply& reply); 133 134 signals: 135 void success(const ServerRepo& repo); 136 137 private: 138 Q_DISABLE_COPY(GetRepoRequest) 139 const QString repoid_; 140 }; 141 142 class CreateRepoRequest : public SeafileApiRequest 143 { 144 Q_OBJECT 145 146 public: 147 CreateRepoRequest(const Account& account, 148 const QString& name, 149 const QString& desc, 150 const QString& passwd); 151 CreateRepoRequest(const Account& account, 152 const QString& name, 153 const QString& desc, 154 int enc_version, 155 const QString& repo_id, 156 const QString& magic, 157 const QString& random_key); 158 // Constructor for seafile encryption v3 159 CreateRepoRequest(const Account& account, 160 const QString& name, 161 const QString& desc, 162 int enc_version, 163 const QString& repo_id, 164 const QString& magic, 165 const QString& random_key, 166 const QString& salt); 167 168 protected slots: 169 void requestSuccess(QNetworkReply& reply); 170 171 signals: 172 void success(const RepoDownloadInfo& info); 173 174 private: 175 Q_DISABLE_COPY(CreateRepoRequest) 176 }; 177 178 class CreateSubrepoRequest : public SeafileApiRequest 179 { 180 Q_OBJECT 181 182 public: 183 explicit CreateSubrepoRequest(const Account& account, 184 const QString& name, 185 const QString& repoid, 186 const QString& path, 187 const QString& passwd); 188 189 protected slots: 190 void requestSuccess(QNetworkReply& reply); 191 192 signals: 193 void success(const QString& sub_repoid); 194 195 private: 196 Q_DISABLE_COPY(CreateSubrepoRequest) 197 }; 198 199 class GetUnseenSeahubNotificationsRequest : public SeafileApiRequest 200 { 201 Q_OBJECT 202 203 public: 204 explicit GetUnseenSeahubNotificationsRequest(const Account& account); 205 206 protected slots: 207 void requestSuccess(QNetworkReply& reply); 208 209 signals: 210 void success(int count); 211 212 private: 213 Q_DISABLE_COPY(GetUnseenSeahubNotificationsRequest) 214 }; 215 216 class GetDefaultRepoRequest : public SeafileApiRequest 217 { 218 Q_OBJECT 219 public: 220 GetDefaultRepoRequest(const Account& account); 221 222 signals: 223 void success(bool exists, const QString& repo_id); 224 225 protected slots: 226 void requestSuccess(QNetworkReply& reply); 227 228 private: 229 Q_DISABLE_COPY(GetDefaultRepoRequest); 230 }; 231 232 class CreateDefaultRepoRequest : public SeafileApiRequest 233 { 234 Q_OBJECT 235 public: 236 CreateDefaultRepoRequest(const Account& account); 237 238 signals: 239 void success(const QString& repo_id); 240 241 protected slots: 242 void requestSuccess(QNetworkReply& reply); 243 244 private: 245 Q_DISABLE_COPY(CreateDefaultRepoRequest); 246 }; 247 248 class GetStarredFilesRequest : public SeafileApiRequest 249 { 250 Q_OBJECT 251 public: 252 GetStarredFilesRequest(const Account& account); 253 254 signals: 255 void success(const std::vector<StarredItem>& starred_files); 256 257 protected slots: 258 void requestSuccess(QNetworkReply& reply); 259 260 private: 261 Q_DISABLE_COPY(GetStarredFilesRequest); 262 }; 263 264 // get starred item api v2.1 265 class GetStarredFilesRequestV2 : public SeafileApiRequest 266 { 267 Q_OBJECT 268 public: 269 GetStarredFilesRequestV2(const Account& account); 270 271 signals: 272 void success(const std::vector<StarredItem>& starred_files); 273 274 protected slots: 275 void requestSuccess(QNetworkReply& reply); 276 277 private: 278 Q_DISABLE_COPY(GetStarredFilesRequestV2); 279 }; 280 281 class GetEventsRequest : public SeafileApiRequest 282 { 283 Q_OBJECT 284 public: 285 GetEventsRequest(const Account& account, int start = 0); 286 287 signals: 288 void success(const std::vector<SeafEvent>& events, int more_offset); 289 290 protected slots: 291 void requestSuccess(QNetworkReply& reply); 292 293 private: 294 Q_DISABLE_COPY(GetEventsRequest); 295 }; 296 297 class GetEventsRequestV2 : public SeafileApiRequest 298 { 299 Q_OBJECT 300 public: 301 GetEventsRequestV2(const Account& account, int page = 1, int perpage = 25, int avatar_size = 36); 302 303 signals: 304 void success(const std::vector<SeafEvent>& events); 305 306 protected slots: 307 void requestSuccess(QNetworkReply& reply); 308 309 private: 310 Q_DISABLE_COPY(GetEventsRequestV2); 311 }; 312 313 class GetCommitDetailsRequest : public SeafileApiRequest 314 { 315 Q_OBJECT 316 public: 317 GetCommitDetailsRequest(const Account& account, 318 const QString& repo_id, 319 const QString& commit_id); 320 321 signals: 322 void success(const CommitDetails& result); 323 324 protected slots: 325 void requestSuccess(QNetworkReply& reply); 326 327 private: 328 Q_DISABLE_COPY(GetCommitDetailsRequest); 329 }; 330 331 class FetchImageRequest : public SeafileApiRequest 332 { 333 Q_OBJECT 334 public: 335 FetchImageRequest(const QString& img_url); 336 337 signals: 338 void success(const QImage& avatar); 339 340 protected slots: 341 void requestSuccess(QNetworkReply& reply); 342 343 private: 344 Q_DISABLE_COPY(FetchImageRequest); 345 }; 346 347 class GetAvatarRequest : public SeafileApiRequest 348 { 349 Q_OBJECT 350 public: 351 GetAvatarRequest(const Account& account, 352 const QString& email, 353 qint64 mtime, 354 int size); 355 356 ~GetAvatarRequest(); 357 358 const QString& email() const 359 { 360 return email_; 361 } 362 const Account& account() const 363 { 364 return account_; 365 } 366 qint64 mtime() const 367 { 368 return mtime_; 369 } 370 371 signals: 372 void success(const QImage& avatar); 373 374 protected slots: 375 void requestSuccess(QNetworkReply& reply); 376 377 private: 378 Q_DISABLE_COPY(GetAvatarRequest); 379 380 FetchImageRequest* fetch_img_req_; 381 382 QString email_; 383 384 Account account_; 385 386 qint64 mtime_; 387 }; 388 389 class SetRepoPasswordRequest : public SeafileApiRequest 390 { 391 Q_OBJECT 392 public: 393 SetRepoPasswordRequest(const Account& account, 394 const QString& repo_id, 395 const QString& password); 396 397 signals: 398 void success(); 399 400 protected slots: 401 void requestSuccess(QNetworkReply& reply); 402 403 private: 404 Q_DISABLE_COPY(SetRepoPasswordRequest); 405 }; 406 407 class ServerInfoRequest : public SeafileApiRequest 408 { 409 Q_OBJECT 410 public: 411 ServerInfoRequest(const Account& account); 412 413 signals: 414 void success(const Account& account, const ServerInfo& info); 415 416 protected slots: 417 void requestSuccess(QNetworkReply& reply); 418 419 private: 420 Q_DISABLE_COPY(ServerInfoRequest); 421 const Account account_; 422 }; 423 424 class LogoutDeviceRequest : public SeafileApiRequest 425 { 426 Q_OBJECT 427 public: 428 LogoutDeviceRequest(const Account& account); 429 430 const Account& account() 431 { 432 return account_; 433 } 434 435 signals: 436 void success(); 437 438 protected slots: 439 void requestSuccess(QNetworkReply& reply); 440 441 private: 442 Q_DISABLE_COPY(LogoutDeviceRequest); 443 444 Account account_; 445 }; 446 447 class SingleBatchRepoTokensRequest : public SeafileApiRequest 448 { 449 Q_OBJECT 450 public: 451 SingleBatchRepoTokensRequest(const Account& account, const QStringList& repo_ids); 452 453 const QMap<QString, QString>& repoTokens() const 454 { 455 return repo_tokens_; 456 } 457 458 const QStringList repoIds() const { 459 return repo_ids_; 460 } 461 462 signals: 463 void success(); 464 465 protected slots: 466 void requestSuccess(QNetworkReply& reply); 467 468 private: 469 Q_DISABLE_COPY(SingleBatchRepoTokensRequest); 470 471 QStringList repo_ids_; 472 QMap<QString, QString> repo_tokens_; 473 }; 474 475 // Request repo sync tokens from the server, and break the request into batches 476 // if there are too many, to avoid request URI too large. 477 class GetRepoTokensRequest : public SeafileApiRequest 478 { 479 Q_OBJECT 480 public: 481 GetRepoTokensRequest(const Account& account, const QStringList& repo_ids, int max_retry, int batch_size=50); 482 483 virtual void send() Q_DECL_OVERRIDE; 484 485 const QMap<QString, QString>& repoTokens() const 486 { 487 return repo_tokens_; 488 } 489 490 int maxRetries() const { return max_retries_; } 491 const QStringList& repoIds() const { return repo_ids_; } 492 const Account& account() const 493 { 494 return account_; 495 } 496 497 signals: 498 void success(); 499 500 protected slots: 501 void requestSuccess(QNetworkReply& reply); 502 503 private slots: 504 void batchSuccess(); 505 506 private: 507 Q_DISABLE_COPY(GetRepoTokensRequest); 508 509 void doNextBatch(); 510 511 Account account_; 512 QStringList repo_ids_; 513 QMap<QString, QString> repo_tokens_; 514 int max_retries_; 515 516 // The start position of the next batch 517 int batch_offset_; 518 // How many tokens to ask in a single request 519 int batch_size_; 520 521 QScopedPointer<SingleBatchRepoTokensRequest, QScopedPointerDeleteLater> batch_req_; 522 }; 523 524 class GetLoginTokenRequest : public SeafileApiRequest 525 { 526 Q_OBJECT 527 public: 528 GetLoginTokenRequest(const Account& account, const QString& next_url); 529 530 const Account& account() 531 { 532 return account_; 533 } 534 const QString& nextUrl() 535 { 536 return next_url_; 537 } 538 539 signals: 540 void success(const QString& token); 541 542 protected slots: 543 void requestSuccess(QNetworkReply& reply); 544 545 private: 546 Q_DISABLE_COPY(GetLoginTokenRequest); 547 548 Account account_; 549 QString next_url_; 550 }; 551 552 struct FileSearchResult { 553 QString repo_id; 554 QString repo_name; 555 QString name; 556 QString oid; 557 qint64 last_modified; 558 QString fullpath; 559 qint64 size; 560 bool is_dir; 561 }; 562 563 Q_DECLARE_METATYPE(FileSearchResult) 564 565 class FileSearchRequest : public SeafileApiRequest 566 { 567 Q_OBJECT 568 public: 569 FileSearchRequest(const Account& account, 570 const QString& keyword, 571 int page = 0, 572 int per_page = 10, 573 const QString& repo_id = QString()); 574 const QString& keyword() const 575 { 576 return keyword_; 577 } 578 579 signals: 580 void success(const std::vector<FileSearchResult>& result, 581 bool is_loading_more, 582 bool has_more); 583 584 protected slots: 585 void requestSuccess(QNetworkReply& reply); 586 587 private: 588 Q_DISABLE_COPY(FileSearchRequest); 589 590 const QString keyword_; 591 const int page_; 592 }; 593 594 class FetchCustomLogoRequest : public SeafileApiRequest 595 { 596 Q_OBJECT 597 public: 598 FetchCustomLogoRequest(const QUrl& url); 599 600 signals: 601 void success(const QUrl& url); 602 603 protected slots: 604 void requestSuccess(QNetworkReply& reply); 605 606 private: 607 Q_DISABLE_COPY(FetchCustomLogoRequest); 608 }; 609 610 class FetchAccountInfoRequest : public SeafileApiRequest 611 { 612 Q_OBJECT 613 public: 614 FetchAccountInfoRequest(const Account& account); 615 616 const Account& account() const 617 { 618 return account_; 619 } 620 621 signals: 622 void success(const AccountInfo& info); 623 624 protected slots: 625 void requestSuccess(QNetworkReply& reply); 626 627 private: 628 Q_DISABLE_COPY(FetchAccountInfoRequest); 629 630 Account account_; 631 }; 632 633 class PrivateShareRequest : public SeafileApiRequest 634 { 635 Q_OBJECT 636 public: 637 enum ShareOperation { 638 ADD_SHARE, 639 UPDATE_SHARE, 640 REMOVE_SHARE, 641 }; 642 PrivateShareRequest(const Account& account, 643 const QString& repo_id, 644 const QString& path, 645 const SeafileUser& user, 646 int group_id, 647 SharePermission permission, 648 ShareType share_type, 649 ShareOperation op); 650 651 ShareOperation shareOperation() const 652 { 653 return share_operation_; 654 } 655 656 int groupId() const 657 { 658 return share_type_ == SHARE_TO_GROUP ? group_id_ : -1; 659 }; 660 661 SeafileUser user() const 662 { 663 return share_type_ == SHARE_TO_USER ? user_ : SeafileUser(); 664 }; 665 666 SharePermission permission() const 667 { 668 return permission_; 669 } 670 671 ShareType shareType() const 672 { 673 return share_type_; 674 } 675 676 signals: 677 void success(); 678 679 protected slots: 680 void requestSuccess(QNetworkReply& reply); 681 682 private: 683 Q_DISABLE_COPY(PrivateShareRequest); 684 685 int group_id_; 686 SeafileUser user_; 687 SharePermission permission_; 688 ShareType share_type_; 689 ShareOperation share_operation_; 690 }; 691 692 class GetPrivateShareItemsRequest : public SeafileApiRequest 693 { 694 Q_OBJECT 695 public: 696 GetPrivateShareItemsRequest(const Account& account, 697 const QString& repo_id, 698 const QString& path); 699 700 signals: 701 void success(const QList<GroupShareInfo>&, const QList<UserShareInfo>&); 702 703 protected slots: 704 void requestSuccess(QNetworkReply& reply); 705 706 private: 707 Q_DISABLE_COPY(GetPrivateShareItemsRequest); 708 }; 709 710 class FetchGroupsAndContactsRequest : public SeafileApiRequest 711 { 712 Q_OBJECT 713 public: 714 FetchGroupsAndContactsRequest(const Account& account); 715 716 signals: 717 void success(const QList<SeafileGroup>&, const QList<SeafileUser>&); 718 719 protected slots: 720 void requestSuccess(QNetworkReply& reply); 721 722 private: 723 Q_DISABLE_COPY(FetchGroupsAndContactsRequest); 724 }; 725 726 727 class RemoteWipeReportRequest : public SeafileApiRequest 728 { 729 Q_OBJECT 730 public: 731 RemoteWipeReportRequest(const Account& account); 732 733 signals: 734 void success(); 735 736 protected slots: 737 void requestSuccess(QNetworkReply& reply); 738 739 private: 740 Q_DISABLE_COPY(RemoteWipeReportRequest); 741 }; 742 743 class SearchUsersRequest : public SeafileApiRequest 744 { 745 Q_OBJECT 746 public: 747 SearchUsersRequest(const Account& account, const QString& pattern); 748 749 QString pattern() const { return pattern_; } 750 751 signals: 752 void success(const QList<SeafileUser>& users); 753 754 protected slots: 755 void requestSuccess(QNetworkReply& reply); 756 757 private: 758 Q_DISABLE_COPY(SearchUsersRequest); 759 760 QString pattern_; 761 }; 762 763 class FetchGroupsRequest : public SeafileApiRequest 764 { 765 Q_OBJECT 766 public: 767 FetchGroupsRequest(const Account& account); 768 769 signals: 770 void success(const QList<SeafileGroup>&); 771 772 protected slots: 773 void requestSuccess(QNetworkReply& reply); 774 775 private: 776 Q_DISABLE_COPY(FetchGroupsRequest); 777 }; 778 779 class GetThumbnailRequest : public SeafileApiRequest 780 { 781 Q_OBJECT 782 public: 783 GetThumbnailRequest(const Account& account, 784 const QString& repo_id, 785 const QString& path, 786 const QString& dirent_id, 787 uint size); 788 789 const Account& account() const 790 { 791 return account_; 792 } 793 const QString& repoId() const 794 { 795 return repo_id_; 796 } 797 const QString& path() const 798 { 799 return path_; 800 } 801 const QString& direntId() const 802 { 803 return dirent_id_; 804 } 805 uint size() const 806 { 807 return size_; 808 } 809 signals: 810 void success(const QPixmap& thumbnail); 811 812 protected slots: 813 void requestSuccess(QNetworkReply& reply); 814 815 private: 816 Q_DISABLE_COPY(GetThumbnailRequest); 817 Account account_; 818 QString repo_id_; 819 QString path_; 820 QString dirent_id_; 821 uint size_; 822 }; 823 824 class UnshareRepoRequest : public SeafileApiRequest 825 { 826 Q_OBJECT 827 public: 828 UnshareRepoRequest(const Account& account, 829 const QString& repo_id, 830 const QString& from_user); 831 832 const QString& repoId() { return repo_id_; } 833 834 signals: 835 void success(); 836 837 protected slots: 838 void requestSuccess(QNetworkReply& reply); 839 840 private: 841 Q_DISABLE_COPY(UnshareRepoRequest); 842 843 QString repo_id_; 844 }; 845 846 struct UploadLinkInfo { 847 QString username; 848 QString repo_id; 849 QString ctime; 850 QString token; 851 QString link; 852 QString path; 853 }; 854 855 class CreateFileUploadLinkRequest : public SeafileApiRequest 856 { 857 Q_OBJECT 858 public: 859 CreateFileUploadLinkRequest(const Account& account, 860 const QString& repo_id, 861 const QString& path, 862 const QString& password = QString()); 863 864 signals: 865 void success(const UploadLinkInfo& link_info); 866 867 protected slots: 868 void requestSuccess(QNetworkReply& reply); 869 870 private: 871 Q_DISABLE_COPY(CreateFileUploadLinkRequest); 872 QString repo_id_; 873 QString path_; 874 QString password_; 875 }; 876 877 class GetUploadFileLinkRequest : public SeafileApiRequest 878 { 879 Q_OBJECT 880 public: 881 GetUploadFileLinkRequest(const QString& link); 882 883 signals: 884 void success(const QString& url); 885 886 protected slots: 887 void requestSuccess(QNetworkReply& reply); 888 889 private: 890 Q_DISABLE_COPY(GetUploadFileLinkRequest); 891 }; 892 893 #endif // SEAFILE_CLIENT_API_REQUESTS_H 894