Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/duracellko/planningpoker4azure
Planning Poker 4 Azure
https://github.com/duracellko/planningpoker4azure
asp-net-core azure blazor c-sharp planning-poker scrum scrum-poker service-bus
Last synced: 12 days ago
JSON representation
Planning Poker 4 Azure
- Host: GitHub
- URL: https://github.com/duracellko/planningpoker4azure
- Owner: duracellko
- License: mit
- Created: 2015-02-09T13:05:19.000Z (over 9 years ago)
- Default Branch: master
- Last Pushed: 2024-09-13T11:50:54.000Z (about 2 months ago)
- Last Synced: 2024-09-14T04:13:05.629Z (about 2 months ago)
- Topics: asp-net-core, azure, blazor, c-sharp, planning-poker, scrum, scrum-poker, service-bus
- Language: C#
- Size: 2.95 MB
- Stars: 62
- Watchers: 7
- Forks: 26
- Open Issues: 3
-
Metadata Files:
- Readme: README.md
- License: License.txt
Awesome Lists containing this project
- awesome-blazor - Planning Poker - commit/duracellko/planningpoker4azure?style=flat-square&cacheSeconds=86400) An app to play Planning Poker for distributed teams. The app is implemented using Blazor and shows how to switch between client-side and server-side mode with a configuration change. [Demo](http://planningpoker.duracellko.net). (Sample Projects / Others)
README
# Planning Poker 4 Azure
**Live** @ [http://planningpoker.duracellko.net/](http://planningpoker.duracellko.net/)
- [Overview](#Overview)
- [How to play Planning Poker](#How-to-play-Planning-Poker)
- [Installation](#Installation)
- [Architecture](#Architecture)
- [Configuration](#Configuration)
- [Buid and test](#Buid-and-test)
- [Solution projects](#Solution-projects)
- [Attributions](#Attributions)## Overview
Planning Poker web application allows distributed teams to play [planning poker](https://en.wikipedia.org/wiki/Planning_poker) using just their web browser and is optimized for mobile. The application does not require any registration at all. Scrum Master simply creates a team and all other members connect to the team. Observer role is supported too. The observer can watch the game, but cannot estimate. This is ideal role for a product owner.
## How to play Planning Poker
This guide assumes that you already know what planning poker is about and how to play with real cards. If you need any information about planning poker see the [wikipedia page](https://en.wikipedia.org/wiki/Planning_poker). To play planning poker using this application is very simple. For distributed team a conference call is required as this is not provided by the application.
1. At first Scrum Master creates new team by entering Team name and Scrum master name.
2. Then all team members join the team by entering the same Team name and unique member name.
3. Optionally product owner can join the team by entering the same Team name, unique member name and checking Observer checkbox.
4. When all participants joined the team, the team can discuss first story.
5. After discussion Scrum Master starts the estimation.
6. Then all members pick estimates. Optionally Scrum Master can cancel estimation when any of the members requests that.
7. After all members picked an estimate, the estimates are shown to all participants.
8. If concensus is found then team can discuss another story and Scrum Master can start estimation again. Otherwise team discusses their estimates and then Scrum Master starts estimation again.![Planning Poker screenshot](docs/images/Screenshot.png)
## Installation
Requirements:
- .NET 8.0 runtime
Run: `dotnet Duracellko.PlanningPoker.Web.dll`
### Docker
It is also possible to install the application using Docker image from [duracellko/planningpoker](https://hub.docker.com/r/duracellko/planningpoker) repository.
```
docker pull duracellko/planningpoker
docker run -p 80:8080 duracellko/planningpoker
```## Architecture
Application is implemented using [ASP.NET Core 8.0](https://docs.microsoft.com/en-us/aspnet/core/?view=aspnetcore-8.0). Front-end is Single-Page Application implemented using [Blazor](https://dotnet.microsoft.com/apps/aspnet/web-apps/blazor). This technology allows deployment to different environments:
- Locally on Windows or Linux
- In Docker container
- In [Azure AppService](https://azure.microsoft.com/en-us/services/app-service/)
- or any environment supported by ASP.NET CoreThe application does not have any dependencies to run in basic mode. However, there are configurable advanced features.
### Blazor models
Blazor supports multiple [rendering modes](https://learn.microsoft.com/en-us/aspnet/core/blazor/components/render-modes?view=aspnetcore-8.0) including Client-side and Server-side. It is possible to simply switch between the modes by configuring **UseServerSide** setting.
### Teams storage
By default, when server application is restarted, all teams are lost. It is possible to specify folder to store teams data between application restarts. Team data are stored in JSON format.
### Azure Service Bus
The application is state-full (it stores all teams data in memory). Therefore, it is not simple to deploy the application to a web-farm. Each server in web-farm would have different state of team. However, it is possible to setup [Azure Service Bus](https://azure.microsoft.com/en-us/services/service-bus/) to synchronize state between nodes in web-farm.
## Configuration
The application can be configured using default ASP.NET Core configuration sources:
- appsettings.json
- appsettings._Environment_.json
- Environment variables
- Command-line argumentsThe application has following configuration settings:
```javascript
{
"PlanningPokerClient": {
"UseServerSide": "Never" // string - Never | Always | Mobile
},
"PlanningPoker": {
"RepositoryFolder": "", // string
"RepositoryTeamExpiration": 1200, // integer - time in seconds
"ClientInactivityTimeout": 900, // integer - time in seconds
"ClientInactivityCheckInterval": 60, // integer - time in seconds
"WaitForMessageTimeout": 60, // integer - time in seconds// Azure Service Bus configuration
"ServiceBusConnectionString": "", // string
"ServiceBusTopic": "PlanningPoker", // string
"InitializationTimeout": 60, // integer - time in seconds
"InitializationMessageTimeout": 5, // integer - time in seconds
"SubscriptionMaintenanceInterval": 300, //integer - time in seconds
"SubscriptionInactivityTimeout": 300 // integer - time in seconds
}
}
```- **UseServerSide** (default: Never) - This setting has following options:
- **Always** - Blazor runs in server-side and HTML is synchronized with browser using SignalR.
- **Never** - Blazor runs in WebAssembly on client.
- **Mobile** - Blazor runs on server for mobile devices and on client otherwise. Startup of Blazor can be slow on mobile devices, therefore this option fallbacks to server-side for faster start.
- **RepositoryFolder** (default: empty) - Path to folder, where data are stored between application restarts. Path is relative to the application folder. When this setting is empty, no data are stored and all are lost on application restart.
- **RepositoryTeamExpiration** (default: 1200) - Team is deleted after specified time with no user activity.
- **ClientInactivityTimeout** (default: 900) - User is disconnected from the team after specified time with no connection from the user.
- **ClientInactivityCheckInterval** (default: 60) - Time interval to run periodic job that disconnects innactive users.
- **WaitForMessageTimeout** (default: 60) - Each client requests regularly for status updates. When there is no change in specified time, client receives response that there is no change and requests for update again. This way client notifies to keep connection is alive.
- **ServiceBusConnectionString** (default: empty) - Connection string to Azure Service Bus used to synchronize data between servers in web-farm. For example: Endpoint=myEndpoint;SharedSecretIssuer=mySecret;SharedSecretValue=myPassword;
- **ServiceBusTopic** (default: PlanningPoker) - Nodes uses the specified Service Bus topic for communication.
- **InitializationTimeout** (default: 60) - Time after initialization phase is cancelled and server assumes that it is alone. This timeout should not be reached, because InitializationMessageTimeout is shorter.
- **InitializationMessageTimeout** (default: 5) - Timeout to wait for message from another node during initialization phase. When the timeout is reached, server contacts another node or assumes that it is alone in web-farm.
- **SubscriptionMaintenanceInterval** (default: 300) - Time interval to do periodic check, which nodes in web-farm are responding.
- **SubscriptionInactivityTimeout** (default: 300) - Service Bus subcsriptions are deleted for nodes, which do not respond in the specified time.## Buid and test
Requirements:
- .NET SDK 8.0
To run build and tests simply execute PowerShell script BuildAndRun.ps1.
```powershell
.\BuildAndRun.ps1
```Optionally it is possible to include execution of end-2-end tests using Selenium.
```powershell
.\BuildAndRun.ps1 -E2ETest:$true
```### Run in Visual Studio
**PlanningPokerCore.sln** solution can be normally open, built and debugged in Visual Studio 2022. Also unit tests can be executed.
For end-2-end tests (Duracellko.PlanningPoker.E2ETest) Playwright dependencies (browser) need to be installed. Simply execute following commands:
```
.\Build\bin\Debug\net8.0\playwright.ps1 install chromium
```## Solution projects
PlanningPoker solution contains following projects:
* **PlanningPoker.Domain** contains domain classes of the application. This includes domain logic and entities e.g. ScrumMaster, Estimation.
* **PlanningPoker** implements host of domain objects, JSON web service and file-system repository.
* **PlanningPoker.Service** implements DTOs shared between server and client.
* **PlanningPoker.Web** is host application. It starts ASP.NET Core hosting, dependency injection and loads configuration.
* **PlanningPoker.Client** is Blazor SPA client. It containes 2 pages, Blazor components and communication with the server.
* **PlanningPoker.Azure** contains modified host of domain objects used on Windows Azure platform. Additionally it implements communication between cloud instances using [Service Bus](https://azure.microsoft.com/products/service-bus/).
* **PlanningPoker.Redis** contains extension to use [Redis PubSub](https://redis.com/glossary/pub-sub/) instead of Azure Service Bus.
* **PlanningPoker.Domain.Test** contains unit-tests of domain classes.
* **PlanningPoker.Test** contains unit-tests of PlanningPoker project classes.
* **PlanningPoker.Client.Test** contains unit-tests of client application.
* **PlanningPoker.Azure.Test** contains unit-tests of classes in PlanningPoker.Azure project.
* **PlanningPoker.E2ETest** contains end-2-end tests of full system. Tests are implemented using Selenium and tests mostly Chrome browser and partially Firefox.## Attributions
This application including source code can be used under [MIT License](License.txt).
* [Planning Poker](https://www.mountaingoatsoftware.com/agile/planning-poker/license) is a registered trademark of Mountain Goat Software, LLC.
* [Rock, Paper, Scissors, Lizard, Spock](http://www.samkass.com/theories/RPSSL.html) is licensed under [CC BY-NC 3.0](https://creativecommons.org/licenses/by-nc/3.0/).
* [Open Iconic](https://useiconic.com/open) is licensed under [MIT](https://opensource.org/licenses/MIT) and [OFL](https://scripts.sil.org/cms/scripts/page.php?item_id=OFL_web).
* Translations are made available thanks to following people:
* Italian - [@johnfelipe](https://github.com/johnfelipe)
* Spanish - [@johnfelipe](https://github.com/johnfelipe)