Andreas/wekan
1
0
Fork 0
mirror of https://github.com/wekan/wekan.git synced 2026-01-06 17:48:49 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

Reorganized Docs. In Progress.

Browse source
This commit is contained in:
Lauri Ojansivu 2024-06-27 11:08:43 +03:00
parent 1961e22cbd
commit ce89ff4833
202 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

186
docs/Platforms/AWS.md Normal file
View file

@ -0,0 +1,186 @@
[Scaling Meteor](https://medium.freecodecamp.org/scaling-meteor-a-year-on-26ee37588e4b)
## Production setup at AWS for thousands of users
* 3-4x m4.large for Node (ECS Cluster)
* 3x r4.large for Mongo (1 Primary for read and write, 2 replicas)
This setup runs very well for thousands of users.
To improve scalability even more, add [Redis Oplog support](https://github.com/cult-of-coders/redis-oplog), also see related [Redis Oplog discussion forum post](https://forums.meteor.com/t/meteor-scaling-redis-oplog-status-prod-ready/30855/479). At AWS you can use AWS ElastiCache that has Redis support.
### Mongo URL AND Oplog settings
From [comment at issue](https://github.com/wekan/wekan-mongodb/issues/2#issuecomment-378343587):
We've fixed our CPU usage problem today with an environment
change around Wekan. I wasn't aware during implementation
that if you're using more than 1 instance of Wekan
(or any MeteorJS based tool) you're supposed to set
MONGO_OPLOG_URL as an environment variable.
Without setting it, Meteor will perform a pull-and-diff
update of it's dataset. With it, Meteor will update from
the OPLOG. See here
https://blog.meteor.com/tuning-meteor-mongo-livedata-for-scalability-13fe9deb8908
After setting in [docker-compose.yml](https://github.com/wekan/wekan-mongodb/blob/master/docker-compose.yml):
```
MONGO_OPLOG_URL=mongodb://<username>:<password>@<mongoDbURL>/local?authSource=admin&replicaSet=rsWekan
```
the CPU usage for all Wekan instances dropped to an average
of less than 10% with only occasional spikes to high usage
(I guess when someone is doing a lot of work)
```
- MONGO_URL=mongodb://wekandb:27017/wekan
- MONGO_OPLOG_URL=mongodb://<username>:<password>@<mongoDbURL>/local?authSource=admin&replicaSet=rsWekan
```
If there is other ideas to improve scalability, add info to [existing scalability issue](https://github.com/wekan/wekan-mongodb/issues/2) or [scalability forum post](https://discourse.wekan.io/t/cpu-utilization-problems-with-large-userbase/579/15), there is also mentioned that smart-disconnect is already in Wekan.
For Enterprises using Wekan xet7 recommends participating in Wekan development, see [Benefits of contributing your features to Upstream Wekan](https://blog.wekan.team/2018/02/benefits-of-contributing-your-features-to-upstream-wekan/index.html), having your own developers working on Wekan daily, and using Commercial Support at https://wekan.team , as Wekan Team [already has access to high performance bare metal servers at CNCF / Packet for running high load testing](https://blog.wekan.team/2018/01/wekan-progress-on-x64-and-arm/index.html). With the benefits you get by using Wekan, it’s [time well spent](https://blog.wekan.team/2018/02/time-well-spent/index.html). Some [DTrace and eBPF info here](https://news.ycombinator.com/item?id=16375938).
## Single Server Install for small teams
1) Add AWS Security Group with for example name wekan, and incoming ports 80 and 443 for all. Only add ssh access to your own IP address CIDR like 123.123.123.123/32 so it means one IP address.
2) Start Ubuntu 17.10 64bit EC2 instance that has at least 2 GB RAM, 30 GB diskspace, probably you need more when you add more customers. Add your SSH public key to instance or let it create new.
3) Add new Elastic IP address pointing to your EC2 instance. That way IP address stays same, and you can also make snapshot of EC2 instance and start that as new EC2 instance with more RAM and change Elastic IP to point to new EC2 instance with minimal downtime, but prefer times when there is no active changes to Wekan.
4) Set your subdomain.yourdomain.com address DNS pointing to your Elastic IP address as A record in Route 53, Namecheap or elsewhere where your domain control panel is. It will take max 24h for DNS to propagate globally.
5) ssh to your server, for example:
```
ssh -i pubkey.pem ubuntu@server-ip-address
(or: root@)
```
6) Update all packages:
```
sudo apt update
sudo apt -y dist-upgrade
reboot
```
7) Install Docker CE and docker-compose for ubuntu from www.docker.com , also add user ubuntu to group docker in post-install step.
8) Install nginx, for example:
```
sudo apt install nginx
(or: nginx-full)
sudo systemctl start nginx
sudo systemctl enable nginx
```
[Example nginx config](Nginx-Webserver-Config)
Test nginx config with:
```
sudo nginx -t
```
And take config into use with:
```
sudo systemctl reload nginx
```
9) Install certbot from https://certbot.eff.org for Let's Encrypt SSL certs, redirect http to https
10) For different customers, you use different location /customer1 2 etc block and wekan running behind nginx proxy on different localhost port in same nginx virtualhost subdomain config file.
11) Get latest wekan release info from https://github.com/wekan/wekan/releases , read docker-compose.yml file from https://github.com/wekan/wekan-mongodb where all settings are explained, so you setup ROOT_URL=https://sub.yourdomain.com/customer1 and for example the 8080:80 for local server port 8080 to go inside docker port 80.
For example Wekan v0.70, use in docker-compose.yml file:
image: quay.io/wekan/wekan:v0.70
Only use release version tags, because latest tag can be broken sometimes.
12) For email, in AWS SES add email address to domain, verify SPF and DKIM with Route53 wizard if you have domain at Route53 as I recommend. At SES create new SMTP credentials and [add them to docker-compose.yml SMTP settings](Troubleshooting-Mail)
13) Start wekan and mongodb database containers with command:
```
docker-compose up -d
```
So it goes nginx SSL port 443 => proxy to localhost port 8080 or any other => wekan-app port 80 inside docker
14) For different customers have different docker-compose.yml script in directories named by customer names. You may need to rename docker containers from wekan-app to wekan-customer1 etc, and probably also docker internal network names.
15) [Backup, restore, and moving data outside/inside docker](Export-Docker-Mongo-Data)
16) Register as user at https://subdomain.yourdomain.com/customer1/sign-up and login at https://subdomain.yourdomain.com/customer1/sign-in , first user will be admin. Click your username at top right corner / Admin Panel, and there chang settings to invite only.
## Upgrading Wekan
1) Go to directory where docker-compose.yml is, as in install step 14) , and create directory for backup
```
cd wekan-customer1
mkdir backup-2018-02-03
cd backup-2018-02-03
```
2) Make backup of database outside docker in that backup directory, as in install step 15)
3) Edit docker-compose.yml to have new Wekan release number:
```
image: quay.io/wekan/wekan:v0.71
```
4) Restart Wekan:
```
docker-compose stop
docker-compose start
```
5) Login to Wekan and check at Admin Panel that Wekan version is updated.
6) If version is not updated, you could also need some of these:
Seeing what Docker containers are running:
```
docker ps
```
Seeing what Docker images are installed:
```
docker images
```
Stopping containers (or start, if starting containers)
```
docker stop wekan-app
docker stop CONTAINER-ID-HERE
```
Removing containers:
```
docker rm wekan-app
docker rm CONTAINER-ID-HERE
```
Removing images:
```
docker rmi quay.io/wekan/wekan:latest
docker rmi quay.io/wekan/wekan:v0.70
```
Starting new containers from docker-compose.yml file:
```
docker-compose up -d
```
TODO:
- allow resend invites https://github.com/wekan/wekan/issues/1320
- changing logo everywhere, whitelabeling https://github.com/wekan/wekan/issues/1196

180
docs/Platforms/Azure.md Normal file
View file

@ -0,0 +1,180 @@
### Install for example from:
- [Snap](Snap)
- [Docker](Docker)
*Make sure you are running at least **v2.21***
### Redirect URL
[About AZURE-NEW-APP-CLIENT-ID and AZURE-NEW-APP-SECRET](https://community.microfocus.com/t5/Identity-Manager-Tips/Creating-the-application-Client-ID-and-Client-Secret-from/ta-p/1776619). The redirect URL is your Wekan root-url+_oauth/oidc like this: https://boards.example.com/_oauth/oidc
<img src="https://wekan.github.io/azure-redirect.png" width="100%" alt="Wekan logo" />
AZURE_DIRECTORY_ID = TENANT-NAME-FOR-YOUR-ORGANIZATION
### If Azure Active Directory login does not work
Check that your CLIENT_SECRET = AZURE-NEW-APP-SECRET has not expired. If it has, delete old secret, and add new secret.
Add it like this, and also check that your Azure Directory ID is in server URL:
```
sudo snap set wekan oauth2-secret='AZURE-CLIENT-SECRET'
sudo snap set wekan oauth2-server-url='https://login.microsoftonline.com/AZURE_DIRECTORY_ID'
```
<img src="https://wekan.github.io/azure-app-client-secret.png" width="100%" alt="Azure App Client Secret" />
###
## Note: Mailjet is not available at Azure anymore
Instead, use O365 at upcoming Wekan v5.38 or newer.
### Mailjet: getaddrinfo ENOTFOUND
With Wekan Snap and Mailjet, if you get getaddrinfo ENOTFOUND error when you try to send a test email from within Wekan, it can be something with networking for the snap. Fix can be found in [Ubuntu DNS resolution issue affecting other snap packages](https://github.com/nextcloud/nextcloud-snap/issues/881). Thanks to [peterk for info](https://github.com/wekan/wekan/issues/3184#issuecomment-699669350).
### Mailjet: mail-from
When using sending email with Mailjet, set `mail-from` to some real email address so you get info if email bounces back.
### Snap settings
```
sudo snap set wekan debug='true'
sudo snap set wekan caddy-enabled='true'
sudo snap set wekan mail-from='Example Boards <BOARD-ADMIN@example.com>'
sudo snap set wekan mail-url='smtps://username:password@in-v3.mailjet.com:465/'
sudo snap set wekan oauth2-enabled='true'
sudo snap set wekan oauth2-request-permissions='openid'
sudo snap set wekan oauth2-client-id='AZURE-NEW-APP-CLIENT-ID'
sudo snap set wekan oauth2-secret='AZURE-NEW-APP-SECRET'
sudo snap set wekan oauth2-auth-endpoint='/oauth2/v2.0/authorize'
sudo snap set wekan oauth2-server-url='https://login.microsoftonline.com/AZURE_DIRECTORY_ID'
sudo snap set wekan oauth2-token-endpoint='/oauth2/v2.0/token'
sudo snap set wekan oauth2-userinfo-endpoint='https://graph.microsoft.com/oidc/userinfo'
sudo snap set wekan oauth2-email-map='email'
sudo snap set wekan oauth2-username-map='email'
sudo snap set wekan oauth2-fullname-map='name'
sudo snap set wekan oauth2-id-map='email'
sudo snap set wekan port='3001'
sudo snap set wekan richer-card-comment-editor='false'
sudo snap set wekan root-url='https://boards.example.com'
sudo snap set wekan with-api='true'
```
At Admin Panel / Settings / Email:
- SMTP Host: `in-v3.mailjet.com`
- SMTP Port: `465`
- Username: `MAILJET-USERNAME`
- Password: `MAILJET-PASSWORD`
- TLS Support: `[_]` (not checked)
If you use Caddy Let's Encrypt SSL for public server, that requires SSL cert validation from multiple not-listed IP addresses of Let's Encrypt, file `/var/snap/wekan/common/Caddyfile`
```
boards.example.com {
tls {
alpn http/1.1
}
proxy / localhost:3001 {
websocket
transparent
}
}
# If you have static main website in this directory, also add it:
example.com {
root /var/snap/wekan/common/example.com
tls {
alpn http/1.1
}
}
```
If you have private server that should be only accessible from private IP (limited by Azure firewall settings), and need SSL, you can not use Let's Encrypt free SSL that validates public availability from multiple non-disclosed IP addresses. For this purpose, you can get SSL certificate. Here is example of SSL cert from with SSL.com .
Join certificates together to .pem file, in order of:
1) privatekey of example.com
2) wildcard (or one subdomain cert) of example.com
3) sub ca
4) root ca
5) trusted network ca
```
cat example_com.key >> example.com.pem
cat STAR_example_com.crt >> example.com.pem
cat SSL_COM_RSA_SSL_SUBCA.crt >> example.com.pem
cat SSL_COM_ROOT_CERTIFICATION_AUTHORITY_RSA.crt >> example.com.pem
cat CERTUM_TRUSTED_NETWORK_CA.crt >> example.com.pem
```
Then transfer SSL cert to server:
```
scp example.com.pem ubuntu@example.com:/home/ubuntu
ssh ubuntu@example.com
sudo mkdir /var/snap/wekan/common/certs
sudo mv example.com.pem /var/snap/wekan/common/certs/
sudo chown root:root /var/snap/wekan/common/certs/example.com.pem
sudo chmod og-rwx /var/snap/wekan/common/certs/example.com.pem
sudo nano /var/snap/wekan/common/Caddyfile
```
At Caddyfile, add these settings for SSL cert:
```
# Static main website, if you have that, redirect to SSL
http://example.com {
redir https://example.com
}
# Wekan redirect to SSL
http://boards.example.com {
redir https://boards.example.com
}
# Static main website, if you have that in this directory
https://example.com {
root /var/snap/wekan/common/example.com
tls {
load /var/snap/wekan/common/certs
alpn http/1.1
}
}
# Wekan
https://boards.example.com {
tls {
load /var/snap/wekan/common/certs
alpn http/1.1
}
proxy / localhost:3001 {
websocket
transparent
}
}
```
Optionally you can would like to [disable all Snap automatic updates](https://github.com/wekan/wekan-snap/wiki/Automatic-update-schedule#if-required-you-can-disable-all-snap-updates) (not recommended, only required by some clients).
### There are two major steps for configuring Wekan to authenticate to Azure AD via OpenID Connect (OIDC)
Note: These old docs below don't have all settings listed that above new Snap settings have. Text case and _- is different, for example at Docker there is `OAUTH2_ENABLED=true` when at Snap same setting is `sudo snap set wekan oauth-enabled='true'`
1. Register the application with Azure. Make sure you capture the application ID as well as generate a secret key.
2. Configure the environment variables. This differs slightly by installation type, but make sure you have the following:
* OAUTH2_ENABLED = true
* OAUTH2_CLIENT_ID = xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx (application GUID captured during app registration)
* OAUTH2_SECRET = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx (secret key generated during app registration)
* OAUTH2_SERVER_URL = https://login.microsoftonline.com/<tenant GUID specific to your organization>
* OAUTH2_AUTH_ENDPOINT = /oauth2/v2.0/authorize
* OAUTH2_USERINFO_ENDPOINT = https://graph.microsoft.com/oidc/userinfo
* OAUTH2_TOKEN_ENDPOINT = /oauth2/v2.0/token
* OAUTH2_ID_MAP = email (the claim name you want to map to the unique ID field)
* OAUTH2_USERNAME_MAP = email (the claim name you want to map to the username field)
* OAUTH2_FULLNAME_MAP = name (the claim name you want to map to the full name field)
* OAUTH2_EMAIL_MAP = email (the claim name you want to map to the email field)
I also recommend setting DEBUG = true until you have a working configuration. It helps.
You may also find it useful to look at the following configuration information:
https://login.microsoftonline.com/**the-tenant-name-for-your-organization**/v2.0/.well-known/openid-configuration
Some Azure links also at wiki page about moving from Sandstorm to Docker/Snap , and using Docker Swarm:
- https://github.com/wekan/wekan/wiki/Export-from-Wekan-Sandstorm-grain-.zip-file#azure-links

3
docs/Platforms/Cloud-Foundry.md Normal file
View file

@ -0,0 +1,3 @@
[Article from 2016](https://www.cloudfoundry.org/100-day-challenge-082-running-wekan-cloud-foundry/)
Probably needs update to use [precompiled Wekan release](https://www.cloudfoundry.org/100-day-challenge-082-running-wekan-cloud-foundry/) ?

19
docs/Platforms/Cloudron.md Normal file
View file

@ -0,0 +1,19 @@
# Cloudron setup
Status:
- [Cloudron now uses upstream Wekan directly](https://github.com/wekan/wekan/issues/3035), so Cloudron users get all Wekan newest features and fixes
Cloudron is a complete solution for running apps on your server and keeping them up-to-date and secure.
1. First install Cloudron on your server with 3 simple commands - https://cloudron.io/get.html
2. Install Wekan from the Cloudron Store. Once installed, you will get automatic updates for Wekan as and when they get released.
[![Install](https://wekan.github.io/hosting/cloudron.svg)](https://cloudron.io/button.html?app=io.wekan.cloudronapp)
The source code for the package can be found [here](https://git.cloudron.io/cloudron/wekan-app/).
You can also test the wekan installation on the demo Cloudron instance - https://my.demo.cloudron.io (username: cloudron password: cloudron).
# Backup
[Backup Cloudron](Backup#Cloudron)

6
docs/Platforms/Dome.md Normal file
View file

@ -0,0 +1,6 @@
- Website: http://trydome.io
- Location: USA
- Free trial of WeKan Hosting at https://app.trydome.io/signup?package=wekan
- Paid SaaS hosting at propietary backend
- Hosted code examples at https://github.com/domeplatform
- Developer info at https://www.trydome.io/developer

214
docs/Platforms/Friend.md Normal file
View file

@ -0,0 +1,214 @@
## TODO
WeKan:
- integration to Friend TODO list https://github.com/FriendUPCloud/friendup/issues/114
- timezone https://github.com/wekan/wekan/wiki/Timezone
Friend Desktop Cloud OS:
- Secure encrypted skinnable fast Open Source desktop in webbrowser/mobile/desktop app
- WeKan as app at Friend
## Chat
Discord link at https://friendos.com/en/developers/
Not in use currently: IRC at Freenode #friendup
## Website
https://friendos.com
## Video
https://www.youtube.com/watch?v=SB4dNC7u2MU
## Roadmap
- It's possible to use Wekan with Friend. At 2019-06-30 Wekan also works at [Raspberry Pi](Raspberry-Pi) like Friend already works, it makes possible local RasPi-only network.
- Then on local network you can use RasPi Cromium or Friend mobile/tablet Android/iOS app to connect to local network Friend desktop, also possible without connection to Internet.
- If using RasPi4 with 4 GB RAM or more, it's possible to run Wekan+Friend+Desktop etc on same RasPi4, servers+client webbrowser.
- Alternative to RasPi is Orange Pi 5 that can have 16 GB RAM http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/Orange-Pi-5-plus.html
## Screenshot
Wekan Friend development version at Friend Desktop. Not released to Friend Store yet.
![Wekan Friend development version screenshot](https://wekan.github.io/wekan-friend-dev.png)
More Screenshots of Wekan and Friend at https://blog.wekan.team/2018/05/upcoming-wekan-v1-00-and-platforms/
## Source code
Friend Server source code at GitHub https://github.com/FriendUPCloud/friendup . Mobile apps are not at GitHub yet.
Friend Apps source code at GitHub https://github.com/FriendUPCloud/friend-applications
Wekan FriendUPApp source code at GitHub https://github.com/wekan/FriendUPApp
Friend repos:
- https://github.com/FriendSoftwareLabs/
- https://github.com/FriendUPCloud/
Docker
- https://github.com/primesoftnz/friendos-docker
- https://github.com/wekan/friendos-docker
- https://github.com/wekan/docker-friendup
AmiBase, mount Friend disk:
- https://github.com/steffest/AmiBase/blob/master/plugins/friend/friend.js
- https://www.stef.be/video/AmiBase_Friend_Filesystem.mp4
Other Web Desktops:
- Puavo, based on Debian, for schools https://github.com/puavo-org
- Win11 React https://github.com/xet7/win11
- Win11 Svelte https://github.com/xet7/win11-svelte
## News about Wekan at Friend
- Friend Software Labs Releases FriendUP v1.2 Release Candidate https://medium.com/friendupcloud/friend-software-labs-releases-friendup-v1-2-release-candidate-637d7bf800d4
- Medium 2018-01-26: With Friend Wekan! https://medium.com/friendupcloud/with-friend-wekan-707af8d04d9f , you can discuss at Hacker News https://news.ycombinator.com/item?id=16240639
## News about Friend
- Video of Friend Desktop walkthrough https://www.youtube.com/watch?v=PX-74ooqino
- Friend Network and Friend Store questions answered https://medium.com/friendupcloud/friend-network-and-friend-store-questions-answered-56fefff5506a
- How Friend Store unifies Blockchain projects https://medium.com/friendupcloud/how-friend-store-unifies-blockchain-projects-d3a889874bec
- Video of Friend Talk at Blockchangers Event - Oslo 2018 https://www.youtube.com/watch?v=7AsSlFenRwQ
- Video of Friend talk at DeveloperWeek 2018 https://medium.com/friendupcloud/video-of-our-talk-at-developerweek-2018-e9b10246a92f
- Friend interview at FLOSS450 https://twit.tv/shows/floss-weekly/episodes/450
***
## Install from Source
TODO: Update install info
### 1. Setup new Ubuntu 16.04 64bit server or VM
Install script currently works only on Ubuntu 16.04 (and similar Xubuntu 16.04 64bit etc).
### 2. Install git and create repos directory
```
sudo apt-get update
sudo apt-get install git
mkdir ~/repos
cd repos
```
### 3. Clone Friend server repo
```
git clone https://github.com/FriendUPCloud/friendup
```
### 4. Clone Friend Apps repos
```
git clone https://github.com/FriendUPCloud/friend-applications
```
### 5. Clone Friend Chat repo
```
git clone https://github.com/FriendSoftwareLabs/friendchat
```
### 6. Clone Wekan App repo
```
git clone https://github.com/wekan/FriendUPApp
```
### 7. Optional: Clone Webmail repo
```
git clone https://github.com/RainLoop/rainloop-webmail
```
### 8. Install Friend to `~/repos/friendup/build` directory
This will install:
- MySQL database, credentials are in install.sh script, can be changed
- Untrusted SSL certificate for Friend with OpenSSL command
```
cd friendup
./install.sh
```
### 9. Add Wekan app
```
cd ~/repos/friendup/build/resources/webclient/apps
ln -s ~/repos/FriendUPApp/Wekan Wekan
```
### 10. Add other apps
```
cd ~/repos/friendup/build/resources/webclient/apps
ln -s ~/repos/FriendUPCloud/friend-applications/Astray Astray
ln -s ~/repos/FriendUPCloud/friend-applications/CNESSatellites CNESSatellites
ln -s ~/repos/FriendUPCloud/friend-applications/CubeSlam CubeSlam
ln -s ~/repos/FriendUPCloud/friend-applications/Doom Doom
ln -s ~/repos/FriendUPCloud/friend-applications/FriendBrowser FriendBrowser
ln -s ~/repos/FriendUPCloud/friend-applications/GameOfBombs GameOfBombs
ln -s ~/repos/FriendUPCloud/friend-applications/GeoGuessr GeoGuessr
ln -s ~/repos/FriendUPCloud/friend-applications/Instagram Instagram
ln -s ~/repos/FriendUPCloud/friend-applications/InternetArchive InternetArchive
ln -s ~/repos/FriendUPCloud/friend-applications/MissileGame MissileGame
ln -s ~/repos/FriendUPCloud/friend-applications/Photopea Photopea
ln -s ~/repos/FriendUPCloud/friend-applications/PolarrPhotoEditor PolarrPhotoEditor
ln -s ~/repos/FriendUPCloud/friend-applications/Swooop Swooop
ln -s ~/repos/FriendUPCloud/friend-applications/TED TED
```
### 11. Optional: Add custom modules
```
cd ~/repos/friendup/build/modules
ln -s ~/repos/mysupermodule mysupermodule
```
### 12. Install [Wekan Snap](https://github.com/wekan/wekan-snap/wiki/Install)
```
sudo apt-get -y install snapd
sudo snap install wekan --channel=latest/candidate
```
### 13. [ROOT_URL settings](Settings) to your server IP address
```
sudo snap set wekan root-url='http://192.168.0.100:5000'
sudo snap set wekan port='5000'
```
### 14. Start Wekan
```
sudo snap start wekan
sudo snap enable wekan
```
### 15. Start Friend
a) To background:
```
cd ~/repos/friendup/build
./nohup_FriendCore.sh
```
b) to foreground, useful when developing:
```
./Phonix_FriendCore.sh
```
or some of the following
```
./Phonix_FriendCoreGDB.sh
./ValgrindGriendCore.sh
```
### 16. Use with webbrowser
Chrome or Chromium works best 32bit/64bit OS and also with Raspberry Pi on ARM.
https://localhost:6502/webclient/index.html
Username: fadmin
Password: securefassword
### 17. Use with mobile app
Play Store: FriendUP by Friend Software Labs
iOS App Store for iPhone/iPad: If not at App Store, ask
Using Friend Android app to connect to your Friend server URL.
There is also Friend iOS app, but I think it's not yet officially released. If someone is interested, invite to iOS Testflight can be had from [Friend chat](Friend).
# Adding app icons to Friend desktop menus
@CraigL: I found that when I added my web apps to the Dock (by dragging the .jsx file onto it) The app list (on the left side) in the Dock editor showed the full path of the application even after adding a "Display Name" field entry. What I did was to use the Display Name entry for the App list (if available). What I ended up with was:
Orig:
App List => /Home/apps/Youtube/YouTube.jsx
New:
App List => YouTube
[My change is here](https://github.com/344Clinton/friendup/commit/6943cc3c05d74adc147950fb2a272d025b50e680). The fix was simple enough. Tracking it down took me a long time :grinning:

5
docs/Platforms/Helm.md Normal file
View file

@ -0,0 +1,5 @@
# Helm Chart for Kubernetes
[Official Helm Chart](https://github.com/wekan/wekan/tree/main/helm/wekan)
[Related issue](https://github.com/wekan/wekan/issues/3923)

14
docs/Platforms/Heroku.md Normal file
View file

@ -0,0 +1,14 @@
[![Deploy][heroku_button]][heroku_deploy]
[Heroku deployment quide needed](https://github.com/wekan/wekan/issues/693)
[Deploy error](https://github.com/wekan/wekan/issues/638)
[Problem with Heroku](https://github.com/wekan/wekan/issues/532)
Email to work on already working Heroku: Use 3rd party email like SendGrid, update process.env.MAIL_URL ,
change from email at Accounts.emailTeamplates.from , new file in server folder called smtp.js on code
`Meteor.startup(function () });` . TODO: Test and find a way to use API keys instead.
[heroku_button]: https://www.herokucdn.com/deploy/button.png
[heroku_deploy]: https://heroku.com/deploy?template=https://github.com/wekan/wekan/tree/devel

52
docs/Platforms/Metal.md Normal file
View file

@ -0,0 +1,52 @@
https://blog.wekan.team/2019/06/wekan-on-raspi3-and-arm64-server-now-works-and-whats-next-with-cncf/
https://github.com/cncf/cluster/issues/45
CNCF Packet is now part of Equinix Metal.
## Equinix Metal Console
https://console.equinix.com
## Ubuntu Reboot Fix
https://gist.github.com/vielmetti/dafb5128ef7535c218f6d963c5bc624e
```
sudo apt-get update
sudo apt-get install grub2-common
sudo grub-install --bootloader-id=ubuntu
```
Failure to reboot
If an affected system is rebooted, it might not come back online. Instead, the [serial over SSH](https://metal.equinix.com/developers/docs/resilience-recovery/serial-over-ssh/) or SOS console will show the system at the GRUB prompt.
To recover from this condition, log in to the SOS console, which will connect you to GRUB. Then issue the following command:
```
grub> configfile ($root)/EFI/GRUB/grub.cfg
```
The device will load the correct boot sequence and return to service.
## SSH SOS fix
https://osxdaily.com/2022/12/22/fix-ssh-not-working-macos-rsa-issue/
How to Fix SSH Not Working with RSA Signatures on MacOS Ventura
We’re going to modify the ssh_config file to allow for RSA host key again, here’s how to do this.
Open the Terminal (via Spotlight or through the Utilities folder) and enter the following command string:
```
sudo nano /etc/ssh/ssh_config
```
You’ll need to authenticate with the admin password.
Scroll all the way to the bottom of the ssh_config file and then add the following lines to the bottom of ssh_config:
```
HostkeyAlgorithms +ssh-rsa
PubkeyAcceptedAlgorithms +ssh-rsa
```
Hit Control+O to save, and Control+X to exit.

55
docs/Platforms/OS/Android.md Normal file
View file

@ -0,0 +1,55 @@
### Running Wekan server at Android
Requirements:
- arm64 or x64 Android with at least 3 GB RAM. Tested with with arm64 OnePlus 3 that has 6 GB RAM.
- It is not necessary to root Android.
## 1) Install AnLinux and Termux from Play Store
At AnLinux choose:
- Ubuntu
- XFCE4
- Copy those commands to Termux to install Linux.
## 2) At Termux
When you get from Termux to Ubuntu bash, you can install Wekan similarly like arm64 or x64:
https://github.com/wekan/wekan/wiki/Raspberry-Pi
Edit start-wekan.sh so you can start Wekan for example:
```
ROOT_URL=http://localhost:2000
PORT=2000
```
At Android webbrowser like Chrome and Firefox browse to http://localhost:2000
## 3) WLAN
If you connect to WLAN, you can get your IP address with command:
```
ip address
```
Edit start-wekan.sh so you can start Wekan for example:
```
ROOT_URL=http://IP-ADDRESS:2000
PORT=2000
```
Then you can use any computer or mobile phone Javascript capable webbrowser at WLAN to use Wekan at http://IP-ADDRESS:2000 like http://192.168.0.100:2000 . [More info about ROOT_URL](Settings).
## 4) Optional: Mobile Linux Desktop
Requirements:
- 1 WLAN, for example: mobile hotspot, Android device sharing WLAN, hotel WLAN, office WLAN
- ChromeCast that is connected to HDMI Input of hotel/office/home TV and WLAN
- Bluetooth keyboard
- Bluetooth mouse
- 1 Android device that has:
- Wekan installed according to steps 1-3 above
- Android VNC client to local AnLinux Ubuntu desktop
- Firefox installed with apt-get to that Ubuntu desktop, browsing Wekan at http://IP-ADDRESS:2000
- Using ChromeCast to show Android full screen at TV
This way, you have:
- Big TV display
- Full size keyboard and mouse
- Full featured Firefox at Ubuntu Desktop using Wekan

285
docs/Platforms/OS/Chromebook.md Normal file
View file

@ -0,0 +1,285 @@
## WARNING: PLEASE do not try on your Chromebook below info.
First, [download all your Google Account data as 4 GB .zip files](https://takeout.google.com/) and burn them to DVD or Blueray disks, where they can not be easily accidentally deleted.
Because this happened:
- Someone else had their Google Drive full.
- That someone else did not backup local data from Chromebook.
- Installing Linux etc did fill up Chromebook harddisk.
- Chromebook got stuck and messed up, and needed to be reinstalled.
- That someone else lost some data.
Below intructions only worked for xet7, because xet7 did have free disk space on Chromebook. There is **NO WARRANTY OF ANY KIND** for any of below info. If your Chomebook breaks, well, thank your backups, and have a nice day!
## Installing Wekan Snap to Chromebook
Installing to Asus Chromebook C223NA-GJ0007 11.6" laptop, that was cheapest available at local shop, did cost 199 euro.
It has:
- 4 GB RAM
- 32 GB eMMC disk
- Intel® Celeron® N3350 CPU
- Bluetooth
- webcam
- WLAN
- USB3
- 2 x USB-C, both work for charging (I have not tried data transfer yet)
- microSD slot
- package includes USB-C charger and USB mouse
- keys for fullscreen, switch apps, brighness, volume, those do not need any modifier keys like other laptops
- playing youtube videos fullscreen works very well
- speakers sound can be set to very loud if needed
- big enough keys, good keyboard layout
- small and lightweight laptop
- has Play Store Android apps and Linux apps that can work fullscreen
- I did not try yet replacing Chrome OS with full Linux https://galliumos.org that has some drivers Chromebook needs, but according to their [hardware compatibility](https://wiki.galliumos.org/Hardware_Compatibility) this model has Known issues: internal audio, suspend/resume, when using galliumos.
## 1) Install Linux Beta
At Chromebook settings, install Linux Beta. It will have Debian 10, that will be changed to Ubuntu 20.10 64bit.
## 2) Install Ubuntu Container
[Source](http://intertwingly.net/blog/2020/07/21/Ubuntu-20-04-on-Chromebook)
Start by entering the Chrome shell (crosh) by pressing CTRL+ALT+T, then enter the default termina VM:
```
vmc start termina
```
Delete the default penguin container that had Debian 10:
```
lxc stop penguin --force
lxc rm penguin
```
Create a new Ubuntu container named penguin:
```
lxc launch ubuntu:20.10 penguin
```
Enter the new container (as root):
```
lxc exec penguin -- bash
```
## 3) Import public keys
While Ubuntu 20.10 will install, various apt commands will fail due to an inability to verify GPG keys. This problem is not unique to Crostini, it is seen in other environments, like Raspberry Pis.
The fix is to import two public keys:
```
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 7638D0442B90D010
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 04EE7237B7D453EC
```
## 4) Update groups
```
groups ubuntu >update-groups
sed -i 'y/ /,/; s/ubuntu,:,ubuntu,/sudo usermod -aG /; s/$/ \$USER/' update-groups
killall -u ubuntu
userdel -r ubuntu # ignore warning about mail spool
sed -i '/^ubuntu/d' /etc/sudoers.d/90-cloud-init-users
```
## 5) Install Crostini packages
Prepare for installing Google's Crostini specific packages. First bring Ubuntu up to date:
```
apt update
apt upgrade -y
```
Now add the Crostini package repository to apt. This repository provides the Linux integration with Chrome OS (ignore RLIMIT_CORE warning):
```
echo "deb https://storage.googleapis.com/cros-packages stretch main" > /etc/apt/sources.list.d/cros.list
if [ -f /dev/.cros_milestone ]; then sudo sed -i "s?packages?packages/$(cat /dev/.cros_milestone)?" /etc/apt/sources.list.d/cros.list; fi
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1397BC53640DB551
apt update
```
A work-around is needed for a cros-ui-config package installation conflict. First, install binutils to get the ar command:
```
apt install -y binutils
```
Then create the cros-ui-config work-around package:
```
apt download cros-ui-config # ignore any warning messages
ar x cros-ui-config_0.12_all.deb data.tar.gz
gunzip data.tar.gz
tar f data.tar --delete ./etc/gtk-3.0/settings.ini
gzip data.tar
ar r cros-ui-config_0.12_all.deb data.tar.gz
rm -rf data.tar.gz
```
Now install the Crostini packages and the "work-around" package, ignoring any warning messages. This will take awhile:
```
apt install -y cros-guest-tools ./cros-ui-config_0.12_all.deb
```
Delete the "work-around" package:
```
rm cros-ui-config_0.12_all.deb
```
Install the adwaita-icon-theme-full package. Without this package, GUI Linux apps may have a very small cursor:
```
apt install -y adwaita-icon-theme-full
```
Now, shut down the container:
```
shutdown -h now
```
Reboot Chrome OS and start the Terminal application from the launcher. If it fails to start the first time, try again and it should work.
Rebooting is by clicking desktop right bottom clock / Power icon. After Chromebook has shutdown, short press laptop power button to start Chromebook.
### 8) Optional, if you install some Snap GUI apps
These are from same [Source](http://intertwingly.net/blog/2020/07/21/Ubuntu-20-04-on-Chromebook)
but xet7 did not test them.
The fix is to copy the desktop and pixmap files to your .local environment:
```
mkdir -p ~/.local/share/pixmaps
cp /snap/code/current/snap/gui/com.visualstudio.code.png ~/.local/share/pixmaps
cp /snap/code/current/snap/gui/code.desktop ~/.local/share/applications
```
Finally, you will need to change three lines in the code.desktop file in your ~/.local directory.
First, you will need to change Exec=code to specify the full path, namely Exec=/snap/bin/code.
Next, in the two places where Icon= is defined, you will need to replace this with the path to the icon that you copied into your .local directory. In my case, the resulting lines look as follows:
Icon=/home/rubys/.local/share/pixmaps/com.visualstudio.code.png
Once these changes are made, you should be able to launch the application using the Launcher in the lower left hand corder of the screen, by clicking on the circle, entering code into the search box and then clicking on the Visual Studio Code icon. Once launched, the application will appear in the shelf at the bottom of the screen. Right clicking on this icon will give you the option to pin the application to the shelf.
It is still a beta, and the installation instructions (above) are still a bit daunting. More importantly, things that used to work can stop working at any time, like, for example, Ubuntu 18.04.
That being said, it is a full, no-compromise Ubuntu. I've developed and tested code using this setup. I even have installed my full development environment using Puppet.
The only glitch I do see is occasionally GUI applications don't receive keystrokes. This is generally fixed by switching focus to Chromebook application and then back again. Once the application is able to process keystrokes, it remains able to do so.
## 6) Install Wekan
At Ubuntu terminal:
```
sudo snap install wekan
```
#### a) Use Wekan locally
At Ubuntu terminal, type:
```
ip address
```
It shows container internal IP address. You can set it to use Wekan locally, for example:
```
sudo snap set wekan root-url='http://100.115.92.200'
sudo snap set wekan port='80'
```
Then Wekan works locally using Ubuntu webbrowser at http://100.115.92.200 , and you can open cards.
#### b) Use Wekan from other computers at LAN
Look at your Chromebook wifi settings `(i)`, what is your laptop IP address, and use it with below http address:
```
sudo snap set wekan root-url='http://192.168.0.2:2000'
sudo snap set wekan port='2000'
```
At Chromebook settings / Linux Beta / > / Port forwarding, forwart port `2000` with nickname like for example `wekan`. This does forward Chromebook port to inside Ubuntu 20.10 64bit LXC container where Wekan is running.
NOTE: Sometimes reboot stops port forwarding, then it needs to be enabled again at Chromebook settings.
But problem is, using that LAN IP address does not work from Chromebook's own browser like Chrome or Linux Firefox. So looking at that at the next option:
#### c) Use hosts file
At your Chromebook Ubuntu, edit hosts:
```
sudo nano /etc/hosts
```
There add:
```
127.0.0.1 localhost wekan
```
Then with Ubuntu webbrowser you can browse http://wekan:2000 .
At other LAN computer, edit hosts:
```
sudo nano /etc/hosts
```
There add:
```
192.168.0.2 wekan
```
Then you can browse http://wekan:2000 from LAN computers. But mobile phones like Android and iOS can not usually change those settings, and if you don't have a way to setup local network computer names, let's look at next option:
#### d) Use some subdomain
If you have some domain, you can set new record `wekan.example.com A 192.168.0.2` . That is internet wide, but resolves to your local IP address on your local network. Then on your LAN mobile phones you can browse to http://wekan.example.com:2000 .
At Chromebook Ubuntu:
```
sudo nano /etc/hosts
```
There add:
```
127.0.0.1 localhost wekan.example.com
```
So then you can browse to http://wekan.example.com:2000 from Chromebook Ubuntu Firefox, Chromebook Chrome, other LAN computers and mobile phones.
#### Mobile app icon
For iOS and Android, you can [create app PWA icon this way](PWA).
## 7) Optional: Change Linux desktop apps language and install Firefox
Here changing to Finnish:
```
sudo dpkg-reconfigure-locales
```
There add this language, and set is as default:
```
fi_FI.UTF8
```
And install Ubuntu 20.10 version Firefox and translation:
```
sudo apt install firefox firefox-locale-fi
```
Shutdown Ubuntu container:
```
sudo shutdown -h now
```
Reboot Chromebook by clicking desktop right bottom clock / Power icon. After Chromebook has shutdown, short press laptop power button to start Chromebook.
## 8) Optional: Install HP DeskJet 2600 multifunction printer/scanner
This inkjet printer was cheapest available, and does print excellent quality similar to laser color printer.
You should set your wireless network printer to have Static IP address.
[Source](https://chromeunboxed.com/how-to-use-your-hp-printer-with-linux-on-chrome-os/)
```
sudo apt install hplip hplip-gui cups system-config-printer
sudo xhost +
sudo hp-setup
```
Check:
```
[X] Network/Ethernet/Wireless newtork (direct connection or JetDirect)
```
Click:
```
> Show Advanced Options:
```
Check:
```
[X] Manual Discovery
IP Address or network name: [ YOUR-PRINTER-STATIC-IP-HERE, for example 192.168.0.200 ]
JetDirect port: [1]
```
Next, Next, Add Printer.
```
sudo system-config-printer
```
Set printer as Default.
You are also able to Scan images from your multifunction printer with XSane, that was installed with HP printer drivers.
You can print from Ubuntu Linux apps, like for example Firefox, LibreOffice, Inkscape, etc what you can install with apt.
## 9) Optional: Gimp
[Gimp PPA for Ubuntu 20.10 Groovy](https://launchpad.net/~ubuntuhandbook1/+archive/ubuntu/gimp). Note: Other versions of Gimp do not have all translations or do not create icons, like default Gimp from Ubuntu 20.10 repos and Snap.

10
docs/Platforms/OS/Debian.md Normal file
View file

@ -0,0 +1,10 @@
- [Snap](Snap)
- [Docker](Docker)
- [Source](Source)
- [Unofficial debian package](https://github.com/soohwa/wekan-deb/releases) with build and installation instructions [here](https://github.com/soohwa/wekan-deb)
### Old install scripts
[Debian Wheezy 64bit & Devuan Jessie 64 bit](https://github.com/wekan/sps)
[Autoinstall script](https://github.com/wekan/wekan-autoinstall)

8
docs/Platforms/OS/FreeBSD.md Normal file
View file

@ -0,0 +1,8 @@
Newest info at https://github.com/wekan/wekan/issues/2662
Old disappeared info [this comment](https://github.com/wekan/wekan/issues/1155#issuecomment-326734403) instructions:
[https://github.com/greinbold/install-wekan/blob/master/v0.32/freebsd-11.0-RELEASE.md](https://github.com/greinbold/install-wekan/blob/master/v0.32/freebsd-11.0-RELEASE.md)
## FreeBSD Meteor build instructions
TODO

103
docs/Platforms/OS/Install-Wekan-from-source-on-Windows.md Normal file
View file

@ -0,0 +1,103 @@
# Newest Windows info here
https://github.com/wekan/wekan/wiki/Offline
## OLD INFO BELOW, DOES NOT WORK
Also see: [Excel and VBA](Excel-and-VBA)
a) Lowest resource usage: [Windows Subsystem for Linux, build from source](https://github.com/wekan/wekan/issues/2066#issuecomment-468328001)
b) Docker for Windows, [prebuilt without --build option, or build from source](https://github.com/wekan/wekan-dev/issues/12#issuecomment-468657290)
***
### Source install required dependencies
Questions, comments to old closed issue about nexe https://github.com/wekan/wekan/issues/710
Beginnings of build and run scripts, please add PRs for additional fixes etc:
- https://github.com/wekan/wekan/blob/edge/rebuild-wekan.bat
- https://github.com/wekan/wekan/blob/edge/start-wekan.bat
Script for using MongoDB portable:
- https://github.com/wekan/wekan/issues/883#issuecomment-283755906
Requirements:
- Install [MeteorJS](https://www.meteor.com/)
- Install [NodeJS](https://nodejs.org/en/download/releases/) (Optional but recommended)
- Install Python 2.7 (Installation through Chocolatey(`choco install python2 -y`) is recomended)
- If you are on windows 7, Install .NET 4.5.1+
- **MUST MAKE SURE TO** Install [Visual C++ 2015 Build Tools](http://landinghub.visualstudio.com/visual-cpp-build-tools) or run this command from an elevated PowerShell or CMD.exe (run as Administrator) to install, `npm install --global --production windows-build-tools`
- Install Git
- Restart Windows (Optional but recommended)
From this point, it's advised to use **Git bash** to run commands to make sure everything works as is, but if you had trouble accessing meteor or npm commands via Git bash, windows CMD will most likely work without any problem.
Inside the Git Bash, run these commands:
```
npm config -g set msvs_version 2015
meteor npm config -g set msvs_version 2015
```
# Running Wekan
- Clone the repo (`https://github.com/wekan/wekan`)
- Browse the wekan directory and run `meteor`,
- If you see any error regarding **xss**, do `meteor npm i --save xss` to install xss.
- Set the Environment variables, or create a .env file with the following data.
- open your browser, make changes and see it reflecting real-time.
## Example of setting environment variables
You need to have start-wekan.bat textfile with that content of those environment variables.
In Windows, .bat files use DOS style of setting varibles.
Similar file for Linux bash is here:
https://github.com/wekan/wekan-maintainer/blob/master/virtualbox/start-wekan.sh
ROOT_URL examples are here:
https://github.com/wekan/wekan/releases
```
SET MONGO_URL=mongodb://127.0.0.1:27017/wekan
SET ROOT_URL=http://127.0.0.1/
SET MAIL_URL=smtp://user:pass@mailserver.example.com:25/
SET MAIL_FROM=admin@example.com
SET PORT=8081
```
## Example contents of `.env` file
```
MONGO_URL=mongodb://127.0.0.1:27017/wekan
ROOT_URL=http://127.0.0.1/
MAIL_URL=smtp://user:pass@mailserver.example.com:25/
MAIL_FROM=admin@example.com
PORT=8081
```
That URL format is: mongodb://ip-address-of-server:port/database-name
You can access MongoDB database with GUI like Robo 3T https://robomongo.org .
There is no username and password set by default.
## Overview,
Here is how it looks like,
```
git clone https://github.com/wekan/wekan
cd wekan
<SET ENV OR CREATE .env FILE>
meteor npm install --save xss
meteor
```
![](https://i.imgur.com/aNVBhj5.png)
# FAQ
### I am getting `node-gyp` related issues.
Make sure to install all required programs stated here, https://github.com/wekan/wekan/wiki/Install-Wekan-from-source-on-Windows#setup-required-dependencies
### I am getting `Error: Cannot find module 'fibers'` related problem.
Make sure to run the command `meteor` instead of `node`.

50
docs/Platforms/OS/Install-Windows.md Normal file
View file

@ -0,0 +1,50 @@
## 1. Get Windows 8/10/11 key, if there is no key sticker
1.1. Get USB stick (USB2 works better than USB3) that is 8 GB or a little bigger (not too big like 128 GB)
1.2. Download Rufus https://rufus.ie (or BalenaEtcher https://etcher.balena.io)
1.3. Download some live distro, for example:
- newest Linux Mint Mate https://linuxmint.com , .iso size about 4 GB
- UPupBB https://sourceforge.net/projects/zestypup/files/ , .iso size about 340 MB
- Puppy Linux https://puppylinux-woof-ce.github.io/ , .iso small download about 400 MB
1.4. With Rufus of BalenaEtcher, write .iso to USB stick
1.5. Boot from USB Linux Mint, usually after power on F8 key is boot menu, or F12
Windows 8 and Windows 10/11 OEM product key from BIOS when using Linux
```
sudo cat /sys/firmware/acpi/tables/MSDM | tail -1
```
## 2. Create bootable Windows Install USB stick
2.1. Download Rufus https://rufus.ie
2.2. Download Windows, big download
https://www.microsoft.com/software-download/windows11
https://www.microsoft.com/fi-fi/software-download/windows10ISO
2.3. If you are installing Windows to VirtualBox, newest VirtualBox has TPM 2.0 and Secure Boot emulation.
Win11 on VirtualBox may have some visual transparency bugs, that updates to VirtualBox
display drivers may fix later. Earlier OS shows correctly.
2.4. If you are installing Windows 11 to computer that does not support Windows 11
Try adding some Windows Registry keys:
https://blogs.oracle.com/virtualization/post/install-microsoft-windows-11-on-virtualbox
2.5. Boot from USB Instal Windows stick, usually after power on F8 key is boot menu, or F12
2.6. If using same license key at dual boot:
- Win11
- Ubuntu host, VirtualBox Win11 Guest
If some activation phone call asks in how many computers you use license at, answer 1.

1
docs/Platforms/OS/Install-and-Update.md Normal file
View file

@ -0,0 +1 @@
Moved to [Platforms](Platforms)

23
docs/Platforms/OS/Install-from-source-without-root.md Normal file
View file

@ -0,0 +1,23 @@
# Quick install for development / debugging
* Install [nvm](https://github.com/creationix/nvm)
* `source NVMPATH/nvm.sh` for example `source ~/.nvm/nvm.sh`
* `nvm install v8.16.0`
* `nvm use v8.16.0`
* `nvm install-latest-npm`
* `cd ~`
* Clone repo to home: `git clone https://github.com/wekan/wekan.git`
* Install meteor (you can skip sudo by entering invalid password): `curl https://install.meteor.com/ | sh`
* `cd wekan/`
* `~/.meteor/meteor npm install --save babel-runtime xss meteor-node-stubs`
* `~/.meteor/meteor npm install --save bcrypt`
* `~/.meteor/meteor`
When you get this output, wekan is ready:
```
=> Started your app.
=> App running at: http://localhost:3000/
```
Register new user for administrator

175
docs/Platforms/OS/Install-latest-Wekan-release-on-Uberspace.md Normal file
View file

@ -0,0 +1,175 @@
# NEWEST:
[UberLab/Uberspace 7 Manual: Wekan](https://lab.uberspace.de/guide_wekan.html) - ([Source](https://github.com/wekan/wekan/issues/2009#issuecomment-817010524))
***
# OLD:
**NOTE**:
- [Newest Node/Mongo/Meteor versions](https://github.com/wekan/wekan/blob/main/Dockerfile).
- For x64 wekan-VERSION.zip is at https://releases.wekan.team and some related install info https://github.com/wekan/wekan/wiki/Raspberry-Pi
**Purpose**: Install latest Wekan release on [Uberspace](https://uberspace.de/) 6 and run as [daemontools](https://cr.yp.to/daemontools/faq/create.html) service in local userspace.
This script installs Wekan on a fresh Uberspace 6. It setup Node 4, MongoDB, a Port, installs Wekan and starts it as a service. It's tested with Wekan versions 0.32 and 0.63.
You have two Options to use it.
# Option 1:
You can run the commands of the following script step-by-step in the shell.
At first step set the SMTP-Password variable. Replace the `$1` with the password in that way `SMTP_PASS="smtp_password"` and continue line-by-line.
# Option 2:
Or you can run it automatically.
* Save it as script in file `install_wekan.sh`
* Make it executable `chmod +x install_wekan.sh`
* And run it. Pass the SMTP-Password as command line parameter `./install_wekan.sh smtp_password`.
## ./install_wekan.sh
```
#!/bin/sh
##
## Usage: ./install_wekan.sh SMTP-password
##
## Draft
## Install Wekan (v0.63) on Uberspace 6 by Noodle / Chris
##
## Sources:
## https://github.com/wekan/wekan/wiki/Install-and-Update#manual-installation-steps
## https://wiki.uberspace.de/database:mongodb
## https://wiki.uberspace.de/development:nodejs
## https://wiki.uberspace.de/system:daemontools
## https://github.com/wekan/wekan/issues/907
## Set SMTP password
# SMTP_PASS="xxxxxxxxxx"
SMTP_PASS="$1"
#####################
### Setup Node.js ###
#####################
cat <<__EOF__ > ~/.npmrc
prefix = $HOME
umask = 077
__EOF__
echo 'export PATH=/package/host/localhost/nodejs-4/bin:$PATH' >> ~/.bash_profile
source ~/.bash_profile
#####################
### Setup MongoDB ###
#####################
test -d ~/service || uberspace-setup-svscan
TEMPMDB="$(uberspace-setup-mongodb)"
MONGO_USER="${USER}_mongoadmin"
MONGO_PORT="$(echo ${TEMPMDB} | grep -E -o 'm#:\s[0-9]{5}\sUs' | cut -d' ' -f 2)"
MONGO_PASS="$(echo ${TEMPMDB} | grep -E -o 'rd:\s.+\sTo\sconn' | cut -d' ' -f 2)"
echo -e "MONGO_USER: ${MONGO_USER} \nMONGO_PORT: ${MONGO_PORT} \nMONGO_PASS: ${MONGO_PASS}"
############################
### Setup Websocket Port ###
############################
export FREE_PORT="$(uberspace-add-port --protocol tcp --firewall | grep -E -o '[0-9]{5}')"
echo "FREE_PORT: ${FREE_PORT}"
###################
### Setup Wekan ###
###################
## Issue #907 - Port must be speccified in root url, when Version > 0.10.1
MONGO_URL="mongodb://${MONGO_USER}:${MONGO_PASS}@127.0.0.1:${MONGO_PORT}/wekan?authSource=admin"
ROOT_URL="http://${USER}.${HOSTNAME}:${FREE_PORT}/"
MAIL_URL="smtp://${USER}:${SMTP_PASS}@${HOSTNAME}:587/"
MAIL_FROM="${USER}@${HOSTNAME}"
PORT="${FREE_PORT}"
echo -e "MONGO_URL: ${MONGO_URL} \nPORT: ${PORT} \nROOT_URL: ${ROOT_URL} \nMAIL_URL ${MAIL_URL} \nMAIL_FROM: ${MAIL_FROM}"
#####################
### Install Wekan ###
#####################
mkdir ~/wekan && cd ~/wekan
# Tested versions 0.32, 0.63
WEKAN_VERSION=0.63
curl -OL https://github.com/wekan/wekan/releases/download/v${WEKAN_VERSION}/wekan-${WEKAN_VERSION}.tar.gz && tar xzf wekan-${WEKAN_VERSION}.tar.gz && rm wekan-${WEKAN_VERSION}.tar.gz
cd ~/wekan/bundle/programs/server && npm install
cd ~
#####################
### Setup Service ###
#####################
cat <<__EOF__ > ~/etc/wekan-setup
#!/bin/bash
export MONGO_URL=${MONGO_URL}
export ROOT_URL=${ROOT_URL}
export MAIL_URL=${MAIL_URL}
export MAIL_FROM=${MAIL_FROM}
export PORT=${PORT}
__EOF__
cat <<__EOF__ > ~/etc/wekan-start
#!/bin/bash
source ~/etc/wekan-setup
exec node ~/wekan/bundle/main.js
__EOF__
chmod 700 ~/etc/wekan-setup
chmod a+x ~/etc/wekan-start
## Init & Start as servcie
uberspace-setup-service wekan ~/etc/wekan-start
## Setup & Start in bg for debugging
# source ~/etc/wekan-setup && node ~/wekan/bundle/main.js &
#####################
### Finish ###
#####################
echo -e "\n Login: ${ROOT_URL} \n\n"
```
# Control Wekan Service
Basic control of the Wekan service:
* Stop the service: `svc -d ~/service/wekan`
* Start the service: `svc -u ~/service/wekan`
* Keep an eye on the log while running the service: `tailf ~/service/wekan/log/main/current`
More about [daemontools](https://cr.yp.to/daemontools/faq/create.html).
# Uninstall Wekan
To remove Wekan from your uberspace you have to do the following steps.
* Stop and remove the service.
`uberspace-remove-service -s wekan`
* Remove the complete data.
```
mongo admin --port $MONGO_PORT -u $MONGO_USER -p $MONGO_PASS
use wekan
db.dropDatabase()
exit
```
* Remove the installation.
`rm -Rf ~/wekan/ ~/etc/wekan-*`

57
docs/Platforms/OS/Install-source-without-sudo-on-Linux.md Normal file
View file

@ -0,0 +1,57 @@
In-progress script for installing npm modules locally. Not tested.
Anyone: If you get this working, edit this wiki and add remaining to be installed locally.
## TODO
- Add MongoDB running locally like at wiki page [Install from source](Install-and-Update#install-mongodb-1)
- Add node.js, npm etc installed locally
- Update [wekan-autoinstall](https://github.com/wekan/wekan-autoinstall), please send pull requests
- Update [Install from source](Install-and-Update#install-mongodb-1) so then this temporary page can possibly be removed later
## Related info
- Node.js and npm version downloaded at [Dockerfile](https://github.com/wekan/wekan/blob/main/Dockerfile)
- https://gist.github.com/isaacs/579814
- http://linuxbrew.sh
## Only this run with sudo
```
sudo apt-get install build-essential c++ capnproto nodejs nodejs-legacy npm git curl
```
## Install npm modules etc locally
```
# Local node module install from here:
# https://docs.npmjs.com/getting-started/fixing-npm-permissions
# If NPM global package directory does not exists
if [ ! -d "~/.npm-global" ]; then
# Create it
mkdir ~/.npm-global
fi
# If .npm-global/bin is in the path
if grep -Fxq "export PATH=~/.npm-global/bin:$PATH" ~/.bashrc
then
# Continue
else
# Add it to path
echo "export PATH=~/.npm-global/bin:$PATH" >> ~/.bashrc
# Add it to current path in RAM
export PATH=~/.npm-global/bin:$PATH
fi
```
## Install packages globally to local ~/.npm-global directory
```
npm -g install n
npm -g install npm@4.6.1
npm -g install node-gyp
npm -g install node-pre-gyp
npm -g install fibers@1.0.15
```
## Install meteor
Continue at [Install from source](Install-and-Update#install-manually-from-source)

143
docs/Platforms/OS/Mac.md Normal file
View file

@ -0,0 +1,143 @@
<img src="https://wekan.github.io/wekan-logo.svg" width="20%" alt="Wekan logo" />
<img src="https://wekan.github.io/donated/MacStadium-developerlogo.png" width="20%" alt="Powered by MacStadium" />
## ChangeLog
- Previously:
- Below info about Wekan on Mac x64
- [Wekan PWA on iOS Safari](PWA)
- Many mobile web fixes
- 2021-05-14 Wekan maintainer [xet7](https://github.com/xet7) got donated hardware [OpenSource MacStadium](https://www.macstadium.com/opensource) remote access to Mac Mini M1 that has 16 GB RAM and 1 TB SSD.
- 2021-05-15 xet7 bought Apple Developer access for 99 euro/year. Trying to figure out how to sign some test app for iPhone, did not get it working yet.
- 2021-05-16 Instructions added below by xet7 about how to run Wekan Server Node.js/MongoDB for development on M1.
- 2021-06-21 xet7 got iPhone 12 mini for testing prototypes locally. Some testing of coding tools on M1.
- 2022-02-12 [Enable drag handles on iPad landscape mode automatically](https://github.com/wekan/wekan/issues/3755).
- TODO:
- Trying to find out some way how to make macOS App Store and iOS iPhone/iPad App Store versions of Wekan.
## Docker: Easiest for install and use
1. Install Docker Desktop for Mac and start it. Then:
```
git clone https://github.com/wekan/wekan
cd wekan
```
2. Look what is your Mac IP address:
```
ifconfig | grep broadcast | grep 'inet ' | cut -d: -f2 | awk '{ print $2}' | cut -d '/' -f 1
```
3. Edit docker-compose.yml-arm64
```
nano docker-compose.yml-arm64
```
4. Change ROOT_URL to be your IP address, like http://192.168.0.100 :
https://github.com/wekan/wekan/blob/main/docker-compose.yml-arm64#L185
5. Save and exit: Cmd-o Enter Cmd-x.
6. Start WeKan:
```
docker-compose up -d -f docker-compose.yml-arm64
```
7. At same local network, use any webbrowser at any computer/smartphone/TV to browse to your WeKan IP address, like http://192.168.0.100
## Mac M1 Wekan development
Meteor includes Node.js and MongoDB version, when developing. But if not developing, those can be installed like below in Bundle section.
1) Install rosetta:
```
softwareupdate --install-rosetta --agree-to-license
```
2) Clone Wekan:
```
git clone https://github.com/wekan/wekan
cd wekan
```
3) Install Meteor etc
```
curl https://install.meteor.com/ | arch -x86_64 sh
arch -x86_64 meteor npm install --save @babel/runtime
```
3a) Run Meteor on localhost port 4000:
```
WRITABLE_PATH=.. WITH_API=true RICHER_CARD_COMMENT_EDITOR=false arch -x86_64 meteor --port 4000
```
3b) Run Meteor on computer IP address on local network port 4000:
```
WRITABLE_PATH=.. ROOT_URL=http://192.168.0.100:4000 PORT=4000 WITH_API=true RICHER_CARD_COMMENT_EDITOR=false arch -x86_64 meteor --port 4000
```
## Bundle for non-devepment use with start-wekan.sh
1. Download Node.js from https://github.com/wekan/node-v14-esm/releases/tag/v14.21.4 , and MongoDB 6.x from https://www.mongodb.com/try/download/community
2. Download wekan-VERSIONNUMBER.zip from https://releases.wekan.team
3. Unzip file you downloaded at step 2. There will be directory called `bundle`.
4. Download [start-wekan.sh script](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.sh) to directory `bundle` and set it as executeable with `chmod +x start-wekan.sh`
5. Install Node.js version mentioned at https://wekan.github.io Download section
6. Install MongoDB version mentioned at https://wekan.github.io Download section [with Mac install info](https://docs.mongodb.com/manual/tutorial/install-mongodb-on-os-x/)
7. Edit `start-wekan.sh` so that it has for example:
```
export WRITABLE_PATH=..
export ROOT_URL=http://localhost:2000
export PORT=2000
export MONGO_URL=mongodb://127.0.0.1:27017/wekan
```
[More info about ROOT_URL](Settings)
8. Edit `start-wekan.sh` so that it starts in bundle directory command `node main.js`
## Build bundle from source and develop Wekan
1. Install XCode
2. [With steps 3-6 fork and clone your fork of Wekan](https://github.com/wekan/wekan-maintainer/wiki/Developing-Wekan-for-Sandstorm#3-fork-wekan-and-clone-your-fork)
## Docker
Note: With Docker, please don't use latest tag. Only use release tags. See https://github.com/wekan/wekan/issues/3874
- [Repair Docker](Repair-Docker)
- [Docker](Docker)
- [Docker Dev Environment](https://github.com/wekan/wekan-dev)
If you don't need to build Wekan, use prebuilt container with docker-compose.yml from https://github.com/wekan/wekan like this:
```
docker-compose up -d
```
If you like to build from source, clone Wekan repo:
```
git clone https://github.com/wekan/wekan
```
Then edit docker-compose.yml with [these lines uncommented](https://github.com/wekan/wekan/blob/main/docker-compose.yml#L132-L142) this way:
```
#-------------------------------------------------------------------------------------
# ==== BUILD wekan-app DOCKER CONTAINER FROM SOURCE, if you uncomment these ====
# ==== and use commands: docker-compose up -d --build
build:
context: .
dockerfile: Dockerfile
args:
- NODE_VERSION=${NODE_VERSION}
- METEOR_RELEASE=${METEOR_RELEASE}
- NPM_VERSION=${NPM_VERSION}
- ARCHITECTURE=${ARCHITECTURE}
- SRC_PATH=${SRC_PATH}
- METEOR_EDGE=${METEOR_EDGE}
- USE_EDGE=${USE_EDGE}
#-------------------------------------------------------------------------------------
```
Then you can build Wekan with
```
docker-compose up -d --build
```
## macOS Finder: Show hidden files
Q: Is there file manager, that shows all files and directories that are at directory? Or should I use mc at zsh? For example, if there is directory /Users/username/repos, it is not visible in Finder, until I move it to /Users/username/Downloads/repos
A: I just add my home directory to the list of favorites. You can also just go to any directory you want with CMD+Shift+G .
CMD+Shift+Period toggles hidden files on and off

315
docs/Platforms/OS/OAuth2.md Normal file
View file

@ -0,0 +1,315 @@
- [More RocketChat fixes here](https://github.com/wekan/wekan/wiki/RocketChat)
- [OAuth2 small bug](https://github.com/wekan/wekan/issues/1874) - currently OAuth2 works mostly
# OAuth2 providers
You can use some OAuth2 providers for logging into Wekan, for example:
- [Auth0](OAuth2#auth0) - works
- [Rocket.Chat](OAuth2#rocketchat-providing-oauth2-login-to-wekan) - works
- [GitLab](OAuth2#gitlab-providing-oauth2-login-to-wekan) - works
- Google - not tested yet
- [LemonLDAP::NG](OAuth2#lemonldapng) - works
You can ask your identity provider (LDAP, SAML etc) do they support adding OAuth2 application like Wekan.
## GitLab providing OAuth2 login to Wekan
[Thanks to derhelge who figured out GitLab login](https://github.com/wekan/wekan/issues/3156).
[GitLab login related debugging](https://github.com/wekan/wekan/issues/3321)
These are the settings (snap installation):
```shell
sudo snap set wekan oauth2-enabled='true'
sudo snap set wekan oauth2-client-id='xxx'
sudo snap set wekan oauth2-secret='xxx'
sudo snap set wekan oauth2-server-url='https://gitlab.example.com/'
sudo snap set wekan oauth2-auth-endpoint='oauth/authorize'
sudo snap set wekan oauth2-userinfo-endpoint='oauth/userinfo'
sudo snap set wekan oauth2-token-endpoint='oauth/token'
sudo snap set wekan oauth2-id-map='sub'
sudo snap set wekan oauth2-username-map='nickname'
sudo snap set wekan oauth2-fullname-map='name'
sudo snap set wekan oauth2-email-map='email'
sudo snap set wekan oauth2-request-permissions='openid profile email'
```
And in GitLab you have to set the same scopes inside the created Application:
* openid
* profile
* email
The redirect URL is described in the wekan wiki: https://wekan.example.com/_oauth/oidc
## Rocket.Chat providing OAuth2 login to Wekan
- [More RocketChat fixes here](https://github.com/wekan/wekan/wiki/RocketChat)
- [RocketChat Skip Install Registration Wizard Fix](https://github.com/RocketChat/Rocket.Chat/issues/31163#issuecomment-1848364117)
> So for someone using snap, it means creating a file `/var/snap/rocketchat-server/common/override-setup-wizard.env ` (the name of the file itself could be anything as long as it has an .env extension) and setting its content to `OVERWRITE_SETTING_Show_Setup_Wizard=completed`
>
> Then, restarting the server by `systemctl restart snap.rocketchat-server.rocketchat-server.service`
- [RocketChat Webhook workaround](https://github.com/wekan/univention/issues/15)
Also, if you have Rocket.Chat using LDAP/SAML/Google/etc for logging into Rocket.Chat, then same users can login to Wekan when Rocket.Chat is providing OAuth2 login to Wekan.
If there is existing username/password account in Wekan, OAuth2 merges both logins.
Source: [OAuth2 Pull Request](https://github.com/wekan/wekan/pull/1578)
# Docker
https://github.com/wekan/wekan-mongodb/blob/master/docker-compose.yml#L146-L166
# Snap
### 1) Install Rocket.Chat
[Rocket.Chat Snap](https://rocket.chat/docs/installation/manual-installation/ubuntu/snaps/) has Node at port 3000 and mongodb at port 27017.
```
sudo snap install rocketchat-server
sudo systemctl disable rocketchat-server.rocketchat-caddy
sudo systemctl stop rocketchat-server.rocketchat-caddy
```
### 2) Install Wekan
[Wekan Snap](https://github.com/wekan/wekan-snap/wiki/Install) has Node at port 3001 and MongoDB at port 27019.
```
sudo snap install wekan
sudo snap set wekan root-url='https://BOARDS.YOURDOMAIN.COM'
sudo snap set wekan port='3001'
sudo snap set core refresh.schedule=02:00-04:00
sudo snap set wekan with-api='true'
```
Email settings [ARE NOT REQUIRED](Troubleshooting-Mail), Wekan works without setting up Email.
```
sudo snap set wekan mail-url='smtps://user:pass@MAILSERVER.YOURDOMAIN.COM:453'
sudo snap set wekan mail-from='Wekan Boards <support@YOURDOMAIN.COM>'
```
Edit Caddyfile:
```
sudo nano /var/snap/wekan/common/Caddyfile
```
Add Caddy config. This uses free Let's Encrypt SSL. You can also use [free CloudFlare wildcard SSL or any other SSL cert](Caddy-Webserver-Config).
```
boards.yourdomain.com {
proxy / localhost:3001 {
websocket
transparent
}
}
chat.yourdomain.com {
proxy / localhost:3000 {
websocket
transparent
}
}
```
Enable Wekan's Caddy:
```
sudo snap set wekan caddy-enabled='true'
```
### 3) Add Rocket.Chat settings
Login to Rocket.Chat at https://chat.yourdomain.com .
Accept chat URL to be https://chat.yourdomain.com .
Click: (3 dots) Options / Administration / OAuth Apps / NEW APPLICATION
CHANGE BELOW ONLY THOSE THAT ARE UPPER CASE, AND URLs TO LOWER CASE.
Add settings:
```
Active: [X] True
Application Name: WEKAN
Redirect URI: https://BOARDS.YOURDOMAIN.COM/_oauth/oidc
Client ID: abcde12345 <=== Rocket.Chat generates random text to here
Client Secret: 54321abcde <=== Rocket.Chat generates random text to here
Authorization URL: https://CHAT.YOURDOMAIN.COM/oauth/authorize
Access Token URL: https://CHAT.YOURDOMAIN.COM/oauth/token
```
Save Changes.
### 4) Add Wekan settings
Copy below commands to `auth.sh` textfile, make it executeable `chmod +x auth.sh` and run it with `./auth.sh`.
CHANGE BELOW ONLY THOSE THAT ARE UPPER CASE, AND URLs TO LOWER CASE.
```
sudo snap set wekan oauth2-enabled='true'
sudo snap set wekan oauth2-client-id='YOUR-CLIENT-ID'
sudo snap set wekan oauth2-secret='YOUR-CLIENT-SECRET'
sudo snap set wekan oauth2-server-url='https://CHAT.YOURDOMAIN.COM/'
sudo snap set wekan oauth2-auth-endpoint='oauth/authorize'
sudo snap set wekan oauth2-userinfo-endpoint='oauth/userinfo'
sudo snap set wekan oauth2-token-endpoint='oauth/token'
sudo snap set wekan oauth2-id-map='preffered_username'
sudo snap set wekan oauth2-username-map='preffered_username'
sudo snap set wekan oauth2-fullname-map='preffered_username'
sudo snap set wekan oauth2-email-map='email'
```
### If login does not work, debug it
```
sudo snap set wekan debug='true'
```
Click Oidc button. Then:
```
sudo snap logs wekan.wekan
sudo systemctl status snap.wekan.wekan
```
### 5) Login to Wekan
1) Go to https://boards.example.com
2) Click `Sign in with Oidc`
3) Click `Authorize` . This is asked only first time when logging in to Wekan with Rocket.Chat.
<img src="https://wekan.github.io/oauth2-login.png" width="60%" alt="Wekan login to Rocket.Chat" />
### 6) Set your Full Name
Currently Full Name is not preserved, so you need to change it.
1) Click `Your username / Profile`
2) Add info and Save.
<img src="https://wekan.github.io/oauth2-profile-settings.png" width="60%" alt="Wekan login to Rocket.Chat" />
### 7) Add more login options to Rocket.Chat
1) At Rocket.Chat, Click: (3 dots) Options / Administration
2) There are many options at OAuth menu. Above and below of OAuth are also CAS, LDAP and SAML.
<img src="https://wekan.github.io/oauth-rocketchat-options.png" width="100%" alt="Wekan login to Rocket.Chat" />
# Auth0
[Auth0](https://auth0.com) can provide PasswordlessEmail/Google/Facebook/LinkedIn etc login options to Wekan.
### 1) Auth0 / Applications / Add / Regular Web Application / Auth0 Settings
CHANGE BELOW ONLY THOSE THAT ARE UPPER CASE, AND URLs TO LOWER CASE.
```
Client ID: <== Copy to below snap settings
Secret: <== Copy to below snap settings
Account url: YOURACCOUNT.eu.auth0.com <== Copy to below snap settings
Application Logo: <== Add your logo
Application Type: Single Page Application
Token Endpoint Authentication Method: Post
Allowed Callback URLs: https://BOARDS.YOURDOMAIN.COM/_oauth/oidc <== Change your Wekan address
Allowed Web Origins: https://BOARDS.YOURDOMAIN.COM <== Change your Wekan address
Use Auth0 instead of the IdP to do Single Sign On: [X]
```
If you need more info, they are at bottom of the page Advanced Settings / Endpoint / OAuth
2) Auth0 Dashboard => Rules => Add Rule
CHANGE BELOW ONLY THOSE THAT ARE UPPER CASE, AND URLs TO LOWER CASE.
Rule Name: Encrich Wekan login
```
function (user, context, callback) {
// Only use this rule for Auth0 Dashboard / Applications / WekanApplication
if(context.clientName !== 'YOUR-APPLICATION-NAME'){
return callback(null, user, context);
}
user.user_metadata = user.user_metadata || {};
var ns = "https://BOARDS.YOURDOMAIN.COM/";
context.idToken[ns + "id"] = user.user_id;
context.idToken[ns + "email"] = user.email;
context.idToken[ns + "name"] = user.name || user.user_metadata.name;
context.idToken[ns + "picture"] = user.picture;
callback(null, user, context);
}
```
### 3) Snap settings, change to it from above client-id, secret, server-url and web-origin (=namespace for rules function above).
Note: namespace works for multiple apps. For example, you can use same namespace url for many different wekan board apps that have different client-id etc, and different board url, and still use same namespace url like https://boards.example.com .
CHANGE BELOW ONLY THOSE THAT ARE UPPER CASE.
```
sudo snap set wekan oauth2-client-id='YOUR-CLIENT-ID'
sudo snap set wekan oauth2-secret='YOUR-SECRET'
sudo snap set wekan oauth2-server-url='https://YOURACCOUNT.eu.auth0.com'
sudo snap set wekan oauth2-auth-endpoint='/authorize'
sudo snap set wekan oauth2-userinfo-endpoint='/userinfo'
sudo snap set wekan oauth2-token-endpoint='/oauth/token'
sudo snap set wekan oauth2-id-map='https://BOARDS.YOURDOMAIN.COM/id'
sudo snap set wekan oauth2-username-map='https://BOARDS.YOURDOMAIN.COM/email'
sudo snap set wekan oauth2-fullname-map='https://BOARDS.YOURDOMAIN.COM/name'
sudo snap set wekan oauth2-email-map='https://BOARDS.EXAMPLE.COM/email'
```
For login to work, you need to:
- Create first Admin user
- Add other users with REST API or Password registration
- Login with OIDC button
- Have Auth0 configured for passwordless email login (on some other login)
### 4) Auth0 ID provider to Custom OAuth RocketChat
These do work currently so that Auth0 passwordless login to RocketChat does work,
but there is some additional code also that is not added as PR to RocketChat yet.
Code mainly has generating custom authorization cookie from user email with addition to
RocketChat API, and using it and login_token + rc_token to check on RocketChat login page
using router repeating trigger so that if those cookies exist then automatically login
user in using RocketChat Custom OAuth2.
CHANGE BELOW ONLY THOSE THAT ARE UPPER CASE, AND URLs TO LOWER CASE.
```
Enable: [X] True
URL: https://YOURACCOUNT.eu.auth0.com/
Token Path: oauth/token
Token Sent Via: Payload
Identity Token Sent Via: Same as "Token Sent Via"
Identity Path: userinfo
Authorize Path: authorize
Scope: openid profile email
ID: YOUR-ACCOUNT-ID
Secret: YOUR-ACCOUNT-SECRET
Login Style: Redirect
Button Text: JOIN CHAT
Button Text Color: #FFFFFF
Button Color: #000000
Username field: (empty)
Merge users: [X] True
```
# lemonldapng
Official documentation : https://lemonldap-ng.org/documentation/latest/applications/wekan
## Wekan Config
Basically, you need to set theses variables to your wekan env :
```
OAUTH2_ENABLED: TRUE
OAUTH2_CLIENT_ID: ClientID
OAUTH2_SECRET: Secret
OAUTH2_SERVER_URL: https://auth.example.com/
OAUTH2_AUTH_ENDPOINT: oauth2/authorize
OAUTH2_USERINFO_ENDPOINT: oauth2/userinfo
OAUTH2_TOKEN_ENDPOINT: oauth2/token
OAUTH2_ID_MAP: sub
```
## LemonLDAP::NG Config
You need to set a new OpenID Connect Relay Party (RP) with theses parameters :
* Client ID: the same you set in Wekan configuration (same as OAUTH2_CLIENT_ID)
* Client Secret: the same you set in Wekan configuration (same as OAUTH2_SECRET)
* Add the following exported attributes
* name: session attribute containing the user's full name
* email: session attribute containing the user's email or _singleMail
See LLNG doc for more details

38
docs/Platforms/OS/OpenSuse.md Normal file
View file

@ -0,0 +1,38 @@
## Install WeKan for OpenSuse amd64
1) Install Snap:
https://snapcraft.io/docs/installing-snap-on-opensuse
2) Install WeKan:
```
sudo snap install wekan --channel=latest/candidate
sudo snap set wekan root-url='http://localhost'
sudo snap set wekan port='80'
```
3) Register at at http://localhost/sign-up
Login at http://localhost/sign-in
More info at https://github.com/wekan/wekan/wiki/Adding-users
4) If you instead would like to access WeKan from other
laptops on your local network, check what is your computer
IP address, and change your IP address here:
```
sudo snap set wekan root-url='http://192.168.0.200'
```
More info at https://github.com/wekan/wekan/wiki/Settings
5) Create app icon for your mobile devices on local WLAN:
https://github.com/wekan/wekan/wiki/PWA
6) Some more info:
- https://github.com/wekan/wekan-snap/wiki/Install
- https://github.com/wekan/wekan/wiki

3
docs/Platforms/OVH.md Normal file
View file

@ -0,0 +1,3 @@
Currently only way is to get Wekan working at OVH is [install from source](Source).
OVH and Kimsufi servers have restricted OVH kernels, so you can't run Snap or Docker.

179
docs/Platforms/Offline.md Normal file
View file

@ -0,0 +1,179 @@
Also see: [Windows](Windows)
[Other CPU/OS On-Premise WeKan install](https://github.com/wekan/wekan/wiki/Raspberry-Pi)
## Wekan Windows 64bit version On-Premise
This is without container (without Docker or Snap).
Right click and download files 1-4:
1. [wekan-7.49-amd64-windows.zip](https://github.com/wekan/wekan/releases/download/v7.49/wekan-7.49-amd64-windows.zip)
2. [node.exe](https://nodejs.org/dist/latest-v14.x/win-x64/node.exe)
3. [mongodb-windows-x86_64-6.0.15-signed.msi](https://fastdl.mongodb.org/windows/mongodb-windows-x86_64-6.0.15-signed.msi)
4. [start-wekan.bat](https://raw.githubusercontent.com/wekan/wekan/main/start-wekan.bat)
5. Copy files from steps 1-4 with USB stick or DVD to offline Windows computer
6. Double click `mongodb-windows-x86_64-6.0.15-signed.msi` . In installer, uncheck downloading MongoDB compass.
7. Unzip `wekan-7.49-amd64-windows.zip` , inside it is directory `bundle`, to it copy other files:
```
bundle (directory)
|_ start-wekan.bat (downloaded file)
|_ node.exe (downloaded file)
|_ main.js (extracted file)
```
8. Edit `start-wekan.bat` with Notepad. There add [Windows computer IP address](https://support.microsoft.com/en-us/windows/find-your-ip-address-in-windows-f21a9bbc-c582-55cd-35e0-73431160a1b9) , like this, then Wekan will be at http://IP-ADDRESS-HERE/sign-in , for example http://192.168.0.100/sign-in but your different IP address. Add there wekan server computer IP address, not localhost. `node.exe main.js` is at bottom of `start-wekan.bat`, change there longer filename:
```
SET ROOT_URL=http://IP-ADDRESS-HERE
SET PORT=80
node.exe main.js
```
If there is already some webserver at port 80, change to other port:
```
REM # Writable path required to exist and be writable for attachments to migrate and work correctly
SET WRITABLE_PATH=..
SET ROOT_URL=http://IP-ADDRESS-HERE:2000
SET PORT=2000
```
Then Wekan will be at http://IP-ADDRESS-HERE:2000/sign-in , for example http://192.168.0.100/sign-in , but with your different IP address.
9. Double click `start-wekan.bat` to run it. Give permission to network. If it does not work, try instead with right click, Run as Administrator.
10. For mobile devices, you can [create PWA app icon](PWA) using that http://IP-ADDRESS-HERE:2000/sign-in
RELATED INFO:
- Windows 2022 server example https://github.com/wekan/wekan/issues/5084
- Other settings example https://github.com/wekan/wekan/issues/4932
## Docker WeKan Offline
At Internet connected computer, download:
1. Docker for Windows
2. docker-compose.yml from https://github.com/wekan/wekan
3. `docker-compose up -d` at Internet connected computer
4. Save wekan-app and wekan-db containers to files https://docs.docker.com/engine/reference/commandline/save/
At Offline Windows computer:
1. Install Docker for Windows
2. Load `wekan-app` container from file https://docs.docker.com/engine/reference/commandline/load/
3. Check what is ID of `wekan-app` container with `docker images`
4. Change at `docker-compose.yml` wekan-app contaier `image:gc....` to `image:ID` where ID from step 3 above
5. Do steps 2-4 also for `wekan-db` container
6. `docker-compose up -d`
## WeKan Updates
1. Updating only WeKan. Not updating Node.js and MongoDB.
1.1. Make backup, look at steps 2.1. and 2.2 below.
1.2. Download newest WeKan bundle .zip file from https://github.com/wekan/wekan/releases
1.3. Replace old bundle with new from that .zip file.
1.4. Start WeKan with `start-wekan.sh`
2. If it does not work, you maybe need to update Node.js and MongoDB.
2.1. Backup part 1/2. Try mongodump to backup database like this command. If mongodump command does not exist, download MongoDB Tools from https://www.mongodb.com/try/download/database-tools . Make backup:
```
mongodump
```
Backup will be is in directory `dump`. More info at https://github.com/wekan/wekan/wiki/Backup
2.2. Backup part 2/2. If there is files at `WRITABLE_PATH` directory mentioned at `start-wekan.bat` of https://github.com/wekan/wekan , also backup those. For example, if there is `WRITABLE_PATH=..`, it means previous directory. So when WeKan is started with `node main.js` in bundle directory, it may create in previous directory (where is bundle) directory `files`, where is subdirectories like `files\attachments`, `files\avatars` or similar.
2.3. Check required compatible version of Node.js from https://wekan.github.io `Install WeKan ® Server` section and Download that version node.exe for Windows 64bit from https://nodejs.org/dist/
2.4. Check required compatible version of MongoDB from https://wekan.github.io `Install WeKan ® Server` section and Download that version Windows MongoDB .msi installer from https://www.mongodb.com/try/download/community
2.5. Remove old Node.js and MongoDB (at Windows, Control Panel / Add Remove Programs).
2.6. Install newest Node.js and MongoDB.
2.7. Restore database with mongorestore, like this:
```
mongorestore --drop
```
If there are errors, try this instead:
```
mongorestore --drop --noIndexRestore
```
2.8. Start wekan with `start-wekan.bat`
2.9. If WeKan does not start with your old start-wekan.bat, download newest [start-wekan.bat](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.bat) and look are there differences to your old start-wekan.bat . For example, with this command, could work on WSL or PowerShell or Linux or after installing git:
```
diff old-start-wekan.bat start-wekan.bat
```
## b) How to fix errors on Linux bundle to create Windows bundle
Download Linux bundle wekan-VERSION.zip from from https://github.com/wekan/wekan/releases or https://releases.wekan.team/
```
npm install -g node-pre-gyp
cd bundle\programs\server\npm\node_modules\meteor\accounts-password
npm remove bcrypt
npm install bcrypt
```
## c) WSL
[WSL](WSL)
## d) Wekan to VirtualBox Ubuntu offline
1. Install newest [VirtualBox](https://www.virtualbox.org/)
2. Install newest [Ubuntu 64bit](https://ubuntu.com) to VirtualBox
3. Install Wekan [Snap](https://github.com/wekan/wekan-snap/wiki/Install) version to Ubuntu with these commands:
```
sudo snap install wekan
```
4. Shutdown Ubuntu
5. At VirtualBox menu, export appliance to `wekan.ova` file
6. Copy `virtualbox-install.exe` and `wekan.ova` to offline computer
7. At offline computer, install virtualbox and import wekan.ova
8. Set virtualbox network to bridged:
https://github.com/wekan/wekan/wiki/virtual-appliance#how-to-use
9. Start VirtualBox and Ubuntu
10. In Ubuntu, type command:
```
ip address
```
=> it will show Ubuntu IP address
11. In Ubuntu Terminal, type with your IP address,
at below instead of 192.168.0.100:
```
sudo snap set wekan root-url='http://192.168.0.100'
sudo snap set wekan port='80'
```
12. Then at local network Wekan is at:
http://192.168.0.100

6
docs/Platforms/OpenShift.md Normal file
View file

@ -0,0 +1,6 @@
[Docker, Wekan and MongoDB on OpenShift](https://github.com/wekan/wekan/tree/main/openshift)
[OpenShift config issue](https://github.com/wekan/wekan/issues/1778)
[Help for Openshift Setup from template failure](https://github.com/wekan/wekan/issues/1923)

3
docs/Platforms/OpenVZ.md Normal file
View file

@ -0,0 +1,3 @@
Only [install from Source](Source) works.
OpenVZ does usually have 2.x kernel that would [support Snap](https://github.com/wekan/wekan-snap/issues/30) or [Docker](Docker).

3
docs/Platforms/PikaPods.md Normal file
View file

@ -0,0 +1,3 @@
Instantly run WeKan on [PikaPods.com](https://www.pikapods.com):
[![Run on PikaPods](https://wekan.github.io/hosting/pikapods.svg)](https://www.pikapods.com/pods?run=wekan)

154
docs/Platforms/Platforms.md Normal file
View file

@ -0,0 +1,154 @@
## Downloads
Downloading and installing Wekan on various platforms.
Only newest Wekan is supported. Please check you are running newest Wekan, because old versions of Wekan have old Node.js and other vulnerabilities.
## Related
* [Wekan new release ChangeLog](https://github.com/wekan/wekan/blob/main/CHANGELOG.md)
* [Adding Users](Adding-users)
* [Forgot Password](Forgot-Password)
* [Settings](Settings)
* [Email](Troubleshooting-Mail)
* **[Backup and Restore](Backup) <=== VERY CRITICAL. DO AUTOMATICALLY OFTEN !!**
* [Logs and Stats](Logs)
* [Wekan bug reports and feature requests](https://github.com/wekan/wekan/issues)
* [Proxy](https://github.com/wekan/wekan/issues/1480)
***
## <a name="ProductionUnivention"></a>Production: [Univention](https://www.univention.com/products/univention-app-center/app-catalog/wekan/) platform, many apps and Wekan.
- Virtual Appliances Download: [VirtualBox, KVM, VMware, VMware ESX](https://www.univention.com/products/univention-app-center/app-catalog/wekan/)
- [Video of installing Univention Wekan Appliance](https://wekan.github.io/UCS-4.4-with-wekan-10.200.2.25.webm)
- After installing, you get license key file in email. Go with webbrowser to VM ip address like http://192.x.x.x and upload license. After that also on VM screen console login as root is possible. If you install KDE app from App Center with webbrowser, you get KDE on VM screen.
- [Wekan for Univention Feature Requests and Bug Reports](https://github.com/wekan/univention)
- [Univention Open Source repos](https://github.com/Univention)
- [Univention interview at FLOSS Weekly 480](https://twit.tv/shows/floss-weekly/episodes/480)
- VM based on Debian. Free and Enterprise versions of Univention are same, only difference is paid support.
- Univention VM can be standalone, or replace Windows Server Active Directory, or join to existing Active Directory. Has web UI, LDAP server, Users/Groups management, adding user to app.
- Wekan LDAP login is integrated to Univention LDAP. Create at Univention web UI at Users management LDAP Domain Admin user, and add Wekan app for that user, to get Wekan Admin Panel. Normal users don't have Admin Panel.
- Has Wekan. From App Center you can install RocketChat, WordPress, OnlyOffice, NextCloud, OpenXChange, etc. Some apps are full free versions, some other apps require payment for more features. Wekan is full free version.
- Wekan on Univention is based Wekan Docker version. Upgrading all apps on Univention upgrades also Wekan to newest available Wekan version.
- Newer version of Wekan will be released when building and testing is done.
***
* Cloud: Some additional info
* [AWS](AWS)
* [Azure](Azure)
* [OpenShift](OpenShift)
***
## Production: SaaS, Wekan ready paid services, just start using.
* [Wekan Team](https://wekan.team/commercial-support/) - Snap Gantt Gpl Automatic Updates. Supports Wekan maintenance and development.
* [Cloudron](Cloudron) - Standalone Wekan
* [PikaPods](PikaPods) - Standalone Wekan with managed updates and backups.
* [Scalingo](Scalingo) - Standalone Wekan
## <a name="ProductionDocker"></a>Not exposed to Internet: Docker. No automatic upgrades.
Keep backups, Docker is more complex than others above. Use only if you have time to test new release first, and it's critical nothing gets broken. Because Docker does not have automatic updates, please keep behind firewall, without any ports open to Internet, because Wekan gets new security etc updates to Node.js and other dependencies often.
* [Docker](Docker)
* [Windows](Windows) + build from source
* [Mac](Mac)
* [SLES 64bit](Install-Wekan-Docker-on-SUSE-Linux-Enterprise-Server-12-SP1)
* [Proxy](https://github.com/wekan/wekan/issues/1480)
***
## Not exposed to Internet: Bundle for [RasPi 3, arm64, Windows and any Node+Mongo CPU architectures](Raspberry-Pi). No automatic updates, no sandboxing.
New at 2019-06-30. If CPU architecture has enough RAM and fast harddisk, it can be used, but there
is no automatic updates and no sandboxing.
New at 2019-09-08. You can also try [bash install script and automatic
upgrade script](https://github.com/wekan/wekan-bash-install-autoupgrade).
Stop Wekan. Download newest bundle version at https://releases.wekan.team .
Install Node 8.16.2 and some MongoDB like 3.2.x - 4.x. Preferred 4.x if available.
Bundle works for Windows native Node.js and MongoDB, arm64 server, etc any CPU node+mongodb.
Building from source does not seem to work on Windows.
Extra steps only for CentOS 6:
- Install gcc-4.9.3 and boost
- Add gcc to path, for example: `export LD_LIBRARY_PATH=/root/gcc-4.9.3/lib/gcc/x86_64-unknown-linux-gnu/4.9.3/:$LD_LIBRARY_PATH`
- At below fibers step, do instead `npm install fibers@2.0.1`
Then, for example:
```
mkdir repos
cd ~/repos
rm -rf bundle
wget https://releases.wekan.team/wekan-3.52.zip
unzip wekan-3.01.zip
cd bundle/programs/server
npm install
npm install node-gyp node-pre-gyp fibers
cd ../../..
```
Then modify `start-wekan.sh` or `start-wekan.bat` for Node and MongoDB paths.
See [Raspberry Pi page](Raspberry-Pi) for info about systemd etc.
***
## <a name="Development"></a>Development: Not updated automatically.
* [Virtual appliance](virtual-appliance) - old
* [Source](Source) for development usage only. Source, Snap, Docker, Sandstorm, Meteor bundle and Windows build instructions.
* [Vagrant](Vagrant)
* Upcoming:
* [Friend](Friend) - Snap Standalone Wekan
## Operating Systems
* [Debian 64bit](Debian)
* [SmartOS](SmartOS)
* [FreeBSD](FreeBSD)
## NAS
* [Qnap TS-469L](https://github.com/wekan/wekan/issues/1180)
## Other Clouds. Can have some restrictions, like: Requires from source install, has restricted 2.x kernel, does not support websockets, or not tested yet.
* [Uberspace](Install-latest-Wekan-release-on-Uberspace)
* [OVH and Kimsufi](OVH)
* [OpenVZ](OpenVZ)
* [Heroku](Heroku) ?
* [Google Cloud](Google-Cloud) ?
* [Cloud Foundry](Cloud-Foundry) ?
## Does not work yet: [DEB/RPM packages at Packager.io](https://packager.io/gh/wekan/wekan)
New at 2019-08-04. For Ubuntu, Debian, CentOS and SLES.
[Testing how to get it working in progress here](https://github.com/wekan/wekan/issues/2582).
# More
[Features](Features)
[Integrations](Integrations)
[install_source]: https://github.com/wekan/wekan/wiki/Install-and-Update#install-manually-from-source
[installsource_windows]: https://github.com/wekan/wekan/wiki/Install-Wekan-from-source-on-Windows
[cloudron_button]: https://cloudron.io/img/button.svg
[cloudron_install]: https://cloudron.io/button.html?app=io.wekan.cloudronapp
[docker_image]: https://hub.docker.com/r/wekanteam/wekan/
[heroku_button]: https://www.herokucdn.com/deploy/button.png
[heroku_deploy]: https://heroku.com/deploy?template=https://github.com/wekan/wekan/tree/main
[indiehosters_button]: https://indie.host/signup.png
[indiehosters_saas]: https://indiehosters.net/shop/product/wekan-20
[sandstorm_button]: https://img.shields.io/badge/try-Wekan%20on%20Sandstorm-783189.svg
[sandstorm_appdemo]: https://demo.sandstorm.io/appdemo/m86q05rdvj14yvn78ghaxynqz7u2svw6rnttptxx49g1785cdv1h
[scalingo_button]: https://cdn.scalingo.com/deploy/button.svg
[scalingo_deploy]: https://my.scalingo.com/deploy?source=https://github.com/wekan/wekan#master
[wekan_mongodb]: https://github.com/wekan/wekan-mongodb
[wekan_postgresql]: https://github.com/wekan/wekan-postgresql
[wekan_cleanup]: https://github.com/wekan/wekan-cleanup
[wekan_logstash]: https://github.com/wekan/wekan-logstash
[autoinstall]: https://github.com/wekan/wekan-autoinstall
[autoinstall_issue]: https://github.com/anselal/wekan/issues/18
[debian_wheezy_devuan_jessie]: https://github.com/wekan/sps

8
docs/Platforms/Qnap-NAS.md Normal file
View file

@ -0,0 +1,8 @@
## Qnap TS-469L
Related older info: https://github.com/wekan/wekan/issues/1180
Use wekan-VERSION.zip bundle from https://releases.wekan.team
with these instructions: https://github.com/wekan/wekan/wiki/Raspberry-Pi

638
docs/Platforms/Raspberry-Pi.md Normal file
View file

@ -0,0 +1,638 @@
NOTE: If you use MongoDB Snap package below, most likely it works with many distro versions, like newest distros also. But if installing without Snap from https://www.mongodb.com/try/download/community , those packages are not for so many distros and versions.
This page is NOT only about Raspberry Pi. This page IS about install without container for ANY Linux/BSD/[macOS](Mac)/[Windows](Offline) using CPU of amd64/arm64/s390x/ppc64le.
WeKan only requires:
- WeKan bundle .zip file of Javascript etc for that CPU. Only difference per CPU is that fibers package is compiled for that CPU. Those .zip files are built this way, for example:
- `git clone https://github.com/wekan/wekan && cd wekan && ./releases/release-wekan.sh WEKAN-VERSION-NUMBER` where version like 5.55
- releases directory has `rebuild-release.sh` that build amd64 bundle, `release-bundle.sh` that uploads amd64 bundle to arm64/s390x/ppc64le servers, and `maintainer-make-bundle-*.sh` scripts for compiling fibers on those arm64/s390x/ppc64le servers. Note: Only xet7 has ssh private keys to build servers, as maintainer of WeKan.
- Node.js binary, version number is at https://wekan.github.io Download section, like https://nodejs.org/dist/latest-v14.x/
- MongoDB, version number is at https://wekan.github.io Download section, like 5.x https://www.mongodb.com/try/download/community or Percona MongoDB https://www.percona.com/software/mongodb/feature-comparison Download at https://www.percona.com/downloads/percona-server-mongodb-LATEST/
- some way to start Wekan, like any of:
- bash script: [start-wekan.sh](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.sh)
- cmd.exe script: [start-wekan.bat](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.bat)
- [systemd service script](#6-running-wekan-as-service)
- init.d script
- any other script, that sets environment variables and in bundle directory does `node main.js`
- most important environment settings are:
- `ROOT_URL=http://192.168.0.200` for WeKan server IP address at local network or `ROOT_URL=https://kanban.example.com` if [Caddy](Caddy-Webserver-Config)/[Nginx](Nginx-Webserver-Config)/[Apache2](Apache) proxies from HTTPS to WeKan http://127.0.0.1:4000 etc, see https://github.com/wekan/wekan/wiki/Settings
- `PORT=80` or `PORT=4000` or some other port where WeKan Nodejs runs.
- `MONGO_URL=mongodb://127.0.0.1:27017/wekan` where MongoDB server is, like localhost port 27017 using database name wekan. (Snap usually has MongoDB port at 27019, if it's not changed for example with `sudo snap set wekan mongodb-port='27020'`)
- `WRITABLE_PATH=..`
- if using node http at port 80, permission for binding to port 80, like `sudo setcap cap_net_bind_service=+ep /usr/local/bin/node`. See https://github.com/wekan/wekan/issues/4735#issuecomment-1295079327
- Optional other settings are at [start-wekan.sh](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.sh) (and at https://github.com/wekan/wekan-snap/wiki/Supported-settings-keys#list-of-supported-keys but Snap settings have lowercase minus like `root-url`, where `.sh` scripts and services have uppercase underline like `ROOT_URL`)
- https://github.com/wekan/wekan/wiki/Adding-users and https://github.com/wekan/wekan/wiki/Troubleshooting-Mail
- Optional autoupgrade script https://github.com/wekan/wekan-bash-install-autoupgrade
## Bundle files
Windows and Linux versions at:
- https://github.com/wekan/wekan/releases
and also:
- Linux amd64 https://releases.wekan.team filename wekan-VERSION-amd64.zip
- Linux arm64 https://releases.wekan.team/raspi3/
- Linux [s390x](s390x) https://releases.wekan.team/s390x/
## Related wiki pages
- https://github.com/wekan/wekan/wiki/ppc
- https://github.com/wekan/wekan/wiki/s390x
## Installing Node.js
Download from https://github.com/wekan/node-v14-esm/releases/tag/v14.21.4
## Installing MongoDB Snap for amd64/arm64/ppc64el/s390x
NOTE: If you use this MongoDB Snap package, most likely it works with many distro versions, like newest distros also. But if installing without Snap from https://www.mongodb.com/try/download/community , those packages are not for so many distros and versions.
This Snap package https://snapcraft.io/juju-db , created by Canonical, has MongoDB for various CPU architectures . It is internal package for Canonical's Juju service https://jaas.ai . Snap repo at https://github.com/juju/juju-db-snap and copy at https://github.com/wekan/mongodb-snap
Install Snap for your distro https://snapcraft.io/docs/installing-snapd
Note: Below `sudo dnf install nano` at CentOS/RHEL/Fedora is like `sudo apt install nano` on Debian/Ubuntu
```
ssh yourserver
sudo dnf install nano
sudo reboot
sudo snap install juju-db
sudo snap refresh juju-db --channel=5.3/stable
sudo snap enable juju-db
sudo snap start juju-db
nano .bashrc
```
There add path to commands mongo, mongodump, mongorestore etc, depending on your CPU architecture,
check filenames of directories etc at /snap/juju-db, like this:
For amd64:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/juju-db/135/usr/lib/x86_64-linux-gnu
export PATH="$PATH:/snap/juju-db/135/bin"
```
For arm64:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/juju-db/137/usr/lib/aarch64-linux-gnu
export PATH="$PATH:/snap/juju-db/137/bin"
```
For ppc64el:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/juju-db/138/usr/lib/powerpc64le-linux-gnu
export PATH="$PATH:/snap/juju-db/138/bin"
```
For s390x:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/juju-db/139/usr/lib/s390x-linux-gnu
export PATH="$PATH:/snap/juju-db/139/bin"
```
Save and exit: Ctrl-o Enter Ctrl-x
Exit ssh, and ssh to server again,
```
exit
ssh yourserver
```
Or alternatively just read new paths to mongo etc commands:
```
source .bashrc
```
Now MongoDB is at localhost port 27017. You connect to CLI with command:
```
mongo
```
## About Raspberry Pi
[Blogpost](https://blog.wekan.team/2019/06/wekan-on-raspi3-and-arm64-server-now-works-and-whats-next-with-cncf/index.html) - [Blogpost repost at dev.to](https://dev.to/xet7/wekan-on-raspi3-and-arm64-server-now-works-and-what-s-next-with-cncf-pbk) - [Thanks at CNCF original issue](https://github.com/cncf/cluster/issues/45#issuecomment-507036930) - [Twitter tweet](https://twitter.com/WekanApp/status/1145168007901134848) - [HN](https://news.ycombinator.com/item?id=20318237)
## Please store MongoDB database etc Wekan files to external SSD hardrive (or HDD)
It's very easy to corrupt microSD card with a lot of writes. Please make [at least daily backups](Backup).
## Install Wekan to RasPi3, RasPi4 or any arm64 server
Look at webbrowser files at https://releases.wekan.team/raspi3/
Download and open README.md, there could be text similar to this:
```
README
Currently uses Node v12.17.0 and MongoDB v3.x or v4.x
Built on arm64 server.
Should work on RasPi3 and RasPi4 on Ubuntu 20.04 64bit arm64 or Raspberry Pi OS 64bit.
Install info here:
https://github.com/wekan/wekan/wiki/Raspberry-Pi
```
You should always check what distro, node etc version it has, before downloading and installing.
## Raspberry Pi OS arm64 with MongoDB 4.2.x
- At [RasPi4 8GB RAM announcement](https://www.raspberrypi.org/blog/8gb-raspberry-pi-4-on-sale-now-at-75/) xet7 found [Raspberry Pi OS 64bit image](https://downloads.raspberrypi.org/raspios_arm64/images/) for RasPi3 and RasPi4.. xet7 did not notice any problems yet with Raspberry Pi OS arm64. [Info why it's not called Raspbian arm64](https://www.tomshardware.com/news/raspberry-pi-os-no-longer-raspbian).
- There is [MongoDB Server Community Edition webpage](https://www.mongodb.com/download-center/community) that has Ubuntu 18.04 Linux arm64 server .deb package of MongoDB 4.2.x that works with Raspberry OS 64bit.
- You see what is newest Node.js 12.x version from [Nodejs.org](https://nodejs.org/en/).
## Ubuntu 20.04
- [Ubuntu 20.04 Server arm64](http://cdimage.ubuntu.com/ubuntu/releases/20.04/release/) for RasPi3 and RasPi4
- Try [MongoDB Server Community Edition webpage](https://www.mongodb.com/download-center/community) that has Ubuntu 18.04 Linux arm64 server .deb package of MongoDB 4.2.x, or MongoDB 3.6.x from repos
- Newest Wekan with newest Meteor
If you have RasPi3, 1 GB RAM can only run Wekan Node.js + MongoDB. There is not enough RAM to run also Ubuntu desktop at the same RasPi.
If you have RasPi3, you can install textmode webbrowser, and download files with it:
```
sudo apt-get install elinks
elinks https://releases.wekan.team/raspi3/
```
If you have RasPi4 with 4 GB RAM, you can also install Ubuntu Desktop with:
```
sudo apt-get install ubuntu-desktop
```
Note: Raspbian is not recommended, because it is 32bit and has [32bit MongoDB that has file size limit of 2 GB](https://www.mongodb.com/blog/post/32-bit-limitations), if it grows bigger then it gets corrupted. That's why here is 64bit arm64 version of Ubuntu.
### 1. Download Ubuntu 19.10 64bit Server for RasPi and write to SD Card
Download from: https://ubuntu.com/download/raspberry-pi
Alternatively, if that link does not work, go to https://ubuntu.com, Download, IoT RasPi arm, and there select 64bit Server for your RasPi.
It seems that [RasPi website](https://www.raspberrypi.org/documentation/installation/installing-images/) recommends [BalenaEtcher GUI](https://www.balena.io/etcher/) for writing image to SD Card.
For Linux dd users, after unarchiving in file manager, if sd card is /dev/sdb, it's for example:
```
sudo su
dd if=ubuntu.img of=/dev/sdb conv=sync bs=40M status=progress
sync
exit
```
And wait for SD card light stop blinking, so it has written everything.
### 2. Preparing for booting RasPi
With RasPi, you need:
- Ubuntu SD card inserted to your RasPi.
- Ethernet cable connected to your router/modem/hub, with connection to Internet.
- USB keyboard and mouse connected.
- Monitor connected to HDMI. Or alternatively, look at your router webpage http://192.168.0.1 (or similar) what is your RasPi IP address, and ssh ubuntu@192.168.0.x with password ubuntu.
- Power cable.
Boot RasPi.
Username: ubuntu
Password: ubuntu
This info is from https://wiki.ubuntu.com/ARM/RaspberryPi
It will ask you to change your password at first login.
### 3. Wait for updates to finish
After login, type:
```
top
```
When you see `apt` or `dpkg`, automatic updates are still running. Wait for updates to finish. Then press `q` to quit top.
### 4. Install remaining updates and reboot
```
sudo apt-get update
sudo apt-get -y dist-upgrade
sudo reboot
```
### 5. Login and install Wekan related files
Look at webbrowser files at https://releases.wekan.team/raspi3/
Or install elinks textmode browser and download with it:
```
sudo apt-get install elinks
elinks https://releases.wekan.team/raspi3
```
Download and open README.md, there could be text similar to this:
```
README
Currently uses Node v12.16.1 and MongoDB v3.x or v4.x
Built on Ubuntu 19.10 arm64 on RasPi4.
Should work on RasPi3 and RasPi4 on Ubuntu 19.10 64bit.
```
Install these:
```
sudo apt-get install npm mongodb-server mongodb-clients mongo-tools zip unzip
sudo npm -g install npm
sudo npm -g install n
```
Then from README.md you downloaded, look at Node version, and install it, for example:
```
sudo n 12.16.1
```
Then look again files:
```
elinks https://releases.wekan.team/raspi3/
```
Download there from files like these:
```
wget https://releases.wekan.team/raspi3/wekan-3.xx-arm64.zip
```
Also download newest start-wekan.sh:
```
wget https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.sh
```
With elinks, you can use arrow keys to navigate, and enter to download file to current directory.
Then unzip file:
```
unzip wekan*.zip
```
### 6. Running Wekan as service
If you would like to run node as non-root user, and still have node at port 80, you could add capability to it, by first looking where node binary is:
```
which node
```
And then adding capability to that path of node, for example:
```
sudo setcap cap_net_bind_service=+ep /usr/local/bin/node
```
This is modified version from https://www.certdepot.net/rhel7-install-wekan/
Edit this new service file:
```
sudo nano /etc/systemd/system/wekan.service
```
There add this text:
```
[Unit]
Description=The Wekan Service
After=syslog.target network.target
[Service]
EnvironmentFile=/etc/default/wekan
User=ubuntu
Group=ubuntu
WorkingDirectory=/home/ubuntu/bundle
ExecStart=/usr/local/bin/node main.js
Restart=on-failure
SuccessExitStatus=143
[Install]
WantedBy=multi-user.target
```
Look at what is your IP address at eth0, for example 192.168.0.x, with this command, and write it somewhere to your other computer or phone or paper:
```
ip address
```
IP address will be added as your ROOT_URL.
You could also login to your router for example at http://192.168.0.1 to set static IP pointing always to your specific RasPi IP address, so that address would not change.
Then edit this file:
```
sudo nano /etc/default/wekan
```
There add this text:
```
NODE_ENV=production
WITH_API=true
MONGO_URL=mongodb://127.0.0.1:27017/wekan
ROOT_URL=http://192.168.0.x
PORT=80
```
There are [many more other possible settings here that you can optionally add](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.sh)
After that start and enable Wekan:
```
sudo systemctl start wekan
sudo systemctl enable wekan
```
Wekan should work at your ROOT_URL in your webbrowser like http://192.168.0.x
## 7. Optional: Email
Note: Configuring email is not required to use Wekan.
If you really would like to install email sending server,
you could install [postfix](https://github.com/wekan/wekan-bash-install-autoupgrade/blob/master/install.sh#L63-L67), but that would probably make your mail to spam banning lists. You would add to above settings:
```
MAIL_URL='smtp://127.0.0.1:25/'
MAIL_FROM='Board Support <wekan@example.com>'
```
It is much more recommended to use [email sending service like AWS SES or some other service](Troubleshooting-Mail) that can ensure delivering email correctly, for Wekan email notifications etc.
## 8. Optional: Nginx and Let's Encrypt SSL
If your router has ports forwarded to your RasPi (in virtual server settings at http://192.168.0.1), then you could also [install nginx and Let's Encrypt SSL](https://github.com/wekan/wekan-bash-install-autoupgrade/blob/master/install.sh) in front of Wekan.
## 9. Updating Wekan
Stop Wekan and move old stuff away:
```
sudo systemctl stop wekan
mkdir old
mv wekan*.zip old/
mv bundle old/
```
Download new Wekan version:
```
elinks https://releases.wekan.team/raspi3/
```
There with keyboard arrow keys go move to top of newest `wekan-3.xx-arm64.zip` and press Enter to download.
Also check README.md about what Node version newest Wekan uses.
In elinks press `q` to exit elinks
Unzip and start Wekan:
```
unzip wekan*.zip
sudo systemctl start wekan
```
If it works, delete old files:
```
rm -rf old
```
***
# STOP HERE. OLD NOT NEEDED INFO BELOW.
***
### b) Running Wekan with startup script
Look at what is your IP address at eth0, for example 192.168.0.x, with this command, and write it somewhere to your other computer or phone or paper:
```
ip address
```
You could also login to your router for example at http://192.168.0.1 to set static IP pointing always to your specific RasPi IP address, so that address would not change.
Make start-wekan.sh executeable, and edit it:
```
chmod +x start-wekan.sh
nano start-wekan.sh
```
There change ROOT_URL like [described here](https://github.com/wekan/wekan/Settings),
for example your RasPi IP address and port, and MongoDB URL:
```
export ROOT_URL=http://192.168.0.x:2000
export PORT=2000
export MONGO_URL='mongodb://127.0.0.1:27017/wekan'
```
If you would like to run node as non-root user, and still have node at port 80, you could add capability to it, by first looking where node binary is:
```
which node
```
And then adding capability to that path of node, for example:
```
sudo setcap cap_net_bind_service=+ep /usr/local/bin/node
```
Then change to start-wekan.sh:
```
export ROOT_URL=http://192.168.0.x
export PORT=80
export MONGO_URL='mongodb://127.0.0.1:27017/wekan'
```
Also in start-wekan changing directory like this:
```
cd bundle
node main.js
```
You need to check that it changes to correct directory, so that it can start `node main.js`
And then start Wekan with:
```
./start-wekan.sh
```
***
## Wekan for RasPi3 arm64 and other CPU architectures
<img src="https://wekan.github.io/wekan-raspi3.png" width="100%" alt="Wekan on RasPi3" />
Newest Wekan:
- Ubuntu 19.10 Server arm64 for RasPi3 and RasPi4
- MongoDB 3.6.x
- Newest Wekan with newest Meteor
To test RasPi3, xet7 tested it with all his Wekan boards data:
```
mongorestore --drop
```
If there is errors in restoring, try:
```
mongorestore --drop --noIndexRestore
```
<img src="https://wekan.github.io/wekan-raspi3-with-all-data.jpg" width="100%" alt="Wekan on RasPi3" />
When using Firefox on network laptop (Core 2 Duo laptop, 8 GB RAM, SSD harddisk) to browse RasPi Wekan server, small boards load at about 3 seconds at first time. When loading, node CPU usage goes to about 100%. MongoDB CPU usage stays low, sometimes goes to 18%. This is because indexes has been added to Wekan MongoDB database. Loading my biggest Wekan board at first time takes 45 seconds, and next time takes about 2 seconds, because data is at browser cache. When Wekan browser tab is closed, node CPU usage drops 4-23%. There is no errors given by Wekan at RasPi3, RasPi3 arm64 behaves similar to x64 server that has 1 GB RAM.
<img src="https://wekan.github.io/wekan-raspi3-cpu-usage.jpg" width="100%" alt="Wekan on RasPi3" />
I did also test Wekan arm64 on arm64 bare metal server, same Wekan bundle worked there.
# Old info below
.7z size 876 MB, unarchived RasPi3 .img size of 4.5 GB. At first boot disk image expands to full SD card size.
https://releases.wekan.team/raspi3/wekan-2.94-raspi3-ubuntu18.04server.img.7z
Or alternatively Wekan Meteor 1.8.1 bundle for arm64:
https://releases.wekan.team/raspi3/wekan-2.94-arm64-bundle.tar.gz
### How to use .img
1) Write image to SD card
```
sudo apt-get install p7zip-full
7z x wekan-2.94-raspi3-ubuntu18.04server.img.7z
sudo dd if=wekan-2.94-raspi3-ubuntu18.04server.img of=/dev/mmcblk0 conv=sync status=progress bs=100M
```
2) Login for Wekan files
- Username wekan
- Password wekan (for Wekan files)
(Or for ubuntu user: username ubuntu password ubuntuubuntu)
3) After login as wekan user, check IP address with command:
```
ip address
```
4) Change that IP addess to start-wekan.sh:
```
cd repos
nano start-wekan.sh
```
There change ROOT_URL to have your IP address. Save and Exit: Ctrl-o Enter Ctrl-x Enter
5) Restore your Wekan dump subdirectory
```
mongorestore --drop --noIndexRestore
```
6) Start Wekan:
```
./start-wekan.sh
```
And maybe [run as service](https://www.certdepot.net/rhel7-install-wekan/)
Or start at boot, by having [at bottom of /etc/rc.local](https://github.com/wekan/wekan/blob/main/releases/virtualbox/etc-rc.local.txt).
7) On other computer, with webbrowser go to http://192.168.0.12 (or other of your IP address you changed to start-wekan.sh)
### How to use bundle
#### a) On any Ubuntu 18.04 arm64 server
```
wget https://releases.wekan.team/raspi3/wekan-2.94-arm64-bundle.tar.gz
tar -xzf wekan-2.94-arm64-bundle.tar.gz
sudo apt-get install build-essential curl make nodejs npm mongodb-clients mongodb-server
sudo npm -g install npm
sudo npm -g install n
sudo n 8.16.0
sudo systemctl start mongodb
sudo systemctl enable mongodb
wget https://releases.wekan.team/raspi3/start-wekan.sh
nano start-wekan.sh
```
There edit [ROOT_URL to have your IP address or domain, and PORT for your localhost port](Settings).
You can also allow node to run on port 80, when you check where node is:
```
which node
```
and then allow it:
```
sudo setcap cap_net_bind_service=+ep /usr/local/bin/node
```
[Adding users](Adding-users)
#### Upgrade bundle
Stop Wekan. See what is newest bundle version at https://releases.wekan.team .
Then, for example:
```
cd ~/repos
rm -rf bundle
wget https://releases.wekan.team/wekan-3.01.zip
unzip wekan-3.01.zip
cd bundle/programs/server
npm install
npm install node-gyp node-pre-gyp fibers (maybe not needed)
cd ../../..
```
Then Start Wekan.
#### b) Other CPU architectures
Do as above, but then also install node packages for your architecture:
```
cd bundle/programs/server
npm install
npm install node-gyp node-pre-gyp fibers
cd ../../..
```
Then start Wekan
```
./start-wekan.sh
```
#### c) Even more something?
Well, you could get some other newest Meteor x64 bundle, like RocketChat, and this way make it run on your CPU architecture, that has required Node+NPM+MongoDB.
### How this was done
1) Bundle at https://releases.wekan.team/raspi3/ was created this way originally on Xubuntu 19.10 x64. This is because officially Meteor only supports x32 and x64. One workaround would be to [add patch to allow other architecture, like this](https://github.com/wekan/meteor/commit/014fe0469bc75eb0371b90464befebc883a08a26). But better workaround is to just build bundle on x64 and then on other architectures download bundle and reinstall npm packages.
```
git clone https://github.com/wekan/wekan
cd wekan
git checkout meteor-1.8
./rebuild-wekan.sh
# 1 and Enter to install deps
./rebuild-wekan.sh
# 2 and Enter to build Wekan
cd .build
```
Then create tar.gz that included bundle directory, with name wekan-VERSION.tar.gz
Ready-made bundles of Meteor 1.6 Wekan x64 at https://releases.wekan.team
Ready-made bundle of Meteor 1.8 Wekan for arm64 at https://releases.wekan.team , works at RasPi3, and any other arm64 server that has Ubuntu 18.04 arm64.
2) Ubuntu Server for RasPi3 from https://www.raspberrypi.org/downloads/
Write to SD card.
Boot:
- Username ubuntu
- Password ubuntu
- It asks to change password at first boot.
3) Create new user:
```
sudo adduser wekan
```
Add name wekan, password wekan, and then other empty with Enter, and accept with Y.
4) Add passwordless sudo:
```
export EDITOR=nano
sudo visudo
```
There below root add:
```
wekan ALL=(ALL:ALL) NOPASSWD:ALL
```
Save and Exit: Ctrl-o Enter Ctrl-x Enter
5) Logout, and login
- Username wekan
- Password wekan
6) Download bundle etc
See above about downloading bundle, start-wekan.sh, dependencies etc.
7) Shutdown RasPi3
```
sudo shutdown -h now
```
8) At computer, insert SD card and unmount partitions:
```
sudo umount /dev/mmcblk0p1 /dev/mmcblk0p2
```
9) Read SD card to image
```
sudo dd if=/dev/mmcblk0 of=wekan-2.94-raspi3-ubuntu18.04server.img conv=sync status=progress
```
10) Resize image to smaller from 32 GB to 4.5 GB:
Resize script is [originally from here](https://evilshit.wordpress.com/2014/02/07/how-to-trim-disk-images-to-partition-size/).
```
wget https://releases.wekan.team/raspi3/resize.sh
chmod +x resize.sh
sudo ./resize.sh wekan-2.94-raspi3-ubuntu18.04server.img
```
11) Make .7z archive to pack about 4.5 GB to about 800 MB:
```
7z a wekan-2.94-raspi3-ubuntu18.04server.img.7z wekan-2.94-raspi3-ubuntu18.04server.img
```

65
docs/Platforms/Sandstorm.md Normal file
View file

@ -0,0 +1,65 @@
## Sandstorm Website
[Sandstorm Website](https://sandstorm.io)
If you have any grains at Sandstorm's **Oasis montly paid service**, please move those to self-hosted, because [only **Oasis grain hosting** part is shutting down](https://sandstorm.io/news/2019-09-15-shutting-down-oasis) - [HN](https://news.ycombinator.com/item?id=20979428). This does not affect any other parts like self-hosting at sandcats.io, App Market, updates, etc.
Works on Ubuntu 64bit, on Debian 64bit.
[Security audited](https://sandstorm.io/news/2017-03-02-security-review), recommended for security critical use on public internet or internal network. [Sandstorm Security Features](https://docs.sandstorm.io/en/latest/using/security-practices/). Sandstorm is [completely Open Source](https://sandstorm.io/news/2017-02-06-sandstorm-returning-to-community-roots), including [Blackrock Clustering](https://github.com/sandstorm-io/blackrock).
Install to your own server. Automatic updates, tested before release. Sandstorm Wekan has different features than Standalone.
**Works**
- Google/GitHub/LDAP/SAML/Passwordless email login.
- Import from Wekan JSON.
- Free SSL at https://yourservername.sandcats.io domain.
- [Rescuing MongoDB data from Sandstorm Grain .zip file to Standalone Wekan](Export-from-Wekan-Sandstorm-grain-.zip-file)
**Does not work**
- [Sandstorm open issues](https://github.com/wekan/wekan/issues?q=is%3Aissue+is%3Aopen+sandstorm+label%3ATargets%3ASandstorm)
- Import from Trello does not import attachments, because Sandstorm-compatible HTTP-access from Wekan to outside of Wekan grain sandbox is not implemented yet
- [Copying/Moving card to another board](https://github.com/wekan/wekan/issues/1729).
- [REST API](https://github.com/wekan/wekan/issues/1279)
- [Outgoing Webhooks](Outgoing-Webhook-to-Discord)
- [Email from Wekan](https://github.com/wekan/wekan/issues/2208#issuecomment-469290305)
## Demo
[![Try on Sandstorm][sandstorm_button]][sandstorm_appdemo]
## Keep backups
- Keep backups. Download your Wekan grains.
- It's possible to [Export from Wekan Sandstorm grain .zip file to rescue data](Export-from-Wekan-Sandstorm-grain-.zip-file)
## Wekan App
Wekan at [experimental](https://apps.sandstorm.io/app/m86q05rdvj14yvn78ghaxynqz7u2svw6rnttptxx49g1785cdv1h?experimental=true) or [official](https://apps.sandstorm.io/app/m86q05rdvj14yvn78ghaxynqz7u2svw6rnttptxx49g1785cdv1h) Sandstorm App Market. Note: Only use official. Experimental versions are broken.
Newest Wekap app .spk file download at https://releases.wekan.team/sandstorm/
## Bug reports and Feature Requests
[Wekan for Sandstorm bug reports and feature requests](https://github.com/wekan/wekan/issues)
[Sandstorm bug reports and feature requests](https://github.com/sandstorm-io/sandstorm/issues)
## Building Wekan for Sandstorm
[Building Wekan for Sandstorm](https://github.com/wekan/wekan-maintainer/wiki/Building-Wekan-for-Sandstorm)
## Wekan Sandstorm cards to CSV using Python
[Wekan Sandstorm cards to CSV using Python](Wekan-Sandstorm-cards-to-CSV-using-Python)
## Importing to Trello workaround
It is not possible to import attachments directly from Trello when using Sandstorm version of Wekan. This is because Wekan is in secure sandbox at Sandstorm, and does not yet have Sandstorm-compatible way to import attachments from outside of Sandstorm. You need to:
1. Install Standalone version of Wekan, for example Docker/Snap/VirtualBox, for example to your own computer
2. Import board from Trello
3. Export board as Wekan board. Exported JSON file includes attachments as base64 encoded files.
4. Import board as Wekan board to Sandstorm.
[sandstorm_button]: https://img.shields.io/badge/try-Wekan%20on%20Sandstorm-783189.svg
[sandstorm_appdemo]: https://demo.sandstorm.io/appdemo/m86q05rdvj14yvn78ghaxynqz7u2svw6rnttptxx49g1785cdv1h

4
docs/Platforms/Scalingo.md Normal file
View file

@ -0,0 +1,4 @@
[![Deploy to Scalingo][scalingo_button]][scalingo_deploy]
[scalingo_button]: https://cdn.scalingo.com/deploy/button.svg
[scalingo_deploy]: https://my.scalingo.com/deploy?source=https://github.com/wekan/wekan#master

72
docs/Platforms/SmartOS.md Normal file
View file

@ -0,0 +1,72 @@
# Install Wekan on SmartOS
based on: https://github.com/greinbold/install-wekan/blob/master/v0.32/freebsd-11.0-RELEASE.md
Used https://github.com/skylime/mi-core-base 1963511a-19d8-4646-90b4-09ecfad1d3ac core-base 16.4.7
## Prerequisites
Add user `wekan`
# useradd -m wekan -s /usr/bin/bash
Install prerequisites packages
# pkgin install mongodb
## if this failes use
# pkg_add https://pkgsrc.smartos.skylime.net/packages/SmartOS/2016Q4/x86_64/All/mongodb-3.2.10.tgz
# pkgin install nodejs curl # 8
# pkgin install gmake gcc5 git jq # build requirements
Enable MongoDB
# /usr/sbin/svcadm enable -r svc:/pkgsrc/mongodb:default
## Installation
Newest wekan-VERSION.zip at https://releases.wekan.team
As wekan
$ cd
$ curl https://releases.wekan.team/wekan-0.89.tar.gz --output wekan-bundle.tar.gz
$ tar -xzpf wekan-bundle.tar.gz
As root
# chown -R wekan:wekan /home/wekan/bundle
As wekan
$ su wekan
$ cd ~/bundle/programs/server
$ npm install # this might be optional - needs testing
$ export CXX="/opt/local/gcc5/bin/g++ -m64"
$ export CC="/opt/local/gcc5/bin/gcc -m64"
$ export CPPFLAGS="-I/opt/local/include"
$ ln -s /opt/local/bin/node /opt/local/bin/nodejs
$ npm install fibers
$ npm install bcrypt
$ cd ~/bundle/programs/server/npm
$ npm install bson-ext@$(jq -r .version < node_modules/bson-ext/package.json)
$ npm install bcrypt@$(jq -r .version < node_modules/bcrypt/package.json)
$ # find more packages with native modules: find ~/bundle/ | grep "binding.gyp$"
## Run
Considering that we set the shell for user wekan to `/usr/bin/bash`, the following ENV variables can be set according the following method before starting of Wekan. These must be adapted according the shell.
$ export MONGO_URL=mongodb://127.0.0.1:27017/wekan
$ export ROOT_URL=https://example.com
$ export MAIL_URL=smtp://user:pass@mailserver.example.com:25/
$ export MAIL_FROM=wekan-admin@example.com
$ export PORT=8080
Now it can be run
$ cd ~/bundle
$ node main.js
## Cleanup
$ pkgin rm gmake gcc5 git jq # remove build requirements

5
docs/Platforms/Snap.md Normal file
View file

@ -0,0 +1,5 @@
### Snap
[Install Snap](https://github.com/wekan/wekan-snap/wiki/Install) <=== **EASIEST INSTALL, UPDATES AUTOMATICALLY**. Available for [many Linux 64bit distros](https://snapcraft.io). Has [Caddy automatic SSL integration](https://github.com/wekan/wekan-snap/wiki/Supported-settings-keys).
[Snap bug reports and feature requests](https://github.com/wekan/wekan-snap/issues)

112
docs/Platforms/Source.md Normal file
View file

@ -0,0 +1,112 @@
## Build from source on Mac
[Build from source on Mac](Mac)
## Build from source on VirtualBox
At [Virtual Appliance](virtual-appliance) there is build scripts and all dependencies installed already.
## Build from source on Linux
To have [Node 100% CPU fixes](https://github.com/wekan/wekan/blob/main/CHANGELOG.md#v084-2018-04-16-wekan-release): Increase ulimit for node in systemd config to 100 000
Wekan:
- On any x64 hardware that has Ubuntu 14.04 or Debian 9 or newer installed directly or in VM:
[Build from source scripts](https://github.com/wekan/wekan/tree/edge/releases/virtualbox)
Wekan Meteor Bundle:
1. [Build from source scripts](https://github.com/wekan/wekan/tree/edge/releases/virtualbox) built on [Wekan VirtualBox Ubuntu 14.04 64bit](virtual-appliance)
2. Copy arhive directory wekan/.build/bundle to .zip file so it includes bundle directory and subdirectories as wekan-1.xx.tar.gz
Wekan for Sandstorm:
- Install above Wekan from source
- Install [Sandstorm locally](https://sandstorm.io/install) with `curl https://install.sandstorm.io | bash`, select dev install
- Install [meteor-spk](https://github.com/sandstorm-io/meteor-spk)
- Get 100% CPU issue fibers fixed node, and copy it to spk directory:<br />
`wget https://releases.wekan.team/node`<br />
`chmod +x node`<br />
`mv node ~/projects/meteor-spk/meteor-spk-0.4.0/meteor-spk.deps/bin/`
- Add to your /home/username/.bashrc : <br /> `export PATH=$PATH:$HOME/projects/meteor-spk/meteor-spk-0.4.0`
- Close and open your terminal, or read settings from .bashrc with<br />`source ~/.bashrc`
- `cd wekan && meteor-spk dev`
- Then Wekan will be visible at local sandstorm at http://local.sandstorm.io:6080/
- Sandstorm commands: `sudo sandstorm`. [Release scripts](https://github.com/wekan/wekan-maintainer/tree/master/releases). Official releases require publishing key that only xet7 has.
Docker:
- `git clone https://github.com/wekan/wekan`
- `cd wekan`
- Edit docker-compose.yml script ROOT_URL etc like documented at https://github.com/wekan/wekan-mongodb docker-compose.yml script
- `docker-compose up -d --build`
Wekan on Windows:
- [Docker, Windows Subsystem for Linux, and compile from source on Windows](Windows)
### (Optional) Run Wekan as service with startup script
[Build from source scripts](https://github.com/wekan/wekan-maintainer/tree/master/virtualbox) - from there run node-allow-port-80.sh and add etc-rc.local.txt before last line in your /etc/rc.local
### (Optional) Run Wekan as service with SystemD on Linux
This may need testing, does this work.
Add to to /etc/systemd/system/wekan@.service
```bash
; see `man systemd.unit` for configuration details
; the man section also explains *specifiers* `%x`
; update <username> with username below
[Unit]
Description=Wekan server %I
Documentation=https://github.com/wekan/wekan
After=network-online.target
Wants=network-online.target
Wants=systemd-networkd-wait-online.service
[Service]
ExecStart=/usr/local/bin/node /home/<username>/repos/wekan/.build/bundle/main.js
Restart=on-failure
StartLimitInterval=86400
StartLimitBurst=5
RestartSec=10
ExecReload=/bin/kill -USR1 $MAINPID
RestartSec=10
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=Wekan
User=<username>
Group=<username>
Environment=NODE_ENV=production
Environment=PWD=/home/<username>/repos/wekan/.build/bundle
Environment=PORT=3000
Environment=HTTP_FORWARDED_COUNT=1
Environment=MONGO_URL=mongodb://127.0.0.1:27017/admin
; https://example.com/wekan for deployment
Environment=ROOT_URL=http://localhost/wekan
Environment=MAIL_URL='smtp://user:pass@mailserver.example.com:25/'
[Install]
WantedBy=multi-user.target
```
#### To start Wekan and enable service, change to your username where Wekan files are:
```bash
sudo systemctl daemon-reload
sudo systemctl start wekan@<username>
sudo systemctl enable wekan@<username>
```
#### To stop Wekan and disable service, change to your username where Wekan files are:
```bash
sudo systemctl daemon-reload
sudo systemctl stop wekan@<username>
sudo systemctl disable wekan@<username>
```
Checkout instructions for setup with [[Caddy Webserver Config]] and [[Nginx Webserver Config]] respectively.
## Windows
Building on Windows (if it works) is a lot slower than on Linux/Mac.
[Windows](Windows)

144
docs/Platforms/Test-Edge.md Normal file
View file

@ -0,0 +1,144 @@
## Testers to ping with new Wekan Edge release
- All those whose issues were fixed [at ChangeLog](https://github.com/wekan/wekan/blob/main/CHANGELOG.md)
- @saschafoerster
Those should reply to new issue that has name `Test Edge Wekan (version-number-here)` at https://github.com/wekan/wekan/issues .
## Why test?
https://github.com/wekan/wekan/issues/2811
## Who should test
- If you are the person in your company that gets yelled at when something breaks in new version of Wekan.
- If you think xet7 releasing new version of Wekan every day directly to stable production Snap channel is in any way risky.
## What usually happens when Wekan gets broken
1. There is many new issues about some same new feature or bug. Yes, also when some notices new feature that is already [at ChangeLog](https://github.com/wekan/wekan/blob/main/CHANGELOG.md), they add issue about it, usually asking "Can this feature be turned off or made optional?". This is usually if new feature changes some old workflow radically.
2. Many do tag @xet7 that are you aware of the issue.
3. Someone yells at IRC that "this is too much, it's time to fork Wekan". Well, that's because he gets yelled at by all users of Wekan at his company.
4. xet7 does not have time to answer those, he just fixes the issue - usually at the same day, makes new release, closes all related issues with last comment "Please try Wekan (version-number-here)".
5. There is [only one comment](https://github.com/wekan/wekan/issues/2812#issuecomment-555860032) that says "This resolved things for me. Thanks for such a quick fix. This is an invaluable piece of software for me!"
6. xet7 thinks this is great normal development day: Got some features added, got some bugs fixes, and happily goes to sleep well. This is because above 1-5 has happened many times before, it's just normal.
## ChangeLog
https://github.com/wekan/wekan/blob/main/CHANGELOG.md
## Backup before testing. And backup daily in production.
Why? Well, Wekan has no undo yet. If you delete Swimlane/List/Card, it's gone.
That's why it's harder to reach in submenu. It's better to Arhive those,
and unarchive.
https://github.com/wekan/wekan/wiki/Backup
You could test at other computer than your production.
## Snap
Snap has automatic update, or you can update manually:
```
sudo snap refresh
```
You see at https://snapcraft.io/wekan what are current versions.
To change to Edge:
```
sudo snap refresh wekan --edge --amend
```
And back to stable:
```
sudo snap refresh wekan --stable --amend
```
## Docker
`docker-compose.yml` is at https://github.com/wekan/wekan .
### Latest development version from master branch
Quay:
```
image: quay.io/wekan/wekan
```
Docker Hub:
```
image: wekanteam/wekan
```
### Example of using release tags
[Quay tags](https://quay.io/repository/wekan/wekan?tag=latest&tab=tags):
```
image: quay.io/wekan/wekan:v3.55
```
[Docker Hub tags](https://hub.docker.com/r/wekanteam/wekan/tags):
```
image: wekanteam/wekan:v3.55
```
### How to change Docker version
1) Backup first
https://github.com/wekan/wekan/wiki/Backup
```
docker-compose stop
docker rm wekan-app
```
2) Change version tag. Then:
```
docker-compose up -d
```
### Build Docker version from source
At docker-compose.yml is these lines:
```
#-------------------------------------------------------------------------------------
# ==== BUILD wekan-app DOCKER CONTAINER FROM SOURCE, if you uncomment these ====
# ==== and use commands: docker-compose up -d --build
#build:
# context: .
# dockerfile: Dockerfile
# args:
# - NODE_VERSION=${NODE_VERSION}
# - METEOR_RELEASE=${METEOR_RELEASE}
# - NPM_VERSION=${NPM_VERSION}
# - ARCHITECTURE=${ARCHITECTURE}
# - SRC_PATH=${SRC_PATH}
# - METEOR_EDGE=${METEOR_EDGE}
# - USE_EDGE=${USE_EDGE}
#-------------------------------------------------------------------------------------
```
Uncomment from those this way:
```
build:
context: .
dockerfile: Dockerfile
args:
- NODE_VERSION=${NODE_VERSION}
- METEOR_RELEASE=${METEOR_RELEASE}
- NPM_VERSION=${NPM_VERSION}
- ARCHITECTURE=${ARCHITECTURE}
- SRC_PATH=${SRC_PATH}
- METEOR_EDGE=${METEOR_EDGE}
- USE_EDGE=${USE_EDGE}
```
Then start Wekan to http://localhost this way:
```
docker-compose up -d --build
```
## Sandstorm
1) Install local development version of Sandstorm to your laptop from https://sandstorm.io/install
2) Download and install experimental version to your local Sandstorm:
https://github.com/wekan/wekan/wiki/Sandstorm
Local sandstorm is at http://local.sandstorm.io:6080/ .
3) Download your production Wekan grain .zip file with down arrow button. Upload to your dev local Sandstorm.
Try does it work.

49
docs/Platforms/UCS.md Normal file
View file

@ -0,0 +1,49 @@
<img src="https://wekan.github.io/hosting/univention.svg" width="30%" alt="Univention logo" />
## <a name="ProductionUnivention"></a>Production: [Univention](https://www.univention.com/products/univention-app-center/app-catalog/wekan/) platform, many apps and WeKan ®
- Virtual Appliances Download: [VirtualBox, KVM, VMware, VMware ESX](https://www.univention.com/products/univention-app-center/app-catalog/wekan/)
- [Video of installing Univention WeKan ® Appliance](https://wekan.github.io/UCS-4.4-with-wekan-10.200.2.25.webm)
- After installing, you get license key file in email. Go with webbrowser to VM ip address like http://192.x.x.x and upload license. After that also on VM screen console login as root is possible. If you install KDE app from App Center with webbrowser, you get KDE on VM screen.
- [WeKan ® for Univention Feature Requests and Bug Reports](https://github.com/wekan/univention/issues)
- [Univention Open Source repos](https://github.com/Univention)
- [Univention interview at FLOSS Weekly 480](https://twit.tv/shows/floss-weekly/episodes/480)
- VM based on Debian. Free and Enterprise versions of Univention are same, only difference is paid support.
- Univention VM can be standalone, or replace Windows Server Active Directory, or join to existing Active Directory. Has web UI, LDAP server, Users/Groups management, adding user to app.
- WeKan ® LDAP login is integrated to Univention LDAP. Create at Univention web UI at Users management LDAP Domain Admin user, and add WeKan ® app for that user, to get WeKan ® Admin Panel. Normal users don't have Admin Panel.
- Has WeKan ® . From App Center you can install RocketChat, WordPress, OnlyOffice, NextCloud, OpenXChange, etc. Some apps are full free versions, some other apps require payment for more features. WeKan ® is full free version.
- WeKan ® on Univention is based WeKan ® Docker version. Upgrading all apps on Univention upgrades also WeKan ® to newest available WeKan ® version.
- Newer version of WeKan ® will be released when building and testing is done.
- [RocketChat Webhook workaround](https://github.com/wekan/univention/issues/15)
## Feature Requests and Bugs
[WeKan ® for Univention Feature Requests and Bugs](https://github.com/wekan/univention/issues)
## Gantt
[How to use Gantt](Gantt)
UCS WeKan v5.71 and newer is using WeKan Gantt GPL version. [Source](https://github.com/wekan/wekan/issues/2870#issuecomment-954598565).
## Email on Univention
[Source](https://github.com/wekan/univention/issues/6#issuecomment-607986717)
### 1) WeKan ® product page, scroll down
![ucs-mail-1](https://user-images.githubusercontent.com/15545/78279227-e682f700-751f-11ea-83fc-d22bc71b77fb.png)
### 2) Click APP SETTINGS
![ucs-mail-2](https://user-images.githubusercontent.com/15545/78279301-fdc1e480-751f-11ea-9d7b-1632c71cd79a.png)
### 3) Mail Settings
https://github.com/wekan/wekan/wiki/Troubleshooting-Mail
![ucs-mail-3](https://user-images.githubusercontent.com/15545/78279359-129e7800-7520-11ea-9e22-a911826285ba.png)
# Repairing MongoDB
https://github.com/wekan/wekan/wiki/Repair-MongoDB

25
docs/Platforms/Ubuntu-Core.md Normal file
View file

@ -0,0 +1,25 @@
## Install
On [Ubuntu Core KVM Download page](https://ubuntu.com/download/kvm) local x64 VM:
```
ssh -p 8022 username@localhost
snap install wekan
snap set wekan root-url='http://localhost:8090'
snap set wekan port='80'
```
Then Wekan is visible at http://localhost:8090
[Adding users](Adding-users)
List of Wekan Snap settings:
```
wekan.help | less
```
More info about Wekan Snap [Snap Install page](https://github.com/wekan/wekan-snap/wiki/Install) and right menu on that page.
[Documentation](https://github.com/wekan/wekan/wiki)

40
docs/Platforms/Vagrant.md Normal file
View file

@ -0,0 +1,40 @@
## Using Vagrant and VirtualBox on an Ubuntu 16.04 64bit
1) Download Vagrant https://www.vagrantup.com/
and Virtualbox https://www.virtualbox.org/wiki/Downloads
2) In CMD or BASH `mkdir wekan_vagrant`
3) `cd wekan_vagrant`
4) `vagrant init -m ubuntu/xenial64`
5) Open up the vagrantfile in a text editor and copy this into it:
```
Vagrant.configure("2") do |config|
config.vm.box = "ubuntu/xenial64"
config.vm.provision :shell, path: "bootstrap.sh"
config.vm.network "forwarded_port", guest: 8080, host: 8080
config.vm.provider "virtualbox" do |v|
v.memory = 2048
v.cpus = 2
end
end
```
6) Create a new text file in the same folder and call it bootstrap.sh
7) Copy this into the sh file
```
#!/usr/bin/env bash
sudo apt-get update
sudo snap install wekan
sudo snap set wekan root-url="http://localhost:8080"
sudo systemctl restart snap.wekan.wekan
```
8) Type 'vagrant up' to start the VM and wait for it to boot.
9) Got to your local browser and type in `localhost:8080`
10) You can go inside VM with `vagrant ssh`
11) Look at [Ubuntu snap wiki](https://github.com/wekan/wekan-snap/wiki) for additional configuration, backups etc
## Deleting
Once your done testing your Vagrantbox just go back to the cmd line and type `vagrant destroy` And it completely wipes any trace of the test environment from your system, however you can very very easily rebuild it by doing another `vagrant up` **Note: This will not save any data you may have put into Wekan!!!**

1
docs/Platforms/Vultr.md Normal file
View file

@ -0,0 +1 @@
https://www.vultr.com/docs/install-wekan-on-debian-10

69
docs/Platforms/WSL.md Normal file
View file

@ -0,0 +1,69 @@
https://learn.microsoft.com/en-us/windows/wsl/install
```
wsl --install
wsl --list --online
wsl --install -d Ubuntu-22.04
```
https://ubuntu.com/blog/ubuntu-wsl-enable-systemd
## If GitHub problems in WSL
If you have these problems in WSL:
```
~/repos/wekan$ git pull
ssh: Could not resolve hostname github.com: Name or service not known
fatal: Could not read from remote repository.
Please make sure you have the correct access rights
and the repository exists.
```
Then edit `/etc/wsl.conf`:
```
sudo nano /etc/wsl.conf
```
There have these:
```
[boot]
systemd=true
[network]
generateResolvConf = false
```
Then edit `/etc/resolf.conf`:
```
sudo nano /etc/resolv.conf
```
There have for example this, CloudFlare nameserver:
```
nameserver 1.1.1.1
```
Then edit Windows Internet network settings. There:
- Have only IPv4 enabled (not IPv6)
- DNS: 1.1.1.1 with HTTPS Automatic encryption settings.
## WeKan Snap amd64 on WSL2
1. At https://ubuntu.com/blog/ubuntu-wsl-enable-systemd read `How to enable systemd in Ubuntu WSL` to install WSL2 and SystemD.
2. `sudo snap install wekan --channel=latest/candidate`
3. Your Windows computer IP address, change there: `sudo snap set wekan root-url='http://192.168.0.200'`
4. Your Windows compoter webserver port: `sudo snap set wekan port='80'`
5. Use Chromium Edge (or Chromium/Firefox/Safari based browsers) to browse http://192.168.0.200 (your computer IP address there)
6. For mobile devices, make PWA icon like https://github.com/wekan/wekan/wiki/PWA
7. Optional: For SSL/TLS, look at Caddy/Apache/Nginx configs at https://github.com/wekan/wekan/wiki right menu, and https://github.com/wekan/wekan/wiki/Settings
## Related
- https://github.com/wekan/wekan/wiki/Offline
- https://ubuntu.com/blog/ubuntu-wsl-enable-systemd
- https://github.com/wekan/wekan-snap/wiki/Install
- https://github.com/wekan/wekan/wiki/Windows

36
docs/Platforms/Wekan-vs-Sandstorm.md Normal file
View file

@ -0,0 +1,36 @@
This is totally oversimplified TLDR comparison that leaves out a lot of details.
## Both Wekan and Sandstorm
* Authentication
* Admin Panel
* Wekan kanban board
* Can be installed to Ubuntu 16.04 64bit without Docker
* Can run inside Docker, see [Sandstorm within Docker](https://docs.sandstorm.io/en/latest/install/#option-6-using-sandstorm-within-docker)
## Difference: User interface
### Wekan
[Themes feature](https://github.com/wekan/wekan/issues/781), pull requests welcome.
### Sandstorm
[Themes feature](https://github.com/sandstorm-io/sandstorm/issues/1713#issuecomment-301274498), pull requests welcome.
[Current Admin Panel / Authentication screenshots](https://discourse.wekan.io/t/sso-passing-variables-through-url/493/8).
The user interface in Sandstorm is one of Sandstorm's [long list of high-end security features](https://docs.sandstorm.io/en/latest/using/security-practices/) protecting potentially malicious applications running on Sandstorm sandboxes/grains to hijack whole full screen interface and do phishing of information, stealing admin credentials when replacing admin menus, etc. It's black to be totally recognizable and different from other applications. Having it hidden or on not so dark would make new users to not find it. There has been usability testing of Sandstorm's user interface. Sandstorm has been fully security audited and found problems fixed already.
## Difference: Hardware requirements
### Wekan
* Can run on less powerful hardware than Sandstorm
* Could potentially run on ARM, if there is Meteor.js port for ARM. Some platform running on Raspberry Pi could already have Wekan, someone needs to do more research about it.
### Sandstorm
* Works only on x64 platform
* Requires at least 1GB RAM
* Is very efficient in handling RAM, shutting down sandboxes/grains when they are not in use.

262
docs/Platforms/Windows.md Normal file
View file

@ -0,0 +1,262 @@
Use these instructions instead: [Offline](Offline)
***
Windows Updates:
1) WuMgr: Windows Update but Not Automatic
- https://github.com/DavidXanatos/wumgr
- https://news.ycombinator.com/item?id=34175466
2) Legacy Update
- https://legacyupdate.net
- https://news.ycombinator.com/item?id=34019900
3) Win7 Extended Security Updates Ending
- https://news.ycombinator.com/item?id=34307029
- How to create Win7.iso with all updates
- https://www.youtube.com/watch?v=l5ADP-VZMsw
- https://en.wikipedia.org/wiki/Windows_Update_MiniTool
4) Snappy Driver installer
- https://sdi-tool.org
***
## OLD BELOW: a) Bundle with Windows Node+MongoDB
This has **highest performance and lowest RAM usage**, because there is no virtualization like Docker, Windows Subsystem for Linux, etc. Wekan is run with Windows native version of Node.js and MongoDB, directly at Windows filesystem.
1. If you have important data in Wekan, do [backup](Backup).
2. Install newest Node.js LTS v12.x for Windows from https://nodejs.org . When installing, checkmark "Install additional tools" that will install also Chocolatey etc.
3. Run cmd.exe as Administrator, and there type:
```
choco install -y mongodb
```
4. Download and newest Wekan bundle wekan-x.xx.zip from https://releases.wekan.team
5. Unzip wekan-x.xx.zip, it has directory name `bundle`
6. Download [start-wekan.bat](https://raw.githubusercontent.com/wekan/wekan/master/start-wekan.bat) to your bundle directory. Default settins are: `ROOT_URL=http://localhost` and `PORT=80`, so it works only in local [compatible browser](Browser-compatibility-matrix). You can edit [ROOT_URL](Settings) to be or `http://YOUR-IP-ADDRESS` so it works on local network with `http://YOUR-IP-ADDRESS` .
7. Start Wekan in cmd.exe as Administrator:
```
cd bundle
start-wekan.bat
```
8. Start MongoDB cmd.exe as Administrator:
```
net start mongodb
```
You can also stop MongoDB this way:
```
net stop mongodb
```
When you have MongoDB running, you can connect to database with nosqlbooster GUI, to localhost 27017.
You can create backup of MongoDB database with this mongodump command, that is similar to mysqldump:
```
"C:\Program Files\MongoDB\Server\4.2\bin\mongodump"
```
It will create subdirectory `dump` that contains backup. You can restore with:
```
"C:\Program Files\MongoDB\Server\4.2\bin\mongorestore"
```
You can connect to MongoDB CLI with this command:
```
"C:\Program Files\MongoDB\Server\4.2\bin\mongo"
```
There you can show databases. One MongoDB server can have many databases, similarly like MySQL server can have many databases created with MySQL `CREATE DATABASE` command:
```
show dbs
```
Then use Wekan database:
```
use wekan
```
List wekan database collections/tables:
```
show collections
```
Show content of users collection/table:
```
db.users.find()
```
Create new database:
```
use testing
```
Delete current database:
```
db.dropDatabase()
```
List databases again to show that database testing is not there anymore:
```
show dbs
```
Also see [Forgot Password](Forgot-Password)
Exit MongoDB CLI:
```
exit
```
You should not backup Windows MongoDB RAW database files that are here, when you in File Explorer folder properties show hidden system files and file extensions:
```
C:\ProgramData\MongoDB\data\db
```
[More info about MongoDB](Export-from-Wekan-Sandstorm-grain-.zip-file)
9. [Add users](Adding-users).
***
## b) [Docker](Docker)
Note: With Docker, please don't use latest tag. Only use release tags. See https://github.com/wekan/wekan/issues/3874
[Repair Docker](Repair-Docker)
If you don't need to build Wekan, use prebuilt container with docker-compose.yml from https://github.com/wekan/wekan like this:
```
docker-compose up -d
```
If you like to build from source, clone Wekan repo:
```
git clone https://github.com/wekan/wekan
```
Then edit docker-compose.yml with [these lines uncommented](https://github.com/wekan/wekan/blob/main/docker-compose.yml#L132-L142) this way:
```
#-------------------------------------------------------------------------------------
# ==== BUILD wekan-app DOCKER CONTAINER FROM SOURCE, if you uncomment these ====
# ==== and use commands: docker-compose up -d --build
build:
context: .
dockerfile: Dockerfile
args:
- NODE_VERSION=${NODE_VERSION}
- METEOR_RELEASE=${METEOR_RELEASE}
- NPM_VERSION=${NPM_VERSION}
- ARCHITECTURE=${ARCHITECTURE}
- SRC_PATH=${SRC_PATH}
- METEOR_EDGE=${METEOR_EDGE}
- USE_EDGE=${USE_EDGE}
#-------------------------------------------------------------------------------------
```
Then you can build Wekan with
```
docker-compose up -d --build
```
## c) Windows Subsystem for Linux on Windows 10
- [Install Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/wsl2-install) in PowerShell as Administrator `Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux` and reboot
- Install Ubuntu 18.04 from Windows Store
If you don't need to build from source, download newest wekan-VERSION.zip from https://releases.wekan.team and unzip it. Then:
```
sudo apt update
sudo apt install npm mongodb-server mongodb-clients
sudo npm -g install n
sudo n 12.16.1
sudo npm -g install npm
```
Then edit `start-wekan.sh` to start at correct port, ROOT_URL setting, and MONGO_URL to port 27017, cd to correct bundle directory where `node main.js` can be run, and then:
```
./start-wekan.sh
```
More info at https://github.com/wekan/wekan/wiki/Raspberry-Pi
- You could try to proxy from IIS SSL website to Wekan localhost port, for example when ROOT_URL=https://example.com and PORT=3001 , and you make IIS config that supports websockets proxy to Wekan http port 3001.
If you need to build from source, do as above, and build Wekan with `wekan/rebuild-wekan.sh`.
After building, if you like to start meteor faster by excluding some parts, have rebuilds after file change, and test on local network devices, try with your computer IP address:
```
WITH_API=true RICHER_CARD_COMMENT_EDITOR=false ROOT_URL=http://192.168.0.200:4000 meteor --exclude-archs web.browser.legacy,web.cordova --port 4000
```
## d) VirtualBox with Ubuntu 19.10 64bit
Install Ubuntu to VirtualBox and then Wekan, for example Wekan Snap.
Currently Snap works only when installed to Ubuntu 19.10 64bit running on VirtualBox VM.
https://github.com/wekan/wekan-snap/wiki/Install
[Related VM info how to expose port with bridged networking](Virtual-Appliance)
[UCS has prebuilt VirtualBox VM](Platforms#production-univention-platform-many-apps-and-wekan)
***
# BELOW: DOES NOT WORK
## e) Probaby does not work
[Install from source directly on Windows](Install-Wekan-from-source-on-Windows) to get Wekan running natively on Windows. [git clone on Windows has been fixed](https://github.com/wekan/wekan/issues/977). Related: [running standalone](https://github.com/wekan/wekan/issues/883) and [nexe](https://github.com/wekan/wekan/issues/710).
## f) Install Meteor on Windows - does not build correctly, gives errors
https://github.com/zodern/windows-meteor-installer/
```
REM Install Chocolatey from
REM https://chocolatey.org/install
REM in PowerShell as Administrator
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
REM Install with cmd.exe or PowerShell as Administrator
REM - nodejs-lts, that is 12.x
REM - ndm, that is npm package manager for Windows
choco install -y nodejs-lts ndm git
REM Close and open cmd.exe or PowerShell as normal user.
REM Update npm:
npm -g install npm
REM Install meteor using https://github.com/zodern/windows-meteor-installer/
npm i -g @zodern/windows-meteor-installer
REM Close and open cmd.exe or PowerShell as normal user.
git clone https://github.com/wekan/wekan
cd wekan
REM a) For development, available at local network, at your computer IP address. Does rebuild when code changes.
SET WITH_API=true
SET RICHER_CARD_EDITOR=false
SET ROOT_URL=http://192.168.0.200:4000
meteorz --port 4000
REM b) For development, available only at http://localhost:4000 . Does rebuild when code changes.
SET WITH_API=true
SET RICHER_CARD_EDITOR=false
meteorz --port 4000
REM c) For production, after Wekan is built to "wekan/.build/bundle",
REM edit "start-wekan.bat" to "cd" to correct bundle directory to run "node main.js"
```
## g) Snap
[WSL](WSL)
## Related
[Linux stuff in Windows 10 part 1](https://cepa.io/2018/02/10/linuxizing-your-windows-pc-part1/) and [part 2](https://cepa.io/2018/02/20/linuxizing-your-windows-pc-part2/).

84
docs/Platforms/ppc.md Normal file
View file

@ -0,0 +1,84 @@
## About OpenPower
- [OpenPOWER Foundation](https://openpowerfoundation.org)
- [University of Campinas - Unicamp Minicloud](https://openpower.ic.unicamp.br), that was before available, but now is closed
[xet7](https://github.com/xet7), as maintainer of [Wekan](https://wekan.github.io), got access to ppc64le at
at University of Campinas - Unicamp Minicloud. Unicamp is member of [OpenPOWER Foundation](https://openpowerfoundation.org). At Minicloud OpenStack, xet7 created Ubuntu 20.10 VM, and at 2020-12-22 ported Wekan to ppc64le very similarly like previously for [s390x](s390x).
## Installing MongoDB on OpenPower Ubuntu 20.04 ppc64le
This Snap package https://snapcraft.io/juju-db , created by Canonical, has MongoDB for various CPU architectures . It is internal package for Canonical's Juju service https://jaas.ai . Snap repo at https://github.com/juju/juju-db-snap and copy at https://github.com/wekan/mongodb-snap
```
ssh yourserver
sudo apt install snapd nano
sudo reboot
sudo snap install juju-db
sudo snap refresh juju-db --channel=5.3/stable
sudo snap enable juju-db
sudo snap start juju-db
nano .bashrc
```
There add path to commands mongo, mongodump, mongorestore etc
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/juju-db/138/usr/lib/powerpc64le-linux-gnu
export PATH="$PATH:/snap/juju-db/138/bin"
```
Save and exit: Ctrl-o Enter Ctrl-x
Now MongoDB is at localhost port 27017. You connect to CLI with command:
```
mongo
```
## Download
- wekan-VERSION-ppc64le.zip at https://releases.wekan.team/ppc64le/
- nodejs for linux ppc64le at https://nodejs.org/dist/latest-v14.x/
## Install
Installing is similar like at https://github.com/wekan/wekan/wiki/Raspberry-Pi
You can start it with start-wekan.sh from https://github.com/wekan/wekan or add SystemD service.
Setup ROOT_URL like described at https://github.com/wekan/wekan/wiki/Settings
At https://github.com/wekan/wekan/wiki is also info about Caddy/Nginx/Apache etc.
Some related links also at https://github.com/wekan/wekan/wiki/Platforms
## How this ppc64le bundle package was created
1. Install Node.js
2. scp wekan-VERSION.zip bundle to ppc64le server, and unzip it
2. Clone and build Fibers, copy fibers to bundle, and zip bundle.
```
git clone https://github.com/laverdet/node-fibers
cd node-fibers
npm install
node build.js
cd ..
cp -pR /home/ubuntu/node-fibers/bin/linux-ppc64-72-glibc bundle/programs/server/node_modules/fibers/bin/
zip -r wekan-VERSION-ppc64le.zip bundle
```
## OLD INFO: About MongoDB for OpenPower
Working:
- Official MongoDB binaries for OpenPower are available as part of MongoDB Enterprise subscription.
Other options:
- There is no Community version of MongoDB binaries for OpenPower available, like there is for other CPUs like x64/arm64/s390x.
- xet7 did not yet get MongoDB successfully built from source for OpenPower.
- There are some unofficial MongoDB Docker images by random people, but they could be old versions of MongoDB, and there is no guarantee they don't have any malicious code.
- If sometime in the future some working database binaries become available, link to them will be added here.
- If sometime in the future support for other databases is added to Wekan, info about it could be added here, although adding support for other databases could be a lot of work.

202
docs/Platforms/s390x.md Normal file
View file

@ -0,0 +1,202 @@
## About s390x
- Dave's Garage at 2023-10: Why Do Mainframes Still Exist? What's Inside One? 40TB, 200+ Cores, AI, and more! https://www.youtube.com/watch?v=ouAG4vXFORc
- https://en.wikipedia.org/wiki/Linux_on_IBM_Z
- [FLOSS 564 Interview about Open Mainframe Project](https://twit.tv/shows/floss-weekly/episodes/564?autostart=false)
- [Open Mainframe Project](https://www.openmainframeproject.org)
- [LinuxOne Community Cloud](https://developer.ibm.com/linuxone/)
- [SWLUG Talk - Linux on the IBM Z mainframe platform](https://www.youtube.com/watch?v=V-5dqnTd09k)
- https://wiki.qemu.org/Documentation/Platforms/S390X
- https://arstechnica.com/information-technology/2023/07/the-ibm-mainframe-how-it-runs-and-why-it-survives/
- https://sdl-hercules-390.github.io/html/
- Big-endian s390x https://community.ibm.com/community/user/ibmz-and-linuxone/blogs/javier-perez1/2021/01/19/endianness-guidance-for-open-source-projects
***
## Petclinic s390x
2024-01-20 Petclinic fork https://github.com/xet7/pet , with command `blink redbean.com`
- With Petclinic website, it is possible to add pets, visits to clinic, etc. There is no login system, it is possible to add to database directly at website http://127.0.0.1:8000/ or http://YOUR-COMPUTER-IP-ADDRESS:8000/
- When xet7 added issue about blink segfault at s390x, 5 minutes later jart added fix https://github.com/jart/blink/issues/162
- Blink is x86_86 emulator, similar to qemu https://github.com/jart/blink . With blink, it works at Linux s390x. Without blink, it works at x86_86/arm64 Win/Mac/Linux/BSD, but ASAN security feature does not work yet at arm64, like mentioned at Makefile of https://github.com/xet7/pet . If there is errors, maybe you need to run it with `chmod +x redbean.com && sh -c ./redbean.com`, or also need to install `ape` from https://github.com/jart/cosmopolitan .
- Redbean is webserver https://redbean.dev
- Fullmoon is Lua web framework https://github.com/pkulchenko/fullmoon . Petclinic has fork of Fullmoon, making possible to use SQLite across CGI-like Lua processes of Redbean, like mentioned at Readme https://github.com/xet7/pet
- SQLite has triggers, and it's possible to Redbean's cron like scheduled actions
- By using Makefile with `make all` or `make start` it makes one executeable. When starting, it creates SQLite database to same directory, adding data, with `srv/.lua/*.sql`
- At fork https://github.com/xet7/pet , xet7 added all external `.sql`, Javascript and CSS dependencies directly inside executeable. This can be seen at Makefile, where files from `srv` directory are are added to `.zip` file, that is added to end of `redbean.com` executeable.
- Releases at https://github.com/xet7/pet/releases
### Petclinic Benchmark
At Makefile, xet7 fixed `make benchmark` of wrk benchmarks to to work at Mac M1 `brew install wrk` and Linux `sudo apt install wrk` . But wrk does not yet work at s390x, xet7 added issue about it to https://github.com/jart/blink/issues/163 . If you start with silent mode `./redbean.com -s` , then at M1 Air macOS Sonoma is this benchmark:
```
~/Downloads/pet$ make benchmark
wrk -H 'Accept-Encoding: gzip' -t 12 -c 120 http://127.0.0.1:8000/
Running 10s test @ http://127.0.0.1:8000/
12 threads and 120 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 73.21ms 136.41ms 1.25s 86.04%
Req/Sec 7.72k 12.48k 65.33k 89.46%
600013 requests in 10.09s, 708.40MB read
Socket errors: connect 0, read 427, write 2, timeout 0
Requests/sec: 59485.18
Transfer/sec: 70.23MB
```
### Lua IDE
- It is possible to show hidden files like `.gitignore` with Lua IDE, ZeroBrane Studio, this way, and also debug redbean: https://github.com/xet7/pet/wiki/Redbean
### QuickJS
- Unrelated to Lua, there is also QuickJS (similar like Node.js/Bun/Deno), where it is possible to embed Javascript to same Cosmopolitan x86_85/arm64 Win/Mac/Linux/BSD executeable binary https://github.com/xet7/pet/wiki/QuickJS
***
## Other non-WeKan Open Source projects xet7 tried to build at s390x
- Works:
- TSC platform game, C++ https://secretchronicles.org/en/news/2020/11/16/tsc-for-s390x-available/
- Darkest Hour halloween text adventure game, C89, xet7 ported to 30+ CPU/OS https://github.com/xet7/darkesthour
- Does not work yet:
- V https://github.com/vlang/v/issues/18737
- LLVM, Zig, Bun https://github.com/wekan/wekan-node20#trying-to-compile-llvm-for-zig-and-bun-at-s390x-fails
- Deno, because Rust ring (a crypto dependency) does not support s390x https://github.com/wekan/wekan-node20#trying-to-compile-deno-for-s390x-fails
Ported by others, not xet7:
- PostreSQL https://news.ycombinator.com/item?id=38398305
## From xet7, WeKan at s390x
- https://www.openmainframeproject.org/blog/2020/11/20/wekan-open-source-kanban-on-s390x
[xet7](https://github.com/xet7), as maintainer of [WeKan](https://wekan.github.io), got access to mainframe at IBM LinuxOne Community Cloud. Access to those servers is monitored, it's running on a real mainframe.
Previously xet7 had ssh access. At 2023-09 xet7 got web console access, and IBM bumped quota to 2 VMs with 8 GB of memory, 200 GB disk and 4 CPUs each. At web console it is possible to create and remove VMs, and select distro like RHEL/SUSE/Ubuntu. xet7 did do-release-upgrade to upgrade newest Ubuntu 23.10.
## Download
- wekan-VERSION-s390x.zip at https://releases.wekan.team/s390x/
## Installing MongoDB for s390x
This Snap package https://snapcraft.io/juju-db , created by Canonical, has MongoDB for various CPU architectures . It is internal package for Canonical's Juju service https://jaas.ai . Snap repo at https://github.com/juju/juju-db-snap and copy at https://github.com/wekan/mongodb-snap
Install Snap for your distro https://snapcraft.io/docs/installing-snapd
Then:
```
ssh yourserver
sudo dnf install nano
sudo reboot
sudo snap install juju-db
sudo snap refresh juju-db --channel=5.3/stable
sudo snap enable juju-db
sudo snap start juju-db
nano .bashrc
```
There add path to commands mongo, mongodump, mongorestore etc
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/juju-db/139/usr/lib/s390x-linux-gnu
export PATH="$PATH:/snap/juju-db/139/bin"
```
Save and exit: Ctrl-o Enter Ctrl-x
Exit ssh, and ssh to server again,
```
exit
ssh yourserver
```
Or alternatively just read new paths to mongo etc commands:
```
source .bashrc
```
Now MongoDB is at localhost port 27017. You connect to CLI with command:
```
mongo
```
### RHEL 8
New info 2022-01-18:
1. Install snapd https://snapcraft.io/docs/installing-snap-on-red-hat
2. Reboot
3. Install MongoDB, so it will be at port 27017:
```
sudo snap install mongo36-configurable
```
4. Install WeKan s390x bundle from:
- [Raspberry Pi](Raspberry-Pi)
- https://releases.wekan.team/s390x/
Old info:
```
sudo yum -y update
sudo yum -y install git nano npm curl wget podman-docker openssl-devel libcurl-devel clang zip unzip
docker run --name wekan-db -d -p 127.0.0.1:27017:27017 mongo
sudo npm -g install n
sudo n 12.18.0 ## newest 12.x from https://nodejs.org
mkdir repos
cd repos
git clone https://github.com/wekan/wekan
cp wekan/start-wekan.sh .
nano start-wekan.sh
# Edit start-wekan.sh for ports and paths, so starts
# "node main.js" at "build" directory".
# Look for version number from https://releases.wekan.team/s390x/
wget https://releases.wekan.team/s390x/wekan-VERSION-s390x.zip
unzip wekan*s390x.zip
./start-wekan.sh
```
### RHEL 7
Node.js LTS newest 12.x release for s390x can be downloaded from https://nodejs.org
MongoDB v4.x Community Server for s390x RHEL7 is at https://www.mongodb.com.
For example files can be like these filenames:
- mongodb-org-mongos-4.2.3-1.el7.s390x.rpm
- mongodb-org-server-4.2.3-1.el7.s390x.rpm
- mongodb-org-shell-4.2.3-1.el7.s390x.rpm
- mongodb-org-tools-4.2.3-1.el7.s390x.rpm
## Install
Installing is similar like at [Raspberry Pi](Raspberry-Pi)
You can start it with start-wekan.sh from https://github.com/wekan/wekan or add SystemD service.
Setup ROOT_URL like described at [Settings](Settings)
At wiki is also info about Caddy/Nginx/Apache etc.
Some related links also at [Platforms](Platforms)
## How this s390x bundle package was created for RHEL 7
1. Install Node.js
2. scp wekan-VERSION.zip bundle to s390x server, and unzip it
2. Clone and build Fibers, copy fibers to bundle, and zip bundle.
```
git clone https://github.com/laverdet/node-fibers
cd node-fibers
node build.js
cd ..
cp -pR /home/linux1/node-fibers/bin/linux-s390x-72-glibc bundle/programs/server/node_modules/fibers/bin/
zip -r wekan-VERSION-s390x.zip bundle
```

158
docs/Platforms/virtual-appliance.md Normal file
View file

@ -0,0 +1,158 @@
## Virtual Appliance by xet7
Requirements: [VirtualBox version 5.2.22 or newer](https://www.virtualbox.org/). Old versions of VirtualBox are not compatible. Both of these have username: wekan , password: wekan , Network Bridged mode so VM has separate IP address so you can also ssh to it.
[Wekan for VirtualBox bug reports and feature requests](https://github.com/wekan/wekan/issues)
a) For general Wekan usage: Only Wekan and building it from source in Ubuntu 14.04 64bit VM.
Download wekan-VERSION.ova at https://releases.wekan.team
b) For Developers, only this one Wekan-Sandstorm.ova needed for all development: for compiling Wekan, Sandstorm, Wekan for Sandstorm, etc, all. Also has Snap, Docker, Firefox, Chrome, Visual Studio Code with Meteor.js additions, GHex hex editor, etc. Based on Debian 9 64bit. Also see https://github.com/sandstorm-io/sandstorm/issues/3047#issuecomment-369002784 about what dependencies were installed for compiling Sandstorm, although after that dependencies have been changed to [automatically download up-to-date Clang from Chromium project](https://github.com/sandstorm-io/sandstorm/commit/4463c3f52093de8f0c546c93cd55a7bb556aa9d7), so it's easier to compile Sandstorm also on Ubuntu, without using Clang ppa.
Wekan-Sandstorm-VERSION.ova at https://releases.wekan.team
### Build scripts
[Scripts from virtual appliance](https://github.com/wekan/wekan-maintainer/tree/master/virtualbox), can be used on any Ubuntu 14.04 64bit or Debian 9 or newer install like native or VM. Includes script how to run Node.js on port 80.
### Wekan Meteor 1.4 and Node.js v4.x version on Ubuntu 14.04 64bit desktop, Gnome fallback, in VirtualBox
- Ubuntu 14.04 64bit desktop with latest updates.
- Wekan installed from source.
- Includes VirtualBox Guest Additions.
### Download
.ova files can be downloaded at https://releases.wekan.team
VirtualBox .ova file contains harddisk image that has current size of 16 GB and maximum growable size of 500GB.
You can enlarge it with VBoxManage command and then starting with LiveCD iso deleting logical swap and
extended and resizing and creating extended and inside it logical swap.
Size of this VirtualBox image has been reduced: [http://acidx.net/wordpress/2014/03/how-to-reduce-the-size-of-virtualbox-vms/](http://acidx.net/wordpress/2014/03/how-to-reduce-the-size-of-virtualbox-vms/).
Use 7zip (Windows) or p7zip (Linux etc) to unarchive.
### Updating VirtualBox image to have newest Wekan
Download newest VirtualBox scripts:
[https://github.com/wekan/wekan-maintainer/tree/master/virtualbox](https://github.com/wekan/wekan-maintainer/tree/master/virtualbox)
There is script rebuild-wekan-meteor-1.6.sh
First do some sudo command so you get to insert sudo password, for example:
```
sudo ls
```
Then run script as as normal user:
```
./rebuild-wekan-meteor-1.6.sh
```
Run it with option 1 at first to install dependencies, and then option 3 to rebuild source code.
### Updating to newest Ubuntu updates
```
sudo apt-get update
```
( password: wekan )
```
sudo apt-get -y dist-upgrade
```
### Instructions
When using VirtualBox bridged mode, you can browse from other computer to http://ipadress
to use Wekan. Node runs on port 80 and is started from /etc/rc.local on boot.
See also README.txt at Ubuntu desktop, scripts at ~/repos directory, and
/home/wekan/.bash_history how it was installed, including typos :)
To login to the virtual machine with ssh port 22:
username: wekan
password: wekan
### Install VirtualBox
VirtualBox is available for example Windows, Mac, Linux and Solaris from:
* VirtualBox website: [https://virtualbox.org](https://virtualbox.org)
### How to use
a) Import Virtual Appliance .ova
b) Extract .ova to use as .vmdk for virtualization raw .img for Qubes OS:
[https://www.qubes-os.org/doc/hvm/#converting-virtualbox-vm-to-hvm](https://www.qubes-os.org/doc/hvm/#converting-virtualbox-vm-to-hvm)
These settings are for example with VirtualBox:
* new Ubuntu 64bit VM
* 2GB RAM
* Add Wekan.vmdk as harddisk.
* Not needed usually: Audio, Serial Ports, USB
* Network: If you select Bridged Adapter, name is your network you use, like eth0 / exp9s0 for Ethernet, and there's also wlan etc if available:
![BridgedAdapter.png](https://wekan.github.io/BridgedAdapter.png)
If you select NAT to keep virtual machine using same address as your server:
![NAT.png](https://wekan.github.io/NAT.png)
Then you can also setup port forwarding to Wekan VM port 8080:
![PortForwarding.png](https://wekan.github.io/PortForwarding.png)
2) Start VM
3) To access Wekan on local network, setup ROOT_URL to your IP address at /home/wekan/repos/start-wekan.sh inside VM.
```
cd repos
./stop-wekan.sh
nano start-wekan.sh
```
4) Add have there your IP address, for example:
```
export ROOT_URL=http://192.168.1.200
export MAIL_URL=smtp://user:pass@mailserver.example.com:25/
export MAIL_FROM='Example Wekan Support <support@example.com>'
```
5) Save with Ctrl-o Enter and after that exit with Ctrl-x
6) Allow port 80 and start Wekan:
```
./node-allow-port-80.sh
./start-wekan.sh
```
7) Access Wekan at your network with IP address of VM, for example
More details of settings at:
[https://github.com/wekan/wekan-mongodb/blob/master/docker-compose.yml](https://github.com/wekan/wekan-mongodb/blob/master/docker-compose.yml)
## Virtual Appliance by anselal
You can download a virtual appliance from https://github.com/anselal/wekan/releases
To login to the virtual machine use:
* username: wekan
* password: wekan
You can find more information at https://github.com/anselal/wekan including the script which was used to create the Virtual Appliance.