Scoold
- 0 ratings
Stack Overflow in a JAR. An enterprise-ready Q&A platform with full-text search, SAML, LDAP integration and social login support.
Deploy this app to Linode with a free $100 credit!
Scoold is a Q&A and a knowledge sharing platform for teams. The project was created back in 2008, released in 2012 as social network for schools inspired by Stack Overflow. In 2017 it was refactored, repackaged and open-sourced.
Scoold can run anywhere - Heroku, DigitalOcean, AWS, Azure or any VPS hosting provider. It's lightweight (~7000 LOC), the backend is handled by a separate service called Para. Scoold does not require a database, and the controller logic is really simple because all the heavy lifting is delegated to Para. This makes the code easy to read and can be learned quickly by junior developers.
Scoold Pro, the paid version of Scoold, has premium features which make it the perfect knowledge sharing platform for your company or team.
This project is fully funded and supported by Erudika - an independent, bootstrapped company.
...and more!
For admin access, open the Scoold Pro demo and login with "Demo login".
Scoold is a client application of the Para backend server. Almost every request to
Scoold produces at least one request to Para as well. When you ask a question on Scoold, a create request is
sent to Para to the location POST /v1/questions. Here are a few key points about that architecture:
- A Para server can be hosted anywhere and store data inside any of the supported databases.
- Para is a multi-tenant server which stores data in isolated environments called "apps".
- One or more instance of Scoold (like a cluster) can connect to the same Para app environment and share the data.
- Multiple separate Scoold websites can be powered by the same Para backend using different Para apps.
- Each app environment is completely independent from others and has its own database table and search index.
- Both Scoold and Para can be hosted on the same machine or on multiple machines, on different networks.
- Scoold talks to Para via HTTP(S) so Para must be directly accessible from Scoold, but can also be hosted on a private network.
Here's an overview of the architecture:
┌────────────┐
┌───► Database │
┌──────────┐ ┌────────┐ │ ┌────────────┤
│ Scoold 1 ├──► │ │ └────────────┤
├──────────┤ │ Para ◄──┼───► Search │
│ Scoold 2 ├──► │ │ ┌────────────┤
└──────────┘ └────────┘ │ └────────────┤
└───► Cache │
└────────────┘
JDK 11 or higher is required to build and run the project. All major operating systems are supported.
application.conf with these properties:
scoold.env = "production"
scoold.app_name = "Scoold"
scoold.para_access_key = "app:scoold"
scoold.para_secret_key = "_secret_key_from_para_"
scoold.para_endpoint = "https://paraio.com"
# add your email here
scoold.admins = "my@email.com"
# (optional) require authentication for viewing content
scoold.is_default_space_public = falsejava -jar -Dconfig.file=./application.conf scoold-*.jar.To login with a social account, you must create a developer app with Facebook, Google or any other identity provider. This is not required when you log in with LDAP, SAML or email/password.
Save the obtained API keys in the application.conf file that you have created above.
For all identity providers, you must whitelist the Para host with the appropriate authentication endpoint: - GitHub:
https://paraio.com/github_auth- OAuth 2:https://paraio.com/oauth2_authLearn more about custom authentication
Note: The Para backend server is deployed separately and is required for Scoold to run.
scoold and inside, a new configuration file named scoold-application.conf (see example above)java -jar -Dconfig.file=./scoold-application.conf \
-Dscoold.autoinit.para_config_file=../para-application.conf scoold-*.jar`Optionally, you can also install the Para CLI tool for browsing and managing data in your Scoold app.
Important:
- The convention is to use para-application.conf and scoold-application.conf for Para and Scoold respectively.
- All settings shown here are meant to be kept inside the Scoold configuration file.
- SMTP settings must be configured before deploying Scoold to production.
Read the Para docs for details on how to run and configure your Scoold backend.
Scoold and Para can both be hosted on the same machine, provided it has at least 3 GB of RAM.
Scoold requires: - at least 500 MB RAM - 1 vCPU or more - 10 GB disk space or more (primarily for logs and storing images)
Para requires: - at least 1 GB RAM - 1 vCPU (2 are recommended) - 10 GB disk space or more (unless the database is stored on the same machine)
JVM parameters: e.g. java -jar -Xms600m -Xmx600m scoold-*.jar
Scoold requires a persistent and direct connection to a Para server to function properly.
Copy this Scoold example configuration to your application.conf (edit the values if needed):
# the name of the application
scoold.app_name = "Scoold"
# the port for Scoold
scoold.port = 8000
# environment - "production" or "development"
scoold.env = "production"
# the public-facing URL where Scoold is hosted
scoold.host_url = "http://localhost:8000"
# the URL of Para - can also be "https://paraio.com"
scoold.para_endpoint = "http://localhost:8080"
# access key for your Para app
scoold.para_access_key = "app:scoold"
# secret key for your Para app
scoold.para_secret_key = ""
# the email or identifier of the admin user - check Para user object
scoold.admins = "admin@domain.com"
# Enable/disable password authentication
scoold.password_auth_enabled = trueOn startup, Scoold tries to connect to Para every 10 seconds, 10 times in total. (default). If the connection is unsuccessful, the settings will not be persisted.
scoold.connection_retries_max = 10
scoold.connection_retry_interval_sec = 10For an infinite number of attempts to connect to Para, set connection_retries_max to -1.
For tagged Docker images for Scoold, go to erudikaltd/scoold on Docker Hub.
The :latest_stable tag always points to the latest stable release version. The :latest tag can be broken/unstable.
The easiest way to create the Scoold stack is to run docker compose up.
docker-compose.yml (for Scoold Pro
docker-compose.yml is here)
to it from this repository.$ touch para-application.conf scoold-application.confscoold.app_secret_key and scoold.para_secret_key, these secrets will be populated automatically upon initialization.$ docker compose upTo stop the containers use Ctrl + C.
Important: Scoold will connect to Para on http://para:8080, inside the Docker container environment.
That hostname may not be accessible from your local machine or the Internet, which will break authentication redirects.
For example, when signing in with Google, you will be redirected to Google and then back to Para, on the address
specified in scoold.security.redirect_uri. Para must be a publicly accessible on that address or the authentication
requests will fail.
If you prefer, you can run the Scoold container outside of Docker Compose.
First, have your Scoold application.conf configuration file ready in the current directory and run this command:
$ docker run -ti -p 8000:8000 --rm -v $(pwd)/application.conf:/scoold/application.conf \
-e JAVA_OPTS="-Dconfig.file=/scoold/application.conf" erudikaltd/scoold:latest_stableFor Scoold Pro the images are located in a private registry. You can get access to it once you purchase a Pro license. The run command for Scoold Pro is similar with the only difference being the uploads volume:
$ docker run -ti -p 8000:8000 --rm -v $(pwd)/application.conf:/scoold-pro/application.conf \
-v scoold-uploads:/scoold-pro/uploads -e JAVA_OPTS="-Dconfig.file=/scoold-pro/application.conf" \
374874639893.dkr.ecr.eu-west-1.amazonaws.com/scoold-pro:latest_stableFollow the getting started guide after starting the Para and Scoold containers.
Environment variables
JAVA_OPTS - Java system properties, e.g. -Dscoold.port=8000
BOOT_SLEEP - Startup delay, in seconds
There's a Helm chart inside the helm/ folder. First edit helm/scoold/values.yaml and then you can deploy Scoold to
Kubernetes with a single command:
cd helm; helm install ./scooldFor more info, read the README at helm/README.md.
If you purchase Scoold Pro you can get access to the private Docker registry hosted on the AWS Elastic Container Registry. Access to the private registry is not given automatically upon purchase - you have to request it. You will then be issued a special access key and secret for AWS ECR. Then execute the following BASH commands (these require AWS CLI v2.x): 1. Configure AWS CLI to use the new credentials:
aws configureaws ecr get-login-password --region eu-west-1 | \
docker login --username AWS --password-stdin 374874639893.dkr.ecr.eu-west-1.amazonaws.comaws ecr list-images --repository-name scoold-pro
docker pull 374874639893.dkr.ecr.eu-west-1.amazonaws.com/scoold-pro:{tag}The :latest tag is not supported but you can use :latest_stable. The command aws get-login-password
gives you an access token to the private Docker registry which is valid for 12 hours.
For connecting Kubernetes to AWS ECR, please refer to this article.
In case you don't want to use AWS CLI for logging into the Scoold Pro registry, install the AWS ECR Docker Credentials Helper.
For license holders with access to the Scoold Pro source code, the steps to browse the Git repository are as follows:
git remote add scoold https://git-codecommit.eu-west-1.amazonaws.com/v1/repos/scoold-pro
git fetch scoold masterYou should be able to browse the source code with any of the Git graphic interface tools out there. Keep in mind that the repository is read-only, so you can only work with local branches and merge the latest changes from the main branch to your local branch.
One-click deployment
git push heroku masterscoold.para_endpoint -> scoold_para_endpoint.https://{appname}.herokuapp.com.heroku/jvm and heroku/java buildpacks to your Heroku app from the Settings pageProcfile containing this line:
web: java -Dserver.port=$PORT $JAVA_OPTS -jar scoold-*.jar $JAR_OPTS$ heroku plugins:install java
$ heroku deploy:jar scoold-x.y.z.jar --app myscooldappOn Heroku you don't have a configuration file, instead you use Heroku's environment variables to configure Scoold.
You can add each Scoold configuration property as an environment variable on the Settings page of your Heroku admin page.
Click "Reveal Config Vars". Configuration variables (config vars) must not contain dots ".", for example scoold.para_endpoint
becomes para_endpoint. You must replace every dot with an underscore in order to convert a Scoold configuration
property to a Heroku environment variable.
Installing the Heroku CLI tool allows you to watch the Scoold logs with:
$ heroku logs --tail --app myscooldapp$ heroku restart --app myscooldappubuntu with adduser ubuntuwget https://raw.githubusercontent.com/Erudika/scoold/master/installer.sh && bash installer.shscp application.conf root@123.234.12.34:/home/ubuntussh root@123.234.12.34 "systemctl restart scoold.service"http://123.234.12.34:8000 and verify that Scoold is running (use the correct IP address of your droplet)
Lightsail
8000Elatic Beanstalk
mvn -Pwar packagetarget/scoold-x.y.z.war to Beanstalk, modify any additional options and hit "Create"Authentication with Amazon Cognito
Scoold is fully compatible with Amazon Cognito because Cognito is just another OAuth 2.0 service provider. Here's how to configure Scoold to work with Amazon Cognito:
https://scoold.auth.eu-west-1.amazoncognito.comapplication.conf and add a new OAuth 2.0 authentication provider:
scoold.oa2_app_id = "cognito_app_client_id"
scoold.oa2_secret = "cognito_app_client_secret"
scoold.security.oauth.authz_url = "https://scoold.auth.eu-west-1.amazoncognito.com/login"
scoold.security.oauth.token_url = "https://scoold.auth.eu-west-1.amazoncognito.com/oauth2/token"
scoold.security.oauth.profile_url = "https://scoold.auth.eu-west-1.amazoncognito.com/oauth2/userInfo"
scoold.security.oauth.provider = "Continue with Cognito"Make sure you whitelist your Para authentication endpoint with Cognito https://para_url/oauth2_auth.
/bin/shvi application.conf, hit i and paste in your configurationEsc and type in :wq then restart your container
Another option is to attach a secret volume
to your container, containing the configuration. It should be mounted as /scoold/application.conf.scoold.jarapp.gae.yaml from this repository to the same folder and rename it to app.yamlapp.gae.yaml and fill in the correct configuration propertiesgcloud preview app deploy app.yamlThe instructions for Tomcat in particular are:
mvn -Pwar packageROOT.war if you want it deployed to the root context or leave it as isTomcat/webapps/ & start Tomcatapplication.conf in Tomcat/webapps/scoold-folder/WEB-INF/classes/ & restart TomcatScoold is compatible with Tomcat 9+.
To deploy Scoold at a different path instead of the root path, set scoold.context_path = "/newpath. The default value
for this setting is blank, meaning Scoold will be deployed at the root directory.
There are situations where you want to transfer your data from one Para server to another. This may be because you decided to switch databases or hosting providers. This process is made simple with the backup and restore feature in Scoold and Scoold Pro. Simply go to the Administration page and download all your data from the source installation. Then on the target installation go to the Administration page and import the ZIP file which contains the backup.
Important: All data will be overwritten on restore, so it's highly recommended that the target Scoold installation is fresh and containing no data.
When using the default H2 database, you can also copy the ./data directory to the new installation or just copy all
*.db files. The data directory also contains Lucene index folders for each app, e.g. ./data/scoold-lucene. These
folders can also be moved and copied or even deleted. You can easily restore the Lucene index for a Para app by running
a rebuild index task from the para-cli tool. Here's how to rebuild the root app para and a child app scoold with
just two simple commands:
$ npm i -g para-cli
$ para-cli rebuild-index --endpoint "http://localhost:8080" --accessKey "app:para" --secretKey "secret1"
$ para-cli rebuild-index --endpoint "http://localhost:8080" --accessKey "app:scoold" --secretKey "secret2"All the data for your team on Stack Overflow, except for user badges, will be imported into Scoold.
You can seamlessly upgrade from Scoold to Scoold Pro without changing the configuration or anything else in your infrastructure. The process is very simple:
This header is enabled by default for enhanced security. It can be disabled with scoold.csp_header_enabled = false.
The default value is modified through scoold.csp_header = "new_value". The default CSP header is:
default-src 'self';
base-uri 'self';
connect-src 'self' scoold.com www.google-analytics.com www.googletagmanager.com accounts.google.com;
frame-src 'self' accounts.google.com staticxx.facebook.com;
font-src cdnjs.cloudflare.com fonts.gstatic.com fonts.googleapis.com;
style-src 'self' 'unsafe-inline' fonts.googleapis.com cdnjs.cloudflare.com static.scoold.com accounts.google.com;
img-src 'self' https: data:;
object-src 'none;
report-uri /reports/cspv;
script-src 'unsafe-inline' https: 'nonce-{{nonce}}' 'strict-dynamic';The placeholder {{nonce}} will get replaced by the CSP nonce value used for whitelisting scripts.
Note: If you get CSP violation errors, check your scoold.host_url and scoold.cdn_url configuration,
or edit the value of scoold.csp_header.
Additionally, there are 4 options to extend the values of connect-src, frame-src, font-src and style-src
respectively:
scoold.csp_connect_sources = "connect-domain1.com connect-domain2.com"
scoold.csp_frame_sources = "frame-domain1.com frame-domain2.com"
scoold.csp_font_sources = "font-domain1.com font-domain2.com"
scoold.csp_style_sources = "style-domain1.com style-domain2.com"You can also enable or disable CSP violation reports (visible only to admins) by setting scoold.csp_reports_enabled = true.
Keep in mind that if your website has a lot of traffic, this will result in hundreds of new reports being created each hour.
You can append external scripts and JS snippets to the end of the page by setting the scoold.external_scripts property.
Scripts are loaded in alphabetical order based on their key.
# URL
scoold.external_scripts.myscript1 = "https://mydomain.com/script.js"
# Base64 encoded long JavaScript snippet
scoold.external_scripts.myscript2 = "J2Y2M3VlcH .... enZ2OScpOw=="
# Short raw JS snippet
scoold.external_scripts.myscript3 = "var x = 5; console.log('x is', x);"Important: Watch out for console errors in the browser after you add external scripts. In such cases you might have to
modify the frame-src or connect-src portions of the CSP header (see the 4 options above).
If 3rd party cookie consent is enabled (for GDPR, CCPA), all external scripts will be disabled until the user gives their
consent. You can bypass that by prefixing its key with "bypassconsent", e.g. scoold.external_scripts.bypassconsent_myscript2.
Additionally, you can put scripts in the <head> element by prefixing their name with "head", for example:
scoold.external_scripts.head_script.
You can inline short snippets of CSS using scoold.inline_css. Keep in mind that any inlined CSS rules will
override any of the previously declared stylesheets, including the main stylesheet rules.
scoold.inline_css = "body { color: #abcdef; }"scoold.external_styles = "https://mydomain.com/style1.css, https://mydomain.com/style2.css"/styles/style.css and modify those, then upload the new
custom stylesheet file to a public location and set:
scoold.stylesheet_url = "https://public.cdn.com/custom.css"The order in which CSS rules are loaded is this (each overrides the previous ones): 1. main stylesheet, 2. external stylesheets, 3. inline CSS or custom theme
You can also override the default dark stylesheet which is only loaded if dark mode is enabled:
scoold.dark_stylesheet_url = "https://public.cdn.com/dark.css"By default, Scoold will only serve static files from the /static folder on the classpath (inside the JAR).
If you want to configure it to serve additional resources from a local directory, set this system property:
spring.web.resources.static-locations = "classpath:/static/, file:/home/scoold/static-folder/"/home/scoold/static-folder/file.png will be served from localhost:8000/file.png.
For more information, check the
Spring Boot documentation.
Scoold will serve static files (JS, CSS, fonts) from the same domain where it is deployed. You can configure the
scoold.cdn_url to enable serving those files from a CDN. The value of the CDN URL must not end in "/".
Scoold uses the JavaMail API to send emails. If you want Scoold to send notification emails you should add the following SMTP settings to your config file:
# system email address
scoold.support_email = "support@scoold.com"
scoold.mail.host = "smtp.example.com"
scoold.mail.port = 587
scoold.mail.username = "user@example.com"
scoold.mail.password = "password"
scoold.mail.tls = true
scoold.mail.ssl = false
# enable SMTP debug logging
scoold.mail.debug = truesrc/main/resources/emails/notify.html.
Email notifications are enabled by default but can also be turned off completely by changing these settings:
# disable all notifications
scoold.notification_emails_allowed = true
# disable notifications for new posts
scoold.newpost_emails_allowed = true
# disable notifications for new posts that match favorite tags
scoold.favtags_emails_allowed = true
# disable notifications for replies
scoold.reply_emails_allowed = true
# disable notifications for comments
scoold.comment_emails_allowed = true
# additional options for Scoold Pro
# disable notifications for mentions
scoold.mentions_emails_allowed = trueFor Gmail you have to turn on "Less secure app access" in your Google account settings. There's no need to configure
mail.tls or mail.ssl, just set the mail.host to smtp.gmail.com and your Gmail email and password.
You can enable or disable the email verification step by setting scoold.security.allow_unverified_emails = true
(in Scoold's application.conf). By default, email verification is turned off when Scoold is running in development mode.
This will allow new users to register with fake emails and Scoold will not send them a confirmation email. It's useful
for testing purposes or in certain situations where you want to programmatically sign up users who don't have an email.
You can protect signups and password reset functionality with reCAPTCHA v3. First you will need to register a new domain
at Google reCAPTCHA. Create a new reCAPTCHA v3, add your site to the whitelist
and copy the two keys - a clientside key (site key) and a serverside key (secret). Then, protect the pages
/signin/register and /signin/iforgot by adding these properties to your configuration:
scoold.signup_captcha_site_key = "site-key-from-google"
scoold.signup_captcha_secret_key = "secret-from-google"By default, Scoold will protect valuable questions and answers from accidental deletion. If a question has at least one answer, the author of that question will not be able to delete it. Or, if an answer is accepted by the author of the question, the person who wrote the answer won't be able to delete it. You can turn this off with:
scoold.delete_protection_enabled = falseTo customize the message sent when a new user signs up with Scoold, modify these properties in your Scoold configuration file:
scoold.emails.welcome_text1 = "You are now part of {0} - a friendly Q&A community..."
scoold.emails.welcome_text2 = "To get started, simply navigate to the "Ask question" page and ask a question..."
scoold.emails.welcome_text3 = "Best, <br>The {0} team<br><br>"For all social identity providers, you need to obtain both the OAuth2 client ID (app id) and secret key.
Note: if the credentials are blank, the sign in button is hidden for that provider.
# Facebook
scoold.fb_app_id = ""
scoold.fb_secret = ""
# Google
scoold.gp_app_id = ""
scoold.gp_secret = ""
# GitHub
scoold.gh_app_id = ""
scoold.gh_secret = ""
# LinkedIn
scoold.in_app_id = ""
scoold.in_secret = ""
# Twitter
scoold.tw_app_id = ""
scoold.tw_secret = ""
# Microsoft
scoold.ms_app_id = ""
scoold.ms_secret = ""
scoold.ms_tenant_id = ""
# Slack
scoold.sl_app_id = ""
scoold.sl_secret = ""
# Amazon
scoold.az_app_id = ""
scoold.az_secret = ""scoold.host_url = "https://your.scoold.url"Important: You must to whitelist the Para endpoints in the admin consoles of
each authentication provider. For example, for GitHub you need to whitelist https://parahost.com/github_auth as a
callback URL (redirect URL). Same thing applies for the other providers. For these two providers you need to whitelist
these two URLs, containing the public address of Scoold:
https://myscoold.com
https://myscoold.com/signinIf you skip this step, authentication will most likely not work.
In some cases (see related issue) you want to have Scoold connect to
Para which is hosted somewhere on your local network and logging in with some authentication providers, like Microsoft,
doesn't work. In such cases you would see an error "redirect_uri mismatch" or "invalid redirect_uri - must start with
https:// or http://localhost". To make it work you can set scoold.security.redirect_uri = "https://public-para.host"
while still keeping scoold.para_endpoint = "http://local-ip:8080".
You can authenticate users against any OAuth 2.0/OpenID Connect server through the generic OAuth 2 filter in Para.
Make sure you whitelist your Para authentication endpoint https://para_url/oauth2_auth as a trusted redirect URL.
Here are all the options which you can set in the Scoold configuration file:
# minimal setup
scoold.oa2_app_id = ""
scoold.oa2_secret = ""
scoold.security.oauth.authz_url = "https://your-idp.com/login"
scoold.security.oauth.token_url = "https://your-idp.com/token"
scoold.security.oauth.profile_url = "https://your-idp.com/userinfo"
scoold.security.oauth.scope = "openid email profile"
# extra options
scoold.security.oauth.accept_header = ""
scoold.security.oauth.domain = "paraio.com"
scoold.security.oauth.parameters.id = "sub"
scoold.security.oauth.parameters.picture = "picture"
scoold.security.oauth.parameters.email = "email"
scoold.security.oauth.parameters.name = "name"
scoold.security.oauth.parameters.given_name = "given_name"
scoold.security.oauth.parameters.family_name = "family_name"
# Sets the string on the login button
scoold.security.oauth.provider = "Continue with OpenID Connect"
# [PRO] Enable/disable access token delegation
scoold.security.oauth.token_delegation_enabled = false
# [PRO] Assigns spaces to each user from the OAuth2 claim 'spaces'
scoold.security.oauth.spaces_attribute_name = "spaces"
# [PRO] Assigns moderator/admin roles from the OAuth2 claim 'roles'
scoold.security.oauth.groups_attribute_name = "roles"
scoold.security.oauth.mods_equivalent_claim_value = "mod"
scoold.security.oauth.admins_equivalent_claim_value = "admin"
# if specified, users who are not admin/mod will be denied access when not members of group
scoold.security.oauth.users_equivalent_claim_value = ""
# Enable/disable avatar fetching from IDP
scoold.security.oauth.download_avatars = false
# State parameter in auth requests can be disabled if problematic
scoold.security.oauth.state_param_enabled = truePRO This is an additional security feature, where the access token from the identity provider (IDP)
is stored in the user's idpAccessToken field and validated on each authentication request with the IDP. If the IDP
revokes a delegated access token, then that user would automatically be logged out from Scoold Pro and denied access
immediately.
The basic profile data attributes (name, email, etc.) can be extracted from a complex response payload which is returned
from the identity provider's userinfo endpoint. You can use JSON pointer syntax to locate attribute values within a
more complex JSON payload like this one:
{
"sub": "gfreeman",
"attributes": {
"DisplayName": "Gordon Freeman",
"DN": "uid=gordon,CN=Users,O=BlackMesa",
"Email": "gordon.freeman@blackmesa.gov"
}
}scoold.security.oauth.parameters.email = "/attributes/Email"
scoold.security.oauth.parameters.name = "/attributes/DisplayName"PRO This feature requires token delegation to be enabled with scoold.security.oauth.token_delegation_enabled = true.
When working with complex user profile payloads coming from the ID provider, you can specify the exact property
name where the roles data is contained. For example, having a JSON user profile response like this:
{
"sub": "gfreeman",
"DisplayName": "Gordon Freeman",
"Roles": "Staff,Admins,TopSecret",
"attributes": {
"MemberOf": [
"CN=Admins,CN=Lab,O=BlackMesa"
]
}
}scoold.security.oauth.groups_attribute_name = "Roles"
scoold.security.oauth.admins_equivalent_claim_value = ".*?Admins.*"scoold.security.oauth.groups_attribute_name = "/attributes/MemberOf"
scoold.security.oauth.admins_equivalent_claim_value = "^CN=Admins.*"scoold.security.oauth.users_equivalent_claim_value. For example, if the value of that is set
to "scoold_user", and a user having the claim of "roles": ["sales_rep"] tries to login, they will be denied access.
By default, all OAuth2 users are allowed to log into Scoold.
You can add two additional custom OAuth 2.0/OpenID connect providers called "second" and "third". Here's what the settings look like for the "second" provider:
# minimal setup (second provider)
scoold.oa2second_app_id = ""
scoold.oa2second_secret = ""
scoold.security.oauthsecond.authz_url = "https://your-idp.com/login"
scoold.security.oauthsecond.token_url = "https://your-idp.com/token"
scoold.security.oauthsecond.profile_url = "https://your-idp.com/userinfo"
scoold.security.oauthsecond.scope = "openid email profile"
# extra options (second provider)
scoold.security.oauthsecond.accept_header = ""
scoold.security.oauthsecond.domain = "paraio.com"
scoold.security.oauthsecond.parameters.id = "sub"
scoold.security.oauthsecond.parameters.picture = "picture"
scoold.security.oauthsecond.parameters.email = "email"
scoold.security.oauthsecond.parameters.name = "name"
scoold.security.oauthsecond.parameters.given_name = "given_name"
scoold.security.oauthsecond.parameters.family_name = "family_name"
# Sets the string on the login button (second provider)
scoold.security.oauthsecond.provider = "Continue with Second OAuth 2.0 provider"
# Enable/disable access token delegation (second provider)
scoold.security.oauthsecond.token_delegation_enabled = falseFor the "third" OAuth 2.0 provider it's the same configuration but replace "second" with "third".
Note: If Para and Scoold are hosted both on the same server and your Para instance is not publicly accessible from
the Internet, you need to expose localhost:8080/oauth2_auth by configuring a proxy server to forward
yourdomain/oauth2_auth requests to localhost:8080/oauth2_auth. If Para is publicly accessible this step is not necessary.
This is an example guide for configuring Scoold to work with an authentication provider like Okta. The steps are similar for other providers, such as Auth0.
http://para-host:8080/oauth2_auth as a login redirect URICopy the client credentials (client id, secret) to your Scoold application.conf file:
scoold.oa2_app_id = "0oa123...."
scoold.oa2_secret = "secret"
scoold.security.oauth.authz_url = "https://${yourOktaDomain}/oauth2/v1/authorize"
scoold.security.oauth.token_url = "https://${yourOktaDomain}/oauth2/v1/token"
scoold.security.oauth.profile_url = "https://${yourOktaDomain}/oauth2/v1/userinfo"
scoold.security.oauth.scope = "openid email profile"
scoold.security.oauth.provider = "Continue with Okta"${yourOktaDomain} with your actual Okta domain name.
Restart Scoold and login with an Okta user account
This is an example guide for configuring Scoold to use Azure Active Directory (aka Microsoft Identity Platform) as its authentication provider. The steps are similar to other OAuth2.0 identity providers setup.
/oauth2_auth endpoint (make sure that
this URL is accessible from your users' devices). For development purposes http://localhost:8080/oauth2_auth
is probably sufficient.scoold.oa2_app_id
setting in your configuration.scoold.oa2_secret setting in your configuration.Fill in the configuration of Scoold:
scoold.oa2_app_id = "e538..."
scoold.oa2_secret = "secret"
scoold.security.oauth.authz_url = "https://login.microsoftonline.com/${yourAADTenantId}/oauth2/v2.0/authorize"
scoold.security.oauth.token_url = "https://login.microsoftonline.com/${yourAADTenantId}/oauth2/v2.0/token"
scoold.security.oauth.profile_url = "https://graph.microsoft.com/oidc/userinfo"
scoold.security.oauth.scope = "openid email profile"
scoold.security.oauth.provider = "Continue with AAD"Make sure to replace ${yourAADTenantId} with your actual AAD tenant ID.
LDAP authentication is initiated with a request like this POST /signin?provider=ldap&access_token=username:password.
There are several configuration options which Para needs in order to connect to your LDAP server. These are the defaults:
# minimal setup
scoold.security.ldap.server_url = "ldap://localhost:8389/"
scoold.security.ldap.base_dn = "dc=springframework,dc=org"
scoold.security.ldap.user_dn_pattern = "uid={0}"
# add this ONLY if you are connecting to Active Directory
scoold.security.ldap.active_directory_domain = ""
# extra options - change only if necessary
scoold.security.ldap.user_search_base = ""
scoold.security.ldap.user_search_filter = "(cn={0})"
scoold.security.ldap.password_attribute = "userPassword"
scoold.security.ldap.username_as_name = false
# Sets the string on the login button (PRO)
scoold.security.ldap.provider = "Continue with LDAP"
# automatic groups mapping
scoold.security.ldap.mods_group_node = ""
scoold.security.ldap.admins_group_node = ""The search filter syntax allows you to use the placeholder {0} which gets replaced with the person's username.
You can also map LDAP DN nodes to Para user groups. For example, with the following configuration:
scoold.security.ldap.mods_group_node = "ou=Moderators"
scoold.security.ldap.admins_group_node = "cn=Admins"uid=Gordon,ou=Moderators,dc=domain,dc=org will automatically become part of the mods group,
i.e. groups: "mods". Similarly, if their DN contains cn=Admins they will become administrators, i.e. groups: "admins".
To enable authentication with an Active Directory LDAP server, set scoold.security.ldap.ad_mode_enabled = true.
In this mode, the search filter defaults to (&(objectClass=user)(userPrincipalName={0})).
An alternative search filter would be (&(objectClass=user)(sAMAccountName={1})). Keep in mind that the domain you
put in the configuration is actually the UPN suffix which gets appended to the username as username@domain.com if
the supplied login username doesn't end with a domain. The domain has nothing to do with the AD domain or the location
of the AD server.
The only valid configuration properties for AD are:
user_search_filter, base_dn, server_url and active_directory_domain - everything else is ignored so don't put
it in the config file at all!
Here's a working LDAP configuration for AD:
scoold.security.ldap.ad_mode_enabled = true
scoold.security.ldap.user_search_filter = "(&(objectClass=user)(sAMAccountName={1}))"
scoold.security.ldap.base_dn = "ou=dev,dc=scoold,dc=com"
scoold.security.ldap.server_url = "ldap://192.168.123.70:389"
scoold.security.ldap.active_directory_domain = "scoold.com"For the above configuration the following logins should work, given that a user joe exists:
- joe@scoold.com + password
- joe@some-other-domain.com + password
- joe + password
As you can see the domain part is actually ignored because it is irrelevant. You cannot bind an AD user with their email.
You can bind them based on their username a.k.a. sAMAccountName. If the user has an email address where the alias is
the same as the sAMAccountName but the domain is different, then the login will succeed. If the user above has an email
joe.smith@gmail.com then the login with that email will fail because a bind is not possible,
and the LDAP search request will return no results.
The syntax for the search filter allows you to use the placeholders {0} (replaced with username@domain) and {1}
(replaced with username only).
Here's an example Active Directory configuration (note that any other settings than the ones below will be ignored):
scoold.security.ldap.server_url = "ldap://server:389"
scoold.security.ldap.active_directory_domain = "domain.com"
scoold.security.ldap.user_search_filter = "userPrincipalName={0}"
scoold.security.ldap.base_dn = "ou=dev,dc=domain,dc=com"Scoold supports authentication with a FreeIPA server over LDAP. Here's a sample configuration for the free demo instance provided by FreeIPA - ipa.demo1.freeipa.org:
scoold.security.ldap.server_url = "ldap://ipa.demo1.freeipa.org:389"
scoold.security.ldap.base_dn = "cn=users,cn=accounts,dc=demo1,dc=freeipa,dc=org"
scoold.security.ldap.user_dn_pattern = "uid={0}"manager and password Secret123.
PRO Scoold Pro can authenticate users with an internal (local) LDAP server, even if your Para backend is hosted outside of your network (like ParaIO.com). This adds an extra layer of security and flexibility and doesn't require a publicly accessible LDAP server. To enable this feature, add this to your configuration:
scoold.security.ldap.is_local = true
# required for passwordless authentication with Para
scoold.app_secret_key = "change_to_long_random_string"To print out debug information about LDAP requests, start Para with -Dlogging.level.org.springframework.ldap=DEBUG.
If you are connecting to an internal LDAP server, add the same system property to the Scoold command line.
To learn more about the settings above, read the LDAP docs for Para.
PRO
First, you have to setup Para as a SAML service provider using the config below. Then you can exchange SAML metadata with
your SAML identity provider (IDP). The SP metadata endpoint is /saml_metadata/{appid}. For example, if your Para
endpoint is paraio.com and your appid is scoold, then the metadata is available at
https://paraio.com/saml_metadata/scoold.
SAML authentication is initiated by sending users to the Para SAML authentication endpoint /saml_auth/{appid}.
For example, if your Para endpoint is paraio.com and your appid is scoold, then the user should be sent to
https://paraio.com/saml_auth/scoold. Para (the service provider) will handle the request and redirect to the SAML IDP.
Finally, upon successful authentication, the user is redirected back to https://paraio.com/saml_auth/scoold which is
also the assertion consumer service (ACS).
Note: The X509 certificate and private key must be encoded as Base64 in the configuration file. Additionally,
the private key must be in the PKCS#8 format (---BEGIN PRIVATE KEY---). To convert from PKCS#1 to PKCS#8, use this:
openssl pkcs8 -topk8 -inform pem -nocrypt -in sp.rsa_key -outform pem -out sp.pemgencerts.sh,
located in this repository:
./gencerts.sh localhost secretlocalhost.pem and private key localhost.key:
base64 localhost.key > localhost_saml_base64.key
base64 localhost.pem > localhost_saml_base64.pemThere are lots of configuration options but Para needs only a few of those in order to successfully authenticate with your SAML IDP (listed in the first rows below).
# minimal setup
# IDP metadata URL, e.g. https://idphost/idp/shibboleth
scoold.security.saml.idp.metadata_url = ""
# SP endpoint, e.g. https://paraio.com/saml_auth/scoold
scoold.security.saml.sp.entityid = ""
# SP public key as Base64(x509 certificate)
scoold.security.saml.sp.x509cert = ""
# SP private key as Base64(PKCS#8 key)
scoold.security.saml.sp.privatekey = ""
# attribute mappings (usually required)
# e.g. urn:oid:0.9.2342.19200300.100.1.1
scoold.security.saml.attributes.id = ""
# e.g. urn:oid:0.9.2342.19200300.100.1.3
scoold.security.saml.attributes.email = ""
# e.g. urn:oid:2.5.4.3
scoold.security.saml.attributes.name = ""
# extra options (optional)
# this is usually the same as the "EntityId"
scoold.security.saml.sp.assertion_consumer_service.url = ""
scoold.security.saml.sp.nameidformat = ""
# IDP metadata is usually automatically fetched
scoold.security.saml.idp.entityid = ""
scoold.security.saml.idp.single_sign_on_service.url = ""
scoold.security.saml.idp.x509cert = ""
scoold.security.saml.security.authnrequest_signed = false
scoold.security.saml.security.want_messages_signed = false
scoold.security.saml.security.want_assertions_signed = false
scoold.security.saml.security.want_assertions_encrypted = false
scoold.security.saml.security.want_nameid_encrypted = false
scoold.security.saml.security.sign_metadata = false
scoold.security.saml.security.want_xml_validation = true
scoold.security.saml.security.signature_algorithm = ""
scoold.security.saml.attributes.firstname = ""
scoold.security.saml.attributes.picture = ""
scoold.security.saml.attributes.lastname = ""
scoold.security.saml.domain = "paraio.com"
# Sets the string on the login button
scoold.security.saml.provider = "Continue with SAML"Scoold Pro can authenticate users with an internal (local) SAML provider, even if your Para backend is hosted outside of your network (like ParaIO.com). This adds an extra layer of security and flexibility and doesn't require your SAML endpoints to be publicly accessible. To enable this feature, add this to your configuration:
scoold.security.saml.is_local = true
# required for passwordless authentication with Para
scoold.app_secret_key = "change_to_long_random_string"PRO Para supports custom authentication providers through its "passwordless" filter. This means that you can send any user info to Para and it will authenticate that user automatically without passwords. The only verification done here is on this secret key value which you provide in your Scoold Pro configuration file:
scoold.app_secret_key = "change_to_long_random_string"The JWT must contain the following claims:
email - user's email addressname - user's display nameidentifier - a unique user id in the format custom:123appid - the app id (optional)The JWT is signed with the value of scoold.app_secret_key and should have a short validity period (e.g. 10 min).
The JWT should also contain the claims iat and exp and, optionally, nbf. Supported signature algorithms for the JWT
are HS256, HS384 or HS512.
Once you generate the JWT on your backend (step 4 above), redirect the successful login request back to Scoold:
GET https://scoold-host/signin/success?jwt=eyJhbGciOiJIUzI1NiI..&passwordless=trueThe UI button initiating the authentication flow above can be customized like this:
scoold.security.custom.provider = "Continue with Acme Co."
# location of your company's login page
scoold.security.custom.login_url = ""There's an example login page implementing this sort of authentication.
You can configure Scoold to redirect users straight to the identity provider when they click the "Sign in" button. This feature is disabled by default:
scoold.redirect_signin_to_idp = falsescoold.is_default_space_public = false,
unauthenticated users will be sent directly to the IDP without seeing the "Sign in" page or any other page on Scoold.
You can also configure users to be redirected to an external location when they log out:
scoold.signout_url = "https://homepage.com"PRO Scoold Pro has a dedicated SCIM API endpoint for automatic user provisioning at http://localhost:8000/scim.
This allows you to manage Scoold Pro users externally, on an identity management platform of your choice.
Here's an example configuration for enabling SCIM in Scoold:
scoold.scim_enabled = true
scoold.scim_secret_token = "secret"
scoold.scim_map_groups_to_spaces = true
scoold.scim_allow_provisioned_users_only = falseGroup it receives from your identity platform and assign the
members of that group to the corresponding space. Just make sure that groups are pushed from your IdM platform to Scoold.
If scoold.scim_allow_provisioned_users_only = true, user accounts which have not been SCIM-provisioned will be blocked
even if those users are members of your identity pool. This allows system administrators to provision a subset of the
user pool in Scoold.
Important: When users are provisioned from a SCIM client (Azure AD, Okta, OneLogin, etc.) ensure that the SCIM
userName attribute is unique. This means that when a SCIM client sends an update to Scoold Pro,
the user will be matched based on their userName.
You can also map groups from your identity pool to Para user groups. For example:
scoold.security.scim.mods_group_equivalent_to = "Moderators"
scoold.security.scim.admins_group_equivalent_to = "Administrators"Spaces are a way to organize users and questions into isolated groups. There's a default space, which is publicly accessible by default. Each user can belong to one or more spaces, but a question can only belong to a single space. Permission to access a space is given by an administrator. You can bulk edit users' spaces and also move a question to a different space.
By default there's a public "default" space where all questions go. When you create a new space and assign users to it
they will still see all the other questions when they switch to the "default" space. To make the default space private
set scoold.is_default_space_public = false.
PRO In Scoold Pro, you can create as many space as you need. The open source version is limited to 10 spaces. Also in PRO you can automatically assign multiple spaces to new users, whereas in the OSS version you can only assign one.
If you want to assign space(s) to new users automatically, add this to your configuration:
# put space ids here, the "scooldspace:" prefix is optional
scoold.auto_assign_spaces = "my-space-one,my-other-space"scoold.auto_assign_spaces = "default,My Custom Space"scoold.reset_spaces_on_new_assignment = truefalse and you have configured Scoold to assign custom spaces to new users
(e.g. "my-space-1" and "my-space-2"), those users will become members of "my-space-1", "my-space-2" and the
default space. If the value is true, the default space gets overwritten by the custom spaces you have specified in
scoold.auto_assign_spaces and new users will only be members of "my-space-1" and "my-space-2".
This is turned on for all users authenticated with LDAP, SAML or OAuth 2.0.
Alternatively, Scoold Pro can have spaces and roles delegated to users from an OpenID Connect/OAuth 2.0 identity provider.
You have to enable access token delegation with scoold.security.oauth.token_delegation_enabled = true and Scoold Pro will
try to obtain spaces from a custom attribute like spaces. Such custom attributes can be configured in the IDP and
pushed to clients (Scoold Pro) embedded in access tokens. If you want to change the name of the custom attribute supplied
by your IDP, set scoold.security.oauth.spaces_attribute_name, which by default is equal to spaces. The value of that
attribute should contain comma-separated list of spaces. If the spaces pushed from the IDP do not exist, Scoold will
create them for you.
Webhooks are enabled by default in Scoold. To disable this functionality set scoold.webhooks_enabled = false. If you
are self-hosting Para, you need to also enable webhooks there using the same configuration option.
You can add or remove webhooks in the "Administration" page. Webhooks can also be disabled and they will be
disabled automatically when the target URL doesn't respond to requests from Para.
Para will notify your target URL with a POST request containing the payload and a X-Webhook-Signature header. This
header should be verified by the receiving party by computing Base64(HmacSHA256(payload, secret)).
The standard events emitted by Scoold are:
question.create - whenever a new question is createdquestion.close - whenever a question is closedanswer.create - whenever a new answer is createdanswer.accept - whenever an answer is acceptedreport.create - whenever a new report is createdcomment.create - whenever a new comment is createduser.signup - whenever a new user is createdrevision.restore - whenever a revision is restoreduser.ban - Pro whenever a user is banneduser.mention - Pro whenever a user is mentionedquestion.like - Pro whenever a question is favoritedIn addition to the standard event, Para also sends webhooks to the following core (CRUD) events, for all object types:
create, update, delete, createAll, updateAll, deleteAll.
You can subscribe to any of these custom events in Scoold using the REST API like so: ```POST /api/webhooks { "targetUrl": "https://myurl", "typeFilter": "revision", "urlEncoded": false, "create": true, "update": false, "delete": false, "createAll": true, "updateAll": false, "deleteAll": false, "customEvents": ["revision.create"] }
This will create a new custom event `revision.create` which will fire whenever a new revision is created.
This makes it easy to integrate Scoold with services like Zapier because it implements the
[RESTHooks](https://resthooks.org/) best practices.
For more details about webhooks, please read the [Para docs on webhooks](https://paraio.org/docs/#011-webhooks).
## Session management and duration
By default, only one session is allowed per user/browser. When a user logs in from one device, they will automatically be
logged out from every other device. This can be disabled to allow multiple simultaneous sessions with:
```ini
scoold.security.one_session_per_user = falseUser session cookies in Scoold expire after 24h. To change the session duration period to 6h for example, set
scoold.session_timeout = 21600 (6h in seconds) and restart. In 6h the Scoold authentication cookie will expire and so
will the access token (JWT) inside the cookie.
You can restrict signups only to users from a particular identity domain, say acme-corp.com. To do so, set the
following configuration property:
scoold.approved_domains_for_signups = "acme-corp.com"john@acme-corp.com will be allowed to login (the identity provider is irrelevant), but user
bob@gmail.com will be denied access.
PRO In Scoold Pro, this setting can also contain a comma-separated list of identity domains:
scoold.approved_domains_for_signups = "acme-corp.com,gmail.com"You can specify the user with administrative privileges in your application.conf file:
scoold.admins = "joe@example.com"scoold.admins = "joe@example.com,fb:1023405345366,gh:1234124"If you remove users who are already admins from the list of admins scoold.admins, they will be demoted to regular
users. Similarly, existing regular users will be promoted to admins if they appear in the list above.
PRO This feature is enabled with scoold.anonymous_posts_enabled = true. It allows everyone to ask questions and write
replies, without having a Scoold account. Posting to the "Feedback" section will also be open without requiring users
to sign in. This feature is disabled by default.
People may wish to make their profile details anonymous from the Settings page. To allow this option set:
scoold.profile_anonimity_enabled = trueYou can enable or disable the "Feedback" page where people can discuss topics about the website itself or submit general
feedback. This section is disabled by default and can be activated with scoold.feedback_enabled = true.
PRO You can enable this feature by setting scoold.mathjax_enabled = true. Then you can use MathML expressions by surrounding
them with $$ signs, e.g. $$ \frac {1}{2} $$ By default, MathJax is disabled.
The Prism syntax highlighter is included and it supports many different languages. You need to specify the language for each code block if you want the highlighting to be more accurate (see all supported languages). For example:
```csharp
var dict = new Dictionary<string>();
```
PRO Files can be uploaded to the local file system or to cloud storage. File uploads are enabled by default in Scoold Pro.
To disable file uploads altogether set scoold.uploads_enabled = false. To protect uploaded files from unauthenticated
access, set scoold.uploads_require_auth = true.
To upload a file just drag & drop the file onto the post editor area. A link will automatically appear when the upload is finished. Uploads can fail either because their size is too large or because their format is not in the white list of permitted formats (documents, images, archives, audio or video). You can extend the list of permitted file types by configuring:
scoold.allowed_upload_formats = "yml,py:text/plain,json:application/json"extension:mime_type, the default text/plain is used when serving these
files.
By default, the size of uploaded files is unrestricted. To limit the maximum size of uploads, set the following Spring Boot system properties:
spring.servlet.multipart.max-file-size = "2MB"
spring.servlet.multipart.max-request-size = "10MB"Scoold Pro also allows users to capture and upload video and audio from their input devices (mic/webcam). This functionality is enabled by default:
scoold.media_recording_allowed = trueProfile pictures (avatars) can also be changed by dragging a new image on top of the existing profile picture on a
user's /profile page. For best results, use a square image here.
Local file storage is used by default. To configure the directory on the server where files will be stored, set:
scoold.file_uploads_dir = "uploads"To use S3 for file storage, specify the name of the S3 bucket where you want the files to be uploaded. AWS credentials and region settings are optional as they can be picked up from the environment automatically.
# required
scoold.s3_bucket = ""
# path within the bucket (object prefix)
scoold.s3_path = "uploads"
# these are optional
scoold.s3_region = ""
scoold.s3_access_key = ""
scoold.s3_secret_key = ""To use Azure Blob storage for storing uploaded files, first you'll need to create a storage account and get a SAS URL and token. Scoold Pro will need full permissions to your storage container so it's best that you dedicate a container just for Scoold files.
# required
scoold.blob_storage_account = ""
scoold.blob_storage_token = ""
# name of the container
scoold.blob_storage_container = ""
# path prefix within a container (subfolder)
scoold.blob_storage_path = "uploads"This feature is available in both Scoold and Scoold Pro. You can configure Scoold to upload custom profile pictures to a cloud-based image hosting service like Imgur or Cloudinary. In Scoold Pro, avatars are uploaded to the configured storage provider, but by configuring Imgur or Cloudinary for avatars, you will essentially change where avatars are stored and served from.
To use Imgur for storing images, specify your Imgur API client id:
scoold.imgur_client_id = "x23e8t0askdj"
scoold.avatar_repository = "imgur"To use Cloudinary for storing images, specify your Cloudinary API client id:
scoold.cloudinary_url = "cloudinary://123456:abcdefaddd@scoold"
scoold.avatar_repository = "cloudinary"You must create several presets on your cloudinary account:
- avatar (upload preset): for processing when receiving a file (example: c_thumb,g_face,h_404,q_auto:good,w_404,z_0.4)
- square25: for the display in 25x25 format (example: c_scale,h_25,q_auto:eco,w_25)
- square32: for displaying in 32x32 format (example: c_scale,h_32,q_auto:eco,w_32)
- square50: for displaying in 50x50 format (example: c_scale,h_50,q_auto:good,w_50)
- square127: for displaying in 127x127 format (example: c_scale,h_127,q_auto:good,w_127)
- profile: for displaying in 404x404 format (example: c_scale,h_404,q_auto:good,w_404)
PRO Scoold Pro integrates with Slack on a number of levels. First, Scoold users can sign in with Slack. They can also use slash commands to search and post questions. Also Scoold can notify Slack users when they are mentioned on Scoold. Finally, Scoold allows you to map spaces to Slack workspaces or channels. By default, each Slack workspace (team) is mapped to a single Scoold space when people sign in with Slack.
Important: Most of the Slack operations require a valid Slack ID stored in Scoold which enables the mapping of Slack users to Scoold accounts and vice versa. Slack IDs are set automatically when a Scoold user signs in with Slack.
The integration endpoint for Slack is /slack - this is where Scoold will accept and process requests from Slack.
To enable the Slack integration you need to register for a Slack app first and set scoold.sl_app_id and scoold.sl_secret.
Here are the configuration properties for Slack:
# Slack OAuth2 client id
scoold.sl_app_id = ""
# Slack OAuth2 secret
scoold.sl_secret = ""
scoold.slack.app_id = "SHORT_APPID"
scoold.slack.map_workspaces_to_spaces = true
scoold.slack.map_channels_to_spaces = false
scoold.slack.post_to_space = "workspace|scooldspace:myspace|default"
scoold.slack.notify_on_new_question = true
scoold.slack.notify_on_new_answer = true
scoold.slack.notify_on_new_comment = true
scoold.slack.dm_on_new_comment = false
scoold.slack.default_question_tags = "via-slack"
scoold.slack.auth_enabled = trueSetting scoold.slack.map_channels_to_spaces will ask for additional permissions, namely channels:read and groups:read.
On sign in, Scoold will read all your channels and create spaces from them. The workspace space is always created if
scoold.slack.map_workspaces_to_spaces = true, which is the default setting.
When creating questions from Slack they are posted to the channel workspace by default, if
scoold.slack.map_channels_to_spaces is enabled. For example, in this case, for a team "My Team" and channel "chan",
your space will become "My Team #chan". This is controlled by scoold.slack.post_to_space which is blank by default.
If you set it to workspace, then questions will be posted to the "My Team" space. Or you could set a specific Scoold
space to post to with scoold.slack.post_to_space = "scooldspace:myspace". If the value is default then all questions
posted from Slack will go to the default space.
You can also create answers to questions from Slack, either from the message action button or by typing in the
/scoold ask command. This requires the URL of a specific question you wish to answer.
Clicking the "Ask on Scoold" message action will also save the full message thread on Scoold. The action will create a new question from the first message of the thread and save each reply as an answer on Scoold.
When scoold.slack.dm_on_new_comment is enabled, Scoold will send a direct message notification to the author of
the post on which somebody commented. By default, DMs are turned off and the notification is sent to the channel instead.
Slack authentication can be disabled with scoold.slack.auth_enabled = false and the "Continue with Slack" button
will be hidden away.
Typing in /scoold help gives you a list of commands available:
/scoold - Interact with your Scoold server/scoold ask [text] Ask a question directly, first sentence becomes the title. Example: /scoold ask How does this work? @john I'm having troubles with.../scoold answer [question URL] [answer] Answer a question directly. Example: /scoold answer https://host/question/123 This is my answer to your question, @john./scoold search [query] Search for questions. Example: /scoold search solution AND quick*/scoold search-people [query] Search for people. Example: /scoold search-people John*/scoold search-tags [query] Search for tags. Example: /scoold search-tags solution*/scoold version Get version information for Scoold and Para./scoold whoami Get information for your Scoold account./scoold stats Get general statistics.Here are the interactive message actions which are currently implemented:
- create_question - "Ask on Scoold", Creates a new question on Scoold directly from a chat message.
- create_question_dialog - "Edit & ask on Scoold", Opens up a dialog to edit question before posting.
- create_answer_dialog - "Answer on Scoold", Opens up a dialog to edit your answer before posting.
These allow you to perform actions from any channel and best of all, these can turn any chat message into a question or answer.
If you get an error "User not authorised to open dialogs" it means that your Scoold user is not logged in via Slack and Scoold doesn't have a Slack access token on record. Simply log into Scoold with Slack and the error should go away.
PRO Scoold Pro also integrates with Mattermost. Scoold users can sign in with Mattermost, use slash commands to interact with Scoold and also get in-chat notification for mentions and new posts on Scoold. Scoold allows you to map spaces to Mattermost teams or channels. By default, each Mattermost team is mapped to a single Scoold space when people sign in with Mattermost.
Important: Most of the Mattermost operations require a valid Mattermost ID stored in Scoold which enables the mapping of Mattermost users to Scoold accounts and vice versa. Mattermost IDs are set automatically when a Scoold user signs in with Mattermost.
The integration endpoint for Mattermost is /mattermost - this is where Scoold will accept and process requests from
Mattermost. To enable the Mattermost integration you must create a new OAuth 2.0 app in Mattermost's System
Console. Get the app's credentials and add them to your Scoold configuration as scoold.mm_app_id and scoold.mm_secret.
If you just want the Scoold-Mattermost integration working and don't want your users to login with Mattermost, you have the option to disable the Mattermost authentication button on the sign in page:
scoold.mattermost.auth_enabled = falseHere are the configuration properties for Mattermost:
# Mattermost OAuth2 client id
scoold.mm_app_id = ""
# Mattermost OAuth2 client secret
scoold.mm_secret = ""
scoold.mattermost.server_url = "http://localhost:8065"
scoold.mattermost.bot_username = "scoold"
scoold.mattermost.bot_icon_url = "http://localhost:8000/images/logowhite.png"
scoold.mattermost.map_workspaces_to_spaces = true
scoold.mattermost.map_channels_to_spaces = false
scoold.mattermost.post_to_space = "workspace|scooldspace:myspace|default"
scoold.mattermost.notify_on_new_question = true
scoold.mattermost.notify_on_new_answer = true
scoold.mattermost.notify_on_new_comment = true
scoold.mattermost.dm_on_new_comment = false
scoold.mattermost.default_question_tags = "via-mattermost"Note: Mattermost does not support message actions like in Slack. This means that you can't create a question from
a any chat message. The reply dialog box can be opened from a "Reply" button under each question notification message or
via the /scoold answer-form command.
The dialog box for new questions is opened via the new slash command /scoold ask-form.
All the other slash commands and notifications work just like with Slack and are described above. The Mattermost integration will automatically create a slash command for each channel linked to Scoold on the admin page.
When scoold.mattermost.dm_on_new_comment is enabled, Scoold will send a direct message notification to the author of
the post on which somebody commented. By default, DMs are turned off and the notification is sent to the channel instead.
You can also save a full message thread on Scoold with the command /scoold save {thread_link} - this will create a new
question from the first message of the thread and save each reply as an answer on Scoold.
PRO Scoold Pro also integrates with Microsoft Teams. Scoold users can sign in with a Microsoft account, use bot commands to interact with Scoold and also get in-chat notification for mentions and new posts on Scoold. Scoold allows you to map spaces to teams or channels. By default, each team in MS Teams is mapped to a single Scoold space when people sign in with Microsoft.
Important: Most of the Teams operations require a valid Microsoft ID stored in your Scoold profile which enables the mapping of Teams users to Scoold accounts and vice versa. Microsoft IDs are added to each profile automatically when a Scoold user signs in with Microsoft.
The integration endpoint for Teams is /teams - this is where Scoold will accept and process requests from
MS Teams. To enable the Teams integration you first need to create a new bot for your app.
After creating the bot, take note of its ID and client secret and add those to your Scoold configuration file.
Then sideload (upload) the Scoold.zip app package in the Teams Developer Portal.
The app package can be downloaded from the Administration page after your bot has been created.
Also set scoold.ms_app_id and scoold.ms_secret as you normally would for an OAuth2 authentication with Microsoft.
Note: Clicking the "Ask on Scoold" message extension button will also save the full message thread on Scoold. The action will create a new question from the first message of the thread and save each reply as an answer on Scoold.
Here are the configuration properties for MS Teams:
# Microsoft OAuth2 client id
scoold.ms_app_id = ""
# Microsoft OAuth2 secret
scoold.ms_secret = ""
scoold.teams.bot_id = ""
scoold.teams.bot_secret = ""
scoold.teams.map_workspaces_to_spaces = true
scoold.teams.map_channels_to_spaces = false
scoold.teams.post_to_space = "workspace|scooldspace:myspace|default"
scoold.teams.notify_on_new_question = true
scoold.teams.notify_on_new_answer = true
scoold.teams.notify_on_new_comment = true
scoold.teams.dm_on_new_comment = false
scoold.teams.default_question_tags = "via-teams"You can type @Scoold help to get a list of all supported actions. All the other bot commands and notifications work
just like with Slack and Mattermost, described above. A bot registration is required for the Teams integration
and it has to be created manually from the Teams Developer Portal.
When scoold.teams.dm_on_new_comment is enabled, Scoold will send a direct message notification to the author of
the post on which somebody commented. By default, DMs are turned off and the notification is sent to the channel instead.
If you wish to hide the Microsoft login button "Continue with Microsoft", you can do it by adding this to your configuration:
scoold.teams.auth_enabled = falseScoold will notify the channels where you have it installed, whenever a new question or answer is created, and also
whenever a user is mentioned. To install the application on multiple channels go to the Administration page and click
one of the "Add to Slack/Mattermost/Teams" buttons for each channel where you wish to get notifications. You can receive
notification on up to 10 channels simultaneously. Notifications for new posts will go to the channel associated with the
space in which the post was created. For example, when using Slack, if scoold.slack.map_workspaces_to_spaces is true,
and a question is created in space "Team1 #general", Scoold will search for webhook registrations matching that
team/channel combination and only send a notification there. Direct message webhooks will be used only if there's no
space-matching channel found.
This works if you have enabled scoold.posts_need_approval. When a new question or answer is created by a user with less
reputation than the threshold, a notification message will be sent to Slack/Mattermost/Teams, giving you the option to
either approve or delete that post. The action can only be performed by moderators.
The recommended way for enabling HTTPS with your own SSL certificate in a self-hosted environment is to run a proxy server like NGINX in front of Scoold and Para. As an alternative you can use Apache or Lighttpd.
:8080:8000As an alternative, you can enable SSL and HTTP2 directly in Scoold:
1. Run the script gencerts.sh to generate the required self-signed certificates
echo "scoold.local" | sudo tee -a /etc/hosts
./gencerts.sh scoold.local secretScooldRootCA.(crt,key,pem), scoold.local.(crt,key,pem) as well as a
Java Keystore file scoold-keystore.p12 and a Truststore file scoold-truststore.p12.
Optionally, you can run generate the server certificates using an existing RootCA.pem and RootCA.key files like so:
./gencerts.sh para.local secret /path/to/ca/RootCAjava -jar -Dconfig.file=./application.conf \
-Dserver.ssl.key-store-type=PKCS12 \
-Dserver.ssl.key-store=scoold-keystore.p12 \
-Dserver.ssl.key-store-password=secret \
-Dserver.ssl.key-password=secret \
-Dserver.ssl.key-alias=scoold \
-Dserver.ssl.enabled=true \
-Dserver.http2.enabled=true \
scoold-*.jarScooldRootCA.crt by importing it in you OS keyring or browser (check Google for instructions).https://scoold.local:8000First of all, configure the DNS records for your domain to point to the IP address where Scoold is hosted.
sudo apt-get install nginx certbot python-certbot-nginxsudo certbot --nginx8000 and only allow ports 80 and 443.
ufw allow 'Nginx Full' && sudo ufw enable80 and 443 to localhost:8000
location / {
proxy_pass http://127.0.0.1:8000;
proxy_redirect http:// $scheme://;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
proxy_set_header Host $http_host;
}That's it! If the Certbot validation above fails, your DNS is not configured properly or you have conflicting firewall rules. Refer to this article for more details.
You can enable mTLS between Scoold and Para, as well as between Scoold and a proxy like Nginx. There are two ways to do that: - each service can trust each other's public certificate - each service can use a TLS certificate signed by a CA which is trusted by all services
To go the first route, execute the getcerts.sh script as shown above. You may need to run it once for Scoold and once
for Nginx, unless Nginx has its own certificate already. Then add the Nginx certificate to the Truststore.
./gencerts.sh scoold.local secret
keytool -v -importcert -file /path/to/nginx_public_cert.pem -alias nginx -keystore scoold-nginx-truststore.p12 -storepass secret -nopromptserver_name scoold-pro.local;
listen 443 ssl http2;
location / {
proxy_pass https://scoold.local:8000;
proxy_redirect http:// $scheme://;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
proxy_set_header Host $http_host;
proxy_ssl_certificate /path/to/nginx_public_cert.pem;
proxy_ssl_certificate_key /path/to/nginx_public_cert.key;
proxy_ssl_trusted_certificate /path/to/RootCA.pem;
proxy_ssl_verify on;
proxy_ssl_verify_depth 2;
}If you want to trust the Root CA instead, the steps are similar but in the Nginx configuration use this line:
ssl_client_certificate /path/to/RootCA.pem;scoold-truststore.p12 which should already contain the Root CA.
To go the first route, execute the getcerts.sh script as shown above for both Scoold and Para. Then create a Truststore
for each service which contains the certificate of the other.
./gencerts.sh scoold.local secret
./gencerts.sh para.local secret
keytool -v -importcert -file scoold.local.pem -alias scoold -keystore para-scoold-truststore.p12 -storepass secret -noprompt
keytool -v -importcert -file para.local.pem -alias para -keystore scoold-para-truststore.p12 -storepass secret -nopromptIf you want to trust the Root CA instead, the steps are similar but using the previously generated Truststores
- scoold-truststore.p12 and para-truststore.p12 respectively, which should already contain the Root CA.
For end-to-end encryption of traffic, you can enable mTLS between your TLS-terminating proxy (like nginx), Scoold and Para.
In some rare cases, your Scoold server may be behind more than one proxy server. In these cases you have configuration like this:
scoold.host_url = "http://192.168.3.4:8000"
scoold.host_url = "http://192.168.3.4:8080"scoold.rewrite_inbound_links_with_fqdn = "https://public-scoold-domain.com"PRO You can choose to enable periodic summary emails for all users in Scoold or allow them to opt-in for these messages.
By default summary emails are disabled and users can unsubscribe if they are enabled by admins.
A summary email contains all new questions for a past period of time (daily, weekly). Admins can enable summary emails
for everyone from the Settings page if scoold.summary_email_controlled_by_admins = true. If that parameter is false
each person (by default) controls whether they want to receive summary emails or not.
The period for which a summary report is generated is controlled by:
scoold.summary_email_period_days = 21 to 30 days, where 2 means "every other day", 7 means "every week".
The summary email contains a list of the top 25 recent questions. For more questions set scoold.summary_email_items = 30.
PRO In Scoold Pro, you can mention anyone in a question, answer or comment with @Name. A popup menu will appear once you
start typing after @ giving you a list of names to choose from. The selected user will be mentioned with a special
mention tag in the form of @<userID|John Doe>. You can edit the name part of that tag (after |) but nothing else,
if you want the mention to work. You can mention up to 10 people in a post.
Users can opt-in to receive email notifications when they are mentioned or that can be switched on/off by admins. For the latter option set:
scoold.mention_emails_controlled_by_admins = trueIn certain cases, there may be lots of people with identical or similar names within a team which could make it difficult to tell them apart when trying to mention them. For such scenarios, there is an option to show additional details for each user, like username and tags. This is enabled like so:
scoold.user_autocomplete_details_enabled = trueScoold attaches several security headers to each response. These can be enabled or disabled with the following configuration properties:
# Strict-Transport-Security
scoold.hsts_header_enabled = true
# X-Frame-Options
scoold.framing_header_enabled = true
# X-XSS-Protection
scoold.xss_header_enabled = true
# X-Content-Type-Options
scoold.contenttype_header_enabled = true
# Referrer-Policy
scoold.referrer_header_enabled = trueBy default, votes expire after a certain period, meaning the same user can vote again on the same post (after 30 days by default). Votes can also be amended within a certain number of seconds (30s by default). There are two configurable parameters which allow you to modify the length of those periods:
scoold.vote_locked_after_sec = 30
scoold.vote_expires_after_sec = 2592000There are a number of settings that let you customize the appearance of the website without changing the code.
scoold.fixed_nav = false
scoold.show_branding = true
scoold.logo_url = "https://static.scoold.com/logo.svg"
scoold.logo_width = 90
# footer HTML - add your own links, etc., escape double quotes with \"
scoold.footer_html = "<a href=\"https://my.link\">My Link</a>"
# show standard footer links
scoold.footer_links_enabled = true
# favicon image location
scoold.favicon_url = "/favicon.ico"
# add your own external stylesheets
scoold.external_styles = "https://mydomain.com/style1.css, https://mydomain.com/style2.css"
# appends extra CSS rules to the main stylesheet
scoold.inline_css = ""
# edit the links in the footer of transactional emails
scoold.emails_footer_html = ""
# change the logo in transactional emails
scoold.small_logo_url = "https://scoold.com/logo.png"
# enable/disable dark mode
scoold.dark_mode_enabled = true
# enabled/disable Gravatars
scoold.gravatars_enabled = true
# pattern of default image of Gravatars (https://fr.gravatar.com/site/implement/images/)
scoold.gravatars_pattern = "retro"
# custom navbar links
scoold.navbar_link1_url = ""
scoold.navbar_link2_url = ""
scoold.navbar_link1_text = "Link1"
scoold.navbar_link2_text = "Link2"
scoold.navbar_link1_target = "_self"
scoold.navbar_link2_target = "_self"
# custom navbar menu links (shown to logged in users)
scoold.navbar_menu_link1_url = ""
scoold.navbar_menu_link2_url = ""
scoold.navbar_menu_link1_text = "Menu Link1"
scoold.navbar_menu_link2_text = "Menu Link2"
scoold.navbar_menu_link1_target = "_self"
scoold.navbar_menu_link2_target = "_self"
# default email notification toggles for all users
scoold.favtags_emails_enabled = false
scoold.reply_emails_enabled = false
scoold.comment_emails_enabled = false
# comment input box toggle
scoold.always_hide_comment_forms = truePRO In Scoold Pro, you can change the logo of the website just by dragging and dropping a new image of your choice.
If you wish to add just a few simple CSS rules to the <head> element, instead of replacing the whole stylesheet,
simply add them as inline CSS:
scoold.inline_css = ".scoold-logo { width: 100px; }"You can set a short welcome message for unauthenticated users which will be displayed on the top of the page and it
can also contain HTML (use only single quotes or escape double quotes \\\"):
scoold.welcome_message = "Hello and welcome to <a href='https://scoold.com'>Scoold</a>!"scoold.welcome_message_onlogin = "<h2>Welcome back <img src=\\\"{{user.picture}}\\\" width=30> <b>{{user.name}}</b>!</h2>"Profile object of the logged in user.
For a list of available user properties, take a look at the
Profile
and Sysprop
classes.
There are a total of 4 slots for external links in the navbar area - two links publicly visible can go in the navbar and another two links can go in the navbar menu, shown only to logged in users. Here's how to set a private link in the navbar menu:
scoold.navbar_menu_link1_url = "https://homepage.com"
scoold.navbar_menu_link1_text = "Visit my page"If you want to completely customize the frontend code, clone this repository and edit the files you want:
src/main/resources/templates/src/main/resources/static/styles/src/main/resources/static/scripts/src/main/resources/static/images/src/main/resources/themes/In Scoold Pro, you don't have access to the files above but you can purchase the Pro with Source code license, for full customization capability.
Also, please refer to the documentation for Spring Boot and Spring MVC.
Some countries have laws that require explicit cookie consent (e.g. GDPR, CCPA). Scoold can be integrated with Osano's cookie consent script to enable the consent popup for compliance with those laws. Here's the configuration which enables cookie consent:
scoold.cookie_consent_required = true
scoold.external_styles = "https://cdn.jsdelivr.net/npm/cookieconsent@3/build/cookieconsent.min.css"
scoold.external_scripts.bypassconsent1 = "https://cdn.jsdelivr.net/npm/cookieconsent@3/build/cookieconsent.min.js"
scoold.external_scripts.bypassconsent2 = "d2luZG93LmNvb2tpZWNvbnNlbnQuaW5pdGlhbGlzZSh7CiAgInBhbGV0dGUiOiB7CiAgICAicG9wdXAiOiB7CiAgICAgICJiYWNrZ3JvdW5kIjogIiM0NDQ0NDQiCiAgICB9LAogICAgImJ1dHRvbiI6IHsKICAgICAgImJhY2tncm91bmQiOiAiIzc3Nzc3NyIKICAgIH0KICB9LAogICJ0aGVtZSI6ICJjbGFzc2ljIiwKICAicG9zaXRpb24iOiAiYm90dG9tLWxlZnQiLAogICJ0eXBlIjogIm9wdC1pbiIsCiAgIm9uU3RhdHVzQ2hhbmdlIjogZnVuY3Rpb24ocyl7bG9jYXRpb24ucmVsb2FkKCk7fQp9KTs="window.cookieconsent.initialise({
"palette": {
"popup": {
"background": "#444444"
},
"button": {
"background": "#777777"
}
},
"theme": "classic",
"position": "bottom-left",
"type": "opt-in",
"onStatusChange": function(s){location.reload();}
});"onStatusChange": function(s){location.reload();} at the end.
Enabling cookie consent will automatically disable all external scripts (like Google Analytics, etc.), until the user gives their explicit consent.
Note: Any other script can be used instead, as long as it set a cookie cookieconsent_status = "allow".
The REST API can be enabled with the following configuration:
scoold.api_enabled = true
# A random string min. 32 chars long
scoold.app_secret_key = "change_to_long_random_string"/api/* and the OpenAPI documentation and console are located at /apidocs.
API keys can be generated from the "Administration" page and can be made to expire after a number of hours or never
(validity period = 0). Keys are in the JWT format and signed with the secret defined in scoold.app_secret_key.
API keys can also be generated with any JWT library. The body of the key should contain the iat, appid and exp
claims and must be signed with the secret scoold.app_secret_key.
Note: The Scoold API also accepts Para "super" tokens (manually generated) or JWTs generated using the Para CLI tool.
You can use the public endpoint http://localhost:8000/api to check the health of the server. A GET /api will
return 200 if the server is healthy and connected to Para, otherwise status code 500 is returned.
The response body is similar to this:
{
"healthy": true,
"message": "Scoold API, see docs at http://localhost:8000/apidocs",
"pro": false
}API clients can be auto-generated using Swagger Codegen. You can also open the API schema file in the Swagger Editor and generate the clients from there.
You can get support here by submitting an issue. Also you can head over to the Gitter chat room for help. Issues related to Scoold Pro must be reported to Erudika/scoold-pro. Paid/priority support is also available.
scoold tagpara tag on Stack OverflowYou can translate Scoold to your language by copying the English language file and translating it. When you're done, change the file name from "lang_en.properties" to "lang_xx.properties" where "xx" is the language code for your locale. Finally, open a pull request here.
| Language | File | Progress |
|---|---|---|
| Albanian | lang_sq.properties | 0% |
| Arabic | lang_ar.properties |  (Google Translate) |
| Belarusian | lang_be.properties | 0% |
| Bulgarian | lang_bg.properties | |
| Catalan | lang_ca.properties | 0% |
| Chinese (Traditional) | lang_zh_tw.properties | Thanks Kyon Cheng! |
| Chinese (Simplified) | lang_zh_cn.properties | Thanks Kyon Cheng! |
| Croatian | lang_hr.properties | 0% |
| Czech | lang_cs.properties | 0% |
| Danish | lang_da.properties | Thanks @viking1972! |
| Dutch | lang_nl.properties | Thanks Jan Halsema! |
| English | lang_en.properties | |
| Estonian | lang_et.properties | 0% |
| Farsi | lang_fa.properties | Thanks Sadegh G. Shohani! |
| Finnish | lang_fi.properties | 0% |
| French | lang_fr.properties | Thanks Charles Maheu! |
| German | lang_de.properties | Thanks Patrick Gäckle! |
| Greek | lang_el.properties | 0% |
| Hebrew | lang_iw.properties | Thanks David A. |
| Hindi | lang_hi.properties | Thanks Rakesh Gopathi! |
| Hungarian | lang_hu.properties | 0% |
| Icelandic | lang_is.properties | 0% |
| Indonesian | lang_in.properties | 0% |
| Irish | lang_ga.properties | 0% |
| Italian | lang_it.properties | 0% |
| Japanese | lang_ja.properties | Thanks Mozy Okubo! |
| Korean | lang_ko.properties | Thanks HyunWoo Jo! |
| Lithuanian | lang_lt.properties | 0% |
| Latvian | lang_lv.properties | 0% |
| Macedonian | lang_mk.properties | 0% |
| Malay | lang_ms.properties | 0% |
| Maltese | lang_mt.properties | 0% |
| Norwegian | lang_no.properties | 0% |
| Polish | lang_pl.properties | 0% |
| Portuguese | lang_pt.properties | Thanks Karina Varela! |
| Romanian | lang_ro.properties | 0% |
| Russian | lang_ru.properties | Thanks Vladimir Perevezentsev! |
| Serbian | lang_sr.properties | 0% |
| Slovak | lang_sk.properties | 0% |
| Slovenian | lang_sl.properties | 0% |
| Spanish | lang_es.properties | Thanks Trisha Jariwala! |
| Swedish | lang_sv.properties | 0% |
| Thai | lang_th.properties | 0% |
| Turkish | lang_tr.properties | Thanks Aysad Kozanoglu! |
| Ukrainian | lang_uk.properties | 0% |
| Vietnamese | lang_vi.properties | 0% |
You can also change the default language of Scoold for all users by setting scoold.default_language_code = "en", where
instead of "en" you enter the 2-letter code of the language of your choice.
To compile it you'll need JDK 8+ and Maven. Once you have it, just clone and build:
$ git clone https://github.com/erudika/scoold.git && cd scoold
$ mvn install$ mvn -Dconfig.file=./application.conf spring-boot:runTo generate a WAR package, run:
$ mvn -Pwar packagegit checkout -b my-new-feature)git commit -am 'Added a new feature')git push origin my-new-feature)Please try to respect the code style of this project. To check your code, run it through the style checker:
mvn validateFor more information, see CONTRIBUTING.md
Please login to review this project.
No reviews for this project yet.
Federated content aggregator and microblogging platform.
Self-Hosted, Twitter™-like Decentralised micro-logging plat…
Federated and decentralized profile builder and social netw…
Comments (0)
Please login to join the discussion on this project.