From 3e4aa6908cb22789b13786d9aa3a2021a94f4005 Mon Sep 17 00:00:00 2001
From: Joan Bruguera <joanbrugueram@gmail.com>
Date: Sun, 3 Jun 2018 00:18:31 +0200
Subject: [PATCH] Instead of downloading pregenerated backup ZIPs (which now
 require a manual login they previously didn't), generate the backups, keeping
 the exact same ZIP layout, from the Todoist API, which still works correctly.

---
 README.md                                     |  10 +-
 experiment-webapp/index.html                  |   2 +-
 .../backup_downloader.py                      |  39 +++---
 todoist_full_offline_backup/controller.py     |  49 +-------
 todoist_full_offline_backup/frontend.py       |  32 +----
 todoist_full_offline_backup/runtime.py        |   8 +-
 .../integration_files/expected/BackupList.txt |   3 -
 .../expected/TodoistBackupNoAttach.zip        | Bin 0 -> 3314 bytes
 ...-25 10_13.zip => TodoistBackupWAttach.zip} | Bin
 .../Project_2181147709.csv}                   | Bin 6201 -> 4497 bytes
 .../sources/Project_2181147711.csv            |   1 +
 .../sources/Project_2181147712.csv            |   1 +
 .../sources/Project_2181147713.csv            |   1 +
 .../sources/Project_2181147714.csv            |   1 +
 .../sources/Project_2181147715.csv            |   1 +
 .../sources/Project_2181147955.csv            |   4 +
 .../d786b8464e642890cd575bdefc87dcda.zip      | Bin 6201 -> 0 bytes
 .../f9610a4296c5deaf536de3fc9bfd113a.zip      | Bin 6317 -> 0 bytes
 .../sources/get_backups.json                  |   1 -
 .../sources/project_list.json                 |  91 ++++++++++++++
 .../test_backup_attachments_downloader.py     |   2 +-
 .../tests/test_backup_downloader.py           |  77 +-----------
 .../tests/test_controller.py                  | 111 +++---------------
 .../tests/test_frontend.py                    |  66 ++---------
 .../tests/test_integration.py                 |  63 +++++-----
 .../tests/test_runtime.py                     |   4 -
 .../tests/test_todoist_api.py                 |  61 +++++-----
 todoist_full_offline_backup/todoist_api.py    |  56 +++++----
 todoist_full_offline_backup/utils.py          |   2 +-
 29 files changed, 253 insertions(+), 433 deletions(-)
 delete mode 100644 todoist_full_offline_backup/tests/integration_files/expected/BackupList.txt
 create mode 100644 todoist_full_offline_backup/tests/integration_files/expected/TodoistBackupNoAttach.zip
 rename todoist_full_offline_backup/tests/integration_files/expected/{TodoistBackupWAttach_2018-03-25 10_13.zip => TodoistBackupWAttach.zip} (100%)
 rename todoist_full_offline_backup/tests/integration_files/{expected/TodoistBackup_2018-03-25 10_12.zip => sources/Project_2181147709.csv} (63%)
 create mode 100644 todoist_full_offline_backup/tests/integration_files/sources/Project_2181147711.csv
 create mode 100644 todoist_full_offline_backup/tests/integration_files/sources/Project_2181147712.csv
 create mode 100644 todoist_full_offline_backup/tests/integration_files/sources/Project_2181147713.csv
 create mode 100644 todoist_full_offline_backup/tests/integration_files/sources/Project_2181147714.csv
 create mode 100644 todoist_full_offline_backup/tests/integration_files/sources/Project_2181147715.csv
 create mode 100644 todoist_full_offline_backup/tests/integration_files/sources/Project_2181147955.csv
 delete mode 100644 todoist_full_offline_backup/tests/integration_files/sources/d786b8464e642890cd575bdefc87dcda.zip
 delete mode 100644 todoist_full_offline_backup/tests/integration_files/sources/f9610a4296c5deaf536de3fc9bfd113a.zip
 delete mode 100644 todoist_full_offline_backup/tests/integration_files/sources/get_backups.json
 create mode 100644 todoist_full_offline_backup/tests/integration_files/sources/project_list.json

diff --git a/README.md b/README.md
index f9384e5..32811e6 100644
--- a/README.md
+++ b/README.md
@@ -40,17 +40,13 @@ Early version - enough for basic use, but not tested under every possible scenar
 
 ## Usage examples
 
-Download latest backup from Todoist's servers, including attachments:
+Create a backup from Todoist's servers, including attachments:
 
-``python3 __main__.py download LATEST --with-attachments --token 0123456789abcdef``
-
-Download a specific backup from Todoist's servers, without including attachments:
-
-``python3 __main__.py download "2018-02-16 06:46" --token 0123456789abcdef``
+``python3 __main__.py download --with-attachments --token 0123456789abcdef``
 
 Download a specific backup from Todoist's servers, including attachments, and with tracing/progress info:
 
-``python3 __main__.py --verbose download "2018-02-16 06:46" --token 0123456789abcdef``
+``python3 __main__.py --verbose download --token 0123456789abcdef``
 
 List available backups:
 
diff --git a/experiment-webapp/index.html b/experiment-webapp/index.html
index c33e8e6..7198e6c 100644
--- a/experiment-webapp/index.html
+++ b/experiment-webapp/index.html
@@ -7,7 +7,7 @@
         <script>
         function askCommandLine() {
             return prompt("Enter the command line args",
-                "todoist-offline-backup-dl --verbose download LATEST --token XXX");
+                "todoist-offline-backup-dl --verbose download --token XXX");
         }
 
         function hexEncode(str) {
diff --git a/todoist_full_offline_backup/backup_downloader.py b/todoist_full_offline_backup/backup_downloader.py
index 875e525..ce0f095 100644
--- a/todoist_full_offline_backup/backup_downloader.py
+++ b/todoist_full_offline_backup/backup_downloader.py
@@ -1,44 +1,35 @@
 #!/usr/bin/python3
 """ Class to download Todoist backup ZIPs using the Todoist API """
-import zipfile
-import io
+import datetime
 from .utils import sanitize_file_name
 
 class TodoistBackupDownloader:
     """ Class to download Todoist backup ZIPs using the Todoist API """
     __ZIP_FLAG_BITS_UTF8 = 0x800
 
-    def __init__(self, tracer, urldownloader):
+    def __init__(self, tracer, todoist_api):
         self.__tracer = tracer
-        self.__urldownloader = urldownloader
+        self.__todoist_api = todoist_api
 
-    def download(self, backup, vfs):
-        """ Downloads the specified backup to the specified folder """
-        self.__tracer.trace("Downloading backup with version '{}'".format(backup.version))
+    def download(self, vfs):
+        """ Generates a Todoist backup and saves it to the given VFS """
+        self.__tracer.trace("Generating backup from current Todoist status")
 
         # Sanitize the file name for platforms such as Windows,
         # which don't accept some characters in file names, such as a colon (:)
-        vfs.set_path_hint(sanitize_file_name("TodoistBackup_" + backup.version))
+        backup_version = datetime.datetime.utcnow().replace(microsecond=0).isoformat(' ')
+        vfs.set_path_hint(sanitize_file_name("TodoistBackup_" + backup_version))
 
         # Download the file
         if vfs.existed():
             self.__tracer.trace("File already downloaded... skipping")
             return
 
-        self.__tracer.trace("Downloading from {}...".format(
-            backup.url))
-        raw_zip_bytes = self.__urldownloader.get(backup.url)
-        with zipfile.ZipFile(io.BytesIO(raw_zip_bytes), "r") as zipf:
-            for info in zipf.infolist():
-                # Todoist backup ZIPs may contain filenames encoded in UTF-8, but they will not
-                # actually have the UTF-8 filename flag set in the ZIP file.
-                # This causes some ZIP parsers, such as Python's own parser, to consider the
-                # file names in the legacy CP-437 format.
-                # To fix this, let's re-encode the filenames in CP-437 to get the original
-                # bytes back, then properly decode them to UTF-8.
-                if info.flag_bits & self.__ZIP_FLAG_BITS_UTF8:
-                    encoding_file_name = info.filename
-                else:
-                    encoding_file_name = info.filename.encode('cp437').decode("utf-8")
+        self.__tracer.trace("Downloading project list from todoist API...")
+        projects = self.__todoist_api.get_projects()
 
-                vfs.write_file(encoding_file_name, zipf.read(info.filename))
+        for project in projects:
+            export_csv_file_name = "{} [{}].csv".format(
+                sanitize_file_name(project.name), project.identifier)
+            export_csv_file_content = self.__todoist_api.export_project_as_csv(project)
+            vfs.write_file(export_csv_file_name, export_csv_file_content)
diff --git a/todoist_full_offline_backup/controller.py b/todoist_full_offline_backup/controller.py
index 00cd972..eb735fd 100644
--- a/todoist_full_offline_backup/controller.py
+++ b/todoist_full_offline_backup/controller.py
@@ -3,10 +3,6 @@
 
 from abc import ABCMeta, abstractmethod
 
-class BackupNotFoundException(Exception):
-    """ Thrown when the user requests a download of a backup that does not exist """
-    pass
-
 class ControllerDependencyInjector(object, metaclass=ABCMeta):
     """ Rudimentary dependency injection container for the controller """
 
@@ -17,18 +13,15 @@ def __init__(self, token, verbose):
     @property
     @abstractmethod
     def tracer(self):
-        """ Get an instance of the tracer """
-
-    @property
-    @abstractmethod
-    def todoist_api(self):
-        """ Gets an instance of the Todoist API """
+        """ Gets an instance of the debug tracer """
 
     @property
     @abstractmethod
     def backup_downloader(self):
         """ Gets an instance of the Todoist backup downloader """
 
+    @property
+    @abstractmethod
     def backup_attachments_downloader(self):
         """ Gets an instance of the Todoist backup attachment downloader """
 
@@ -38,38 +31,8 @@ class Controller:
     def __init__(self, dependencies):
         self.__dependencies = dependencies
 
-    def get_backups(self):
-        """ Gets the list of backups along with the latest backup """
-        backups = self.__dependencies.todoist_api.get_backups()
-        return (backups, self.__get_latest(backups))
-
-    def download_latest(self, vfs, with_attachments):
-        """ Downloads the latest (i.e. most recent) Todoist backup ZIP """
-        self.__dependencies.tracer.trace("Fetching backup list to find the latest backup...")
-        backups = self.__dependencies.todoist_api.get_backups()
-        backup = self.__get_latest(backups)
-        if backup is None:
-            raise BackupNotFoundException()
-        self.__dependencies.backup_downloader.download(backup, vfs)
-        if with_attachments:
-            self.__dependencies.backup_attachments_downloader.download_attachments(vfs)
-
-    def download_version(self, version, vfs, with_attachments):
-        """ Downloads the specified Todoist backup ZIP given by its version string """
-        self.__dependencies.tracer.trace(
-            "Fetching backup list to find the backup '{}'...".format(version))
-        backups = self.__dependencies.todoist_api.get_backups()
-        backup = self.__find_version(backups, version)
-        if backup is None:
-            raise BackupNotFoundException()
-        self.__dependencies.backup_downloader.download(backup, vfs)
+    def download(self, vfs, with_attachments):
+        """ Generates a Todoist backup ZIP from the current Todoist items """
+        self.__dependencies.backup_downloader.download(vfs)
         if with_attachments:
             self.__dependencies.backup_attachments_downloader.download_attachments(vfs)
-
-    @staticmethod
-    def __get_latest(backups):
-        return max(backups, key=lambda x: x.version_date, default=None)
-
-    @staticmethod
-    def __find_version(backups, version):
-        return next((x for x in backups if x.version == version), None)
diff --git a/todoist_full_offline_backup/frontend.py b/todoist_full_offline_backup/frontend.py
index 3baaec2..ab4af65 100644
--- a/todoist_full_offline_backup/frontend.py
+++ b/todoist_full_offline_backup/frontend.py
@@ -21,24 +21,16 @@ def __add_token_group(parser):
                                  help="file containing the todoist API token")
 
     def __parse_command_line_args(self, prog, arguments):
-        example1_str = "Example: {} download LATEST --token 0123456789abcdef".format(prog)
-        example2_str = "         {} --verbose list --token 0123456789abcdef".format(prog)
+        example1_str = "Example: {} download --token 0123456789abcdef".format(prog)
         parser = argparse.ArgumentParser(prog=prog, formatter_class=argparse.RawTextHelpFormatter,
-                                         epilog=example1_str + '\r\n' + example2_str)
+                                         epilog=example1_str)
         parser.add_argument("--verbose", action="store_true", help="print details to console")
         subparsers = parser.add_subparsers(dest='action')
         subparsers.required = True
 
-        # create the parser for the "list" command
-        parser_list = subparsers.add_parser('list', help='list available backups')
-        parser_list.set_defaults(func=self.handle_list)
-        self.__add_token_group(parser_list)
-
         # create the parser for the "download" command
         parser_download = subparsers.add_parser('download', help='download specified backup')
         parser_download.set_defaults(func=self.handle_download)
-        parser_download.add_argument("version", type=str, metavar="VERSIONSPEC|LATEST",
-                                     help="backup version to download, or LATEST")
         parser_download.add_argument("--with-attachments", action="store_true",
                                      help="download attachments and attach to the backup file")
         parser_download.add_argument("--output-file", type=str,
@@ -59,20 +51,6 @@ def __get_token(args):
 
         return args.token
 
-    def handle_list(self, args):
-        """ Handles the list subparser with the specified command line arguments """
-        # Configure controller
-        token = self.__get_token(args)
-        dependencies = self.__controller_dependencies_factory(token, args.verbose)
-        controller = self.__controller_factory(dependencies)
-
-        # Execute requested action
-        (backups, latest_backup) = controller.get_backups()
-        print("{:<30} | {}".format("VERSION", "URL"))
-        for backup in backups:
-            is_latest_str = " (LATEST)" if backup == latest_backup else ""
-            print("{:<30} | {}".format(backup.version + is_latest_str, backup.url))
-
     def handle_download(self, args):
         """ Handles the download subparser with the specified command line arguments """
 
@@ -84,8 +62,4 @@ def handle_download(self, args):
         # Setup zip virtual fs
         with ZipVirtualFs(args.output_file) as zipvfs:
             # Execute requested action
-            if args.version == 'LATEST':
-                controller.download_latest(zipvfs, with_attachments=args.with_attachments)
-            else:
-                controller.download_version(args.version, zipvfs,
-                                            with_attachments=args.with_attachments)
+            controller.download(zipvfs, with_attachments=args.with_attachments)
diff --git a/todoist_full_offline_backup/runtime.py b/todoist_full_offline_backup/runtime.py
index ab9c88d..f10c3fc 100644
--- a/todoist_full_offline_backup/runtime.py
+++ b/todoist_full_offline_backup/runtime.py
@@ -15,8 +15,8 @@ def __init__(self, token, verbose):
         super(RuntimeControllerDependencyInjector, self).__init__(token, verbose)
         self.__tracer = ConsoleTracer() if verbose else NullTracer()
         urldownloader = URLLibURLDownloader()
-        self.__todoist_api = TodoistApi(token, self.__tracer, urldownloader)
-        self.__backup_downloader = TodoistBackupDownloader(self.__tracer, urldownloader)
+        todoist_api = TodoistApi(token, self.__tracer, urldownloader)
+        self.__backup_downloader = TodoistBackupDownloader(self.__tracer, todoist_api)
         self.__backup_attachments_downloader = TodoistBackupAttachmentsDownloader(
             self.__tracer, urldownloader)
 
@@ -24,10 +24,6 @@ def __init__(self, token, verbose):
     def tracer(self):
         return self.__tracer
 
-    @property
-    def todoist_api(self):
-        return self.__todoist_api
-
     @property
     def backup_downloader(self):
         return self.__backup_downloader
diff --git a/todoist_full_offline_backup/tests/integration_files/expected/BackupList.txt b/todoist_full_offline_backup/tests/integration_files/expected/BackupList.txt
deleted file mode 100644
index 809e85f..0000000
--- a/todoist_full_offline_backup/tests/integration_files/expected/BackupList.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-VERSION                        | URL
-2018-03-25 10:13 (LATEST)      | https://s3.amazonaws.com/user_backups.todoist.com/f9610a4296c5deaf536de3fc9bfd113a.zip
-2018-03-25 10:12               | https://s3.amazonaws.com/user_backups.todoist.com/d786b8464e642890cd575bdefc87dcda.zip
diff --git a/todoist_full_offline_backup/tests/integration_files/expected/TodoistBackupNoAttach.zip b/todoist_full_offline_backup/tests/integration_files/expected/TodoistBackupNoAttach.zip
new file mode 100644
index 0000000000000000000000000000000000000000..fe5cd445bd47b1191781d8304421a388c1c2b519
GIT binary patch
literal 3314
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
Pyp!>kF^Z?my7l)PZG{*J

literal 0
HcmV?d00001

diff --git a/todoist_full_offline_backup/tests/integration_files/expected/TodoistBackupWAttach_2018-03-25 10_13.zip b/todoist_full_offline_backup/tests/integration_files/expected/TodoistBackupWAttach.zip
similarity index 100%
rename from todoist_full_offline_backup/tests/integration_files/expected/TodoistBackupWAttach_2018-03-25 10_13.zip
rename to todoist_full_offline_backup/tests/integration_files/expected/TodoistBackupWAttach.zip
diff --git a/todoist_full_offline_backup/tests/integration_files/expected/TodoistBackup_2018-03-25 10_12.zip b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147709.csv
similarity index 63%
rename from todoist_full_offline_backup/tests/integration_files/expected/TodoistBackup_2018-03-25 10_12.zip
rename to todoist_full_offline_backup/tests/integration_files/sources/Project_2181147709.csv
index 8c69bcd76e49baeaa6efde9871e4bce268739a30..dfca45549f67723afb0e1af47d692b195f187659 100644
GIT binary patch
delta 58
zcmdmKFj0AOpRm`)y2}ESSMdwVWELyr=jBu?WacT9WTYzOB$lKWmnbA9CTEuxOuoQx
I&!Gba0EZV882|tP

delta 1226
zcmbQJywkuWz?+#xgn@yBfuSX^(ns{&pKr2)3=AMF#=yYfnU|Dbp%86kXkln*Vs36=
z8LO9ET(&`0&>U4?y97(G7f?M2O9F8~YEf~1USbYHtDzxS>jW<XI)gLv3kovx(vfr;
zL3JAAwo?>nXLx>5Hj*x5s4g?yx+H+QT#Jel^HPeDG@3v)+Tqry0MzK4UzV9#tWc7#
zP@Y(loPlJ3DbxTLR0G&fPCm=U#J~W;YCr=%%wN{6kW^Yyl3J9O12QTnv$zCqjHM~m
zn6QbvxP?E=pD<e?GfyG2q*x&@F*j9FQE~Dde)W2t)I1&6(xUu=RDIvXl%mWOUaq|S
zl2jcfh3M$C%$!t(Y9%EQ9bcSTm8zs<Wn`fP6)34J00}55m84db#ON2~BxdF*DZykx
zc7SD*O4Id9DoVgIr3E?pi7D~LC5a^v$>hm1S$QXmFquWCo15xp`&bl|hei7NCj}>0
z`Q(K~q?)*SR(hpaL<ahpC0SHDXXdz9W>y$jCi$j#<yIt>6uJ9`TV{EtdX{^|=qFXi
z=o^}uniyFcn8xTQ76U~fR!?5YD$We_!(=;ti~0a>MkWzv-02k<tYFZ<2%@m3UUW0i
z(=NmW28IU4KwvIFNy+u#TmVhV#G7*oXb#SFjn5cRvW9^M#$cg(9H|_i8K6WC0}YH9
zgm5Q$e5NRXjR4vY0u77-!h|ybx^d{~A7U2Bv>QOvh{_G(WdYu-Y#@#7K=>CJ$!efd
GiU9z4jvzDu

diff --git a/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147711.csv b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147711.csv
new file mode 100644
index 0000000..c834dee
--- /dev/null
+++ b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147711.csv
@@ -0,0 +1 @@
+TYPE,CONTENT,PRIORITY,INDENT,AUTHOR,RESPONSIBLE,DATE,DATE_LANG,TIMEZONE
\ No newline at end of file
diff --git a/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147712.csv b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147712.csv
new file mode 100644
index 0000000..c834dee
--- /dev/null
+++ b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147712.csv
@@ -0,0 +1 @@
+TYPE,CONTENT,PRIORITY,INDENT,AUTHOR,RESPONSIBLE,DATE,DATE_LANG,TIMEZONE
\ No newline at end of file
diff --git a/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147713.csv b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147713.csv
new file mode 100644
index 0000000..c834dee
--- /dev/null
+++ b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147713.csv
@@ -0,0 +1 @@
+TYPE,CONTENT,PRIORITY,INDENT,AUTHOR,RESPONSIBLE,DATE,DATE_LANG,TIMEZONE
\ No newline at end of file
diff --git a/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147714.csv b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147714.csv
new file mode 100644
index 0000000..c834dee
--- /dev/null
+++ b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147714.csv
@@ -0,0 +1 @@
+TYPE,CONTENT,PRIORITY,INDENT,AUTHOR,RESPONSIBLE,DATE,DATE_LANG,TIMEZONE
\ No newline at end of file
diff --git a/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147715.csv b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147715.csv
new file mode 100644
index 0000000..c834dee
--- /dev/null
+++ b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147715.csv
@@ -0,0 +1 @@
+TYPE,CONTENT,PRIORITY,INDENT,AUTHOR,RESPONSIBLE,DATE,DATE_LANG,TIMEZONE
\ No newline at end of file
diff --git a/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147955.csv b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147955.csv
new file mode 100644
index 0000000..6561f18
--- /dev/null
+++ b/todoist_full_offline_backup/tests/integration_files/sources/Project_2181147955.csv
@@ -0,0 +1,4 @@
+TYPE,CONTENT,PRIORITY,INDENT,AUTHOR,RESPONSIBLE,DATE,DATE_LANG,TIMEZONE
+task,this task has a 🐛 in its name!!!,4,1,test_integration_test (16542905),,,en,Europe/Madrid
+note," [[file {""file_size"":28,""file_type"":""text\/plain"",""file_name"":""bug.txt"",""upload_state"":""completed"",""file_url"":""https:\/\/d1x0mwiac2rqwt.cloudfront.net\/g75-kL8pwVYNObSczLnVXe4FIyJd8YQL6b8yCilGyix09bMdJmxbtrGMW9jIeIwJ\/by\/16542905\/as\/bug.txt"",""resource_type"":""file""}]]",,,test_integration_test (16542905),,,,
+,,,,,,,,
\ No newline at end of file
diff --git a/todoist_full_offline_backup/tests/integration_files/sources/d786b8464e642890cd575bdefc87dcda.zip b/todoist_full_offline_backup/tests/integration_files/sources/d786b8464e642890cd575bdefc87dcda.zip
deleted file mode 100644
index 03e5cd1478bff1ebdac64331dec0ba587deff2cb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6201
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
M1Hf7FpMjPC0GISp9smFU

diff --git a/todoist_full_offline_backup/tests/integration_files/sources/f9610a4296c5deaf536de3fc9bfd113a.zip b/todoist_full_offline_backup/tests/integration_files/sources/f9610a4296c5deaf536de3fc9bfd113a.zip
deleted file mode 100644
index 3575b0e1ec19f0ae245120a515d42f2d8207f4af..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6317
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

diff --git a/todoist_full_offline_backup/tests/integration_files/sources/get_backups.json b/todoist_full_offline_backup/tests/integration_files/sources/get_backups.json
deleted file mode 100644
index d2d3915..0000000
--- a/todoist_full_offline_backup/tests/integration_files/sources/get_backups.json
+++ /dev/null
@@ -1 +0,0 @@
-[{"url":"https:\/\/s3.amazonaws.com\/user_backups.todoist.com\/f9610a4296c5deaf536de3fc9bfd113a.zip","version":"2018-03-25 10:13"},{"url":"https:\/\/s3.amazonaws.com\/user_backups.todoist.com\/d786b8464e642890cd575bdefc87dcda.zip","version":"2018-03-25 10:12"}]
\ No newline at end of file
diff --git a/todoist_full_offline_backup/tests/integration_files/sources/project_list.json b/todoist_full_offline_backup/tests/integration_files/sources/project_list.json
new file mode 100644
index 0000000..6a166e6
--- /dev/null
+++ b/todoist_full_offline_backup/tests/integration_files/sources/project_list.json
@@ -0,0 +1,91 @@
+{
+    "projects" : [
+        {
+            "is_archived" : 0,
+            "color" : 7,
+            "shared" : false,
+            "inbox_project" : true,
+            "id" : 2181147955,
+            "collapsed" : 0,
+            "item_order" : 0,
+            "name" : "🦋 butterflies list",
+            "is_deleted" : 0,
+            "indent" : 1
+        },
+        {
+            "is_archived" : 0,
+            "color" : 7,
+            "shared" : false,
+            "inbox_project" : true,
+            "id" : 2181147714,
+            "collapsed" : 0,
+            "item_order" : 0,
+            "name" : "Errands",
+            "is_deleted" : 0,
+            "indent" : 1
+        },
+        {
+            "is_archived" : 0,
+            "color" : 7,
+            "shared" : false,
+            "inbox_project" : true,
+            "id" : 2181147709,
+            "collapsed" : 0,
+            "item_order" : 0,
+            "name" : "Inbox",
+            "is_deleted" : 0,
+            "indent" : 1
+        },
+        {
+            "is_archived" : 0,
+            "color" : 7,
+            "shared" : false,
+            "inbox_project" : true,
+            "id" : 2181147715,
+            "collapsed" : 0,
+            "item_order" : 0,
+            "name" : "Movies to watch",
+            "is_deleted" : 0,
+            "indent" : 1
+        },
+        {
+            "is_archived" : 0,
+            "color" : 7,
+            "shared" : false,
+            "inbox_project" : true,
+            "id" : 2181147711,
+            "collapsed" : 0,
+            "item_order" : 0,
+            "name" : "Personal",
+            "is_deleted" : 0,
+            "indent" : 1
+        },
+        {
+            "is_archived" : 0,
+            "color" : 7,
+            "shared" : false,
+            "inbox_project" : true,
+            "id" : 2181147712,
+            "collapsed" : 0,
+            "item_order" : 0,
+            "name" : "Shopping",
+            "is_deleted" : 0,
+            "indent" : 1
+        },
+        {
+            "is_archived" : 0,
+            "color" : 7,
+            "shared" : false,
+            "inbox_project" : true,
+            "id" : 2181147713,
+            "collapsed" : 0,
+            "item_order" : 0,
+            "name" : "Work",
+            "is_deleted" : 0,
+            "indent" : 1
+        }
+    ],
+    "full_sync" : true,
+    "temp_id_mapping" : {},
+    "sync_token" : "aLGJg_2qwBE_kE3j9_Gn6uoKQtvQeyjm7UEz_aVwF8KdriDxw7e_InFZK61h"
+ }
\ No newline at end of file
diff --git a/todoist_full_offline_backup/tests/test_backup_attachments_downloader.py b/todoist_full_offline_backup/tests/test_backup_attachments_downloader.py
index 0877917..bf85b06 100644
--- a/todoist_full_offline_backup/tests/test_backup_attachments_downloader.py
+++ b/todoist_full_offline_backup/tests/test_backup_attachments_downloader.py
@@ -37,7 +37,7 @@ def test_on_simple_download_downloads_attachments(self):
         writer.writerow(["task", "This is a random task", "4"])
         writer.writerow(["note", " [[file {}]]".format(json.dumps({
             "file_type": "image/jpg",
-            "file_name": "this/is/an/image.jpg",
+            "file_name": "this_is_an_image.jpg",
             "file_url": self._TEST_FILE_JPG_URL
         })), "test"])
 
diff --git a/todoist_full_offline_backup/tests/test_backup_downloader.py b/todoist_full_offline_backup/tests/test_backup_downloader.py
index 11f5555..cc8d7a3 100644
--- a/todoist_full_offline_backup/tests/test_backup_downloader.py
+++ b/todoist_full_offline_backup/tests/test_backup_downloader.py
@@ -3,9 +3,6 @@
 # pylint: disable=invalid-name
 import unittest
 from unittest.mock import MagicMock
-import io
-import zipfile
-from ..todoist_api import TodoistBackupInfo
 from ..backup_downloader import TodoistBackupDownloader
 from ..tracer import NullTracer
 from .test_util_memory_vfs import InMemoryVfs
@@ -14,28 +11,10 @@ class TestBackupDownloader(unittest.TestCase):
     """ Tests for the Todoist backup downloader class """
     def setUp(self):
         """ Creates the sample instrastructure for the test """
-        self.__backup = TodoistBackupInfo("2016-01-01 12:30", "http://www.example.com/backup.zip")
-
-        empty_zip_bytes_io = io.BytesIO()
-        with zipfile.ZipFile(empty_zip_bytes_io, "w") as _:
-            pass
-        empty_zip_bytes = empty_zip_bytes_io.getvalue()
-
-        self.__urlmap = {"http://www.example.com/backup.zip": empty_zip_bytes}
+        self.__urlmap = {}
         self.__fake_urldownloader = MagicMock(get=lambda url: self.__urlmap[url])
 
-
-    def test_on_nonexisting_version_throws_exception(self):
-        """ Tests that an exception is thrown when one attempts to download a backup
-            that does not exist on the server """
-        # Arrange
-        backup_downloader = TodoistBackupDownloader(NullTracer(), self.__fake_urldownloader)
-        fake_backup = TodoistBackupInfo("123", "file:///this/path/does/not/exist/hopefully.zip")
-
-        # Act/Assert
-        self.assertRaises(Exception, backup_downloader.download, fake_backup, "/")
-
-    def test_on_latest_version_and_existing_destination_doesnt_overwrite(self):
+    def test_on_existing_destination_doesnt_overwrite(self):
         """ Tests that if the backup already exists in the destination path,
             it is not overwriten """
 
@@ -45,58 +24,8 @@ def test_on_latest_version_and_existing_destination_doesnt_overwrite(self):
         vfs.write_file("test", b'testdata')
 
         # Act
-        backup_downloader.download(self.__backup, vfs)
+        backup_downloader.download(vfs)
 
         # Assert
         self.assertEqual(vfs.file_list(), ["test"])
         self.assertEqual(vfs.read_file("test"), b'testdata')
-
-    def test_on_zip_with_no_utf8_parses_utf8_filename(self):
-        """ Tests that, if the server provides a backup ZIP file with no UTF-8 filename flag,
-            it is patched to include it (since the Todoist servers provide ZIPs without it)
-            and the backup files can be correctly parsed """
-
-        # Arrange
-        backup_downloader = TodoistBackupDownloader(NullTracer(), self.__fake_urldownloader)
-        vfs = InMemoryVfs()
-
-        # This is a prepared ZIP file with UTF-8 filenames but without the UTF-8 filenames set,
-        # like those that come from Todoist backups...
-        # pylint: disable=line-too-long
-        self.__urlmap = {"http://www.example.com/backup.zip": bytearray.fromhex(
-            '504b03040a03000000000b90524c0000000000000000000000000d00000041534349494e414d452e747874' +
-            '504b03040a03000000000f90524c00000000000000000000000014000000554e49434f44454e414d4520f09f92a92e747874' +
-            '504b01023f030a03000000000b90524c0000000000000000000000000d0024000000000000002080a4810000000041534349494e414d452e7478740a0020000000000001001800005773f6d9a8d301005773f6d9a8d301005773f6d9a8d301' +
-            '504b01023f030a03000000000f90524c000000000000000000000000140024000000000000002080a4812b000000554e49434f44454e414d4520f09f92a92e7478740a002000000000000100180080749ffad9a8d30180749ffad9a8d30180749ffad9a8d301' +
-            '504b05060000000002000200c50000005d0000000000')}
-
-        # Act
-        backup_downloader.download(self.__backup, vfs)
-
-        # Assert
-        self.assertIn("ASCIINAME.txt", vfs.file_list())
-        self.assertIn("UNICODENAME 💩.txt", vfs.file_list())
-
-    def test_on_zip_with_utf8_flag_does_not_break(self):
-        """ Tests that, if the server provides a backup ZIP file with the UTF-8 filename flag,
-            the backup files can be correctly parsed """
-
-        # Arrange
-        backup_downloader = TodoistBackupDownloader(NullTracer(), self.__fake_urldownloader)
-        vfs = InMemoryVfs()
-
-        # This is a prepared ZIP file with UTF-8 filenames and with the UTF-8 filenames set
-        # pylint: disable=line-too-long
-        self.__urlmap = {"http://www.example.com/backup.zip": bytearray.fromhex(
-            '504b03040a03000800000b90524c0000000000000000000000000d00000041534349494e414d452e747874' +
-            '504b03040a03000800000f90524c00000000000000000000000014000000554e49434f44454e414d4520f09f92a92e747874' +
-            '504b01023f030a03000800000b90524c0000000000000000000000000d0024000000000000002080a4810000000041534349494e414d452e7478740a0020000000000001001800005773f6d9a8d301005773f6d9a8d301005773f6d9a8d301' +
-            '504b01023f030a03000800000f90524c000000000000000000000000140024000000000000002080a4812b000000554e49434f44454e414d4520f09f92a92e7478740a002000000000000100180080749ffad9a8d30180749ffad9a8d30180749ffad9a8d301' +
-            '504b05060000000002000200c50000005d0000000000')}
-
-        # Act
-        backup_downloader.download(self.__backup, vfs)
-
-        # Assert
-        self.assertIn("ASCIINAME.txt", vfs.file_list())
-        self.assertIn("UNICODENAME 💩.txt", vfs.file_list())
diff --git a/todoist_full_offline_backup/tests/test_controller.py b/todoist_full_offline_backup/tests/test_controller.py
index 6501024..b5587db 100644
--- a/todoist_full_offline_backup/tests/test_controller.py
+++ b/todoist_full_offline_backup/tests/test_controller.py
@@ -3,18 +3,16 @@
 # pylint: disable=invalid-name
 import unittest
 from unittest.mock import Mock, ANY
-from ..todoist_api import TodoistBackupInfo
 from ..tracer import NullTracer
-from ..controller import ControllerDependencyInjector, Controller, BackupNotFoundException
+from ..controller import ControllerDependencyInjector, Controller
 
 class TestControllerDependencyInjector(ControllerDependencyInjector):
     """ Rudimentary dependency injection container for the tests """
 
-    def __init__(self, test_tracer, test_todoist_api, test_todoist_downloader,
+    def __init__(self, test_tracer, test_todoist_downloader,
                  test_todoist_attachments_downloader):
         super(TestControllerDependencyInjector, self).__init__("", False)
         self.__test_tracer = test_tracer
-        self.__test_todoist_api = test_todoist_api
         self.__test_todoist_downloader = test_todoist_downloader
         self.__test_todoist_attachments_downloader = test_todoist_attachments_downloader
 
@@ -22,10 +20,6 @@ def __init__(self, test_tracer, test_todoist_api, test_todoist_downloader,
     def tracer(self):
         return self.__test_tracer
 
-    @property
-    def todoist_api(self):
-        return self.__test_todoist_api
-
     @property
     def backup_downloader(self):
         return self.__test_todoist_downloader
@@ -36,122 +30,51 @@ def backup_attachments_downloader(self):
 
 class TestController(unittest.TestCase):
     """ Tests for the controller class that gives access to most classes of the system """
-    def setUp(self):
-        """ Creates the test sample data """
-        self.__old_backup = TodoistBackupInfo("2016-01-01 12:30", "file://backup1.zip")
-        self.__latest_backup = TodoistBackupInfo("2016-01-02 14:56", "file://backup2.zip")
-        self.__test_data = [self.__old_backup, self.__latest_backup]
-
-    def test_on_get_backups_returns_correct_list_and_latest_backup(self):
-        """ Tests that a valid operation to get the list of backups returns the expected result """
-        # Arrange
-        controllerdi = TestControllerDependencyInjector(
-            NullTracer(), Mock(get_backups=lambda: self.__test_data), Mock(), Mock())
-        controllerinst = Controller(controllerdi)
-
-        # Act
-        (backups, latest_backup) = controllerinst.get_backups()
-
-        # Assert
-        self.assertEqual(backups, self.__test_data)
-        self.assertEqual(latest_backup, self.__latest_backup)
-
-    def test_on_get_backups_with_no_backups_returns_empty_list_and_no_latest_backup(self):
-        """ Tests that getting an empty list of backups is correctly handled """
-        # Arrange
-        downloader_mock = Mock()
-        controllerdi = TestControllerDependencyInjector(
-            NullTracer(), Mock(get_backups=lambda: []), downloader_mock, Mock())
-        controllerinst = Controller(controllerdi)
-
-        # Act
-        (backups, latest_backup) = controllerinst.get_backups()
-
-        # Assert
-        self.assertEqual(backups, [])
-        self.assertEqual(latest_backup, None)
-
-    def test_on_nonexisting_version_throws_exception(self):
-        """ Tests that an exception is thrown
-            when attempting to download a non-existing backup version """
-
-        # Arrange
-        controllerdi = TestControllerDependencyInjector(
-            NullTracer(), Mock(get_backups=lambda: self.__test_data), Mock(), Mock())
-        controllerinst = Controller(controllerdi)
 
-        # Act/Assert
-        self.assertRaises(BackupNotFoundException, controllerinst.download_version,
-                          "2016-01-03 11:22", "/", with_attachments=False)
-
-    def test_on_existing_version_calls_download_for_that_version(self):
-        """ Tests that the backup downloader is called
-            when attempting to download an specific version of an existing backup """
-        # Arrange
-        downloader_mock = Mock()
-        controllerdi = TestControllerDependencyInjector(
-            NullTracer(), Mock(get_backups=lambda: self.__test_data), downloader_mock, Mock())
-        controllerinst = Controller(controllerdi)
-
-        # Act
-        controllerinst.download_version(self.__old_backup.version, ".", with_attachments=False)
-
-        # Assert
-        downloader_mock.download.assert_called_with(self.__old_backup, ".")
-
-    def test_on_existing_version_with_attachments_calls_download_attachments(self):
+    @staticmethod
+    def test_on_existing_version_with_attachments_calls_download_attachments():
         """ Tests that the backup + attachments downloader is called
             when attempting to download an specific version of an existing backup w/attachments """
         # Arrange
         downloader_attachments_mock = Mock()
-        controllerdi = TestControllerDependencyInjector(NullTracer(), Mock(
-            get_backups=lambda: self.__test_data), Mock(), downloader_attachments_mock)
+        controllerdi = TestControllerDependencyInjector(
+            NullTracer(), Mock(), downloader_attachments_mock)
         controllerinst = Controller(controllerdi)
 
         # Act
-        controllerinst.download_version(self.__old_backup.version, ".", with_attachments=True)
+        controllerinst.download(".", with_attachments=True)
 
         # Assert
         downloader_attachments_mock.download_attachments.assert_called_with(ANY)
 
-    def test_on_nonexisting_latest_throws_exception(self):
-        """ Tests that an exception is thrown
-            when attempting to download the latest backup, if there is none """
-        # Arrange
-        controllerdi = TestControllerDependencyInjector(
-            NullTracer(), Mock(get_backups=lambda: []), Mock(), Mock())
-        controllerinst = Controller(controllerdi)
-
-        # Act/Assert
-        self.assertRaises(BackupNotFoundException,
-                          controllerinst.download_latest, "/", with_attachments=False)
-
-    def test_on_latest_version_calls_download_for_that_version(self):
+    @staticmethod
+    def test_on_latest_version_calls_download_for_that_version():
         """ Tests that the backup + attachments downloader is called
             when attempting to download the latest existing backup """
         # Arrange
         downloader_mock = Mock()
         controllerdi = TestControllerDependencyInjector(
-            NullTracer(), Mock(get_backups=lambda: self.__test_data), downloader_mock, Mock())
+            NullTracer(), downloader_mock, Mock())
         controllerinst = Controller(controllerdi)
 
         # Act
-        controllerinst.download_latest(".", with_attachments=False)
+        controllerinst.download(".", with_attachments=False)
 
         # Assert
-        downloader_mock.download.assert_called_with(self.__latest_backup, ".")
+        downloader_mock.download.assert_called_with(".")
 
-    def test_on_latest_version_with_attachments_calls_download_attachments(self):
+    @staticmethod
+    def test_on_latest_version_with_attachments_calls_download_attachments():
         """ Tests that the backup downloader is called
             when attempting to download the latest existing backup w/attachments """
         # Arrange
         downloader_attachments_mock = Mock()
-        controllerdi = TestControllerDependencyInjector(NullTracer(), Mock(
-            get_backups=lambda: self.__test_data), Mock(), downloader_attachments_mock)
+        controllerdi = TestControllerDependencyInjector(
+            NullTracer(), Mock(), downloader_attachments_mock)
         controllerinst = Controller(controllerdi)
 
         # Act
-        controllerinst.download_latest(".", with_attachments=True)
+        controllerinst.download(".", with_attachments=True)
 
         # Assert
         downloader_attachments_mock.download_attachments.assert_called_with(ANY)
diff --git a/todoist_full_offline_backup/tests/test_frontend.py b/todoist_full_offline_backup/tests/test_frontend.py
index 2e870c8..fe9294d 100644
--- a/todoist_full_offline_backup/tests/test_frontend.py
+++ b/todoist_full_offline_backup/tests/test_frontend.py
@@ -2,61 +2,15 @@
 """ Tests for the console frontend """
 # pylint: disable=invalid-name
 import unittest
-from unittest.mock import Mock, MagicMock, patch, ANY
-import io
-import tempfile
+from unittest.mock import Mock, MagicMock, ANY
 from ..frontend import ConsoleFrontend
-from ..todoist_api import TodoistBackupInfo
 
 class TestFrontend(unittest.TestCase):
     """ Tests for the console frontend """
 
-    def test_on_list_backups_prints_list_to_console(self):
-        """ Tests that the list backups operation prints the list of backups to the console """
-        # Arrange
-        with patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:
-            backup1 = TodoistBackupInfo("BACKUP1", "file:///test1.zip")
-            backup2 = TodoistBackupInfo("BACKUP2", "file:///test2.zip")
-            backups = [backup1, backup2]
-
-            controller = Mock(get_backups=lambda: (backups, backup2))
-            frontend = ConsoleFrontend(Mock(return_value=controller), Mock())
-
-            # Act
-            frontend.run("util", ["list", "--token", "1234"])
-
-            # Assert
-            self.assertRegex(mock_stdout.getvalue(), "BACKUP1")
-            self.assertRegex(mock_stdout.getvalue(), "file:///test1.zip")
-            self.assertRegex(mock_stdout.getvalue(), r"BACKUP2 \(LATEST\)")
-            self.assertRegex(mock_stdout.getvalue(), "file:///test2.zip")
-
-    def test_on_list_backups_with_token_from_file(self):
-        """ Tests that the list backups operation prints the list of backups to the console """
-        # Arrange
-        with patch('sys.stdout', new_callable=io.StringIO) as mock_stdout:
-            with tempfile.NamedTemporaryFile(delete=False) as tmpf:
-                tmpf.write(b'1234')
-
-                backup1 = TodoistBackupInfo("BACKUP1", "file:///test1.zip")
-                backup2 = TodoistBackupInfo("BACKUP2", "file:///test2.zip")
-                backups = [backup1, backup2]
-
-                controller = Mock(get_backups=lambda: (backups, backup2))
-                frontend = ConsoleFrontend(Mock(return_value=controller), Mock())
-
-                # Act
-                frontend.run("util", ["list", "--token-file", tmpf.name])
-
-                # Assert
-                self.assertRegex(mock_stdout.getvalue(), "BACKUP1")
-                self.assertRegex(mock_stdout.getvalue(), "file:///test1.zip")
-                self.assertRegex(mock_stdout.getvalue(), r"BACKUP2 \(LATEST\)")
-                self.assertRegex(mock_stdout.getvalue(), "file:///test2.zip")
-
     @staticmethod
-    def test_on_download_version_calls_controller_with_that_version():
-        """ Tests that when attempting to download an specific version of a backup,
+    def test_on_download_calls_controller():
+        """ Tests that when attempting to download a backup (without attachments),
             the corresponding method of the controller is called """
 
         # Arrange
@@ -64,21 +18,21 @@ def test_on_download_version_calls_controller_with_that_version():
         frontend = ConsoleFrontend(Mock(return_value=controller), Mock())
 
         # Act
-        frontend.run("util", ["download", "4321", "--token", "1234"])
+        frontend.run("util", ["download", "--token", "1234"])
 
         # Assert
-        controller.download_version.assert_called_with("4321", ANY, with_attachments=False)
+        controller.download.assert_called_with(ANY, with_attachments=False)
 
     @staticmethod
-    def test_on_download_latest_version_calls_controller_latest_version():
-        """ Tests that when attempting to download the latest backup,
-            the corresponding method of the controller is called """
+    def test_on_download_with_attachments_calls_controller_with_attachments():
+        """ Tests that when attempting to download a backup (with attachments),
+            the corresponding method of the controller is called (with attachments) """
         # Arrange
         controller = MagicMock()
         frontend = ConsoleFrontend(Mock(return_value=controller), Mock())
 
         # Act
-        frontend.run("util", ["download", "LATEST", "--token", "1234"])
+        frontend.run("util", ["download", "--with-attachments", "--token", "1234"])
 
         # Assert
-        controller.download_latest.assert_called_with(ANY, with_attachments=False)
+        controller.download.assert_called_with(ANY, with_attachments=True)
diff --git a/todoist_full_offline_backup/tests/test_integration.py b/todoist_full_offline_backup/tests/test_integration.py
index 3932194..12fe454 100644
--- a/todoist_full_offline_backup/tests/test_integration.py
+++ b/todoist_full_offline_backup/tests/test_integration.py
@@ -5,7 +5,7 @@
 from unittest.mock import patch
 import urllib.request
 import os
-import io
+import glob
 from pathlib import Path
 import tempfile
 import zipfile
@@ -29,12 +29,22 @@ def setUp(self):
         # Set up the fake HTTP server with local responses
         # pylint: disable=line-too-long
         route_responses = {
-            "/https://todoist.com/api/v7/backups/get?token=mysecrettoken":
-                Path(self.__get_test_file("sources/get_backups.json")).read_bytes(),
-            "/https://s3.amazonaws.com/user_backups.todoist.com/f9610a4296c5deaf536de3fc9bfd113a.zip":
-                Path(self.__get_test_file("sources/f9610a4296c5deaf536de3fc9bfd113a.zip")).read_bytes(),
-            "/https://s3.amazonaws.com/user_backups.todoist.com/d786b8464e642890cd575bdefc87dcda.zip":
-                Path(self.__get_test_file("sources/d786b8464e642890cd575bdefc87dcda.zip")).read_bytes(),
+            "/https://todoist.com/api/v7/sync?token=mysecrettoken&sync_token=%2A&resource_types=%5B%22projects%22%5D":
+                Path(self.__get_test_file("sources/project_list.json")).read_bytes(),
+            "/https://todoist.com/api/v7/templates/export_as_file?token=mysecrettoken&project_id=2181147955":
+                Path(self.__get_test_file("sources/Project_2181147955.csv")).read_bytes(),
+            "/https://todoist.com/api/v7/templates/export_as_file?token=mysecrettoken&project_id=2181147714":
+                Path(self.__get_test_file("sources/Project_2181147714.csv")).read_bytes(),
+            "/https://todoist.com/api/v7/templates/export_as_file?token=mysecrettoken&project_id=2181147709":
+                Path(self.__get_test_file("sources/Project_2181147709.csv")).read_bytes(),
+            "/https://todoist.com/api/v7/templates/export_as_file?token=mysecrettoken&project_id=2181147715":
+                Path(self.__get_test_file("sources/Project_2181147715.csv")).read_bytes(),
+            "/https://todoist.com/api/v7/templates/export_as_file?token=mysecrettoken&project_id=2181147711":
+                Path(self.__get_test_file("sources/Project_2181147711.csv")).read_bytes(),
+            "/https://todoist.com/api/v7/templates/export_as_file?token=mysecrettoken&project_id=2181147712":
+                Path(self.__get_test_file("sources/Project_2181147712.csv")).read_bytes(),
+            "/https://todoist.com/api/v7/templates/export_as_file?token=mysecrettoken&project_id=2181147713":
+                Path(self.__get_test_file("sources/Project_2181147713.csv")).read_bytes(),
             "/https://d1x0mwiac2rqwt.cloudfront.net/g75-kL8pwVYNObSczLnVXe4FIyJd8YQL6b8yCilGyix09bMdJmxbtrGMW9jIeIwJ/by/16542905/as/bug.txt":
                 Path(self.__get_test_file("sources/bug.txt")).read_bytes(),
             "/https://d1x0mwiac2rqwt.cloudfront.net/s0snyb7n9tJXYijOK2LV6hjVar4YUkwYbHv3PBFYM-N4nJEtujC046OlEdZpKfZm/by/16542905/as/sample_image.png":
@@ -76,30 +86,11 @@ def __compare_zip_files(self, zip_path_1, zip_path_2):
                     self.assertEqual(content_1, content_2)
 
     @patch.object(sys, 'argv', ["program",
-                                "list",
+                                "download", "--with-attachments",
                                 "--token", "mysecrettoken"])
     @patch.object(urllib.request, 'urlopen')
-    @patch.object(sys, 'stdout', new_callable=io.StringIO)
-    def test_integration_list_backups(self, mock_stdout, mock_urlopen):
-        """ Integration test for listing all the backups in the system """
-
-        # Arrange
-        mock_urlopen.side_effect = self.__urlopen_redirect_to_local
-
-        # Act
-        main()
-
-        # Assert
-        expected_list_path = self.__get_test_file("expected/BackupList.txt")
-        expected_list = Path(expected_list_path).read_bytes().decode()
-        self.assertEqual(mock_stdout.getvalue(), expected_list)
-
-    @patch.object(sys, 'argv', ["program",
-                                "download", "LATEST", "--with-attachments",
-                                "--token", "mysecrettoken"])
-    @patch.object(urllib.request, 'urlopen')
-    def test_integration_download_latest_with_attachments(self, mock_urlopen):
-        """ Integration test for downloading the latest backup with attachments """
+    def test_integration_download_with_attachments(self, mock_urlopen):
+        """ Integration test for downloading the backup with attachments """
 
         # Arrange
         mock_urlopen.side_effect = self.__urlopen_redirect_to_local
@@ -108,16 +99,16 @@ def test_integration_download_latest_with_attachments(self, mock_urlopen):
         main()
 
         # Arrange
-        expected_file = self.__get_test_file("expected/TodoistBackupWAttach_2018-03-25 10_13.zip")
-        actual_file = os.path.join(self.__test_dir, "TodoistBackup_2018-03-25 10_13.zip")
+        expected_file = self.__get_test_file("expected/TodoistBackupWAttach.zip")
+        actual_file = glob.glob(os.path.join(self.__test_dir, "*"))[0]
         self.__compare_zip_files(expected_file, actual_file)
 
     @patch.object(sys, 'argv', ["program",
-                                "download", "2018-03-25 10:12",
+                                "download",
                                 "--token", "mysecrettoken"])
     @patch.object(urllib.request, 'urlopen')
-    def test_integration_download_specific(self, mock_urlopen):
-        """ Integration test for downloading a specific backup (without attachments) """
+    def test_integration_download_without_attachments(self, mock_urlopen):
+        """ Integration test for downloading the backup without attachments """
 
         # Arrange
         mock_urlopen.side_effect = self.__urlopen_redirect_to_local
@@ -126,6 +117,6 @@ def test_integration_download_specific(self, mock_urlopen):
         main()
 
         # Arrange
-        expected_file = self.__get_test_file("expected/TodoistBackup_2018-03-25 10_12.zip")
-        actual_file = os.path.join(self.__test_dir, "TodoistBackup_2018-03-25 10_12.zip")
+        expected_file = self.__get_test_file("expected/TodoistBackupNoAttach.zip")
+        actual_file = glob.glob(os.path.join(self.__test_dir, "*"))[0]
         self.__compare_zip_files(expected_file, actual_file)
diff --git a/todoist_full_offline_backup/tests/test_runtime.py b/todoist_full_offline_backup/tests/test_runtime.py
index cd7a234..e25cceb 100644
--- a/todoist_full_offline_backup/tests/test_runtime.py
+++ b/todoist_full_offline_backup/tests/test_runtime.py
@@ -16,8 +16,6 @@ def test_runtime_dependency_injector_caches_values(self):
         runtimedi = RuntimeControllerDependencyInjector("1234", True)
         tracer1 = runtimedi.tracer
         tracer2 = runtimedi.tracer
-        todoist_api1 = runtimedi.todoist_api
-        todoist_api2 = runtimedi.todoist_api
         backup_downloader1 = runtimedi.backup_downloader
         backup_downloader2 = runtimedi.backup_downloader
         backup_attachments_dl1 = runtimedi.backup_attachments_downloader
@@ -26,8 +24,6 @@ def test_runtime_dependency_injector_caches_values(self):
         # Assert
         self.assertIs(tracer1, tracer2)
         self.assertIsNotNone(tracer1)
-        self.assertIs(todoist_api1, todoist_api2)
-        self.assertIsNotNone(todoist_api1)
         self.assertIs(backup_downloader1, backup_downloader2)
         self.assertIsNotNone(backup_downloader1)
         self.assertIs(backup_attachments_dl1, backup_attachments_dl2)
diff --git a/todoist_full_offline_backup/tests/test_todoist_api.py b/todoist_full_offline_backup/tests/test_todoist_api.py
index 0ed6cbb..e5c111f 100644
--- a/todoist_full_offline_backup/tests/test_todoist_api.py
+++ b/todoist_full_offline_backup/tests/test_todoist_api.py
@@ -3,69 +3,70 @@
 # pylint: disable=invalid-name
 import unittest
 from unittest.mock import MagicMock, ANY
-import datetime
 from ..todoist_api import TodoistApi
 from ..tracer import NullTracer
 
 class TestTodoistApi(unittest.TestCase):
     """ Tests for the Todoist API wrapper """
 
-    def test_on_empty_json_returns_empty_list(self):
-        """ Tests that when the operation to get the backups returns an empty JSON list,
-            an empty list of backups is returned """
+    def test_on_empty_projects_json_returns_empty_list(self):
+        """ Tests that when the operation to get the projects returns an empty JSON list,
+            an empty list of projects is returned """
         # Arrange
         mock_urldownloader = MagicMock()
-        mock_urldownloader.get.return_value = "[]".encode()
+        mock_urldownloader.get.return_value = '{"projects": []}'.encode()
 
         # Act
-        backups = TodoistApi("FAKE_TOKEN", NullTracer(), mock_urldownloader).get_backups()
+        projects = TodoistApi("FAKE_TOKEN", NullTracer(), mock_urldownloader).get_projects()
 
         # Assert
-        self.assertEqual(len(backups), 0)
+        self.assertEqual(len(projects), 0)
 
-    def test_on_valid_json_returns_associated_backups(self):
-        """ Tests that when the operation to get the backups returns a valid JSON list,
-            the correct list of backups is returned """
+    def test_on_valid_projects_json_returns_associated_projects(self):
+        """ Tests that when the operation to get the projects returns a valid JSON list,
+            the correct list of projects is returned """
 
         # Arrange
         mock_urldownloader = MagicMock()
-        mock_urldownloader.get.return_value = """[
-            {"version":"2016-01-13 02:03","url":"https://www.example.com/1.zip"},
-            {"version":"2016-01-12 06:03","url":"https://www.example.com/2.zip"}
-        ]""".encode()
+        mock_urldownloader.get.return_value = """{ "projects" : [
+            { "id" : 2181147711, "name" : "Not Work" },
+            { "id" : 2181147713, "name" : "Work" }
+        ]}""".encode()
 
         todoist_api = TodoistApi("FAKE_TOKEN", NullTracer(), mock_urldownloader)
 
         # Act
-        backups = todoist_api.get_backups()
+        projects = todoist_api.get_projects()
 
         # Assert
-        self.assertEqual(len(backups), 2)
-        self.assertEqual(backups[0].version, "2016-01-13 02:03")
-        self.assertEqual(backups[0].version_date, datetime.datetime(2016, 1, 13, 2, 3))
-        self.assertEqual(backups[0].url, "https://www.example.com/1.zip")
+        self.assertEqual(len(projects), 2)
+        self.assertEqual(projects[0].identifier, 2181147711)
+        self.assertEqual(projects[0].name, "Not Work")
 
-        self.assertEqual(backups[1].version, "2016-01-12 06:03")
-        self.assertEqual(backups[1].version_date, datetime.datetime(2016, 1, 12, 6, 3))
-        self.assertEqual(backups[1].url, "https://www.example.com/2.zip")
+        self.assertEqual(projects[1].identifier, 2181147713)
+        self.assertEqual(projects[1].name, "Work")
 
     @staticmethod
-    def test_on_call_with_token_calls_download_with_token():
+    def test_on_call_get_projects_with_token_calls_download_with_token():
         """ Tests that the token is correctly URL encoded when using the Todoist API """
 
         # Arrange
         mock_urldownloader = MagicMock()
-        mock_urldownloader.get.return_value = "[]".encode()
+        mock_urldownloader.get.return_value = '{"projects": []}'.encode()
 
         todoist_api = TodoistApi("FAKE TOKEN", NullTracer(), mock_urldownloader)
 
         # Act
-        todoist_api.get_backups()
+        todoist_api.get_projects()
 
         # Assert
-        mock_urldownloader.get.assert_called_with(ANY, {'token': 'FAKE TOKEN'})
+        mock_urldownloader.get.assert_called_with(ANY, {
+            'token': 'FAKE TOKEN',
+            'sync_token': '*',
+            'resource_types': '["projects"]'
+        })
 
-    def test_on_invalid_json_throws_exception(self):
+    def test_on_invalid_projects_json_throws_exception(self):
         """ Tests that an exception is thrown when the Todoist API returns an invalid JSON """
 
         # Arrange
@@ -75,9 +76,9 @@ def test_on_invalid_json_throws_exception(self):
         todoist_api = TodoistApi("FAKE_TOKEN", NullTracer(), mock_urldownloader)
 
         # Act/Assert
-        self.assertRaises(Exception, todoist_api.get_backups)
+        self.assertRaises(Exception, todoist_api.get_projects)
 
-    def test_on_http_fail_throws_exception(self):
+    def test_on_projects_http_fail_throws_exception(self):
         """ Tests that an exception is thrown on a HTTP error when using the Todoist API """
 
         # Arrange
@@ -87,4 +88,4 @@ def test_on_http_fail_throws_exception(self):
         todoist_api = TodoistApi("FAKE_TOKEN", NullTracer(), mock_urldownloader)
 
         # Act/Assert
-        self.assertRaises(Exception, todoist_api.get_backups)
+        self.assertRaises(Exception, todoist_api.get_projects)
diff --git a/todoist_full_offline_backup/todoist_api.py b/todoist_full_offline_backup/todoist_api.py
index 954ecf7..57a3e3d 100644
--- a/todoist_full_offline_backup/todoist_api.py
+++ b/todoist_full_offline_backup/todoist_api.py
@@ -1,39 +1,49 @@
 #!/usr/bin/python3
 """ Provides access to a subset of the features of the Todoist API"""
 
-import datetime
 import json
 
-class TodoistBackupInfo:
-    """ Represents the properties of a Todoist backup """
+class TodoistProjectInfo:
+    """ Represents the properties of a Todoist project """
 
-    def __init__(self, version, url):
-        self.version = version
-        self.url = url
-
-    @property
-    def version_date(self):
-        """ Parses the Todoist backup version as a date and time """
-        return datetime.datetime.strptime(self.version, "%Y-%m-%d %H:%M")
+    def __init__(self, name, identifier):
+        self.name = name
+        self.identifier = identifier
 
 class TodoistApi:
     """ Provides access to a subset of the features of the Todoist API"""
 
-    __BACKUP_LIST_ENDPOINT = "https://todoist.com/api/v7/backups/get"
+    __SYNC_ENDPOINT = "https://todoist.com/api/v7/sync"
+    __EXPORT_PROJECT_AS_CSV_FILE_ENDPOINT = "https://todoist.com/api/v7/templates/export_as_file"
 
     def __init__(self, api_token, tracer, urldownloader):
         self.__api_token = api_token
         self.__tracer = tracer
         self.__urldownloader = urldownloader
 
-    def get_backups(self):
-        """ Obtains the list of all backups from the Todoist API """
-        self.__tracer.trace("Fetching backups using the Todoist API...")
-        backup_list_json = self.__urldownloader.get(
-            self.__BACKUP_LIST_ENDPOINT, {"token": self.__api_token})
-
-        self.__tracer.trace("Loading Todoist API backup JSON...")
-        backup_list = json.loads(backup_list_json.decode())
-
-        self.__tracer.trace("Parsing Todoist API backup JSON...")
-        return [TodoistBackupInfo(row["version"], row["url"]) for row in backup_list]
+    def get_projects(self):
+        """ Obtains the list of all projects from the Todoist API """
+        self.__tracer.trace("Fetching projects using the Todoist API...")
+        project_list_json = self.__urldownloader.get(
+            self.__SYNC_ENDPOINT, {
+                "token": self.__api_token,
+                "sync_token": '*',
+                "resource_types": '["projects"]',
+            })
+
+        self.__tracer.trace("Loading Todoist API projects JSON...")
+        project_list = json.loads(project_list_json.decode())
+
+        self.__tracer.trace("Parsing Todoist API projects JSON...")
+        return [TodoistProjectInfo(row["name"], row["id"]) for row in project_list["projects"]]
+
+    def export_project_as_csv(self, project):
+        """ Obtains the latest version of the specified project as a CSV file """
+        self.__tracer.trace("Fetching project '{}' (ID {}) as CSV using the Todoist API...".format(
+            project.name, project.identifier))
+
+        return self.__urldownloader.get(
+            self.__EXPORT_PROJECT_AS_CSV_FILE_ENDPOINT, {
+                "token": self.__api_token,
+                "project_id": project.identifier
+            })
diff --git a/todoist_full_offline_backup/utils.py b/todoist_full_offline_backup/utils.py
index 54faeb8..810aa49 100644
--- a/todoist_full_offline_backup/utils.py
+++ b/todoist_full_offline_backup/utils.py
@@ -4,4 +4,4 @@
 
 def sanitize_file_name(filename):
     """ Sanitizes a file name, removing characters that may cause problems on some platforms """
-    return re.sub(r'[^a-zA-Z0-9_.\- ]', "_", filename)
+    return re.sub(r'[\\/:*?\"<>|]', "", filename)