Start a Project on the TPEN website

### Primary Agent

Scholar/Researcher

### Story

```markdown
As a researcher, I would like to log into TPEN and start a transcription project. The images I select may be of a few types:

- a IIIF Manifest.json file
- an open image URL
- a local file that I have on my own machine
- an actual book or separately held image that cannot be referenced
- maybe I can browse or search through some collections of manuscripts

I would like to have the option of jumping right in or configuring my project before beginning.
```

### Resources Involved

- [ ] TPEN 3: business card site
- [X] Services: the main API hub
- [ ] TinyPen: the RERUM proxy
- [ ] Static: the midcache for complex documents
- [ ] Users: Auth0 User management and tools
- [X] RERUM (external): Linked Open Data
- [X] Interfaces: web interfaces for humans and reports
- [ ] Rerum Inbox (external): Linked Open Data Notification Inbox
- [X] External Service

### Structural Solution

```markdown
An authenticated user can call a `new Project(resources)` constructor. The interface is the tricky part. A IIIF solution should support drag-n-drop feature as well. A local file solution could be a guide to uploading to GitHub or a sophisticated module to use the GitHub API to spin up a repo. Pasting in a single image url is straightforward and should be converted to a IIIF resource.

Solutions for multiple image URLs and collection browser are similar. A separate, possibly out of scope, application can create a manifest.json and publish it online (or save in RERUM) and then enter TPEN at some "create project from IIIF Manifest" end point. A non-imaged transcription would require its own special transcription interface, but the project and Annotation Collections never require an image to exist.

The resulting interface once a project is created may be a configurable thing or have a parameter as a callback location. Suggestions include:
- start transcribing on creation
- manage project page to add metadata, titles, collaborators, etc.
- list of all projects
- success report and return to the "create a project" interface
- send project id/info to internal or external API

In the API services, documents representing the content should be built and stored in RERUM, baseline config and group management should be in the local database, and possibly some helpful documents will also be queued in the Static files cache.

IIIF Commons libraries in GitHub may be considered for work here, as they do not have the same debt as some other files. It might also be possible to bury these in Interfaces that are non-essential alternatives.
```

### Additional context

```markdown
This is a risky place for scope creep but we should prioritize building a system that may not include all the options, but which takes pains to not exclude any of them. This may be later development or third parties.

It should also be noted that the minimum valid project has not been defined, nor has a schema been established. The scope of this story assumes only a project can exist.
```