Need to write a process that will clean up posts/post list items that are trashed or should no longer belong to a post filter.

Add a flag to folders and to folder assets to indicate what has been synced and what has not been synced to the remote site.

For folders, if synced there should be an associated draft.
For folder assets, if synced there should be an associated attachment to the draft.

Assets can not be synced until their story has a draft.

• Dark mode
• Accessibility
• State Restoration

The new default page sheet presentation style in iOS 13 means the presenting view controller never receives view(Will/Did)Disappear events or the corresponding view(Will/Did)Appear events when the authentication flow completes. This is preventing the main menu from appearing.

Need to refactor the presentation logic related to the main screen after auth to resolve the issue.

When the app launches a user will see the screen defined in the LaunchScreen.storyboard and then should either see the authentication flow or the post list depending on if they are logged in.

Add some logic to intelligently make this decision and avoid instantiating a flow that is not needed. Ensure the transition from the launch screen is not wonky.

Plan on using the WordPressAuthenticator pod to wrangle signing into the app. A complete implementation will depend on building out our core data model, leveraging the OS keychain, and whether we can rely on WordPress.com bearer token or require username/password for API calls. For now just stub out a simple integration and we'll iterate later.

• Review the authenticator pod.
• Integrate it.
• Stub out an implementation of the self-hosted auth flow.

Add a flag to designate the current working folder.
If the folder is missing or deleted clear the flag and select another.
If there are no folders create one by default and make it the working folder.

Similar to #9, create an option to update an existing post. Keep it simple as a proof of concept.

We anticipate supporting Newspack in a number of languages.
Ensure that Newspack is configured for localization similar to our other apps, and the necessary scripts are in place.

• Dark mode
• Accessibility
• State Restoration

The post list was updated to use a DiffableDataSource for its table view. During the course of the refactor relationships between the Post related models were simplified to rely on a UUID where it made sense.

Let's do the same for media to improve list performance and avoid some tricky core data crashes.

We anticipate relying solely on mobile Gutenberg as the Newspack editor. Investigate the mobile Gutenberg library and integrate it. Stub a simple UI interaction to launch the editor.

• Investigate mobile Gutenberg
• Integrate it.
• Add a button to launch the editor.

Folders should be sortable by data or by name, asc and desc.

Folder contents should be manually sortable.
New items are always appended.
Unsorted items (those shared from another app) should appear in a separate section.

Create and display a basic post list. For now, this should appear right after authentication, or be the first screen the users sees after authenticating. Create the necessary classes for the networking and service layers following our existing remote/service pattern. Create the necessary classes for the UI layer. Consider whether it makes sense to adopt a flux pattern. Ensure a basic level of offline support.

• Investigate the appropriateness of a Flux architecture. Adopt it if it makes sense.
• Create the relevant code for the networking layer (fetching)
• Create the relevant code for the UI layer (viewing, listing)

Add ability to create new folders via the files API.
Folders should be quick to create, and have a default name that can be changed during creation.
There should be a root "stories" folder that contain newly created story folders.

Title has it.

Assume that not all content should automatically be synced.
Add a flag indicating what should be synced and what should not be synced.

For convenience, whenever fetching an updated post also fetch and store any revisions it has. This can be a batch request managed by the API.

There are a large number of TODOs in the v0 code related to error handling. Pick an approach for displaying errors to a user in the UI. Ensure it follows established design principles.

Create a very basic integration with the media picker in order to insert an image into a post. Keep it simple as a proof of concept should be.

In a few places there are controllers calling stores directly to kick off a sync. Refactor this so actions are dispatched to ensure things stay fluxy.

For the version one release we want to allow other apps to view and edit the contents of our documents folder. This requires some configuration in the Xcode project. Configure up the necessary keys and values in the info.plist.

Add ability to change the folder name.
Ensure that naming collisions are handled.

To ensure that we can eventually easily port the core api calls to WordPressKit, insert a new layer to sit between the api calls and flux. The layer should be a thin wrapper around the remote services and only responsible for wrangling API call backs and calling action dispatchers.

Anticipate that we're rely on the MediaPicker-iOS library to manage image and video selection within the editor. Investigate the library, integrate it, and stub some simple UI to present it.

• Investigate MediaPicker-iOS
• Integrate it
• Wire up a button to present the media picker UI.

The Unified Login & Signup project has significant navigational changes made to WordPressAuthenticator-iOS. Update the pod to the latest version to support Newspack.

Wire up the basic ability to sync a folder and its contents. More refined implementation details will come later.

A story folder is represented by a draft. Create a new draft, upload it, save its data locally. A draft should not be synced until it has at least one piece of syncable content.
Story folder assets are represented by attachments to the draft. Unsynced attachments that are flagged to by synced, should be synced.

Create the initial data model for the Newspack app. This should include a strategy for managing migrations, and storing data related to users, sites, posts, and media. Keep the implementation simple for now, but move code related to the persistent store out of the app delegate.

Questions:
What post types are supported? Do we need pages? Other types?
Are we concerned about post formats?
Do we need tags and categories?

• Move core data related code out of the app delegate.
• Create entities and backing code for users
• Create entities and backing code for sites
• Create entities and backing code for posts
• Create entities and backing code for media

Add ability to delete a folder and it's contents. Prompt to confirm before deletion. This only deletes the local contents, nothing remote.

Ghost cells are mostly working but it looks like there might be a glitch where cells do not animate when reused.
Jorge had some thoughts. Investigate and fix.

Let's anticipate that WordPressKit will contain the bulk of the API calls the app will need to make. We'll need to determine the data and service layer architecture before wiring up any calls so for now just add the pod.

• Investigate the WordPressKit pod and confirm its a viable solution for our API layer.
• Integrate into the project.

Set up swift lint support in the Github project.

Well spotted by @jleandroperez when testing #74.

We could handle this a couple of ways. We might try appending a numeric after the name like when creating new stories. Regardless the UI should update appropriately, probably displaying a brief prompt to the user.

Folder renaming is something we could move out of the story folder list and into the details section of the asset list. This might be something we handle as part of the UI implementation.

Display existing story folders in a list.
Any/Every folder in the parent folder should be displayed.

In version 0, the data model was configured anticipating support for a number of entities that we do not plan to support in version 1. Let's clean this up.

Title has it. We want to ensure the v1 app is available and well supported on iPads. In particular ensure multitasking and drag and drop is accounted for

PostListItems have fields that are also present on Posts. Whenever a post is saved in core data, ensure that it updates the relevant fields on the PostListItem to avoid stale data. Maybe something managed by the store... maybe something we could manage on the post if we can see its modified date is more recent than its related item's.

We need a single source of truth for change detection between posts, revisions, autosaves, and stagedEdits. This can potentially exist in a store but it might be nice to have it in a PostListItem since it is aware of both its post (if one is present) and its stagedEdits.

Ensure version one is configured to support other apps sharing text, video, images, and audio to Newspack.

These are the anticipated high level tasks needed to lay the ground work for starting work on a v1.

• #1 Authentication
• #2 App secrets
• #3 Basic Networking/API layer
• #4 Basic editor integration
• #5 Stubbed media support
• #6 Initial data model
• #7 Stubbed post list
• #9 Create a post
• #10 Edit a post
• #11 Browse and insert media into a post

The first pass on Folder Contents was inspecting the file system directly (just like for the story folder themselves). We want to move away from this and rely on core data as a proxy for the file system, as well as implement similar reconciliation logic that we now have for the story folder.

• Remove references to direct file system access
• Implement core data fetching and interaction behaviors for story assets. These will be the general ground work as the particulars will come as individual asset features are implemented.
• Implement basic reconciliation logic. Inspect the contents of a story folder, look for anything new and create the appropriate record for it. Look for anything missing and remove it. Ignore anything that is not a known type.

Mimic the way applications secrets are managed in the WooCommerce and WordPress apps.

• Create a new application in the WordPress developers portal so we have a client ID and secret.
• Create in the Newspack app versions of the relevant secret wrangling code from WooCommerce/WordPress
• Create a new secrets file in the secrets repo.
• Add in the Newspack project a user defined setting pointing to the secrets file.
• Update the project build phase to generate AppCredentials.
• Push the new file to the secrets repo.

Tap to view the contents of a folder.
For now just show a blank list view as the contents.

Update to the current versions of bundler, ruby, cocoapods etc. used by our other apps.
Investigate whether we can move directly to Swift 5 in Newspack.
Investigate whether we can switch to iOS 13 only and embrace SwiftUI for the V1.

Display the contents of a folder in a list.
There should be a matching core data representation backing the contents of a folder. This will require some updates to the current folder code.

Folders and folder contents should:

• Detect when a new folder or asset is added and create any needed data.
• Detect when an existing folder or asset is deleted and clean up any associated data.
• Detect when an existing folder is moved/renamed and maintain the correct data association.

Basically what's in core data should be kept in sync with what's in the file system.

Additionally:

• Associate Folders and contents with a site. Site folders naming should be robust.

Show an icon representing the type of story asset.
There are only specific types that are supported.
When an invalid type is present in a folder, show it separately from valid types. For now, it will be ignored when syncing.

Mimic the error handling in wpios.
Consider a single persistent derived context for background saves.
Consider what we should move off of the main thread.
Ensure we're doing work in a perform block where required.

Need to be able to preview existing posts, and new drafts after the first autosave. Look to see how authentication is handled by WPiOS in order to preview private posts. (Also needed for private media.)

Add simple support for creating a new post. Open the editor from the post list. There should be a way to specify a title and some content. There should be a way to publish the post. Keep it simple.

• Open the editor from the post list
• Support title and content editing
• Add relevant service/networking code to save/publish/sync the new post.
• Add publish option to editor.
• Update the post list to show the new post.

A punch list of things to wrap up between v0 and v1 milestones:

• #19 Ensure the view relies on actions when initiating work in stores. Media should be fine. Double check posts.
• #27 Fix menu view controller presentation on iOS 13
• #22 Double check we have good test coverage for posts
• #17 Let's just remove the ghosts for now.
• #16 Clean up trashed posts. Oguz had thoughts about this.
• #20 and #21 Improve change detection in posts

For later exploration when there is time:

• #15 sync revisions with posts.
• #23 Implement post previews.
• Add scaffolding for syncing taxonomies like categories and tags.