hackathon_id
int64 1.57k
23.4k
| project_link
stringlengths 30
96
| full_desc
stringlengths 1
547k
⌀ | title
stringlengths 1
60
⌀ | brief_desc
stringlengths 1
200
⌀ | team_members
stringlengths 2
870
| prize
stringlengths 2
792
| tags
stringlengths 2
4.47k
| __index_level_0__
int64 0
695
|
|---|---|---|---|---|---|---|---|---|
10,045 | https://devpost.com/software/news-7xmdr2 | Inspiration
What it does
Content management for news.
How I built it
Challenges I ran into
Accomplishments that I'm proud of
What I learned
What's next for News
Built With
bitbucket
confluence
forge
Try it out
bitbucket.org | News | News Management | ['Tri Labs'] | [] | ['bitbucket', 'confluence', 'forge'] | 158 |
10,045 | https://devpost.com/software/velocity-chart-for-confluence-cloud | Inspiration
Velocity report in Jira provides important information to Scrum teams about their plans, achievements, and trends. We created Velocity Chart macro that can be added to Confluence Cloud pages.
What it does
Velocity Chart for Confluence Cloud enables you to discover and visualize the history and trends, progress and performance of Agile Teams with the following sprint metrics:
Initial commitment
Final commitment
Added work
Removed work
Estimate change
Not completed work
Completed work
Key features:
Support of Issue Count, Story Points, Time estimates
Filter sprint issues using JQL
Group sprints by month / quarter
Sprints from date range
Filter sprints by name
Moving average / all sprints average
Multiple chart types (bar, line, stack)
Export data to Excel
View sprint issues (Sprint Report)
How I built it
We have built Velocity Chart for Confluence Cloud using React, Atlaskit and Atlassian Connect.
Challenges I ran into
The biggest challenge was to fetch data in Confluence Cloud from Jira Cloud. Due to lack of support of
OAuth 2 for Jira Software
we had to use our existing app Agile Velocity Chart Gadget for Jira as a required dependency in a data flow.
Accomplishments that I'm proud of
We have managed to reuse 99% of the frontend code for of the Velocity Chart gadget for Jira to create Velocity Chart for Confluence Cloud. With the support of Confluence Cloud now Velocity Chart can be run in Jira and Confluence in any platform.
What's next for Velocity Chart for Confluence Cloud
At the moment Velocity Chart covers team and product (cross-team) levels. As a next step we will add support for individual user velocity.
Built With
connect
node.js
react
Try it out
marketplace.atlassian.com | Velocity Chart for Confluence Cloud | Velocity Chart to track progress of Agile Teams. Configurable. Reliable. Fast | ['Vasyl Krokha'] | [] | ['connect', 'node.js', 'react'] | 159 |
10,045 | https://devpost.com/software/issue-participants-for-jira | See how each team member contributes to great work
Inspiration
The idea for the app was born from our daily work. Very often not only people from the support team are involved in support requests, but also people from other teams: developers, testers, product owners, testers. We often exchange internal comments, but sometimes we need to discuss the problem. Before the coronavirus pandemic, when we worked in the office, we all met at one desk (most of us sat in one room) and discussed. Now, when we work remotely, we organize conversations on Slack or meetings on Zoom. Every time we have to wonder "
Who should participate in the conversation?
". We lacked an overview of the people involved in the issue. In addition, we noticed that it would be a lot easier to set up a channel on Slack or to organize a meeting on Zoom with one click, where all issue participants would be invited.
What it does
This app displays all users involved in the issue. These are people who performed an action related to it, for example, created an issue, added a comment, logged in working time, etc. All this information is easily available in the
Issue Glance
.
This app works also in Next-Gen Jira projects.
How we built it
We used Forge UI components which helped us create the front end of our app:
IssueGlance
Table
Text Link
We also used Forge Fetch API which is a partial implementation of node-fetch.
We manage the entire project using Jira Cloud and Confluence. We have prepared the interface graphic designs in Figma.
Challenges we ran into
The biggest pain caused us a lack of support for the Click On event by the AvatarStack component which represents multiple avatars (name and profile picture) for users. For this reason, we have not achieved the effect that was important to us: showing details of the changes made to the issue by the selected user.
In the current version, integrations with Slack and Zoom is not yet done because they need more investigations from our side.
These limitations we reported to the Atlassian team.
Accomplishments that we're proud of
Our beginnings with Forge were very difficult. That is why we consider it successful that the application works. What's more: it works correctly.
The strength of our solution is the
lack of configuration
. The application is installed and is immediately ready for use. On the other hand, we are aware that this can be a problem for large instances. Therefore, in the future, we would like to add a module with a configuration for the administrator.
We think that the design of the panel (glance) and the mechanics of the application's operation do not differ from the Jira standards. We believe that it is important that the end-user does not feel that he is using an external application. Our application fits perfectly into the product offered by Atlassian.
What we learned
This was our first contact with Forge, so everything was new to us. We learned how Forge works, what is currently possible to achieve, what not yet. In case of this app, the biggest limitation was using only their components to build the interface. We cannot use HTML tags and design UI with CSS. Worth noticing that having React background was really helpful to create the app quickly.
None of us has ever participated in any hackathon!
We work with each other every day, but it is a completely different style of work than during such a competition. We were still thinking about how little time we have left, and how much is still to be done. But we can say it was worth it and it certainly is not our last time. We still want to work together :)
What's next for Issue Participants for Jira
The most important functionalities we would like to add to the application are:
details of user activity after clicking on his avatar
showing grouped avatars depending on their actions or the day they were performed
integration with Slack: the ability to create a channel with participants in a single click
integration with Zoom: the ability to organize a meeting with participants in a single click
possibility to create an email where participants are automatically added as recipients
A lot depends on how much Forge will offer us and in what direction its possibilities will develop. Currently, Forge is not supported on the Atlassian Marketplace. (We are looking forward to adding such support!) For this reason, we decided to
convert the application into a Connect app
to be able to share it with other users and publish it on the Marketplace.
Built With
forge | Issue Participants for Jira | Check who participate in the current issue. Adding a comment, changing status, improving description - every action matters. See how each member of the team contributes to great work! | ['Krzysztof Skoropada'] | [] | ['forge'] | 160 |
10,045 | https://devpost.com/software/organisation-reputation | Inspiration
Tickets in Jira can have multiple customer stories and issues. This application gives an insight into the reputation of all the organisations mentioned in the description.
What it does
It applies a Corporate Reputation model based on a set of reputational dimensions (e.g., innovation, social responsibility) and, inside each of them, an array of variables that influence an organisation’s reputation. It returns the name and type of the organisation as well as the sentiment and subjectivity of the assement.
How I built it
This app is available for JIRA. It is built using Forge.
What I learned
Working with Forge
Development and debugging in Javascript
What's next for Organisation Reputation
Make it more visually appealing. Publish a similar application for Confluence
Built With
atlassian
forge
javascript
jira
react | Organisation Reputation | Don't know your clients? Get a list of all the organisations mentioned in your Jira ticket and find out the type of organisation and the general sentiment about them using this App. | ['Saumya Suvarna'] | [] | ['atlassian', 'forge', 'javascript', 'jira', 'react'] | 161 |
10,045 | https://devpost.com/software/page-information-macro | Call Macro
Select a data to be displayed
View Page mode
Edit Page mode
Inspiration
Idea goes from observing how managers tries to combine different source of the information into one page.
They want to keep an eye on everything desirable having one page for that.
For example current status of the product documentation.
That's why on demonstration video I've focused on data aggregation.
However,
Page Information macro
could embed information about current page to itself which should be useful on page exporting, printing or sharing via email.
What it does
Page Information macro
adds a macro to Confluence.
This macro could embed the following information into the page:
ID
Version
Tiny URL
Labels
Author
Created On
Last Changed By
Last Changed On
Of the current or any other page from the instance.
How I built it
Simply and fast.
Forge platform with sdk and good documentation gives an ability to do it.
Development iteration (change, build, deploy, check) takes ~30 seconds which is pleasant experience.
Challenges I ran into
The key to
the Great Plugin
is a great idea behind it.
It turned out that with all limitations of the Forge find even good idea was hard.
Second thing, that I'm Java developer and working with React was something new to me.
Accomplishments that I'm proud of
I did it!
No, really.
Get into, do the job, FINALIZE it (stop to polishing) and submit.
To be done with all these things is kind of a good personal accomplishment.
What I learned
That conception with strict limitation of UI elements (Forge UI on React) could be a good architectural decision for the ecosystem.
Another new thing that I've learned, is how to run JS asynchronous HTTP calls in the loop :)
What's next for Page Information macro
It has some potential as a product, so might be released to the marketplace.
It would be great to publish it as a Forge app. However, seems that Forge has unpredictable date of the final release.
Maybe, I'll recreate it on Atlassian Connect soon.
Regarding additional functionality,
Page Information macro
has a lot of things to be added:
More options, Space information, System information and other stuff...
Built With
forge
visual-studio
Try it out
diceus-bubiakin-qa.atlassian.net | Page Information macro | Show information about the page or any other page directly in the page body | ['Roma Bubyakin'] | [] | ['forge', 'visual-studio'] | 162 |
10,045 | https://devpost.com/software/topic-extraction | Topic Extraction
Inspiration
Sometimes in an attempt to be more through, a lot of unnecessary jargon makes it way into JIRA tickets and confluence pages. With the amount of tickets raised per day, it is really tiresome to go through the entire content at times and a short topic summary would be really useful.
What it does
Topic Extraction parses the description on JIRA tickets and then finds the relevant topics and classifies them into entities(proper nouns like people and places) and concepts(common nouns like products). It also provides the relevant type and subtype for each of these topics if there is one and their respective relevance.
What I learned
Forge.
How to resolve an error on like 2941 in a 50 line Javascript code!
What's next for Topic Extraction
Make it more visually appealing by adding it into a table. Publish a similar application for confluence
Built With
atlassian
forge
javascript
jira | Topic Extraction | JIRA tickets too long?? Only one minute left before your standup?? Don't fret. 'Topic Extraction' will save the day by giving you a list of topics used and their relevance!!! | ['Saumya Suvarna'] | [] | ['atlassian', 'forge', 'javascript', 'jira'] | 163 |
10,045 | https://devpost.com/software/simple-planning-poker | Voting integration
Overview over all votes
Settings
Inspiration
Ticket estimation is quite an important part in the development cycle and takes a lot of time and effort if done right.
Most teams do the estimation on a consensus-based voting with all team members, where games like
planning poker
can improve the estimation process a lot.
Jira marketplace offers several solutions for playing Planning Poker to estimate Story Points, but they are all pretty complicated and just overkill, so with most of our teams we started to write our vote/estimation in a chat, which is annoying for everyone involved.
What it does
Simple Planning Poker integrates directly into the Jira issue and enables all team members to vote (even asynchrounus), calculates the result, updates the story point estimation on the ticket and shows the votes of all members. It is customizable, simple to use and understand.
How I built it
It was build with the Forge Beta and has no external dependencies.
Challenges I ran into
Finding the correct name for the story point field because it is a jira custom field
Updating the story point value, as it seems there is a bug in Jira where the field permissions seem the be incorrect (i can see the story point field on the ticket, in the ticket settings but it is missing in the schema so I cant update it)
Currently with forge it is not possible to "refresh" the UI based on events, so the I needed a refresh-button as workaround
Accomplishments that I'm proud of
The code architecture is quite well.
What I learned
How complicated but interesting it can be to work with Atlassian Products on the development side. That FaaS can be nicely used for integrating widget-like snippets.
What's next for Simple Planning Poker
Add realtime updates (when supported by forge)
Add statistics
Allow more options like "break" "?" as planning poker cards
Built With
forge
jira:issueaction
jira:issuepanel
storage:app | Simple Planning Poker | Most teams use a game called "Planning Poker" as a consensus-based technique to estimate development effort. Simple Planning Poker allows consensus-based estimation directly on a Jira Ticket. | ['Elias W.-S.'] | [] | ['forge', 'jira:issueaction', 'jira:issuepanel', 'storage:app'] | 164 |
10,045 | https://devpost.com/software/mermaid-y3ans2 | Populated macro
Empty Macro
Empty configuration
Populated configuration for the first time
Full page example
Inspiration
Have you ever wanted to create diagrams in a standard format, without the need to click and drag around? Or you wanted people to make diagrams where the look and feel were automatically consistent?
I like graphical user interfaces as much as everyone else as they naturally have an easier learning curve, however I found this was overkill for some simple diagram types, for example flow diagrams would have different padding and spacing depending on the mood I was on that day.
So I wanted to find a more consistent method, that would allow me to just focus on the content and not the style. I did some research and found two popular alternatives:
Mermaid
and
PlantUML
(more on this with challenges later).
What it does
Using markup like:
graph TD
A[Christmas] -->|Get money| B(Go shopping)
B --> C{Let me think}
C -->|One| D[Laptop]
C -->|Two| E[iPhone]
C -->|Three| F[fa:fa-car Car]
To create diagrams like:
Mermaid supports multiple diagram types:
Flowchart
Sequence diagram
Gantt diagram
And a bunch of other ‘experimental’ types.
This a good time to point out that the app I have written is solely for integrating
Mermaid’s Live Editor
project into Confluence using the Forge framework. Credit should be given to Mermaid and the live editor for creating the markup rendering.
How I built it
The app was created with Forge using the the following modules:
macro - to provide the diagram image and the configuration form
function - to define the behaviour of rendering the diagram and the form
Credit should be given to the
Mermaid
project for defining the markdown rendering and
Mermaid’s Live Editor
project for rendering the diagram to an image format.
The app encodes the markdown added through the macro and displays an image sourced from the live editor project.
Challenges I ran into
From the beginning, I did not know how to approach the problem, all I wanted was to use markup to create diagrams. So I started spikes to determine the paths I could take.
The first spike I conducted was to determine libraries that I could use so that I could render the images in Forge. It became apparent that I could not use most libraries as they all required a window DOM. Given the time limitation for completing the project, I chose not to rewrite a rendering engine.
In my second spike I investigated further into using external services to provide the rendering. I looked at both using Mermaid and PlantUML. PlantUML was more fully featured with support for more diagram types than Mermaid. I ended up not going with PlantUML because it did not secure the connection with SSL and made the whole page appear unsecured.
Accomplishments that I’m proud of
Working with Forge has been a pleasure, and the main accomplishment that I have personally gained is how quick it has been for me to get prototypes working.
What I learned
I learned that Forge apps can be used to build on top of other solutions. In my case, I did not need to rewrite the Mermaid libraries, but instead just extended the Mermaid project.
Whats next for Mermaid
I would like to add more dynamic charts, for example to pull in Jira issues and display a pie chart of the statistics. or maybe a timeline using a start date and end date of issues.
Architecturally, I would like to find a method of rendering the diagrams without an external service whether that is via another serverless application or directly in Forge.
Built With
forge
mermaid | Mermaid Diagrams for Confluence | Create technical diagrams with markup using this Mermaid integration. | ['Victor Lee'] | [] | ['forge', 'mermaid'] | 165 |
10,045 | https://devpost.com/software/secure-pages-for-confluence | Apply pre-defined templates
Create restriction template
Create automation rule
List of restriction templates
Inspiration
Some time ago we created Secure Fields for Jira. The app helps users to expand data security for Jira users. We found out that Confluence users have similar issues with keeping data secure and existing Confluence features can be a little hard to manage and enforce keeping data secure.
What it does
The app ease content security management in Confluence Cloud. It allows space admins to create reusable "restriction templates" that can be applied by users with just 2 clicks or can secure newly-created content automatically thanks to automation rules that are based on selected conditions (when conditions are met, specified templates are applied in background).
How I built it
It's AWS-stored pure js application that uses Confluence API to secure content. All data is stored directly in Confluence, so there was no need to build persistency layer. Application purely relies on REST API requests.
Challenges I ran into
We tried out (and finally got it) not to keep any user data in our application and rely on Atlassian cloud data only.
Accomplishments that I'm proud of
Creating app that solves well-defined problem and do it without involving huge effort on both users and admins side. It's our first cloud app, so most of work was connected to explore APIs and solve small technical issues.
What I learned
This plugin was our first successful attempt to cloud development and extesive usage of Confluence REST APIs.
What's next for Secure Pages for Confluence
Create version for on-premise and add more features like export/import template, maybe add more conditions...
Built With
amazon-ec2
amazon-web-services
angular.js
connect
express.js
javascript
node.js
pm2
rxjs
Try it out
marketplace.atlassian.com
marketplace.atlassian.com | Secure Pages for Confluence | Managing information security in cloud is a challenge. Confluence often keeps company secrets and other sensitive information. Secure Pages for Confluence allows to manage content security easily. | ['Robert Dzido'] | [] | ['amazon-ec2', 'amazon-web-services', 'angular.js', 'connect', 'express.js', 'javascript', 'node.js', 'pm2', 'rxjs'] | 166 |
10,045 | https://devpost.com/software/teamployees | Add extended data to the Jira Users
Birthday reminder (Today/Before/Soon)
The list of External (non-Jira) playmates and their extended data
Add extended data to the non-Jira Employees
Filter employees list by labels
Inspiration
When you know every playmate in your team, you know the dates of birth, zodiac signs, hobbies, the circle of interests. But if you a new playmate in the team. What you could know about your Colleagues on your first day? What could be the small talks about?
Such thoughts led us to create the TEAMPLOYEES - useful trifle for me, my team, my company.
What it does
The TEAMPLOYEES plugin keeps you informed about today's birthdays, this week's celebrations, or some birthdays in the few days past as a reminder to congrats your teammates. TEAMPLOYEES is an open product for open teams, all users of your Jira Cloud will be listed in one place. Also - you can add some colleagues, which are not Jira Users yet, but they are the part of your team already, with some base information about them, like a date of birth, Zodiac signs, hobbies, etc. And sure - you can filter such information to find the teammates, with helpful skills.
How we built it
It
s our first experience to create something with Atlassian Connect Express and now we have a result of teamwork, we proud that we make it and we knew that it
s the great start for this year and future wins!
Challenges we ran into
Part of the challenge we have is not to cross the technical restrictions - it was really hard.
Accomplishments that we're proud of
We are proud that we make it together. It`s perfect when the team is working as one Employee. We share the ideas, discuss the value, create requirements, and release our product. It was hard, at the same time - it was cool!
What we learned
It was the first product with Atlassian Connect. Now we know! ))
What's next for Teamployees
Admin settings page
Custom users columns
Change columns range
Complying with the GDPR
Import data from *.csv
Skills radar
Smart filters for labels
Team collaboration
Telegram integration
Validating data by Email
Watcher`s list for custom data
Built With
atlasct | Teamployees | Your team at a glance. Quick access to all shared team mates details: birthday reminders, contacts, locations, skills and other details. | ['Bohdan Belokur', 'Yaroslav Bondarets', 'Dmytro Koziarevych', 'Tetiana Bondar'] | [] | ['atlasct'] | 167 |
10,045 | https://devpost.com/software/thoughtflow | ThoughtFlow Mindmap View
ThoughtFlow Spreadsheet View
ThoughtFlow synced with Trello
Inspiration
The sequential paradigm of
Strategy
followed by
Planning
followed by
Execution
works for companies that rely on quarterly planning. Whereas fast growing companies that think on their feet and make decisions on the move switch between these phases on a weekly or daily basis.
Mindmapping is a popular techniques for Strategic Ideation. It helps in aligning teams, visualizing the big picture, and breaking down complex ideas into simpler achievable steps.
The biggest limitation with the currently available mind mapping tools is that they don't sync with other tools. Which limits their use to the Ideation phase. Once this stage is over, we move on to other tools like spreadsheets for planning and project management tools like Trello for execution.
This also creates larger problems
When we go back to the drawing board, we have to from scratch with a new Mindmap
The teams responsible for the
how and when
lack visibility to the
why
as the strategy and execution are not interlinked. This creates misalignment.
With ThoughtFlow, our goal is to help teams bring their
strategic
,
tactical
and day-to-day
activities
of their work on a single interconnected “map”, so that they can work independently, while still being perfectly aligned to the larger picture.
What it does
ThoughtFlow combines the visual flow of a mindmap with the computational power of a spreadsheet and integrates with popular project management tools like Trello and Jira.
Teams can brainstorm using mindmaps, or use one of the inbuilt Ideation templates like User Story Mapping and Impact Mapping.
A spreadsheet view allows for planning and prioritization by adding additional fields like effort estimates and dates. Prioritization scores can be created by combining multiple fields like impact and effort using the formula feature.
Integrations with tools like Trello and Jira allow teams to continue using their familiar and favorite tools while having the context of the bigger picture behind their tasks.
How I built it
Initially, it was a personal itch. My workflow involved Mindmaps, Spreadsheets and Trello. I spent a lot of time copy pasting back and forth between these tools which was a big pain. I wanted to build something to solve this, and
posted on LinkedIn
to see if others would be interested.
To my surprise, the post went viral and gained a lot of traction. I searched on the net if someone was looking for something like this, and came across
posts on various forums
.
The current product is the result of multiple iterations using the lean startup approach of interviewing users, building prototypes, and acting on the feedback. It's built on the MEAN stack.
Challenges I ran into
The biggest challenge was getting to a design that could handle the complexity of what’s possible, and at the same time be extremely simple to use. This took multiple iterations of releasing something and observe people use it to identify the mental bottlenecks.
Accomplishments that I'm proud of
We came to know of codegeist only a week back. Although a trello integration was always on our roadmap, we never prioritized it. With this contest we took a chance and gave it a shot :)
So I’m pretty proud that we are able to make a decent submission with the integration and video in such a short period
What I learned
Got introduced to the trello power-up API, and atlassian connect API. Learnt that we work best under tight timelines as it forces us to pick the important items and ignore the rest.
What's next for ThoughtFlow
Improving the Trello Integration
Integrate pricing plans
Integrate with Jira, Asana and Monday
Create ideation and planning templates for product managers
Get our first 100 customers and take it from there
Built With
angular.js
loopback
mongodb
node.js
Try it out
app.thoughtflow.io | Mindmapping for Trello | Turn Mindmaps and Spreadsheet into Trello Cards | ['Kranthi Kiran'] | [] | ['angular.js', 'loopback', 'mongodb', 'node.js'] | 168 |
10,045 | https://devpost.com/software/issue-time-in-status | Inspiration
When working with the team as a scrum master or project manager it happens that some issues take longer to deliver then others and we need to see retrospectively where was a problem.
There is Time in a status gadget which is great for analyzing average time in status on high level (project) but when investigating causes of some of the statuses taking too long we need to look on the issue level.
Was issue too long in Code review? Or in testing? To figure out we would need to go through issue history and that might take a long time 😓
What it does
The Issue Time in Status shows a bar chart in the issue under the description.
From the chart, you can see the different statuses issue went through and how long it was in this status.
How I built it
We are using the Jira APIs to retrieve status information for the issue. After formatting the data in the desired structure we use a 3rd party service called
https://quickchart.io/
that exposes an API to send data and return a processed bar chart image with time on Y axis and statuses on X axis. This statuses chart then gets embedded into the issue fragment using the Image component from Forge-UI.
Challenges I ran into
Due to Forge limitations and restrictions in rendering any sort of pure HTML and CSS elements we had to come up with an alternative to generating the diagram
Accomplishments that I'm proud of
Once we figured out the chart solution the implementation was pretty straight forward
What I learned
That when there are limitations you get creative :)
What's next for Issue Time in Status
The app is a great addition to Project Time in Status gadget and will be ready to be used once forge is enabled.
Built With
forge
Try it out
bitbucket.org | Issue Time in Status | Never go through history logs again. See for how long was your issue in different statuses from a simple chart. | ['Biro Florin'] | [] | ['forge'] | 169 |
10,045 | https://devpost.com/software/comment-sentiment-analyzer | Inspiration
When working on production support, sometimes it happens that the client gets frustrated and support needs to handle the conversation well. One of the tools that can help spot frustration early on is sentiment analysis on the comments. We can then react to the ticket accordingly before it graduates to the state where we could even lose the client.
Sentiment analysis can also play an important part of project management. Happy teams work better together and deliver higher-value and achieve goals easier then unhappy, demotivated teams.
Analyzing and tracking the sentiment of issues can be a great addition to the project analysis tools. If you spot some issue is being problematic you can quickly check the Issue sentiment and even see the sentiment of people involved in the comments.
So you don't need to read through all comments anymore to see if the discussion is healthy or heated and take quick actions.
What it does
Comment Sentiment analyzer looks through the comments and shows sentiment in the 'Comments tone analyser' section in the right panel of the issue.
Here you can see:
the average sentiment of the issue (includes all comments in the issue)
the average sentiment per user
How I built it
A small but useful Forge app that pulls user input text from issue comments and description and processes using sentiment library and the AFINN-165 wordlist to identify the tone of voice.
Challenges I ran into
There is no straight forward way to apply styling in Forge so we had to use some SVG wizardry to make the tone list show the way it does
Limitations in Forge, we wanted to add the average sentiment emoji in a lozenge on the Glance tab. This would’ve enabled user to quickly understand if the issue needs attention. This is not currently possible with Forge.
Accomplishments that I'm proud of
Making the list of users and their tone assessment look as per mockups
What I learned
The lack of the ability to manipulate DOM elements and styles limits significantly what you can achieve with Forge
That there’s no way to send dynamic data to the glance tab
What's next for Comment Sentiment analyzer
Sentiment analysis is definitely a big topic. A great addition to this app would be to analyze sentiment on the project over time and provide a chart for the dashboard. Then project managers could monitor the chart and if any problems come up (sentiment drops) they can drill down and see what issues influenced sentiment drop most in this period.
Then they could use Issue level of sentiment analysis to see shat caused the troubles and who they need to speak to.
Built With
forge
Try it out
bitbucket.org | Comment Sentiment Analyzer | Spot frustration and act on it early on with sentiment analysis for your issues. | ['Biro Florin'] | [] | ['forge'] | 170 |
10,045 | https://devpost.com/software/user-story-linter | Inspiration
The inspiration for this project came from several sources:
I'm a long-time fan and user of Atlassian products.
I'm a software engineer and as such I was curious about the Atlassian Connect framework. I wanted to take it for a test drive.
I had a frustrating experience which could have been a lot smoother with the help of a Jira add-on like Story Linter.
You can read about the experience
in this blog post
or in the
Atlassian Community
.
What it does
Currently, Story Linter analyzes your user stories and checks that they
are syntactically well formed
and that an acceptance criteria is included. But, we are planning to add more rules and config options, soon.
How we built it
It's built with Spring Boot, Kotlin and Atlassian Connect Spring Boot Starter on the backend. On the Frontend we are using Gatsby, Atlassian JavaScript API and Atlaskit Components.
The build and deployment are completely automated and it's currently
deployed in Heroku
.
The whole project is in
this repo
.
Challenges we ran into
We are new to Jira Cloud app development. It took us a bit of time to smoothly navigate the documentation and understand the Atlassian Connect Framework but we have a working app (a good one we hope!).
Accomplishments that I'm proud of
I'm proud that even in its early stage the project has received great feedback from strangers and friends (fellow developers, project managers, scrum masters, etc.) Check out the following posts:
https://mprieto.me/blog/2020/07/03/story-linter/
https://community.atlassian.com/t5/Jira-discussions/Automated-User-Story-Quality-Tool/td-p/1422741
https://www.linkedin.com/feed/update/urn:li:activity:6686677465173151744/
I'm proud that my friend Carlos who is a great software engineer decided to be a part of this project. Since joining, he has brought so much to the table on our conversations about the value that this product brings to its users, how to build it, etc. etc. I'm excited and happy that we're building this together!
What we learned
We learned that we are not alone. We learned that there's an audience for this tool.
Thanks to Carlos, I've learned a bit about NLP and this very
interesting conceptual framework to measure user story quality
What's next for Story Linter
We envision Story Linter in the future as a more generic tool with of plenty of configurable, powerful and smart rules. Realtime syntax highlighting, autocompletion and a beautiful map of stories based on roles and intents, and many other cool features.
We want this project to evolve into a framework that would help developers, managers, scrum masters and others, write better issues.
We know that there's a long way to go to fulfill our vision but every journey starts with a first step.
Built With
antlr
gatsby
kotlin
mysql
react
spring
Try it out
github.com | Story Linter | Story Linter is a Jira Cloud application that helps agile teams write high-quality stories and keep a clean backlog | ['https://mprieto.me/blog/2020/07/03/story-linter/', 'Miguel Prieto', 'Carlos Cardozo'] | [] | ['antlr', 'gatsby', 'kotlin', 'mysql', 'react', 'spring'] | 171 |
10,045 | https://devpost.com/software/codegeist-excel-addin | Get started in excel desktop
Start addin
Add data in jira issues table
Create issues from table
Create issues from table 2
Inspiration
To create excel add in that can be compatible with both excel desktop app and excel online. Using which we can create bulk jira issues from sheet.
What it does
You need to download JiraIssuesTemplate or JiraIssuesFile and codegeistexceladdin-manifest files from
here
Add "Account URL" and "Authorization Code" to configure add-in
Add data in table in "jira issues" sheet , select project and run add-in
This will create issues as per entered data in selected project
Detailed instruction on how to run is available in above link
How I built it
Create Excel-add in using Yeoman generator and visual studio code
Use REST API of Jira Cloud platform from
here
Create API in node js for authorization and other operation for jira
Host this api on heroku
Host static HTML, css and js files for add-in on google Firebase
Challenges I ran into
To create multiple jira issues from table and update status and details column against respective row
Accomplishments that I'm proud of
I am able to create functionality that can add multiple jira issues from table
What I learned
Atlassian cloud developer
host and consume API from node js
What's next for Codegeist Excel Addin
Right now it is one way operation means user can add data from excel to atlassian account, we can add functionality to update data back to table from atlassian using Data operation in Excel
We can further add chart and pivot table to visualize project progress in excel itself.
Eliminate use for end user to add Authorization Code while configuration
Publish add-in on office add-in store
Built With
add-in
api
atlassian
excel
firebase
heroku
jira
node.js
office
Try it out
codegeistexceladdin.web.app | Codegeist Excel Addin | Create bulk jira issues from either excel desktop or excel online using add-in | ['Harsh Bhavsar'] | [] | ['add-in', 'api', 'atlassian', 'excel', 'firebase', 'heroku', 'jira', 'node.js', 'office'] | 172 |
10,045 | https://devpost.com/software/trello-board-inside-jira | Trello Board Inside Jira acts as extension to WatchTower, allows tracking Trello cards along with Jira issues on a single board
Connect Trello board to be used inside Jira - Use Trello board as a source in WatchTower to pull data from
Make "list" from Trello act as "status" in Jira, which you can map to column on a board
Update Trello cards right from your Jira board - Transition Trello cards in Jira and have them updated in Trello accordingly
Add comments to "issue" in Jira and they automatically appear in Trello card
Inspiration
The roots of
Trello Board inside Jira
lay in the challenge of maintaining project management activities in distributed environment. It all started in 2017, when we faced the need of combining data from multiple Jira instances into one agile board - that's how
WatchTower for Jira
emerged. WatchTower aimed at consolidating data from several Server and Cloud Jiras into one agile board giving the user the possibility to control activities from one place. Becoming 2017's top three app choice in "Best Software Team App", over the years, WatchTower extended its functionality to enable Board Sharing, support of Cross-Jira JQL search, Quick filters and Time reports consolidating data from remote Jira instances.
With the feedback of our users, we realized that project management tools in use are not limited to Jira Software and there is a need for supporting the same idea of _ One-Control-Dashboard _ for projects spread over different tools. Trello, being very close to Jira and part of Atlassian product family, was chosen as the most requested from our users' feedback.
Now, with the help of
Trello Board inside Jira
you can add your Trello board as one of the sources in WatchTower and have a precise overview of all your activities spread across Jira instances and Trello.
What it does
Trello Board Inside Jira
enhances team collaboration between Trello and Jira - the app allows adding data from Trello boards to agile board inside WatchTower.
You can view, comment, and transition Trello cards right from inside Jira, with immediate change inside Trello.
A convenient tool to grasp the status of your projects in federated environment at a glance.
Check out the
step-by-step guide
.
How we built it
As
Trello Board Inside Jira
is an extension for WatchTower, connecting Trello as a source in Watchtower was an obvious choice. In WatchTower, we already have support for sources that represent Jira cloud instances. Similar to this, Trello board is connected as a new type of sources.
We had to deal with a new type of authentication but the extensive Trello API made it convenient to achieve.
Thereafter, we had to provide a certain mapping between Jira entities and Trello counterparts.
This way, lists became statuses, cards became issues.
Transitions and changes to Trello cards were also implemented with the comprehensive Trello API.
Challenges we ran into
Trello API
Mapping of Trello entities and artifacts to corresponding counterparts in Jira.
Accomplishments that we're proud of
Seamless work with Trello from inside Jira
What's next for Trello Board Inside Jira
Adding labels, images to cards etc.
Editing Trello cards from Jira board
Built With
angular.js
atlassian-connect
bootstrap
Try it out
marketplace.atlassian.com
marketplace.atlassian.com | Trello Board Inside Jira | Project management in federated environment poses a challenge of grabbing information from multiple sources. Trello Board Inside Jira pulls data from Trello into Jira board and allows realtime changes | ['Andrey Dekhtyar', 'Olena Havrylenko', 'Andrey Suray', 'Alexandr Matyukhin'] | [] | ['angular.js', 'atlassian-connect', 'bootstrap'] | 173 |
10,045 | https://devpost.com/software/cryptosign-xrgnvf | CryptoSign
Valid signature
Invalid signature
CryptoSign
allows users to sign their JIRA issues into the Blockchain, and verify integrity of signatures. This is a blockchain alternative to signing solutions like DocuSign.
Hash
Let's first talk a little about hashes in order to understand the concept of CryptoSign. A hash is a fixed-size and unique representation of some data, like a fingerprint. The same data will always have the same hash, but if the data changes by even a single character, then the hash changes entirely. It is impossible from the hash to go back to the original data, therefore we can safely store hashes in a public blockchain without compromising the privacy of the original data. Here are some examples:
“Hello world” => 0x185f8db32271fe25f561a6fc938b2e264306edu343gu
The entire Lord of the Rings collection => 0x5aee9a0d38ffe31fe100042698edc9fbe905njh343
So what is CryptoSign?
The CryptoSign JIRA app computes the hash of the description of an issue, and sends the hash to an Ethereum Smart Contract that I wrote to store the hash and automatically associate it with the sender’s public address and current date. Users can then later verify signatures by computing the hash of the data themselves and checking that this hash does exist in the smart contract and has been signed by the correct public address.
Let's install a wallet
To send data to the smart contract, you need a wallet. The wallet will sign every blockchain operations (called transactions) with your private key that only you alone knows, proving you are the originator of the transaction. You can use many wallets, but for this demo we are going to use Metamask, the most popular in-browser wallet.
To install metamask, just go to the
https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn?hl=en
. Then install it and create your wallet to define your private key.
Using a testnet
CryptoSign is production-ready and can be used on the Ethereum Mainnet using real Ethers. However, when sending data to the blockchain you need to pay a small network processing fee (usually a few cents), so for demo purposes, you can switch Metamask to the Ropsten test network so you can use fake test Ethers to pay for transactions.
To get test Ethers, go to
https://faucet.ropsten.be/
Let's get started (finally!)
You are now ready to use CryptoSign. Open any JIRA issue load the CryptoSign app. You can see two buttons: “Sign Document” and “Verify Signature”. If we click ‘Sign Issue’, the app will compute the hash of the issue description and send it to our smart contract. For now, we only include the issue description in the hash but further development could include more fields from the issue like title, story points, priority or even custom fields.
Now, if you click ‘Sign Document’, the current hash of the document will be sent to our smart contract. For this, Metamask will automatically open and asks you to sign the transaction for sending data to the blockchain. You need to pay some Ethers. Since we are on the testnet we are paying with test Ethers. Notice that this corresponds to only a few US cents.
Pay and wait for the transaction to be verified by the network, this usually take a few seconds but can go up to a few minutes if the network is very busy.
In the meantime, you can check on the status of the transaction in Metamask and even click on the Etherscan link to check the status on the official Ethereum block explorer.
Tadaaaa
Once the transaction is done, the document is signed! You can see that CryptoSign shows some metadata captured by the smart contract from the transaction, i.e. the date and time of the signature and the sender’s public address. If you check your metamask address, you can see that it does indeed correspond to your public address.
Let’s take a quick look at the code of the smart contract so you can understand what is under the hood.
pragma solidity 0.5.16;
contract Cryptosign {
struct Metadata {
address sender;
uint256 date;
}
mapping(string => Metadata) public hashToMetadata;
event Signed(string hash, address sender, uint256 date);
function sign(string memory hash) public {
hashToMetadata[hash] = Metadata(msg.sender, now);
emit Signed(hash, msg.sender, now);
}
function verify(string memory hash) public view returns (address sender, uint256 date) {
Metadata memory metadata = hashToMetadata[hash];
require(metadata.date > 0, "Invalid Signature");
return (metadata.sender, metadata.date);
}
}
As you can see it is quite simple. We have a mapping that stores the document hashes and their corresponding metadata, and the "sign" function that accepts the hash as input.
Notice that the sender’s public key and the date of signing are not part of the function input. They are fetched automatically from the transaction itself so they
cannot be faked or altered by the signer.
Notice also that data stored like that in the blockchain becomes
immutable and inalterable for life!
Even if the CryptoSign block gets discontinued, the smart contract data will always be publicly available in the blockchain and signatures will always be verifiable.
Now the "verify" function works just the other way. You call it with a hash and it will check if this hash exists in the smart contract storage. If so, it will return the stored signer’s public address and signing date. If not, it will send an invalid signature error.
Back to JIRA
You can then go back to JIRA and refresh the page as if you were checking it out as another user. You can click "Verify Signature" and this will send the hash to the smart contract. You should see almost immediately that the hash was found so the signature is confirmed. The smart contract sends back the metadata and we display them on the block itself so users can verify them.
Now let’s try to change some data. Modify something in the issue description and click "Verify Signature" again. The smart contract sends back ‘Invalid Signature’ because the new hash does not correspond to any hash stored in the smart contract. This proves someone has tempered with the document since the signature was done.
Try removing your modifications to revert to the original document and click "Verify Signature" again. The signature is now correct again. Notice you could alternatively decide to keep the modified version and sign this new version instead. You would therefore have 2 signatures, one for each version of the document, but one would have a more recent date than the other. Further developments could include displaying an history of signatures.
What about security ?
As noted above, it is impossible to fake or cheat a signature sent to the blockchain because the protocol fetches it automatically from the transaction signed with the private key of the signer. The whole Ethereum blockchain relies on these cryptographic principles and Ethereum has never been hacked, despite constant attempts.
CryptoSign is more cryptographically secured than DocuSign and way less expensive. The signer only has to pay the network fee when signing a document to pay for the execution of the smart contract
Caveat
For the sake of transparency, there is one caveat to be noted. You have to know the identity of the person behind the public Ethereum address. The cryptographic signature guarantees that a public address has indeed signed the document, but it doesn’t prove the identity of the person behind that public address.
There are multiple ways to solve that issue, the most popular being that the user has to pass a KYC before using CryptoSign. We can therefore associate his public address with his identity. There are multiple services online offering to pass a "Crypto KYC" with easy API integrations. Further developments of CryptoSign could include such integration.
Conclusion
CryptoSign offers a quick and cheap solution to sign data on JIRA and provide a cryptographic proof that can be to verify the document has not been altered since the signature. Any change would immediately be visible as an Invalid Signature, and either require the data to come back to the original signed version or to sign the new version.
The use cases for this are numerous :
a consultant could agree on development prices by signing the client’s user stories (so the client could not change them later)
an auditor could sign audit trails or security reports,
etc...
Anything requiring a proven signature can now be done on JIRA!
PS: I first started coding CryptoSign as a Forge app but it soon turned out to be impossible for the app to connect to Metamask because it needs access to the "window" global browser variable in order to fetch "window.ethereum" injected by Metamask. This seems to be because Forge app are server-side rendered and therefore "window" gets filled by server's variables rather than the browser's ones. I therefore recoded the app with Connect instead which worked fine as the app is client-side rendered in an iframe. However I can still provide the Forge version if needed which looks much better thanks to the Forge/ui components and the much slicker integration with JIRA issues.
Built With
ethereum
react
solidity
web3
Try it out
github.com | CryptoSign | CryptoSign allows users to sign their JIRA issues into the Blockchain, and verify integrity of signatures. This is a basically a blockchain alternative to signing solutions like DocuSign. | [] | [] | ['ethereum', 'react', 'solidity', 'web3'] | 174 |
10,045 | https://devpost.com/software/approve-pages | Draft
In Review
Approved
Rejected
Show Reviews
Reviews (in Jira board)
Inspiration
It can be challenging to track different versions and approvals of company documents. For many businesses, this is required by regulatory and it's often done via email. This however, has some major disadvantages:
No history of document changes is available
Approval flow e.g. Draft -> Review -> Approved/Rejected cannot be easily enforced
Statistical analysis of approvals is impractical or impossible (e.g. answering: "How long did it take to go from draft to approved 95% of the time?" is not a simple task)
By using Approve Pages for Confluence all of the above are not only possible but also simple to implement with just existing Confluence and Jira subscription.
What it does
Approve Pages let's editors submit version of a Confluence page for review by approvers. Jira issue is created for each submitted version for review. Depending on Jira workflow, approvers may approve changes, reject them or anything in between. Different business may define Jira worklow that suits their own approval process.
How I built it
Approve Pages is build on the new
Atlassian Forge
- trusted, scalable platform with Atlassian-hosted compute and storage, eliminating the need to manage infrastructure or security. Your Confluence pages or any information about them will never leave your existing Confluence and Jira subscriptions.
Challenges I ran into
There are some limitations what's possible to display in Confluence macro. I've overcame those by leveraging features already available in Confluence and Jira e.g. version history.
Accomplishments that I'm proud of
Seamless integration with Confluence and Jira. No new special fields, minimal configuration and use of Jira are aimed to work with the simplest setups.
What I learned
I became very familiar with
Forge
,
Jira
and
Confluence
developer platforms, their features and limitations.
What's next for Approve Pages
Selection of approval workflows in Jira Marketplace
Changes shown directly in Jira
No reload required for status refresh of a Jira review transition
Reports
Built With
confluence
forge
jira
typescript | Approve Pages | Approval Process for Confluence Pages | ['Roman Velic'] | [] | ['confluence', 'forge', 'jira', 'typescript'] | 175 |
10,045 | https://devpost.com/software/jira-standup | Home screen, listing JIRA boards
Josh is giving his update to the team
Alert when the standup goes over 15 minutes
Standup is complete!
Inspiration
The inspiration for JIRA standup came from my team at work – we've experimented with several different approaches to standup over the years – a physical board, presenting the JIRA board to a TV, huddling around someone's computer, etc. However we've consistently run into several problems – how does everyone remember what they worked on yesterday? How can we filter out the noise if there are lot of cards on the board? In what order do people go in? And how can we keep the standups short, sharp and focused?
I've wanted for several years to try and tackle these problems, and I thought that Codegeist 2020 was a fantastic opportunity to do so!
What it does
JIRA Standup takes the guesswork out of your daily standup meetings. It walks everyone though the list of team members and lists what each person did yesterday, and what they're assigned to today. Each team member can then give their daily update by simply looking at JIRA Standup – they don't need to try and remember what they did yesterday or consult their notes. It removes all non-relevant information from the screen and focuses on one person at a time, so the app is fantastic to use when it is being presented to a videoconference, for example, or when being projected to a screen in an office. JIRA Standup also keeps track of the length of the meeting, and encourages everyone to keep the meeting under 15 minutes – keeping everyone focused and
in the zone
! It also includes links to tips from
Atlassian's Agile Coach
documentation on standups, to try and encourage users to adopt agile best practices.
How I built it
The application is built using TypeScript and React, and uses the Atlassian Connect JavaScript library to fetch data from the JIRA API. It uses components, styling and themes from Atlassian's Atlaskit – ensuring it looks right at home inside the Atlassian software stack. The source code is hosted on BitBucket, and BitBucket Pipelines are used to automatically publish new versions of the application to AWS S3, where it can then be installed into JIRA. In building the app I used the Atlassian Developer and JIRA API documentation documentation extensively.
Challenges I ran into
The main challenge that I ran into was choosing the subset of features that I wanted to tackle in the hackathon time frame. I initially had a list of features that was very extenisve, but I needed choose a subset that made up a viable product that I could focus on during the hackathon.
Accomplishments that I'm proud of
I created and published TypeScript
type definitions for the Atlassian Connect JS library
, and other people have since started to use them! This was awesome to be able to contribute to the community, and hopefully make it easier for people to use Atlassian Connect from their frontend apps in the future.
I'm also proud that I was able to submit a functional application in the time frame – whilst it is far from feature complete I'm very glad that I was able to build the product that I've submitted today.
What I learned
I learned a
tonne
about Atlassian's developer ecosystem throughout this hackthon. I spent a lot of time reading about Atlassian Connect and the best way to structure this application, as well as learning about the different JIRA APIs. I've also been wanting to try out Atlaskit for a while, and was so happy using it. The documentation is fantastic and I learnt all about the wide variety of components that can be used and composed together.
What's next for JIRA Standup
There are plenty more features that can be added to JIRA Standup to ensure that it works for every team that uses JIRA. I hope to let people customise a swathe of different features – such as the ability to include or exclude certain cards & team members, the maximum standup duration, the days that people work on, and change the way that the UI is displayed.
Built With
amazon-web-services
atlassian
bitbucket
jira
react
s3
typescript
Try it out
jira-standup.s3.amazonaws.com
bitbucket.org | JIRA Standup | Helping everyone run better standup meetings – guides teams through each member's daily update in a beautiful, clean UI that is designed with remote meetings in mind, and keeps the meeting on track. | ['Josh Parnham'] | [] | ['amazon-web-services', 'atlassian', 'bitbucket', 'jira', 'react', 's3', 'typescript'] | 176 |
10,045 | https://devpost.com/software/niko-niko-calendar-for-confluence | A calendar
The configuration panel
Inspiration
The Niko-niko calendar is the application of a principle in Agile project management described by american engineer and Agile expert Tom Gilb:
Anything you need to quantify can be measured in some way that is superior to not measuring it at all.
The measure doesn’t have to be perfect nor precise. The objective is to quantify something that wasn’t.
A niko niko calendar is a useful tool that helps quantify an important element of team performance – motivation/morale or well-being - three factors that are usually difficult to measure. Having this calander in your confluence instance is an easy way to gather comments from the whole team, particularly when working remotely. It also enables you to better analyze trends during retrospectives.
What it does
This tool is a calendar that aligns to your sprint cadence and captures the mood of every team member daily in a fun and easy interface.
How I built it
I followed the Atlassian connect express tutorial on node.js, using vanilla JS & HTML5 in the front-end, using sequelize for mapping the object model to the database.
Challenges I ran into
I had a prototype using google for authentication, which was working decently, but moving to Atlassian Connect I realised most of the data exchange didn't make sense and the only data I needed was the
accountId
which makes the stored data as anonymous as possible.
I started developing on sqlite and the move to postgres was harder than I though because I had to write some custom SQL and rewrite it again for the new db engine.
Calculating the start and end date of a sprint was harder than I thought, especially taking into account the user timezone preferences and locale timeformat.
Accomplishments that I'm proud of
Delivering a quick and easy way for team members to keep in touch while adding value to sprint retrospectives.
What I learned
I discovered the
MutationObserver
class in javascript and this how I implemented the custom mood selector. I also learner about
Intl.DateTimeFormat
to leverage browser knowledge of locale formating.
What's next for Niko niko calendar for Confluence Cloud
There is so much more we could be doing, like adding the option to annonomise reporting, and having notification and reminders to fill in the calendar. I am currently working on a customisable retrospective view/export function as well as mobile support.
Built With
confluence
connect
express.js
javascript
node.js
Try it out
cloudscript-niko.herokuapp.com | Niko niko calendar for Confluence Cloud | This is a quick and easy way to monitor your teams mood, morale and motivation. Three factors that are particularly difficult to measure and quantify, especially when working remotely. | ['Patrick Roumanoff'] | [] | ['confluence', 'connect', 'express.js', 'javascript', 'node.js'] | 177 |
10,045 | https://devpost.com/software/what-s-new | What's New
Inspiration
I want to develop an application for Jira and Forge is the great tool for me to start.
How I built it
Learnt about Forge
Built the app with Forge
Challenges I ran into
I am new to Jira and Forge is also a new way to develop an app. But fortunately, Forge was designed to develop an app easily even with a newbie like me.
What I learned
How to develop an app for Jira using Forge.
What's next for What's New
I will add more settings for this app.
Built With
forge
jql
tunnel | What's New | It's a simple but must-have plugin for Jira. It provides the latest updates in the project. | ['Ryan Nguyen'] | [] | ['forge', 'jql', 'tunnel'] | 178 |
10,045 | https://devpost.com/software/expression-playground-for-jira | Text search makes defining context variables a breeze
Easily define an "issues" context variable with JQL assistance and preview
Get clear feedback on any issues that may occur with your Jira expression
Inspect the expression complexity go get a better understanding of your expression's performance
Filter the evaluation history to find exactly what you are looking for
Inspiration
With the introduction of Jira expressions, admins and developers have a new, powerful yet lightweight tool to query Jira entities. Expressions can be evaluated by calling the REST API or by defining a workflow validator or condition. Unfortunately, it is a rather tedious process to test expressions via the REST API because one has to look up entity ids for context variables all the time. Jira currently lacks a tool to explore the capabilities of Jira expressions and to easily develop and test them.
But not anymore - Expression Playground for Jira makes expression accessible to everyone.
What it does
Expression Playground for Jira provides an easy to use UI to create, develop, and test Jira expressions. Context variables for various Jira entities can be defined with a few clicks and text search makes finding a Jira entity a breeze. The expression editor analyzes the user's expression and provides immediate feedback if an expression contains syntax errors. Users evaluate expressions with a single click and inspect the result in the UI.
In order to reuse expressions, the playground offers an evaluation history that contains context variables and expressions. The context variable and text search make it easy to find a previously evaluated expression. Additionally, history items can be restored with a single click.
How we built it
We used Figma for paper-prototyping, design, and conception. To develop the application we used Typescript, React, and Atlaskit components to get a nicely integrated app that follows Atlassian’s style guidelines. With the entire application running in the web browser and by leveraging Jira entity properties for persistence we have built an app that stands directly on top of Jira’s permission and security schemes and runs without any third-party server involved.
Challenges we ran into
Lukas:
As a Java enterprise application developer it was challenging to learn and apply the React framework in a very short amount of time. Another big challenge was to develop a UI concept that is intuitive and productive.
Tobias:
The biggest challenge was to come up with an intuitive and efficient UI concept that makes expressions simple and easy to explore.
The fact that we worked in different time zones (CET and MYT) required us to work asynchronously and regularly align our work.
Accomplishments that we're proud of
After a few development iterations of the UI prototype and the user workflow, we were able to deliver an appealing and intuitive playground for Jira expressions.
What we learned
Lukas:
I learned React and how to create an entire Connect app that only runs in the browser.
Tobias:
Developing the expression playground gave me a much better understanding of Jira expressions and how to use them in my own day to day work and in other projects.
What's next for Expression Playground for Jira
With Expression Playground for Jira, we have laid out the groundwork to make Jira expressions accessible. As a next step, we are looking to apply the design concepts established for Expression Playground to the workflow editor in order to give admins the means to define custom workflow validators and conditions without having to leave the UI.
Built With
atlaskit
react
typescript
Try it out
expression-playground-for-jira.netlify.app | Expression Playground for Jira | Accessible Jira expressions | ['Tobias Binna', 'Lukas Hofmaier'] | [] | ['atlaskit', 'react', 'typescript'] | 179 |
10,045 | https://devpost.com/software/simple-polls-for-confluence | Configuring a poll from page editor
Vote submission form
Poll results
Usage idea: collect feedback on meeting effectiveness
Usage idea: make decisions together as a team
Usage idea: help run exercises like Team Health Monitor remotely
Feature: multiple-choice votes
Feature: anonymous polls (use names hidden)
Inspiration
I was inspired by how simple yet powerful Forge and Forge UI is, even in the early stages, and set out to build a production-grade app that would leverage the new platform. There are several poll apps in the Marketplace but they are either too sophisticated or look dated. I saw an opportunity to build something simple for the user, something that "just works" and is easily accessible.
What it does
The app allows you to add polls to Confluence pages. It focuses on simplicity and empowering teams to easily collect feedback and make decisions.
Features
Anyone on your team can easily add polls to Confluence pages
Results are instantly available to those who voted and are continuously updated
Single or multiple-choice voting available
Polls can be made anonymous
Respondents can correct their votes if needed
Close the poll to stop receiving votes and display the results
Reset the poll to discard existing vote data (useful if significant edits to poll choices were made)
No data ever leaves your Confluence instance because the app doesn't make any external requests
How I built it
The app is built with Atlassian Forge. It implements a Macro component and uses a number of other elements and hooks offered by Forge UI. Poll data is stored in page properties.
Challenges I ran into
I ran into a number of limitations and bugs in Forge that prevented me from delivering an ideal user experience in some places (see "What's next..." below), but I was able to find reasonable workarounds.
Accomplishments that I'm proud of
I'm proud to have built a production-ready app from scratch using the new development platform and can't wait to ship it!
What I learned
I learned how Forge works and the platform's current capabilities. Despite being in early stages and having some limitations, you can already implement a lot of things with it, including apps with sophisticated multi-modal UI.
What's next for Simple Polls For Confluence
First and foremost, I can't wait to publish my app in the Atlassian Marketplace when it supports Forge apps!
I plan on keeping the app simple and am not looking to overload it with features. That said, as the Forge platform matures, new opportunities to deliver more value may arise.
There are also areas where the UX is suboptimal due to platform's current limitations. I'm hoping to incorporate improvements as these issues are addressed:
Ability for first-time users to authorize the app from page editor.
Because of
FRGE-110
, the first time you create a poll, you have to save the page, authorize, then go back to configure the poll.
Ability to delete a non-last option in poll configuration.
Currently you can only remove choices from the end due to
FRGE-103
.
Lock down poll anonymity once it has votes (once Forge UI supports
disabled
prop on Checkbox)
Add visual feedback when the macro editor is loading.
Immediately open macro editor when adding the poll macro - it's useless without prior configuration.
Always show preview of the poll submission form in poll editor, even if the current user has voted.
Currently the macro app has no way of telling whether it's being rendered inside the page editor or not.
More component styling and layout options to create a more aesthetically pleasing UI.
Built With
forge
node.js | Simple Polls For Confluence | This app allows you to add polls to Confluence pages. It focuses on simplicity and empowering teams to easily collect feedback and make decisions. | ['Dmitry Pashkevich'] | [] | ['forge', 'node.js'] | 180 |
10,045 | https://devpost.com/software/diagrammer | Sequence Diagrams
Gantt charts
Class diagrams
User Journeys
ER diagrams
Inspiration
Diagrams are an essential part of the Software development process, helping to communicate complex ideas visually.
However, it is not possible to create diagrams directly in Jira. This means you need to integrate third-party solutions, and you end up wasting time from changing between different software.
So, what if you quickly and easily create diagrams directly in your Jira Issue?
Well, that's what Diagrammer is for.
What it does
It allows you to create diagrams in your Jira Issue using a simple, yet powerful markup language, transforming raw text into beautiful diagrams.
Seven different types of diagrams and charts are available:
Sequence Diagram
Class Diagram
State Diagram
Entity Relationship Diagram
Flow Chart
Gantt Chart
User Journey
Sequence Diagram
sequenceDiagram
Alice->>+John: Hello John, how are you?
Alice->>+John: John, can you hear me?
John-->>-Alice: Hi Alice, I can hear you!
John-->>-Alice: I feel great!
Renders this:
Class Diagram
classDiagram
Animal <|-- Duck
Animal <|-- Fish
Animal <|-- Zebra
Animal : +int age
Animal : +String gender
Animal: +isMammal()
Animal: +mate()
class Duck{
+String beakColor
+swim()
+quack()
}
class Fish{
-int sizeInFeet
-canEat()
}
class Zebra{
+bool is_wild
+run()
}
Renders this:
State Diagram
stateDiagram
[*] --> Still
Still --> [*]
Still --> Moving
Moving --> Still
Moving --> Crash
Crash --> [*]
Renders this:
Entity Relationship Diagram
erDiagram
CUSTOMER }|..|{ DELIVERY-ADDRESS : has
CUSTOMER ||--o{ ORDER : places
CUSTOMER ||--o{ INVOICE : "liable for"
DELIVERY-ADDRESS ||--o{ ORDER : receives
INVOICE ||--|{ ORDER : covers
ORDER ||--|{ ORDER-ITEM : includes
PRODUCT-CATEGORY ||--|{ PRODUCT : contains
PRODUCT ||--o{ ORDER-ITEM : "ordered in"
Renders this:
Flow Chart
graph TD
A[Christmas] -->|Get money| B(Go shopping)
B --> C{Let me think}
C -->|One| D[Laptop]
C -->|Two| E[iPhone]
C -->|Three| F[fa:fa-car Car]
Renders this:
Gantt Chart
gantt
title A Gantt Diagram
dateFormat YYYY-MM-DD
section Section
A task :a1, 2014-01-01, 30d
Another task :after a1 , 20d
section Another
Task in sec :2014-01-12 , 12d
another task : 24d
Renders this:
How I built it
I have used the amazing MermaidJS library to transform text into diagrams and charts.
Challenges I ran into
The biggest challenge was finding a way to create beautiful diagrams without being able to use HTML tags directly in Forge. After trying different approaches, the final solution was transforming the diagrams into images.
Accomplishments that I'm proud of
I'm really proud of the flexibility that it is possible to achieve with my app. It can be easily extended to include more diagrams, more customisations, and yet everything is very simple to use.
What I learned
It was a great experience to learn how to use Forge and other Atlassian products. The ecosystem is amazing and allows you to create amazing products by leveraging Atlassian solutions.
What's next for Prototyper
Add more diagrams
Allow to customise themes
Built With
forge
javascript
react
Try it out
github.com | Diagrammer - Create diagrams in your Jira Issue | Easily create diagrams and charts in your Jira Issue. No external tool needed. | ['Gustavo Zomer'] | [] | ['forge', 'javascript', 'react'] | 181 |
10,045 | https://devpost.com/software/image-to-text | Step 1: The default UI when you first added the macro.
Step 2: The popup will appear when you click the `Select Image` button.
Step 3: After the image has been processed. It will display the resulting text. You have the option to update the text.
Step 4: After saving the details, the end result will display on screen with the title caption and converted text.
Inspiration
Have you experienced manually copying and typing all the information from an image or actual paper to your confluence page? It’s painful right? Especially if you are copying all the text of an image that size of at least standard letter page.
What it does
Image-To-Text lets you upload an image that has text information and it will automatically convert it as text for you. You have the option to change or update the resulting text before saving it.
How I built it
The Forge App was built using Forge/Forge UI and the API was built using Azure Functions and Azure OCR Cognitive Service. The API was deployed on Azure. The forge app was only works on Confluence.
Challenges I ran into
Since Forge is relatively new, the most challenging part is familiarizing Forge UI's full capabilties in a short matter of time.
Accomplishments that I'm proud of
I'm very proud of the fact that I made an app in just matter of hours compare to other development platform that would take me at least days or weeks. Also, it is my first time to make an app without worrying about the UI since it is fully handled by Forge.
What I learned
I learned a lot about different Atlassian development products. Without this hackathon, I wouldn't know that Atlassian allows other developer to make an app for their products and platform.
What's next for Image-To-Text
It depends on how far Forge will reach. Also, how the community will react with my work and hopefuly will receive some feedback that will make Image-To-Text a great app in the future.
Built With
azure
forge
typescript
Try it out
github.com | Image-To-Text | Image-To-Text lets you upload an image that has text information and it will automatically convert it as text for you. You have the option to change or update the resulting text before saving it. | [] | [] | ['azure', 'forge', 'typescript'] | 182 |
10,045 | https://devpost.com/software/trend-radar | Highlight 2A
Trend Radar Logo
Highlight 2
Highlight 1
Highlight 3A
Highlight 3
Trend Radar Banner
Inspiration
The challenge to built an Atlassian Cloud app in less than two weeks without any detailed knowledge about Atlassian Cloud app development.
What it does
Identifying important trends as early as possible will be a crucial competitive advantage. One step ahead, managers and teams can assess the potential impact on their business: From cloud computing and big data to artificial intelligence and robotics or whatever comes next.
Be ahead with syracom Trend Radar expertise:
Identify digital influences in good time and evaluate them systematically
Analyse technological hypes and correctly interpret impacts on your company
Identify future technologies for your business areas
Make relevant digital trends quickly usable
Develop use cases of digital trends for your specific needs
Monitor opportunities and risks relevant for your business
How we built it
We used HTML5, CSS and JavaScript to build the app.
Challenges we ran into
Building an Atlassian Cloud app with Connect, never done before more easier as expected.
What's next for Trend Radar
New features to make it more comfortable for all customers and better user experience.
Built With
css
html5
javascript | Trend Radar | Identify future business opportunities and risks visualized within trend radars. | ['Nici Emmel', 'Sebastian Baumbach', 'Frank Polscheit', 'Martin Hühn'] | [] | ['css', 'html5', 'javascript'] | 183 |
10,045 | https://devpost.com/software/face-detect | Step 1: The default UI when you first added the macro.
Step 2: The popup will appear when you click the `Select Image` button. It will require you to add title caption and image URL path.
Step 3: After the image has been processed. It will display the list of faces. You are required to add some details for each image.
Step 4: End result will display on screen with the title caption, the original image and the extracted face images.
Inspiration
Have you imagined to add your individual team members photo on a confluence page without manually ask for it from your team members and upload it manually to your confluence page? Can you feel the how hustle is it right?
What it does
Face Detect lets you just upload a single image of your team and it will automatically handle the extraction of your team members' faces. Also, you have the option to add the name and some details about each of your member teams.
How I built it
The Forge App was built using Forge/Forge UI and the API was built using Azure Functions and Azure Face Cognitive Service. The API was deployed on Azure. The forge app was only works on Confluence.
Challenges I ran into
Since Forge is relatively new, the most challenging part is familiarizing Forge UI's full capabilties in a short matter of time.
Accomplishments that I'm proud of
I'm very proud of the fact that I made an app in just matter of hours compare to other development platform that would take me at least days or weeks. Also, it is my first time to make an app without worrying about the UI since it is fully handled by Forge.
What I learned
I learned a lot about different Atlassian development products. Without this hackathon, I wouldn't know that Atlassian allows other developer to make an app for their products and platform.
What's next for Face Detect
It depends on how far Forge will reach. Also, how the community will react with my work and hopefuly will receive some feedback that will make Face Detect a great app in the future.
Built With
azure
forge
typescript
Try it out
github.com | Face Detect | Face Detect lets you just upload a single image of your team/group and it will automatically handle the extraction of your teams members faces. It is capable to add some caption for the team members. | [] | [] | ['azure', 'forge', 'typescript'] | 184 |
10,045 | https://devpost.com/software/h-kjopfg | This Issue is Ancient installed as a Forge issue glance
An event timeline on an issue created in 2019
An event timeline displayed on an issue created in 2004
An event timeline on a more recent issue created in 2019
Inspiration
As a Scrum Master, I often facilitate meetings to groom my team's backlog of issues. Doing this week-after-week, I have noticed how easy it is for the team to forget how long an issue has been lurking in the backlog for with no fix in sight.
This Issue is Ancient!
is a fun reminder of all the events that have happened during the time that this issue was idling in the backlog. While at it, it provides the team with a healthy dose of historic trivia.
What it does
This Issue is Ancient!
is an Atlassian Forge app that presents a timeline of events that occurred through subsequent years on the same day that the issue was created.
How I built it
The app was built on Atlassian Forge as an Issue Glance. The app uses the Wikipedia API to fetch historic events that occurred on a given date.
Challenges I ran into
This being our first time building a Forge app, we had to read through all available documentation to learn the best way to leverage everything that it has to offer.
Accomplishments that I'm proud of
We are happy with the way the app turned out. It requires no user intervention for setup or API access and provides good user experience.
What I learned
We are now proficient in building apps on Atlassian Forge, and can't wait for the Forge UI component library to expand for us to build more powerful but lightweight applications!
What's next for
We would like to use sentiment analysis to limit the events presented to just uplifting news or truly historic events.
We would like to obtain more granular event data so that even issues that were recently filed can present interesting and meaningful event timelines.
Built With
forge
javascript
node.js
Try it out
github.com | This Issue is Ancient! | Some of the worst issues to work on are the ones that are long lived. "This Issue is Ancient!" is a fun reminder of how old your issue is with a little help from history. | ['Gopinath Sundaramurthy', 'Siddharth Subramanian', 'Vikram Parthasarathy', 'Revanth Anireddy', 'Nithya Renganathan'] | [] | ['forge', 'javascript', 'node.js'] | 185 |
10,045 | https://devpost.com/software/chargebee-jira-service-deck-connector | Inspiration
Our organisation has recently switched to using Chargebee to manage subscriptions for Confluence Server product licenses.
We were thinking that allowing Jira service desk agents to quickly view the subscriptions that a customer has will help them in deciding how to proceed with a ticket.
What it does
After connecting with Chargebee, there will be a panel in Service Desk projects displaying Chargebee customer details, monthly recurring revenue (MRR), as well as active and in trial subscription that the customer has.
How we built it
We built it using Ruby on Rails for the backend.
For the frontend, we utilised React as we want to make use of the Atlaskit components.
Challenges we ran into
We were going to use the reporter's email to search for the corresponding customer in Chargebee.
For that information, we require the Jira Email API, which requires a ticket to be raised to Atlassian with some 'ready for production' information, which we unfortunately do not have yet.
https://community.developer.atlassian.com/t/guidelines-for-requesting-access-to-email-address/27603
For now, we have hardcoded the email used to pull the Chargebee customer information.
What's next for Chargebee Jira Service Deck Connector
We are hoping to give it slightly more polish and get it to Marketplace, as well as work on getting approval for the email API.
We are considering to implement a search function, that will allow for service desk agents to search for the company that the reporter is part of. We are aware that a ticket reporter might not be the same contact in Chargebee.
Built With
atlaskit
react
ruby-on-rails
Try it out
cbjsdc.herokuapp.com | Chargebee Jira Service Deck Connector | Allow service desk agents to quickly view a reporter or customer's Chargebee subscription details while responding to tickets. | ['Wilson Lai', 'Jowin Yip'] | [] | ['atlaskit', 'react', 'ruby-on-rails'] | 186 |
10,045 | https://devpost.com/software/disastr-jira | DISASTR JIRA
Inspiration
What it does
Project Management for Post-Disaster Reconstruction
How I built it
JIRA
Challenges I ran into
Accomplishments that I'm proud of
What I learned
What's next for DISASTR JIRA
Built With
bitbucket
jira
Try it out
bitbucket.org | DISASTR JIRA | Post-Disaster Reconstruction Project Management | ['Tri Labs'] | [] | ['bitbucket', 'jira'] | 187 |
10,045 | https://devpost.com/software/dsastr | Disastr
Inspiration
What it does
Disaster Management
How I built it
Challenges I ran into
Accomplishments that I'm proud of
What I learned
What's next for Dsastr
Built With
blockchain | Disaster Relief Disbursement through Blockchain | Disaster Relief Disbursement through Blockchain | ['Tri Labs'] | [] | ['blockchain'] | 188 |
10,045 | https://devpost.com/software/jira-sticker-generator | Inspiration
Fun app to generate a sticker based on JIRA issue summary
Inspired by the example app
What it does
Generates a sticker based on the JIRA issue summary
How I built it
Using GIPHY stickers API
Challenges I ran into
Getting started with Forge
Try it out
github.com | JIRA sticker generator | Generate a sticker based on the JIRA issue summary | ['Suchita Tiwari'] | [] | [] | 189 |
10,045 | https://devpost.com/software/jira-issue-status-in-confluence | Inspiration
Teams use Confluence for collaboration. If a macro is available to know the status of an specific issue(s) for a release with tight deadline, it will help to get the live status of the issue from Confluence itself.
What it does
A confluence macro which helps get the JIRA issue status.
How I built it
Using Forge API.
Challenges I ran into
Forge Beta access.
Initial struggle to understand the APIs.
Accomplishments that I'm proud of
A working solution
What I learned
Forge, A lot about Altlassian, React
What's next for JIRA issue status in Confluence
More info related to JIRA issues directly available in Confluence + adding some triggers for leads and PMs to add comments, remind developers, etc directly from Confluence.
Built With
confluence
forge
jira
Try it out
github.com | JIRA issue status in Confluence | Teams use Confluence for collaboration. If a macro is available to know the status of an specific issue(s) for a release with tight deadline, it will help to get the live status of the issue. | ['Suchita Tiwari'] | [] | ['confluence', 'forge', 'jira'] | 190 |
10,045 | https://devpost.com/software/contract | Inspiration
As researchers, many times, we have to purchase articles or pay for article processing charges (APC) using non-local currencies.
What it does
JournalPay simplifies the checkout process for APC payment in our journal.
How I built it
We have integrated Payment API to simplify APC payment.
Challenges I ran into
Integration of Open Journal System (OJS) with Invoices API.
Accomplishments that I'm proud of
Integrating simple checkout to the OJS.
Built With
amazon-web-services | JournalPay | OJS Payment System | ['Tri Labs'] | [] | ['amazon-web-services'] | 191 |
10,045 | https://devpost.com/software/google-knowledge-graph-for-confluence | Inspiration
When I saw an example app in Forge for a dictionary that displays information about whatever you selected I remembered the
Google Knowledge Graph Search API
. Its an API which allows you to get information about almost anything (People, Places, Companies, etc.) and thought it would be useful to integrate it to allow people to see information about things selected in the wiki.
What it does
Uses the Google Knowledge Graph Search API to fetch info about whatever text you select and displays it in a tooltip
How I built it
Using Atlassian Forge
Challenges I ran into
Support for doing styling in Forge UI is pretty limited, I just tried to do the best I could but it could be more pretty if we could use CSS or something to style the components
Accomplishments that I'm proud of
I was able to go from nothing to having a working app quickly
What I learned
How to implement a Forge application
What's next for Google Knowledge Graph for Confluence
I released the code as an open source so anyone can contribute. I have ideas about various additional features.
Built With
bitbucket
forge
Try it out
briankircho.atlassian.net
bitbucket.org | Google Knowledge Graph for Confluence | Learn more about anything on your confluence wiki pages (People, Places, Companies, etc.) simply by selecting the text | ['Brian Kirchoff'] | [] | ['bitbucket', 'forge'] | 192 |
10,045 | https://devpost.com/software/jira-bodo-jql-powered-dashboards | Inspiration
Dashboarding tools like redash and superset give power to the users in terms of creating their own dashboards. I wanted to do something similar but using JQL instead. Existing charting solutions are either too simple or too complicated, I wanted to create something in between so that folks are able to create complex charts without delving into expensive third party products.
What it does
It allows the user to create customizable charts and tables purely through JQL. Users are able to generate multiple charts from the same table source and also have the ability to export the table to csv for consumption elsewhere. Users are also able to even create text widgets that are powered by Markdown.
How I built it
I used atlassian-connect-express to build everything. API is mostly driven by graphql and I used typeorm as the db modeling layer. The frontend is purely made out of modern react.
Challenges I ran into
Deploying on digital ocean was harder than I anticipated. Mostly because digital ocean's managed db's require SSL which the default ACE setup does not support. I had to fork ACE and updated it to support it
Lack of JQL editor meant that it's not as great as a user experience as native jira would be
Deploying SSL and testing the deployed app was challenging as I kept on encountering cryptic error messages and there's not a great reliable source for help. The forums are good but the feedback loop is too slow.
Lots of edge cases relating to the jira search api. The jira issues search has a lot of edge cases when it comes to rendering the results in a standard way. I had to come up with my own custom converter to represent the issues in the way that is flexible enough to use inside the tables.
Accomplishments that I'm proud of
I also realised codegeist was happening 2 weeks before the deadline so I'm proud that I was able to wrap up the mvp and have something deployed. Throughout the process I also managed to submit a bunch of PRs into the ACE framework, mostly around code maintainability so that future developers have an easier time reading the code.
https://bitbucket.org/atlassian/atlassian-connect-express/pull-requests/188
(merged)
https://bitbucket.org/atlassian/atlassian-connect-express/pull-requests/190
(merged)
https://bitbucket.org/atlassian/atlassian-connect-express/pull-requests/193
(merged)
https://bitbucket.org/atlassian/atlassian-connect-express/pull-requests/194
(merged)
https://bitbucket.org/atlassian/atlassian-connect-express/pull-requests/195
https://bitbucket.org/atlassian/atlassian-connect-express/pull-requests/196
What I learned
ACE
Docker and deploying on digital ocean
Creating a typescript mono-repo
Using github actions for CI
Setting up sentry for monitoring
Setting up mixpanel for analytics
What's next for Dashbodo for Jira - JQL powered dashboards
More chart types and charting options. Introduce more widgets to be added to the dashboard.
Built With
atlassian-connect-express
connect
graphql
jira
react
typescript | Dashbodo for Jira - JQL powered dashboards | Create advanced charts and tables purely using JQL. | ['John Jiang'] | [] | ['atlassian-connect-express', 'connect', 'graphql', 'jira', 'react', 'typescript'] | 193 |
10,045 | https://devpost.com/software/telegram-support-channel | Inspiration
In May 2020 Atlassian acquires Halp to make integration with Slack better. Our mission was to create an application that give an ability to create new customer requests from Telegram which allows to communicate between user and Jira Servicedesk agent.
What it does
This application creates new jira issue, from Telegram, which are based on the specific configuration for every project.
Jira Administrator can set bot token in the plugin general settings. Jira project administrator configures project and telegram request types by himself. Telegram request type is similar to servicedesk customer request types.
How we built it
We used Atlassian Connect for Spring Boot, ReactJS, Swagger.
Challenges we ran into
Work with Atlaskit was a great effort for us because there are a lot of workarounds which are not obvious.
What we learned
New stack of technologies and how to build plugin for Jira Cloud platform
What's next for Telegram Support Channel
We will improve communication features between Jira and Telegram users and publish our work to Atlassian Marketplace.
Built With
atlassian-connect
java
react
spring
Try it out
github.com | Telegram Support Channel | In April 2020 Telegram has had 400 millions monthly active users. Our idea is to create new issue channel which is based on the requests in Telegram bots. | ['Bohdan Belokur'] | [] | ['atlassian-connect', 'java', 'react', 'spring'] | 194 |
10,045 | https://devpost.com/software/who-is-the-team-adept | WITTA project title page
WITTA
Who Is The Team Authority
Who exactly knows the person best to advise on tasks and coding problems?
The person who has committed the code, that's who!
The person who helps in confluence chats, that's who!
The person who checks in the change, that's who!
Using AI analysis we create a trained model of the code base and ask it.
Introduction
https://developer.atlassian.com/
hack2020
https://www.atlassian.com/forge
https://codegeist2020.slack.com/
https://witta.atlassian.net
Inspiration
I am an avid consumer of personal assistants, ranging from "Alexa turn off the light/heater" to "OK Google, do I have anything on tomorrow". These seem to be cute skills, but not particularly time saving in the long term.
As a seasoned (more pepper than salt) developer, and freelancer I often struggle with the small spheres of knowledge which some teams and companies operate in. With everyone being busy, or not knowing who did what and who the current authority on a subject is. I eventually find out, but usually via several hours of other peoples precious time. I've always wanted a service which volunteered this information while I was developing tasks or documentation and to be able to contact the very person who could answer my questions quickly and with Authority.
Most of our time is spent searching for information, and to create an AI driven expert for locating the authority on a codebase or subject within the company would save a lot of my time.
Eventually, I see WITTA transforming into a codebase assistant, being able to ask questions like "Who has committed the most database code in this project" and "Who knows most about widgets". These are very generalised questions, but I don't think we're that far from being able to create something a few steps closer.
Aims
When working on a task, or gathering information, the person who is commonly believed
to have the most knowledge may not actually be the correct person to contact.
Or the process to find the people to speak with is fraught with red tape and assumptions.
All we want to know is;
Who is the best for this task?
Submit task text (unfiltered)
identify user with git experience, etc
Are they free?
system allows organised meeting time
Can we ask a question of them?
Instead of direct contact, authorities can be contacted without the team knowing who, via the WITTA system, and are invited to contribute. No pressure.
e.g. "This JIRA ticket has been created and the author may need your expertise. The creator has asked for optional feedback."
Alternatively, list of people are generated under jira ticket with specific knowledge
recently committed code in area of current task
have commits which mention keywords mentioned in task
have approved code in area of current task
have created tickets in area of current task.
Also, while in IDE, show people who are most proficient in the particular area by accessing the WITTA Api.
AI Aims
To index a whole company's JIRA and Confluence stack may be a step too far, so there may need to be individual stacks of knowledge to enable the AI engine to focus on specific projects and collections only.
Text Analysis ; Person has created content for target / key phrase
Code Analysis ; Person has submitted code/approved code in code area
Comment Analysis ; Person has commented on code area/confluence
Sentiment Analysis; To determine areas of the codebase which have caused issues in the past
UI Elements
Jira panel : See experts relevant to this JIRA
Confluence Panel : See experts relevant to this JIRA
Services available for future WITTA forge integration
Webservice 1: WITTA query service to interrogate the AI model remotely
Webtrigger: Submit new content to the AI model
UI: Submit tickets or Confluence pages to be consumed by the Witta engine. Request Adepts from WITTA
Ingestion
The way which the information will be ingested and tested will depend on the technology used and the weight
of authority in each organisation. For example, an organisation may put more weight on code comments than
confluence comments. Others may only wish the knowledge model to be purely code based, another, comment based.
Phrases and content will be separated into code and system models.
Where code will focus on comments made in submissions to bitbucket and diffs
within codebases, and system will focus on confluence and JIRA comments, reinforced with emoji and like detection.
Ingestion of current content
It should be possible to write a script that will start at the first commit, or confluence message related to a task, and find references to JIRA
and Confluence and commits in BitBucket and submit them for ingestion.
Model Training
Where ingestion would allow the models to be populated, it will need to be trained prior to the dataset being utilised.
Future considerations / possibilities
The model itself would need to be retrained periodically as the data set grows to ensure that the quality of suggestions remain high.
The interface for this will need to be created as per the AI platform used, but is wholly separate from WITTA development.
As the model increases in size, the predictions may also include showing similar tasks and completed code, and ultimately suggesting solutions to tasks and what areas caused repeated commits and longer than estimated task durations.
Implemented Features
Two Lambda functions were created.
Two AWS API interfaces were created.
Two Forge UI components created
WITTA Panel, showing authorities based on contents of a task in JIRA
WITTA Ingest, automatically supplying content to AI engine
WITTA Query, showing authorities based on selected text in Confluence
Resources
Education Pack
Icons made by
Nhor Phai
from
www.flaticon.com
Appendix / code examples
AWS Event
WITTA-Update
arn:aws:lambda:us-east-2:652680035346:function:witta-update
https://mzh822kz64.execute-api.us-east-2.amazonaws.com/default/witta-update
WITTA Update API
API: api-gateway/mzh822kz64/*/*/witta-update
API endpoint: https://mzh822kz64.execute-api.us-east-2.amazonaws.com/default/witta-update
API key:
API name: witta-update-API
API type: rest
Authorization: NONE
Enable metrics and error logging: No
Method: ANY
Resource path: /witta-update
Security: NONE_KEY
Stage: default
exports.handler = async (event) => {
const uuid = {
v1:()=>{
return '00001'
}
}
let resp=[];
let date='2001-01-01';
let guid=uuid.v1();
let teamId=event['teamid'];
let projectId=event['projectid'];
let siteId=event['siteid'];
let userId=event['userid'];
let c=0;
let t=event['data'].length;
const processData=(data)=>{
//upload to witta-engine ML
c++;
resp.push(guid+':'+siteId+'-'+projectId+'-'+teamId+'-'+userId+' data item '+c+' of '+t+' from '+data['source']+'(REF:'+data['ref']+') ingested');
}
resp.push('WITTA-UPDATE');
event['data'].forEach(d=>processData(d));
resp.push(guid+':'+date+': All ('+c+') Items of Data Processed, thankyou');
const response = {
statusCode: 200,
body: JSON.stringify(resp),
};
return response;
};
WITTAUpdate
{
"data": [
{
"ref": "reference-1",
"source": "jira",
"text": "some text here"
},
{
"ref": "reference-2",
"source": "confluence",
"text": "some text here"
}
],
"userid": "person1",
"teamid": "team-gamma",
"projectid": "project-alpha",
"siteid": "site-beta"
}
WITTA-Find
arn:aws:lambda:us-east-2:652680035346:function:WITTA-Find
https://agtnwb4k4i.execute-api.us-east-2.amazonaws.com/default/WITTA-Find
exports.handler = async (event) => {
let content=event['content-by-importance'];
let people=['5f03a0bf1a26ad0014e8bfe6','5efe82df3404690bae97dd5c','5f03a0bf1a26ad0014e8bfe6','5f03a0c0502ce1001dc740ae','5f03a0bf502ce1001dc740ab']
const PopulateResponse=(query)=>{
//This would call the WITTA ML algorithms, populated by WITTA-Update
let selected=[];
let num=Math.floor(Math.random()*people.length);
let highest=0;
let total=0;
for(var i=0;i<num;i++){
let person=people[Math.floor(Math.random()*people.length)];
let score=Math.random();
selected.push({"userref":person,"score":score});
if(highest<score){highest=score;}
total=total+score;
}
let average=total/num;
return {'query':event['query'],"numadepts":num,"maxscore":highest,"averagescore":average,"adepts":selected};
}
let resp=PopulateResponse(event['query'])
const response = {
statusCode: 200,
body: JSON.stringify(resp),
};
return response;
};
{
"query": "some query hered"
}
WITTA-Find API
API: api-gateway/agtnwb4k4i/*/*/WITTA-Find
API endpoint: https://agtnwb4k4i.execute-api.us-east-2.amazonaws.com/default/WITTA-Find
API key:
API name: witta-find-API
API type: rest
Authorization: NONE
Enable metrics and error logging: No
Method: ANY
Resource path: /WITTA-Find
Security: NONE_KEY
Stage: default
Built With
amazon-web-services
bitbucket
confluence
forge
functions
jira
lambda
Try it out
witta.atlassian.net
hack2020.appmecha.co.uk | Who Is The Team Aauthority (WITTA) | Who exactly knows the person best to advise on tasks and coding problems? The person who has committed the code, that's who! Using AI analysis we create a trained model of the code base and ask it. | ['neil highley'] | [] | ['amazon-web-services', 'bitbucket', 'confluence', 'forge', 'functions', 'jira', 'lambda'] | 195 |
10,045 | https://devpost.com/software/search-gadget-for-jira | Inspiration
Searching for an issue in Jira is very imprecise and time-consuming. And you would need a search per context (support board, custom board, billing board, ...) to search even more precisely and effectively. And searching over the whole text. Not only by words or beginning of words (like JQL).
What it does
With this plugin you get a Dashboard gadget that allows you to find processes very effectively and quickly. You set a filter as a subset of your processes once and define which fields should be searched and which should be displayed.
Now you simply search for the processes in the respective context by entering text. A full-text search is used (in contrast to JQL).
What advantage does the Search Gadget bring you? Convince yourself with the following Use Cases:
On the accounting board: Quickly find an invoice transaction in a specific project by the invoice number.
Customer calls - quickly find the customer by phone number or name.
Support board: Just find support ticket by customer e-mail, text or transaction key.
How we built it
We build this with atlassian connect and react. And with a super team!
Challenges we ran into
The full text search was a challenge because you had to find it very quickly and effectively. And we have not native java but only the existing REST APIs.
Accomplishments that we're proud of
Because of some API restrictions we found an effective way for searching fast in many issues.
What we learned
It was the first time with react in jira context. Wonderful framework for plugins!
What's next for Search Gadget for Jira
We want to include more searches outside of dashboard. Even replace the existing search across all issues.
Built With
atlassian
javascript
jira-cloud
react
Try it out
marketplace.atlassian.com | Search Gadget for Jira | Stop searching - start finding! Find issues (full-text) context sensitive in Jira very effectively. Set a filter as a subset of your Issues once and define fields should be searched and displayed. | ['Steffen Stamprath', 'Ronny Hergaden', 'Marcel Herrmann'] | [] | ['atlassian', 'javascript', 'jira-cloud', 'react'] | 196 |
10,045 | https://devpost.com/software/conduit | Final View
Template Creator
Pipeline Editor
Inspiration
I wanted to be able to display a list of pull requests closed recently on a Confluence page as part of a change management documentation process, but couldn't find a straightforward way to do so. This got me to think that we have so many sources of data all over the place but no real central way of pulling and displaying them where we want it/how we want it. So I started working on Conduit!
What it does
Bring your data back to you
Conduit is a platform that lets you create pipelines that pulls data from various sources (called producers) back to you. Currently there is support for HTTP APIs, but there may be more in the future.
Transform and present your data the way you want it
Conduit allows you to create templates to present your data how you want to. The easy to use templating engine includes features from looping through an array of items to util functions that can transform data. The template also blends in with the Confluence page styles and supports additional formatting such as code blocks, blockquotes, tables, etc.
How I built it
The backend API is written in Golang. It uses Firestore to store the pipelines that are created since the pipelines configuration has to be flexible.
The Confluence integration/macro is built on top of the Atlassian Connect Express framework (which is in Node.js), and the macro editor frontend is built using React. The integration also has a Postgres store.
Both services are currently deployed onto Heroku.
Challenges I ran into
Atlaskit UI source code examples are not viewable and it can be hard to integrate sometimes since the components are using outdated libraries
Confluence has bugs that prevented the macro from working as expected (eg. Editing a macro doesn't refresh the macro preview panel, Can't use
rich-text
type macro)
Accomplishments that I'm proud of
Getting more familiar with React/Redux and building a full UI with these technologies
Learning how to use GitHub Workflow/Actions
Successfully creating a macro on Confluence
What I learned
React/Redux
GitHub Workflow/Actions
Atlassian Connect
What's next for Conduit
More producers/ways to pull data apart from HTTP APIs
Better transformation functions
UI/UX improvements
More integrations
Built With
atlaskit
confluence
go
node.js
react
Try it out
confluence.teamconduit.com | Conduit | Create pipelines that pulls, transform and present data anyway and anywhere you want it. | ['Joey Lee'] | [] | ['atlaskit', 'confluence', 'go', 'node.js', 'react'] | 197 |
10,045 | https://devpost.com/software/resthuman-ixr6ob | Request Builder
POST request
API Response
Request History
RestHuman - API management for Bitbucket
RestHuman is an API management tool for Bitbucket. Using RestHuman you can easily test REST APIs from your repo page. It is powered by Atlassian Connect. It supports request methods like GET, POST, PUT, PATCH, DELETE and OPTIONS. You can easily add headers or Basic Auth using the user interface. The request builder supports both raw and form request body. RestHuman also supports local request history powered by local storage.
Installation Steps
1) Enable Development mode for your bitbucket account by visiting
https://bitbucket.org/account/addon-management
and selecting "Enable development mode" checkbox.
2) Install the RestHuman app by visiting
https://bitbucket.org/site/addons/authorize?addon_key=resthuman&redirect_uri=https://resthumanapi.netlify.app/
and granting access to your account. Confirm the successful installation of the RestHuman app by visiting
https://bitbucket.org/account/addon-management
and double checking that RestHuman app is displayed in the list of installed apps.
3) Go to your repo page. The RestHuman app will be available in the left Sidebar of your repo page
e.g.
https://bitbucket.org/viraj07/test_repo/addon/resthuman/resthuman
Sample APIs to test
Use the APIs from
https://reqres.in/
Future Improvements
As of now the tool only supports CORS enabled secure APIs. Later it will allow you to test any APIs using a secure proxy.
Built With
atlassian-connect
bitbucket
react
Try it out
bitbucket.org | RestHuman | API Management for Bitbucket | ['Viraj Anchan'] | [] | ['atlassian-connect', 'bitbucket', 'react'] | 198 |
10,045 | https://devpost.com/software/com-plaint | Com-plaint
Inspiration
A need for developing a complaint module and its wiki in our current project.
What it does
Com-plaint handling and management.
How I built it
Challenges I ran into
Accomplishments that I'm proud of
What I learned
What's next for Com-plaint
Built With
bitbucket
confluence
forge
Try it out
bitbucket.org
tri-labs.atlassian.net | Com-plaint | Complaint handling and management | ['Tri Labs'] | [] | ['bitbucket', 'confluence', 'forge'] | 199 |
10,045 | https://devpost.com/software/my-issue-notes | Issue without any note
Adding new note to issue
Using "Help" button, you can check available formats that you can use in note
Issue with example note
Using "Publish" button, you can create commend from your note
Issue with commented example note
Inspiration
Sometimes when browsing issues on Jira we want to make quick notes, add some TODOs, create draft of an comment, but we don’t want to share everything with others. Unfortunately everything that we input on issue is publicly visible with others on Jira.
We wanted to change that and add user some space where one can add some quick personal notes about issues. That lead us to our idea for My Issue Notes app.
What it does
My Issue Notes allow users to create their personal notes on Jira issues. Those notes, unlike other fields on Jira, are visible only for users that create them, thus allow them to quickly add their personal todo lists, thoughts about issue, temporary drafts of comments, etc. Each created note can be easily edited or deleted.
Additionally each note can be published as public comment with a click of a button. This gives user ability to create comment drafts as a notes and publish it later. Despite on what computer or browser he/she created that note - notes are saved on Jira issues and can be accessed and published from other devices!
Notes accepts standard markdown syntax. It even keeps proper formatting when publishing them as comments!
How we built it
We built our app using Forge and Jira Cloud API. We tried to use best of what Forge and Jira Cloud could give. With Forge API we build UI and business logic for an app, while Jira Cloud API was used to help us store and retrieve data for issue notes.
With the help of the TypeScript we managed to develop maintainable code base for an app, that we want to publish in future to Atlassian Marketplace.
Challenges we ran into
It was our second Jira Cloud + Forge app, so we were already familiar with things that we can and can’t do in this environment. This helped us a lot to avoid problems on early design stage.
When we get to the developing phase everything was going smooth. Until we get to the publishing notes as comments part. We found out that v3 version of Jira Cloud endpoint for creating comments accepts only
Atlassian Document Format
- document format stored in JSON. It was totally not compatible with pure string markdown format that we were using in notes.
So we search a little to find out easiest solution for this case, and we found it! At least it looked like so. Version 2 of this endpoit accepted plain string, so we were full of hope that it would also recognize markdown syntax. But nope - it was plain text only. Anyway, it was endpoint from old version of API, so it could be used as a temporary solution.
We wanted proper solution for this problem, so we get back to v3 endpoint. Unfortunately there’s no direct Markdown → ADF converters, but we were able to find neat Markdown-it library, which helped us tokenize markdown text. With that tokens it was relatively easy to quickly develop converter that would convert Markdown tokens to Atlassian Document Format JSON.
And that we managed to provide this functionality in our current version of app. It definitely need some more care and tweaks, but from our initial tests it was working flawless!
We also got some minor issues with buttons. Unfortunately buttons in standard Forge UI cannot by styled in any way nor we could add any icons to them. So we end up with four gray buttons for saving, deleting, cancelling and help in a row. It was a bad UI choice, as they were not easily recognizable, especially saving.
But luckily we came up with an idea: emojis❗ We added some of them to buttons labels (✔ 🗙 🗑️ 💬 📝) and suddenly each button was easily recognizable.
Accomplishments that we're proud of
We are happy about time that we need to implement fully fledged app to Jira Cloud. Even with some issues with Markdown to Atlassian Document Format converter, we managed to build our app from scratch in couple of days.
What we learned
Quick app development and quick problem solving! We managed to design an app and estimate time to ship all its features that we wanted in given deadline.
Additionally with this being our second Jira Cloud and Forge app we learned a lot about these technologies, so we looking forward to develop some more apps for Jira Cloud in Forge. 😊
What's next for Absence Tracker
We want to expand on some ideas that we had while developing our app.
First of all we want to add user an ability to create multiple notes per issue. This would help him track multiple ideas on issue without needing to keep them all in one note.
We also want to expand on idea about sharing notes with others. Currently its only available by publishing it as comment, but we are seeing neat feature in collaborating on notes with other selected users.
At the end we also want to add some panel, where user can browse and find all his notes.
And just like our other Forge app, we are looking forward to get Forge out of beta and share our work with other Jira users!
Built With
bitbucket
forge
git
javascript
jira
markdown
react
typescript | My Issue Notes | Add personal notes for Jira issues.Got some notes for issue, but don't want to share it with others? Or maybe you want to create draft for comment and publish it later?We've created app for you! | ['Przemysław Stępniak', 'Tomasz Witkowski', 'Michael Dubel'] | [] | ['bitbucket', 'forge', 'git', 'javascript', 'jira', 'markdown', 'react', 'typescript'] | 200 |
10,045 | https://devpost.com/software/absence-tracker | Quick preview panel for upcoming and ongoing absences in 7 days for users related to this issue (reporter, assignee, user pickers)
You can click on Absence Tracker panel on the right to get more information about absences
You can get even more informations, like summary with type of absence or direct link to absence task
New absences are logges as new issues in absences project. With familiar Jira interface it's easy to use by users!
App in full glory on fullscreen issue view (you can also hover on each row to get some more information)
Issue without users on upcoming or ongoing leaves
After installing app you will be greet with initialization button, so it will automatically create absences project & start/end date fields
Inspiration
We were inspired by our working environment. We can can create issue, assign someone and then… turns out he/she have upcoming vacations in few days. It’s can be problematic, especially in current pandemic times, where we are working mainly from our homes and we have limited communication options than before. Holiday season is not helping either!
It’s also great way to learn Forge and start developing for Jira Cloud!
What it does
It helps you tracking leaves, absences or remote work of your colleagues directly on your Jira Cloud.
But it’s not an ordinary leave tracker! It integrates with Jira and shows upcoming and ongoing absences directly on Jira issue and only for users that are connected to that issue.
What does that mean? After you create issue, or you are viewing others tasks you will see absences only for users that are related to that issue: as reporter, assignee or any other custom user picker fields. Thanks to it you will get instant information about current and upcoming absences for users that are crucial to that issue. Now you will get some time to do important stuff with that task, before others will go on their dream vacation.
After installing our app you will be greeted with an initial setup message. You will need to be logged as admin, so you could create dedicated Jira project and custom fields for logging absences. After initial setup process you will end up will new project “Absence Tracker” with two new custom fields: start/end date. Users then could create new tasks in that project with their absences.
This approach let you store all personal data directly in Jira, without any external services. Additionally it’s easy to get custom absences statistics using Jira's built in issues search with JQL.
How we built it
We tried to get best of what Jira Cloud and Forge API can provide us.
First - don’t reinvent the wheel. We tried to use elements that Jira provided us out of the box. So we used dedicated Jira project for storing information about upcoming leaves. Every absence is logged as an issue in that project. We also created two date custom fields for providing start/end dates and added them to project screen. This way we got great way to store absences without using any custom storage or dedicated external database. We could also filter out those issues using JQL, just like in SQL!
Second - squeeze everything best from Forge API. With Forge we don’t need to care about infrastructure that our plugin runs on. It was great help, as we could focus more on development features that we want to provide for our users, not about future maintenance of servers that it will be running on. Additionally with Forge Issue Panel and Issue Glance we could fit our application perfectly in Jira issue view!
Third - clean code. With a quick and easy integration with TypeScript we were able to quickly build our app from scratch in a way we wanted to built it. Static type checking is something we wanted in an app that we plan to publish and support in longer term.
Challenges we ran into
Despite having experience developing Jira Server plugins, developing for Jira Cloud for our part of team was completely new experience. We were so used to Jira Server and its limitless ways of doing stuff in different ways (at least UI-wise) that at first we were a bit overwhelmed and skeptic, if our idea was even possible in current state of Forge UI.
So biggest challenge was definitely making some design changes so we could make our idea possible on Forge UI. And still, our app should be as less intrusive as possible, showing only crucial information at first glance, and display more detailed data only when user demanded for that.
Next big obstacle was project that we wanted to log absences on. We really wanted to automatize process of creating Absences Project and adding start/end date fields. And arrange them in a proper way on issue screen! It was crucial for our app, as we wanted to make it as user friendly as possible. So we studied Jira Cloud API v3
a lot
. A lot of test projects were created. A lot of test projects were deleted. But we finally…
Accomplishments that we're proud of
…made it! Now setup process is completely automated. When first installed our plugin displays button with information about initial setup. This initial setup creates Jira project, start/end date custom field, add them to default screen and even arrange them on issue create screen! After that users are free to create their first absences in our project. We still got some timeouts due to a lot of API calls in one action, but we figured out that we can remove some unnecessary API calls, and use Promises to call multiple endpoints in parallel without waiting for them. At least where we could do this.
But this is not only thing we are proud of. Even with challenges that we met with limited UI features compared to Jira Server, we were still able to quickly redesign and ship our app. Instead of initial, impossible idea of displaying absence information below every user fields, we instead take some good use of Issue Panel and Issue Glance. Now we use Issue Panel for quick information about current and upcoming absences, and Issue Glance for detailed view. Everything is located in one place, so at the end we think it was great and user friendly redesign idea.
What we learned
First and foremost - developing for Jira Cloud. After years of developing for Jira Server this was our first app for this platform. With the help of the new Forge API it was like a breeze.
Second - fast app development. Due to relatively late entry for Codegeist we got some limited time to design app, learn new APIs and develop it. It was intense days for our small team, but we made it! And learned a lot from it.
What's next for Absence Tracker
We definitively want to get more usage of issue types. Currently there’s one default issue type, but we plan to add ability to create more issue types specific for different absence types. Eg.: one issue type will be only for holiday leave, other for remote work etc. At the back-end we already have implemented issue type parsing, but there’s still some work to add ability to automatically create issue types in our project without need to do it manually in Jira configuration.
We also got some other ideas like project workflow with custom approve statuses, and ability to add more projects (eg.: one project per team).
At the end we also looking forward to publish our app on Atlassian Marketplace, when Forge will be out of beta. 😊
Built With
bitbucket
forge
git
javascript
jira
react
typescript | Absence Tracker | Easily track absences of your colleagues with help of the Jira issues!With Absence Tracker you can check if any active user on Issue (like assignee, reporter, etc.) have ongoing or upcoming leave. | ['Tomasz Witkowski', 'Przemysław Stępniak', 'Michael Dubel'] | [] | ['bitbucket', 'forge', 'git', 'javascript', 'jira', 'react', 'typescript'] | 201 |
10,045 | https://devpost.com/software/matrix-for-jira | Matrix View - shows risks (issues) in the matrix rows and columns and allows you to drag and drop the cards around.
List View - allows you to manage items that are included on the board, change the columns displayed (inc. custom fields) and show links
Issue View - Access matrices that contain the current issue
The customized color scheme feature in action - create unique color combinations!
Right click context menu adds issues directly to the cell!
Design Mockup for the Matrix View
Team Cover Card - Team Members: Himal, Craig, Jack
Inspiration
We are interested to see if the two-dimensional grid concept, which can be used to plot risk matrices, translates well onto Jira Cloud and to use as many different approaches to design and implementation as we could - including new interface elements, libraries and optimizations. We wanted the UI to be vibrant, animated and a bit different, drawing on features like drag/drop, context menus, inline fields and lottie animations to give the App a personality.
What it does
Visualize your Jira Issues on a two-dimensional grid (a matrix), which can be customized in several ways to suit many different applications, for example, as a Risk Matrix to help you understand risks and their likelihood by plotting your issues on the grid.
In order to apply to many customer sectors, the following features had to be implemented:
Increase or decrease the number of rows and columns in the matrix
Multiple matrices per Project
An issue must be able to appear on multiple matrices at once
Customizable labels that are used across the matrix and interface
Change the color of individual cells or entire rows and columns.
Ability to see which matrices an issue is included on from the 'View Issue' page
How we built it
We had 4 design and requirements meetings initially where we decided (a) which features needed to be included, (b) what the layout and structure of the App was going to be and lastly (c) decided which team members will collaborate on which parts of the App.
Craig constructed some high-level designs of the primary pages using Illustrator - the Matrix View, the Item List and the Settings page. Himal and Jack then performed the development based on these designs, which involved collaborating and working independently to product a solution that, when combined, is more than the sum of it's parts -
First, we designed the Data Model that would be used to underpin the solution (Issue Properties were eventually chosen), as well as putting together what we call the 'skeleton', which is a very early version of the App with all extension points added via the atlassian-connect.json file as well as their matching routes and React components - which are set up with react-router to respond to the relevant endpoints - this laid the foundation for the development work to commence.
Next, as we had designed the data model and architecture, we were ready to assign work to both developers to work individually to rapidly prototype each part - we decided that Himal would implement the back-end and the matrix settings interface, while Jack would complete the matrix and list front-end components - as they were most familiar with these elements. However, each developer also checked the others' work using the code history and suggested improvements during meetings we ran.
We frequently pushed our changes to Git, fixing any merge conflicts that occurred and ensured that we were aligned on the particular pieces - the Typescript language was great for this, as using type definitions, each developer knew what object structure and format to expect - this has been a problem in the past due to the flexible (weak) typing in JavaScript.
We also performed regular stand-up meetings a few times a week and collaborated as a team to make the App as cohesive as possible - but we still went through 2 release candidates before we were able to record our demonstration video and at the end we had a product in MVP form for submission and we are really excited to see what people think of it!
We're planning to do a recorded discussion on some of the choices we made with the App, but it wasn't possible to have this ready in time for this submission.
Challenges we ran into
There were numerous challenges that we ran into during the planning, implementation and design of the App - we learnt a lot from these -
One of the biggest problems was underestimating how much work was involved in writing the App in the short space of time and we had to compromise and leave out some elements for the submission (e.g. different matrix appearance options and matrix permissions). These features will be added to the release version of the App.
Working remotely – recent events have forced us to work in a different way and ensuring everyone was aware what each other was working on was difficult. We have learnt a lot from this which we will apply to our daily work.
The short implementation time meant that we had to work a lot more 'closer' and problems with version control (merging) were a lot more frequent than other projects we have worked on.
We were stuck on the data model for a little while, until we decided on a system that allows us to search not only for issues with a particular pair of values, but any issues in a particular matrix, column or row - great for allowing us to fix any values when you e.g. remove a row, as the operation is not O(n), with n being the number of columns but O(1) as you can get them all with a single query. This was made possible by using an array of UUID's which contains both the row and columns of the issue across all matrices - which we found beneficial. This used Issue Properties to store the matrix values and the Jira Index to index their values - meaning we didn't have to write our own storage system (the App itself is stateless other than the required AddonSettings data.
What's next for Matrix for Jira
We plan to release Matrix for Jira in July after it has been thoroughly tested.
We'd also like to implement a number of features that we had to leave out of this version due to time constraints:
Different appearance options (as shown in the appearance settings tab) that change the view onto the data
Permissions that can be placed on individual matrices to restrict access
A global page which allows you to access and search for matrices across all of your projects
The ability to opt-in or opt-out Projects from the Matrix capability
We'd also like to improve the operation of the drag/drop and context menu features on the Board, as they don't work great on touch devices at the moment.
Most of all, we are excited to see the community response to Matrix for Jira and are looking forward to bringing this to customers soon!
Built With
node.js
react
typescript
Try it out
the-matrix-app.herokuapp.com | Matrix for Jira | A simple way to plot your Jira issues in a two-dimensional matrix grid. The intuitive drag and drop interface allows you to arrange your issues into the desired position. Change size, color and labels | ['Jack Graves', 'Craig Willson', 'Himal Gurung'] | [] | ['node.js', 'react', 'typescript'] | 202 |
10,045 | https://devpost.com/software/program-tree | Birdseye view of your entire Program
Create your program quickly and easily using a drag and drop interface
Track the story point and time tracking progress of every level
Inspiration
I noticed many people wanted to represent their entire Program on one page in a tree, but getting set up with existing apps like Portfolio and Structure could be time consuming and confusing.
I was inspired to create a way to track and your manage your Program which retained the flexibility of Portfolio and Structure but was much easier to use and set up.
What it does
It lets you create a Progam which can be represented on a single page. You can use JQL to create groupings, like Projects, Releases, Teams, sprints and assignees of unlimited depth. It also rolls up story point and time tracking estimates to each level so you can tack the progress of each level at a glance.
How I built it
I built it using ACE and Next.js. I used a
boilerplate
I created which lets you build ACE apps fast using modern frontend tools like React.js and Styled Components. It has a bunch of bundled features such as automatic license validation, cancellation page, loading components, Sentry integration, and some functions to make API calls from the frontend or backend much simpler.
Challenges I ran into
Making a drag and drop interface in a tree structure was difficult, but essential for a seamless user experience. There were a number of drag and drop packages but none for drag and drop in a nested tree list. I had to develop a system of indexing each item and tracking how far the mouse moved on the horizontal axis of the screen to determine where to add the dropped item.
I also needed to develop a way to recursively get an issue's children or parent/s, regardless of whether in a next-gen or classic project, and which worked with the new higher level issue types created in Program Tree. This took some trial and error to eventually get right.
Accomplishments that I'm proud of
I'm proud to develop a working app, which makes creating and visualising your Program a breeze. There are almost no buttons on the UI. It's a truly zen experience. When creating your program, you can drag and drop different segments in a way which is hard to beat in terms of simplicity.
What I learned
I learned that accommodations needed to be made for different project types. Next-gen projects connect issues to Epics with a Parent field, classic projects link with an Epic Link. Portfolio created issue types use Parent Link and Program Tree uses Parent Issues.
I learned how to develop a drag and drop interface in a tree structure. It requires a different way of indexing each issue and the functions for moving issues around on drop are very different.
What's next for Program Tree
I plan to release it in the Atlassian Marketplace. I still have some tidying up to do to make the experience even better:
add jql validations to make sure a query is a valid jql query, and there's not too many issues in the segment
ability to edit a program once created. I ran out of time before I could implement this
Built With
ace
next.js
node.js
Try it out
marketplace.atlassian.com | Program Tree | Visualise, track and manage your entire Program, including all your Projects, Releases, Teams and Issue Hierarchies, on ONE page in a nested tree list | ['Rhys Diab'] | [] | ['ace', 'next.js', 'node.js'] | 203 |
10,045 | https://devpost.com/software/smart-tracker-covid-19-ewyhzx | Inspiration
Now a days whole world facing the novel Corona Virus, to track the spread of novel Corona Virus country-wise, details of confirmed cases, deaths and Recovered, awareness regarding COVID-19. This Android app was created to spread awareness about the covid -19 virus.
What it does
The Android app named as ‘SmartTracker-Covid-19’ created to spread awareness about the COVID -19 virus. App includes following functionalities:
CoronaEx Section - This section having following sub components: • News tab: Having latest new updates. Fake news seems to be spreading just as fast as the virus but as we have integrated from official sources so everyone will be aware from fake news. • World Statistic tab: Real-time Dashboard that tracks the recent cases of covid-19 across the world. • India Statistic tab: Coronavirus cases across different states in India with relevant death and recovered cases. • Prevention tab: Some Prevention to be carried out in order to defeat corona.
CoronaQuiz section - quiz that will help people know about the Corona virus and its effects on human body. It chooses random questions and show the correct answer for the questions and at the end user will get to know their highest score.
Helpline Section - As this application particularly made for Indian citizen to use, all state helpline number of India included.
Chatbot Section - A self-assisted bot made for the people navigate corona virus situation. Common Questions: Start screening,what is COVID-19? , What are the symptoms?
How I built it
We built with using Android studio. For the quiz section we have used sqlite database and live news data we have integrated from the News API. For the coronavirus statistic we have collected data from worldometer and coronameter.
Challenges I ran into
At time of integrating the chatbot in application.
Accomplishments that I'm proud of
Though , It was the first attempt to create chatbot.we have tried to up our level at some extent.
What's next for Smart-Tracker-COVID-19
For the better conversation we will be looking to work more on chatbot.
Built With
ai
android
dialogflow
newsapi
sqlite
Try it out
drive.google.com | Smart-Tracker-COVID-19 | Developed an android application to track COVID-19 current situation in all over world and stats, all state wise in India | ['Pramod Paratabadi'] | [] | ['ai', 'android', 'dialogflow', 'newsapi', 'sqlite'] | 204 |
10,045 | https://devpost.com/software/jira4devs | Auto-complete with available commands
Auto-complete with contextual Jira data
Results view
Inspiration
I've used Jira in the past and have noticed its sometimes tricky users (especially new users) to find the correct screen to complete a certain action. This was an attempt to create one location to action most common Jira tasks. I decided to create a UI that closely resembles a terminal for a number of reasons
It's a familiar interface to many developers and computer users
The interface is clean and intuitive
Actions can be easily shared between users by copying and pasting the executed command
What it does
The application acts as an interface for many common Jira actions. By typing commands into the virtual terminal actions such as assigning or creating issues, logging work, or viewing project details can be quickly run. The application allows power users to utilize the power of Jira in a from a single location in an efficient manner
How I built it
The Jira4Devs UI framework was built from scratch using React JS. The static website is hosted on AWS S3 behind CloudFront allowing the application to be serverless.
All interaction with Jira is done with the Atlassian connect API which is injected in to the application by Jira.
Challenges I ran into
The trickiest part of this project was creating the terminal interface. There are a few open source react terminal components, but none were able to provide the extensibility requires of this project. Creating the terminal from scratch was the trickiest and most rewarding part of the project
Accomplishments that I'm proud of
I am most proud of of the user interface of this project. It was challenging creating a terminal-like interface in React but the end result looks clean and closely approximates an actual terminal emulator.
What I learned
The two main things I learnt from this project were
How to use the Atlassian Connect API, and its strengths/pitfalls
Advanced styling with React
What's next for Jira4Devs
There are a couple future features I would like to add to Jira4Devs
More commands
: The Jira API is quite comprehensive, so supporting more actions shouldn't be too challenging
Cleaner results view
: The current results table is concise functional, but there may be better means of representing some data. Sorting the reported data would also fall under this category
Code Refactor
: As is customary for a hackathon the code is a bit thrown together. Refactoring it into a maintainable project would enable more advanced features to be introduced with little risk to existing functionality
Built With
amazon-web-services
react
Try it out
marketplace.atlassian.com | Jira4Devs | A terminal built in to Jira that allows for the fast execution of command actions | ['Leighton Lilford'] | [] | ['amazon-web-services', 'react'] | 205 |
10,045 | https://devpost.com/software/intelligent-inventories | How Does it Work?
For Codegeist 2020, the "Inbound Inventory" module of Intelligent Inventories was implemented. This module creates a new Jira issue based on inbound inventory item details. A new inbound inventory item is identified by the inventory clerk (or other applicable role) who labels the email containing the inventory item details with the "Inbound Inventory" Gmail label. This label triggers a Zapier Zap and relays inbound inventory item details to Forge.
How was it Built?
Communication between Gmail and Jira was accomplished by using Zapier to send a webhook to Atlassian Forge. Atlassian Forge then used the data from Gmail to create a new Jira issue.
What's Next for Intelligent Inventories?
Additional modules, automation, and integration.
Built With
atlassian
forge
gmail
javascript
zapier | Intelligent Inventories | The Intelligent Inventories app integrates Jira's project management superpowers with the tools you use every day! | ['Faith Whitley'] | [] | ['atlassian', 'forge', 'gmail', 'javascript', 'zapier'] | 206 |
10,045 | https://devpost.com/software/sethlans | Inspiration
What it does
SETHLANS (Structured Ecosystem and Technical Hierarchy of Linked Atlassian Novel Solutions)
is a collection of
Atlassian
cloud apps utilizing the
Forge
development platform.
These apps include:
Jira-Forge-On-Helium
is an integration of
Jira
and the
Helium Network
.
Confluence-Forge-On-Helium
is an integration of
Confluence
and the
Helium Network
.
PyAtlasForgeSDK
is a software development kit for python and the
Atlassian Forge
platform.
ForgeSquarePOS
is an integration of the
Atlassian Forge
platform and
Square
small business APIs.
How I built it
Challenges I ran into
Accomplishments that I'm proud of
What I learned
What's next for SETHLANS
Try it out
bitbucket.org | SETHLANS | SETHLANS (Structured Ecosystem and Technical Hierarchy of Linked Atlassian Novel Solutions) is a collection of Atlassian cloud apps utilizing the Forge development platform. | ['Warp Smith'] | [] | [] | 207 |
10,045 | https://devpost.com/software/checkout-procurement-for-jira-service-desk | Catalog landing page in JSD help center using custom Checkout Request Type.
Catalog item browser showing item in the org store front.
Item detail showing price, description, image and specs.
Checkout Cart.
Checking out and making payment using department funds.
Item creation / editing in Checkout administration.
Department creation / editing in Checkout administration
Vendor creation / editing in Checkout administration
Purchase order template selection and customization in Checkout administration.
Agent fulfillment of a Checkout purchase request from user.
Sending a purchase order to a vendor via email. PDF is created and added to the ticket as well.
Assigning an existing item to user from Asset manager.
Assessing item assigned to users from Asset manager. Displays items in stock as well.
Ordering a backfill item after assigning asset to user.
Company details overview.
Items overview in administration. Displays item bundle capability.
Item Order view including status and requester from procurement agent view.
Agent view of the order request. Agent can edit, decline or submit order to vendors as well as receive items from vendors.
Department budget audit view listing procured items and remaining budget.
Vendor list in Agent View.
Inspiration
After working with several customers, we noticed that the procurement process was broken in their organizations. Multiple channels were used to make purchasing requests causing confusion and unnecessary repetition in communication. Additionally, it was hard to track budgets related to purchasing and keep all stake holders informed.
What it does
Manage items that organization users can order.
Manage vendors.
Create Purchase orders and email them to vendors for fulfillment.
Manage department budgets by keeping a log of all procured items for departments.
Manage assets in stock and assigned to users using Atlassian asset management API.
How I built it
Checkout is built using Atlassian Springboot framework, Atlassian React Kit and designed using Atlassian template in Sketch. Other than the items in Checkout, all data is stored as entity properties in customers Jira. All images are stored in a secured AWS S3 bucket. We use Postgres SQL to store all item descriptions and metadata for the store. We utilize AWS Fargate to host the products. The product can scale automatically to meet demand.
Challenges I ran into
The biggest challenge was trying to figure out where to store the data. We wanted to store all data in Jira but we were not getting great response from the Asset API. Ultimately, this is where we want all data to reside.
Accomplishments that I'm proud of
Biggest accomplishment is creating and moulding a product to fit into the Atlassian ecosystem by overcoming limitation in the UI and API and yet make it feel like it is an Atlassian product.
What I learned
It takes a great team to build a great product. Without my teammates it would have been impossible to build this product. It required a wide range of skillsets to accomplish.
What's next for Checkout - Procurement for Jira Service Desk
We are going to build an automation engine to interact with Jira and other tools as well as create ability to add custom fields into Checkout. Will add more capability to manage vendors and contracts.
Built With
adg
amazon-web-services
atlas-kit
fargate
jira-framework
postgresql
react
spring
Try it out
marketplace.atlassian.com | Checkout - Procurement for Jira Service Desk | Checkout streamlines your purchasing process with the simplicity and power of Jira Service Desk. Manage purchase requests, vendors, department budgets, orders and acquired assets all in one app. | ['Vincent Mutambuki', 'Andrii Medytskyi', 'Caleb Mackey', 'Wilber Torres Cristobal'] | [] | ['adg', 'amazon-web-services', 'atlas-kit', 'fargate', 'jira-framework', 'postgresql', 'react', 'spring'] | 208 |
10,045 | https://devpost.com/software/issue-dependency-tracker | Inspiration
When working on a big project with cross-department dependencies we were usually tracking all our work in Jira. If some of the issues were dependent or blocked we linked issues together and waited till blockers were addressed.
This works great when the relationships aren't complex and when you need to track only 1st level links. You can simply see them in Linked issues section in issue detail.
But often it happened that issue that was blocking the first was blocked by the other. And this is how the idea of the Issue Dependency map was born.
What it does
Issue Dependency Tracker visualizes nested issue dependencies on the simple treemap.
Using this map you’ll:
understand the full context of the relationship between the issues,
see what is that status and type of linkage of the issues (also nested issues).
How I built it
We pulled all the dependencies of the subject issue and structure it accordingly in preparation to send to a 3rd party service called
https://quickchart.io/
that exposes an API to send data and return a processed diagram image. This dependency diagram then gets embedded into the issue fragment using the Image component from Forge-UI
Challenges I ran into
Due to Forge limitations and restrictions in rendering any sort of pure HTML and CSS elements we had to come up with an alternative to generating the diagram
Translating the dependencies from current structure into a new one was a bit of a hassle
Accomplishments that I'm proud of
The initial planned implementation was going to be with the use of SVG canvas but we quickly decided against that due to the level of complexity required to build a dependency system based on SVG shapes. It was a great moment when one of our team members suggested this 3rd party library which enabled us to build the Forge app quick.
What I learned
That when there are limitations you get creative :)
What's next for Issue Dependency Tracker
Initial step will be to convert it into a Conect app to publish on the Marketplace. Eventually, when Forge is ready, port back to Forge.
Built With
forge
Try it out
bitbucket.org | Issue Dependency Tracker | See the whole context of the issue and understand how it impacts others work and projects. Issue dependency map shows relationships between the issues and their progress. | ['Biro Florin'] | [] | ['forge'] | 209 |
10,045 | https://devpost.com/software/requirements-checker | Inspiration
Let's be honest, it happened to us at least once that we rushed with the story, send it to our team without enough information or missing acceptance criteria. Sometimes we just scribble few words and hope that team will understand.
After a few years working with remote teams, we found out that well-written story makes happier and more productive teams.
We always make sure they're written in simple plain language so they're easy to understand for non-native speakers. Stories should also include motivation to give more context and of course acceptance criteria.
What it does
Requirements Checker analyzes issue description to see if the following criteria are met:
Does user story have correct format? The format should be As [a product manager] I [want to do something] so [I can achieve this]
Did you include the motivation section in your story?
Are there acceptance criteria or requirements included?
If any of the above is missing in the description Requirements Checker gives tips to improve.
It also analyses the readability of the text and ranks is with English level - 5th grade is easiest to read to Professional which is hardest based on Flesch–Kincaid readability scale.
You can access the results from the issue detail by clicking on the User story checker field.
How I built it
We used the text-readability library to interpret how easy or complicated the language is and we built a utility function to check if requirements are meet.
Challenges I ran into
Limitations in Forge, we wanted to add the FAILED/PASSED status of the issue requirements in a lozenge on the Glance tab. This would’ve enabled user to quickly understand if the requirements list needs attention. Unfortunately, as with a lot of other things this is not currently possible with Forge.
Accomplishments that I'm proud of
Pretty small and clean app.
What I learned
That there’s no way to send dynamic data to the glance tab
What's next for Requirements Checker
Requirements checker is a small motivational app that could be released for free to the Atlassian marketplace once Forge is publicly available.
We might think of giving an option to customize what checks should be done on the description to make it really usefull for every team and project.
Built With
forge
Try it out
bitbucket.org | Requirements Checker | This app checks your issue requirements and suggests improvements you can make to make it easier for others start their work on it. | ['Biro Florin'] | [] | ['forge'] | 210 |
10,045 | https://devpost.com/software/context-issues | Quickly find similar issues without leaving Issue View or switching to Issue Navigator
Select fields with shared values to significantly narrow down your search
Filter by fields in the currently viewed
issue to get more context
Enter the advanced mode and search using far-reaching JQL criteria and conditions
Context Issues is an app dedicated for Jira Cloud built with the Atlassian Connect framework.
Inspiration
Quick access to information is key to productive work. Context Issues lets you instantly discover similar issues, without switching contexts or leaving Issue View. Its purpose is not to replace Issue Navigator, but to save time and let you stay focused.
We have combined some ideas coming from our other apps - Dynamic JQL Links (which is no longer available) and TestFlo Server (which extends Issue View with a panel presenting JQL-based results), and reforged them into a completely new app, focused on user experience and simplicity and no need for configuration.
At the beginning of the year, we have learned that the Glance module will be supported in Jira Mobile, and we eagerly decided to use in our design.
What it does
Context Issues displays a list of issues that have something in common with the issue you are currently viewing in Issue View. Using buttons representing fields or properties of the current issue, like project, sprint, status, component, etc., you can quickly search for similar issues. With every push of a buttons you narrow down search results. No need for typing or JQL knowledge.
Imagine you are working on the backlog. You have created an epic and now you are creating a yet another story or subtask. During refinement of its description, you realize that you need to take a glance at stories you have previously created to make sure the scope of the new issue doesn’t overlap with other tasks. With Context Issues, you can access the list with just 2 clicks and don’t need to leave Issue View.
Or imagine you are a Jira Service Desk agent, working on your queue. A new ticket has arrived and you want to quickly find out if the customer has contacted you before, or check whether the problem is new or recurring. With Context Issues, you can find all tickets with the same reporter on the spot.
Context Issues supports a wide range of fields, so the number of use cases is enormous. If your search is very specific, you can switch to JQL and refine your search.
How we built it
The app appears on the right side of the
new Jira Issue View
and uses the potential of the Jira Glance module. Thanks to Glance, it is easily accessible in almost every place where the new Issue View is displayed, including issue preview on queues, boards and Issue Navigator. Moreover, Context Issues works in Jira Mobile.
It is built on top of atlassian-connect-express. UI is built with the help of React and AtlasKit. The application is hosted on Heroku.
Challenges we ran into
The biggest challenge was the UI design. Depending on the Jira page, the width of a glance panel can be as small as 160px, which makes it hard to present all the data we would like to. Therefore the UI itself had to be very compact in order to leave as much space as possible for search results. It had to blend in the background and be almost invisible, but at the same time be intuitive enough to require no earlier introduction for new users.
Accomplishments that we are proud of
Many parts of Jira require a bit of tweaking before getting up and running, so it was a fun challenge for us to design an application that would require absolutely
no configuration
. We stepped into our users' shoes and created an app that works right out of the box.
What we learned
While designing the app, we decided to change some of the UI concepts. We have replaced filter names with basic buttons. We have learned that filter names can be cryptic or misleading, while buttons representing fields help you understand what you see.
It was the first time we have used a Glance module in our apps, and liked it straightaway.
What's next for Context Issues
We want to ensure it works smoothly in Jira Mobile.
We also want to make it smart. Using analytics, we want to predict what you are looking for, reducing clicks to the minimum. Basic buttons will change depending on what is available on the issue. The default selection of buttons that are pressed on when you visit an issue for the fist time will change based on context, like project type, issue type and your last activity.
We will continue to expand the number of fields supported in the basic search. In the future, we will add special purpose buttons and will allow users to create their own buttons.
We also want to synchronize switching between basic and JQL search modes, so it is easier to refine the basic search after you switch to JQL. Our dialect of JQL will also support placeholders, so you won’t need to type a value directly, but it will be substituted with the values taken from the current issue.
Built With
atlaskit
atlassian-connect-express
heroku
javascript
react
webpack
Try it out
context-issues.herokuapp.com | Context Issues | Take a glance at similar issues in just a few clicks. Stay focused, don't switch contexts. Display subtasks, stories in epic, tickets you are assigned to, and much more right on the Issue View. | ['Maciej Dudziak', 'Beata Szydłowska', 'Jarosław Morawski', 'Aleksandra Bosacka', 'Alan Leszczuk', 'Łukasz Szarecki'] | [] | ['atlaskit', 'atlassian-connect-express', 'heroku', 'javascript', 'react', 'webpack'] | 211 |
10,045 | https://devpost.com/software/the-scheduler-t9xnha | Inspiration
The main purpose of changes we introduced was provide easier manage automatically created tasks by The Scheduler for users.
We understand problem when some issues get lost in backlog among of hundred other tasks. We face up to users and allow them set initial issue status and put the tasks there where they want.
We realized that current user interface is not most clearly for users, so it was second thing which we introduce to easier managing and review recurring tasks.
What it does
The set initial issue status feature allows to set the status in Scheduled Issue in which Jira issue will be created. It allows to set tasks into correct columns in Kanban board eg. ‘Selected for Development’ on Scheduled Issues
New view using fewer elements and fewer requests - resulting in page speed up and better user experience. actions are grouped correctly.
Refresh the whole user interface is breaking change for current application users, so the intro guide has been added. The guide with step by step overview of the possible actions. It helps for existing users to transition to new UI, for new users it’s a great UX feature allowing to learn about app in few slides.
How we built it
The above changes we introduced to existing application, which is created using Atlassian Connect Spring Boot Framework. Most of done work has been implemented on the frontside, so the Atlaskit library was very helpful to build user interface similar to Atlassian's products.
Challenges we ran into
The hardest thing to do was, realize what the refreshed user interface should contain. It's not straight task, the perfect user interface should not overwhelm users, but still be easy to use and provide all required actions.
To rise the challenge, we tried to understand what parts of current application UI are the most important for the users and how the users use our product.
Accomplishments that we're proud of
We are happy that new features allow our users to reduce the burden of maintaining the backlog. They are also being able to manage recurring tasks faster, because of refurbished UI that we've introduced.
What we learned
The thing we learned is not exactly new programming knowledge, it was something more important. We learned to understand need users of application we are creating. This skill will allow us understand the application users and
provide them features dreamed of.
What's next for The Scheduler
In the next releases we plan to improve a bit new UI and focus on migrator between Jira Server and Cloud, which has high priority.
Built With
amazon-web-services
atlaskit
atlassian-connect-spring-boot
java
javascript
react
Try it out
marketplace.atlassian.com | The Scheduler | The Scheduler allows you to plan and automate your process – all you need to do is to create issue template, define when it should be created – and that’s all! | ['Kamil Klimek', 'Paula Zachacz', 'Łukasz Modzelewski', 'Michael Dubel'] | [] | ['amazon-web-services', 'atlaskit', 'atlassian-connect-spring-boot', 'java', 'javascript', 'react'] | 212 |
10,045 | https://devpost.com/software/buttons-for-confluence | Example use-case
Edit screen
Choose from list of button icons
Inspiration
Content formatting and management are increasing requirements within the Confluence space. There are lots of great options currently available on DC and Server in the Marketplace, whether it's a solution that offers a suite of functionality as a bundle or one that offer a single individual functionality (the former are typically more expensive). The availability of these solutions however are less abundant on Cloud, understandable as Confluence Cloud is still growing.
One of these is Button for Confluence, it allows the user to add styling to hyperlinks in Confluence by creating dedicated buttons or groups of dedicated buttons
What it does
The Button Hyperlink macros allows you to create AUI-styled buttons which provides hyperlinks to other pages or websites.
How I built it
We initially built a base Confluence Cloud App before building the macros on top. These in general took a few days due to its complex functionalities. We also followed the provided Atlassian documentation
https://developer.atlassian.com/cloud/confluence/getting-started/#step-4--create-a-basic-app
.
Challenges I ran into
Resolving the type of link provided by the user to something usable in Confluence was challenging because we support different use cases like external links, confluence links, files, and mailto.
What I learned
Better understanding of the Cloud infrastructure
What's next for Buttons for Confluence
Release the App into MPAC. Evaluate the performance and continue to deliver features/value to users
Built With
connect
Try it out
marketplace.atlassian.com | Buttons for Confluence | Add a touch of styling to hyperlinks in Confluence by creating a AUI styled dedicated buttons | ['christo-m', 'Andrea Rosati', 'Deborah Scott', 'Dylan Lindsay', 'Kankemwa Ishaku', 'Orah Apps Ltd'] | [] | ['connect'] | 213 |
10,045 | https://devpost.com/software/progress-bar-for-confluence | Example usecase
Edit screen
Inspiration
Content formatting and management are increasing requirements within the Confluence space. There are lots of great options currently available on DC and Server in the Marketplace, whether it's a solution that offers a suite of functionality as a bundle or one that offer a single individual functionality (the former are typically more expensive). The availability of these solutions however are less abundant on Cloud, understandable as Confluence Cloud is still growing.
We therefore wanted to create a solution on Cloud that allows users to manage their content better and improve engagement. One of these is Progress Bar for Confluence, it allows the user to document and visualise the stages of processes in Confluence.
What it does
Progress Bar for Confluence lets you provide visualisation and context for processes in Confluence. Making it easy for readers to see all the stages and view the associated content as a styled progress bar
How I built it
We initially built a base Confluence Cloud App before building the macros on top. These in general took a few days due to its complex functionalities. We also followed the provided Atlassian documentation
https://developer.atlassian.com/cloud/confluence/getting-started/#step-4--create-a-basic-app
.
Challenges I ran into
In general to develop a macro we faced the same issues. Each macro is self isolated in an iframe, so it is difficult to interact with the other macros and with the page itself:
https://en.wikipedia.org/wiki/HTML_element#Frames
In particular for Progress Bar the main challenge was to link and align all the different steps present in the page. Because they don't know each other (iframe problem), we had to use an event mechanism to make them work together.
What I learned
Better understanding of the Cloud infrastructure. Learned how iframes work and how to handle them.
New frameworks learned: Typescript, React, Redux, Webpack, Jest
What's next for Progress Bar for Confluence
Observing the performance in the MPAC to improve and provide more features/value to users
Built With
connect
Try it out
marketplace.atlassian.com | Progress Bar for Confluence | Provide context and visualisation for all the stages of a process using the Progress Bar macro | ['christo-m', 'Andrea Rosati', 'Deborah Scott', 'Dylan Lindsay', 'Kankemwa Ishaku', 'Orah Apps Ltd'] | [] | ['connect'] | 214 |
10,045 | https://devpost.com/software/tabs-for-confluence | Tabs usecase example
Macro screen
Edit screen
Inspiration
Content formatting and management are increasing requirements within the Confluence space. There are lots of great options currently available on DC and Server in the Marketplace, whether it's a solution that offers a suite of functionality as a bundle or one that offer a single individual functionality (the former are typically more expensive). The availability of these solutions however are less abundant on Cloud, understandable as Confluence Cloud is still growing.
We therefore wanted to create a solution on Cloud that allows users to manage their content better and improve engagement. One of these is Tabs for Confluence, it allows the user to structure and segment long congested content into tabs, making it easy for the reader to navigate and consume.
What it does
Tabs for Confluence lets you structure your page into styled tabs so the content is organised, easy to use, and easy to digest. The intuitive design also ensures users can get started and make edits quickly.
How I built it
We initially built a base Confluence Cloud App before building the macros on top. These in general took a few days due to its complex functionalities. We also followed the provided Atlassian documentation
https://developer.atlassian.com/cloud/confluence/getting-started/#step-4--create-a-basic-app
.
Challenges I ran into
In general to develop a macro we faced the same issues. Each macro is self isolated in an iframe, so it is difficult to interact with the other macros and with the page itself:
https://en.wikipedia.org/wiki/HTML_element#Frames
Moreover Tabs is a rich-text macro. This means that Tabs is also responsible to render the nested macros.
What I learned
Better understanding of the Cloud infrastructure, iframes and how to handle them.
New frameworks learned: Typescript, React, Redux, Webpack, Jest
What's next
Evaluate the perfomance on MPAC to provide continued value and benefits to customers.
Built With
connect
Try it out
marketplace.atlassian.com | Tabs for Confluence | Make content easy to navigate and consume in Confluence by using Tabs to manage and structure your pages | ['christo-m', 'Andrea Rosati', 'Deborah Scott', 'Dylan Lindsay', 'Kankemwa Ishaku', 'Orah Apps Ltd'] | [] | ['connect'] | 215 |
10,045 | https://devpost.com/software/extractext-for-confluence-cloud-5s7fyj | Macro to search and select images
Image editor
Search images
Dedicated type for searching images
Inspiration
Images contain so much valuable data. But once an image is added into a system, it becomes a blackbox as it is not possible to what was in the image. OCR technology has been around for a while, so the idea was to bring it to life for Attachments for Confluence cloud. We have developed proprietary algorithms to make all the text to be extracted as traditional tools were only fetching dark text in consistent light backgrounds.
What it does
ExtracText for Confluence Cloud extracts all text from images and adds it to confluence search index making it available for searching. It also provides an advanced image editor which helps adding annotations to your images and all data is now contained within the image and available through search. A dedicated ExtracText Image search page allows to search and shows the images in thumbnails to identify them easily. There is also a macro that lets you search and add an existing image using text into any pages.
How I built it
We had the backend OCR technology built using Java for a while which we are using in "ExtracText for Confluence" server version. Now we are using the same technology in the backend and using Atlassian Connect framework for the front end. All apps are hosted in Google cloud Platform and highly available and scalable architecture with monitoring and production ready systems.
Challenges I ran into
Understanding how AtlassinConnectFramework works was the biggest challenge. There are very limited number of resources online and lot of trail and error before we get it right.
Accomplishments that I'm proud of
We set a target to finish it for this competition and we achieved it on time and of a high quality production release. The knowledge we gained will go a long way - Express framework, node, Java, HTML5, javascript, CICD automation , agile delivery, automation all the way, wearing so many hats- customer, product owner, developer, QA, operations, configuration management, build system etc etc!!! so many things!!! proud!!!
What I learned
Pay attention to little details. If not we will end up wasting lots of time on minor issues.
What's next for ExtracText for Confluence Cloud
Our mission is to solve unsolved useful problems and we are going to make this app the best image editing, creating tool available in the market with features no others have
Instructions for testing
Have provided our production link. The app is pending submission. Please use a trial version to test it out or let us know if you need a token generated.
Built With
appengine
atlassianconnectexpress
css3
google-cloud
html5
java
javascript
node.js
postgresql
pubsub
Try it out
efcc-prod-282705.uc.r.appspot.com | ExtracText OCR for Confluence Cloud | Images contain so much valuable data. But once an image is added into a system, it becomes a blackbox as it is not possible to know what is in the image. Not anymore! all text in images are searchable | ['Narendran Bhojan'] | [] | ['appengine', 'atlassianconnectexpress', 'css3', 'google-cloud', 'html5', 'java', 'javascript', 'node.js', 'postgresql', 'pubsub'] | 216 |
10,045 | https://devpost.com/software/issue-matrix-cloud | IssueMatrix_Cloud_Adding_Matrix_1
IssueMatrix_Cloud_Adding_Matrix_2
IssueMatrix_Cloud_Adding_Matrix_3
IssueMatrix_Cloud_Board_1
IssueMatrix_Cloud_Highlight_1
IssueMatrix_Cloud_Highlight_2
IssueMatrix_Cloud_Highlight_3
IssueMatrix_Cloud_Panel_1
IssueMatrix_Cloud_Panel-2
What inspired us
While Jira Software remains the most powerful platform for managing agile projects, its robustness poses a level of complexity, which in certain cases is challenging to handle by Jira users.
As an agile organization, we use Jira Software and Jira Cloud daily. This has inspired us to build a flexible and powerful solution with an immediate effect on our work.
Issue Matrix Cloud was born out of the aspiration to visualize Jira Cloud view screens in a more effective, faster, and user-friendly way and make the work-life of Agile teams and business users of Jira Cloud much easier and highly productive.
The app gives you better visibility into additional information and fields about each sub-task, linked issue, or Issues in Epics without opening them individually, thus saving hundreds of hours. You can also track the progress of all completed, currently running, or to-do issues in the matrix.
Use Cases
Issue Matrix Cloud provides indispensable help to business users and Аgile teams in leveraging Jira Cloud visualization and resolving several of its usability and productivity limitations when working with sub-tasks and linked issues.
1. Business users
While Jira Cloud’s current interfaces fit the processes of technical teams, it is still a struggle for business users to realize Jira’s potential fully.
Built as a highly customizable app, Issue Matrix Cloud helps in overcoming these drawbacks by enhancing how sub-tasks, linked Issues, and issues in epics get visualized in the Issue View Screen.
What business users benefit from Issue Matrix Cloud:
Better visibility into sub-tasks & linked issues
Issue Matrix offers several different matrix types you can create and configure to fit the needs of your team. This feature significantly improves the way users interact with Jira and saves organizations countless hours and unnecessary click-throughs, resulting in the increased overall productivity of teams.
Content features for better flexibility & information display
Issue Matrix has a set of essential options related to the content of the Issue Matrix table. After you choose the Issue Matrix mode, you can configure a subset of settings (types, context, columns) and apply them to the selected mode.
2. Agile teams
Agile-centric technologies are designed to adapt to and optimize the work of teams by enabling them to quickly and easily access actionable information.
This was one of the defining principles behind the Issue Matrix Cloud app development - to enrich the existing capabilities of Jira Cloud so Agile teams can access and work with actionable data, without the need to navigate through multiple UI pages and waste valuable time.
What Аgile teams benefit from Issue Matrix Cloud:
Improve your Scrum & Kanban boards
The Issue Matrix table content can be configured for Agile boards as well and significantly improves how users interact with the tasks on their Scrum and Kanban boards.
High customization and increased usability, structure & content display
The app offers three highly customizable modes - Sub-task, Issue Link, and Epic. They enable users to define the types of issues and information that will be shown in the Issue View screen.
How we built it
Issue Matrix Cloud is designed as a serverless Web app, written entirely in TypeScript with React.js and using AtlasKit. The App has no server-side back-end code. For the User Interface, we used React functional components mixed with components from AtlasKit. These components rely on React hooks to encapsulate our business logic and delegate the remote requests to Jira Cloud REST API, leveraging Jira Cloud JavaScript API. App data is persisted in Jira Project Entity Properties. The web resources are hosted on AWS S3 and distributed via AWS CloudFront.
Jira Project Administrators configure Issue Matrices on a project level and based on these configurations the end-users see enriched data in the issue view.
The challenges we faced
Because Issue Matrix Cloud is a serverless app, a lot of the business logic that we'd usually put in the back-end
had to be done in the front-end
Working inside an iframe introduces technical problems that are not present otherwise
An extra effort had to be put to provide rich enough user experience due to gaps in JavaScript and REST APIs of Jira Cloud
What we learned
Issue Matrix Cloud has been a significant milestone, as it is our company's first Jira Cloud App. We learned what it is like to build a Cloud App from scratch. We experimented with a lot of technologies that we don't use in our other Jira apps, and now we're going to use this knowledge as a basis for new cloud apps and improvements in our existing ones.
Built With
amazon-cloudfront-cdn
amazon-web-services
atlaskit
atlassian-connect
javascript
react
rest
typescript
typescript-language
Try it out
marketplace.atlassian.com | Issue Matrix Cloud | Issue Matrix Cloud is the ideal fit for Agile teams and business users of Jira Cloud. It saves thousands of hours per team by transforming the visualization of sub-tasks and linked issues. | ['Efrosina Hristova', 'Yuri Diamandiev', 'Botron Software', 'Petar Petrov', 'Petar Geshev', 'Peter Toudjarski'] | [] | ['amazon-cloudfront-cdn', 'amazon-web-services', 'atlaskit', 'atlassian-connect', 'javascript', 'react', 'rest', 'typescript', 'typescript-language'] | 217 |
10,045 | https://devpost.com/software/asset-tracker-for-cloud-at4c | Advanced Search
Assets linking
Linking to Jira issue(s)
Bulk update
Import / export
Fields configuration
App access configuration
Assets access configuration
Inspiration
We (Spartez Software) have a Server app for assets tracking: Asset Tracker for Jira-Asset Management. We have more than 400 customers that use the tool and “when will it be available for Cloud?” is one of the very frequent questions we get.
Few engineers decided to start the development of the Cloud version of Asset Tracker as their 20% time. A great chance to experiment with new technologies, re-consider features need and usability, and develop something from scratch.
And when Codegeist was announced we asked ourselves - why not push now and make the app available for the customers?
What it does
It helps with assets management directly from Jira. Asset Tracker for Cloud (AT4C is how we call it internally) comes with a preset of different asset types - computers, printers, TVs, etc. And then a journey begins - the user can:
Manage asset types
Create assets
Customize fields per asset
Group assets into folders
Search for assets
Customize assets list view
Print asset labels
Link assets between themselves
Link assets to Jira issues
View assets from Jira issues directly
View History of asset modifications
Import / export assets through .csv file
Configure permissions - who can view/edit assets (global and per-folder configuration is available)
How we built it
App is run from Google Cloud:
Cloud Run - auto-scalable back-end based on Docker containers
Cloud Tasks - to execute long-running & async tasks, e.g. as import/export operations and synchronization with Jira
Cloud Storage - storing files required for import & export
Data resides in FaunaDB database, some highlights:
Powerful query language enabled us to move almost all back-end logic to database
Support for temporal queries made it easy to handle assets history
Attribute-based access control allowed to create security rules that work on database level
Built-in multi-tenancy guarantees data security
Back-end / REST API - TypeScript - mostly to validate incoming data and perform DB queries.
Front-end:
Single-page app based on VueJS
Re-used front-end of Asset Tracker for Server in 99%
We created and maintain unofficial UI library, built according to the Atlassian Design Guidelines:
https://github.com/spartez/vue-atlaskit
Challenges we ran into
Creating/updating a large number of assets at the same time;
Ensuring that Asset Platform data is consistent with the Asset Tracker database;
Multi-tenancy:
Making sure that the activity of one customer won’t affect app performance of other customers
Security - isolating customers data properly
Accomplishments that we're proud of
UI shared between Cloud and Server versions of Asset Tracker
Cloud version with tens of thousands of assets has better performance than Server version
What we learned
Creating an app is a no brainer :), giving it into customers hands is difficult: answering “are we ready?” question from feature-wise and operational readiness perspectives.
Data consistency in distributed systems is HARD (well we knew that before, but this was a good reminder ).
FaunaDB & FQL - slightly different approach to database systems than other well-known solutions like Firebase or MongoDB
What's next for Asset Tracker for Cloud (AT4C)
We want to have all features that are used by at least 10% users of the Server version of Asset Tracker in Cloud.
A short-term plan includes:
Full-text search speed improvements
Possibility to save / share search filters
Adding a unique identifier for every asset
Validation of field types
Improvements to CSV import/export (validation, error handling)
Built With
faunadb
google-cloud
javascript
typescript
vue.js
Try it out
ac.asset-tracker.spartez-software.com | Asset Tracker for Cloud (AT4C) | Asset Tracker for Cloud allows asset tracker management right from your Jira project - browse, check-in or check-out shared assets, devices, and tools. | ['Michał Nykiel', 'Vasilii Kizhaev', 'Viktor Shmoilov', 'Agnieszka Jóźwiak', 'Roman Lutsiv', 'Adrian Bilicz'] | [] | ['faunadb', 'google-cloud', 'javascript', 'typescript', 'vue.js'] | 218 |
10,045 | https://devpost.com/software/team-files-office-365-google-docs | Inspiration
Wouldn't it be amazing if we could have our important documents stored in our cloud (Sharepoint, Google Drive, Dropbox, etc.) linked directly to Jira issues or Jira Service Desk tickets? What if we could also edit these documents without leaving the Atlassian Products (Confluence, Jira, JSD) while maintaining one single source of truth? That is all possible with Team Files. Team Files allows you to embed your cloud documents in a Jira issue or Confluence page with your team, removing the headache of having multiple versions of the same document across the instance.
What it does
In the App Week at Scottsdale we had a meeting with some people Atlassian on how we could use Team Files to leverage the flexibility of Jira Service Desk itself, regarding documents sharing. It would be amazing if we could get your documents for edit/preview in the Jira Service Desk ticket so your customers can consult or edit them.
Thus, for this Codegeist added the support for Jira Service Desk projects to Team Files. This new capability allows you to embed that document you would like your customer to read, as well as to share any form you would like him to fill, without worrying about downloading and saving the file in the right place after the process is done. This, again, will maintain a single source of truth.
Accomplishments that we are proud of
We are really happy with this integration because we believe this is an important step to leverage any team productivity. Because we maintaing the single source of truth, teams only need to embed documents and relax.
What's next for Team Files: Office 365 & Google Docs
Our next steps are to integrate Team Files with the JSD knowledge base. It would be awesome if we could list documents embed via Team Files in the knowledge base results. That would make Team Files and Service Desk to work even more as a whole.
Built With
atlassian-connect-express
node.js
react
Try it out
marketplace.atlassian.com | Team Files: Office 365 & Google Docs | Keep your team and customers on the same page by linking important files from your cloud to Jira issues and Jira Service Desk tickets | ['Miguel Jesus', 'Luís Gomes'] | [] | ['atlassian-connect-express', 'node.js', 'react'] | 219 |
10,045 | https://devpost.com/software/dynamic-fields-for-jira | Dynamic Fields for Jira app listing
Create dynamic fields by using pre-defined templates or custom Jira expressions
Show custom fields as columns in Jira issue search or reporting
Show dynamic custom fields in the Jira issue view
Inspiration
We often hear from customers with very unique use cases that they'd like to customize Jira fields in a very specific way, using their existing data. With current apps in the Jira ecosystem, there are a lot of custom fields already available - however, they always fit a very specific use case and cannot be adjusted easily. We'd like to enable our customers to use truly dynamic custom fields that can be fine-tuned according to their very specific needs, and kept in sync when issue data changes automatically.
What it does
Dynamic Fields for Jira provides the capability to add truly dynamic fields to Jira, using "Jira expressions" to compute their values whenever an issue is created or changed. Dynamic fields can be viewed in issue search, reporting or the issue view and can also be used to filter results based on ranges or values using JQL.
How I built it
I utilized Atlassian Connect and our proven infrastructure for our Atlassian apps. Also, the feedback from my colleagues at codefortynine was invaluable as we tweaked the app until it was worthy to be submitted to the Atlassian Marketplace.
Challenges I ran into
Jira expressions are very flexible, but also have some limitations that our updating algorithm needs to work around. For example, it would take very long if we'd evaluate each expression for every single issue, but may also be too complex to update many issues at once. Finding the right balance between complexity and efficiency was no easy task and I'm sure we can make more improvements as we gain experience with customers using our app.
Accomplishments that I'm proud of
Developing the initial version of Dynamic Fields for Jira within 4 weeks, while also organizing our move into a new office, was definitely a challenge.
What I learned
I learned a lot about Jira expressions, its amazing capabilities but also about its current limitations. Also it is truly inspiring how custom fields can be used for a wide variety of use cases within Jira.
What's next for Dynamic Fields for Jira
I'm sure we can add a lot of templates and more capabilities once our first customers start using Dynamic Fields for Jira.
Built With
connect
java
jira
vuejs | Dynamic Fields for Jira | Computed custom fields for Jira, searchable and usable in statistics, reporting and JQL. Choose from over 50 templates for new custom fields, or use your own custom expressions! | ['Ben Romberg'] | [] | ['connect', 'java', 'jira', 'vuejs'] | 220 |
10,045 | https://devpost.com/software/jira-cloud-dashboard-export | Jira Cloud gadgets exported to PDF
Find the "Export dashboard to PDF" option under the ... menu in the upper-right corner of your dashboard screen
One-column, portrait-oriented export of a progress tracking dashboard, featuring the Created vs. Resolved, the Time Since Chart, and others.
Agile sprint report. The report helps to understand the status and bottlenecks of agile teams' on-going sprint in a single PDF document.
This company-branded document is combining hand-written content with the visually simplified look of the Average Age Chart, and others.
This A3 landscape example demonstrates custom layouts: on top of the report, four charts give a visual explanation of the project progress.
A three-column project status report, featuring the agile board as well.
A version of a project status report, but this layout give more emphazis on the agile board.
If your Jira language is not English, the exported gadgets will reflect that as well automatically.
Inspiration
Our team at Midori has been developing apps for Atlassian products for more than 15 years.
The Jira Server version of our very first app,
Better PDF Exporter
, has been released for the public in 2009 (long before Atlassian Marketplace even existed!).
Over the past 11 years, the app proved that it's more than just "yet another" PDF exporter.
Teams of all sizes and from all industries are using it to solve various use cases:
custom reporting
generating documents of various types
archiving Jira issues
and sharing Jira data securely with third-parties
Some teams use it to create documents for agile meetings, like sprint plannings, daily standups, or retros.
Others are creating ready-to-use invoices or timesheets from Jira data with a click (also using third-party data like Tempo Timesheets).
Tech-savvy customers are building
archiving solutions
with it (often with the help of a Solution Partner).
They do all these using PDF, the standard business document format.
👉 Check out the
Template Gallery
for PDF samples
Now also for Jira Cloud!
One of the most popular app features has been
exporting Jira dashboards to PDF files
.
To date, Better PDF Exporter is the
only
solution for the Jira platform that allows exporting and sharing dashboards, reports, and agile boards with external people.
When we released the initial version of Better PDF Exporter for Jira Cloud, it was immediately made clear by the end-users that they want this feature also on the cloud.
We understand that more and more Jira users are moving to the cloud, so we made this feature request the #1 priority in the product roadmap.
It was a huge challenge due to the cloud being a "dramastically" different technology environment, but our team solved it.
We are super-proud to announce that the biggest new feature and improvement to Better PDF Exporter Cloud has been shipped today!
You can export Jira Cloud dashboards to professional and customizable PDF documents now.
How we built it
The new feature required fairly small changes in the existing user interface, although we had to evaluate multiple variants of the user interaction.
Ultimately, we implemented the one that is super-intuitive and that cannot be simplified further.
It was a lot more complicated in the back-end side.
(Our app is running on AWS, the cloud platform developed by Amazon.)
Being in the cloud, scalability has been key.
Therefore, we implemented a special AWS API Gateway resource that triggers a sequence of AWS Lambda functions.
They provide scalability by parallelization and by building up the final PDF document from smaller fragments (think Lego bricks!).
Due to the cloud, security has been key, as well.
As we store confidential information, we rely on the cryptography features provided by AWS, then store the encrypted data in a DynamoDB database operated by the AWS team.
Challenges we ran into
Initially, we had to realize that the support for the dashboard entity is extremely limited both in the Jira Cloud REST API and in Atlassian Connect.
These are the two pillars you build Jira Cloud apps on top of.
They were clearly insufficient for the use case we wanted to solve.
The other aspect of the problem is that you can't solve it purely on the server-side, the gadgets being AJAXy and Javascript-heavy, and you can't solve it purely in the client-side (browser), either, due to the massive use of iframe's and due to various XSS problems.
At a point, it really felt like "mission impossible".
To overcome various limitations, we tried every sort of creative solutions both in the browser and in the server-side, validated by continuous experiments.
Accomplishments that we're proud of
We managed to solve the problem in a way that supports
every
gadget types!
We provide so-called "full support" for the most frequently used gadgets and a fall back option of screenshot-based exports for the less frequently used ones.
(Our approach makes it possible to give "full support" for any gadget any time in the future.)
We worked a lot on hiding the technical complexity from the end-user: the feature is simple to use and it
just works
.
As they say, solving simple problems in simple ways is great, solving complex problems in complex ways is excellent, but solving complex problems in simple ways is what makes a genius (sorry 🙂).
What we learned
We learned that Amazon AWS is a great platform to build world-scale systems and that it is a good choice to build Atlassian apps, as well.
Since launching the first version of the Better PDF Exporter app, it operated with 99.999999% uptime.
We are confident that it will not degrade after introducing this new feature, either.
We also learned that creativity and brain-storming help to solve problems that look impossible for the first sight, and that it is always worth to run the extra miles for the ultimate user experience.
What's next for Jira Cloud dashboard export
In the short run, we will introduce a new "quota" concept which will allow running an export for a longer duration in case of massive data, still protecting the system resources.
(After dashboards, it is the #2 most requested change.)
In the midterm, the app will:
implement PDF automation (exporting files
periodically or at certain events
)
integrate with even more popular Jira Cloud apps
support PDF/A documents for archiving use cases
generate password-protected documents
In the long run, we will introduce support for new export file formats (e.g.
Excel
).
As always, we are keen to learn what the user community would need!
Thanks for reading!
Built With
amazon-web-services
atlassian-connect
java
javascript
node.js
python
spring-boot
Try it out
marketplace.atlassian.com | Jira Cloud dashboard export | Export your Jira Cloud dashboards to PDF! Create customizable PDF reports from your dashboards and share your reports with those without Jira access. | ['Levente Szabo [Midori]', 'Aron Gombas', 'Gabor Nagy', 'Gergely Juhasz [Midori]', 'Ferenc Nagy [Midori]'] | [] | ['amazon-web-services', 'atlassian-connect', 'java', 'javascript', 'node.js', 'python', 'spring-boot'] | 221 |
10,045 | https://devpost.com/software/foxly-backlog-priority-scoring | Inspiration
From my own experience, backlog prioritization and grooming can be a real can of worms. Dealing with different stakeholders, ensuring everyone's opinion is heard, bringing in customer feedback, figuring out how to introduce your customer data to make more data-driven decisions and many many more.
You might want to use some of the prioritization frameworks that are out there like ICE, RICE, WSJF or Value vs Effort and Priority Matrix.
These frameworks help you bring the system into your prioritization and help you look at the issue from different angles.
The idea is simple. You have a few metrics that you fill and these are then used to calculate the priority score. The challenge is with having to manage the metric values and the priority scoring in spreadsheets.
If you use Jira to manage work then you’d want to attach your prioritization attributes to your existing issues so you don’t have an overhead by managing backlog in multiple tools.
What it does
Because spreadsheets get lost and what is not in Jira doesn't count for many of us 😁 we created the Jira prioritization plugin that:
gives you the freedom to choose the prioritization framework you want (ICE, RICE, WSJF, Value vs Effort)
allows you to customize and create a new prioritization template with your own metrics and scoring formula
has an interactive priority table where you can assign values for the metrics and score is calculated real-time
creates Priority Matrix where you can faster spot quick wins
has plenty of filters to help you get view you need
shows score in issue detail and you can also adjust metrics from there
Foxly is making the prioritization process in Jira more systematic but fast.
How I built it
We built the app using our own Boilerplate for ACE:
https://jexo.io/jira-confluence-app-boilerplate
similar to our existing apps. The difference was that we wanted to use Jira APIs more and not have a mirror of the Jira issues and projects in our own data models and not have to keep this in sync using webhooks. So we decided to use entity properties to associate scoring values with issues and only store templates information in our database.
Challenges I ran into
Working with Entity Properties is not as straight forward as first assessed, you cannot create complex query-able objects, if you need to be able to JQL by custom property you need simple, flat data.
Had to consider workarounds for updating Issue At-Glance tab dynamic data (changeable scoring number). Changing the scoring formula would mean bulk updating entity properties for all the issues using that formula.
For the central piece, the table view, Atlaskit Dynamic Table component was not a fit because 2 main limitations: 1. You can’t use inline edit component inside table cells; 2. You can’t add a footer with total values of rows in view.
Accomplishments that I'm proud of
Clearly structured the data patterns so that there’s no confusion what data is owned by the app database vs Jira.
What I learned
To work with features that haven’t used before like the entity properties and issue at-glance dynamic lozenge data
What's next for Foxly - Backlog Priority Scoring
We just published the app on the Marketplace and we’re planning to improve based on customers feedback.
One of the upcoming improvements is going to be using priority score to change the issue rank so users can quicker organize their backlog.
We’re also going to make Priority score available for JQL so users can filter the issues by this field but also show the priority score on their kanban tiles.
Built With
amazon-web-services
atlaskit
atlassian-connect
graphql
jexo-ace-boilerplate
react
Try it out
foxly.jexo.rocks | Foxly - Backlog Priority Scoring | Project Management tool for Prioritizing Jira backlog using scoring models and Priority matrix - WSJF (SAFe), RICE, ICE or custom | ['Biro Florin'] | [] | ['amazon-web-services', 'atlaskit', 'atlassian-connect', 'graphql', 'jexo-ace-boilerplate', 'react'] | 222 |
10,045 | https://devpost.com/software/chat-for-jira-service-desk-cloud | Chat icon on customer portal to initiate chat
Customer chat window to exchange messages with agent
Agent active chat view to send and receive messages and attchments to customer
Create a request(issue) on behalf of customer for further followup with customer
Review old chats, see messages inline and create a request for followup if needed
Transfer chat to other agents to provide seamless support to customers
Customer portal settings to enable/disable chat. Customize icons, colors, custom messages, website widget code
Website chat widget to support customers from your website
Inspiration
Live chat is an essential part of any servicedesk environment and it helps in having better customer satisfaction. But currently JIRA servicedesk doesn't have native live chat for customers to get their queries resolved in real time. Instead of having to wait for a reply on a ticket which can be frustrating at times.
What it does
It allows customers and agents to chat with each other in real time. Customers can initiate chat by simply clicking on the chat widget available on the customer portal. Agent and customer can exchange messages as well as any file - attachments as part of the chat conversation.
Agents can transfer chat to other agents in case of any assistance required.
Agents can create a request(issue) on behalf of a customer from chat for further followup if needed.
Chat for JSD also offers the ability to embed chat widget on external websites so that customers/prospects can chat with your agents from your website.
localization support is available for french and portugese
Servicedesk project admin can customize the look and feel of chat widget available on the portal. They can set custom welcome messages, offline messages and control colors.
How I built it
What started as curious proof of concept just before codegeist was announced, led me this far to making this submission. I just wanted to understand if a live chat can be implemented at all on cloud or not. After lots of trial and error I could get it working and the basic version was submitted to the marketplace for approval. I was lucky to get some early adopters even before marketplace approval to try it out and share their feedback. They made me realize that chatting was just a small part of the whole solution. People want it to be configurable and customizable with many more features. Most of the features which you see in the app has been mostly suggested by people who tried using it.
Challenges I ran into
Biggest challenge I encountered was putting the chat widget on the customer portal. There are limited UI locations available on the customer portal for apps to extend. After a lot of searching and discussion on forums, footer element was the only viable location.
Showing the user's name without storing it to avoid getting into gdpr compliance was another challenge.
Getting the publisher subscriber model to work for messaging was another challenge
Getting to right documentations and support on any queries
Accomplishments that I'm proud of
Learning nodejs from scratch.
Getting the messaging bit to work.
Embed chat widget on customer portal and website.
What I learned
I learned a lot as I started almost from ground zero, before this I had just developed a small connect app that was in springboot long time back.For this app I decided to learn nodejs so I had to learn nodejs, express and allied technologies to put this together. I also got some deep dive into various JIRA & Servicedesk APIs which I had never used before. Overall it was satisfying experience.
What's next for Chat for JIRA Service Desk Cloud
There are many ideas I have, I would like to develop this app to be much beyond being just a chat app but to be a more powerful part of the whole workflow. I would eventually like it to be as powerful as any other live chat apps available outside Atassian ecosystems. I have listed some pointers below, some have been tried to an extent and some other are just thoughts
Integrate Knowledge Base - I did try this using servicedesk’s experimental knowledge base API which is available but was not entirely happy with results so it's disabled for now.
Anonymous portal support - Somehow I was under the impression that JSD doesn't allow anonymous access
Ability to send notifications to agents even when he's not on the chat support page. This is currently not possible and needs changes in framework from Atlassian. Ecosystem ticket is already open with them.
Once above is possible agent can set themselves as online & offline, schedule can also be set for the agent
Feedback at end of chat
Canned response
FAQ bot to answer standard questions
Chatbot for better conversational support
Automated actions from chat
Built With
atlaskit
bootstrap
javascript
jquery
mongodb
mongoose
node.js
Try it out
marketplace.atlassian.com | Chat for JIRA Service Desk Cloud | Live chat is an essential part of any servicedesk, currently there's no option available to let customers chat with agents. Chat for JSD enables customers to have realtime communication with agents. | ['Vishwajeet Singh'] | [] | ['atlaskit', 'bootstrap', 'javascript', 'jquery', 'mongodb', 'mongoose', 'node.js'] | 223 |
10,045 | https://devpost.com/software/brainstorm-boards-for-jira | Handwritten notes from your whiteboard and wall
And it doesn't need to be notes!
A place to organise
Live Jira overlayed on your brainstorm
What it does
Brainstorm boards for Jira gives you a space to create whatever you want. Upload photos of your workshop wall, sticky notes, notes from your whiteboard and you can add them to Jira without the typing.
But there is more, by overlaying live Jira data that workshop never becomes stale. You can see whats happening - status & assignee.
Any diagram can be used to tract execution, coming to life with the power of Jira
How I built it
We've trained some machine learning models to recognise stick notes lists and paragraphs of text and transcribe them. We then do some image processing to extract colour and position.
We built an online canvas that we can add these items to and use Jira apis to allow users to interact with the diagrams to make Jira stuff happen
Challenges I ran into
Time! What I'd give for two more weeks :-) The biggest challenge was getting the canvas to be stable enough in the short timeframe. We had hoped to make it more fully-featured, but we believe it is good enough to solve the problem for the users.
What's next for Brainstorm boards for Jira
First off, we need to get it ready for prime time. There are a few hardening activities and a lot of testing to be done before we can add it to the marketplace.
Soon we'd like to strengthen the team features, having multiple people editing the canvas and seeing what is going on with everyone would be both cool and useful.
Integration into video conferencing would be cool too to support the 'new normal' ways of working
Built With
connect
javascript
jira
ml | Brainstorm boards for Jira | Maintain your momentum! Move handwritten items from the workshop wall to Jira at the click of a button. A brainstorming canvas to express yourself all linked with live Jira issues | ['Geoff Bullen'] | [] | ['connect', 'javascript', 'jira', 'ml'] | 224 |
10,045 | https://devpost.com/software/scan-read-text | Inspiration
Cancel
What it does
Cancel
How I built it
Cancel
Challenges I ran into
Cancel
Accomplishments that I'm proud of
Cancel
What I learned
Cancel
What's next for Scan Read Text
Cancel
Built With
confluence
final-cut-pro | Scan Read Text | Next level of enhancement for reading emails. Functionality that makes it easier to read emails for mobile device users. | [] | [] | ['confluence', 'final-cut-pro'] | 225 |
10,045 | https://devpost.com/software/curate-slack-posts-for-confluence | Search Slack posts and drag-and-drop them in favorable order
GIF
Search Slack posts, drag-n-drop them, insert texts to add a context, and leave a comment!
Put together Slack posts on the Confluence page
Inspiration
We found that there was a Confluence page created with a collection of Slack post screenshots. We found it useful to have an app that could create such pages without taking screenshots and pasting them one by one, which is why we decided to make this app.
What it does
With this app, you can:
Display any post on any public channel in Slack in any order on the Confluence page. Intuitive arrangement by drag and drop
Insert headings and descriptions above and below posts to keep things organized
Add comments to each post as a Confluence user
This app gives you the following values
Source of the idea
: Start discussions and develop into projects based on Slack posts displayed together
Visibility
: In Slack, only channel participants see the content of posts, but Confluence makes it more visible to more people
Give context to chat
: Slack is a chat tool, so it's easy to overwhelm large and small topics and fill them up. By consolidating posts and giving context and consolidating them in Confluence, it becomes a resource that can be used in the long term
How we built it
We developed this app on Heroku. Since it is necessary to refer to the information in Slack, this app was also registered as a Slack app
We built UI/UX with powerful and productive components (AtlasKit, react-beautiful-dnd) from Atlassian
Challenges we ran into
There were two versions of Slack's OAuth 2.0 authentication, and I had a hard time understanding
Integration of express environment and ReactJS environment
Accomplishments that we're proud of
With the help of react-beautiful-dnd, we were able to create an intuitive UI/UX
What we learned
How to use Slack API
The pros and cons of Forge. We learned them because we first tried implementing Forge
A method to build a prototype in a short period to maximize the appeal of a product
What's next for Slack Pinboard for Confluence
Enhanced search function
Enhanced editing functions
Allows you to incorporate more expressions on Slack such as reactions and images
Built With
atlaskit
heroku
javascript
react
react-beautiful-dnd | Slack Pinboard for Confluence | Don’t let your best ideas get lost in Slack. Bring them into your wiki with Slack Pinboard for Confluence. Now you can easily drag-and-drop comments onto your page, format text, and add more comments! | ['Kenichi Abe', 'Sean Osawa', 'Natsumi Sahashi'] | [] | ['atlaskit', 'heroku', 'javascript', 'react', 'react-beautiful-dnd'] | 226 |
10,045 | https://devpost.com/software/team-reports | Team status settings - Standup list and toggle to show/hide the web item in the project sidebar
Team status settings - Edit a standup, setup questions and participants
Team status - List of standups for the current user
Standup summary - The participants' status for the selected standup
Status form - The place where the participants share the status with the team
Status history - The place to see past status (Calendar closed)
Status history - The place to see past status (Calendar open)
Team status hub - See the status of the people who you share a standup with
Team status hub - See the general state of your status across standups
Inspiration
At Regos Dev Studio, like many other teams in the world, we work on multiple projects at the same time. Sometimes the people work on or leads more than one project simultaneously and, with the time, the standup meetings become a pain and a lot of time is spent to attend the calls.
In addition to that initial problem we identified a few more:
It was not easy to see what other persons who I work within a team are doing on other teams
For some people it's easy for forget the issues they were or are working on while giving a status
By default there is no a record of the status history for a team, if needed, someone will take notes to track that history
In an internal effort to solve this situation, we decided to implement something to keep all the teams in sync, reduce the meetings count, and integrate our status with Jira by default.
What it does
Helps the teams to run async standups in Jira. The main features provided by the add-on are:
Allows the Jira users to run async standups integrated with Jira Cloud.
Ability to create multiple standups with dynamic questions and notifications on a project basis to support multi-teams projects.
If desired, the add-on can be disabled for specific projects.
Jira issue suggestions are provided to the team members while submitting the status.
Provides a section to see a cross-team status of the people who you share standups with.
Auto generates a status for those team members who haven't sent the status at a certain point in time.
How I built it
We have some experience building apps for Jira and Confluence using Node.js, ACE, and React. With the time we have developed a good code base so that we decided to use it for this project.
The work started on the UX side by building freehands and prototypes in Invision, then we went through internal usability tests to make sure we cover our internal needs (in the end this is where everything started).
Once we felt we were ready to start building the app... well the team started to code it. We decided to use Atlaskit to reuse the components that Atlassian already wrote for us and, after a couple of weeks, we had an MVP to start using it in our teams.
Honestly, the result was great and we started to see good results by implementing async standups for our teams. A side effect of starting using the add-on in an early stage was that we collected feedback as we were building it!
Finally, we did put attention to permissions and performance tuning in a way that we even created our first open-source package, but we'll talk more about that in the next sections.
Challenges I ran into
One of the challenges (and advantages at the same time) was to update the requirements based on the team's feedback and keep building the app at the same time.
Also, as we mentioned before, for some parts of the app did some performance tuning so that we ran some tests using different configurations and environments. At the same time, we were working on the open-source package needed to support the changes we wanted to implement for performance improvements.
Accomplishments that I'm proud of
We are very happy about:
Our team using a great tool and reduce the meetings count
Having a production-ready app to publish after the hackathon :D
We are already using our first
open source repository
We make a great improvement in our technology and codebase thanks to this app. We are excited to start sharing our technology with the community in the near future!
What I learned
The main lesson after this event is that the quality of a product improves drastically when you and your team use it on a daily basis. Some times we are focused on building solutions for others, but it's great when you build solutions to solves problems you are already facing.
What's next for Regos Team status for Jira Cloud
A lot of things!
The first one is to make it public. We are excited to publish the add-on and see how other teams start using it and improving their work.
Also, we'd like to improve the Jira issues suggestions in the status form and enhance the auto-status generation feature for the users who haven't sent the status. With time and more data, we are planning to improve the reports to provide powerful insights for project leads.
Finally, we are thinking about future integrations with Slack and other messaging platforms to improve the notification system and the status submission.
Built With
atlaskit
heroku
node.js
react
redis
Try it out
regoscodegeist2020.atlassian.net | Regos Team Status for Jira Cloud | Power up your team communication, increase visibility and reduce the number of meetings by having async standups and status history report directly inside Jira | ['Regos Dev Studio'] | [] | ['atlaskit', 'heroku', 'node.js', 'react', 'redis'] | 227 |
10,045 | https://devpost.com/software/regos-jira-toolkit | Regos Jira Toolkit - Personal notes Glance
Regos Jira Toolkit - Personal notes Glance - Adding a new note
Regos Jira Toolkit - Time Tracker - Tracking time
Regos Jira Toolkit - Time Tracker - Showing Tracking Data
Regos Jira Toolkit - Members Custom Field
Regos Jira Toolkit - Managing Members Custom Field
Regos Jira Toolkit - Shared Task List
Regos Jira Toolkit - Managing Tasks
Inspiration
Our first idea was like two weeks before the Codegeist contest when we read about Forge and we decided to give it a chance for an idea we had in mind for our internal use. We needed a tool that allows us to manage private notes inside a Jira Issue. When we started the development of the prototype for it the Codegeist was announced and we decided to participate in with our new tool because we saw a very big potential with it and Forge, but to have a more solid application, we decided to implement three more tools that we would use too besides the Personal Notes one.
Also, when we saw that the contest also had an Open Source section, we decided to do it this way because we believe that free code is important. We like to think that with our code we can help people who are starting to develop and to break myths about the difficulty of developing addons. If only one person reads our code and it is useful for something, we will be satisfied.
What it does
The app provides four new sections inside the Jira Issue's view:
Members Custom Field
: Provides a way to assign more than one user to the issue. In some cases, we need to assign more than one user to an issue because they are working on it. With this custom field, you can have a list of users that are related to the issue at a glance.
Personal Time Tracker Glance
: It allows you to have control of the time spent on an issue. With a simple click, you can start tracking the time working on an issue, and continues in the background even if you close the issue view or the browser. Once you finish, you can stop the tracker and a new record will be added in the glance to be able to track all the time spent. It also gives an absolute value of all the time spent on the issue.
Personal Notes Glance
: A simple but very useful tool to manage private notes related to an issue. The user will always have it available with one click on the Issue's view.
Shared Task List
: A new Issue panel that provides a shared task list for all the project users. It allows the users to manage Tasks inside the Issue and mark them as resolved. All users that have access to the Issue will be able to create their tasks and see the other tasks' status.
How I built it
The tool we used to build it was Atlassian Forge (Beta) combined with Visual Studio Code IDE. Forge is Atlassian's new platform for building serverless cloud addons for all major Atlassian applications and allows developers to build and integrate applications faster.
Related to Forge we used Forge UI components, the Forge UI API, and Forge Hooks.
The first thing we did was an internal test to see if Forge will be useful for use. As we said earlier, we started with the Personal Notes addon. After that, we decided to build the other tools that would complete the addon.
And last but not least we would like to give special thanks to all the people who at one time or another helped us to clear up our doubts in the Forge and Codegeist 2020 Slacks, especially Neil Mansilla, Karol Grabowski, Joe Clark, Dugald Morrow, Michael Ventnor, Kang-Wei Chan, and Daniel Winter-Wijntjes.
Challenges I ran into
The development of the application has been very interesting and challenging:
The first challenge we encountered was to become familiar with the new development platform, which being Beta some things still didn't do everything we expected of them, having to look for alternatives to solve it. An example of this would be that the Table component of Forge UI does not allow yet the use of checkbox and we had to simulate it using a button with Unicode texts.
Another challenge was not having all the tools that React offers. As the code is executed by the server, many of the tools we were used to using were not available, so we had to come up with solutions for that.
Accomplishments that I'm proud of
The main achievement was to be able to finish the application at the level we wanted. We wanted it to be easy to use for the user, and in the state that Forge is in, we have achieved this satisfactorily. We still have a lot of improvements to do it, like a better styling and UI components accommodation, but for the first attempt, we are very proud of it.
We also are proud to share the application as an Open Source.
What I learned
A lot! We learned a complete framework and to create addons in a fast way. Forge still has some things to improve but we are sure it will be the future of addon creations in the Atlassian Ecosystem.
We also learned that communication with the Atlassian team is crucial to receive and give help, and also to give feedback from the products. In particular with Forge, all the team members were charming when we asked questions or when we gave feedback on something.
What's next for Regos Jira Toolkit
First of all, we want to update it each time Forge includes new things or update existing ones, trying to polish up things that were left over due to the beta state of the framework, for example, application styles.
Also, we hope that the application will be used for two things:
Being Open Source, we hope that more people will be motivated to start developing addons that will be useful for all Atlassian users, and show that with Forge it's very easy to do it.
Other companies will be encouraged to use it to improve their processes and their users can have more options to work.
Built With
cloud
forge
javascript
jira
node.js
react
Try it out
github.com | Regos Jira Toolkit | Regos Jira Toolkit app for Jira Cloud adds four new features to the Issues view. Two new glances for Private Notes and Personal Time Tracking, a Members custom field and a shared Tasks list. | ['Regos Dev Studio'] | [] | ['cloud', 'forge', 'javascript', 'jira', 'node.js', 'react'] | 228 |
10,045 | https://devpost.com/software/hey-giphy | GIF
Inspiration
Scrum meetings like daily stand-ups and backlog prioritization can become rather tedious as the team discusses several JIRA issues, one after the other. Working remotely makes this problem worse. Wouldn't it be nice if we can make these meetings more fun and lighten the mood of the team?
What it does
HEY GIPHY!
is a JIRA app that adds an issue panel titled
HEY GIPHY!
to every JIRA issue. The app will generate GIFs based on the text in the JIRA issue summary. For e.g. if you have a JIRA issue that says
The loader crashes at boot time without any error messages
, the app will show you funny GIFs related to crashes, errors etc. You can cycle through as many GIFs as it takes to amuse your team
How I built it
We used Atlassian Forge and the issuePanel module to add the issue panel. The app uses the JIRA API to get the JIRA issue summary and uses the GIPHY API to get GIFs that are related to the summary.
Challenges I ran into
Since it's a new product, we ran into some minor bugs with the Forge and the Forge CLI but the Forge team was able to help us out. Finding documentation about Forge was also hard, but again the Forge team answered our questions in the slack channel.
Accomplishments that I'm proud of
This is our first Atlassian app.
What I learned
Learned how easy it is to build and deploy a Forge app. It's much easier than a Connect app and I can see how Forge can be the future of building all Atlassian apps.
What's next for HEY GIPHY!
Share interesting GIFs with your team over internal chat. Integrate with other products like Confluence.
Built With
forge
giphy
jira
node.js
typescript
Try it out
github.com | HEY GIPHY! | An app that brings your JIRA issues to life and makes remote scrum meetings fun by generating GIFs based on your issue summary | ['Vikram Parthasarathy', 'Siddharth Subramanian', 'Nithya Renganathan', 'Revanth Anireddy', 'Gopinath Sundaramurthy'] | [] | ['forge', 'giphy', 'jira', 'node.js', 'typescript'] | 229 |
10,045 | https://devpost.com/software/drink-card-powerup | List your beers on a tasting night
Beer information from Untappd appears on the back of each card
Use the Trello mobile app to drag cards into lists and record your favourites while you're out
If you own a venue you can plan events and play with different ideas until you build up a complete beer list
Inspiration
We live in an age of data. It feels like everything is catalogued in some app somewhere: every coffee stand, every campsite, every yoga studio, every EV charging station, every craft beer. But so much of that data is stuck in proprietary apps. Wouldn't it be so much better if we could use all that information and remix it to suit us, instead of being boxed in by the limitations of single app?
I'm a craft beer fan, and the #1 app for beer nerds is Untappd. It lists perhaps a million craft beers with descriptions and reviews and many other details. It's great for recording what I've tried and what I think, but sometimes I'd like to do more with that data.
Trello is great for organising things. This
Drink Card
PowerUp connects Trello with the Untappd API so I can organise my craft beer life however I like! By combining them I get the flexibility of Trello to organise and sort lists, with the rich data of Untappd. Combining two apps to get the best of both is something I think we should be doing a lot more of!
What it does
Drink Card
PowerUp adds two things to Trello cards:
Beers
Breweries
It works by handling URL links to Untappd beers and breweries. When you attach a beer, for example,
Drink Card
sets the cover photo of the card to the beer label. Say you decide to rate the beers at your local pub... your board might now look something like this:
Or perhaps you own a venue and you'd like to plan upcoming events or pick out some interesting beers to order in. You might set up a board with lists for each upcoming event:
As
Drink Card
is a PowerUp it is only available on the desktop, but the data it adds to a card is available when using the mobile app. So if you've loaded up a board with your local pub's tap list before you go then you can easily categorise the cards and take notes on the Trello mobile app while you're enjoying your beer.
How to use it
One of the easiest ways to use
Drink Card
is to have the Untappd website and your Trello board open in two windows, then just click and drag beers onto your board.
Drink Card
will set up a card for each beer you drag:
You can also create cards in Trello then click the 'Add Beer' button on the back of the card to bring up a beer search. Type in a few words and click the beer you're thinking of.
Drink Card
will then attach that beer to the card:
Either way your card now has detailed information about that beer from Untappd and links to more information about the brewery and this beer.
How I built it
There are two parts to
Drink Card:
A static website to configure the Trello PowerUp and provide the UI, built using Typescript, Handlebars and Webpack.
A set of AWS Lambda functions to communicate with the Untappd API and complete an OAuth login to Untappd, building using Typescript and Serverless.
The stack was chosen so that it fits within the free tier of AWS 😀 This is a little app so I didn't want to over-engineer it. Using the combination of a static website plus a small number of independent, stateless functions means it is relatively simple, and so should be reliable and easy to maintain.
Challenges I ran into
Though I'm quite familiar with the technologies I used, I was quite new to Trello PowerUp development so it took me quite some time to get my head around how a PowerUp works.
It's quite a different way of thinking... so often we think of apps as either controlling the whole stack or communicating via a REST API. The PowerUp concept is quite different, more like an augmentation to Trello than a separate app. To make the best use of it had to think differently about how to build an app; instead of storing all my own data I found ways to use attachments effectively to keep all the data in Trello. It can initially feel limiting, but once I embraced it I realised the benefits. No database! No personally identifying information! No GDPR hassles!
Accomplishments that I'm proud of
That little beer bottle icon on the "Add Beer" button.
I drew it myself!
What's next for Drink Card PowerUp
This is a hobby project built for me and a few friends, it's a niche app that I don't expect to be widely used. But there are plenty more possibilities I'm considering if people find it useful:
Displaying beer rating information to Trello cards
Synchronising lists between Trello and Untappd
Using suggestion information from Untappd to create cards for beers you might like
Displaying venue information on Trello cards
More generally I would truely, passionately like to see more Trello PowerUps like this: apps that bring in the wealth of data from the internet right into Trello. There is so much data out there stuck in silos! I hope I inspire a few people to do this for their favourite data source. Where are those hiking trails in Trello? Those recipe cards? Those book covers?
Built With
css3
html
typescript
Try it out
drink-card.charlesgutjahr.com | Drink Card PowerUp | Drink Card lets you add information about beers and breweries to cards on your Trello board. It's for beer nerds, industry professionals, and anyone who just likes to organise their craft beer life! | ['Charles Gutjahr'] | [] | ['css3', 'html', 'typescript'] | 230 |
10,045 | https://devpost.com/software/smart-jira-project-config-documentation | Know the key information of each workflow action
Publish the Smart documentation in Confluence or Export it in DOCX
Inspiration
Smart Jira Project Config Documentation is a Jira app that aims to facilitate the configuration of JIRA following the MDD (Model-Driven Development) methodology.
This application abstracts the project configuration schemes into a single model that is understandable by both Jira Administrators and business users. Say goodbye to the lack of communication between Jira Administrators and Business users.
What it does
Get the documentation of your Jira Project Configuration quickly, up to date and ready to be understood by business users
Save time and have your documentation up to date
Know how your workflows work quickly and easily
Access updated Project Config Documentation in seconds
Export Project Documentation to DOCX in one click
Know the key information of each action in your workflow
Publish the project Documentation in Confluence and review the configuration changes (currently supported by Server and Data Center versions)
How I built it
Migrate a Server version to a ACE version transforming the Servlet to REST calls.
Challenges I ran into
Learn Node.js and the Atlassian Connect Express
Working with Promises to manage asynchronous operations.
Getting the configuration information through REST API was the most important challenge because REST API not gives all the information needed for get the same documentation as the Server version.
Working with JWT
Accomplishments that I'm proud of
Migrate a Server app to a Cloud app in a few weeks
What I learned
Node.js and the Atlassian Connect Express
Working with Promises to manage asynchronous operations
Working with JWT
What's next for Smart Jira Project Config Documentation
Implement the "Publish to Confluence" as the Server version
Show the workflow diagrams as the Server version
Show the Calendars and SLA configuration as the Server version
Documenting 3rd party apps (for example, the Server version documents Profields)
Internationalizing
Export the documentation model of a project and import into another instance.
Create/Update/Delete configurations directly on the Smart documentation (create a new workflow action, modify screens, add a new notification, add a new permission...).
Built With
heroku
jquery
node.js
Try it out
marketplace.atlassian.com
eissoftware.atlassian.net
eisonesoft.atlassian.net | Smart Jira Project Config Documentation | Get the Doc of your Jira Project Configuration quickly, up to date and ready to be understood by business users. Know how your workflows work and publish the doc in Confluence and review the changes | ['Sara Medialdea'] | [] | ['heroku', 'jquery', 'node.js'] | 231 |
10,045 | https://devpost.com/software/project-performance-dashboard-for-jira-cloud | Analyze the sprint velocity of your team and of individual developers within your team
Analyze the structure of your sprints and optimize the scope of each your sprint to deliver new functionality
Analyze how many stories are completed per each sprint to better understand how soon the project will be completed
Inspiration
We decided to create the project performance dashboard to view all the essential information about completed sprints and team performance on the single dashboard without the continuous generation of reports and their configuration.
What it does
The app generates the four charts that give project managers and team leads sufficient insights about completed sprints and performance of their teams and individual developers. This allows them to better forecast the tentative performance of the team and better plan sprints and workload.
The app provides the following charts:
📊
Sprint Structure
per Issue Type: analyze the structure of your sprints and find out whether you add new functionality or address issues and bugs from previous sprints.
💡
Story Throughput
: analyze the number of completed stories throughout the sprints to better understand how your project evolves.
📈
Team and Individual Velocity
: evaluate velocity of your team and individual developers to better understand the development capacity and plan workload for ontime project completion.
How we built it
Initial work on the app started from analysis of Scrum sprint metrics that can give project managers, team leads and product owners a capability to analyze performance of the team and overall progress on the project. Once we collected all the key metrics, we proceeded to creation of prototypes in AdobeXD. We discussed the mechanism to calculate the reporting data and proceeded to development. We decided to use the reliable and proven technology stack of Atlassian Connect with SpringBoot and Java 8. For front-end we used React, JavaScript and AtlasKit. For chart generation we used D3.js. The app is running in AWS (production) and Heroku (staging).
Challenges we ran into
The main challenge for the team was to start working with D3.js. We have no prior experience with it, so it took some time to figure out how to build charts with it.
Accomplishments that we're proud of
We managed to create the app that can instantly display performance of the project development team without any necessity to configure or adjust anything on the Jira side.
What we learned
We learned that calculation of some simple metrics can be not so trivial as we expected :)
What's next for Project Performance Dashboard for Jira Cloud
We will continue adding new charts and reports, like Issue in Status, Issue Transitions Map, Story Lead Time, Story to Complete Average Time.
Built With
amazon-web-services
atlassian-connect
d3.js
heroku
java-8
javascript
react
springboot
Try it out
cutt.ly | Project Performance Dashboard for Jira Cloud | View all the essential information about performance of your development team and individual contributions of each developer in Jira Cloud | ['Vadim Rutkevich', 'Alexander Ovsyannikov', 'Dmitry Kostochko'] | [] | ['amazon-web-services', 'atlassian-connect', 'd3.js', 'heroku', 'java-8', 'javascript', 'react', 'springboot'] | 232 |
10,045 | https://devpost.com/software/jira-standups | Home Page
Chrome Extension: Run through a timed pacing of active issues with each team member
Chrome Extension: Jira Standups app will pull in the list of participating members
Chrome Extension: Standup completed! Review and improve your daily standup efficiency.
Large view: Choose an active Board to select for your standup
Large view: Jira Standups app will pull in the list of participating members
Large view: Run through a timed pacing of active issues with each team member
Large view: Standup completed! Review and improve your daily standup efficiency.
Jira Standups - The chrome extension to help you run more effective standup meetings.
Jira Standups
The chrome extension that help you run more effective standups, right from Jira.
Built using Atlassian Connect API's and tooling.
Inspiration
Almost every modern engineering org and team runs some form of a standup meeting, whether daily or otherwise, and these can be especially important in a remote-oriented work environment.
However, Running effective standups can be something many struggle with.
Standups can be difficult to manage consistently and stick to fixed time schedule.
Often times one person will go way short and might not be adequately explaining their day to day, and other folks might go way over.
With Jira Standups, the app will help you better time manage your daily standup session and ensure that each participant both voices their status and works within the specified time constraint of your choosing.
If you're running a regularly-scheduled sprint, it can be easy for tickets to simply roll over from week to week, this app will help identify tickets that have been lingering on the board too long - and show issues in 'red' that have been stagnant on the board under a given individuals name for multiple weeks.
Whole process is timed, so day to day you can see how long the average stand up takes and if there are opportunities to trim or improve.
App is open source
How it works
Chrome extension connects with a user's Jira account and pulls the active Boards and Projects from their account.
User can select a board to run a standup from. Jira Standups will pull and categorize the issues from the board, as well as identify the engineers/users currently working on issues.
Jira Standups generates a random order of participants based on the issues and time each participant to fit into a scheduled time window of your choosing (for example, a 15 minute standup with 3 participants would give each member 5 minutes to talk about their status with the team.
Once complete, the extension will show the duration that the overall standup session took. Compare week to week to see how your standup efficiency improves.
Future work
More configurable options and week-to-week tracking for running the standup sessions.
Ability to open window showing the issues at hand without leaving the extension.
Paid options and premium content.
Downloading the extension.
Go to the
extension
folder and view the instructions there.
Dev Notes
https://developer.atlassian.com/cloud/jira/software/rest/
Atlassian Connect App using Express
Built With
atlassian-connect
chrome
css
extension
html
javascript
react
Try it out
github.com | Jira Standups - Run standups with a chrome assistant! | The chrome extension that helps you run better standups, right from Jira | ['Chris Buonocore'] | [] | ['atlassian-connect', 'chrome', 'css', 'extension', 'html', 'javascript', 'react'] | 233 |
10,045 | https://devpost.com/software/sentiment-analysis-understand-ticket-emotions | Positive sentiment ticket
Drill in to see breakdown of ticket sentiment
Negative sentiment ticket
Breakdown of sentiment score
Inspiration
It is all too easy for someone to see on a screen text written for a ticket and to handle it without emotion. However these tickets have been written by someone and that someone has emotional state.
What it does
Sentiment Analysis helps in two areas:
Customer Facing
When using JIRA Service Desk, Sentiment Analysis can be used to understand the incoming tickets from customers and users. After a ticket is raised, the individual triaging it can clearly see the sentiment of the ticket and with a single click can see the breakdown of sentiment through the text the submitter wrote. This means that the triaging individual can prioritise the ticket easily and effectively based on both the priority and the sentiment. For instance a ticket using negative works from a customer such as "It is broken" or "Doesn't work" denotes a customer that is more unhappy and may need more rapid service than a ticket that says "Could we fix" or "It would be better if". Sentiment Analysis also helps if there are multiple people triaging tickets as it provides an initial standard base of understanding and reduces the chance that this information could be missed.
Improving Team Positivity
It is all too easy for a development team to write tickets and raise bugs with negative terminology. These negative comments are not good for team morale and constructive for the resolution of tickets. Sentiment analysis provides teams working in JIRA with the sentiment of what they have written, meaning that they can look to understand how they can write their tickets in a more positive way to boost moral and productivity. Again a team raising tickets saying "It stopped working" or "The login screen is broken" will experience more internal negative compared to a team where tickets are written such as "The login screen needs improvement". A simple exposure of a team to more positive tickets and sentiment will propagate through other parts of the teams day to day work such as stand ups, meetings and improve the team moral which in turn leads to happier work environment and more productivity.
It does this by analysing the ticket content including comments to work out the sentiment value and score of each ticket. It re analyses the tickets when they are loaded and will add to the score if comments and modifications are made to the tickets.
How I built it
I wrote this for atlassian forge in nodejs using VSCode and deployed it to forge easily and quickly.
Challenges I ran into
Working out how to deploy to forge and how the tooling worked.
What I learned
I found that Atlassian forge is a great way to extend the JIRA and JIRA Service desk. It provides a rich, infrastructure hassle free environment to build and extend. I will definitely be building more extensions.
What's next for Sentiment Analysis
Sentiment analysis would be extended to work for more languages with more advanced stemming and natural language analysis to understand phrases as well. This would make the application into an advanced sentiment analysis tool across Atlassian Cloud solutions.
Built With
forge
jira
node.js
service
Try it out
github.com | Sentiment Analysis - understand emotion and sentiment | Tickets are written by real people with emotion. This gives the viewer an understanding of the sentiment allowing them to handle negative or positive tickets more effectively. | ['William Powell'] | [] | ['forge', 'jira', 'node.js', 'service'] | 234 |
10,045 | https://devpost.com/software/bievery | Inspiration
I always wondered that how i can utilize the power of BI to create a service which can help business organizations who use Jira. I am inspired by the dream that we provide such a user experience that it seems like you are connected to private Jira database using any BI Tool. The user interface of BI tool (acts as front end) in which you can create dynamic and real time Dashboards in a quick manner.
What it does
Our service provide the power to create dynamic reports using any BI tool on data generated from API provided by
Jira, Tempo, Team work and Pivotal Tracker. Our service works in real time instead of periodic dumping of data from sources. Once connected to bievery, you can configure Jira details and a database name. In that database you can create as many data sets (tables) as you want by using different Jira APIs. After selecting jira fields, you can give a name to table and save it. Now you are ready to use BI tools and connect to our service. BI tool acts as your interface and different BI tools have different powers which means you can use our service with front end choices of any BI tool.
How I built it
I built it using mariadb. I developed two novel algorithms. One that converts any JSON to relational form. Other is at mariadb level which is our trade secret.
Challenges I ran into
Generic programming is not that easy. I am proud of building this solution.
Accomplishments that I'm proud of
My dream has come true and my product is online. It is stable and i am still harnessing its power.
What I learned
I learned that ideas evolve. Initially I started with finance formula analysis in BI tool. I tried to pitch it and got suggestions which resulted in finding superset and Jira side of it.
What's next for bievery
Generation of report by combining data from multiple Jira instances, and to integrate Trello, Basecamp, Versionone and Redmine API's and many more.
Built With
jiraapi
mariadb
superset
Try it out
www.bievery.com
marketplace.atlassian.com
www.pivotaltracker.com
www.ideasextreme.com
www.ideasextreme.com | bievery | We are giving the power of Business Intelligence to everyone. | ['Waqar Ahmad', 'sarmad asghar'] | [] | ['jiraapi', 'mariadb', 'superset'] | 235 |
10,045 | https://devpost.com/software/confluence-jira-checklist | This the view of the macro when published in a confluence page
Inspiration
While using confluence documentation, we used to use checklists to create a status page.
However, one has to explicitly update these checklists once the task is completed.
In most of the cases, we have these tasks in Jira. So it would be great if we can automatically pull up that data to display here
What it does
In this hack, we have created a confluence macro, which automatically pulls up Jira task status and displays as a table. When there is change in the status of Jira issue, the status in the table changes automatically after a refresh of page. Developers and Program managers need not change the status in two different places
How I built it
This was built using Forge tool set. We have used Confluence Macro template along with Jira APIs to get issue information
The source code of the same is shared in
Public Github repo
What I learned
We learnt how to build a confluence macro using Forge toolset. It is a really simple way to build apps, specially if one comes from React background
What's next for Confluence Jira checklist
One addition we wanted to add here was to have an overall completion status based on the count of completed and remaining story points. In this way the macro can be a complete package of status update
Built With
forge
Try it out
github.com | Confluence Jira checklist | While defining and documenting a project, we might want a checklist of Jira Items, the completion of which defines the project status, which the hack addresses | ['Keerthana R.V', 'Sharath Holla'] | [] | ['forge'] | 236 |
10,045 | https://devpost.com/software/elements-connect | You can fetch data from any SQL databases. In the future, we plan to add many more data sources types.
Elements Connect lets you configure how your data is displayed with HTML and native AUI components.
Set-up dependencies between your connected items and create cascading select lists.
Inspiration
The lack of information about a request often leads to longer delays in providing an answer. Yet providing the required level of details to Jira Service Desk agents can be quite challenging for customers.
By connecting Jira Service Desk to external datasources such as the client's CRM, Asset Manager or User Directory, our app Elements Connect aims at reducing the time support agents and JSD customers loose fishing for information and improve customer satisfaction.
What it does
Elements Connect brings external data inside Jira forms, wether it comes from a CRM, an Asset Management System or a User directory. You can customize how data is displayed to match your use-case.
How we built it
We used the Atlassian Connect framework to build the app
Challenges we ran into
Creating a seamless integration within Jira Service Desk was quite challenging.
Performances and security are also critical to us and our customers. We focused a lot on those key subjects.
Accomplishments that we're proud of
Being able to create a seamless integration in Jira Service Desk forms.
Jira Service Desk customers barely notice the difference between Elements Connect items and regular Jira fields.
What we learned
We have learnt that the Jira Cloud platform is full of promises but also quite challenging for a team used build apps for Jira Server and Datacenter.
We feel grateful for the advises and help we've received from the Marketplace team and Ecosystem community. Thanks to CDAC, the Appweek in Scottsdale AZ and few Slack channels, all our burning questions have found answers!
What's next for Elements Connect
The next versions of Elements Connect will bring several improvement like an extended datasource support (i.e.: Active Directories, more databases or REST APIs). We'll listen to our first users feedback to shape the product that perfectly fits their needs. We have already receive constructive feedback on our support portal.
Built With
amazon-ebs
connect
cucumber
es6
java
jpa
node.js
npm
react
spring-boot
tomcat
typescript
Try it out
marketplace.atlassian.com | Elements Connect | Bring external data from your CRM, Asset Manager or User Directory in Jira Service Desk tickets. Elements Connect for Jira Cloud helps admins ensure data is available in context to agents and users. | ['Christophe Prome', "Julie d'Antin", 'Caroline Erhart'] | [] | ['amazon-ebs', 'connect', 'cucumber', 'es6', 'java', 'jpa', 'node.js', 'npm', 'react', 'spring-boot', 'tomcat', 'typescript'] | 237 |
10,045 | https://devpost.com/software/it-infrastructure-management-cio-s-desk | Home Page
Registration Page
Employee List
Resource Management
Add Equipments
Add Projects
User Management Page
Apps and Integration Page
My Contacts Page
Ticketing and Support Page
Jira Integration Page
Active Project Update Page
Project Overview
Project Manager View
Project Cost Calculation
Notification / My To Do list
Inspiration
In today's world, everything as a service for an organization striving the digital transformation that aligns the IT and business strategy. Information Technology is responsible for making sure that nothing goes wrong and must commit the success of every department or organization as a whole. So, balancing innovation and maintenance is crucial.
Chief Information Officer (CIO) plays a major role in the IT sector. CIO can create business value through technology. He has strategic planning, approve technology features, budgets, and growth objective in line with the business goals. He manages IT development team personnel and oversees the customer service platform. Also, he can approve the vendor negotiation, risk management, establish standards, and IT infrastructure. The Biggest Issues CIO faces today are,
* Aligning the IT initiatives with Business Goals
* Improving the IT Operations, System Performance & Security Management
* Cultivating the Vendor and Business Partnerships
* Implementing New systems & Architecture
* Driving Business Innovation with cost control and change efforts
What it does:
Our website makes the CIO's tasks much easier. He can manage the employee on-boarding, resource planning, user and group in the organization, Integrating the application, ticketing and support, project deployment, and contacts on this portal. The application has the following features,
Efficient employee on-boarding is critical for long term success. This app will help to keep track of the people those who are on-boarding into the organization and their essential task associated with them.
Planning Resources effectively is essential for any successful Project. In Resources, you can track and manage the projects, peoples, types of equipment, and schedules efficiently.
User Management provides complete information about the employee in the organization.
Group Management helps to create and allocate the 'N' number of users to various groups in the organization
Manage your contacts with supplier, vendor, partner, and customer details for the organization in this portal
Through App Integration, you can install the featured apps and make use of that functionality on websites. Also, the installed apps can be deleted from the websites so that you can secure the username and password.
Emails are often treated as support tickets. It is a service request from an end-user. Our support portal enable to find information, get support and resolves the issues easily and autonomously.
The project deployment provides a lot of information about the projects in the organization. From the active project, you can understand the milestones and percentage of tasks that are completed. The level of risk, budget, schedule, and quality from a particular project due date managed by the project manager can be identified. Data visualization helps to understand project health in terms of preplanning, feasibility, operating cost, design and development, maintenance with respect to cost. Finally, the project value with respect to the time can be determined.
These features will dramatically improve the productivity of the organization.
How I built it
We have used Atlassian Jira for the creation of epics and user stories. The features are divided into epics and user stories. The epics are a smaller part of our project and the bigger part of user stories. User stories are a smaller part of the epics and considered to be the tasks for our team members. So, We collaborate on design and development with our team members to build this web application.
Challenges I ran into
Our web application is a technology-oriented project. It needs a lot of skills for design and developing the application. We have a small team that needs additional support and work for completing the project within the deadline. As a product manager, it is a big challenge to contribute to the coding and implementation of this web application.
Accomplishments that I'm proud of
We are proud that we have completed and can deliver the project successfully with full functionalities by this deadline.
What I learned
As a product manager, I have learned a lot of new things in the coding part of this project. Also, I have learned to use the Atlassian Jira software for completing the project with our team members. It is a good experience to design and develop the project within the deadline.
What's next for IT Infrastructure Management - CIO's Desk
We have developed the initial version of CIO's desk for the enterprise software application. Still, we need to integrate other roles in the organization. So, We will work out the other important features and roles in the organization for the complete enterprise web application.
Built With
bootstrap
css3
html5
javascript
jira
jquery
mysql
php
Try it out
atlassiancodegeist.com | IT Infrastructure Management - CIO's Desk | Simplifying the tasks of CIO's role on the website. Web application contains Employees, Resources, User Management, Group Management, Apps Integration, Ticketing & Support, and Project Deployment. | ['https://www.figma.com/file/qXy2YWtS41Pw8AkDaTQpRT/Codegeist?node-id=1%3A136', 'Nihal Nihalani', 'Mr Clan'] | [] | ['bootstrap', 'css3', 'html5', 'javascript', 'jira', 'jquery', 'mysql', 'php'] | 238 |
10,045 | https://devpost.com/software/affinity-relative-estimation-for-jira | Drag and drop unestimated stories relatively with estimated stories
Use any sizing you want
Inspiration
Story points sizing is a common problem for teams using Scrum boards. Too often user story sizing falls back to absolute sizing, with using story points as a representation for days or hours.
What it does
This app solves the problem, by introducing truly relative estimations. You can drag and drop issues to be estimated relatively to the already estimated issues. By comparing the stories to each other it is impossible to fall back to absolute estimations, thus producing the perfect relative estimates.
How I built it
The app is built using Vue.js with many FOSS components provided by vue-aui package. However, it was necessary to make many of the additional components myself - such as issue cards, swimlanes, columns, etc.
Challenges I ran into
Building the app brought me many challenges - first and the major one was making of swimlanes board interface, support for drag and drop, while at the same time adhering to Atlassian User Interface guidelines.
Accomplishments that I'm proud of
Making a final product better than I have expected in the first place.
What I learned
More CSS tricks.
What's next for Affinity/Relative Estimation for Jira
This app will be released in Atlassian Marketplace to gather feedback from the first users and will be improved based on the user suggestions.
Built With
firebase
html5
javascript
vue.js | Affinity/Relative Estimation for Jira | Quickly estimate a large number of user stories in story points. Save time and produce estimates using relative comparison. | ['Raimundas Juška'] | [] | ['firebase', 'html5', 'javascript', 'vue.js'] | 239 |
10,045 | https://devpost.com/software/velocity-sprint-planning-tracking | Past sprint velocities
Individual user velocities to account for user absences if needed
Active sprint progress
Inspiration
Sprint planning is a bi-weekly routine for many teams. One of the ways the planning is done is Velocity-Driven Sprint Planning. However, this involves doing a lot of manual work to arrive at a result, which can be achieved with better automation.
What it does
Velocity Sprint Planning & Tracking app introduces a more convenient way of Velocity-Driven Sprint Planning, with automating average sprint velocities, calculating individual user's velocity to account for user absences and providing with a convenient drag-and-drop user interface.
How I built it
The app is built using Vue.js with many FOSS components provided by vue-aui package. However, it was necessary to make many of the additional components myself - such as issue cards, swimlanes, columns, etc.
Challenges I ran into
Building the app brought many challenges, such as building an interface for swimlanes and cards that mimics the one that Agile teams are accustomed to. There also were some problems of respecting ranking on the boards as well as supporting issues moving from backlog to sprint and sprint to backlog.
Accomplishments that I'm proud of
Making a final product better than I have expected in the first place.
What I learned
More CSS tricks.
What's next for Velocity Sprint Planning & Tracking
This app will be released in Atlassian Marketplace to gather feedback from the first users and will be improved based on the user suggestions.
Built With
firebase
html5
javascript
vue.js | Velocity Sprint Planning & Tracking | Plan sprints based on your team's previous velocities. Account for team member absences with individual velocity. | ['Raimundas Juška'] | [] | ['firebase', 'html5', 'javascript', 'vue.js'] | 240 |
10,045 | https://devpost.com/software/elements-copy-sync | Set up a copy recipe using Elements Copy & Sync
Step 1 - Configure the source issues
Step 2 - Configure the target issues
Step 3 - Configure the issue content
Select a recipe for each need
Inspiration
What we wanted to accomplish with Copy & Sync was nothing short of complete peace of mind.
The peace of mind of Jira admins, first, who can always be sure that their tools will be handled by their users exactly as they are intended to.
The peace of mind of the Jira users, then, who will be guided every step of the way in their work, and free of any repetitive tasks they had to perform until now.
What inspired us was watching our own support agents struggle daily on tasks that were an inefficient use of time for them. Their expertise was in the help they could provide to our customers, not in their ability to copy Jira issues from one project to another, or manually sifting through information to select what would be relevant to our developers.
What it does
That's where Elements Copy & Sync can be particularly useful. After a couple of simple configuration steps, our copy recipes can be used across any Jira Cloud instance by all types of users. No matter if Copy & Sync is used by beginners or more experienced Jira users, the result will always be the same : issues will be copied where they are supposed to, with the exact information needed, whether it's included in the issue context, in comments, or in attachments.
As different Jira projects often require completely different actions, Copy & Sync Cloud recipes can be customized to any situation. Jira admins have the complete control over where the copies can be performed by users, for instance in a given project only, or for a couple of issue types in a specific status, or even for issues with a distinct label and priority.
The same level of guidance can be applied to what is copied, and where it will be copied to.
How we built it
Our team strives to always look at new technologies, so with that in mind we opted to build our application with React (Redux-Saga) and Typescript for the front-end. The back-end runs on Java, Spring Boot and JPA.
Challenges we ran into
An interesting challenge we ran into was using the Jira Cloud API for the first time. Until now, our team had only worked on Jira Server/Data Center, so discovering what is (and more importantly, isn't) possible to do in Jira Cloud had its share of surprises.
Accomplishments that we're proud of
Setting apart a few setbacks, we are really proud of what we were able to accomplish in such a short amount of time. Not only were we able to complete the features we were hoping for in time for Codegeist, but we had time to add even more, in a good-looking package we are actually very proud of.
What we learned
We discovered that our little team worked really well toward a common and clear goal and that we were able to help one another every step of the way. With a full Agile development process, we were able to increment little by little on our features and what our app was bringing to the table, while always having a product we felt we could release on a days notice.
What's next for Elements Copy & Sync
We still have a few features we want to implement before going public with our add-on, but in the meantime we are quite happy that some people will be able to discover it, and hopefully enjoy it, right now.
Built With
amazon-ebs
atlaskit
atlassian-connect
es6
java
react
redux
saga
springboot
typescript | Elements Copy & Sync | Elements Copy & Sync aims to reduce manual inputs by copying, linking, and synchronizing Jira issues automatically. Our goal is to simplify issue escalation from support agents to development teams. | ['Julien Peyrade', 'Dusan Spaic', 'Mélanie Geffre', 'Bastien Fiorito', 'Basile Grandperret'] | [] | ['amazon-ebs', 'atlaskit', 'atlassian-connect', 'es6', 'java', 'react', 'redux', 'saga', 'springboot', 'typescript'] | 241 |
10,045 | https://devpost.com/software/covid-stats-fn1m65 | Inspiration
Right from this global pandemic hit I wanted to some effort from my side for a better tomorrow. So I have been reading blog posts and articles describing the spread and a few challenges where we can participate in making it better with the technology. But one thing common about all the posts is that for live stats it always redirect to other pages. I even conversed with a few business analysts who are writing reports and they find it difficult to embed the statistics and graphs right on-page they write.
Also, this can be a friendly reminder to all the members who are reading the confluence page to be
Stay Safe, Stay Calm, Stay Informed
What it does
The application fetches the live data from the COVID-19 API of all the countries around the world and also fetches the live graph from another API and displays it on the page.
In simple terms, it displays a graph and also stats of the top 10 most affected countries.
How I built it
I built it with
forge
, the forge is an amazing library that helped a lot in building the tool. The documentation is really robust and
@forge/api
library helped to fetch those stats.
const fetchCovidStats = async () => {
const res = await (
await fetch("https://coronavirus-19-api.herokuapp.com/countries")
).json();
return res.slice(0, 10);
};
The above snippet is used to fetch the statistics.
Challenges I ran into
Initially, I had some hard time trying to add react and failing it miserable. Then I got to know it uses Node packages. Then I saw
@forge/ui
documentation and shifted to try that library and it felt amazing.
I also found it hard to find accurate data to display, one misleading value can really create great havoc in the reader's mind. Once I found the API things went smoothly.
Accomplishments that I'm proud of
The final output was one thing I am definitely proud of, I have shown it to a few confluence page writers and document reader. They were really happy seeing the app.
I always get immense satisfaction when anyone uses the application I develop.
What I learned
I have learnt how to use
@forge/ui
and
@forge/api
. Learnt about
forge tunnel
and some new things.
What's next for Covid Stats
Next for Covid Stats will be adding a map where user can select a country on the map and then reveal it's statistics. Also, pre-rendering the
svg
of the graph for the top 10 countries.
Built With
api
await
forge
javascript
Try it out
github.com | Covid Stats | Coronavirus is creating a global pandemic and we all must be aware of the stats so that we can plan and act accordingly to be safe, calm and informed. Embedding these stats can help analysts alot. | ['Rohith Gilla'] | [] | ['api', 'await', 'forge', 'javascript'] | 242 |
10,045 | https://devpost.com/software/current-time | Right side of a Jira Issue
Inspiration
When working remotely with others from around the world, I constantly had to google what time it was in Vietnam, China, or Ukraine. It would be extremely beneficial to be able to simply see what time it was for them within the Issue ticket.
What it does
This feature is to the right of the ticket under "Current Time".
When expanded, you can see the current time for the reporter and assignee.
If the current time plugin has been sitting idle, click on "Get Current Time" to update.
How I built it
I used Forge and its UI tools for this simple app.
Challenges I ran into
I didn't have as much freedom such as styling and full control of JavaScript, but for my purpose, Forge UI was good enough and did the job well.
Accomplishments that I'm proud of
This was a fairly simple app but the idea is something that could save some time and frustration when working with others from around the world.
What I learned
I learned about some amazing tools and how easy it was to create a Forge app.
What's next for Current Time
When Forge extends their flexibility, I would love to style Current Time better. Also another feature I would love to see is have it update every 10 minutes just in case a user leaves their ticket screen open.
Built With
forge
javascript
moment.js
Try it out
github.com | Current Time | A simple click and you can see what time it is for your assignee or reporter. | ['Jenearly Ang', 'Yenith LianTyHao'] | [] | ['forge', 'javascript', 'moment.js'] | 243 |
10,045 | https://devpost.com/software/automatic-page-archiving-for-confluence-cloud | Keep track of expired content
Archive pages - not deleted, still searchable
Save time from manual, laborious work
Keeping track of all content in Confluence can be a job on its own. Pages should be kept up-to-date and eventually should not distract from relevant content when they turn irrelevant. The manual workload for the user only grows with the number of users.
To help the administrators of Confluence Cloud instances keep the content up-to-date
Automatic Archiving for Confluence Cloud
allows to define simple rules for the lifecycle of pages. On a per space basis it is possible to define when a page expires and when a page should be automatically archived, both in number of days since the last update. The expiration tells you that the page should be updated again. If this does not happen it gets eventually archived and moved to another space, so it does not distract from the still relevant content in the original space. This way the original space is clearer, but no content gets lost, ever.
Related
Administrators request support like this in the Cloud version for quite some time now. While Confluence recently launched a manual archiving feature of single pages in beta, this does not address the discovery of outdated content and also not the automatic part, still leaving a lot of work with the user. For Confluence Server an add-on supporting discovery and cleanup of outdated content became essential to many administrators, also blocking them from migrating to Cloud.
Future considerations
There are plenty of ways to support the user even more by improving this add-on. The add-on will be integrated more thoroughly in the future. E-mail notifications will be sent to authors, editors or other users in charge of content. An overview of all the content in Confluence shall give a better impression of the overall quality of the content.
How does it work?
The site administrator installs the add-on via the Atlassian marketplace. Now all space administrators are able to configure the page lifecycle rules via “Space Settings” > “Add-ons” > “Automatic Page Archiving” for each space. Via “Space Settings” > “Overview” > “Page Status” the administrator is now able to see which pages will expire soon or will be archived soon. For both it is relevant when the page has been updated the latest, or any of its children. Once a week all pages that are ready to be archived will be moved to an archive space. One of these spaces exists for each actual space, contains all the archived pages from the original space and has some limited permissions. This way the content is never lost, can still be found and can easily be restored. Upon installation the optimal time slot for the archival is determined, then it is processed once a week.
See the
User Guide
for more information on how the add-on works.
Built With
atlassian-connect
express.js
javascript
node.js
Try it out
marketplace.atlassian.com
peter-eigenschink.atlassian.net
peter-eigenschink.atlassian.net | Automatic Archiving for Confluence Cloud | Discover & clean up outdated content with minimal manual effort. Configure rules for automatic archiving of outdated pages, without losing them forever. | ['Peter Eigenschink'] | [] | ['atlassian-connect', 'express.js', 'javascript', 'node.js'] | 244 |
10,045 | https://devpost.com/software/context-writing-made-easy | Inspiration
The inspiration for Context came from personal experience. As a team, we are often faced with writing documents and find it quite challenging, especially when we are on a tight schedule. We spend a considerable amount of time searching for the right words and wondering if the ones we have come up with are the best and most appropriate. For this reason, we asked ourselves “What would improve our writing experience?”. The answer was a lexical help that could be consulted in Confluence and that would offer a wealth of useful information. Since inspired writing is a gift for the few, we thought that most people would love a little help. That’s why we decided to develop Context.
What it does
Context is a tool that helps people make the process of writing smoother and improve their style. Context provides alternative terms with usage examples as well as ‘collocations’, i.e. words that habitually go together forming natural patterns. With Context, it is no longer necessary to leave Confluence looking for language help as the sought-after words are readily available on the page. Context is designed for people who don’t have the time to rack their brains in search of words. It is especially useful to non-native English speakers who wish to improve their lexical accuracy and avoid mistakes.
How we built it
Context is an NLP-based project. We have worked on different datasets in order to collect information on word usage. The technologies that were exploited are Atlassian Connect, Nodejs (backend), and Reactjs (frontend). The plugin is embedded in a macro which can be accessed via the command /context
Challenges we ran into
The biggest challenge we faced concerns real-time access to the user’s content as they are typing it. We came up with several workarounds in order to provide a pleasant user experience in spite of the technical limitations.
Accomplishments that we're proud of
We are proud to have come up with a simple but very practical idea that offers concrete help to all those people who struggle with writing and are tired of wasting time jumping from one resource to the next in search of the right words, often failing to find them. We are pleased to present a highly responsive and well-engineered tool that can easily become an indispensable part of the users' writing routine, also owing to its clean design and intuitive feel.
What we learned
From a strictly technical point of view, we learned to build macros for Confluence. More importantly, though, owing to the technical limitations encountered, we learned to stretch our imagination to find solutions. But above all, we learned to apply our skills to a field which is completely new to us.
What's next for Context: writing made easy.
Firstly, we intend to enrich the synonym section by adding more terms. Secondly, we'd love to add a translation functionality. Our idea is to incorporate translations from different languages from and into English so as to help non-native speakers write their documents faster, more accurately and without the nuisance of having to search for equivalents on the web. This would also help English native speakers who write documents in languages other than English.
Lastly, we wish to further exploit Artificial Intelligence to improve the Context experience. In particular, we aim to allow users to copy-paste an entire sentence and have Context to the job of identifying the right synonym for a selected word.
Built With
atlassian-connect
confluence
es6
gitlab
heroku
react | Context for Confluence: Word Prompter | Effortless writing is a gift for the few. Most people struggle to find the right words.That's why we created Context, a tool designed to improve style and accuracy. | ['Andrea Arcifa', 'Giovanni Palmeri', 'Alessandro Distefano', 'Barbara Berti'] | [] | ['atlassian-connect', 'confluence', 'es6', 'gitlab', 'heroku', 'react'] | 245 |
10,045 | https://devpost.com/software/tactic-assignments | High risk parameters
High risk item
Medium risk item
Medium risk parameters
Low risk parameters
Low risk item
World map of team distribution
Risk statuses
Foreword
This information, screenshots and instructions also available on TacTicA GitHub repos for
Front-End
and
Back-End
.
Inspiration
Teams distributed over the world need appropriate tools for their work. Many companies use JIRA for task tracking. Team leads or product managers work with their teams from any locations in the world. Asynchronous communication available via tools like JIRA is essential to make these teams efficient.
However, when a team lead assigns a ticket to his colleague, he has a lack of feedback or response and not sure if it was set into the tasks queue or hanged without being noticed.
I know that many people solve this by pinging each other in messengers or face-to-face communication to fulfill this gap. And developers know how destructive such distractions are.
One way to improve this situation is to give the team leads an appropriate tool to predict how assignments will work (or if it's not - why it's not working as expected).
I developed TacTic Assingments JIRA add-on as part of
Atlassian Codegeist 2020 hackathon
to allow teams that are distributed over the world to be more efficient by making work timelines of every JIRA issue more transparent to all colleagues.
It doesn’t replace direct communication, but it avoids wrong patterns of communications and fits distributed teams where it might be hard to communicate directly because of timezones. It might also fit for organizations that don’t have a lot of project managers to track people’s load. Most organizations that I know are eager to constant progress, want their teams to work like a Clock’s (tick tack tick tack) and to avoid overload, stress, and tons of meetings. This TacTic Assignments add-on brings that into life.
What it does
Basically, TacTic Assingments add-on estimates the risks of every ticket assignment that you make. But it's more appropriate to be used for the tasks that you expect to be executed urgently or really soon.
It uses current information available in JIRA (work in progress already assigned, timezones, etc.) to predict when the assigned person most likely can start work on the subject.
It all starts with knowing the ticket number and assignee. Then this tool will automatically compare the assignee and your timezones and show the difference.
It will also check the amount of work in progress for this person to consider his current load.
It will ensure that the item you have just assigned to a colleague has the best potential to be executed soon. Otherwise, it will raise a red status to let you know about the risks!
How I built it
Front-End part
is built with native JavaScript and using Atlassian Connect add-on library
atlassian-connect-express
.
Back-end API
is built with .NET Core 3.1, C#, Docker and AWS platform (ECS, Fargate, EC2, Route53 etc.).
External API's used:
GeoNames API
for geocoding and timezones
IpInfoDb
service for finding IP address of the client
Challenges I ran into
I'm not a javascript developer, so it was the hardest challenge for me. I also had to figure out how to make my API available from JIRA projects and add-on hosting (CORS, security, and all about), how to load balance my API using AWS, etc.
Accomplishments that I'm proud of
I've made load-balanced back-end infrastructure, containerized API, and feature-rich javascript application.
What I learned
Atlassian Cloud platform
AWS Cloud
Heroku Cloud
Java Script, nodeJS, Express.js
Docker containers
What's next for TacTic Assignments add-on
To make it analyze historical assignments and calculate potential capacity.
To improve the co-workers' map with more features.
To make add-on more dynamic and quick.
Follow
This information, instructions and source code is available on TacTicA GitHub repos for
Front-End
and
Back-End
.
Built With
.net
amazon-ec2
amazon-web-services
atlassian-connect-express
c#
docker
ecs
express.js
fargate
geonames
heroku
ipinfodb
node.js
postgresql
route53
Try it out
github.com | TacTic Assignments | This JIRA addon predicts the risks of assignments. It allows teams distributed over the world to be more efficient by making work timelines of every JIRA issue more transparent to all colleagues. | ['Anton Yarkov'] | [] | ['.net', 'amazon-ec2', 'amazon-web-services', 'atlassian-connect-express', 'c#', 'docker', 'ecs', 'express.js', 'fargate', 'geonames', 'heroku', 'ipinfodb', 'node.js', 'postgresql', 'route53'] | 246 |
10,045 | https://devpost.com/software/jira-excalidraw-integration | Add-on on Jira issue details view (hidden on the first load)
Add new drawing
Save result to Jira
Overview
Inspiration
Ability to have a simple tool inside Jira which helps to draw schemas that look like human writing
What it does
Simple integration with the "excalidraw.com" tool.
How I built it
I have used Atlassian "Connect" approach and built add-on which integrates Jira and "Excalidraw".
Challenges I ran into
Using react and Atlaskit
What I learned
react
What's next for Jira Excalidraw Integration
more features
Built With
javascript
node.js
react | Jira Excalidraw Integration | Jira Excalidraw Integration | ['Oleksii Smargunov'] | [] | ['javascript', 'node.js', 'react'] | 247 |
10,045 | https://devpost.com/software/e-consult | What it does
Online academic consultation service
How I built it
Challenges I ran into
Accomplishments that I'm proud of
What I learned
What's next for e-Consult
Built With
bitbucket
forge
trello
Try it out
bitbucket.org | e-Consult | Online academic consultation service | ['Tri Labs'] | [] | ['bitbucket', 'forge', 'trello'] | 248 |
10,045 | https://devpost.com/software/digital-agile-cards | Running your retrospective meetings on Digital Cards
GIF
Images, animated gifs, SVGs, videos, and music.
Kanban board created in Digital Cards
Create new board dialog
Auto import Jira issues
Share options, copy the invite link, or make the board public.
Ready to use templates, which can help with most popular use cases.
Auto update issues on drag and drop: transition, update a field, or assign issues
Digital Cards are suitable also for diagrams.
GIF
Adding issues from Jira using JQL search
GIF
Convert cards into issues
GIF
Drag multiple cards
GIF
Free hand draw
Inspiration
Teams across the world due to COVID-19 moved from their offices to remote work. They are no longer able to use shared physical board with stickers, markers, or printed issues from their Jira.
Digital Cards app is an answer to this problem, it ads a virtual board functionality to Jira Cloud.
What it does
Thanks to this tool you can run agile rituals in virtual environment: sprint planning, prioritisation, retrospectives, sprint boards, brainstorms, or anything you would normally do on a physical board with your team in the office.
It enables real time collaboration for remote teams in a free form environment just like it was possible on a physical board. You can create stickers, add Jira issues, draw lines, and create simple diagrams. All participant cursors are visible in the viewport, which is scrollable, and zoomable.
Virtual board comes with a powerful Jira integration, so anything that happens with an issue on the virtual board will be immediately synchronised to Jira, and v-ce versa - issue updates are immediately visible on the board.
It's actually more convenient than a physical board: forget about making photos, or writing down your meeting notes - everything is already available in Digital Cards!
How I built it
Technology buzzwords behind Digital Cards:
Google Cloud Platform, Firebase, Cloud Functions, Atlassian Connect
React, Atlaskit, node.js
Digital Cards were used by my team almost since day 1, so dogfooding process was one of key driving factors of the project. I was able to observe how real people are using the product, and quickly learn about problems, bugs, shortcomings, or missing features. My team is using this tool for running retrospectives, planning, and managing daily work on Jira issues.
Later I was lucky to find a group of users outside, and learn from their use case, and needs. This team on the other hand was interested in diagramming capabilities.
That's how Digital Cards were developed simultaneously in two directions: Jira integration, and diagramming.
Challenges I ran into
Product challenge: how to define the scope of MVP, what are the most important user journeys, and use cases.
Programming challenge: complexity of the implementation, degrading performance, peculiarities of Firebase, React, Atlassian Connect, and Atlaskit.
Accomplishments that I'm proud of
It works, and I've got positive feedback from various people. Getting all of this together is an achievement, and I feel that I can easily continue further development without any major roadblocks.
What I learned
It is yet another project which helped me to grow as a programmer. My learning was focused around React, and Firebase. Betting on integration with Jira also allowed me to deepen my knowledge about Atlassian Connect, and Jira.
What's next for Digital Cards for Jira Cloud
Business as usual: gather&address user feedback, improve UX, make the app easier to use, fix bugs, remove code debt, improve performance. I'm already running a closed beta program, and I'm looking for early adopters, so feel free to contact me if you are interested!
Turning this product into a profitable business is the ultimate goal.
Built With
atlaskit
connect
firebase
javascript
react
Try it out
web.archive.org | Digital Cards for Jira Cloud | Collaborative Realtime Virtual Whiteboard for Jira Cloud | ['Grzegorz Tańczyk'] | [] | ['atlaskit', 'connect', 'firebase', 'javascript', 'react'] | 249 |
10,045 | https://devpost.com/software/lango-language-and-translation-manager | Users can change language with a simple switcher popup
Creators can set the current page language with a byline item popup
Create new translations with Creator Tool
Link existing pages as translation of another content with the Linker Tool
Inspiration
Confluence does not have native support for multilingual content. Managing multiple versions of the same content in different languages can be complex.
What it does
Lango simplifies the creation and management of multilingual content
Features:
Switch between languages using a simple drop-down
Create localized content with a simple click
You can link existing pages as translation of another page
Over 40 supported language
How I built it
Atlassian Connect and nodejs for backend, reactjs for frontend using atlaskit as base for my react components.
Lango adds a new content-property on page for linking original content with its translations.
Challenges I ran into
Creating plug-ins for Atlassian cloud products has proven very challenging and sometimes frustrating.
The iframe limits the creation of complex plugins: it is not possible for developers to interact with the pages content and this has huge implications on the user-experience design. Moreover, often there aren't enough extension points.
Accomplishments that I'm proud of
I built a simple and intuitive interface that integrates seamlessly with the native Confluence user experience.
What I learned
Develop applications within an iframe using events to make them communicate with each other
Use expressjs as a backend
Build highly interactive interfaces with atlaskit
What's next for Lango: Language and translation manager
Support for automatic translation for content, with the ability to choose a preferred translation provider (example: Google Cloud, Microsoft, Deepl, etc)
Built With
atlassian-connect
confluence
express.js
gitlab
heroku
javascript
node.js
react
Try it out
marketplace.atlassian.com | Lango: Language and translation manager | A set of multi language tools for Confluence Cloud: language switcher, page linking, automatic content translations with your preferred cloud provider | ['Alessandro Distefano'] | [] | ['atlassian-connect', 'confluence', 'express.js', 'gitlab', 'heroku', 'javascript', 'node.js', 'react'] | 250 |
10,045 | https://devpost.com/software/instant-wiki | Dynamic wiki generated and updated each time the Confluence page is updated
Create wiki action from any confluence page
Wiki links out to wikipedia for additional information on key topics found in your confluence articles
Instant Wiki - An instant references section for your confluence article
Instant Wiki
Use NLP to extract an automatic and dynamically updated references and keywords section to the end of any Confluence article.
Built on Atlassian Forge.
Inspiration
How many times have you come across an article that uses terminology or topics you don't understand? Many times you may be writing documentation yourself for items where additional references might be useful. A references section is something also frequently overlooked when writing documentation, but may help unfamiliar colleagues or readers understand your content through outside sources.
What it does
Instant Wiki is a macro that automatically adds an appendix section to any Confluence article
Uses basic NLP to extract core phrases and topics out of an article. Extracting keywords can help a reader get a quick feel for the gist of a long article, and improve search results.
Generates automatic wikipedia links for additional information on any of the extracted key phrases from the article.
Search for the
instant-wiki
forge app
Invoke via
/Create wiki
How I built it
Macro parses out the paragraph (body) content of the article.
Content is run through a modern NLP javascript engine from retextjs (
https://github.com/retextjs/retext
) and finds core elements.
The core themes and keywords are separated out from the current article and rendered into a simple to understand appendix section for your article
Challenges I ran into
There wasn't a formal API for extracting the plain text out of a confluence article. I had to build a processing function to enable parsing through the formatted confluence markdown to get the relevant content.
Accomplishments that I'm proud of
It works
What I learned
How to build a "serverless" forge app and leverage the confluence API to pull article data
What's next for Instant Wiki
The goal of the Instant Wiki would be to save any potential time needed to generate an appendix of content for an article.
Add more configurable options for the wiki footer content
Link to other sources beyond Wikipedia. Recommend additional content suggestions based on the parsed text and body from the Confluence page.
Parse through the user's Confluence space to find other articles that might be relevant to the current one being read.
Built With
bitbucket
confluence
javascript
typescript
Try it out
github.com | Instant Wiki - an automated reference section for Confluence | Add a dynamically updated appendix / references section to your Confluence articles with a single command. | ['Chris Buonocore'] | [] | ['bitbucket', 'confluence', 'javascript', 'typescript'] | 251 |
10,045 | https://devpost.com/software/jira-risk-forge | Risk field on Jira issue
Glance on Jira issue
Validator
Jira Risk (Forge)
Manage risk in Jira using an app built with Forge.
Inspiration
Teams already track their work in Jira. They include information such as time estimates, the stage in the workflow, and priorities. Jira makes these easy to record with custom places to include the information. However, there's nowhere dedicated to tracking risk or mitigation techniques. Jira Risk gives users a dedicated place to record risk and incorporate it into their workflow.
Our target uses are release managers and people working in DevOps. Release managers can use Jira Risk to review risks, see which issues they should investigate, and check how risky each release is. When an incident happens, someone working in DevOps can use the risk details to identify possible explanations quickly. They can then use the risk details, and people involved to review and improve their development process.
Other apps approach tracking risk with a set matrix, but we want to give teams the flexibility to align on their own definitions of what constitutes a risky change.
What it does
Issue glance: Enter how risky the change is and provide details to explain the risk and the mitigation tactics.
Validator: Enforce the use of Jira Risk by adding a validator to the workflow that prevents an issue from transitioning without the risk level set.
How we built it
We used Forge to see how far we could get with the platform.
Challenges we ran into
Forge was easy and quite to build with, but its limited capabilities were challenging. We want:
A project page module to show a report of risks.
An entry point on the page for a version.
A place in the project settings to enable users to disable it for projects that don't need to track risks.
Accomplishments that we're proud of
The app shares code with the Connect app we built. In particular, they share the same data keys, which lets us easily migrate the data between apps.
What we learned
Codegeist gave us a great opportunity to try creating our new Connect app with Forge.
What's next for Jira Risk
List the Connect app on the Atlassian Marketplace.
Provide documentation to help users get started.
Monitor usage and feedback to help prioritize our backlog.
Investigate migrating the Connect app to AWS Lambda.
Continue developing the Forge app as the platform matures.
Built With
forge
jira | Jira Risk (Forge) | Manage risk where the work happens with a solution built into Jira. | ['Dean Pisani'] | [] | ['forge', 'jira'] | 252 |
10,045 | https://devpost.com/software/jira-risk | Risk field on Jira issue
Risk glance on Jira issue
Risk page
Risk summary on version page
Risk app project settings
Risk validator
Jira Risk
Manage risk in Jira using an app built with Connect.
Inspiration
Teams already track their work in Jira. They include information such as time estimates, the stage in the workflow, and priorities. Jira makes these easy to record with custom places to include the information. However, there's nowhere dedicated to tracking risk or mitigation techniques. Jira Risk gives users a dedicated place to record risk and incorporate it into their workflow.
Our target uses are release managers and people working in DevOps. Release managers can use Jira Risk to review risks, see which issues they should investigate, and check how risky each release is. When an incident happens, someone working in DevOps can use the risk details to identify possible explanations quickly. They can then use the risk details, and people involved to review and improve their development process.
Other apps approach tracking risk with a set matrix, but we want to give teams the flexibility to align on their own definitions of what constitutes a risky change. We also introduce the idea of reviewing risk. A risk review enables people to balance high-risk changes with mitigation techniques.
What it does
Issue glance: Enter how risky the change is and provide details to explain the risk and the mitigation tactics.
Project page: See the aggregate risk details, filter by version, and review the risks. If the risk details are acceptable, you can approve the risk.
Version summary: View a high-level summary of the risk going into a version from the version page. Jump between the summary and full details with the navigation provided.
Validator: Enforce the use of Jira Risk by adding a validator to the workflow that prevents an issue from transitioning without the risk level set.
Project-level configuration: The app can be disabled at the project level for teams that don't need to use it.
How we built it
We used Atlassian Connect Express (ACE) to get started quickly. We built the frontend with React, TypeScript, and Atlaskit. The app is hosted on Heroku.
Challenges we ran into
We used an extension point on the version page that we discovered with the suggested tooling. However, we cannot know which version the page is for from our app. We asked a question about this at the start of Codegeist, but it has not been resolved. See
JSWCLOUD-19011
.
No ACE template uses React, so we had to create our own before we could start.
Accomplishments that we're proud of
The app is ready to scale to large projects with a lot of issues.
We were able to create a Forge app that is compatible with this Connect app.
What we learned
With mainly back end development experience, Codegeist was a great chance to learn some popular front end technologies and experiment with some parts of Atlassian products that were new to me.
These included:
Atlaskit
Bitbucket pipelines
Entity properties, JQL, and the Jira REST API
React
TypeScript
Webpack
What's next for Jira Risk
List the Connect app on the Atlassian Marketplace.
Provide documentation to help users get started.
Monitor usage and feedback to help prioritize our backlog.
Investigate migrating the Connect app to AWS Lambda.
Continue developing the Forge app as the platform matures.
Built With
atlassian
connect
node.js
react | Jira Risk | Manage risk where the work happens with a solution built into Jira. | ['Dean Pisani'] | [] | ['atlassian', 'connect', 'node.js', 'react'] | 253 |
10,045 | https://devpost.com/software/confluence-word-counter | Inspiration
I looked into what Forge can be used for and started working on a simple app that used the content of a Confluence page.
What it does
Counts the number of words on a Confluence page. Due to the complicated json output from the REST api, for some pages it is slightly inaccurate, however tested on blog posts with it works. I decided on this idea because many word editors, like Google Docs, allows you to count the words on the document rather than using another website. It's easier especially if you need to reach or stay under a certain number of words.
How I built it
I used some Forge tutorials to start and then moved on to analyzing the content of the Confluence page. One of the biggest difficulties in this was that since Forge is in beta, there are few answers for how to use it and how to figure out different error messages online.
This was just a way to get acquainted with Confluence and Forge and learn how to integrate the two.
In order to use it you would need the same dependencies listed on
this
example page, and use
forge create
,
forge deploy
, and
forge install
on your own Confluence Atlassian cloud server. The actual app is accessed via the three dots in the top right of Confluence pages
To test it out without installing on your own page, go to the atlassian link at the bottom, go to Confluence and then 'Word count test' and see the option at the bottom of the three dots settings to count words.
Built With
extendscript
forge
javascript
Try it out
github.com
rdtesting.atlassian.net | Confluence Word Counter | Confluence Content Action app built with Forge that provides a word count of a page. | ['Riley Dyer'] | [] | ['extendscript', 'forge', 'javascript'] | 254 |
10,045 | https://devpost.com/software/simple-checklists-for-jira | Simple Checklists for Jira
Inspiration
I was excited to learn about Forge and wanted to try it out. This was my warmup project, and I thought I would open-source it to help others learn.
What it does
The app adds a panel to Jira issues where you can add, remove and toggle tasks. Basic concurrency is supported: multiple users can edit the checklist without overwriting each others' changes.
How I built it
Built with Forge using vanilla JavaScript. The state of the checklist is stored as JSON in the Issue Property. No external services are used. See the GitHub repository for more details:
https://github.com/dpashkevich/forge-jira-checklist
Challenges I ran into
I quickly found that the current Forge UI capabilities are very limited. I was going to use the Checkbox component in checklist items, but that component doesn't support an
onClick
or
onChange
handler, so I had to resort to using a Button component with an emoji to represent the checked state. There are also scarce layout capabilities: the only way to display several components on one line is to use a Table, which is what I went with. Column width isn't customizable, so there's some wasted white space. I deciced to leave out reodering and editing of tasks because there wasn't an elegant way to implement it with the patform's capabilities.
Accomplishments that I'm proud of
I was able to build and deploy a fully functional app in a very short period of time!
What I learned
I learned how Forge works and the platform's current capabilities. Despite being in early stages and having some limitations, you can already implement a lot of things with it. I'm currently working on a larger app.
What's next for Simple Checklists For Jira
I'm happy to share the app's source code as educational material. I plan on improving it as new features land in Forge. I also plan on recording a series of educational screencasts on building this app from scratch.
Built With
forge
javascript
Try it out
github.com | Simple Checklists For Jira | Adds a checklist panel to Jira issues | ['Dmitry Pashkevich'] | [] | ['forge', 'javascript'] | 255 |
10,045 | https://devpost.com/software/castme | Main Menu
Motion capture streaming demo
Female avatar professor teaching
Male Avatar professor teaching
presentation screen
view from the back
View from the middle
Customize Character
castme.life website
Splash Screen
Inspiration
Video lectures are present in abundance but the mocap data of those video lectures is 10 times ahead in the form of precise data. High quality and a large amount of data are one of the requirements of best argmax predicting ML models, so we have used here the mocap data. Despite the availability of such promising data, the problem of generating bone transforms from audio is extremely difficult, due in part to the technical challenge of mapping from a 1D signal to a 3D transform (translation, rotation, scale) float values, but also due to the fact that humans are extremely attuned to subtle details in expressing emotions; many previous attempts at simulating talking character have produced results that look uncanny( two company- neon, soul-machine). In addition to generating realistic results, this paper represents the first attempt to solve the audio speech to character bone transform prediction problem by analyzing a large corpus of mocap data of a single person. As such, it opens to the door to modeling other public figures, or any 3D character (through analyzing mocap data). Text to audio to bone transform, aside from being interesting purely from a scientific standpoint, has a range of important practical applications. The ability to generate high-quality textured 3D animated character from audio could significantly reduce the amount of bandwidth needed in video coding/transmission (which makes up a large percentage of current internet bandwidth). For hearing impaired people, animation synthesis from bone transform could enable lip-reading from over-the-phone audio. And digital humans are central to entertainment applications like movies special effects and games.
What it does
Some of the cutting edge technologies like ML and DL have solved many problems of our society with far more better accuracy than an ideal human can ever do. We are using this tech to enhance our learning procedure in the education system.
The problem with every university student is, they have to pay a big amount of money for continuing to study at any college, they have to interact with the lecturers and professors to keep getting better and better. We are solving the problem of money. Our solution to this problem is, we have created here an e-text data to human AR character sparse point mapping machine learning model to replace the professors and use our ai bots to teach the same thing in a far more intractable and intuitive way that can be ever dome with the professors. The students can learn even by themselves AR characters too.
How we built it
This project explores the opportunities of AI, deep learning for character animation, and control. Over the last 2 years, this project has become a modular and stable framework for data-driven character animation, including data processing, network training, and runtime control, developed in Unity3D / Unreal Engine-4/ Tensorflow / Pytorch. This project enables using neural networks for animating character locomotion, face sparse point movements, and character-scene interactions with objects and the environment. Further advances on this project will continue to be added to this pipeline.
Challenges we ran into
For Building, first of all, a studio kind of environment, we have to collect a bunch of equipment, software, and their requisites. Some of them have been listed following.
Mocap suite- SmartSuite Pro from
www.rokoko.com
- single: $2,495 + Extra Textile- $395
GPU + CPU - $5,000
Office premise – $ 2,000
Data preprocessing
Prerequisite software licenses- Unity3D, Unreal Engine-4.24, Maya, Motionbuilder
Model Building
AWS Sagemaker and AWS Lambda inferencing
Database Management System
Further, we started building.
Accomplishments that we're proud of
The thinking of joining a virtual class, hosting a class, having a realtime interaction with your colleagues, talking with him, asking questions, visualizing an augmented view of any equipment, and creating a solution is in itself is an accomplishment.
Some of the great features that we have added in here are:
Asking questions with your avatar professors,
having a discussion with your colleagues,
Learning at your own time with these avatars professors
and many more. some of the detailed descriptions have been given in the submitted files.
What we learned
This section can be entirely technical. All of the C++ and Blueprint part of a Multiplayer Game Development.
We have started developing some of the designs in MotionBuilder, previously we have been all using the Maya and Blender.
What's next for castme
1. We are looking for a tie-up with many colleges and universities. Some of the examples are Galgotiah University, Abdul Kalam Technical University (AKTU), IIT Roorkee, IIT Delhi.
2. Recording an abundance amount of the lecture motion capture data, for better training our (question-answering-motion capture data) machine learning model.
Try it out here:
Intro Demo (2 min):
https://youtu.be/Xm6KWg1YS3k
Complete Demo:
https://youtu.be/1h1ERaDKn6o
Download pipeline here:
https://www.castme.life/wp-content/uploads/2020/04/castme-life%20Win64%20v-2.1beta.zip
Documentation to use this pipeline:
https://www.castme.life/forums/topic/how-to-install-castme-life-win64-v-2-1beta/
Complete source code (1.44 GB):
https://drive.google.com/open?id=1GdTw9iONLywzPCoZbgekFFpZBLjJ3I1p
castme.life:
https://castme.life
More info
For more info on the project contact me here:
[email protected]
, +1626803601
Built With
blueprint
c++
php
python
pytorch
tensorflow
unreal-engine
wordpress
Try it out
castme.life
www.castme.life
github.com
www.castme.life | castme | We are revolutionizing the way the human learns. We uses the Avatar Professors to teach you in a virtual class.Talk to your professors,ask questions,have a discussion with your colleagues in realtime. | ['Md. Zeeshan', 'Rodrixx Studio'] | ['The Wolfram Award'] | ['blueprint', 'c++', 'php', 'python', 'pytorch', 'tensorflow', 'unreal-engine', 'wordpress'] | 256 |
10,045 | https://devpost.com/software/pledge1percentapp | U-Pledge Settings
U-Pledge User Menu
Inspiration
Due to the pandemic situation in the word, neither are we able to create team-building events, and we thought this event would be something like it, even if it has to be online.
We were brainstorming a lot about what we should build. We knew that we want to create something unique, that can make people have a positive impact on other people's lives, and put the profit mindset behind for a while.
What it does
This app helps you organize, manage, and execute charity events in Atlassian Jira Cloud. All you have to do is create a charity project, and determine a time pool that is available for the employees to spend. In the U-Pledge menu, we visualized the available, planned, and used time in a bar chart, and we also added an event list that shows all the Jira Issues available on the chosen project.
How we built it
Techstack: AWS, PostgreSQL, Java, OSGi, ECM, Querydsl, JTA, RxJava, HTML, JavaScript, TypeScript, CSS, React, Atlaskit
We dedicated 4 days from our development sprint to build U-Pledge from the beginning to the end. On the first day, we presented the app idea to the team, and then we planned the features and created a wireframe. The remaining 3 days were spent on the implementation. Due to the short period of time, we tried to implement only the unique and necessary features and use every possible resource that the Jira Cloud provides. The team consisted of 1 Product Manager, 1 Software Architect, 2 Backend Developers, 2 Frontend Developers, 1 System Administrator and 1 Software Tester.
Challenges we ran into
First of all, this was our first online Hackathon. Of course, we participated in several offline events and the team is well accustomed, yet the development takes extra time when the team is not sitting in the same room.
Another challenge that we faced was that we had to rethink some of our ideas so we could implement them with Jira Cloud's API.
Accomplishments that we're proud of
We are really proud of our team. Building a fully working Jira Cloud application within 3 days is something that we couldn't believe we are capable of. Everyone was fully motivated and 100% percent to achieve success. Even if our app won't be awarded any prize, we believe we reached our goal and passed this challenge successfully with a lot of new knowledge that we can benefit from in the future.
What we learned
We learned a lot about what is possible within Jira Cloud, which we will definitely be able to use in our new apps in the future. Also, this was the first time that we created an integration for social media platforms.
What's next for U-Pledge
We want to publish U-Pledge on the Atlassian Marketplace as a free Jira Cloud application. Based on the interest level, we have many ideas to improve the usability of the app, like:
adding the option to generate the charity project that will be automatically configured with unique workflow and other schemes
adding social media authentication, so the using organization can also post on their own social media next to the public U-Pledge page
improving the visuals of the bar chart
adding participant filters
adding date frames to events
adding visualization and filtering of already happened events
and many more...
Documentation
You can find the full documentation here:
https://everit.atlassian.net/wiki/spaces/UDFJC/overview
Built With
amazon-web-services
atlaskit
css
ecm
html
java
javascript
jta
osgi
postgresql
querydsl
react
rxjava
typescript
Try it out
upledge-cloud.everit.biz | U-Pledge | The U-Pledge is an app to help organizations and companies who uses Jira to join the Pledge 1% movement (https://pledge1percent.org/) | ['Tamás Zsankó', 'Tibor Tasi', 'Péter Tölgyesi', 'Attila Kiss', 'Áron Gyenes', 'Dániel Tóth', 'Valéria Uhljar', 'Attila Bordás', 'Krisztián Hatházi', 'Zsigmond Czine'] | [] | ['amazon-web-services', 'atlaskit', 'css', 'ecm', 'html', 'java', 'javascript', 'jta', 'osgi', 'postgresql', 'querydsl', 'react', 'rxjava', 'typescript'] | 257 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.