Draft preliminary use cases

UseCases/CreateGroupAccount.md

+# Create A Group Account
+
+## Summary
+A new group account directory is created and made available through the service website.
+
+## Rationale
+The service account is a unique identifier that may correspond to individuals, campus units, or working groups. It is the primary means of managing and finding projects, groups, and people within the service. Group accounts (also Organization accounts) are similar to individual accounts except that they are typically shared among multiple users instead of used by an individual.
+
+Group accounts provide high level access to projects, separation of projects, management of project team membership and access, and institutional data retention.
+
+## Actors
+All users
+
+## Preconditions
+1. Individual accounts corresponding to NetIDs are assumed to be prepopulated or created automatically on first login.
+2. The user is logged in.
+
+## Basic Flow
+1. The website displays the user's account dashboard.
+2. The user clicks the New Group link.
+3. The website displays the New Group Options page
+4. The user enters information about the project:
+    * Group Name
+    * Group Description
+    * Additional options (e.g., initial members)
+5. The website creates the Group account
+    * Creates Group web directory under service root
+    * Adds specified users to Group
+    * Adds Group dashboard option to member user accounts
+6. The website redirects the user to the new Group settings page.
+
+## Alternate Flows
+1. Insufficient Privilege: A process should exist for creating groups corresponding to campus units. In some cases, the user might be prompted to follow an alternate path to prove that they should own a departmental Group account.
+
+## Exception Flows
+1. Name Conflict: When leaving the Group Name field, the website will check for name conflicts within the service. If a conflict exists, the user will be prompted for a different name.
+
+## Post Conditions
+1. A web-accessible Group account directory is available and ready to be populated with teams and projects.
+2. Access to project assets is granted to Group members.
+3. The Group name appears in the group members' dashboards.

UseCases/CreateProject.md

+# Create A Project
+
+## Summary
+A new project directory containing default/requested service features (e.g., git repository, issue tracker, etc.) is scaffolded in the owner's account and made available to authorized users.
+
+## Rationale
+This use case is a prerequisite for nearly all other service use cases. A project is a named instance of service features, providing users with a single location to manage file versions, access control, issues, and updates. Project names are unique to a given account, but may be repeated in different accounts. Projects may be owned by individual or organizational accounts. They may be fully public, fully private, or somewhere in between.
+
+## Actors
+All users
+
+## Preconditions
+1. A user account exists to contain the project.
+2. The user is logged in.
+
+## Basic Flow
+1. The website displays the user's account dashboard.
+2. The user clicks the New Project link.
+3. The website displays the New Project Options page
+4. The user enters information about the project:
+    * Project Name
+    * Project Description
+    * Basic project visibility
+    * Additional options (e.g., License, Readme, .gitignore)
+5. The website initializes the project
+    * Creates project web directory under owner's account
+    * Creates source repository
+    * Creates project-specific issue tracker
+    * Scaffolds any default/optional files and features
+    * Restricts access as specified
+6. The website redirects the user to the new project page.
+
+## Alternate Flows
+1. At step 4, the user may specify an alternate owner account (e.g., a service organization or team to which the user belongs). The service will create the new project under the organization's account instead of the individual user's account.
+2. At step 4, the user may be prompted to import an existing project from a supported selection of comparable services. At step 8, the project will be initialized, then populated using the repository and issues from the original project.
+
+## Exception Flows
+* Name Conflict: When leaving the Project Name field, the website will check for name conflicts within the Owner's account. If a conflict exists, the user will be prompted for a different name.
+* Insufficient Access: When creating a project in an organizational account, a user may find that their access has been revoked. The website will warn of the error and return the user to the project creation screen, or will create the project with the user as owner.
+* Disk Quota Reached: If storage quotas are in place, the user may be notified that they do not have sufficient storage to create a new project, and will be prompted to clear space in their account.
+
+## Post Conditions
+1. A web-accessible project directory is available under the Owner's account.
+2. A git repository is ready to be populated with files.
+3. A web-accessible issue tracker is ready to be populated with issues.
+4. Any scaffolded files (e.g., Readme, license, .gitignore) are available in the project repository.
+5. Access to project assets, including project existence and name, are restricted to the specified groups.
+6. The project name appears in the project owner's dashboard.

UseCases/CreateTeam.md

+# Create A Project Team
+
+## Summary
+A new role, populated with members, is created within an account and may be used to modify access to a project or Group account. Team membership may be tied to campus AD or use external accounts. Team names are unique to an account, but may be repeated across the service (e.g., Developers).
+
+## Rationale
+In a sufficiently complex project or organization, project owners will want to be able to assign permissions by role instead of by individual user account. Role-based Teams simplify management and reduce risk by providing a central location in which to add and remove members from teams (e.g., an employee leaves the university), and teams from projects (e.g., an external vendor's contract has expired).
+
+## Actors
+1. All users
+2. All Groups
+
+## Preconditions
+1. An individual or group account that will house the new team.
+2. The user is logged in.
+
+## Basic Flow
+1. The website displays the user's account dashboard.
+2. The user clicks the New Team link.
+3. The website displays the New Team Options page
+4. The user enters information about the project:
+    * Team Name
+    * Team Description
+    * Team Members by account name or AD group
+    * Additional privileges (e.g., Team Admin)
+5. The website creates the Team
+    * Creates Team populated with specified members
+    * Adds Team to account Teams page
+    * Lists number of projects with Team permissions
+6. The website redirects the user to the new Team settings page.
+
+## Alternate Flows
+
+## Exception Flows
+1. Name Conflict: When leaving the Group Name field, the website will check for name conflicts within the service. If a conflict exists, the user will be prompted for a different name.
+
+## Post Conditions
+1. A web-accessible Team directory is available to be modified from the owner's account.
+2. A Team pseudo-account is available and may be used to modify project or Group account access.

UseCases/FileIssue.md

+# File an Issue
+
+## Summary
+A unique issue with appropriate metadata (issue number, labels, milestones, author, etc.) and attachments is added to a project issue tracker.
+
+## Rationale
+Project issues are a project's to-do list. They may be used for anything from bug reports and enhancements to feature requests and change proposals. Project contributors must be able to browse or search existing issues (including closed issues), and should be able to filter by metadata (issue type, milestone, date, etc.).
+
+With sufficient privilege contributors should be able to assign issues to users, add existing category labels, and add existing project milestones.
+
+## Actors
+1. All users with accounts
+2. All users without accounts
+
+## Preconditions
+1. A project with an issue tracker
+2. Sufficient access to view a project's issue tracker
+
+## Basic Flow
+1. The user opens the project issue page and clicks the New Issue link.
+2. The website displays the New Issue page, with both Edit and Preview tabs.
+3. The user enters information about the issue:
+    * Issue Title
+    * Issue Description: the user may reference other issues, lines of code, commits, users, etc.
+    * Labels
+    * Milestone
+    * Assignee
+4. The user may preview the rendered markdown using the Preview tab.
+5. The website generates a unique issue number and adds the user-submitted information.
+6. The website redirects the user to the new issue.
+
+## Alternate Flows
+1. The user may use an API to generate an issue programmatically. The service will send an appropriate response instead of redirecting to a webpage.
+2. The issue tracker may allow public read, but authenticated write. The service will prompt for login at step 2.
+
+## Exception Flows
+1.
+
+## Post Conditions

UseCases/Templates/Sample-UseCase.md

+# Name 	UC-8: Search and Replace
+## Summary
+All occurrences of a search term are replaced with replacement text.
+
+## Rationale
+While editing a document, many users find that there is text somewhere in the file being edited that needs to be replaced, but searching for it manually by looking through the entire document is time-consuming and ineffective. The search-and-replace function allows the user to find it automatically and replace it with specified text. Sometimes this term is repeated in many places and needs to be replaced. At other times, only the first occurrence should be replaced. The user may also wish to simply find the location of that text without replacing it.
+
+## Users
+All users
+
+## Preconditions
+A document is loaded and being edited.
+
+## Basic Course of Events 	
+1. The user indicates that the software is to perform a search-and-replace in the document.
+2. The software responds by requesting the search term and the replacement text.
+3. The user inputs the search term and replacement text and indicates that all occurrences are to be replaced.
+4. The software replaces all occurrences of the search term with the replacement text.
+
+## Alternative Paths 	
+1. In Step 3, the user indicates that only the first occurrence is to be replaced. In this case, the software finds the first occurrence of the search term in the document being edited and replaces it with the replacement text. The postcondition state is identical, except only the first occurrence is replaced, and the replacement text is highlighted.
+2. In Step 3, the user indicates that the software is only to search and not replace, and does not specify replacement text. In this case, the software highlights the first occurrence of the search term and the use case ends.
+3. The user may decide to abort the search-and-replace operation at any time during Steps 1, 2, or 3. In this case, the software returns to the precondition state.
+
+## Postconditions
+All occurrences of the search term have been replaced with the replacement text.

UseCases/Templates/Template-UseCase.md

+# Use Case Template
+
+## Name
+A clear verb/noun or actor/verb/noun descriptor that communicates the scope of the use case.
+
+## Brief Description
+A brief paragraph of text describing the scope of the use case.
+
+## Actors
+A list of the types of users who can engage in the activities described in the use case. Actor names should not correspond to job titles.
+
+## Preconditions
+Anything the solution can assume to be true when the use case begins.
+
+## Basic Flow
+The set of steps the actors take to accomplish the goal of the use case. A clear description of what the system does in response to each user action.
+
+## Alternate Flows
+Capture the less common user/system interactions, such as being on a new computer and answering a security question.
+
+## Exception Flows
+The things that can happen that prevent the user from achieving their goal, such as providing an incorrect username and password.
+
+## Post Conditions
+Anything that must be true when the use case is complete.