github-mirrors/wekan
1
0
Fork 0
mirror of https://github.com/wekan/wekan.git synced 2025-04-23 13:37:09 -04:00
Code Issues Projects Releases Packages Wiki Activity

Added docs from wekan.wiki and wekan-snap.wiki

Browse source
This commit is contained in:
Lauri Ojansivu 2024-03-08 21:24:14 +02:00
parent 76175a711a
commit 73ae73d4c3
198 changed files with 18189 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

27
docs/wekan-snap.wiki/Automatic-update-schedule.md Normal file
View file

@ -0,0 +1,27 @@
## a) Install all Snap updates automatically between 02:00AM and 04:00AM
```
snap set core refresh.schedule=02:00-04:00
```
## b) Update once a week at Sunday between 02:00AM and 04:00AM
```
snap set core refresh.schedule=sun,02:00-04:00
```
## c) Update last Sunday of the month between 02:00AM and 04:00AM
```
snap set core refresh.schedule=sun5,02:00-04:00
```
## [Update until specific day](https://snapcraft.io/docs/keeping-snaps-up-to-date#heading--refresh-hold) and other examples.
## If required, you can disable all Snap updates
at `/etc/hosts` by adding a line:
```
127.0.0.1 api.snapcraft.io
```
## No schedule set
Automatic upgrades happen sometime after Wekan is released, usually quite soon.
## Manual update immediately
`sudo snap refresh`

96
docs/wekan-snap.wiki/Backup-and-restore.md Normal file
View file

@ -0,0 +1,96 @@
Also see [Docker Backup and Restore](https://github.com/wekan/wekan/wiki/Export-Docker-Mongo-Data)
# MongoDB client based backup
## Install MongoDB shell 3.2.x
[MongoDB 3.2.x shell for Ubuntu](https://docs.mongodb.com/v3.2/tutorial/install-mongodb-on-ubuntu/)
## Backup script for MongoDB Data, if running Snap MongoDB at port 27019
```sh
#!/bin/bash
now=$(date +'%Y-%m-%d_%H.%M.%S')
mkdir -p backups/$now
cd backups/$now
mongodump --port 27019
# if running on source install, run for example: mongodump --port 27017)
cd ..
zip -r $now.zip $now
cd ../..
echo "\nBACKUP DONE."
echo "Backup is at directory backups/${now}."
echo "Backup is also archived to .zip file backups/${now}.zip"
```
# Manual Backup
## Stop Wekan and Backup to directory called dump
```
sudo snap stop wekan.wekan
mongodump --port 27019
sudo snap start wekan.wekan
```
## Stop Wekan and Restore
```
sudo snap stop wekan.wekan
## Only if you get errors about existing indexes, use this instead:
## mongorestore -d wekan --drop --noIndexRestore --port 27019
mongorestore -d wekan --drop --port 27019
sudo snap start wekan.wekan
```
***
# Snap based backup (less reliable, can disappear with snap remove wekan)
## Setup backup directory
Create backup directory and set permissions
```
$ sudo mkdir /var/snap/wekan/common/db-backups
$ sudo chmod 777 /var/snap/wekan/common/db-backups
```
## Backup
As normal user as archive:
```
$ wekan.database-backup
```
Backup is created in directory:
```
/var/snap/wekan/common/db-backups
```
There is optional Backup file is optional parameter `$ wekan.database-backup BACKUPFILENAME`, but probably it does not work.
## List backups
You need to first create one backup, otherwise this command shows error.
To list existing backups in default directory, as normal user:
```
$ wekan.database-list-backups
```
## Restore backup
As normal user:
```
$ wekan.database-restore FULL-PATH-TO-BACKUP-FILENAME
```

276
docs/wekan-snap.wiki/Candidate-WeKan-Snap-Manual-Upgrade.md Normal file
View file

@ -0,0 +1,276 @@
# NOTE: Using Candidate, that has MongoDB 6, that is newest version
Required time: If your database size is 500 GB, maybe 4 to 8 hours, or more. So bring enough of pizza, party snacks, limonade etc.
Warning: If you don't have enough disk space, you could get data loss.
Warning2: When starting WeKan Candidate, it could temporarily save all attachments to `/var/snap/wekan/common/files/` or other directory below `common`. That's why xet7 is working on trying to create separate migration app that moves attachments to S3, and that WeKan could upload to S3. This upgrade experience could be improved later. It's just that there are some unknown unknows if there would be automatic upgrade, could it handle all upgrade and migration cases.
If you are have time to try tro update Snap from WeKan Stable to newest WeKan Candidate, to see does update work or not.
If you have problems, add comment to issue https://github.com/wekan/wekan/issues/4780
## From WeKan Stable to Candidate
### Preparation
#### 1. Please read through all these below steps before starting, if possible.
#### 2. Check your database size, and do you have enough disk space for upgrade:
```
sudo du -sh /var/snap/wekan/common
df -h
```
For example, if your database size is 500 GB, and disk is nearly full, you need to stop WeKan and move to bigger disk. If disk gets full, there is possibility to MongoDB database corruption. Making mongodump could maybe take 2x of current size, or more.
Some external disk related steps are at https://github.com/wekan/wekan/wiki/Repair-MongoDB
#### 3. Problems usually are only, are attachments visible or not. Upgrade steps do not delete any files, if commands below are written correctly.
Optional steps:
a) Optionally, you could use [nosqlbooster](https://github.com/wekan/wekan/wiki/Backup#using-nosqlbooster-closed-source-mongodb-gui-with-wekan-snap-to-edit-mongodb-database) to save attachments to files, and export JSON to textfiles, before trying to update. There could also be files at `/var/snap/wekan/common/files` or other subdirectories. When saving attachments, note that there could be many files with same filename.
b) Optinally, you can also save [all database content to JSON](https://github.com/wekan/wekan/wiki/Export-from-Wekan-Sandstorm-grain-.zip-file#11b-dump-database-to-json-text-files), but if your database is about 500 GB then it could be too much disk space required, because attachments are at base64 encoded text in JSON files. It's better ot save attachments with [nosqlbooster](https://github.com/wekan/wekan/wiki/Backup#using-nosqlbooster-closed-source-mongodb-gui-with-wekan-snap-to-edit-mongodb-database).
#### 4. ssh to your server
```
ssh wekanserver
```
#### 5. Save snap settings and set it as executeable
```
sudo snap get wekan > snap-settings.sh
chmod +x snap-settings.sh
```
#### 6. Edit `snap-settings.sh` to look like this, with nano or similar
```
sudo snap set wekan root-url='https://wekan.example.com'
sudo snap set wekan port='80'
```
At nano, Save: Ctrl-o Enter
At nano. Exit: Ctrl-x
#### 7. Download newest MongoDB tools for your distro version that will work with MongoDB 5.x, but do not install it yet
https://www.mongodb.com/try/download/database-tools
For example, for Ubuntu 22.04, [mongodb-database-tools-ubuntu2204-x86_64-100.6.1.deb](https://fastdl.mongodb.org/tools/db/mongodb-database-tools-ubuntu2204-arm64-100.6.1.deb)
#### 8. Remove old versions of MongoDB tools etc, if you have those
List them:
```
dpkg -l | grep mongo
```
If that shows that you have old mongodb server also, check do you really use it, what is the size of database server files?
```
sudo du -sh /var/lib/mongodb
```
Do you have these files, or similar, that show where else mongodb raw database directory could be?
```
/etc/mongod.conf
/etc/mongod/mongod.conf
```
Try to connect to it, and see if there is anything?
```
mongo
```
If it does not connect, maybe start MongoDB database, for example some of these commands:
```
sudo systemctl enable mongod
sudo systemctl start mongod
sudo systemctl enable mongodb
sudo systemctl start mongod
sudo /etc/init.d/mongod start
```
Try then again connect, and view what is there. In this example, if there is wekan database listed with `show dbs`:
```
mongo
show dbs
use wekan
show collections
db.users.count()
db.users.find()
```
Also look is there `mongodb.list` packages repo?
```
sudo ls /etc/apt/sources.list.d/
```
If you have all of mongodb-org, try to remove all of them, with all related files:
```
sudo apt-get --purge remove mongo*
```
Delete mongodb repo:
```
sudo ls /etc/apt/sources.list.d/mongo*
sudo apt update
sudo apt clean
sudo apt -y autoclean
sudo apt -y autoremove
```
### Upgrade
#### 9. Stop wekan app
```
sudo snap stop wekan.wekan
```
#### 10. Use WeKan Stable Snap mongodump version for dumping database
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan/current/lib/x86_64-linux-gnu
export PATH="$PATH:/snap/wekan/current/bin"
mongodump --port 27019
```
#### 11. Move common directory contents. There are raw database files and maybe some attachments.
```
sudo snap stop wekan
sudo mkdir common
sudo mv /var/snap/wekan/common/* common/
sudo rm -rf /var/snap/wekan/common/*
```
#### 12. Change from Stable to Candidate
```
sudo snap refresh wekan --channel=latest/candidate
```
#### 13. Exit ssh and connect again, to not use old mongodump version anymore
```
exit
ssh wekanserver
```
#### 14. Install mongodb tools for your distro version (from [step 7](#7-download-newest-mongodb-tools-for-your-distro-version-that-will-work-with-mongodb-5x-but-do-not-install-it-yet) above)
```
sudo dpkg -i mongodb-database-tools-ubuntu2204-x86_64-100.6.1.deb
```
If there is any errors, please copy all text from install process to comment to issue https://github.com/wekan/wekan/issues/4780
When installing some package, if some dependendencies are missing, they can usually be installed with some of these commands, and installing continued with::
```
sudo apt-get -f install
sudo dpkg --configure -a
```
If you get this kind of error, it means you have existing version of MongoDB Tools still installed, you should remove all those like at step 7 above:
```
Unpacking mongodb-database-tools (100.6.1) ...
dpkg: error processing archive mongodb-database-tools-ubuntu2004-x86_64-100.6.1.deb (--install):
trying to overwrite '/usr/bin/bsondump', which is also in package mongo-tools 3.6.3-0ubuntu1
```
Sure there are options to force install this, for example this way, but not recommended:
```
sudo rm /usr/bin/bsondump
sudo dpkg -i ...
```
Or other not recommended way, forcing overwrite:
```
sudo dpkg -i --force-overwrite mongodb-database-tools-ubuntu2004-x86_64-100.6.1.deb
```
But better would be to use that [step 7](#7-download-newest-mongodb-tools-for-your-distro-version-that-will-work-with-mongodb-5x-but-do-not-install-it-yet) above to remove all old mongodb packages and repo, and then install MongoDB tools.
#### 15. Restore
```
sudo snap stop wekan
sudo snap start wekan.mongodb
mongorestore --drop --port 27019 --noIndexRestore
```
#### 16. Add back settings
Recommended is to use [Caddy 2](https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config) instead of Caddy1 that is included in WeKan Snap currently at 2022-12-21. Caddy 2 maybe will be included to WeKan Snap later.
See if in your `snap-settings.sh` is this kind of command, are you using Caddy1 ?
```
sudo snap set wekan caddy-enabled='true'
```
If you use Caddy1, and have any domain settings in your `common/Caddyfile`, copy it back:
```
sudo cp common/Caddyfile /var/snap/wekan/common/
```
At [step 6](#6-edit-snap-settingssh-to-look-like-this-with-nano-or-similar) above, you did create script that adds back snap settings. Run it to restore those settings:
```
./snap-settings.sh
```
You could also copy that file to common directory, if you like, or just keep it in your current directory:
```
sudo cp snap-settings.sh /var/snap/wekan/common/
```
#### 17. Start WeKan
```
sudo snap start wekan
```
#### 18. Test are WeKan attachments visible
#### 19. If you are using WeKan Snap Caddy1, if it does not work, change to Caddy2 https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config
#### 20. Backup and cleanup
Create archive of old files, and transer it to your local laptop, save somewhere safe:
```
ssh wekanserver
sudo su
7z a old-wekan.7z snap-settings.sh common dump
exit
scp wekanserver:/root/old-wekan.7z .
```
And then delete old files from server. Do not delete `snap-settings.sh`.
```
ssh wekanserver
rm -rf common dump
```
Also, keep [Daily Backups](https://github.com/wekan/wekan/wiki/Backup)
## Oops it did not work. From WeKan Candidate back to Stable
```
sudo snap stop wekan
sudo rm -rf /var/snap/wekan/common/*
sudo snap refresh wekan --channel=latest/stable
sudo snap stop wekan
sudo rm -rf /var/snap/wekan/common/*
sudo mv common/* /var/snap/wekan/common/
sudo snap start wekan
./snap-settings.sh
```
If you have problems, add comment to issue https://github.com/wekan/wekan/issues/4780
## From WeKan Gantt GPL to WeKan Candidate
- This is discontinued, Gantt features will be later added to WeKan MIT version.
- Gantt version files are instead at `/var/snap/wekan-gantt-gpl/`
- Gantt snap name is wekan-gantt-gpl

249
docs/wekan-snap.wiki/CentOS-7.md Normal file
View file

@ -0,0 +1,249 @@
## CentOS 7 and RHEL7 and newer
Alternatives:
- Snap install like below. Automatic updates. Some time ago there were problems with [Snap on CentOS 7](https://github.com/wekan/wekan-snap/issues/103#issuecomment-571223099), that can result in updating not working properly, but that is a long time ago, and Snap version is currently 2020-04-29 installed at about 400 servers worldwide, according to Snap statistics that show only wordwide and per-country stats, not any more specific info. Please keep [daily backups](https://github.com/wekan/wekan/wiki/Backup).
- Docker or Bash/SystemD install from https://wekan.github.io
***
[Wekan snap bug reports and feature requests](https://github.com/wekan/wekan-snap/issues)
# Distro specific info how to install Snap on 64bit Linux
https://snapcraft.io
- CentOS 7, RHEL7 and newer, instructions below
# Install Wekan
### 1) Use root
```
sudo su
```
### 2) Install snap
2019-11-12 If instead of Caddy you use Nginx in front of Wekan on CentOS 7, you should
[disable selinux to prevent Nginx permission denied error](https://github.com/wekan/wekan/issues/2792).
2018-11-05 Also see [new snapd on EPEL](https://forum.snapcraft.io/t/snapd-updates-in-fedora-epel-for-enterprise-linux/8310).
Source: [Experimental CentOS7 snap](https://copr.fedorainfracloud.org/coprs/ngompa/snapcore-el7/) and [Forum post](https://forum.snapcraft.io/t/install-snapd-on-centos/1495/21)
```
yum makecache fast
yum install yum-plugin-copr epel-release
yum copr enable ngompa/snapcore-el7
yum install snapd
systemctl enable --now snapd.socket
```
### 3) Install Wekan. Set URL like (subdomain.)example.com(/suburl)
```
snap install wekan
snap set wekan root-url='https://boards.example.com'
```
[MORE ROOT-URL EXAMPLES](https://github.com/wekan/wekan/wiki/Settings)
### 4) Set port where Wekan runs, for example 80 if http, or local port 3001, if running behing proxy like Caddy
```
snap set wekan port='3001'
systemctl restart snap.wekan.wekan
```
### 5) Install all Snap updates automatically between 02:00AM and 04:00AM
```
snap set core refresh.schedule=02:00-04:00
```
Automatic upgrades happen sometime after Wekan is released, or at scheduled time, or with `sudo snap refresh`
### 6) Email and Other Settings
```
sudo snap set wekan mail-url='smtps://user:pass@mailserver.example.com:453'
sudo snap set wekan mail-from='Wekan Boards <support@example.com>'
```
[Troubleshooting Email](https://github.com/wekan/wekan/wiki/Troubleshooting-Mail)
## LDAP
See [Supported Settings Keys](Supported-settings-keys#ldap)
## [Matomo Web Analytics integration](Supported-settings-keys#matomo-web-analytics-integration)
See [Supported Settings Keys](Supported-settings-keys#matomo-web-analytics-integration)
## [Rocket.Chat providing OAuth2 login to Wekan](https://github.com/wekan/wekan/wiki/OAuth2)
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.
# Optional: Install Caddy - Every Site on HTTPS
a) Personal non-commercial use only, included
b) Commercial use: see https://caddyserver.com/products/licenses
and [commercial usage issue](https://github.com/wekan/wekan-snap/issues/39),
contact Wekan maintainer x@xet7.org about how to enable commercial version
of caddy.
### 7) Add domain to Caddy config
```
nano /var/snap/wekan/common/Caddyfile
```
### 8) Replace first top line of text with (subdomain.)example.com(/suburl), without any beginning of http/https
Example Caddyfile config.
"alpn http/1.1" is because Firefox Inspect Console does not support http/2, so [turning it off](https://github.com/wekan/wekan/issues/934) so that Firefox would not show wss websocket errors. Chrome console supports http/2.
This uses free Let's Encrypt SSL. You can also use [free CloudFlare wildcard SSL or any other SSL cert](https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config).
```
boards.example.com {
tls {
alpn http/1.1
}
proxy / localhost:3001 {
websocket
transparent
}
}
```
Caddyfile example of static directory listing:
```
# Files have these permissions:
# chown root:root /var/snap/wekan/common/download.example.com
download.example.com {
root /var/snap/wekan/common/download.example.com
browse
}
```
[MORE Caddyfile EXAMPLES](https://github.com/caddyserver/examples)
### 9) Enable Caddy automatic https
```
snap set wekan caddy-enabled='true'
```
## 10) Reboot
## 11) Disable and enable wekan
```
$ sudo snap disable wekan
$ sudo snap enable wekan
```
If you use the mongodb port for another app, then, change it too:
```
$ sudo snap set wekan mongodb-port=27019
```
## 12) Add users
[Add users](https://github.com/wekan/wekan/wiki/Adding-users)
[Forgot Password](https://github.com/wekan/wekan/wiki/Forgot-Password)
## MongoDB CLI
1) Install MongoDB 3.2.x tools, and run on CLI:
`mongo --port 27019`
***
# Older install docs
```
$ sudo snap install wekan
```
IMPORTANT: SETUP [URL SETTINGS](#url-settings) BELOW, SO OPENING CARDS ETC WORKS CORRECTLY. More info at [Supported settings keys](Supported-settings-keys).
**IMPORTANT: Wekan Snap is bleeding edge, so any commits made to the wekan repository are pushed to the snap directly. Decide for yourself if you want to run wekan snap in production**
Make sure you have connected all interfaces, check more by calling
```
$ snap interfaces
```
Wekan has two services, to check status/restart/stop use systemd commands:
You can use these service commands:
- status
- start
- stop
- restart
MongoDB service:
```
$ sudo systemctl status snap.wekan.mongodb
```
Wekan service:
```
$ sudo systemctl status snap.wekan.wekan
```
## URL settings
[Nginx and Snap settings for https://example.com/wekan sub-url](https://github.com/wekan/wekan/wiki/Nginx-Webserver-Config)
Full URL to your Wekan, for example:
### Run Wekan on local network on selected port on computer IP address
```
$ sudo snap set wekan root-url='http://192.168.10.100:5000'
```
### Run Wekan only locally on selected port
```
$ sudo snap set wekan root-url='http://localhost:5000'
```
### Nginx or Caddy webserver in front of Wekan
[Nginx](https://github.com/wekan/wekan/wiki/Nginx-Webserver-Config) or [Caddy](https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config) is in front, full URL to real web address URL of Nginx or Caddy.
```
$ sudo snap set wekan root-url='https://example.com'
```
or
```
$ sudo snap set wekan root-url='https://example.com/wekan'
```
## Port settings
Localhost port where Wekan is running. This does not need to be exposed to Internet when running behind Nginx or Caddy.
```
$ sudo snap set wekan port='<your_port>'
```
## Restart Wekan after changes
```
$ sudo systemctl restart snap.wekan.wekan
```
When running without any additional settings, Wekan is at http://localhost:8080

20
docs/wekan-snap.wiki/CentOS8.md Normal file
View file

@ -0,0 +1,20 @@
Using CentOS 8 Stream.
1. Install Snap https://snapcraft.io/docs/installing-snap-on-centos
2. Reboot
3. With terminal, test latest release candidate, to your server IP address:
```
su
snap install wekan --channel=latest/candidate
snap set wekan root-url='http://YOUR-IP-ADDRESS'
snap set wekan port='80'
```
4. For additional server options, see https://github.com/wekan/wekan/wiki/Settings
5. For adding users, see https://github.com/wekan/wekan/wiki/Adding-users
6. For other login option, see right menu at https://github.com/wekan/wekan/wiki

14
docs/wekan-snap.wiki/Home.md Normal file
View file

@ -0,0 +1,14 @@
Welcome to the wekan-snap documentation wiki!
## Wekan snap at web
https://uappexplorer.com/snap/ubuntu/wekan
## Help command after installing
```
$ wekan.help
```
**All of commandline help is also in this wiki, categorized to their own wiki pages.**
See also [Wekan documentation](https://github.com/wekan/wekan/wiki)

15
docs/wekan-snap.wiki/Install-snap-with-Ansible.md Normal file
View file

@ -0,0 +1,15 @@
## Ansible install by Pavel Stratil
[Info source](https://github.com/wekan/wekan/issues/1106)
## Original repos, please add feature requests there
https://github.com/Vaizard/mage-wekan
https://github.com/vaizard/mage-snapd
## Wekan's forked version
https://github.com/wekan/mage-wekan
https://github.com/wekan/mage-snapd

261
docs/wekan-snap.wiki/Install.md Normal file
View file

@ -0,0 +1,261 @@
Snap for Linux, install to your own server or laptop. Automatic Updates. Only Standalone Wekan.
If on Snap Stable automatic update breaks something, [report Wekan for Snap bugs and feature requests here](https://github.com/wekan/wekan-snap/issues), so it can be fixed on some automatic update. If security is critical, keep behind firewall, without any ports open to Internet.
# Distro specific info how to install Snap on 64bit Linux
https://snapcraft.io
- Recommended: Newest 1) Ubuntu 2) Debian based distro
- Arch
- Fedora
- Solus
- OpenSUSE
- Gentoo
- Manjaro
- Elementary OS
- [CentOS 7, RHEL7 and newer](CentOS-7)
- [CentOS 8](CentOS8)
How ROOT_URL is set:
https://github.com/wekan/wekan/wiki/Settings
Here is how to add users:
https://github.com/wekan/wekan/wiki/Adding-users
How to switch between WeKan and WeKan Gantt GPL:
https://github.com/wekan/wekan/issues/2870#issuecomment-721364824
Newest Snap WeKan does not yet have migration to newest MongoDB. Here is how to try newer WeKan test candidate version, and migrate database manually:
https://github.com/wekan/wekan/issues/4505#issuecomment-1158380746
Below is how to install Snap.
# Install Wekan
### 1) Use root
```
sudo su
```
### 2) Install snap
a) Debian or Ubuntu
```
apt install snapd
```
b) Other distros
See [Snapcraft website](https://snapcraft.io).
### 3) Install Wekan. Set URL like (subdomain.)example.com(/suburl)
```
snap install wekan
snap set wekan root-url='https://wekan.example.com'
```
[MORE ROOT-URL EXAMPLES](https://github.com/wekan/wekan/wiki/Settings)
### 4) Set port where Wekan runs, for example 80 if http, or local port 3001, if running behing proxy like Caddy
```
snap set wekan port='3001'
systemctl restart snap.wekan.wekan
```
### 5) Install all Snap updates automatically between 02:00AM and 04:00AM
```
snap set core refresh.schedule=02:00-04:00
```
Update once a week at Sunday between 02:00AM and 04:00AM
```
snap set core refresh.schedule=sun,02:00-04:00
```
Update last Sunday of the month between 02:00AM and 04:00AM
```
snap set core refresh.schedule=sun5,02:00-04:00
```
[Update until specific day](https://snapcraft.io/docs/keeping-snaps-up-to-date#heading--refresh-hold) and other examples.
If required, you can disable all Snap updates at `/etc/hosts` by adding a line:
```
127.0.0.1 api.snapcraft.io
```
Automatic upgrades happen sometime after Wekan is released, or at scheduled time, or with `sudo snap refresh`
### 6) Email and Other Settings
```
sudo snap set wekan mail-url='smtps://user:pass@mailserver.example.com:453'
sudo snap set wekan mail-from='Wekan Boards <support@example.com>'
```
[Troubleshooting Email](https://github.com/wekan/wekan/wiki/Troubleshooting-Mail)
## LDAP
See [Supported Settings Keys](Supported-settings-keys#ldap)
## [Matomo Web Analytics integration](Supported-settings-keys#matomo-web-analytics-integration)
See [Supported Settings Keys](Supported-settings-keys#matomo-web-analytics-integration)
## [Rocket.Chat providing OAuth2 login to Wekan](https://github.com/wekan/wekan/wiki/OAuth2)
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.
# Optional: Install Caddy - Every Site on HTTPS
### 7) Add domain to Caddy config
```
nano /var/snap/wekan/common/Caddyfile
```
### 8) Replace first top line of text with (subdomain.)example.com(/suburl), without any beginning of http/https
Example Caddyfile config.
"alpn http/1.1" is because Firefox Inspect Console does not support http/2, so [turning it off](https://github.com/wekan/wekan/issues/934) so that Firefox would not show wss websocket errors. Chrome console supports http/2.
This uses free Let's Encrypt SSL. You can also use [free CloudFlare wildcard SSL or any other SSL cert](https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config).
```
boards.example.com {
tls {
alpn http/1.1
}
proxy / localhost:3001 {
websocket
transparent
}
}
```
Caddyfile example of static directory listing:
```
# Files have these permissions:
# chown root:root /var/snap/wekan/common/download.example.com
download.example.com {
root /var/snap/wekan/common/download.example.com
browse
}
```
[MORE Caddyfile EXAMPLES](https://github.com/caddyserver/examples)
### 9) Enable Caddy automatic https
```
snap set wekan caddy-enabled='true'
```
## 10) Reboot
## 11) Disable and enable wekan
```
$ sudo snap disable wekan
$ sudo snap enable wekan
```
If you use the mongodb port for another app, then, change it too:
```
$ sudo snap set wekan mongodb-port=27019
```
## 12) Add users
[Add users](https://github.com/wekan/wekan/wiki/Adding-users)
[Forgot Password](https://github.com/wekan/wekan/wiki/Forgot-Password)
## MongoDB CLI
1) Install MongoDB 3.2.x tools, and run on CLI:
`mongo --port 27019`
***
# Older install docs
```
$ sudo snap install wekan
```
IMPORTANT: SETUP [URL SETTINGS](#url-settings) BELOW, SO OPENING CARDS ETC WORKS CORRECTLY. More info at [Supported settings keys](Supported-settings-keys).
**IMPORTANT: Wekan Snap is bleeding edge, so any commits made to the wekan repository are pushed to the snap directly. Decide for yourself if you want to run wekan snap in production**
Make sure you have connected all interfaces, check more by calling
```
$ snap interfaces
```
Wekan has two services, to check status/restart/stop use systemd commands:
You can use these service commands:
- status
- start
- stop
- restart
MongoDB service:
```
$ sudo systemctl status snap.wekan.mongodb
```
Wekan service:
```
$ sudo systemctl status snap.wekan.wekan
```
## URL settings
[Nginx and Snap settings for https://example.com/wekan sub-url](https://github.com/wekan/wekan/wiki/Nginx-Webserver-Config)
Full URL to your Wekan, for example:
### Run Wekan on local network on selected port on computer IP address
```
$ sudo snap set wekan root-url='http://192.168.10.100:5000'
```
### Run Wekan only locally on selected port
```
$ sudo snap set wekan root-url='http://localhost:5000'
```
### Nginx or Caddy webserver in front of Wekan
[Nginx](https://github.com/wekan/wekan/wiki/Nginx-Webserver-Config) or [Caddy](https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config) is in front, full URL to real web address URL of Nginx or Caddy.
```
$ sudo snap set wekan root-url='https://example.com'
```
or
```
$ sudo snap set wekan root-url='https://example.com/wekan'
```
## Port settings
Localhost port where Wekan is running. This does not need to be exposed to Internet when running behind Nginx or Caddy.
```
$ sudo snap set wekan port='<your_port>'
```
## Restart Wekan after changes
```
$ sudo systemctl restart snap.wekan.wekan
```
When running without any additional settings, Wekan is at http://localhost:8080

31
docs/wekan-snap.wiki/Limit-snap-to-root-user-only.md Normal file
View file

@ -0,0 +1,31 @@
If you have some users logging to your server, that don't have root access, and you want to limit snap to root user only, you can do the following:
## 1) Set snap refresh schedule, for example
```
sudo snap set core refresh.schedule=02:00-03:00
```
## 2) Set cron to limit permissions to root users after updates
For example, sudo to root, and edit root cron with nano:
```
sudo su
export EDITOR=nano
crontab -e
```
and add there that at 03:10 permissions are limited to root again:
```
10 3 * * * chmod og-rwx /usr/bin/snap
10 3 * * * chmod -R og-rwx /var/snap
```
You can see crontab syntax help at https://crontab.guru
`snap` is the command, and `/var/snap` is where data is stored.
## Future snap features for permissions
For more advanced user permission control in snap, sometime new features will be added:<br />
https://forum.snapcraft.io/t/multiple-users-and-groups-in-snaps/1461/3

54
docs/wekan-snap.wiki/Making-releases-from-source.md Normal file
View file

@ -0,0 +1,54 @@
# Installing snapcraft from source
This is old and already fixed, was only needed when [snap build servers were broken](https://github.com/wekan/wekan-snap/issues/58) and [snapcraft had bug](https://forum.snapcraft.io/t/permission-denied-when-building-with-snapcore-snapcraft/7186/14?u=xet7) that has [fix that was not released to snap channel yet](https://github.com/snapcore/snapcraft/pull/2240). All this is fixed now.
So I removed snap version, and installed snapcraft from source, and it seems to work for me.
## Snapcraft source install on Ubuntu 16.04 64bit
Add to /root/.bashrc:
```
export PATH="$PATH:/home/user/repos/snapcraft/bin"
```
## Install dependencies
```
sudo apt install python3-yaml python3-tabulate python3-pymacaroons \
python3-progressbar python3-requests-unixsocket python3-petname \
python3-pyelftools python3-click python3-simplejson \
python3-requests-toolbelt python3-jsonschema xdelta3
```
## Install snapcraft
```
cd ~/repos
git clone https://github.com/snapcore/snapcraft.git
cd snapcraft
sudo python3 setup.py install
```
## [Workaround bug](https://bugs.launchpad.net/snapcraft/+bug/1656884/comments/1)
```
sudo ln -s /usr/local/lib/python3.5/dist-packages/snapcraft-2.43-py3.5.egg/share/snapcraft/ /usr/share/snapcraft
```
## Build package
```
cd ~/repos/wekan
sudo snapcraft
```
## Install snap package locally to test it
```
sudo snap install --dangerous wekan_1.*_amd64.snap
```
## Changing back to stable or edge snap
https://github.com/wekan/wekan-snap/wiki/Snap-Developer-Docs
## Login to snapcraft
If you have access to publishing snaps.
## Push package to snap store
```
sudo snapcraft push wekan_1.*_amd64.snap
```
## Publish at snap store
https://dashboard.snapcraft.io/dev/snaps/7867

9
docs/wekan-snap.wiki/Making-releases.md Normal file
View file

@ -0,0 +1,9 @@
## Triggering git import process manually
https://code.launchpad.net/~wekan-team/wekan/+git/wekan
## When ready, uploaded to store. Check and release.
Once you snap is uploaded you should see it here:
https://dashboard.snapcraft.io/dev/snaps/7867

466
docs/wekan-snap.wiki/Many-Snaps-on-LXC.md Normal file
View file

@ -0,0 +1,466 @@
https://github.com/wekan/wekan-snap/wiki/Many-Snaps-on-LXC#lxd-init-cidr
# NEW WAY: Parallel Snap Installs
Note: This presumes that your laptop runs newest Ubuntu or Kubuntu, and that server is Ubuntu.
1) Install Caddy2 https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config
2) Optional, recommended: Encrypted VM. Idea: Bare Metal Caddy => Proxy to encrypted VM ports => Each customer separate Snap WeKan port. Snap sandbox files at /common, snap code can not access files outside of it's /common directories. Newest WeKan is Snap Candidate. Snap has automatic updates.
2.1) If your server has additional harddrives, format them:
```
ls /dev
mkfs.ext4 /dev/nvme0n1
```
2.2) Look at that above command text output, what is created disk UUID. Add those to /etc/fstab:
```
UUID=12345-678-90 /data ext4 errors=remount-ro 0 1
```
2.3) Create directories for mounting disk, and mount all drives:
```
sudo su
cd /
mkdir /data
mount -a
```
2.4) Install to your laptop and bare metal server packages for using remote desktop with KVM:
```
sudo apt install virt-manager qemu-system
```
2.5) Check that you can ssh to server with ssh public key as root. For that, create ssh key on your laptop, press enter many times until it's done:
```
ssh-keygen
```
2.6) copy laptop .ssh/id_rsa.pub content to server /root/.ssh/authorized_keys .
2.7) At server disable password login at /etc/ssh/sshd_config , password login enabled false. And `sudo systemctl restart ssh`
2.8) At your laptop edit .ssh/config , there add your server IP address etc. This server here is named x1.
```
Host x1
Hostname 123.123.123.123
User root
IdentityFile ~/.ssh/id_rsa
```
2.9) Check that you can ssh from laptop to server as root without prompts.
2.10) Start virt-manager GUI at your laptop:
- File / Add connection
- Hypervisor: QEMU/KVM
- [X] Connect to remote host via SSH
- Username: root
- Machine name: x1
- Connect automatically: [X]
- Click [Connect]
2.11) AT SERVER: Create harddrive image: `qemu-img create -f qcow2 web.qcow2 700G`
2.12) Download newest Kubuntu desktop iso with wget.
2.13) Install kubuntu with full disk encryption. Modify amount of RAM (here 32 GB), file locations etc. Do not select to allocate encrypted disk image immediately, let image size grow.
2.14) Create growing disk with max size:
```
qemu-img create -f qcow2 web.qcow2 700G
```
2.15) Start install from .iso image. Here RAM -r 32 GB, name web, change disk and iso locations below, vcpu 20 (check your server with nproc, should be less that all):
```
sudo virt-install -r 32000 -n web --os-type=linux --os-variant=ubuntu16.04 \
--disk /data/VMs/web.qcow2,device=disk,format=qcow2 \
-c /data/VMs/iso/kubuntu-22.10-desktop-amd64.iso \
--vcpus=20 --vnc --noautoconsole
```
It will appear to your laptop virt-manager GUI.
If you have shutdown KVM VM, you can start it from virt-manager, or this way without .iso image:
```
sudo virt-install -r 32000 -n web --boot hd --video=vga --os-type=linux --os-variant=ubuntu16.04 \
--disk /data/VMs/web.qcow2,device=disk,format=qcow2 \
--vcpus=20 --vnc --noautoconsole
```
3) Use Parallel Snap installs https://snapcraft.io/docs/parallel-installs
For example:
```
sudo snap set system experimental.parallel-instances=true
```
4) With newest WeKan Candidate like https://github.com/wekan/wekan-snap/wiki/CentOS8 . Note: Each user has different wekan port and mongodb port.
```
sudo snap install wekan --channel=latest/candidate
sudo snap install wekan wekan_customer1 --channel=latest/candidate
sudo snap disable wekan
sudo snap set wekan_customer1 caddy-enabled='false'
```
Check that each WeKan uses candidate:
```
sudo snap list
```
If not, change to candidate:
```
sudo snap refresh wekan_customer1 --channel=latest/candidate
```
If it complains about old database version (was at stable), stop it, move old files somewhere safe, and start again.
WARNING: this deletes
```
sudo su
mkdir old_customer1_common
snap stop wekan_customer1
mv /var/snap/wekan_customer1/common/* old_customer1_common/
snap start wekan_customer1
```
5) Add some settings, for example Google login and [AWS SES email sending](https://github.com/wekan/wekan/wiki/Troubleshooting-Mail#example-aws-ses):
For each customer, node and mongodb needs to be in different ports, for example:
```
sudo snap set wekan_customer1 port='5001'
sudo snap set wekan_customer1 mongodb-port='25001'
sudo snap set wekan_customer2 port='5002'
sudo snap set wekan_customer2 mongodb-port='25002'
```
For customer1:
```
sudo snap set wekan_customer1 port='5001'
sudo snap set wekan_customer1 mongodb-port='25001'
sudo snap set wekan_customer1 root-url='https://wekan.customer1.com'
sudo snap set wekan_customer1 mail-url='smtp://username:password@email-smtp.eu-west-1.amazonaws.com:587?tls={ciphers:"SSLv3"}&secureConnection=false'
sudo snap set wekan_customer1 mail-from='Wekan Customer1 Support <board@customer1.com>'
sudo snap set wekan_customer1 oauth2-auth-endpoint='https://accounts.google.com/o/oauth2/v2/auth'
sudo snap set wekan_customer1 oauth2-client-id='YOUR-GOOGLE-LOGIN-CLIENT_ID.apps.googleusercontent.com'
sudo snap set wekan_customer1 oauth2-secret='YOUR-GOOGLE-LOGIN-SECRET'
sudo snap set wekan_customer1 oauth2-email-map='email'
sudo snap set wekan_customer1 oauth2-enabled='true'
sudo snap set wekan_customer1 oauth2-fullname-map='name'
sudo snap set wekan_customer1 oauth2-id-map='sub'
sudo snap set wekan_customer1 oauth2-request-permissions='openid https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email'
sudo snap set wekan_customer1 oauth2-token-endpoint='https://oauth2.googleapis.com/token'
sudo snap set wekan_customer1 oauth2-userinfo-endpoint='https://openidconnect.googleapis.com/v1/userinfo'
sudo snap set wekan_customer1 oauth2-username-map='nickname'
```
You can check with [nosqlbooster](https://github.com/wekan/wekan/wiki/Backup#using-nosqlbooster-closed-source-mongodb-gui-with-wekan-snap-to-edit-mongodb-database) that each database has correct data.
When restoring data, stop that wekan, and restore to that port, when you have subdirectory dump:
```
sudo snap stop wekan_customer2.wekan
mongorestore --drop --port 25002
sudo snap start wekan_customer2.wekan
```
If there is errors, try again without restoring indexes:
```
mongorestore --drop --noIndexRestore --port 25002
```
To empty database, use [mongodb shell](https://www.mongodb.com/try/download/shell):
```
mongosh --port 25002
show dbs
use wekan
db.dropDatabase()
```
To see is settings written correctly, use:
```
sudo snap get wekan_customer1
sudo snap get wekan_customer2
```
And that at `Caddyfile` each subdomain is proxied to correct port like 3001 etc.
And that if there is snap called wekan, it's not in use:
```
sudo snap disable wekan
```
or has different port:
```
sudo snap get wekan
sudo snap set wekan port='6001'
sudo snap set wekan mongodb-port='28001'
```
6) Example backup script, that backups MongoDB databases. Although, maybe files directories needed to be added too.
Note: Here customer1 likes to get backup copy of backups, so this copies customer1 backup to separate directory that is synced only to that customer with Syncthing. Via email was asked customer syncthing ID, and added sync.
Set it as executeable:
```
chmod +x backup.sh
```
To run it:
```
sudo su
cd backup
./backup.sh
```
Here is backup.sh, using [mongodb tools](https://www.mongodb.com/try/download/database-tools) for mongodump/mongorestore etc:
```
#!/bin/bash
# Backup all MongoDB databases from different ports.
# Note: You may need to check also is there files directory,
# and also backup that, like /var/snap/wekan/common/files etc
function backup {
cd /home/wekan/backup
# >> /home/wekan/backup/backup-log.txt
mkdir -p /home/wekan/backup/new/$1
cd /home/wekan/backup/new/$1
mongodump --port $2
sudo snap get wekan_$1 > snap-settings.txt
cd ..
7z a $(date -u +$1-wekan-backup-%Y-%m-%d_%H.%M_UTC.7z) $1
mkdir /home/wekan/$3
chown wekan:wekan *.7z
mv *.7z /home/wekan/$3/
rm -rf $1
cd /home/wekan/backup
}
function backupchat {
cd /home/wekan/backup >> /home/wekan/backup/backup-log.txt
mkdir -p /home/wekan/backup/new/$1 >> /home/wekan/backup/backup-log.txt
cd /home/wekan/backup/new/$1 >> /home/wekan/backup/backup-log.txt
mongodump >> /home/wekan/backup/backup-log.txt
cd ..
7z a $(date -u +$1-backup-%Y-%m-%d_%H.%M_UTC.7z) $1
mkdir /home/wekan/$3
chown wekan:wekan *.7z
mv *.7z /home/wekan/$3/
rm -rf $1
cd /home/wekan/backup
}
# Syntax:
# backup customername port backupdir
function websync {
# Backup WeKan Kanban Snaps to different Syncthing sync directories
backup "customer1" "25001" "backup-wekan-customer1"
backup "customer1" "25001" "websync"
backup "customer2" "25002" "websync"
backup "customer3" "25003" "websync"
backup "customer4" "25004" "websync"
backup "customer5" "25005" "websync"
# Backup RocketChat Snap
backupchat "chat" "27027" "websync"
cd ~/websync
## backup the backup scripts
# 7z a $(date -u +wekan-backup-scripts-%Y-%m-%d_%H.%M_UTC.7z) ~/backup
}
(websync) >> /home/wekan/backup/backup-log.txt 2>&1
```
7. At bare metal server is installed [Caddy2](https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config).
Each customer has set in their nameserver to WeKan hosting server IP address:
```
A 123.123.123.123
```
After that, when ping wekan.company1.com shows 123.123.123.123 correctly, it's possible to get
automatic Let's Encrypt SSL/TLS cert with Caddy2.
At encrypted KVM VM type `ip address`, it shows what is KVM VM internal IP address.
Caddy2 proxies with Let's Encrypt TLS HTTPS to encrypted VM HTTP IP address and port where WeKan (Node.js) is running.
/etc/caddy/Caddyfile . Examples when in /etc/caddy directory as root: `caddy start`, `caddy stop`, `caddy validate`, `caddy --help`
```
(redirect) {
@http {
protocol http
}
redir @http https://{host}{uri}
}
kanban.customer1.com {
tls {
alpn http/1.1
}
reverse_proxy 192.168.123.23:5001
}
kanban.customer2.com {
tls {
alpn http/1.1
}
reverse_proxy 192.168.123.23:5002
}
```
Other non-kanban examples:
```
# Static website that uses free CloudFlare TLS certificates
company.com {
tls {
load /data/websites/certificates/company
alpn http/1.1
}
root * /data/websites/company.com
file_server
}
# RocketChat
chat.company.com {
tls {
alpn http/1.1
}
reverse_proxy 192.168.123.23:3000
}
# Browseable files listing static website
files.company.com {
tls {
alpn http/1.1
}
root * /data/websites/files.company.com
file_server browse
}
```
***
# OLD WAY: Many Snaps on LXC
## LXD init CIDR
IPv4 CIDR: 10.1.1.1/24
```
sudo apt install snapd
sudo reboot
sudo snap install lxd
lxd init
Would you like to use LXD clustering? (yes/no) [default=no]:
Do you want to configure a new storage pool? (yes/no) [default=yes]:
Name of the new storage pool [default=default]:
Name of the storage backend to use (dir, lvm, btrfs, ceph) [default=btrfs]: dir
Would you like to connect to a MAAS server? (yes/no) [default=no]:
Would you like to create a new local network bridge? (yes/no) [default=yes]:
What should the new bridge be called? [default=lxdbr0]:
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: 10.1.1.1/24
Would you like LXD to NAT IPv4 traffic on your bridge? [default=yes]:
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]:
Would you like the LXD server to be available over the network? (yes/no) [default=no]:
Would you like stale cached images to be updated automatically? (yes/no) [default=yes]:
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]:
```
> The value you have specified is the “network address”, i.e “.0” is the network address of the subnet “10.1.1.0/24”. Instead you need to specify an IP in that network, such as “.1”, e.g. “10.1.1.1/24”
https://discuss.linuxcontainers.org/t/failed-lxd-init-what-is-cidr/7181/2
## 1) Main Snap on bare metal
[Install Wekan Snap](Install) to newest Ubuntu bare metal server. Snaps have automatic updates.
For example:
```
sudo apt-get install snapd
reboot
sudo snap install wekan
```
For Let's Encrypt SSL, like this to `/var/snap/wekan/common/Caddyfile`. We will be proxying to inside LXD container:
```
boards.example.com {
tls {
alpn http/1.1
}
proxy / 10.10.10.231:3001 {
websocket
transparent
}
}
```
For [CloudFlare SSL](https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config), like this to `/var/snap/wekan/common/Caddyfile`:
```
http://boards.example.com https://boards.example.com {
tls {
load /var/snap/wekan/common/certificates
alpn http/1.1
}
proxy / 10.10.10.231:3001 {
websocket
transparent
}
}
```
## 2) New LXC container
So when I start new lxc container:
```
lxc launch images:ubuntu/20.04 lxccontainername
```
## 3) Snapd and Wekan
Then I go inside container and install snapd:
```
lxc exec lxccontainername -- /bin/bash
apt -y install snapd
reboot
lxc exec lxccontainername -- /bin/bash
snap install wekan
snap set wekan root-url='https://boards.example.com'
sudo snap set wekan port='3001'
sudo snap set wekan mail-from='Wekan Team Boards <info@example.com>'
sudo snap set wekan mail-url='smtps://username:password@email-smtp.eu-west-1.amazonaws.com:587'
ip address
exit
```
That `ip address` command does show current IP address of container, that you can then add to bare metal `/var/snap/wekan/common/Caddyfile`.
You can also add more lxc containers to different subdomains and proxy to them in main Caddyfile.
## 4) Some LXC commands
### New Ubuntu container
```
lxc launch images:ubuntu/20.04 lxccontainername
```
### Inside LXC container
```
lxc exec lxccontainername -- /bin/bash
```
### Running command in LXC
```
lxc exec lxccontainername -- apt install p7zip-full
```
### Limit RAM available to LXC
```
lxc config set lxccontainername limits.memory 4GB
```
### New Debian container
```
lxc launch images:debian/buster mydebiancontainername
```
### New CentOS 7 container
```
lxc launch images:centos/7/amd64 centos
```
### List containers
```
lxc list -cns
```
Result:
```
+---------------+---------+
| NAME | STATE |
+---------------+---------+
| mycontainer | RUNNING |
+---------------+---------+
```
### Stop and delete container
```
lxc stop mycontainer
lxc delete mycontainer
```

78
docs/wekan-snap.wiki/Old-Making-releases.md Normal file
View file

@ -0,0 +1,78 @@
# Older way to make releases, does not work.
***
## Triggering git import process manually
[Info source](https://github.com/wekan/wekan-snap/issues/2#issuecomment-311324364)
To make build quicker, it's possible to trigger git import process manually in launchpad, so you don't need to wait for next sync.
https://code.launchpad.net/~wekan-team/wekan/+git/wekan
## Launchpad project
[Info source](https://github.com/wekan/wekan-snap/pull/3#issuecomment-310764751)
kubiko created launchpad wekan project and wekan team where xet7 is admin in and contributor. xet7 can feel free to add other people on the list.
Wekan project has wekan-snap repo mirrored from github one:
https://code.launchpad.net/~wekan-team/wekan/+git/wekan-snap
Sync happens every ~5 hours
There is snap package enabled for this repo which has automatic build upon change in repo enabled, you can see there also build queue:
https://code.launchpad.net/~wekan-team/+snap/wekan-devel
It has also auto push to store enabled, so once built snap is uploaded to candidate channel.
Once you snap is uploaded you should see it here:
https://dashboard.snapcraft.io/dev/snaps/7867
kubiko got email from launchpad account and added xet7 as collaborator list, so xet7 can control promotion to stable channel once candidate version is tested. There xet7 can see there some other interesting stats about snap adoption.
For the future once xet7 makes change in wekan-snap build and upload should happen automatically, no need for additional interaction.
Next thing for kubiko would be to move people from wekan-ondra to wekan, not quite sure how to announce this though….. From stats kubiko did see there are ~320 downloads/installs of version 0.23.
kubiko also created pull request to wekan repo, which enabled continuous integration from master, typically this would be pushing builds to edge channel, from where xet7 can do testing, or more adventures users can use edge channel to track Wekan master branch….
## Snapcraft build support from source
[Info source](https://github.com/wekan/wekan/pull/1091)
Adding snapcraft build support. This can be used together with launchpad build system for continuous integration.
Intention is to push snaps build from devel branch to edge channel, which can be installed by calling:
```
$ snap install -edge wekan
```
device will keep automatically updating to revisions as they are released to edge channel
@xet7 Snap build job is now created, you can see it here:
https://code.launchpad.net/~wekan-team/+snap/wekan-devel
It's building from devel branch, fee free to change that if you prefer it to build from different branch.
Same as for release apply here, auto builds on change, only resulting snap is pushed to edge channel instead.
Also check please version name if you want it to be something different than:
```
0.26-SNAPSHOT
```
## Old links, not in use
( Old trigger git import https://code.launchpad.net/~wekan-team/wekan/+git/wekan-snap )
( Old build queue, not in use: https://code.launchpad.net/~wekan-team/+snap/wekan-release )
( Old build queue, not in use: https://code.launchpad.net/~ondrak/+snap/wekan-devel )

1
docs/wekan-snap.wiki/OpenSuse.md Normal file
View file

@ -0,0 +1 @@
https://github.com/wekan/wekan/wiki/OpenSuse

14
docs/wekan-snap.wiki/Sharing-MongoDB.md Normal file
View file

@ -0,0 +1,14 @@
## Share MongoDB to other snaps
- connect mongodb-slot with plug from corresponding snap(s)
- configure corresponding service to use mongodb unix socket in shared directory, socket file name is: mongodb-.sock
## Sharing MongoDB from other snap to wekan
- connect mongodb-plug with slot from snap providing mongodb
- disable mongodb in wekan by calling:
```
$ snap set wekan set disable-mongodb='true'
```
- set mongodb-bind-unix-socket to point to serving mongodb. Use relative path inside shared directory, e.g run/mongodb-27017.sock

125
docs/wekan-snap.wiki/Supported-settings-keys.md Normal file
View file

@ -0,0 +1,125 @@
Wekan supports settings key values:
```
$ snap set wekan <key name>='<key value>'
```
## List all possible settings
```
$ wekan.help | less
```
## List your current snap settings
```
sudo snap get wekan
```
## LDAP
- Settings can be seen with command `wekan.help` and [this config file](https://raw.githubusercontent.com/wekan/wekan/master/snap-src/bin/config).
- LDAP repo https://github.com/wekan/wekan-ldap
- Bugs and Feature Requests LDAP repo https://github.com/wekan/wekan-ldap/issues
Example from setting listed at [this config file](https://raw.githubusercontent.com/wekan/wekan/master/snap-src/bin/config):
```
sudo snap set wekan ldap-enable='true'
sudo snap set wekan default-authentication-method='ldap'
sudo snap set wekan ldap-fullname-field='CN'
```
## List of supported keys
```
mongodb-bind-unix-socket: mongodb binding unix socket:
Default behaviour will preffer binding over unix socket, to
disable unix socket binding set value to 'nill' string
To bind to instance of mongodb provided through content
interface, set value to relative path to the socket inside
'shared' directory.
Default value: set to use unix socket binding
mongodb-bind-ip: mongodb binding ip address: eg 127.0.0.1 for localhost
If not defined default unix socket binding is used instead
Default value: ''
mongodb-port: mongodb binding port: eg 27017 when using localhost
Default value: '27019'
mail-url: wekan mail binding
Example: 'smtps://user:pass@mailserver.examples.com:453/'
Default value: 'smtp://user:pass@mailserver.examples.com:25/'
mail-from: wekan's admin mail from name email address
For example: 'Boards Support <support@example.com>'
Default value: 'wekan-admin@example.com'
root-url: wekan's root url, eg http://127.0.0.1, https://example.com,
https://wekan.example.com, http://example.com/wekan
Default value: 'http://127.0.0.1'
port: port wekan is exposed at
Default value: '8080'
disable-mongodb: Disable mongodb service: use only if binding to
database outside of Wekan snap. Valid values: [true,false]
Default value: 'false'
caddy-enabled: Enable caddy service (caddy - Every Site on HTTPS).
see https://caddyserver.com/products/licenses and
https://github.com/wekan/wekan-snap/issues/39 ,
use personal non-commercial license or
contact Wekan maintainer x@xet7.org about enabling
commercial license for Caddy.
Set to 'true' to enable caddy.
caddy settings are handled through
/var/snap/wekan/common/Caddyfile
Default value: 'false'
caddy-bind-port: Port on which caddy will expect proxy, same value
will be also set in Caddyfile
Default value: '3001'
with-api: To enable the API of wekan. If API is disabled,
exporting board to JSON does not work.
Default value: 'true'
cors: Set Access-Control-Allow-Origin header. Example:
snap set wekan cors='*'
Default value, disabled: ''
browser-policy-enabled: Enable browser policy and allow one
trusted URL that can have iframe that has
Wekan embedded inside.
Setting this to false is not recommended,
it also disables all other browser policy protections
and allows all iframing etc. See wekan/server/policy.js
Default value: 'true'
trusted-url: When browser policy is enabled, HTML code at this URL
can have iframe that embeds Wekan inside.
Example: trusted-url='https://example.com'
Default value: ''
webhooks-attributes: What to send to Outgoing Webhook, or leave out.
Example, that includes all that are default:
cardId,listId,oldListId,boardId,comment,user,card,commentId .
To enable the Webhooks Attributes of Wekan:
snap set wekan webhooks-attributes=cardId,listId,oldListId,boardId,comment,user,card,commentId
Disable the Webhooks Attributest of Wekan to send all default ones:
snap set wekan webhooks-attributes=''
```
## Rocket.Chat providing OAuth2 login to Wekan
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.
[OAuth2 Login Docs](https://github.com/wekan/wekan/wiki/OAuth2)
## [Matomo web analytics](https://matomo.org) integration
Example:
```
sudo snap set wekan matomo-address='https://matomo.example.com/'
sudo snap set wekan matomo-site-id='25'
sudo snap set wekan matomo-with-username='true'
sudo snap set wekan matomo-do-not-track='false'
```
Matomo settings keys:
```
matomo-address: The address of the server where matomo is hosted
No value set, using default value: ''
matomo-site-id: The value of the site ID given in matomo server for wekan
No value set, using default value: ''
matomo-do-not-track: The option do not track which enables users to not be tracked by matomo
Current value set to: 'true', (default value: 'true')
matomo-with-username: The option that allows matomo to retrieve the username
Current value set to: 'false', (default value: 'false')
```
**When settings are changed, wekan/mongo/caddy services are automatically restarted for changes to take effect.**

81
docs/wekan-snap.wiki/Testing-new-WeKan-Snap-versions.md Normal file
View file

@ -0,0 +1,81 @@
Please:
- Test does WeKan on some non-stable channel work, [add a new issue](https://github.com/wekan/wekan-snap/issues) about can it be added to stable channel.
- Check [is there PR about fixing some bug already](https://github.com/wekan/wekan/pulls)
- Please report bugs [by adding a new issue](https://github.com/wekan/wekan-snap/issues).
- Make backups first, so you are not using your only copy of production data
- Have time to test
- Have enough disk space. For example, some update migration could write all attachments from database to some subdirectory of `/var/snap/wekan/common` or `/var/snap/wekan-gantt-gpl/common`.
- You can try bleeding edge versions of Wekan Snap, that contains cool new features, and could be broken in many ways.
- Sometimes Snap builds fail, so then there is no package file to upload to Snap store at all, only successfully built are visible at Snap store. Successfully built does not mean that every feature works.
[Changing between WeKan and WeKan Gantt GPL](https://github.com/wekan/wekan/issues/2870#issuecomment-721364824)
## 1) Stop WeKan
```
sudo snap stop wekan
```
or
```
sudo snap stop wekan-gantt-gpl
```
## 2) Create Backup
2.1 Backup settings:
```
sudo snap get wekan > snap-settings.txt
```
or
```
sudo snap get wekan-gantt-gpl > snap-settings.txt
```
2.2 https://github.com/wekan/wekan/wiki/Backup
2.3 Copy files to safe place from /var/snap/wekan/common or /var/snap/wekan-gantt-gpl/common . There could be some board attachments etc.
## 3) Check what is available at various channels
https://snapcraft.io/wekan
https://snapcraft.io/wekan-gantt-gpl
- Stable: Current working version
- Beta: Maybe work, or not
- Edge: Newest that did build, no idea does it work or not
This is how you can try snap beta channel:
```
sudo snap refresh wekan --beta --amend
```
This is how to change back to snap stable channel, that most Wekan users have installed:
```
sudo snap refresh wekan --stable --amend
```
Wekan stable versions are numbered v1.x
## 4) Update all Snaps to newest on that channel
[Check you don't have Snap updates disabled](Automatic-update-schedule#if-required-you-can-disable-all-snap-updates)
```
sudo snap refresh
```
## 5) Start WeKan
```
sudo snap stop wekan
```
or
```
sudo snap stop wekan-gantt-gpl
```
## Other docs
* [Adding Snap settings to code](https://github.com/wekan/wekan/wiki/Adding-new-Snap-settings-to-code)
* [Wekan Developer Docs](https://github.com/wekan/wekan/wiki/Developer-Documentation)

65
docs/wekan-snap.wiki/Troubleshooting.md Normal file
View file

@ -0,0 +1,65 @@
[Info source](https://github.com/wekan/wekan-snap/issues/4#issuecomment-311355296)
1) All you need to do is
```
$ snap install wekan
```
2) Enable/disable is not needed, it is there for cases when for example you want to stop wekan, but do not want to uninstall it (uninstall will delete also all user data)
3) Wekan is service, so apart of help, it does not have any "user executables"
4) You can check status of wekan with:
```
$ sudo systemctl status snap.wekan.*
```
there should be two services, mongodb and wekan running, of either of them is showing error, that would be place to look first. To get detailed look, use
```
$ sudo journalctl -u snap.wekan.*
```
or detailed look of one of services:
```
$ sudo journalctl -u snap.wekan.wekan.service
```
or
```
$ snap.wekan.mongodb.service
```
5) Content interface for mongodb (wekan:mongodb-slot, wekan:mongodb-plug) is there only for more complex cases where for reason you want to:
a) share wekan's mongodb instance with other services, use wekan:mongodb-slot
b) you want to use mongodb instance from some other service, use wekan:mongodb-plug
so connecting wekan:mongodb-plug to wekan:mongodb-slot really makes no sense :)
As @xet7 suggested, first thing to make sure is that update your machine, so you are running up to date snapd. You can check your version with
```
$ snap version
```
Currently we are on 2.26
Otherwise shared folders are created under:
```
/var/snap/wekan/current where writable data lives
```
Databases and other settings live under:
```
/var/snap/wekan/common/
/snap/wekan/current is read only mount of squashfs wekan's image.
```
[Troubleshooting Email](https://github.com/wekan/wekan/wiki/Troubleshooting-Mail)

54
docs/wekan-snap.wiki/Uninstall.md Normal file
View file

@ -0,0 +1,54 @@
List what snaps you have installed. Core is part of snap itself.
```
sudo snap list
```
List what snap services are running:
```
sudo snap services
```
Uninstall Wekan snap and delete all Wekan data. If you have other snaps installed, you can remove them too. Don't remove core, it's part of snap itself.
```
sudo snap stop wekan
sudo snap disable wekan
sudo snap remove wekan
```
OPTIONAL ALTERNATIVE WAY, NOT REQUIRED: Disable some services of wekan using systemd:
```
sudo systemctl stop snap.wekan.wekan
sudo systemctl stop snap.wekan.mongodb
sudo systemctl stop snap.wekan.caddy
sudo systemctl disable snap.wekan.wekan
sudo systemctl disable snap.wekan.mongodb
sudo systemctl disable snap.wekan.caddy
```
Uninstall snap at CentOS:
```
sudo systemctl disable --now snapd.socket
sudo yum copr disable ngompa/snapcore-el7
sudo yum remove yum-plugin-copr snapd
```
Uninstall snap at Debian/Ubuntu/Mint:
```
sudo systemctl stop snapd
sudo systemctl disable snapd
sudo apt --purge remove snapd
```
Uninstall snap at [Ubuntu 14.04](https://github.com/wekan/wekan-snap/issues/34#issuecomment-378295168):
```
sudo service snapd stop
sudo update-rc.d -f snapd remove
sudo apt-get --purge remove snapd
```

5
docs/wekan-snap.wiki/Update-all-snap-packages.md Normal file
View file

@ -0,0 +1,5 @@
Update all snap packages, like Wekan and others, with commmand:
```
sudo snap refresh
```

22
docs/wekan.wiki/ADFS.md Normal file
View file

@ -0,0 +1,22 @@
## ADFS 4.0 using OAuth 2 and OpenID
[Related issue](https://github.com/wekan/wekan/issues/3184)
There is these settings.
## Snap
```
sudo snap set oauth2-enabled='true'
sudo snap set oauth2-adfs-enabled='true'
```
Unset:
```
sudo snap unset oauth2-enabled
sudo snap unset oauth2-adfs-enabled
```
## Docker and .sh/.bat
```
OAUTH2_ENABLED=true
OAUTH2_ADFS_ENABLED=true
```
To disable, uncomment or remove that line.

186
docs/wekan.wiki/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

14
docs/wekan.wiki/Accounts-Lockout.md Normal file
View file

@ -0,0 +1,14 @@
## Brute force protection
For settings, see:
- Snap: `wekan.help | grep lockout`
- Docker: Search lockout from docker-compose.yml at https://github.com/wekan/wekan
[Removing lockout from users](https://github.com/wekan/wekan/issues/3306)
For UCS, it's UCS VM and inside it Docker container. You just ssh your ucs VM like this, with same username password you used when installin UCS and administering UCS apps, su to root:
```
ssh Administrator@192.168.0.100
su
```
And then use those Docker commands https://github.com/wekan/wekan/issues/3306#issuecomment-712743002

91
docs/wekan.wiki/Adding-new-Snap-settings-to-code.md Normal file
View file

@ -0,0 +1,91 @@
# Also see Snap Developer Docs
[Snap Developer Docs](https://github.com/wekan/wekan-snap/wiki/Snap-Developer-Docs)
# When adding settings to code you or somebody else wrote
Add all necessary settings that you find on code.
After doing all changes, [fix lint errors](Developer-Documentation#preventing-travis-ci-lint-errors-before-submitting-pull-requests) and if possible warnings too. You can silence errors if you really can't find solution.
Submit pull request to Wekan edge branch https://github.com/wekan/wekan/tree/edge
# Changes to server code
To use environment variables in your serverside code, use:
```
process.env.YOURSETTING
```
Example: [wekan/server/policy.js](https://github.com/wekan/wekan/blob/edge/server/policy.js)
# Changes to [config](https://github.com/wekan/wekan/blob/edge/snap-src/bin/config)
## 1) Add to beginning
At beginning there is this line:
```
# list of supported keys
keys="MONGODB_BIND_UNIX_SOCKET MONGODB_BIND_IP ..."
```
To the end of it, add name of new setting. For example:
```
keys="... AWESOME_FEATURE_ENABLED"
```
## 2) Add to bottom
Example 1: Set features not enabled as default.
```
DESCRIPTION_LDAP_ENABLED="LDAP enabled. Default: false"
DEFAULT_LDAP_ENABLED="false"
KEY_LDAP_ENABLED="ldap-enabled"
```
Example 2: If setting is different for every server, leave it empty.
```
DESCRIPTION_OAUTH2_TOKEN_ENDPOINT="OAuth2 token endpoint. Example: /oauth/token"
DEFAULT_OAUTH2_TOKEN_ENDPOINT=""
KEY_OAUTH2_TOKEN_ENDPOINT="oauth2-token-endpoint"
```
Example 3: If there is same for every server, set it to general setting.
```
DESCRIPTION_LDAP_SEARCH_FILTER="LDAP search filter. Default: (&(objectCategory=person)(objectClass=user)(!(cn=andy)))"
DEFAULT_LDAP_SEARCH_FILTER="(&(objectCategory=person)(objectClass=user)(!(cn=andy)))"
KEY_LDAP_ENABLED="ldap-enabled"
```
Example 4: If you don't know example, leave it without example.
```
DESCRIPTION_TURBO_FILTER="Turbo filter. Default: ''"
DEFAULT_TURBO_FILTER=""
KEY_TURBO_FILTER="turbo-filter"
```
# Changes to [Snap help](https://github.com/wekan/wekan/blob/edge/snap-src/bin/wekan-help)
## 1) How to quote examples
Snap settings need to be lowercase, and inside single quotes. For example:
```
snap set wekan ldap-user-search-filter='(&(objectCategory=person)(objectClass=user)(!(cn=andy)))'
```
The setting inside single quotes is the actual setting.
Actual settings can include double quotes, spaces, etc, but not single quotes. For example:
```
snap set wekan ldap-user-search-filter='"(&(objectCategory=person)(objectClass=user)(!(cn=andy)))"'
```
## 2) What to add as setting to Wekan help
Example 1:
```
echo -e "OAuth2 Token Endpoint. Example: /oauth/token"
echo -e "To enable the OAuth2 Token Endpoint of Wekan:"
echo -e "\t$ snap set $SNAP_NAME OAUTH2_TOKEN_ENDPOINT='/oauth/token'"
echo -e "\t-Disable the OAuth2 Token Endpoint of Wekan:"
echo -e "\t$ snap set $SNAP_NAME OAUTH2_TOKEN_ENDPOINT=''"
echo -e "\n"
```
So all you add need to be above of this line:
```
# parse config file for supported settings keys
```

32
docs/wekan.wiki/Adding-users.md Normal file
View file

@ -0,0 +1,32 @@
## Standalone Wekan: Snap, (Docker, Source, VirtualBox)
1) [Install Wekan Snap](https://github.com/wekan/wekan-snap/wiki/Install)
2) Go to your Wekan URL like https://example.com/sign-up (your address + /sign-up)
3) Register your username, email address and password. First registered user will be admin, and next ones normal users. If you want other admins too, you can change their permission to admin at Admin Panel.
4) **If you get Internal Server Error when creating account, it's because you have not configured email, and you can ignore it. WORKING EMAIL IS NOT REQUIRED. Wekan works without setting up email.**
If you really want email sending, do for example:
```
sudo snap set wekan mail-url='smtps://user:pass@mailserver.example.com:457/'
sudo snap set wekan mail-from='Example Wekan Support <support@example.com>'
```
For more options see [Troubleshooting Email](Troubleshooting-Mail)
5) Login to Wekan at https://example.com/sign-in (your address + /sign-in)
6) Click on top right your username / Admin Panel. You can change permissions, name, email address and password in Admin Panel.
![Admin Panel](https://wekan.github.io/wekan-admin-panel.png)
7) For registering other users:
a) Let them self-register, or open webbrowser incongnito window, and register them at https://example.com/sign-up (your address + /sign-up)
b) If your email works, click Admin Panel / Settings / Registration / [X] Disable self-registration. Then invite new users to selected boards by email address.
## Deleting Users
[No delete feature yet](https://github.com/wekan/wekan/issues/1289)

3
docs/wekan.wiki/Allow-private-boards-only.md Normal file
View file

@ -0,0 +1,3 @@
[Wekan v5.55 and newer](https://github.com/wekan/wekan/blob/main/CHANGELOG.md#v555-2021-08-31-wekan-release)
<img src="https://wekan.github.io/allow-private-boards-only.png" width="60%" alt="Allow private boards only" />

55
docs/wekan.wiki/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

143
docs/wekan.wiki/Apache.md Normal file
View file

@ -0,0 +1,143 @@
## 1) Enable Mod_Proxy
```
sudo a2enmod ssl proxy proxy_http proxy_wstunnel proxy_balancer
```
[Apache Mod_Proxy documentation](http://httpd.apache.org/docs/current/mod/mod_proxy.html)
## 2) Restart Apache
Systemd:
```
sudo systemctl restart apache2
```
Init.d:
```
sudo service apache2 restart
```
## 3) Enable SSL in Apache config
```
Listen 443
NameVirtualHost *:443
```
## 4) Set Apache proxy
Remember to set `- ROOT_URL=` to the full URL used for your reverse proxy or as `ServerName`.
### a) Main URL
SSL with [Certbot](https://certbot.eff.org).
Config at `/etc/apache2/sites-available/example.com.conf`:
```ApacheConf
<VirtualHost *:443>
ServerName example.com
SSLEngine On
SSLCertificateFile /etc/letsencrypt/live/example.com/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/example.com/privkey.pem
Include /etc/letsencrypt/options-ssl-apache.conf
ServerSignature Off
<Location />
require all granted
</Location>
ProxyPassMatch "^/(sockjs\/.*\/websocket)$" "ws://127.0.0.1:3001/$1"
ProxyPass "/" "http://127.0.0.1:3001/"
ProxyPassReverse "/" "http://127.0.0.1:3001/"
<Proxy *>
Options FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
allow from all
</Proxy>
</VirtualHost>
```
### b) Sub URL
Currently, favicon loading does not work with sub-url [wekan/issues/1692](https://github.com/wekan/wekan/issues/1692)
Config at `/etc/apache2/sites-available/example.com.conf`:
```ApacheConf
<VirtualHost *:443>
ServerName example.com/wekan
SSLEngine On
SSLCertificateFile /etc/letsencrypt/live/example.com/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/example.com/privkey.pem
Include /etc/letsencrypt/options-ssl-apache.conf
ServerSignature Off
ProxyPassMatch "^/(sockjs\/.*\/websocket)$" "ws://127.0.0.1:3001/wekan/$1"
ProxyPass "/wekan" "http://127.0.0.1:3001/wekan"
ProxyPassReverse "/wekan" "http://127.0.0.1:3001/wekan"
<Proxy *>
Options FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
allow from all
</Proxy>
</VirtualHost>
```
To run as default site:
```ApacheConf
<VirtualHost _default_:443>
```
## 5) Enable your site
```
sudo a2ensite example.com
```
Or, add symlink manually:
```
sudo su
cd /etc/apache2/sites-enabled
ln -s ../sites-available/example.com.conf example.com.conf
```
On some distributions, Apache config is at different path:
```
cd /etc/httpd/conf.d
```
## 6) Reload Apache
Systemd:
```
sudo systemctl restart apache2
```
Init.d:
```
sudo service apache2 restart
```
## 7) Snap settings
### a) Main URL
```
sudo snap set wekan port='3001'
sudo snap set wekan root-url='https://example.com'
```
### b) Sub URL
```
snap set wekan port='3001'
snap set wekan root-url='https://example.com/wekan'
```
[All snap settings](https://github.com/wekan/wekan-snap/wiki/Supported-settings-keys)

31
docs/wekan.wiki/Archive-and-Delete.md Normal file
View file

@ -0,0 +1,31 @@
These are on Standalone Wekan: Snap/Docker/Source/VirtualBox. Some of these are also at Sandstorm Wekan.
## Move to Archive: Restore possible
Board => ☰ => Move Board to Archive
Swimlane => ☰ => Move Swimlane to Archive
List => ☰ => Move List to Archive
Card => ☰ => Move Card to Archive
## Restore Card/List/Swimlane from Archive
Board => ☰ => Archive => Cards/Lists/Swimlanes Restore (or Delete - but that has no undo!! It's FINAL DELETE).
## Restore or Delete board
All Boards => Archive => Restore (or Delete - but that has no undo!! It's FINAL DELETE).
## Deleting - NO UNDO
Deleting Board: All Boards => Archive => Delete
Deleting Card: Card => ☰ => More => Delete (at right bottom corner)
Deleting List: List => ☰ => More => Delete (at right bottom corner)
Deleting Swimlane:
1) Swimlane => ☰ => Move Swimlane to Archive
2) Board => ☰ => Archive => Cards/Lists/Swimlanes Restore (or Delete - but that has no undo!! It's FINAL DELETE).

5
docs/wekan.wiki/Asana.md Normal file
View file

@ -0,0 +1,5 @@
2022-03-02
[Added Perl scripts for Asana export to WeKan ®](https://github.com/wekan/wekan/tree/main/asana)
Thanks to GeekRuthie !

178
docs/wekan.wiki/Azure.md Normal file
View file

@ -0,0 +1,178 @@
### Install for example from:
- [Snap](Snap)
- [Docker](Docker)
*Make sure you are running at least **v2.21***
### Snap install info, tested 2021-07-16
[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
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

47
docs/wekan.wiki/B2C.md Normal file
View file

@ -0,0 +1,47 @@
## Azure AD B2C using OAuth2
- Original issue: https://github.com/wekan/wekan/issues/5242
- B2C feature added: https://github.com/wekan/wekan/commit/93be112a9454c894c1ce3146ed377e6a6aeca64a
- Similar like [ADFS](ADFS), but `email` is first of array `userinfo[emails]`
## Snap
```
sudo snap set wekan oauth2-enabled='true'
sudo snap set wekan oauth2-b2c-enabled='true'
sudo snap set wekan oauth2-username-map='sub'
sudo snap set wekan oauth2-request-permissions='openid email profile'
sudo snap set wekan oauth2-client-id='xxxxxxxx'
sudo snap set wekan oauth2-secret='xxxxxxx'
sudo snap set wekan oauth2-server-url='https://B2C_TENANT_NAME.b2clogin.com/B2C_TENANT_NAME.onmicrosoft.com/B2C_POLICY_NAME'
sudo snap set wekan oauth2-auth-endpoint='/oauth2/v2.0/authorize'
sudo snap set wekan oauth2-token-endpoint='/oauth2/v2.0/token'
sudo snap set wekan oauth2-username-map='sub'
sudo snap set wekan oauth2-email-map='email'
sudo snap set wekan oauth2-fullname-map='name'
sudo snap set wekan oauth2-id-map='sub'
```
## Docker
https://github.com/wekan/wekan/blob/main/docker-compose.yml
```
- OAUTH2_ENABLED=true
- OAUTH2_B2C_ENABLED=true
- OAUTH2_USERNAME_MAP=sub
- OAUTH2_REQUEST_PERMISSIONS=openid email profile
- OAUTH2_CLIENT_ID=xxxxxxxx
- OAUTH2_SECRET=xxxxxxx
- OAUTH2_SERVER_URL=https://B2C_TENANT_NAME.b2clogin.com/B2C_TENANT_NAME.onmicrosoft.com/B2C_POLICY_NAME
- OAUTH2_AUTH_ENDPOINT=/oauth2/v2.0/authorize
- OAUTH2_TOKEN_ENDPOINT=/oauth2/v2.0/token
- OAUTH2_USERNAME_MAP=sub
- OAUTH2_EMAIL_MAP=email
- OAUTH2_FULLNAME_MAP=name
- OAUTH2_ID_MAP=sub
```
## Others
Similar like above Docker.

777
docs/wekan.wiki/Backup.md Normal file
View file

@ -0,0 +1,777 @@
[Sandstorm](Sandstorm) - [Sandstorm Backup](Export-from-Wekan-Sandstorm-grain-.zip-file)
# Upcoming
[Transferring to Minio and SQLite](https://github.com/wekan/minio-metadata)
# Backup Docker
[Also see: Upgrading Synology with Wekan quay images](https://github.com/wekan/wekan/issues/3874#issuecomment-867526249)
Note: Do not run `docker-compose down` without verifying your docker-compose file, it does not delete the data by default but caution is advised. Refer to https://docs.docker.com/compose/reference/down/.
[docker-compose.yml](https://raw.githubusercontent.com/wekan/wekan/master/docker-compose.yml)
This presumes your Wekan Docker is currently running with:
```bash
docker-compose up -d
```
Backup to directory dump:
```bash
docker stop wekan-app
docker exec wekan-db rm -rf /data/dump
docker exec wekan-db mongodump -o /data/dump
docker cp wekan-db:/data/dump .
docker start wekan-app
```
Copy dump directory to other server or to your backup.
# Restore Docker
```bash
docker stop wekan-app
docker exec wekan-db rm -rf /data/dump
docker cp dump wekan-db:/data/
docker exec wekan-db mongorestore --drop --dir=/data/dump
docker start wekan-app
```
# Upgrade Docker Wekan version
Note: Do not run `docker-compose down` without verifying your docker-compose file, it does not delete the data by default but caution is advised. Refer to https://docs.docker.com/compose/reference/down/.
```bash
docker-compose stop
docker rm wekan-app
```
a) For example, if you in docker-compose.yml use `image: wekanteam/wekan` or `image: quay.io/wekan/wekan` for latest development version
b) Or in docker-compose.yml change version tag, or use version tag like `image: wekanteam/wekan:v5.50` or `image: quay.io/wekan/wekan:v5.50`
```bash
docker-compose up -d
```
# Backup Wekan Snap to directory dump
```bash
sudo snap stop wekan.wekan
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan/current/lib/x86_64-linux-gnu
export PATH="/snap/wekan/current/bin:$PATH"
mongodump --port 27019
sudo snap get wekan > snap-settings.sh
```
NOTE for Arch Linux: Use this path instead. [Source](https://github.com/wekan/wekan/issues/3941).
```bash
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH-}:/var/lib/snapd/snap/wekan/current/lib/x86_64-linux-gnu
```
username is your /home/username
```bash
sudo chown username:username snap-settings.sh
sudo snap start wekan.wekan
```
Modify snap-settings.sh so that it has commands like:
```bash
sudo snap set wekan root-url='http://localhost'
```
Set snap-settings.sh executeable:
```bash
chmod +x snap-settings.sh
```
# Restore Wekan Snap
```bash
sudo snap stop wekan.wekan
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan/current/lib/x86_64-linux-gnu
export PATH="$PATH:/snap/wekan/current/bin"
mongorestore --drop --port 27019
sudo snap start wekan.wekan
./snap-settings.sh
```
# Upgrade Snap manually immediately (usually it updates automatically)
```bash
sudo snap refresh
```
# Backup Wekan Gantt GPLv2 Snap to directory dump
```bash
sudo snap stop wekan-gantt-gpl.wekan
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan-gantt-gpl/current/lib/x86_64-linux-gnu
export PATH="$PATH:/snap/wekan-gantt-gpl/current/bin"
mongodump --port 27019
sudo snap get wekan-gantt-gpl > snap-settings.sh
```
username is your /home/username
```bash
sudo chown username:username snap-settings.sh
sudo snap start wekan-gantt-gpl.wekan
```
Modify snap-settings.sh so that it has command like:
```bash
sudo snap set wekan-gantt-gpl root-url='http://localhost'
```
Set snap-settings.sh executeable:
```bash
chmod +x snap-settings.sh
```
# Restore Wekan Gantt GPLv2 Snap
```bash
sudo snap stop wekan-gantt-gpl.wekan
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan-gantt-gpl/current/lib/x86_64-linux-gnu
export PATH="$PATH:/snap/wekan-gantt-gpl/current/bin"
mongorestore --drop --port 27019
sudo snap start wekan-gantt-gpl.wekan
./snap-settings.sh
```
# DBGate, Open Source MongoDB GUI
https://dbgate.org - https://github.com/dbgate/dbgate
# Using nosqlbooster closed source MongoDB GUI with Wekan Snap to edit MongoDB database
https://nosqlbooster.com/downloads
### At server where Wekan Snap is installed, MongoDB is running at localhost port 27019
<img src="https://wekan.github.io/nosqlbooster-basic-connection.png" width="60%" alt="Wekan logo" />
### You can tunnel via SSH to server, using password auth or private key auth dropdown selection
<img src="https://wekan.github.io/nosqlbooster-ssh-tunnel.png" width="60%" alt="Wekan logo" />
# Scheduled backups to local or remote server
For below scheduled backup scripts, no info from above of this wiki page is required. Backup scripts below have the required settings.
This does backup of [Wekan+RocketChat snap databases](OAuth2) and php website etc.
If you need to backup some remote server or cloud, you can use scp, or read [rclone docs](https://rclone.org/docs/) about how to configure saving to some other remote server or cloud.
The following .sh bash scripts are added as root user to your `/root/` directory.
Backups are created to subdirectories of `/root/backups/`.
Cron is used to schedule backups, for example once a day.
1. To add bash scripts, you change to root user with this command, and your sudo or root password.
```bash
sudo su
```
2. Use nano editor for editing cron. If you don't have it installed, type:
```bash
apt install nano
```
3. Then we set text editor to be nano. Otherwise it probably uses vi, that is harder to use.
```bash
export EDITOR=nano
```
4. Now we start editing cron scheduler.
```bash
crontab -e
```
For more info how to make cron time, see https://crontab.guru
In this example, we set backups every day at 04:00, then it runs backup.sh script, and saves output of the backup commands to the bottom of textfile backup.log.txt
```bash
# m h dom mon dow command
0 4 * * * /root/backup.sh >> /root/backup.log.txt 2>&1
```
- For changing to `/root` directory, type: `cd /root`
- for editing backup.sh file, type: `nano backup.sh`
- For saving in nano, press Ctrl-o Enter
- For exiting nano, press Ctrl-x Enter
- Set every .sh file as executeable, for example: `chmod +x backup.sh`
This is content of `backup.sh` script. It runs all the other backup scripts.
If you do not need to backup rocketchat or website, or do not need to use rclone,
you don't need to add those command lines at all.
```bash
cd /root
./backup-wekan.sh
./backup-rocketchat.sh
./backup-website.sh
rclone move backups cloudname:backup.example.com
```
More about rclone:
/root/rclone-ls-all.sh , shows directory contests at cloud:
```bash
rclone lsd cloudname:
```
In this example, cron does run backup scripts as root.
This is if you edit cron with command `crontab -e` as root user,
so it edits the cron of root user.
If mongodump command works as normal user for you, you could instead
run backups as normal user, by exiting root user with `exit` and
then as normal user editing cron with `crontab -e`.
You can also list current cron with command `crontab -l`.
If you like to backup Wekan snap settings with this command, then it
only works with sudo at front, or as a root user without sudo at front.
```bash
sudo snap get wekan > snap-settings.txt
```
This below is backup script for backing up Wekan.
/root/backup-wekan.sh
```bash
#!/bin/bash
makeDump()
{
# Backups will be created below this directory.
backupdir="/root/backups/wekan"
# Gets the version of the snap.
version=$(snap list | grep wekan | awk -F ' ' '{print $3}')
# Gets current time to variable "now"
now=$(date +'%Y-%m-%d_%H.%M.%S')
# Creates new backup directory like BACKUPDIR/BACKUPVERSIO-TIMENOW
mkdir -p $backupdir/$version-$now
# Targets the dump file.
#dump=$"/snap/wekan/$version/bin/mongodump"
# Changes to backup directory
cd $backupdir/$version-$now
# Backup Caddy settings
snap get wekan > snap-settings.txt
# Show text that database backup is in progress
printf "\nThe database backup is in progress.\n\n"
# Backup to current directory, creates subdirectory called "dump"
# with database dump files
mongodump --port 27019
# Change diretory (=cd) to parent directory
cd ..
# Show text "Makes the tar.gz archive file"
printf "\nMakes the tar.gz archive file.\n"
# Creates tar.gz archive file. This works similarly like creating .zip file.
tar -zcvf $version-$now.tar.gz $version-$now
# Delete temporary files that have already been
# compressed to above tar.gz file
rm -rf $version-$now
# Shows text "Backup done."
printf "\nBackup done.\n"
# Show where backup archive file is.
echo "Backup is archived to .tar.gz file at $backupdir/${version}-${now}.tar.gz"
}
# Checks is the user is sudo/root
if [ "$UID" -ne "0" ]
then
echo "This program must be launched with sudo/root."
exit 1
fi
# Starts
makeDump
```bash
/root/backup-rocketchat.sh
```bash
#!/bin/bash
makeDump()
{
backupdir="/root/backups/rocketchat"
# Gets the version of the snap.
version=$(snap list | grep wekan | awk -F ' ' '{print $3}')
# Prepares.
now=$(date +'%Y-%m-%d_%H.%M.%S')
mkdir -p $backupdir/$version-$now
# Targets the dump file.
dump=$"/snap/wekan/$version/bin/mongodump"
# Makes the backup.
cd $backupdir/$version-$now
printf "\nThe database backup is in progress.\n\n"
$dump --port 27017
# Makes the tar.gz file.
cd ..
printf "\nMakes the tar.gz file.\n"
tar -zcvf $version-$now.tar.gz $version-$now
# Cleanups
rm -rf $version-$now
# End.
printf "\nBackup done.\n"
echo "Backup is archived to .tar.gz file at $backupdir/${version}-${now}.tar.gz"
}
# Checks is the user is sudo/root
if [ "$UID" -ne "0" ]
then
echo "This program must be launched with sudo/root."
exit 1
fi
# Starts
makeDump
```
/root/backup-website.sh
```bash
#!/bin/bash
makeDump()
{
backupdir="/root/backups/example.com"
# Gets the version of the snap.
version=$(snap list | grep wekan | awk -F ' ' '{print $3}')
# Prepares.
now=$(date +'%Y-%m-%d_%H.%M.%S')
mkdir -p $backupdir/$version-$now
# Makes the backup.
cd $backupdir/$version-$now
printf "\nThe file backup is in progress.\n\n"
# Makes the tar.gz file.
cd ..
printf "\nMakes the tar.gz file.\n"
cp -pR /var/snap/wekan/common/example.com $version-$now
tar -zcvf $version-$now.tar.gz $version-$now
# Cleanups
rm -rf $version-$now
# End.
printf "\nBackup done.\n"
echo "Backup is archived to .tar.gz file at $backupdir/${version}-${now}.tar.gz"
}
# Checks is the user is sudo/root
if [ "$UID" -ne "0" ]
then
echo "This program must be launched with sudo/root."
exit 1
fi
# Starts
makeDump
```
/var/snap/wekan/common/Caddyfile
```bash
chat.example.com {
proxy / localhost:3000 {
websocket
transparent
}
}
https://boards.example.com {
proxy / localhost:3001 {
websocket
transparent
}
}
example.com {
root /var/snap/wekan/common/example.com
fastcgi / /var/run/php/php7.0-fpm.sock php
}
matomo.example.com {
root /var/snap/wekan/common/matomo.example.com
fastcgi / /var/run/php/php7.0-fpm.sock php
}
# Example CloudFlare free wildcard SSL Origin Certificate, there is example.com.pem at certificates directory with private key at to and cert at bottom.
http://example.com https://example.com {
tls {
load /var/snap/wekan/common/certificates
alpn http/1.1
}
root /var/snap/wekan/common/example.com
browse
}
static.example.com {
root /var/snap/wekan/common/static.example.com
}
```
## Related talk about MongoDB backup
Related talk, search for "mongodb" this page:
https://fosdem.org/2020/schedule/events/
There is this:
Percona Backup for MongoDB: Status and Plans
Open Source solution for consistent backups of multi-shard MongoDB
- [Slides](https://fosdem.org/2020/schedule/event/perconamongodb/attachments/slides/3768/export/events/attachments/perconamongodb/slides/3768/Percona_Backup_for_MongoDB.pdf)
- [Video webm](https://video.fosdem.org/2020/UD2.119/perconamongodb.webm)
- [Same Video mp4](https://video.fosdem.org/2020/UD2.119/perconamongodb.mp4)
## Related Sandstorm issue
[Creating a backup while the grain is running could cause corruption](https://github.com/sandstorm-io/sandstorm/issues/3186).
## Combining old and new Wekan version data
Note: Do mongodump/mongorestore only when Wekan is stopped: wekan.wekan (Snap) or wekan-app (Docker).
1. From new Wekan export all boards to Wekan JSON.
2. Backup new Wekan with mongodump.
3. Backup old Wekan with mongodump.
4. Restore old Wekan data to new Wekan with mongorestore.
5. Restore new Wekan JSON exported boards by importing them.
## Rescuing board that does not load
Wekan web UI Import/Export JSON does not have all content currently. To upgrade from old Wekan version, use mongodump/mongorestore to newest Wekan, like described below.
To import big JSON file, on Linux you can use xclip to copy textfile to clipboard:
```bash
sudo apt-get install xclip
cat board.json | xclip -se c
```
Then paste to webbrowser Wekan Add Board / Import / From previous export.
You can [save all MongoDB database content as JSON files](Export-from-Wekan-Sandstorm-grain-.zip-file). Files are base64 encoded in JSON files.
Export board to Wekan JSON, and import as Wekan JSON can make some part of board to load, but you should check is some data missing.
With Wekan Snap, you can use [nosqlbooster GUI](https://nosqlbooster.com/downloads) to login through SSH to Wekan server localhost port 27019 and browse data.
You could use [daff](https://github.com/paulfitz/daff) to compare tables.
## Using Snap Mongo commands on your bash CLI
Add to your `~/.bashrc`
```bash
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan/current/lib/x86_64-linux-gnu
export PATH="$PATH:/snap/wekan/current/bin"
```
Then you can backup:
```bash
mongodump --port 27019
```
And restore:
```bash
mongorestore --drop --port 27019
```
## MongoDB shell on Wekan Snap
mongoshell.sh
```bash
#/bin/bash
export LC_ALL=C
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan/current/lib/x86_64-linux-gnu
version=$(snap list | grep wekan | awk -F ' ' '{print $3}')
mongo=$"/snap/wekan/$version/bin/mongo"
$mongo --port 27019
```
***
# Snap backup-restore v2
Originally from https://github.com/wekan/wekan-snap/issues/62#issuecomment-470622601
## Backup
wekan-backup.sh
```bash
#!/bin/bash
export LC_ALL=C
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan/current/lib/x86_64-linux-gnu
version=$(snap list | grep wekan | awk -F ' ' '{print $3}')
now=$(date +"%Y%m%d-%H%M%S")
parent_dir="/data/backups/wekan"
backup_dir="${parent_dir}/${now}"
log_file="${parent_dir}/backup-progress.log.${now}"
error () {
printf "%s: %s\n" "$(basename "${BASH_SOURCE}")" "${1}" >&2
exit 1
}
trap 'error "An unexpected error occurred."' ERR
take_backup () {
mkdir -p "${backup_dir}"
cd "${backup_dir}"
/snap/wekan/$version/bin/mongodump --quiet --port 27019
cd ..
tar -zcf "${now}.tar.gz" "${now}"
rm -rf "${now}"
}
printf "\n======================================================================="
printf "\nWekan Backup"
printf "\n======================================================================="
printf "\nBackup in progress..."
take_backup 2> "${log_file}"
if [[ -s "${log_file}" ]]
then
printf "\nBackup failure! Check ${log_file} for more information."
printf "\n=======================================================================\n\n"
else
rm "${log_file}"
printf "...SUCCESS!\n"
printf "Backup created at ${backup_dir}.tar.gz"
printf "\n=======================================================================\n\n"
fi
```
wekan-restore.sh
```bash
#!/bin/bash
export LC_ALL=C
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan/current/lib/x86_64-linux-gnu
makesRestore()
{
file=$1
ext=$"$(basename $file)"
parentDir=$"${file:0:${#file}-${#ext}}"
cd "${parentDir}"
printf "\nMakes the untar of the archive.\n"
tar -zxvf "${file}"
file="${file:0:${#file}-7}"
version=$(snap list | grep wekan | awk -F ' ' '{print $3}')
restore=$"/snap/wekan/${version}/bin/mongorestore"
printf "\nThe database restore is in progress.\n\n"
## Only if you get errors about existing indexes, use this below instead:
## $restore --quiet --drop --noIndexRestore -d wekan --port 27019 "${file}/dump/wekan"
$restore --quiet --drop -d wekan --port 27019 "${file}/dump/wekan"
rm -rf "${file}"
printf "\nRestore done.\n"
}
makesRestore $1
```
***
# Snap backup-restore v1
## Backup script for MongoDB Data, if running Snap MongoDB at port 27019
```bash
#!/bin/bash
makeDump()
{
# Gets the version of the snap.
version=$(snap list | grep wekan | awk -F ' ' '{print $3}')
# Prepares.
now=$(date +'%Y-%m-%d_%H.%M.%S')
mkdir -p /var/backups/wekan/$version-$now
# Targets the dump file.
dump=$"/snap/wekan/$version/bin/mongodump"
# Makes the backup.
cd /var/backups/wekan/$version-$now
printf "\nThe database backup is in progress.\n\n"
$dump --port 27019
# Makes the tar.gz file.
cd ..
printf "\nMakes the tar.gz file.\n"
tar -zcvf $version-$now.tar.gz $version-$now
# Cleanups
rm -rf $version-$now
# End.
printf "\nBackup done.\n"
echo "Backup is archived to .tar.gz file at /var/backups/wekan/${version}-${now}.tar.gz"
}
# Checks is the user is sudo/root
if [ "$UID" -ne "0" ]
then
echo "This program must be launched with sudo/root."
exit 1
fi
# Starts
makeDump
```
## Restore script for MongoDB Data, if running Snap MongoDB at port 27019 with a tar.gz archive.
```bash
#!/bin/bash
makesRestore()
{
# Prepares the folder used for the backup.
file=$1
if [[ "$file" != *tar.gz* ]]
then
echo "The backup archive must be a tar.gz."
exit -1
fi
# Goes into the parent directory.
ext=$"$(basename $file)"
parentDir=$"${file:0:${#file}-${#ext}}"
cd $parentDir
# Untar the archive.
printf "\nMakes the untar of the archive.\n"
tar -zxvf $file
file="${file:0:${#file}-7}"
# Gets the version of the snap.
version=$(snap list | grep wekan | awk -F ' ' '{print $3}')
# Targets the dump file.
restore=$"/snap/wekan/$version/bin/mongorestore"
# Restores.
printf "\nThe database restore is in progress.\n\n"
## Only if you get errors about existing indexes, use this below instead:
## $restore --drop --noIndexRestore wekan --port 27019 $file/dump/wekan
$restore --drop wekan --port 27019 $file/dump/wekan
printf "\nRestore done.\n"
# Cleanups
rm -rf $file
}
# Checks is the user is sudo/root.
if [ "$UID" -ne "0" ]
then
echo "This program must be launched with sudo/root."
exit 1
fi
# Start.
makesRestore $1
```
## Docker Backup and Restore
[Docker Backup and Restore](Export-Docker-Mongo-Data)
[Wekan Docker Upgrade](https://github.com/wekan/wekan-mongodb#backup-before-upgrading)
## Snap Backup
[Snap Backup and Restore](https://github.com/wekan/wekan-snap/wiki/Backup-and-restore)
[Wekan Snap upgrade](https://github.com/wekan/wekan-snap/wiki/Install#5-install-all-snap-updates-automatically-between-0200am-and-0400am)
## Sandstorm Backup
Download Wekan grain with arrow down download button to .zip file. You can restore it later.
[Export data from Wekan Sandstorm grain .zip file](Export-from-Wekan-Sandstorm-grain-.zip-file)
## <a name="cloudron">Cloudron
If those [Backup](Backup) ways are not easily found at [Cloudron](Cloudron), one way is to install [Redash](https://redash.io/) and then backup this way:
Redash works with this kind of queries:
```json
{
"collection": "accountSettings",
"query": {
"type": 1
},
"fields": {
"_id": 1,
"booleanValue": 1,
"createdAt": 1,
"modifiedAt": 1,
}
}
```
So:
1) Create this kind of query:
```json
{
"collection": "boards"
}
```
Later when you modify query, you can remove text like boards with double-click-with-mouse and delete-key-at-keyboard (or select characters with mouse and delete-key-at-keyboard), and then click collection/table >> button to insert name of next collection/table.
2) Click Save
3) Click Execute. This will cache query for use with REST API.
4) Click at right top `[...]` => `Show API key`
It looks like this:
https://redash.example.com/api/queries/1/results.json?api_key=...
5) Only when saving first collection/table, Save API key to text file script like this `dl.sh`
```bash
#!/bin/bash
# Example: ./dl.sh boards
export APIKEY=https://redash.example.com/api/queries/1/results.json?api_key=...
curl -o $1.json $APIKEY
```
6) Run save script like:
```bash
./dl.sh boards
```
Note: 1) Save 2) Execute => webbrowser can give this kind of timeout,
but downloading with API script still works:
> wekan
> Error running query: failed communicating with server. Please check your Internet connection and try again.
7) Repeat steps 1-4 and 6 for every collection/table like boards,cards, etc
8) Remove from downloaded .json files extra query related data, so that it is similar like [any other Wekan database backup JSON files](Export-from-Wekan-Sandstorm-grain-.zip-file)
9) Insert data to some other Wekan install with nosqlbooster like mentioned at page [Backup](Backup)

71
docs/wekan.wiki/Browser-compatibility-matrix.md Normal file
View file

@ -0,0 +1,71 @@
If you know updates to this, please add new issue about it. Make changes to this page by cloning wiki:
```
git clone https://github.com/wekan/wekan.wiki
```
There edit Browser-compatibility-matrix.md and attach it with .txt extension or in .zip file to https://github.com/wekan/wekan/wiki/issues
## Webkit based
Browser | [PWA](PWA) | Mobile | Desktop | OS
------- | ----| ------ | ------- | -------
Safari | iOS Yes | iOS Newest | Newest | iOS, macOS
## Firefox based
Any telemetry at any Firefox based browser can be additionally most locked down with arkenfox user JS.
Browser | [PWA](PWA) | Mobile | Desktop | OS
------- | ----| ------ | ------- | -------
[Mypal](https://releases.wekan.team/mypal/) | No | No | Newest | For 32bit ReactOS/WinXP/Win7/etc [issue](https://github.com/wekan/wekan/issues/3132), Other 32bit browsers probably not
Firefox | Android Yes | Android Newest | Newest | Win/Mac/Linux/RasPi
Morph Browser | No | Yes | Yes | [Ubuntu Touch](https://ubports.com) (based on Ubuntu 16.04) on PinePhone, OnePlus 3, [RasPi3](https://ci.ubports.com/job/rootfs/job/rootfs-rpi/) (not RasPi4 yet). Works best with bluetooth or USB mouse and keyboard.
[OpenStore App](https://open-store.io/app/wekan.wekanteam) | Yes | Yes | Yes | Based on [Wekan PWA](https://boards.wekan.team/b/D2SzJKZDS4Z48yeQH/wekan-open-source-kanban-board-with-mit-license/s7SkzYviC2e963FkT), [Ubuntu Touch](https://ubports.com) app at [OpenStore](https://open-store.io/app/wekan.wekanteam) using Morph browser with Wekan demo & development server https://boards.wekan.team . Tested on [RasPi3](https://ci.ubports.com/job/rootfs/job/rootfs-rpi/). PWA URL is configured here https://github.com/wekan/wekan-openstore/blob/master/wekan.desktop#L3
[Waterfox](https://www.waterfox.net) | No | No | Yes | Win/Mac/Linux, more private than Firefox, no tracking
[Floorp](https://floorp.app) | No | No | Yes | [Win/Mac/Linux](https://github.com/Floorp-Projects/Floorp/releases), more private than Firefox, [Repo](https://github.com/Floorp-Projects/Floorp)
[Mercury](https://thorium.rocks/mercury) | No | No | Yes | [Win/Linux](https://github.com/Alex313031/Mercury/releases), more private than Firefox, [Repo](https://github.com/Alex313031/Mercury)
[SeaLion](https://github.com/wicknix/SeaLion) | No | No | Yes | [MacOS 10.7-14.1 x32,x64,ppc,ppc64/Linux x64](https://github.com/wicknix/SeaLion/releases), [Repo](https://github.com/wicknix/SeaLion)
## Chromium based
Browser | [PWA](PWA) | Mobile | Desktop | OS
------- | ----| ------ | ------- | -------
Chrome | Android Yes | Android Newest | Newest | Win/Mac/Linux
Chromium | Android Yes | Android Newest | Newest | Win/Mac/Linux/RasPi
Vivaldi | Android Yes | Android Newest | Newest | Win/Mac/Linux
Opera | Android Yes | Android Newest | Newest | Win/Mac/Linux
Credge, Chromium Edge | Android Yes | Android | Newest | Win/Mac/Linux/Mobile
[Microsoft Store App](https://www.microsoft.com/fi-fi/p/wekan/9p2mrxvd087r#activetab=pivot:overviewtab) | Yes | Yes | Yes | At Microsoft Store of Windows 10/11 desktop, made with [PWABuilder](https://www.pwabuilder.com/). Based on [Wekan PWA](https://boards.wekan.team/b/D2SzJKZDS4Z48yeQH/wekan-open-source-kanban-board-with-mit-license/s7SkzYviC2e963FkT), changed app from EdgeHTML to Credge based with Wekan demo & development server https://boards.wekan.team
[Android Play Store App](https://play.google.com/store/apps/details?id=team.wekan.boards.twa) | Yes | Yes | Yes | Based on [Wekan PWA](https://boards.wekan.team/b/D2SzJKZDS4Z48yeQH/wekan-open-source-kanban-board-with-mit-license/s7SkzYviC2e963FkT), made with [PWABuilder](https://www.pwabuilder.com/), uses Android Chrome browser with Wekan demo & development server https://boards.wekan.team
[Thorium](https://thorium.rocks) | No | Yes | Yes | [Win/Win7/Mac/Linux/Android/RasPi](https://thorium.rocks), speed optimized
[Supermium](https://github.com/win32ss/supermium) | No | No | Yes | 32bit: Windows XP, Windows 2003
## EdgeHTML based
Browser | [PWA](PWA) | Mobile | Desktop | OS
------- | ----| ------ | ------- | -------
Legacy Edge | No | No | Not | Not compatible with newest WeKan. Worked with Wekan v4.19 and before.
## MSHTML based
Browser | [PWA](PWA) | Mobile | Desktop | OS
------- | ----| ------ | ------- | -------
Internet Explorer | No | No | No | No | No
## Other ways to create Mobile App with Meteor
https://guide.meteor.com/cordova
Benefits:
- Can be faster, more stored at mobile
- Native features integration possibilities
## Desktop app with Meteor
https://forums.meteor.com/t/desktop-electron-meteor-app-with-todesktop/60904
## Optional Payments
- If there is sometime a need to develop payment feature, that does not exist yet
- https://forums.meteor.com/t/need-help-adding-in-app-purchases-to-a-meteor-app-specifically-adding-subscription-support-for-android-play-store/40510
- https://www.npmjs.com/package/cordova-plugin-purchase

7
docs/wekan.wiki/Burndown-and-Velocity-Chart.md Normal file
View file

@ -0,0 +1,7 @@
[Discussion](https://github.com/wekan/wekan/discussions/4282)
WeKan Python Burndown Chart:
- [Original](https://github.com/Gelmes/Wekan-Python-Burndown)
- [WeKan fork](https://github.com/wekan/Wekan-Python-Burndown)
[WeKan Burndown Chart Chrome extension](https://chrome.google.com/webstore/detail/burndown-for-wekan/agdbocbobcbelnekjibocbilodjgopgh?)

13
docs/wekan.wiki/CAS.md Normal file
View file

@ -0,0 +1,13 @@
[CAS Issue](https://github.com/wekan/wekan/issues/3204)
[CAS settings commit](https://github.com/wekan/wekan/commit/214c86cc22f4c721a79ec0a4a4f3bbd90d673f93)
Please send pull requests if CAS login does not work.
Wekan clientside code is at `wekan/client/components/main/layouts.*`
Wekan serverside code is at:
- `wekan/server/authentication.js` at bottom
- `wekan/packages/*cas*/*`
Originally before moving to `wekan/packages/*cas*/*` CAS code was at https://github.com/wekan/meteor-accounts-cas

18
docs/wekan.wiki/CSV.md Normal file
View file

@ -0,0 +1,18 @@
Right to click your username / All Boards / Add Board / Import / From CSV/TSV
[Original Import CSV issue](https://github.com/wekan/wekan/issues/395)
[CSV import was added at PR 3081](https://github.com/wekan/wekan/pull/3081)
Here's a copy of the CSV and TSV to test out the functionality:
- [board-import.csv](https://wekan.github.io/csv/board-import.csv)
- [board-import.tsv](https://wekan.github.io/csv/board-import.tsv)
Frontend:
- [Import CSV code](https://github.com/wekan/wekan/tree/main/client/components/import)
Backend:
- [Import CSV code](https://github.com/wekan/wekan/blob/main/models/csvCreator.js) and [General Import code](https://github.com/wekan/wekan/blob/main/models/import.js)
Related:
- [Related PRs](https://github.com/wekan/wekan/pulls?q=is%3Apr+is%3Aclosed+csv)

281
docs/wekan.wiki/Caddy-Webserver-Config.md Normal file
View file

@ -0,0 +1,281 @@
[Caddy 2 .well-known/assetlinks.json config for WeKan Android Play Store app](../PWA#fullscreen-android-app-with-caddy-and-wekan-server)
## Caddy 2
WeKan Snap Candidate for any Snap distros: https://github.com/wekan/wekan/wiki/OpenSuse , disable internal old Caddy 1, when using Caddy 2:
```
sudo snap set wekan caddy-enabled='false'
sudo snap set wekan port='3001'
sudo snap set wekan root-url='https://boards.example.com'
```
More info about root-url at https://github.com/wekan/wekan/wiki/Settings
Browser needs to have only one language https://github.com/wekan/wekan/issues/4803#issuecomment-1374354425
Install Caddy 2 stable release: https://caddyserver.com/docs/install#debian-ubuntu-raspbian
Like this:
```
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt -y install caddy
```
Edit Caddyfile:
```
sudo nano /etc/caddy/Caddyfile
```
Example:
```
# Redirecting http to https
(redirect) {
@http {
protocol http
}
redir @http https://{host}{uri}
}
# WeKan board, proxy to localhost port, or IP-ADDRESS:PORT
boards.example.com {
tls {
load /var/snap/wekan/common/certs
alpn http/1.1
}
reverse_proxy 127.0.0.1:3025
}
# Static website
example.com {
tls {
load /var/snap/wekan/common/certs
alpn http/1.1
}
root * /var/websites/wekan.team
file_server
}
# Files download directory browse website
files.example.com {
root * /var/websites/ftp.secretchronicles.org/public
file_server browse
}
```
Caddy commands list:
```
caddy help
```
***
[Caddy OAuth2 with Let's Encrypt SSL example](OAuth2)
***
## CloudFlare free wildcard SSL *start*
Also works with other SSL certs.
### 1) Requirements: You have changed nameservers to CloudFlare.
### 2) Get CloudFlare SSL wildcard Origin Certificate
Go to CloudFlare login/example.com/Crypto/Origin Certificates.
Create and download certs for `*.example.com, example.com`
### 3) Create directory /var/snap/wekan/common/certs
```
sudo su
cd /var/snap/wekan/common
mkdir certs
cd certs
```
### 4) Create cert file
Create file: `example.com.pem` with content of CloudFlare Origin Certificates.
```
nano example.com.pem
```
There add certs:
```
-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----
-----BEGIN CERTIFICATE-----
-----END CERTIFICATE-----
```
Then Save: Ctrl-o Enter
Then Exit: Ctrl-x.
### 5) Set permissions rw-r--r-- to example.com.pem:
```
chmod 644 example.com.pem
```
### 6) Edit Caddy webserver config
```
sudo nano /var/snap/wekan/common/Caddyfile
```
There change config:
```
http://example.com https://example.com {
tls {
load /var/snap/wekan/common/certs
alpn http/1.1
}
proxy / localhost:3001 {
websocket
transparent
}
}
```
Save: Ctrl-o Enter
Exit: Ctrl-x
Enable Caddy:
```
sudo snap set wekan caddy-enabled='true'
sudo snap set wekan port='3001'
sudo snap set wekan root-url='https://example.com'
```
### 7) Enable CloudFlare SSL
Click CloudFlare login/example.com/DNS.
Check that status of your domains have orange cloud color, so traffic goes through CloudFlare SSL.
Click CloudFlare login/example.com/Page Rules.
Set for example:
```
1) http://example.com/*
Always Use HTTPS
2) http://*.example.com/*
Always use HTTPS
```
Optionally, if you want caching:
```
3) *example.com/*
Cache Level: Cache Everything
```
## CloudFlare free wildcard SSL *end*
***
## Other config stuff
[List of Let's Encrypt implementations](https://community.letsencrypt.org/t/list-of-client-implementations/2103)
## Caddy webserver config with logs
Create directory for caddy, website and logs:
```bash
mkdir -p ~/caddy/example.com ~/caddy/logs
```
Add this config to ~/caddy/Caddyfile
There's also some extra examples.
```bash
example.com {
root /home/username/caddy/example.com
# Static website, markdown or html
ext .md .html
proxy /wekan 127.0.0.1:3000 {
websocket
}
log /home/username/caddy/logs/wekan-access.log {
rotate {
size 100 # Rotate after 100 MB
age 7 # Keep log files for 7 days
keep 52 # Keep at most 52 log files
}
}
errors {
log /home/username/caddy/logs/wekan-error.log {
size 100 # Rotate after 100 MB
age 7 # Keep log files for 7 days
keep 52 # Keep at most 52 log files
}
}
}
example.com/files {
root /home/username/files
# View files in directory, has sorting in browser
browse
}
```
Install Caddy. Change username to what user you run caddy, like in /home/username , and Let's Encrypt email to your email adderess:
```bash
# Install caddy with some plugins
curl https://getcaddy.com | bash -s personal http.ipfilter,http.mailout,http.ratelimit,http.realip
```
# Give permissions to caddy to bind 80 and 443
```
sudo setcap cap_net_bind_service=+ep /usr/local/bin/caddy
```
And this service file for Caddy to /etc/systemd/system/caddy@.service
```bash
; see `man systemd.unit` for configuration details
; the man section also explains *specifiers* `%x`
[Unit]
Description=Caddy HTTP/2 web server %I
Documentation=https://caddyserver.com/docs
After=network-online.target
Wants=network-online.target
Wants=systemd-networkd-wait-online.service
[Service]
; run user and group for caddy
User=username
Group=username
ExecStart=/home/username/caddy/caddy -conf=/home/username/caddy/Caddyfile -agree -email="admin@example.com"
Restart=on-failure
StartLimitInterval=86400
StartLimitBurst=5
RestartSec=10
ExecReload=/bin/kill -USR1 $MAINPID
; limit the number of file descriptors, see `man systemd.exec` for more limit settings
LimitNOFILE=1048576
LimitNPROC=64
; create a private temp folder that is not shared with other processes
PrivateTmp=true
PrivateDevices=true
ProtectSystem=full
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
AmbientCapabilities=CAP_NET_BIND_SERVICE
NoNewPrivileges=true
[Install]
WantedBy=multi-user.target
```
Start caddy and enable service:
```
sudo systemctl daemon-reload
sudo systemctl start caddy@username
sudo systemctl enable caddy@username
```

23
docs/wekan.wiki/Calendar.md Normal file
View file

@ -0,0 +1,23 @@
### Create card
At Calendar View, on Month when you click a date it will ask you if you want to create a new card and give its name. It then creates at first swimlane and at first list the card with the due date that it got from the date you clicked.
Video demonstration:
https://user-images.githubusercontent.com/70445835/184324324-b4bd466e-6873-4eef-8ca5-b6e4d9f95ac5.mp4
- How it works https://github.com/wekan/wekan/issues/2687#issuecomment-1545235649
- Fix for Calendar View Create Card https://github.com/wekan/wekan/pull/5019
- Calendar view logic https://github.com/wekan/wekan/issues/4511
## <a name="Time"></a>Time
* [Due Date](Due-Date)
* [Day of week start](Day-of-week-start)
## What features are missing
* [Calendar issues](https://github.com/wekan/wekan/issues?q=is%3Aissue+is%3Aopen+calendar+label%3AFeature%3ACalendar-view)
* [Time Tracking](Time-Tracking)
* [Gantt Chart](Gantt)

285
docs/wekan.wiki/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.

3
docs/wekan.wiki/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/wekan.wiki/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)

50
docs/wekan.wiki/Converting-Meteor-Stylus-to-CSS.md Normal file
View file

@ -0,0 +1,50 @@
[Original issue](https://github.com/wekan/wekan/issues/4512)
## Introduction
Previously WeKan used Stylus, that is similar to CSS. Stylus has some additional features.
Stylus code was located at `wekan/client/components/*/*.styl`, for example `wekan/client/components/boards/boardsList.styl`.
## Why
- `coagmano:stylus` is not maintained anymore
- When building meteor bundle, `coagmano:stylus` causes [errors like Warning: Accessing non-existent property 'lineno' of module exports inside circular dependency](https://github.com/Meteor-Community-Packages/meteor-stylus/issues/9) with newest Meteor 2.7.2
- Removing `coagmano:stylus` fixed [Mermaid Diagram error: Maximum call stack size exceeded](https://github.com/wekan/wekan/issues/4251) from browserside right click / Inspect / Console. After removing `coagmano:stylus`, that error was not there anymore.
## Converting Stylus to CSS
[Source](https://github.com/wekan/wekan/blob/main/releases/stylus-to-css.sh)
#### 1) Install Stylus
```
sudo npm -g install stylus
```
#### 2) Comment out `@import 'nib'` that is not supported syntax in newest plain Stylus, for all .styl files in directory
```
sed -i "s|@import 'nib'|//@import 'nib'|g" *.styl
```
That code `@import 'nib'` is using [CSS imports](https://developer.mozilla.org/en-US/docs/Web/CSS/@import) that does [Eric Meyer's CSS reset of styles](https://github.com/stylus/nib/blob/master/lib/nib/reset.styl). xet7 [added that reset to separate CSS file](https://github.com/wekan/wekan/commit/985c2cdbfdb38eb43852f3aa257859bbd3f817b9). While in [original converting Stylus to CSS](https://github.com/wekan/wekan/commit/072778b9aaefd7fcaa7519b1ce1cafc1704d646d) that `@import 'nib'` was in many files, it seems it's enough to have it at [client/components/boards/boardsList.css](https://github.com/wekan/wekan/commit/985c2cdbfdb38eb43852f3aa257859bbd3f817b9#diff-c227ea7dd2df8f46604db81ce7c49902b7e8829266ab79bb1c80077b5ba2b5b0) that is used at all pages of WeKan.
Alternative to CSS imports would be to add that CSS code to beginning of that CSS file where it is needed.
Other CSS transpilers may use similar imports.
Not having all requires CSS can be seen like:
- [Some extra bullets](https://github.com/wekan/wekan/issues/4516)
- [Some wrong colors](https://github.com/wekan/wekan/issues/4519)
#### 3) For all files in directory, run command `stylus filename.styl`
```
ls *.styl | xargs stylus
```
#### 4) Remove `coagmano:stylus`
```
meteor remove coagmano:stylus
```
#### 5) Delete .styl files
```
cd wekan
rm client/components/*/*.styl
```

11
docs/wekan.wiki/Cover.md Normal file
View file

@ -0,0 +1,11 @@
## Description
- Cover image = Image that you see first at not yet opened minicard, book, or magazine.
- Minicard = At board, small card, that you have not yet clicked to open card.
- Thumbnail Image = Small Picture of Attachment Image, like at Minicard and Card.
- At opened card, when you click thumbnail, it opens big picture slideshow.
## Minicard Cover Image and Count of attachments
<img src="https://wekan.github.io/cover/cover-and-attachment.png" width="100%" alt="Minicard Cover Image and Count of attachments" />

217
docs/wekan.wiki/Custom-CSS-themes.md Normal file
View file

@ -0,0 +1,217 @@
Here is how to build wekan code and add your new theme with code changes and send as pull request:
https://github.com/wekan/wekan/wiki/Emoji#how-you-could-add-another-plugin
Here is how some have sent previous themes to Wekan, what code changes they made:
https://github.com/wekan/wekan/pulls?q=is%3Apr+is%3Aclosed+theme
After you have sent new theme as pull request, you see it as open pull request:
https://github.com/wekan/wekan/pulls?q=is%3Apr+theme+is%3Aopen
And when I have merged it to Wekan, that theme will be in next Wekan release, listed at ChangeLog:
https://github.com/wekan/wekan/blob/main/CHANGELOG.md
At Wekan Snap page you see with webpage reload, when new version has been released:
https://snapcraft.io/wekan
Wekan Snap version gets updates automatically soon after new Wekan version has been released, or you can update manually immediately:
https://github.com/wekan/wekan-snap/wiki/Automatic-update-schedule
***
Also see: [Dark Mode](Dark-Mode)
All Wekan themes are directly integrated to Wekan. You can add pull request to master branch to add custom theme, you can see from [from this commit](https://github.com/wekan/wekan/commit/34b2168d0dda253dedabbee47031873efa4ae446) required new color/theme name and changes to these files 3 files listed below. In that commit is also changes to other files, you don't need to change those files.
- `wekan/client/components/boards/boardColors.styl`
- `wekan/models/boards.js`
- `wekan/server/migrations.js`
Alternatives for sending new theme as pull request:
- If you would like to have some new theme, please add screenshot mockup to [new Wekan issue](https://github.com/wekan/wekan/issues).
- If possible, you can also try to create those CSS changes with [Stylish browser extension](https://userstyles.org/) and add those to new issue too.
There are currently board color modes/themes, and these full themes:
- Dark: modified from below by @lonix1 and more changes by xet7
- Relax: Light green background that helps Wekan users to relax in company of Wekan contributor that sent theme CSS.
Upcoming full themes that will be added by xet7:
- Corteza, that will be mostly-white theme, although different than example of white theme below
- Octopus, that will have different colors and some Wekan features hidden
![dark wekan](https://wekan.github.io/wekan-dark-mode.png)
## Dark theme
[by @lonix1](https://github.com/wekan/wekan/issues/1149), could look a little like this screenshot mockup:
<!--
![dark wekan](https://user-images.githubusercontent.com/11541071/28684178-574c0852-72fb-11e7-9c39-d11281863c3a.png)
-->
lonix1 created some css overrides with Stylish. It's not complete but I'm happy with it. I work in swimlanes mode, so that is what I changed (not list mode or calendar mode).
Colors:
- adds dark mode, I used vscode as a reference
Other:
- hides various useless icons and things
- hides "add card", "add swimlane", "add list" links, until hovered (I find these very "noisy")
```css
/* HIDE PERMANENTLY -------------------------------------------------- */
/* various */
.wekan-logo,
.close-card-details { display:none; }
/* header text */
#header-quick-access >ul >li:nth-child(1) >a { font-size:0; }
#header-quick-access >ul >li:nth-child(1) >a >.fa-home{ font-size:12px; margin:0; }
/* popup menu titles (boards, swimlanes, lists, cards, labels) */
.pop-over >.header { display:none; }
/* OPTIONAL
card fields: received, start, due, end, members, requested, assigned
I rarely use these... uncomment if you want to hide them */
/*
.card-details-item.card-details-item-received,
.card-details-item.card-details-item-start,
.card-details-item.card-details-item-due,
.card-details-item.card-details-item-end,
.card-details-item.card-details-item-members,
.card-details-item.card-details-item-name { display:none; }
.card-details-items:empty { display:none; }
*/
/* HIDE UNTIL HOVER -------------------------------------------------- */
/* header "+" button */
#header-quick-access .fa-plus { display:none; }
#header-quick-access:hover .fa-plus { display:inherit; }
/* "add card" links (use visibility rather than display so items don't jump) */
.open-minicard-composer { visibility:hidden; }
.list.js-list:hover .open-minicard-composer { visibility:visible; }
.list-header-menu { visibility:hidden; }
.list.js-list:hover .list-header-menu { visibility:visible; }
/* "add list/swimlane" links (use visibility rather than display so items don't jump) */
.list.js-list-composer >.list-header { visibility:hidden; }
.list.js-list-composer:hover >.list-header { visibility:visible; }
/* DARK MODE -------------------------------------------------- */
/* headers */
#header-quick-access, #header { background-color:rgba(0,0,0,.75) !important; }
#header .board-header-btn:hover { background-color:rgba(255,255,255,0.3) !important; }
/* backgrounds: swimlanes, lists */
.swimlane { background-color:rgba(0,0,0,1); }
.swimlane >.swimlane-header-wrap,
.swimlane >.list.js-list,
.swimlane >.list-composer.js-list-composer { background-color:rgba(0,0,0,.9); }
/* foregrounds: swimlanes, lists */
.list >.list-header, .swimlane-header { color:rgba(255,255,255,.7); }
/* minicards */
.minicard { background-color:rgba(255,255,255,.4); }
.minicard-wrapper.is-selected .minicard,
.minicard:hover,
.minicard-composer.js-composer,
.open-minicard-composer:hover { background-color:rgba(255,255,255,.8) !important; color:#000; }
.minicard, .minicard .badge { color:#fff; }
.minicard:hover .badge, .minicard-wrapper.is-selected .badge { color:#000; }
/* cards */
.card-details,
.card-details .card-details-header { background-color:#ccc; }
/* sidebar */
.sidebar-tongue, .sidebar-shadow { background-color:#666 !important; }
.sidebar-content h3, .sidebar-content .activity-desc { color:rgba(255,255,255,.7) !important; }
```
If anyone improves on this, please share here.
## White theme
[pravdomil](https://github.com/wekan/wekan/issues/1690) has created small script for tampermonkey to redesign wekan board.
![image](https://user-images.githubusercontent.com/2387356/41285077-7c5b1c64-6e3b-11e8-91b9-503ffb39eb4a.png)
script for tampermonkey
```js
// ==UserScript==
// @name Kanban
// @namespace https://pravdomil.com/
// @version 0.1
// @match https://wekan.indie.host/*
// @grant none
// ==/UserScript==
;(function() {
const el = document.createElement("style")
// language=CSS
el.textContent = `
/* white background */
body { background-color: white; }
/* header bar next to top bar */
#header #header-main-bar {
position: absolute;
right: 70px;
left: 300px;
top: -3px;
padding: 0;
height: calc(28px + 3px);
}
/* swimlane white background, no borders, fix ellipsis */
.swimlane { background-color: white; }
.swimlane-header-wrap { border: 0 !important; }
.swimlane-header { text-overflow: initial !important; }
/* column header only for first row */
.swimlane .list-header { margin: 4px 12px 4px; }
.swimlane .list-header-name { display: none; }
div:nth-child(1 of .swimlane) .list-header { margin: 20px 12px 4px; }
div:nth-child(1 of .swimlane) .list-header-name { display: inline; }
/* cells no borders, fix height, less padding, no add new card */
.list { border: 0; background-color: white; flex: 300px 0 0; }
.list .list-body { height: 160px; padding: 0 2px; }
.list .open-minicard-composer { display: none; }
.list .open-list-composer { opacity: 0; transition: opacity .2s; }
.list .open-list-composer:hover { opacity: 1; }
/* card style */
.minicard-wrapper { margin-bottom: 2px !important; }
.minicard { box-shadow: 0 0 16px rgba(0,0,0,0.15) inset; }
/* card style for first and last column */
.swimlane .list:nth-child(2) .minicard { opacity: .5 !important; }
.swimlane .list:nth-last-child(2) .minicard { opacity: .1 !important; }
/* card details always center, menu items tweaks */
.card-details {
position: absolute;
z-index: 10000 !important;
top: 0;
bottom: 0;
left: calc(50% - 510px / 2);
}
.pop-over-list .js-labels { display: none }
.pop-over-list .js-move-card-to-top { display: none }
.pop-over-list .js-move-card-to-bottom { display: none }
.pop-over-list .js-archive { color: darkred }
/* not needed */
.wekan-logo, .js-member, .attachments-galery { display: none; }
`
document.body.appendChild(el)
})()
```

29
docs/wekan.wiki/Custom-Fields.md Normal file
View file

@ -0,0 +1,29 @@
[Custom Fields issue](https://github.com/wekan/wekan/issues/807)
## To translators, about the word Custom
See other feature for description of Custom https://github.com/wekan/wekan/wiki/Customize-Translations
## 1) Click: Board hamburger menu / Custom Fields
<img src="https://wekan.github.io/custom-field-1.png" width="50%" alt="Custom Field Step 1" />
## 2) Click: Create Field, add details and Save
<img src="https://wekan.github.io/custom-field-2.png" width="50%" alt="Custom Field Step 1" />
## 3) Click: Card Details hamburger menu / Edit custom fields
<img src="https://wekan.github.io/custom-field-3.png" width="100%" alt="Custom Field Step 1" />
## 4) Click: Your Custom Field name to insert it to Card
<img src="https://wekan.github.io/custom-field-4.png" width="100%" alt="Custom Field Step 1" />
## 5) Click: Your selection from your Custom Field
<img src="https://wekan.github.io/custom-field-5.png" width="100%" alt="Custom Field Step 1" />
## 6) Custom Field is shown at Minicard and Card Details
<img src="https://wekan.github.io/custom-field-6.png" width="100%" alt="Custom Field Step 1" />

24
docs/wekan.wiki/Custom-Logo.md Normal file
View file

@ -0,0 +1,24 @@
In Wekan v4.40 and newer:
- Custom Logo for Login and Top Left Corner.
- Optional link when clicking logo.
- Settings at Admin Panel / Settings / Layout.
Added [with this commit](https://github.com/wekan/wekan/commit/a7c3317ed696fad8e211b22afbb3012f3a4f2ddb). As you can see from that commit:
- Height 27 px in Top Left Corner Logo. Width auto = automatic.
- Width 300 px in Login Logo. Height auto = automatic.
Image can be for example jpg/png/gif/svg.
For those sizes, if logo is a little bigger or smaller, it will be zoomed.
## Storing logo images elsewhere
Add image like `https://example.com/logo.png`
## Storing logos in Wekan
1. Create board and change it from private to public (visible to everyone at Internet)
2. Add card
3. Add logo images to card as attachment
4. Right click on top image and copy image link to Admin Panel/Settings/Layout/Logo image URL

26
docs/wekan.wiki/Customize-Translations.md Normal file
View file

@ -0,0 +1,26 @@
In WeKan v7.08 and newer.
## Description
WeKan has default translations from English to other languages at https://explore.transifex.com/wekan/wekan/
With this feature, you can override some default translation string with custom string, your modified new version of translation text, with GUI at Admin Panel, and changes are immediately in use in WeKan.
## To translators, about the word Custom
Custom means something modified, that is not the default.
For example, WeKan has other feature https://github.com/wekan/wekan/wiki/Custom-Fields ,
where is added new custom fields, that are not default.
## Admin Panel / Translation
- Language: https://github.com/wekan/wekan/blob/main/imports/i18n/languages.js
- Text, source string In English: https://github.com/wekan/wekan/blob/main/imports/i18n/data/en.i18n.json
- Translation text: Your new translation custom string
## Source
- https://github.com/wekan/wekan/pull/5085
- https://github.com/wekan/wekan/issues/5065#issuecomment-1668259510
<img src="https://wekan.github.io/custom-translation-string.png" width="100%" alt="Translation Custom String" />

22
docs/wekan.wiki/Dark-Mode.md Normal file
View file

@ -0,0 +1,22 @@
## Wekan Dark Mode
![dark wekan](https://wekan.github.io/wekan-dark-mode.png)
## Other Dark Modes
### Chrome Desktop Browser
- [Dark Mode Extension](https://chrome.google.com/webstore/detail/dark-mode-for-chrome/geooakdjiamlhpechokegobmhdmlgidk) - changes all webpages to dark, including Wekan.
- [Decent - Dark Theme](https://chrome.google.com/webstore/detail/decent/bnnjhehfmlfkbdocbphdoagolcknbohp)
### Firefox Desktop and Mobile Browser
- [Dark Mode Webextension](https://addons.mozilla.org/en-US/android/addon/dark-mode-webextension/) - changes all webpages to dark, including Wekan.
- There is dark themes, depends what someone likes
### Thunderbird Email
- [TT DeepDark - Dark Theme](https://addons.thunderbird.net/en-US/thunderbird/addon/tt-deepdark/) - after installing click Edit/Preferences/Display/Colors/Font&Colors-Colors Text: Grey Background: Black and also Plain Text Messages Color: Black.
### Qubes OS Desktop
- Start / System Tools / Appearance / Styles: Adwaita-dark
### Android M
- [Dark Phone Theme](https://www.phonearena.com/news/Finally-Android-M-scores-a-new-system-wide-dark-UI-theme_id69814)

7
docs/wekan.wiki/Day-of-week-start.md Normal file
View file

@ -0,0 +1,7 @@
## 1) Click right top your username
<img src="https://wekan.github.io/day/day_of_week_start_1.png" width="40%" alt="Day of Week Start 1" />
## 2) Click Change Settings => Set day of the week start => Select first day of the week from dropdown menu
<img src="https://wekan.github.io/day/day_of_week_start_2.png" width="40%" alt="Day of Week Start 1" />

10
docs/wekan.wiki/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)

115
docs/wekan.wiki/Debugging.md Normal file
View file

@ -0,0 +1,115 @@
## Maximum Call Stack Size Exceeded
https://github.com/wekan/wekan/issues?q=is%3Aissue+maximum+call+stack+is%3Aclosed
https://stackoverflow.com/questions/75869629/ios-websocket-close-and-error-events-not-firing
This can happen, when there is too much or incompatible code at browserside, for example at iOS Safari.
To fix it:
1. Move ExcelJS from browserside to run at serverside https://github.com/wekan/wekan/pull/3871
2. Use Bundle Visualizer to see what is the size of dependencies, and try what can be moved to serverside like at step 1, that bundle visualizer is used in this script https://github.com/wekan/wekan/blob/main/rebuild-wekan.sh
```
meteor run --exclude-archs web.browser.legacy,web.cordova --port 4000 --extra-packages bundle-visualizer --production 2>&1 | tee ../log.txt
```
3. Make dependencies smaller. For example, use only required files, and do not include all dependencies: https://github.com/wekan/wekan/commit/23e5e1e3bd081699ce39ce5887db7e612616014d . In that commit, package was forked to packages directory, then renamed, and added with `meteor add packagename`, where package name does not have character `:`
4. Use Browserstack.com to see errors at browser / inspect / console, or use iOS or other device emulators, to see error messages. Testing at real device is more important, because they could work differently than emulators, emulators sometimes do not emulate all same features. Those error messages have file where error happened, and line number, like `something.js:301` . From there, scroll up a little, look at what function or what package dependency it is where it happened. If possible, try to move that package serverside, like at step 1. Or alternatively, look is it possible to remove or change to some other compatible dependency.
5. See what are the dependencies at your Meteor based software, compared to WeKan dependencies that are usually already upgraded to newest Meteor, is there any differences where changing to correct dependencies could help you to upgrade to newest Meteor:
- https://github.com/wekan/wekan/blob/main/package.json
- https://github.com/wekan/wekan/blob/main/.meteor/packages
- https://github.com/wekan/wekan/blob/main/.meteor/versions
- https://github.com/wekan/wekan/blob/main/.meteor/release
5. If you get some errors, search are those same already fixed in WeKan/Meteor/RocketChat, could you fix them same way:
- https://github.com/wekan/wekan/blob/main/CHANGELOG.md
- https://github.com/wekan/wekan/issues
- https://github.com/wekan/wekan/issues?q=is%3Aissue+is%3Aclosed
- https://github.com/meteor/meteor/issues
- https://github.com/meteor/meteor/issues?q=is%3Aissue+is%3Aclosed
- https://github.com/RocketChat/Rocket.Chat/issues
- https://github.com/RocketChat/Rocket.Chat/issues?q=is%3Aissue+is%3Aclosed
6. If you have some webserver providing SSL/TLS, check that you have websockets enabled:
- https://github.com/wekan/wekan/wiki/Caddy-Webserver-Config
- https://github.com/wekan/wekan/wiki/Nginx-Webserver-Config
- https://github.com/wekan/wekan/wiki/Apache
- OpenLiteSpeed https://github.com/wekan/wekan/issues/3334#issuecomment-723651328
- https://github.com/wekan/wekan/wiki/Local-self-signed-TLS
- https://github.com/wekan/wekan/wiki/Traefik-and-self-signed-SSL-certs
## OLD: TODO
[Quote from advise](https://github.com/meteor/meteor/issues/9796#issuecomment-443520767):
> Identify the core service your app is providing and make sure it is running independently. Put everything non-critical, including reporting, on some other system.
[Look at scaling tips here](https://github.com/meteor/meteor/issues/9796#issuecomment-411373831), quote:
> smeijer commented 25 days ago
> Just wanted to let know that I haven't experienced this issue anymore since I've replaced a lot of `meteor publications` with `apollo/graphql requests`.
>
> The reactivity is thereby lost, but in my case a 30sec poll is also fine. On the places that I do require reactivity, I only `publish` a single `timestamp`. This timestamp is passed through to `apollo`, which triggers a `refetch` when the timestamp is changed.
>
> The [discussion here](https://forums.meteor.com/t/implementing-livedocument-as-an-alternative-to-livequery-discussion/40152) has also been helpfull to improve performance here and there.
[Rocket.Chat scaling tips](https://rocket.chat/docs/installation/manual-installation/multiple-instances-to-improve-performance/)
## Kadira
- https://github.com/edemaine/kadira-compose
- https://github.com/meteor/meteor-apm-agent
- https://github.com/kadira-open/kadira-server
- https://www.gethappyboards.com/2017/07/rolling-out-your-own-instance-of-kadira/
## Finding memory leaks
**[Collect a heap profile and then analyze it](https://github.com/v8/sampling-heap-profiler)**
[Older article: How to Self Detect a Memory Leak in Node](https://www.nearform.com/blog/self-detect-memory-leak-node/)
## 100% CPU usage
1) Increase ulimit system wide to 100 000 in systemd config.
2) Wekan Javascript code has [increaded fiber poolsize](https://github.com/wekan/wekan/blob/main/server/authentication.js#L5-L9).
3) There is [on-going 100% CPU usage Meteor issue](https://github.com/meteor/meteor/issues/9796#issuecomment-400079380) and hopefully [fixes to Node.js will land in Node v8.12](https://github.com/nodejs/node/pull/21593#issuecomment-403636667) sometime. Node 8.12 is now released and official version included at Wekan.
## Scaling to thousands of users
[Production setup at AWS](AWS)
## Current versions of dependencies
[Dockerfile](https://github.com/wekan/wekan/blob/main/Dockerfile), versions of Meteor.js, Node etc listed at beginning.
[Included Meteor packages](https://github.com/wekan/wekan/blob/main/.meteor/packages)
[Included Meteor package versions](https://github.com/wekan/wekan/blob/main/.meteor/versions)
[Added packages at package.json](https://github.com/wekan/wekan/blob/main/package.json)
## Build from source
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-maintainer/tree/master/virtualbox)
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`

136
docs/wekan.wiki/Deep-Dive-Into-WeKan.md Normal file
View file

@ -0,0 +1,136 @@
## WeKan Interview 2023-12-08 starts at 22min 22sec
https://www.youtube.com/watch?v=ke-mbnZM3zE
## Screenshot of Meteor WeKan
<img src="https://wekan.github.io/wekan-dark-mode.png" width="100%" alt="Meteor WeKan screenshot" />
## Description of Meteor WeKan
- WeKan Open Source kanban with MIT license.
- Translated to 70+ languages https://explore.transifex.com/wekan/wekan/
- Used in most countries of the world https://snapcraft.io/wekan
- Biggest user have about 30k users, using many pods at Kubernetes
- Changelog https://github.com/wekan/wekan/blob/main/CHANGELOG.md
- Commercial Support at https://wekan.team/commercial-support/ . Currently looking who could sponsor more of maintenance and development.
## How much effort to create Meteor WeKan, in COCOMO model
- WeKan 134k lines of code: 34 years of effort, 316 contributors https://openhub.net/p/wekan
- Meteor.js, 224k lines of code: 59 years of effort, 819 contributors https://openhub.net/p/meteor-js
- Since December 2016, WeKan maintainer https://github.com/xet7 :
- has added and removed about 4M lines of code https://github.com/wekan/wekan/graphs/contributors
- https://openhub.net/accounts/xet7
## Meteor WeKan Browser support
- Javascript enabled Desktop and Mobile Safari/Chromium/Firefox based browsers
- Apps at Play Store, Windows Microsoft Store, Ubuntu Touch OpenStore https://github.com/wekan/wekan/wiki/Browser-compatibility-matrix
- Alternatively, for self-hosted WeKan, create PWA icon https://github.com/wekan/wekan/wiki/PWA
- Using WeKan with big touchscreen https://github.com/wekan/wekan/wiki/Touch-Screen-support
## Meteor WeKan Server
- Meteor.js 2.x, Node.js 14.x https://github.com/wekan/node-v14-esm/releases/tag/v14.21.4 , MongoDB 6.x
- CPU: amd64, arm64, s390x, Source Bundle at https://github.com/wekan/wekan/wiki/Raspberry-Pi
- Windows On-Premise: https://github.com/wekan/wekan/wiki/Offline
- Mac: Docker, or at https://github.com/wekan/wekan/wiki/Mac
- Newest at platforms: Source Bundle, Snap Candidate, Docker, Kubernetes https://wekan.github.io
- Platforms that will be updated to be up-to-date: Snap Stable, Sandstorm, UCS https://wekan.github.io
## Meteor WeKan Features
- [WeKan Design Principles](https://github.com/wekan/wekan/wiki/Design-Principles)
- Realtime UI. When someone makes change, like drag card or add text, everyone will see changes immediately. This is because Meteor listens to MongoDB change stream, and updates UI. For some rare cases, there needs to be reload of page, those need to be fixed.
- Whitelabel: Change product name and product image at login screen and board left top corner. Not changing favicon, because there are 100+ favicons for different devices.
- Drag Drop at Desktop and Mobile:
- Board Icons, Swimlanes, Lists, Cards, Checklists, Checklist Items
- Drag handles, per screen https://github.com/wekan/wekan/wiki/Drag-Drop
- Some features similar to Trello and Jira. Some features not in Trello and Jira.
- IFTTT Rules like Trello Butler https://github.com/wekan/wekan/wiki/IFTTT , translated to all supported languages. Trello Butler is only In English.
- Many Assignees like in Jira.
- Change background image and Card Cover. Change Theme. Change color of Boards, Swimlane, List, Card, Label.
- Markdown at: Board name and description, Swimlane, List, Card title and description, Checklist and Checklist Item, Subtask title, https://github.com/wekan/wekan/wiki/Wekan-Markdown
- Emoji https://github.com/wekan/wekan/wiki/Emoji
- MathML
- Preview card attachment image and PDF
- Show Start at End Dates of card at Calendar of Swimlanes/Lists/Calendar dropdown menu
- Custom Fields https://github.com/wekan/wekan/wiki/Custom-Fields
- Subtasks https://github.com/wekan/wekan/wiki/Subtasks
- Planning Poker / Scrum Poker at Card https://github.com/wekan/wekan/wiki/Planning-Poker . No other card games yet ;)
- For board actions, like move card etc, Per Board and Global Outgoing and 2-way webhooks to Chat (RocketChat, Slack, Discord etc), NodeRED, or PHP webhook receiver like https://github.com/wekan/webhook
- At top right username menu:
- Search All Boards, with search options
- Public Boards. Board can be set private or public. At Admin Panel is option to disable public boards, so all boards are private.
- Change Language
- My Cards and Due Cards: Show cards where you are member or assignee, from all boards
- At top of current board:
- Filter cards, by user etc
- Multi-Selection, checkmark and drag many cards at once
- Sort current board
- Python and PHP based additional features https://github.com/wekan/wekan/wiki/Python
- Admin Panel:
- Organizations/Teams/People. Impersonate User, logged to database when someone uses that feature.
- Customize Translations https://github.com/wekan/wekan/wiki/Customize-Translations
## Technical details
- Reactive Cache
- mfilser tested speed improvement for half a year, and finally made huge PR to WeKan v7.00 to make all of WeKan use Reactive cache https://github.com/wekan/wekan/pull/5014
- Reactive Cache Repo https://github.com/wekan/meteor-reactive-cache , xet7 updated dependencies
- Big performance improvements https://github.com/wekan/wekan/issues/5000
- Using same style of API for client and serverside
- Use more ReactiveCache than MiniMongo
- Optimizing and Debugging Meteor, reducing size, links to WeKan dependencies https://github.com/wekan/wekan/wiki/Debugging
- Custom OIDC/OAuth2 login
- Repo https://github.com/wekan/wekan/tree/main/packages/wekan-oidc
- Features:
- At Admin Panel, you can change text of login page button `Login with OIDC`
- Auth0 https://github.com/wekan/wekan/wiki/OAuth2#auth0 . This did take about half year to implement by xet7, was not available anywhere else for Meteor.
- Oracle OIM. https://github.com/wekan/wekan/wiki/Oracle-OIM . For this, customer provided some code. xet7 added fix to make login work even when some login field was missing data, by taking data from other field, all this while xet7 did not have access to customers Oracle OIM, just guessing about what code to add, and it worked.
- GitLab https://github.com/wekan/wekan/wiki/OAuth2#gitlab-providing-oauth2-login-to-wekan
- RocketChat https://github.com/wekan/wekan/wiki/OAuth2#rocketchat-providing-oauth2-login-to-wekan
- Nextcloud https://github.com/wekan/wekan/wiki/Nextcloud
- ADFS 4.0 using OAuth2 and OpenID https://github.com/wekan/wekan/wiki/ADFS
- Azure https://github.com/wekan/wekan/wiki/Azure
- Keycloak https://github.com/wekan/wekan/wiki/Keycloak
- Google login https://github.com/wekan/wekan/wiki/Google-login
- Custom LDAP
- LDAP https://github.com/wekan/wekan/wiki/LDAP
- LDAP AD Simple Auth https://github.com/wekan/wekan/wiki/LDAP-AD-Simple-Auth
- Default board for users https://github.com/wekan/wekan/pull/5098
- Brute Force Accounts Lockout https://github.com/wekan/wekan/wiki/Accounts-Lockout
- Markdown, Emoji, MathML, sanitizing https://github.com/wekan/wekan/blob/main/packages/markdown/src/template-integration.js
- Many security fixes from Responsible Disclosure https://wekan.github.io/hall-of-fame/
## Upcoming Features
- CAS https://github.com/wekan/wekan/wiki/CAS
- SAML https://github.com/wekan/wekan/wiki/SAML
## Video
- Creator of WeKan, mquandalle (Maxime Quandalle) https://www.youtube.com/watch?v=N3iMLwCNOro
- https://github.com/wekan/wekan/wiki/FAQ#what-was-wekan-fork--wefork
- Maintainer of WeKan since December 2016, xet7 (Lauri Ojansivu), about WeKan Multiverse at EU NGI Dapsi https://www.youtube.com/watch?v=BPPjiZHVeyM . More about Multiverse at https://github.com/wekan/wekan/wiki/WeKan-Multiverse-Roadmap
## Maybe?
- https://github.com/frozeman/meteor-persistent-minimongo2
## Upcoming upgrades to Meteor 3.0
- This Week in MeteorJS: 22 September 2023 https://www.youtube.com/watch?v=UWVL1xUP9r0
- There Jan Dvorak IV https://github.com/StorytellerCZ commented chat: "We should do deep dive into WeKan!"
- So here is The Deep Dive!
- Questions for upcoming "This Week in MeteorJS", some already mentioned to be upcoming:
- How to upgrade dependencies to Meteor 3.0 ? Some answer was to mention Meteor version at package dependency:
<img src="https://wekan.github.io/upgrade-meteor3-new.png" width="100%" alt="Meteor 3.0 upgrading dependencies" />
- But what if adding dependency adds some more error messages? Probably that depends on error message, like here when
trying to upgrade to Meteor 3.0 alpha 15: https://github.com/wekan/wekan/issues/5142
- https://forums.meteor.com/t/my-journey-towards-meteor-3-0/60001/23
- https://github.com/bratelefant/Meteor-Files
- https://github.com/bratelefant/meteor-roles
- https://github.com/bratelefant/meteor-multitenancy

7
docs/wekan.wiki/Delete-Board.md Normal file
View file

@ -0,0 +1,7 @@
## 1) Move board to Archive
<img src="https://wekan.github.io/boards/delete-board-part1.png" width="60%" alt="Move board to Archive" />
## 2) All Boards => Archive => Delete Board
<img src="https://wekan.github.io/boards/delete-board-part2.png" width="60%" alt="Delete Board from Archive" />

23
docs/wekan.wiki/Design-Principles.md Normal file
View file

@ -0,0 +1,23 @@
## WeKan Design Principles
- Prevent messing up something https://github.com/wekan/wekan/wiki/Monkey-Proof-Software
- Original WeKan Design, that WeKan currently has: Intuitive, easy to figure out, polished UI/UX, menu options are there where you would expect then to be. Try to fix anything unexpected. New features added there where it makes most sense. And not so many duplicate menus and texts like Trello.
- Not the exact design of Trello https://github.com/wekan/wekan/wiki/FAQ#why-does-wekan-look-so-different-now-compared-to--v09 . Also not the exact design of any other software. But note that design of all software changes often, when they are in active development.
- Some features like Trello:
- Import from Trello
- Shortcuts https://github.com/wekan/wekan/issues/1878
- IFTTT Rules like Trello Butler https://github.com/wekan/wekan/wiki/IFTTT
- Progress bar of checklist
- Some features like Jira:
- Multiple assignees
- Some features not in Trello, like:
- FOSS with MIT license
- Self-hosting
- Swimlanes
- All the use cases of WeKan feature/fix contributors
- Cross-platform. Support many CPU/OS/Browsers for Desktop and Mobile. Add support for more.
- https://github.com/wekan/wekan/wiki/Browser-compatibility-matrix
- https://github.com/wekan/wekan/wiki/PWA
- https://github.com/wekan/wekan/wiki/Offline
- https://github.com/wekan/wekan/wiki/Mac
- https://github.com/wekan/wekan/wiki/Raspberry-Pi

106
docs/wekan.wiki/Developer-Documentation.md Normal file
View file

@ -0,0 +1,106 @@
# Style guide
We follow the [meteor style guide](https://guide.meteor.com/code-style.html#javascript).
Please read the meteor style guide before making any significant contribution.
# Stories about how Wekan works, and developing Wekan
- https://www.mongodb.com/docs/drivers/node/v3.7/fundamentals/promises/
- [Do not use code formatters like Prettier and ESLint](https://github.com/wekan/wekan/pull/4633#issuecomment-1214214591)
- [How realtime board updates work](https://github.com/wekan/wekan/issues/3788#issuecomment-834649553)
- [Mobile Web interface](https://github.com/wekan/wekan/issues/3566#issuecomment-778700604)
- [How to add RTL support](https://github.com/wekan/wekan/issues/3376#issuecomment-766092425)
- [How to code Part 1](https://blog.wekan.team/2019/04/howto-code-part-1-learning-to-learn/)
- [First time Wekan contributor easily figures out Wekan and develops big features](https://blog.wekan.team/2018/05/wekan-v1-00-released/)
- [Benefits of contributing your features to upstream Wekan](https://blog.wekan.team/2018/02/benefits-of-contributing-your-features-to-upstream-wekan/)
- [Excellent example how pull requests are improved and integrated, and not needed commits removed](https://github.com/wekan/wekan/pull/1470)
- [How to add dependency](https://github.com/wekan/wekan/discussions/5235)
- [How to add set default view feature](https://github.com/wekan/wekan/discussions/5233)
- [Adding SVG image](https://github.com/wekan/wekan/discussions/5211#discussioncomment-7765365)
## Building code and submitting pull request
- [Building code and submitting pull request](emoji#how-you-could-add-another-plugin)
- When you start `meteor` command, it watches for changes to files in wekan directory and subdirectories, and if it detects changed code, it starts rebuilding bundle and then reloads webbrowser after that automatically
- Also look at meteor changelog mentioned new feature `hot reload` how that could make reloading faster
## VSCode / VSCodium
- I use [VSCodium](https://vscodium.com) that has MS tracking code removed
- Plugin Prettier for right click format javascript code with prettier
- There could be other plugins for Meteor, Jade, Stylus, Dockerfile, etc
## Finding code
There is find.sh script that ignores generated directories, finds code in subdirectories, and paginates with less. For example, finding how search cards is implemented:
```
cd wekan
./find.sh js-search
```
When you run this, you see .jade template files where is search input box, and .js files where is the search code. CSS is in .styl files.
## Getting Started
- Currently Wekan development is done mainly at Ubuntu 20.10 64bit, but building Wekan does work on any Debian, Ubuntu, WSL Ubuntu 20.04, [Mac](Mac). Sametime maybe on [Windows](Windows) with `choco install -y meteor` and installing packages it then asks for with `meteor add ...` or `meteor npm install --save ...` and then running meteor again.
- Look through old [pull requests](https://github.com/wekan/wekan/pulls)
- Read Wekan source code, you can use some git history viewer GUI like gitk
- Read [Meteor documentation](https://docs.meteor.com/) for [Meteor version](https://github.com/wekan/wekan/blob/main/.meteor/release) in use, other versions mentioned at [Dockerfile](https://github.com/wekan/wekan/blob/main/Dockerfile)
- Docker up-to-date way: You can clone wekan/wekan repo and update docker-compose.yml file ROOT_URL etc as documented at https://github.com/wekan/wekan-mongodb commented docker-compose.yml file, install docker, and build from source with docker with "docker-compose up -d --build"
- Docker not up-to-date way: [Docker environment for Wekan development](https://github.com/wekan/wekan-dev).
## Pull Request Workflow (Please read before submitting PR's)
- If package is available on meteor https://atmospherejs.com `meteor add packagename` or https://www.npmjs.com `meteor npm install packagename` then it's enough to add package that way, and there is no need to clone repo in [rebuild-wekan.sh](https://github.com/wekan/wekan-maintainer/tree/master/releases) script.
- When doing pull requests, only add additions and changes to English at wekan/i18n/en.i18n.json . Other translations are done at [https://app.transifex.com/wekan/](https://app.transifex.com/wekan/).
- If you have fix to some existing pull request, add your fix as comment. Do not post new pull request.
- For new features add new pull request, if there is none already.
- remove all console.log statements
- [Here is how to remove commits from pull request](https://stackoverflow.com/questions/36168839/how-to-remove-commits-from-pull-request)
## Preventing Travis CI lint errors before submitting pull requests
- NOTE: Travis is currently broken and always shows warnings and errors like variables not defined or not used, so if your code works, ignore Travis.
- Eslint for linting. To prevent Travis CI lint errors, you can test for lint errors by installing `npm install eslint` and running it with `npm run lint` and trying automatic fixing with `eslint --fix filename.js`
- There is also probably not-currently-working as of 2018-05-05 [jsbeautifer website](http://jsbeautifier.org) with settings Indent with 2 spaces (topmost dropdown), [X] Space before conditional: "if(x)" / "if (x)", [X] Use JSLint-happy formatting tweaks.
## Choosing issues to work on
- You are free to select what feature to work on.
- Leave a comment on an issue saying that you're working on it, and give updates as needed.
- Work and concentrate on one issue at a time and finish it, before moving to other issue.
- Keep list of your contributions on your personal website.
- Keep track of time it takes to implement each part of a feature, so you can estimate what time it would take to implement similar feature. After implementing feature, review your estimate was it correct, make improvements to your process and estimates, also keeping enough time allocated in estimate if something is harder to implement. Employers look for coders with proven track record.
- You can ask for comments from others, but usually those feature requests are clearly defined how they should work. You can place those Settings options there where it seems most logical for you.
Main point is to be friendly to those commenting of your code, and incorporate those suggestions that make most sense.
# Build Pipeline
- Templates are written in [JADE](https://naltatis.github.io/jade-syntax-docs/) instead of plain HTML. Also see [HTML to JADE converter](http://html2jade.org/).
- CSS is written in the [Stylus](http://stylus-lang.com/) precompiler - see [Stylus to CSS converter](https://mikethedj4.github.io/Stylus2CSS/), and
- Meteor templates are created as BlazeLayout templates.
- Instead of the allow/deny paradigm a lot of the `collections` defined in the project use `mutations` to define what kinds of operations are allowed.
For further details look for the 'feature summaries' in the Wiki (still in progress) otherwise go through the git history and see how old features were built. Might I suggest the Start and Due date feature [wefork#26](https://github.com/wefork/wekan/pull/26)
# Translations
If adding new features, please also support the internationalization features built in. Refer to the [[Translations]] wiki page.
# Export From Trello
It's possible to import your existing boards from Trello. Instructions [[here|migrating-from-trello]]
# Directory Structure Details
[Directory Structure](Directory-Structure)
# Chat
[![Wekan chat][vanila_badge]][vanila_chat]
[rocket_chat]: https://chat.indie.host/channel/wekan
[vanila_badge]: https://vanila.io/img/join-chat-button2.png
[vanila_chat]: https://community.vanila.io/wekan

187
docs/wekan.wiki/Directory-Structure.md Normal file
View file

@ -0,0 +1,187 @@
# Routing
We're using [FlowRouter](https://github.com/kadirahq/flow-router) client side router inside **[config/router.js](https://github.com/wekan/wekan/tree/main/config/router.js)**.
For accounts there is [AccountsTemplates](https://github.com/meteor-useraccounts) configured in **[config/accounts.js](https://github.com/wekan/wekan/tree/main/config/accounts.js)**.
# Client
## public
Files in this directory are served by meteor as-is to the client. It hosts some (fav)icons and fonts.
**[wekan-manifest.json](https://github.com/wekan/wekan/tree/main/wekan-manifest.json)**: goes into `link rel="manifest"` in the header of the generated page and is a [Web App Manifest](https://developer.mozilla.org/en-US/docs/Web/Manifest).
## components
* **[activities](https://github.com/wekan/wekan/tree/main/client/components/activities)**:
* **[activities.jade](https://github.com/wekan/wekan/tree/main/client/components/activities/activities.jade)**: `activities` template for the list of activities placed inside a `sidebar-content`; uses `boardActivities` or `cardActivities` depending on `mode`; <span style="color:red">*XXX: does this mean that sidebar should be visible in board list mode? when does the `board` activity gets shown?*</span>
* **[comments.jade](https://github.com/wekan/wekan/tree/main/client/components/activities/comments.jade)**: `commentForm` template used in `card-details-canvas` for adding comments;
* **[boards](https://github.com/wekan/wekan/tree/main/client/components/boards)**:
* **[boardArchive.jade](https://github.com/wekan/wekan/tree/main/client/components/boards/boardArchive.jade)**: `archivedBoards` template for the modal dialog showing the list of archived boards that might be restored;
* **[boardBody.jade](https://github.com/wekan/wekan/tree/main/client/components/boards/boardBody.jade)**: top level template for presenting a board is `board` and, based on screen size and current state, it uses either `cardDetails` or `boardBody` templates; `boardBody` is the one including the `sidebar`, each `list`, `cardDetails` for larger screens when a card is selected and the `addListForm` for adding a new list (also defined in this file);
* **[boardHeader.jade](https://github.com/wekan/wekan/tree/main/client/components/boards/boardHeader.jade)**: `boardHeaderBar`, `boardMenuPopup`, `boardVisibilityList`, `boardChangeVisibilityPopup`, `boardChangeWatchPopup`, `boardChangeColorPopup`, `createBoard`, `chooseBoardSource`, `boardChangeTitlePopup`, `archiveBoardPopup`, `outgoingWebhooksPopup`;
* **[boardsList.jade](https://github.com/wekan/wekan/tree/main/client/components/boards/boardsList.jade)**: `boardList` and `boardListHeaderBar` for the list of boards in the initial screen;
* **[cards](https://github.com/wekan/wekan/tree/main/client/components/cards)**:
* **[attachments.jade](https://github.com/wekan/wekan/tree/main/client/components/cards/attachments.jade)**: `cardAttachmentsPopup`, `previewClipboardImagePopup`, `previewAttachedImagePopup`, `attachmentDeletePopup`, `attachmentsGalery`;
* **[cardDate.jade](https://github.com/wekan/wekan/tree/main/client/components/cards/cardDate.jade)**: `editCardDate` and `dateBadge` templates;
* **[cardDetails.jade](https://github.com/wekan/wekan/tree/main/client/components/cards/cardDetails.jade)**: `boardsAndLists` is the usual layout for a board display with `boardLists` being used in sandstorm where each board is independent;`cardDetails`, `editCardTitleForm`, `cardDetailsActionsPopup`, `moveCardPopup`, `copyCardPopup`,`cardMembersPopup`,`cardMorePopup`, `cardDeletePopup`;
* **[cardTime.jade](https://github.com/wekan/wekan/tree/main/client/components/cards/cardTime.jade)**: `editCardSpentTime` and `timeBadge` templates;
* **[checklists.jade](https://github.com/wekan/wekan/tree/main/client/components/cards/checklists.jade)**: `checklists`, `checklistDetail`, `checklistDeleteDialog`, `addChecklistItemForm`, `editChecklistItemForm`, `checklistItems`, `itemDetail`;
* **[labels.jade](https://github.com/wekan/wekan/tree/main/client/components/cards/labels.jade)**: `formLabel`, `createLabelPopup`, `editLabelPopup`, `deleteLabelPopup`, `cardLabelsPopup`;
* **[minicard.jade](https://github.com/wekan/wekan/tree/main/client/components/cards/minicard.jade)**: has the `minicard` template
* **[forms](https://github.com/wekan/wekan/tree/main/client/components/forms)**: **[inlinedform.jade](https://github.com/wekan/wekan/tree/main/client/components/forms/inlinedform.jade)** has the`inlinedForm` template;
* **[import](https://github.com/wekan/wekan/tree/main/client/components/import)**:
* **[import.jade](https://github.com/wekan/wekan/tree/main/client/components/import/import.jade)**: `importHeaderBar`, `import`, `importTextarea`, `importMapMembers`, `importMapMembersAddPopup` are all templates used for importing Trello (via **[trelloMembersMapper.js](https://github.com/wekan/wekan/tree/main/client/components/import/trelloMembersMapper.js)**) and Wekan (via **[wekanMembersMapper.js](https://github.com/wekan/wekan/tree/main/client/components/import/wekanMembersMapper.js)**) boards;
* **[lists](https://github.com/wekan/wekan/tree/main/client/components/lists)**:
* **[list.jade](https://github.com/wekan/wekan/tree/main/client/components/lists/list.jade)**: `list` is the simple, main template for lists;
* **[listBody.jade](https://github.com/wekan/wekan/tree/main/client/components/lists/listBody.jade)**: `listBody`, `addCardForm`, `autocompleteLabelLine` templates;
* **[listHeader.jade](https://github.com/wekan/wekan/tree/main/client/components/lists/listHeader.jade)**: `listHeader`, `editListTitleForm`, `listActionPopup`, `boardLists`, `listMorePopup`, `listDeletePopup`, `setWipLimitPopup`, `wipLimitErrorPopup` templates;
* **[main](https://github.com/wekan/wekan/tree/main/client/components/main)**:
* **[editor.jade](https://github.com/wekan/wekan/tree/main/client/components/main/editor.jade)**: `editor` and `viewer` templates;
* **[header.jade](https://github.com/wekan/wekan/tree/main/client/components/main/header.jade)**: `header` and `offlineWarning` templates; if the user is connected we display a small "quick-access" top bar that list all starred boards with a link to go there (this is inspired by the Reddit "subreddit" bar); the first link goes to the boards page;
* **[keyboardShortcuts.jade](https://github.com/wekan/wekan/tree/main/client/components/main/keyboardShortcuts.jade)**: `shortcutsHeaderBar`, `shortcutsModalTitle`, `keyboardShortcuts` - all for the shortcuts that are presented when you press `?`re implemented inhere;
* **[layouts.jade](https://github.com/wekan/wekan/tree/main/client/components/main/layouts.jade)**: has the template for head portion of the html page and other general purpose templates: `userFormsLayout`, `defaultLayout`, `notFound`, `message`;
* **[popup.tpl.jade](https://github.com/wekan/wekan/tree/main/client/components/main/popup.tpl.jade)**: tpl files only define a single template so there's no need to wrap content in a template tag; the name of the template is the base name of the file (`popup` in this case);
* **[spinner.tpl.jade](https://github.com/wekan/wekan/tree/main/client/components/main/spinner.tpl.jade)**: is the template for a "waiting" dialog;
* **[settings](https://github.com/wekan/wekan/tree/main/client/components/settings)**:
* **[informationBody.jade](https://github.com/wekan/wekan/tree/main/client/components/settings/informationBody.jade)**: `information`, `statistics` templates;
* **[invitationCode.jade](https://github.com/wekan/wekan/tree/main/client/components/settings/invitationCode.jade)**: `invitationCode` template;
* **[peopleBody.jade](https://github.com/wekan/wekan/tree/main/client/components/settings/peopleBody.jade)**: `people`, `peopleGeneral`, `peopleRow`, `editUserPopup`;
* **[settingBody.jade](https://github.com/wekan/wekan/tree/main/client/components/settings/settingBody.jade)**: `setting`, `general`, `email`, `accountSettings`, `announcementSettings`
* **[settingHeader.jade](https://github.com/wekan/wekan/tree/main/client/components/settings/settingHeader.jade)**: `settingHeaderBar` template;
* **[sidebar](https://github.com/wekan/wekan/tree/main/client/components/sidebar)**:
* **[sidebar.jade](https://github.com/wekan/wekan/tree/main/client/components/sidebar/sidebar.jade)**: `sidebar`, `homeSidebar`, `membersWidget`, `labelsWidget`, `memberPopup`, `removeMemberPopup`, `leaveBoardPopup`, `addMemberPopup`, `changePermissionsPopup`
* **[sidebarArchives.jade](https://github.com/wekan/wekan/tree/main/client/components/sidebar/sidebarArchives.jade)**: `archivesSidebar`
* **[sidebarFilters.jade](https://github.com/wekan/wekan/tree/main/client/components/sidebar/sidebarFilters.jade)**: `filterSidebar`, `multiselectionSidebar`, `disambiguateMultiLabelPopup`, `disambiguateMultiMemberPopup`, `moveSelectionPopup`;
* **[users](https://github.com/wekan/wekan/tree/main/client/components/users)**:
* **[userAvatar.jade](https://github.com/wekan/wekan/tree/main/client/components/users/userAvatar.jade)**: `userAvatar`, `userAvatarInitials`, `userPopup`, `memberName`, `changeAvatarPopup`, `cardMemberPopup`
* **[userHeader.jade](https://github.com/wekan/wekan/tree/main/client/components/users/userHeader.jade)**: `headerUserBar`, `memberMenuPopup`, `editProfilePopup`, `editNotificationPopup`, `changePasswordPopup`, `changeLanguagePopup`, `changeSettingsPopup`;
* **[mixins](https://github.com/wekan/wekan/tree/main/client/components/mixins)**: [extends](http://www.meteorpedia.com/read/Infinite_Scrolling) **[infiniteScrolling.js](https://github.com/wekan/wekan/tree/main/client/components/mixins/infiniteScrolling.js)** for card details, sidebar and also extends **[perfectScrollbar.js](https://github.com/wekan/wekan/tree/main/client/components/mixins/perfectScrollbar.js)**;
## config
* **[blazeHelpers.js](https://github.com/wekan/wekan/tree/main/client/config/blazeHelpers.js)**: following [Blaze](http://blazejs.org/) helpers are registered here:`currentBoard()`, `currentCard()`, `getUser()` and `concat()`;
* **[gecko-fix.js](https://github.com/wekan/wekan/tree/main/client/config/gecko-fix.js)**: removes [deprecated](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/watch)`watch` and `unwatch` from Firefox prior to version 58;
* **[presence.js](https://github.com/wekan/wekan/tree/main/client/config/presence.js)**: custom state function for [Presence](https://github.com/dburles/meteor-presence) that keeps track of current board;
* **[reactiveTabs.js](https://github.com/wekan/wekan/tree/main/client/config/reactiveTabs.js)**: [ReactiveTabs](https://github.com/meteortemplates/tabs) are configured to use `basicTabs` template.
## lib
* **[accessibility.js](https://github.com/wekan/wekan/tree/main/client/lib/accessibility.js)**: define a set of DOM transformations that are specifically intended for blind screen readers;
* **[cssEvents.js](https://github.com/wekan/wekan/tree/main/client/lib/cssEvents.js)**: the `CSSEvents`object has methods that select the name of the event based on the specific transitions and animations;
* **[pasteImage.js](https://github.com/wekan/wekan/tree/main/client/lib/pasteImage.js)** and **[dropImage.js](https://github.com/wekan/wekan/tree/main/client/lib/dropImage.js)**: utility for pasting and dropping images on a web app; <span style="color:red">*XXX: add comments; not same style as the rest of the code*</span>
* **[emoji-values.js](https://github.com/wekan/wekan/tree/main/client/lib/emoji-values.js)**: sets Emoji.values;
* **[escapeActions.js](https://github.com/wekan/wekan/tree/main/client/lib/escapeActions.js)**: defines the behavior (mostly canceling current edit) for escape keyboard key;
* **[i18n.js](https://github.com/wekan/wekan/tree/main/client/lib/i18n.js)**: at startup we choose the language for the ui based on user profile or browser language;
* **[inlinedform.js](https://github.com/wekan/wekan/tree/main/client/lib/inlinedform.js)**: forms for editing a single field (like adding a card); <span style="color:red">*XXX: comments in code suggest that a form that is not submitted will retain its value to prevent data loss using [unsavedEdits.js](https://github.com/wekan/wekan/tree/main/client/lib/unsavedEdits.js);bug?*</span>; <span style="color:red">*XXX: edit button to save and open*</span>;
* **[keyboard.js](https://github.com/wekan/wekan/tree/main/client/lib/keyboard.js)**: the shortcuts that are presented when you press `?`re implemented inhere;
* **[mixins.js](https://github.com/wekan/wekan/tree/main/client/lib/mixins.js)**: stub; no `Mixins` at this point; <span style="color:red">*XXX: what does `new class` do? exlint: missing () invoking a constructor*</span>
* **[popup.js](https://github.com/wekan/wekan/tree/main/client/lib/popup.js)**: defines `Popup` class for things likes electing a date; <span style="color:red">*XXX: not a Blaze helper?*</span>
* **[textComplete.js](https://github.com/wekan/wekan/tree/main/client/lib/textComplete.js)**: extends [jquery-textcomplete](https://yuku-t.com/jquery-textcomplete/) to integrate with the rest of the system (like escape actions, tab and enter key handling); <span style="color:red">*XXX: deprecated?*</span>
* **[utils.js](https://github.com/wekan/wekan/tree/main/client/lib/utils.js)**: various methods all over the place (resize, screen size, sort, capitalize, navigate to board and card);
* **Blaze helpers**:
* **[filter.js](https://github.com/wekan/wekan/tree/main/client/lib/filter.js)**: registers `Filter` [Blaze](http://blazejs.org/) helper to support filtering cards by labels and by members;
* **[modal.js](https://github.com/wekan/wekan/tree/main/client/lib/modal.js)**: registers `Modal` [Blaze](http://blazejs.org/) helper to support showing modal windows like the one for archived boards;
* **[multiSelection.js](https://github.com/wekan/wekan/tree/main/client/lib/multiSelection.js)**: registers `Modal` [Blaze](http://blazejs.org/) helper to support multiple selection mode;
* **[unsavedEdits.js](https://github.com/wekan/wekan/tree/main/client/lib/unsavedEdits.js)**: registers `getUnsavedValue` and `hasUnsavedValue` [Blaze](http://blazejs.org/) helpers to preserve content entered in fields but not saved;
# Server
.js files in this directory are not available to the client.
* **[statistics.js](https://github.com/wekan/wekan/tree/main/server/statistics.js)** implements a Meteor server-only [method](https://guide.meteor.com/methods.html) for general-purpose information such as OS, memory, CPUs, PID of the process and so on.
* **[migrations.js](https://github.com/wekan/wekan/tree/main/server/migrations.js)** is where code that update sold databases to new schema is located. Anytime the schema of one of the collection changes in a non-backward compatible way a migration needs to be written in this file.
* **[authentication.js](https://github.com/wekan/wekan/tree/main/server/authentication.js)** add the `Authentication`object to Meteor that provides methods for checking access rights.
* **[lib/utils.js](https://github.com/wekan/wekan/tree/main/server/lib/utils.js)** defines some checks used by [checklists.js](https://github.com/wekan/wekan/tree/main/models/checklists.js)** model. <span style="color:red">*XXX: these methods are defined in server-only code by are used in models, which are visible by the client (in Checklists.allow)?*</span>
* **[notifications](https://github.com/wekan/wekan/tree/main/server/notifications)**
* **[notifications.js](https://github.com/wekan/wekan/tree/main/server/notifications/notifications.js)**: defines the `Notifications` object that supports [Activities](models/activities.js) and holds a list of functions to call when its `notify()` method is called along with convenience methods to subscribe, unsubscribe and a way to filter recipients according to user settings for notification;
* **[email.js](https://github.com/wekan/wekan/tree/main/server/notifications/email.js)**: makes use of the notification system to send an email to a user;
* **[profile.js](https://github.com/wekan/wekan/tree/main/server/notifications/profile.js)**: *stub*; will allow associating notifications with user ids to be consumed by mobile apps;
* **[notifications.js](https://github.com/wekan/wekan/tree/main/server/notifications/notifications.js)**: adds the `watch()` Meteor server-only [method](https://guide.meteor.com/methods.html) that may watch boards, lists or cards using [models/watchable.js](https://github.com/wekan/wekan/tree/main/models/watchable.js);
* **[outgoing.js](https://github.com/wekan/wekan/tree/main/server/notifications/outgoing.js)**: adds the `outgoingWebhooks()` Meteor server-only [method](https://guide.meteor.com/methods.html) that can call external API <span style="color:red">*XXX: I guess*</span>
* **[publications](https://github.com/wekan/wekan/tree/main/server/publications)** defines sets of records that are [published](https://docs.meteor.com/api/pubsub.html#Meteor-publish) by the server and how clients can subscribe to those:
* **[accountSettings.js](https://github.com/wekan/wekan/tree/main/server/publications/accountSettings.js)**: [AccountSettings](models/accountSettings.js) collection;
* **[activities.js](https://github.com/wekan/wekan/tree/main/server/publications/activities.js)**: [Activities](models/activities.js) collection filtered and paginated;
* **[announcements.js](https://github.com/wekan/wekan/tree/main/server/publications/announcements.js)**: [Announcements](models/announcements.js) collection;
* **[avatars.js](https://github.com/wekan/wekan/tree/main/server/publications/avatars.js)**: [Avatars](models/avatars.js) collection for current user;
* **[boards.js](https://github.com/wekan/wekan/tree/main/server/publications/boards.js)**: [Boards](models/boards.js) collection for current user, archived boards collection and individual board as a [relation](https://atmospherejs.com/cottz/publish-relations);
* **[cards.js](https://github.com/wekan/wekan/tree/main/server/publications/cards.js)**: a [Card](https://github.com/wekan/wekan/tree/main/models/cards.js) by its id;
* **[fast-render.js](https://github.com/wekan/wekan/tree/main/server/publications/fast-render.js)**: configures [FastRender](https://github.com/kadirahq/fast-render) to use the board data; <span style="color:red">*XXX: FastRender docs say "Make sure you're using Meteor.subscribe and not this.subscribe"*</span>
* **[people.js](https://github.com/wekan/wekan/tree/main/server/publications/people.js)**: [Users](models/users.js) collection;
* **[settings.js](https://github.com/wekan/wekan/tree/main/server/publications/settings.js)**: [Settings](models/settings.js) collection and, separately, the mail server;
* **[unsavedEdits.js](https://github.com/wekan/wekan/tree/main/server/publications/unsavedEdits.js)**: [UnsavedEdits](models/unsavedEdits.js) collection;
* **[users.js](https://github.com/wekan/wekan/tree/main/server/publications/users.js)**: provides a "mini-profile" for individual users and a [way](https://docs.meteor.com/api/collections.html#fieldspecifiers) to check if current user is admin.
# Models
The files in **[models](https://github.com/wekan/wekan/tree/main/models)** directory mainly define collections; most of them have [aldeed SimpleSchema](https://atmospherejs.com/aldeed/simple-schema) for automatic validation of insert and update of collections. This is also where helpers, mutations, methods, hooks and bootstrap code is to be found. [Server side code](https://docs.meteor.com/api/core.html#Meteor-isServer) also implements json REST API.
Collections (mostly `Mongo.Collection` except as noted) are defined in:
* **[accountSettings.js](https://github.com/wekan/wekan/tree/main/models/accountSettings.js)**;
* **[activities.js](https://github.com/wekan/wekan/tree/main/models/activities.js)**: does not have a SimpleSchema;
* **[announcements.js](https://github.com/wekan/wekan/tree/main/models/announcements.js)**;
* **[attachments.js](https://github.com/wekan/wekan/tree/main/models/attachments.js)**: file-system collection;
* **[avatars.js](https://github.com/wekan/wekan/tree/main/models/avatars.js)**: file-system collection;
* **[boards.js](https://github.com/wekan/wekan/tree/main/models/boards.js)**;
* **[cardComments.js](https://github.com/wekan/wekan/tree/main/models/cardComments.js)**;
* **[cards.js](https://github.com/wekan/wekan/tree/main/models/cards.js)**;
* **[checklists.js](https://github.com/wekan/wekan/tree/main/models/checklists.js)**;
* **[integrations.js](https://github.com/wekan/wekan/tree/main/models/integrations.js)**;
* **[invitationCodes.js](https://github.com/wekan/wekan/tree/main/models/invitationCodes.js)**;
* **[lists.js](https://github.com/wekan/wekan/tree/main/models/lists.js)**;
* **[settings.js](https://github.com/wekan/wekan/tree/main/models/settings.js)**;
* **[unsavedEdits.js](https://github.com/wekan/wekan/tree/main/models/unsavedEdits.js)**;
* **[users.js](https://github.com/wekan/wekan/tree/main/models/users.js)**: extends the `Meteor.users` collection.
Other files:
* **[watchable.js](https://github.com/wekan/wekan/tree/main/models/watchable.js)**: extends the schema, helpers and mutations of `Boards`, `Lists` and `Cards`.
* **[export.js](https://github.com/wekan/wekan/tree/main/models/export.js)**: has some code to support the REST API.
* **[import.js](https://github.com/wekan/wekan/tree/main/models/import.js)**: implements `importBoard()` method so that Trello (in **[trelloCreator.js](https://github.com/wekan/wekan/tree/main/models/trelloCreator.js)**) and Wekan (in **[wekanCreator.js](https://github.com/wekan/wekan/tree/main/models/wekanCreator.js)**) boards can be imported. <span style="color:red">*XXX: Solid candidates for a directory of their own.*</span>
# Tools
* Git:
* **.git**;
* **[.gitignore](https://github.com/wekan/wekan/tree/main/.gitignore)**;
* Docker:
* **[docker-compose.yml](https://github.com/wekan/wekan/tree/main/docker-compose.yml)**: the compose file is a YAML file defining services, networks and volumes;
* **[Dockerfile](https://github.com/wekan/wekan/tree/main/Dockerfile)**;
* Snap:
* **[snapcraft.yaml](https://github.com/wekan/wekan/tree/main/snapcraft.yaml)**: [Snapcraft](https://snapcraft.io/) packages any app for every Linux desktop, server, cloud or device, and deliver updates directly;
* **[snap](https://github.com/wekan/wekan/tree/main/snap)**;
* **[snap-src](https://github.com/wekan/wekan/tree/main/snap-src)**;
* Sandstorm:
* **[sandstorm.js](https://github.com/wekan/wekan/tree/main/sandstorm.js)**: [Sandstorm](https://sandstorm.io/) specific code;
* **[sandstorm-pkgdef.capnp](https://github.com/wekan/wekan/tree/main/sandstorm-pkgdef.capnp)**: used the meteor-spk tool to generate a sandstorm package;
* Node:
* **[package.json](https://github.com/wekan/wekan/tree/main/package.json)**;
* **node_modules**
* **[app.json](https://github.com/wekan/wekan/tree/main/app.json)**: is a manifest format for describing web apps (build requirements, environment variables, addons, and other information);
* **[app.env](https://github.com/wekan/wekan/tree/main/app.env)**: environment variables;
* Meteor: is a full-stack JavaScript platform for developing modern web and mobile applications.
* **[.meteor](https://github.com/wekan/wekan/tree/main/.meteor)**;
* Translation:
* **[i18n](https://github.com/wekan/wekan/tree/main/i18n)** directory has one .json file for each supported language
* **[.tx](https://github.com/wekan/wekan/tree/main/.tx)**: configuration for [Transifex](https://app.transifex.com/wekan/) tool used to manage translation;
* Text editors:
* **[.vscode](https://github.com/wekan/wekan/tree/main/.vscode)**: [Visual Studio Code Editor](https://code.visualstudio.com/docs/getstarted/settings);
* **[.editorconfig](https://github.com/wekan/wekan/tree/main/.editorconfig)**: [EditorConfig](http://EditorConfig.org) provides consistent coding styles between different editors and IDEs;
* **[.github](https://github.com/wekan/wekan/tree/main/.github)**: hosts the issues template;
* **[.eslintrc.json](https://github.com/wekan/wekan/tree/main/.eslintrc.json)**: [ESLint](https://eslint.org/docs/user-guide/configuring) configuration;
* **[.travis.yml](https://github.com/wekan/wekan/tree/main/.travis.yml)**: configuration for [Travis CI](https://travis-ci.org/);
* **[scalingo.json](https://github.com/wekan/wekan/tree/main/scalingo.json)**: [Scalingo](https://scalingo.com/) is a deploy solution;
* **[fix-download-unicode](https://github.com/wekan/wekan/tree/main/fix-download-unicode)**: `cfs_access-point.txt` from this folder is copied to `bundle/programs/server/packages/cfs_access-point.js` in Docker build and in snapcraft build; this is a monkey patch fix for [downloading files that have unicode in filename](https://github.com/wekan/wekan/issues/784).
# Info
* **[meta](https://github.com/wekan/wekan/tree/main/meta)**: binary signatures, project description, icons, screenshots and, oui, a French change-log;
* **[CHANGELOG.md](https://github.com/wekan/wekan/tree/main/CHANGELOG.md)**;
* **[Contributing.md](https://github.com/wekan/wekan/tree/main/Contributing.md)**;
* **[LICENSE](https://github.com/wekan/wekan/tree/main/LICENSE)**;
* **[README.md](https://github.com/wekan/wekan/tree/main/README.md)**.
---
# Contributions to this page
This documentation was contributed by [TNick](https://github.com/TNick) and [xet7](https://github.com/xet7) while Wekan was at commit [e2f768c](https://github.com/wekan/wekan/tree/e2f768c6a0f913b7c5f07695dce8cec692037255).
Please add new files, fixes, updates, etc directly to this page.

242
docs/wekan.wiki/Docker.md Normal file
View file

@ -0,0 +1,242 @@
## Docker Containers
- [GitHub](https://github.com/wekan/wekan/pkgs/container/wekan)
- [Docker Hub](https://hub.docker.com/r/wekanteam/wekan)
- [Quay](https://quay.io/repository/wekan/wekan)
docker-compose.yml at https://github.com/wekan/wekan
Edit it to have IP address of your server
```
export ROOT_URL=http://SERVER-IP-ADDRESS-HERE
```
Then start WeKan with:
```
docker-compose up -d
```
SSL/TLS info at https://github.com/wekan/wekan/wiki/Settings
## Please only use Docker release tags
## Repair Docker
[Repair Docker](Repair-Docker)
## Using only Docker commands
[![Docker Repository on Quay](https://quay.io/repository/wekan/wekan/status "Docker Repository on Quay")](https://quay.io/repository/wekan/wekan)
[Many tags available](https://quay.io/repository/wekan/wekan?tab=tags)
## Note: docker-compose.yml works
There is much more settings at well-documented [docker-compose.yml](https://raw.githubusercontent.com/wekan/wekan/master/docker-compose.yml), those can also be added to be used below.
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
```
## Example for latest Wekan, port 2000 to Docker Wekan internal port 8080
```
docker run -d --restart=always --name wekan-db mongo:5
docker run -d --restart=always --name wekan --link "wekan-db:db" -e "WITH_API=true" -e "MONGO_URL=mongodb://wekan-db:27017/wekan" -e "ROOT_URL=http://192.168.1.200:2000" -p 2000:8080 wekanteam/wekan:v5.41
```
Specific release in above URL, not latest:
```
quay.io/wekan/wekan:v3.37
```
For latest development version, use without tag:
```
quay.io/wekan/wekan
```
## DockerBunker: Easy Docker management
[Managing Docker containers with DockerBunker](https://github.com/chaosbunker/dockerbunker)
## CaptainDuckDuck
[Managing Docker containers with CaptainDuckDuck](https://github.com/wekan/wekan/issues/1375#issuecomment-413626075)
## Backup and Upgrade
[Import/Export MongoDB data to/from Docker container](Export-Docker-Mongo-Data)
[Move Docker containers to other computer](Move-Docker-containers-to-other-computer), needs more details
### Backup before upgrade
```
docker stop wekan-app
docker exec -it wekan-db bash
cd /data
rm -rf dump
mongodump
exit
docker start wekan-app
docker cp wekan-db:/data/dump .
```
### Upgrade
```
docker stop wekan-app
docker rm wekan-app
```
Then edit docker-compose.yml to have higher wekan-app image version tag, like `image: wekanteam/wekan:v4.12`. Then:
```
docker-compose up -d
```
### Images
Quay: `image: quay.io/wekan/wekan:v4.07`
Docker Hub: `image: wekanteam/wekan:v4.07`
### Restore
```
docker stop wekan-app
docker exec -it wekan-db bash
cd /data
rm -rf dump
exit
docker cp dump wekan-db:/data/
docker exec -it wekan-db bash
cd /data
mongorestore --drop
exit
docker start wekan-app
```
## Cleanup
[Cleanup and delete all Docker data to get Docker Compose working](https://github.com/wekan/wekan/issues/985)
[Cleanup scripts to remove old data](https://github.com/wekan/wekan-cleanup)
## Docker Compose
[Docker Compose: Wekan <=> MongoDB](https://github.com/wekan/wekan-mongodb). REQUIRED: READ AND ADD SETTINGS LIKE ROOT_URL ETC TO docker-compose.yml textfile. It also has info about using same MongoDB database for office and VPN users.
[Docker Compose: Wekan <=> MongoDB <=> ToroDB => PostgreSQL read-only mirroring](https://github.com/wekan/wekan-postgresql)
TODO: [Docker Compose: Wekan <=> MongoDB <=> ToroDB => MySQL read-only mirroring](https://github.com/torodb/stampede/issues/203)
## OpenShift
[OpenShift](OpenShift)
## SLES
[SLES SP1](Install-Wekan-Docker-on-SUSE-Linux-Enterprise-Server-12-SP1)
## Rancher
[Rancher Rancher Active Proxy](Rancher---Rancher-Active-Proxy---Wekan-MongoDB-Docker)
## Testing
[Install for testing](Install-Wekan-Docker-for-testing)
## Production
[Production setup for thousands of users with Docker at AWS](AWS)
[Other way to do production](Install-Wekan-Docker-in-production)
## External MongoDB auth
[External MongoDB authentication](https://github.com/wekan/wekan/issues/1375)
## Admin Panel
First registered Wekan user will get Admin Panel on new Docker and source based
installs. You can also [enable Admin Panel manually](https://github.com/wekan/wekan/blob/main/CHANGELOG.md#v0111-rc2-2017-03-05-wekan-prerelease)
## Docker Hub - sometimes broken
Currently there are two dockerhub builds for wekan. One at [mquandalle dockerhub](https://hub.docker.com/r/mquandalle/wekan/builds/) and another at [wekanteam dockerhub](https://hub.docker.com/r/wekanteam/wekan/builds/).
[wekanteam dockerhub](https://hub.docker.com/r/wekanteam/wekan/builds/) is usually broken.
## Development:
### `docker run` examples
- MongoDB:
```
docker run -d --restart=always --name wekan-db mongo:3.2.20
```
- No build step, pull from the [quay](https://quay.io/repository/wekan/wekan?tab=tags) and
specify docker variables
```
docker run -d --restart=always --name wekan --link "wekan-db:db" -e "MONGO_URL=mongodb://db" -e "ROOT_URL=http://localhost:8080" -p 8080:8080 quay.io/wekan/wekan
```
### `docker-compose` examples
- No build step and pull from [quay](https://quay.io/repository/wekan/wekan?tab=tags)
```
sudo docker-compose up -d --nobuild
```
- Build default
```
sudo docker-compose up -d --build
```
- Build with newer Node version:
```
echo 'NODE_VERSION=v8.11.1' >> .env && \
sudo docker-compose up -d --build
```
- Build custom image off a release candidate or beta for meteor
```
echo 'METEOR_EDGE=1.5-beta.17' >> .env && \
echo 'USE_EDGE=true' >> .env && \
sudo docker-compose up -d --build
```
## Docker env for Wekan dev
* [Docker environment for Wekan Development](https://github.com/wekan/wekan-dev)
## Alpine, needs testing
* [Docker Compose: Alpine Linux and Wekan <=> MongoDB](https://github.com/wekan/wekan-launchpad)
## Webserver Config
* [Caddy Webserver Config](Caddy-Webserver-Config)
* [Nginx Webserver Config](Nginx-Webserver-Config)
* [Apache Webserver Config](Apache)

6
docs/wekan.wiki/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

41
docs/wekan.wiki/Drag-Drop.md Normal file
View file

@ -0,0 +1,41 @@
## Roles
It depends on role of user what drag drop is allowed https://github.com/wekan/wekan/wiki/REST-API-Role
## Mobile Drag Drop
1. Click `Drag Handle Enabled/Disabled` button to enable drag handles
2. Use drag handles to move Board Icons, Swimlanes, MiniCards, Lists, Checklists, Checklist Items.
3. Use non-drag-handle area to to view other parts of board, by dragging board up/down/left/right, without moving any icons etc.
<img src="https://wekan.github.io/dragdrop/mobile-drag-drop.png" width="40%" alt="Wekan logo" />
## 2 or more external screens of desktop or mobile
For each screen, you can enable or disable drag handles, because that setting is stored in browser localstorage, not to database. https://github.com/wekan/wekan/issues/4715
Because this feature was added, `Drag Handle Enabled/Disabled` was moved to current place shown in above screenshot. https://github.com/wekan/wekan/issues/4734
## All Boards page
Reorder with drag drop:
- Board Icons
## One Board page
Reorder with drag drop:
- Swimlanes
- Lists
- MiniCards. MiniCard is card, that is not click opened to view card contents.
- Opened Card: Checklists
- Opened Card: Checklist Items
## Drag code examples
- Draggable objects
- https://www.redblobgames.com/making-of/draggable/
- https://news.ycombinator.com/item?id=37703291
- Fixed Drag at Ubuntu Touch Morph browser https://github.com/wekan/wekan/commit/af63259f091cb2ade84493a288ea37c53cd37321

5
docs/wekan.wiki/Due-Date.md Normal file
View file

@ -0,0 +1,5 @@
- received - when a bug or task is found
- start - when work is started
- due - when it should be done
- end - when it's done

76
docs/wekan.wiki/Emoji.md Normal file
View file

@ -0,0 +1,76 @@
## About markdown changes
Wekan v4.29 changes markdown rendering from [marked](https://github.com/markedjs/marked) to [markdown-it](https://github.com/markdown-it/markdown-it).
## About emoji
With markdown-it, also [markdown-it-emoji](https://github.com/markdown-it/markdown-it-emoji) plugin has been added, supporting [full list of GitHub emojis](https://github.com/markdown-it/markdown-it-emoji/blob/master/lib/data/full.json).
Example emoji code, that you can add for example to card name, card description etc:
```
:rainbow: :thumbsup: :100:
```
That shows emojis :rainbow: :thumbsup: :100:
## About other markdown-it plugins
For markdown-it, there are also other [syntax extensions](https://github.com/markdown-it/markdown-it#syntax-extensions) where some are listed at that markdown-it page, and [others at npmjs.com](https://www.npmjs.org/browse/keyword/markdown-it-plugin).
For example, how to get some [mermaid plugin](https://www.npmjs.com/search?q=markdown-it-mermaid) working so that some syntax works for https://mermaid-js.github.io/mermaid/ ?
## How you could add another plugin
Using newest Ubuntu amd64:
### 1. Install git and configure it
```
sudo apt -y install git
git config --global user.name "Yourfirstname Yourlastname"
git config --global user.email email-address-you-use-at-github@example.com
git config --global push.default simple
```
### 2. Create fork of `https://github.com/wekan/wekan`
```
git clone git@github.com:YourGithubUsername/wekan.git
cd wekan
./rebuild-wekan.sh
```
### 3. Select option 1 to install dependencies, and then Enter.
```
./rebuild-wekan.sh
```
### 4. Select option 2 to build Wekan, and then Enter
### 5. Add new plugin package
```
meteor npm install markdown-it-something --save
```
### 5. Edit file
Edit file `wekan/packages/markdown/src-integration.js` and add using that new package, using code example from that new plugin page, or similar like emoji plugin was added.
### 6. Start meteor in Wekan directory
For example:
```
WRITABLE_PATH=.. meteor --port 4000
```
And then [register and login](Adding-users) at http://localhost:4000
### 7. Test
Test does that new plugin syntax work, for example in card title, card description etc on other input fields.
### 8. If it works
If normal markdown, emoji, and your new added plugin syntax all work, commit your changes:
```
git add --all
git commit -m "Added plugin markdown-it-something."
git push
```
And then at your GitHub for `https://github.com/YOUR-GITHUB-USERNAME/wekan` click `Create pull request`.

75
docs/wekan.wiki/Excel-and-VBA.md Normal file
View file

@ -0,0 +1,75 @@
Related projects:
* [VBA-Web](https://github.com/VBA-tools/VBA-Web) - using REST APIs with VBA
* [VBA-JSON](https://github.com/VBA-tools/VBA-JSON)
* [VBA to Javascript translator](https://github.com/mha105/VBA-to-JavaScript-Translator)
* [Tcl and Excel](http://www.xet7.org/tcl)
For accessing Wekan with Excel VBA, you can use Wekan REST API:
https://github.com/wekan/wekan/wiki/REST-API
For example, with using curl, you first login with admin credentials,
by sending username and password to url.
Change your server url etc details to below:
Login with as JSON https://github.com/wekan/wekan/wiki/REST-API#example-call---as-json
```
curl -H "Content-type:application/json" \
http://localhost:3000/users/login \
-d '{ "email": "my@email.com", "password": "mypassword" }'
```
=>
```
{
"id": "ABCDEFG123456",
"token": "AUTH-TOKEN",
"tokenExpires": "2018-07-15T14:23:18.313Z"
}
```
Then you update card content by sending to card URL the new content:
```
curl -H "Authorization: Bearer AUTH-TOKEN" \
-H "Content-type:application/json" \
-X PUT \
http://localhost:3000/api/boards/ABCDEFG123456/lists/ABCDEFG123456/cards/ABCDEFG123456 \
-d '{ "title": "Card new title", "listId": "ABCDEFG123456", "description": "Card new description" }'
```
When using VBA, you can optionally:
* Use direct VBA commands to send and receive from URLs
* Download curl for Windows, and in VBA call curl.exe with those parameters, and get the result.
You can also google search how you can use JSON format files in VBA,
converting them to other formats etc. There could be something similar that
exists in PHP, that JSON file can be converted to PHP array, and array items accessed
individually, and array converted back to JSON.
Current Wekan REST API does not yet cover access to all data that is in MongoDB.
If you need that, REST API page also has link to Restheart, that adds REST API
to MongoDB, so you can use all of MongoDB data directly with REST API.
https://github.com/wekan/wekan/wiki/REST-API
Wekan boards also have export JSON, where also attachments are included in JSON as
base64 encoded files. To convert them back to files, you first get whole one board exported
after authentication like this:
```
curl https://Bearer:APIKEY@ip-address/api/boards/BOARD-ID/export?authToken=#APIKEY > wekanboard.json
```
Then you read that JSON file with VBA, and get that part where in JSON is the base64 text
of the file. Then you use VBA base64 function to convert it to binary, and write content to file.
# CSV/TSC Import/Export
There is [CSV/TSV pull request](https://github.com/wekan/wekan/pull/413), but it has been made
a long time ago, it would need some work to add all the new tables, columns etc from
MongoDB database, so that it would export everything correctly.
Options are:
a) Some developer could do that work and contribute that code to Wekan as
new pull request to Wekan devel branch.
b) Use [Commercial Support](https://wekan.team) and pay for the time to get it implemented.

205
docs/wekan.wiki/Export-Docker-Mongo-Data.md Normal file
View file

@ -0,0 +1,205 @@
[Managing Docker containers with DockerBunker](https://github.com/chaosbunker/dockerbunker)
## Important info
You need to stop Wekan before importing MongoDB database with command:
`docker stop wekan-app`
And also check that in your start-wekan.sh or docker-compose.yml or similar that
you have corrent MongoDB database name admin, wekan, etc.
Otherwise it will be empty.
Docker containers are at `/var/lib/docker`, so it [may contain important data that could be hard to recover](https://github.com/wekan/wekan-mongodb/issues/8). Restoring mongodump files is much easier. [Related backup feature request](https://github.com/wekan/wekan/issues/1534). With backups it's important to [save file and directory permissions](https://askubuntu.com/questions/225865/copy-files-without-losing-file-folder-permissions).
***
Check from your Dockerfile or docker-compose.yml what is name of MongoDB container.
It can be wekan-db, mongodb or something else.
1) You can run Wekan on Docker locally like this on http://localhost:8080/
(or other port it you change 8080 in script):
```bash
docker run -d --restart=always --name wekan-db mongo:3.2.18
docker run -d --restart=always --name wekan-app --link "wekan-db:db" -e "MONGO_URL=mongodb://db" -e "ROOT_URL=http://localhost:8080" -p 8080:80 wekanteam/wekan:latest
```
2) List docker containers, your ID:s will be different:
```bash
docker ps
```
Result:
```bash
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1234wekanid wekanteam/wekan:latest "/bin/sh -c 'bash $ME" About an hour ago Up 46 minutes 0.0.0.0:8080->80/tcp wekan-app
4321mongoid mongo "/entrypoint.sh mongo" About an hour ago Up 46 minutes 27017/tcp wekan-db
```
3) Enter inside mongo container:
```bash
docker exec -it wekan-db bash
```
4) OPTIONAL: If you want to browse data inside container, you can use CLI commands like listed at
https://docs.mongodb.com/manual/reference/mongo-shell/
like this:
```bash
> mongo <==== START MONGO CLI
MongoDB shell version: 3.2.18
connecting to: test
Server has startup warnings:
2016-06-25T11:39:55.913+0000 I CONTROL [initandlisten]
2016-06-25T11:39:55.913+0000 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2016-06-25T11:39:55.913+0000 I CONTROL [initandlisten] ** We suggest setting it to 'never'
2016-06-25T11:39:55.913+0000 I CONTROL [initandlisten]
2016-06-25T11:39:55.913+0000 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2016-06-25T11:39:55.913+0000 I CONTROL [initandlisten] ** We suggest setting it to 'never'
2016-06-25T11:39:55.913+0000 I CONTROL [initandlisten]
> show dbs <=== SHOW DATABASES
admin 0.034GB
local 0.000GB
> use admin <=== CHANGE TO USE ADMIN DATABASE
switched to db admin
> show collections <=== SHOWS TABLES
activities
boards
card_comments
cards
cfs._tempstore.chunks
cfs.attachments.filerecord
cfs_gridfs._tempstore.chunks
cfs_gridfs._tempstore.files
cfs_gridfs.attachments.chunks
cfs_gridfs.attachments.files
esCounts
lists
meteor-migrations
meteor_accounts_loginServiceConfiguration
presences
users
> db.users.find() <=== LISTS ALL USERS
(list of all users here)
> exit <=== EXIT MONGO CLI
```
5) Go to / directory:
```bash
cd /
```
6) Backup database to files inside container to directory /dump, only Wekan database with name "wekan" is included, not local:
```bash
mongodump -o /dump/
```
7) Exit from inside of container:
```bash
exit
```
8) Copy backup directory /dump from inside of container to current directory:
```bash
docker cp wekan-db:/dump .
```
9a) Restore backup later (restore from /data/dump):
```bash
docker cp dump wekan-db:/data/
docker exec -it wekan-db bash
cd /data
## Only if you get errors about existing indexes, use this instead:
## mongorestore --drop --noIndexRestore --db wekan /data/dump/wekan/
mongorestore --drop --db wekan /data/dump/wekan/
exit
```
That dbname can be for example wekan:
```
## Only if you get errors about existing indexes, use this instead:
## mongorestore --drop --noIndexRestore --db wekan /data/dump/wekan/
mongorestore --drop --db wekan /data/dump/wekan/
```
9b) Or restore to another mongo database, in different port:
```bash
mongorestore --port 11235
```
10) If you would like to browse mongo database that is outside of docker in GUI, you could try some admin interface:
https://docs.mongodb.com/ecosystem/tools/administration-interfaces/
11) If you sometime after backups want to remove wekan containers to reinstall them, do (CAREFUL):
```bash
docker stop wekan-app wekan-db
docker rm wekan-app wekan-db
```
Then you can reinstall from step 1.
12) If latest version of Wekan Docker image is broken, here's how to run older version:
https://github.com/wekan/wekan/issues/659
## Backup and restore scripts
Edit these to suit your own requirements - they will delete backups older than 7 days.
Backup Script
```bash
#!/bin/bash
DATE=$(date +%Y-%m-%d-%H-%M)
SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
cd $SCRIPTPATH
mkdir -p backups/$DATE
docker ps -a | grep 'wekan-db' &> /dev/null
if [ $? = 0 ]; then
docker exec -t wekan-db bash -c "rm -fr /dump ; mkdir /dump ; mongodump -o /dump/"
docker cp wekan-db:/dump $SCRIPTPATH/backups/$DATE
tar -zc -f backups/$DATE.tgz -C $SCRIPTPATH/backups/$DATE/dump wekan
if [ -f backups/$DATE.tgz ]; then
rm -fr backups/$DATE
find $SCRIPTPATH/backups/ -name "*.tgz" -mtime +7 -delete
fi
else
echo "wekan-db container is not running"
exit 1
fi
```
Restore Script
```bash
#!/bin/bash
if [ $# -eq 0 ]
then
echo "Supply a path to a tgz file!"
exit 1
fi
SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
DATE=$(basename $1 .tgz)
docker ps -a | grep 'wekan-db' &> /dev/null
if [ $? = 0 ]; then
if [ -f $1 ]; then
docker stop wekan-app
mkdir -p $SCRIPTPATH/backups/$DATE-restore
tar -zx -f $1 -C $SCRIPTPATH/backups/$DATE-restore
docker exec -t wekan-db bash -c "rm -fr /restore ; mkdir /restore"
docker cp $SCRIPTPATH/backups/$DATE-restore/wekan wekan-db:/restore
## Only if you get errors about existing indexes, use this instead:
## docker exec -t wekan-db bash -c "mongorestore --drop --noIndexRestore --db wekan /restore/wekan/"
docker exec -t wekan-db bash -c "mongorestore --drop --db wekan /restore/wekan/"
docker start wekan-app
fi
else
echo "wekan-db container is not running"
exit 1
fi
```

237
docs/wekan.wiki/Export-from-Wekan-Sandstorm-grain-.zip-file.md Normal file
View file

@ -0,0 +1,237 @@
TODO: [Feature Request: command line utility to convert between Standalone Wekan MongoDB database, and Sandstorm grain .zip file](https://github.com/wekan/wekan/issues/1695)
This is useful for example if you get [Board not found error](https://github.com/wekan/wekan/issues/1430)
Using Ubuntu 18.04 or Mint 19.1 or Ubuntu for Windows Subsystem for Linux:
## 1) Install required packages:
```
sudo apt-get install zip unzip p7zip-full wget
```
## 2) If you don't have Meteor 1.6.0.1 installed, download it to your home directory, and unarchive it
```
cd
wget https://releases.wekan.team/dev/repair/meteor-repair.7z
7z x meteor-repair.7z
```
## 3) Install MongoDB 3.2.22
https://docs.mongodb.com/v3.2/tutorial/install-mongodb-on-ubuntu/
## 4) Download Wekan grain
Use Sandstorm arrow down button to download Wekan grain in .zip file to your home directory.
## 5) Unzip downloaded file
```
unzip "YOUR-GRAIN-NAME-HERE.zip"
```
## 6) Repair database, if it does not open
```
.meteor/packages/meteor-tool/1.6.0_1/mt-os.linux.x86_64/dev_bundle/mongodb/bin/mongod --dbpath "./YOUR-GRAIN-NAME-HERE/data/wiredTigerDb" --repair
```
## 7) (Note to self about future versions of Meteor and Wekan)
Currently Wekan uses Meteor 1.6.0.1. In .meteor/packages/meteor-tool/ directory is also some 1.8.x version for upcoming Wekan version using Meteor 1.8.x. This .meteor directory has been generated by installing meteor from www.meteor.com and then upgrading some existing or new app with for example `meteor update --release 1.6.0.1` so that correct version of Meteor is downloaded.
## 8) Stop MongoDB
```
sudo systemctl stop mongod
```
## 9) Copy repaired database to MongoDB raw files and start MongoDB
```
sudo su
cd /var/lib
mv mongodb mongodb-original
cp -pR "/home/YOUR-USERNAME/YOUR-GRAIN-NAME-HERE/data/wiredTigerDb" .
mv wiredTigerDb mongodb
chown mongodb:mongodb mongodb -R
systemctl start mongod
exit
```
## 10) Browse database with MongoDB CLI
```
mongo
show dbs
use meteor
show collections
db.users.find();
exit
```
## 11a) Dump database to MongoDB dump format
```
mongodump --db meteor
```
## 11b) Dump database to JSON text files
Save this to `dump-json.sh` and then `chmod +x dump-json.sh && ./dump.sh meteor filesdir`
Script is originally [from this Rocket.Chat issue](https://forums.rocket.chat/t/big-issue-with-custom-javascript/261/4)
```
#!/bin/bash
if [ ! $1 ]; then
echo " Example of use: $0 database_name [dir_to_store]"
exit 1
fi
db=$1
out_dir=$2
if [ ! $out_dir ]; then
out_dir="./"
else
mkdir -p $out_dir
fi
tmp_file="fadlfhsdofheinwvw.js"
echo "print('_ ' + db.getCollectionNames())" > $tmp_file
cols=`mongo $db $tmp_file | grep '_' | awk '{print $2}' | tr ',' ' '`
for c in $cols
do
mongoexport -d $db -c $c -o "$out_dir/exp_${db}_${c}.json"
done
rm $tmp_file
```
It's also possible to restore JSON files like described [at stackoverflow](https://stackoverflow.com/questions/11255630/how-to-export-all-collection-in-mongodb) this way, but because userIDs etc can be different, there is no mapping to other users, so you may need to change JSON files some way:
```
for file in *.json; do c=${file#*exp_yourdbname_}; c=${c%.json}; mongoimport --db yourdbname --collection "${c}" --file "${file}"; done
```
## 12) Save attachments to files
[Download NoSQLBooster GUI webpage](https://nosqlbooster.com/downloads)
If you download AppImage for Linux, run it with:
```
chmod +x nosqlbooster4mongo*.AppImage
./nosqlbooster... (full filename here)
```
It can install NoSQLbooster to Linux Menu/Programming/NoSQLBooster for MongoDB.
With it connect to localhost:27017
Double click `cfs_gridfs.attachments.files` and right click filename and Download file.
<img src="https://wekan.github.io/nosqlbooster.png" width="100%" alt="Wekan logo" />
## 13) Optional: Restore
a) Restore data to Standalone Wekan Snap
b) Figure out how to make Sandstorm grain .zip file
***
## OLD CONTENT, TO BE CLEANED UP SOMETIME
## 5) Copy database files from unzipped Wekan grain to MongoDB
In .zip file database files are in directory `data/wiredTigerDb/`
In Wekan Snap, database files are in directory `/var/snap/wekan/common` - if you have other data there, rename common directory to other name first.
[Snap Backup and Restore](https://github.com/wekan/wekan-snap/wiki/Backup-and-restore)
[Docker Backup and Restore](Export-Docker-Mongo-Data)
## 6) Change database file permissions to root user
In Snap:
```
sudo chown root:root /var/snap/wekan/common -R
```
## 7) Start MongoDB
In Snap:
```
sudo snap start wekan.mongodb
```
## 8) Or, if you are brave, also start standalone wekan
Try does Standalone Wekan work with that database
```
sudo snap start wekan.mongodb
sudo snap start wekan.wekan
```
or both wekan and database at once
```
sudo snap start wekan
```
## 9) To see MongoDB data, install Robo3T GUI
https://robomongo.org
Wekan Snap: Connect it to address `localhost:27019`
Wekan Docker: If you have MongoDB exposed to outside Docker, Connect with Robo3T to address `localhost:27017`. Otherwise you first need to copy files from wekan-db Docker container to outside of Docker container, and restore files to local separately installed MongoDB database v3.2.20 or newer
[Snap Backup and Restore](https://github.com/wekan/wekan-snap/wiki/Backup-and-restore)
[Docker Backup and Restore](Export-Docker-Mongo-Data)
## 10) Browse data in Robo 3T
- On left, double click cards, checklists etc collections/tables to see their contents
- Currently default view to see is tree view. To see table view or JSON view, click small buttons above that white data area view display at near right border.
## 11) If you don't find data in Robo 3T, use hex editor GUI
In Linux, you can install Hex Editor for example with command:
```
sudo apt install ghex
```
or
```
sudo yum install ghex
```
Then it's usually in Linux desktop at Menu / Development / GHex.
Or you can start it in command line by writing `ghex`
You can open files from your unzipped Wekan Sandstorm grain directory `data/wiredTigerDb/` to see if there is still some data that is not yet overwritten with other data.
## 12) Moving data from Sandstorm to Standalone Wekan like Snap or Docker
12.1 Compare databases of Sandstorm and Docker Wekan with mongo GUI https://nosqlbooster.com/
12.2 Create new user to Standalone Wekan
12.3 Copy new user bcrypt password structure created bcrypt encrypted password from Sandstorm to Docker wekan structure. It's at users collection/table. Also add isAdmin=true boolean.
12.4 Login
12.5 Here is info about script how to save all from MongoDB to .JSON textfiles https://forums.rocket.chat/t/big-issue-with-custom-javascript/261/4
and most likely how to get them back to mongodb
so just copying all of those boards JSON files and restoring to MongoDB database would work
and editing JSON files with any plain text editor. For big files you can try JEdit.
12.6 Here is how to backup and restore mongodb in docker, snap etc https://github.com/wekan/wekan/wiki/Backup
12.7 All Wekan Docker settings are in this textfile https://raw.githubusercontent.com/wekan/wekan/devel/docker-compose-build.yml
12.8 Database name in Sandstorm is meteor, and in docker is wekan, so here is how to restore with different database name https://stackoverflow.com/questions/36321899/mongorestore-to-a-different-database
## Azure links
https://docs.microsoft.com/en-us/azure/container-service/dcos-swarm/container-service-swarm-mode-walkthrough
https://docs.docker.com/docker-cloud/cloud-swarm/create-cloud-swarm-azure/
https://docs.atlas.mongodb.com/reference/microsoft-azure/

221
docs/wekan.wiki/FAQ.md Normal file
View file

@ -0,0 +1,221 @@
> **»The only stupid question is the one that is not asked.«**
> *– Hull, E., K. Jackson, et al. (2005).*
## About Wekan
Wekan is an completely Open Source and Free software
collaborative [kanban board](https://en.wikipedia.org/wiki/Kanban_board) application with MIT license.
Whether you’re maintaining a personal todo list, planning your holidays with some friends,
or working in a team on your next revolutionary idea, Kanban boards are an unbeatable tool
to keep your things organized. They give you a visual overview of the current state of your project,
and make you productive by allowing you to focus on the few items that matter the most.
Since Wekan is a free software, you don’t have to trust us with your data and can
install Wekan on your own computer or server. In fact we encourage you to do
that by providing one-click installation on various platforms.
- Wekan is used in [most countries of the world](https://snapcraft.io/wekan).
- Wekan largest user has 30k users using Wekan in their company.
- Wekan has been [translated](https://app.transifex.com/wekan/) to about 70+ languages.
- [Features](Features): Wekan has real-time user interface.
- [Platforms](Platforms): Wekan supports many platforms.
Wekan is critical part of new platforms Wekan is currently being integrated to.
- [Integrations](Integrations): Current possible integrations and future plans.
## About niche of WeKan
It's a very specific niche, with limited amount competitors, with all of this applied combined:
- Kanban with very many features, polish and usability
- Permissive MIT license (if some other changes to GPL, Open Core, has https://sso.tax , is propietary etc, it's not in same niche anymore)
- Self-hosted (or SaaS)
- All code https://github.com/wekan/wekan and docs https://github.com/wekan/wekan/wiki Open Source
- Available for many OS and CPU platforms, listed at download/install section of https://wekan.github.io
- Translated to 70+ languages at https://app.transifex.com/wekan
- Has optional affordable Commercial Support for Features/Fixes/Support/Hosting available https://wekan.team/commercial-support/ that funds development of WeKan. Commercial Support provides private support chat with maintainer of WeKan.
- Is actively maintained with major features and fixes being added
- Does not include any enabled telemetry or externally loaded dependencies by default, it does not ping home. Only Snap platform has number of servers per country counted by Canonical that provides Snap store https://snapcraft.io/wekan , not any more specific details.
- Alternative to Enterprise software that can cost 500k euro per year
## Requirements
- 64bit: Linux [Snap](https://github.com/wekan/wekan-snap/wiki/Install) or [Sandstorm](https://sandstorm.io) /
[Mac](Mac) / [Windows](Install-Wekan-from-source-on-Windows).
[More Platforms](Platforms). [ARM progress](https://github.com/wekan/wekan/issues/1053#issuecomment-410919264).
- 1 GB RAM minimum free for Wekan. Production server should have miminum total 4 GB RAM.
For thousands of users, for example with [Docker](https://github.com/wekan/wekan/blob/main/docker-compose.yml): 3 frontend servers,
each having 2 CPU and 2 wekan-app containers. One backend wekan-db server with many CPUs.
- Enough disk space and alerts about low disk space. If you run out disk space, MongoDB database gets corrupted.
- SECURITY: Updating to newest Wekan version very often. Please check you do not have automatic updates of Sandstorm or Snap turned off.
Old versions have security issues because of old versions Node.js etc. Only newest Wekan is supported.
Wekan on Sandstorm is not usually affected by any Standalone Wekan (Snap/Docker/Source) security issues.
- [Reporting all new bugs immediately](https://github.com/wekan/wekan/issues).
New features and fixes are added to Wekan [many times a day](https://github.com/wekan/wekan/blob/main/CHANGELOG.md).
- [Backups](Backup) of Wekan database once a day miminum.
Bugs, updates, users deleting list or card, harddrive full, harddrive crash etc can eat your data. There is no undo yet.
Some bug can cause Wekan board to not load at all, requiring manual fixing of database content.
## What is Wekan Team?
[Wekan Team](https://wekan.team) is Wekan Commercial Support company run by CEO [xet7](https://github.com/xet7), current maintainer of Wekan. xet7 does respond to feedback at GitHub issues very actively, because Wekan is community driven Open Source project. Because conflicting opinions can not be implemented, sometimes xet7 has to behave like a benevolent dictator. Every Wekan team member is free to choose what to contribute and when. We can not force anybody to implement anything. Wekan development speed increases when new Wekan contributors join and start to send PRs to existing and new issues.
## How to convince my company management that Wekan "is less evil" than Trello?
Yes, xet7 received this question in Email.
Trello:
- Code is proprietary. Only Atlassian personnel has access Trello source code.
- You can not install Trello to your own servers.
- Trello has access to all of your data.
- You can not run Trello in internal network that is not connected to Internet.
Wekan:
- All Wekan code is Open Source at https://github.com/wekan/wekan with MIT license, free also for commercial use.
- You don't need to pay monthly fee for using Wekan. Only if you need Commercial Support https://wekan.team for some bugfix, feature or integration, you can pay for that.
- You can download all Wekan code and run in internal network that is not connected to Internet. You can keep all your data to yourself.
- Snap/Docker/Sandstorm versions runs inside sandbox and does not have any access to elsewhere on server filesystem.
- Snap version of Wekan is built directly from https://github.com/wekan/wekan repo on Canonical's build service that does security checks etc.
- Docker version of Wekan is built directly from https://github.com/wekan/wekan by [Quay](https://quay.io/wekan/wekan) and [Docker Hub](https://hub.docker.com/r/wekanteam/wekan/) and they do security checks etc.
- Sandstorm version is checked by [ocdtrekkie](https://github.com/ocdtrekkie) that it does not break anything, before he lets new version of Wekan into [Sandstorm App Market](https://apps.sandstorm.io/app/m86q05rdvj14yvn78ghaxynqz7u2svw6rnttptxx49g1785cdv1h).
- Wekan does not load any files from Internet, when starting Wekan. For further restrictions, you could on internal server only allow incoming and outgoing traffic from
on internal server firewall to those computers that need to use Wekan.
- There is contributors to Wekan from all over the world, that add fixes and features to Wekan.
- There has been some code reviews done by security researchers https://wekan.github.io/hall-of-fame/ and there has been fixes to Wekan related to that.
- xet7 tries to be less evil by trying to listen to some user feedback. For example, someone suggested [inner shadow](https://github.com/wekan/wekan/issues/1690), so it was added, but because of feedback from users inner shadow was removed. Same with removing and adding back [SMTP settings in Admin Panel](https://github.com/wekan/wekan/issues/1790). Unfortunately it's not possible to make everyone happy because different people have different opinions, so xet7 tries to select something that makes some sense. Improvement suggestions welcome.
## When new version of Wekan will be released? When my pull request will be tested, commented or merged?
Usually:
* Fastest: multiple times a day. Sometimes this is 7 releases per day. This is usually because some bug is found and new releases are done in rapid schedule until bug is fixed. Also sometimes there is many new pull requests per day, or fast pace of adding new features. This is like said by Eric S. Raymond: ["Release early. Release often. And listen to your customers."](https://en.wikipedia.org/wiki/Release_early,_release_often)
* Slowest: Once a month.
* One release contains anything from one typo fix to many major features and bugfixes.
For [Wekan Platforms](Platforms), it means these choices:
* Snap: You get updates automatically immediately, or updates automatically scheduled at midnight
* Source/Docker/VirtualBox: You need to test and install new Wekan version yourself
* Sandstorm: ocdtrekkie tests before releasing to Sandstorm App Market, and you backup your grains and upgrade by clicking upgrade button when you wish
## What Wekan version number means?
* Every release has release date and release number.
* Every release increments release number by 0.01. This practise started at 2017-03-05 v0.12. Before it release number was much more compicated like v0.11.1-rc2. After v0.99 comes v1.00, v1.01, v1.02, etc.
* Version number is only incrementing number. Wekan has been in production use for a long time already, so v1.00 is not about being production ready. There has been many performance improvements, but there is still a lot to improve.
* Wekan still has bugs, like any other software. So this is not about being bug free.
* Wekan will keep changing, and providing migrations from old to newest version. In that sense, Wekan has been LTS release as long as it's been maintained already. There have been many fixes to make migrations possible, and adding more fixes will continue.
* Development happens in in edge branch. When release is made, edge branch is merge merged to devel/master/meteor-1.8 branches.
# Features
## Will my feature request be implemented?
There are alternative ways to have your feature implemented:
a) [Commercial Support](https://wekan.team/commercial-support/)
b) Pay someone from your company or some other developer to code feature and submit as pull request
c) Develop feature yourself and submit it as pull requests to devel [Wekan repo](https://github.com/wekan/wekan) branch.
[According to Open Hub](https://www.openhub.net/p/wekan), Wekan code is only about 10500 lines without Meteor.js framework and NPM modules, so it's very small when comparing to other software, and quite logically organized. With git history viewer like gitk it's possible to see how different features are implemented.
For Sandstorm-specific features, have the feature enabled in Sandstorm by using environment variable isSandstorm = true like is at wekan/sandstorm.js .
In wiki there is [Developer Documentation](Developer-Documentation).
## Will you accept my pull request?
We totally rely on pull requests for new features and bug fixes. If your pull request works, it's very likely to be accepted by xet7.
## How can I contribute to Wekan?
We’re glad you’re interested in helping the Wekan project! We welcome bug reports, enhancement ideas, and pull requests, in our GitHub bug tracker. Have a look at the [[Contributing notes|developer-documentation]] for more information how you can help improve and enhance Wekan. We are working to make it possible to have bounties for features. We welcome sponsors.
## Are there any tests?
There are near to zero tests, because nobody has contributed tests as pull request.
## Is there a plugin system?
No. It's not possible in web browser to a) Install npm modules inside Docker or b) Install code afterwards on Sandstorm, because application code is read-only and signed. All features in code are built in, and all data related to features is stored on MongoDB.
## Can Wekan be rewritten in another programming language?
[xet7 tried to rewrite, but it's only at very early steps](https://github.com/wekan/demo/wiki/Roadmap).
# History
## Weren't you called Libreboard before?
Yes, Libreboard was the old project name, which superseded the even older project name Metrello. As the original name suggests, Metrello was a Trello clone built with Meteor. It used a lot of the original assets from Trello and even the name was very similar. When the project turned more mature and gained more interest by the community, this was obviously a [problem]. To get its own identity and due to a DMCA from Trello, efforts started to [redesign] Metrello, which also included to find a new name and so Maxime Quandalle came up with “OpenBoard”, to underline the open source nature of the project. Unfortunately the com domain was already taken and so she replaced the Open with Libre, which stands for free (as in freedom) in many Latin derived languages.
After renaming it to Libreboard, a [new logo] was designed and the project continued to live on as Libreboard. Unfortunately it turned out, that the new logo was apparently ripped-off from a [concept] published at Dribbble, and so a new logo had to be found. There were a lot of [ideas from the community][logo-ticket], and at the end Maxime [proposed][wekan-proposal] a completely new name, Wekan, together with a design proposal for a new logo.
## What was Wekan fork / Wefork?
After 2016-09-02 there were no pull requests reviewed and integrated for nearly 2 months. At 2016-10-20 Wekan community created fork and started merging many bugfixes and new features into Wefork. 2017-01-29 Wekan author mquandalle gave access to Wekan and at 2017-01-31 xet7 started merging Wefork back to Wekan. 2017-02-08 All of Wefork is now merged and moved back to official Wekan. Wefork will not accept any new issues and pull requests. All development happens on Wekan. [Wefork announcement and merging back](https://github.com/wekan/wekan/issues/640#issuecomment-276383458), more info: [Team](Team)
## What is the difference between Wekan and Trello?
The main difference between the two is that Wekan is completely open source and available under the permissive MIT license. That makes it possible to host it on your own server (or your company's or organization's server) and you keep the full control over all data. No need to fear it will disappear some day, like a commercial service like Trello could.
Additionally the long term goal is to have features that are not available on Trello or other alternatives, making Wekan flexible and suitable for complex project organizations.
## Why does Wekan look so different now compared to < v0.9?
Wekan started as a just for fun project to explore meteor and its features and the initial version had a lot of the Trello assets (CSS, Images, Fonts) in it and copied a lot of its design. Due to an DMCA takedown notice and obviously to get its own identity, the old design was dropped after v0.8 and a new UI was developed
See the related tickets [#92] and [#97] for more information.
[#92]: https://github.com/wekan/wekan/issues/92
[#97]: https://github.com/wekan/wekan/issues/97
# Etiquette
## Why am I called a troll?
* You use word "shame", that means you would like to have a feature or fix without contributing any code or payment yourself, worded in a way to make it itch conscience.
* You want a feature, but you add thumbs down emoji reactions
* You are adding image reactions
* You want priorities changed. Current priorities are:
* [High priority](https://github.com/wekan/wekan/issues?q=is%3Aissue+is%3Aopen+label%3AHigh-priority): security issues and high severity bugs
* Medium priority: Import/Export
* Others. Actual roadmap will be updated later.
* You write that you are providing constructive criticism
* You think that free software includes free implemented features
* You are adding something other than:
* Thumbs up reactions to existing posts
* Feature specs
* Technical details
* Links to related documentation
* Links to example code to get a feature implemented
* Pull requests
## Why am I called a spammer?
* You are adding new comments that have only content like:
* +1
* +1 I can confirm this
* +1 It would be great to have this
* +1 This is the only feature for preventing my company to move to Wekan
* You are adding something other than:
* Thumbs up reactions to existing posts
* Feature specs
* Technical details
* Links to related documentation
* Links to example code to get a feature implemented
* Pull requests
## What you should do if you see a troll or a spammer?
Add only one link to this FAQ. Do not in any way comment or feed the trolls.
[problem]: https://github.com/wekan/wekan/issues/92
[redesign]: https://github.com/wekan/wekan/issues/94
[new logo]: https://github.com/wekan/wekan/issues/64#issuecomment-69005150
[concept]: https://dribbble.com/shots/746215-Pigeon
[logo-ticket]: https://github.com/wekan/wekan/issues/64#issuecomment-74357809
[wekan-proposal]: https://github.com/wekan/wekan/issues/64#issuecomment-135221046
---
# Sandstorm
## What Sandstorm is not anymore?
Not a Company, Not a Startup, Not a Product with Enterprise version. Everything is now [Open Source](https://en.wikipedia.org/wiki/Open-source_software) and [Free software](https://en.wikipedia.org/wiki/Free_software).
## What is Sandstorm?
[Sandstorm](https://sandstorm.io) is a open-source and free software security audited platform with grains, logging, admin settings, server clustering and App Market. App Market has Wekan as installable App. SSO options like LDAP, passwordless email, SAML, GitHub and Google Auth are already available on Sandstorm. Sandstorm is preferred platform for Wekan, as it would take a lot of work to reimplement everything in standalone Wekan.
## How can you contribute to Sandstorm?
See [Sandstorm website about contributing pull requests](https://sandstorm.io) and [returning to Open Source community roots, including donation info](https://sandstorm.io/news/2017-02-06-sandstorm-returning-to-community-roots).

228
docs/wekan.wiki/Features.md Normal file
View file

@ -0,0 +1,228 @@
# Current
Not all from [CHANGELOG](https://github.com/wekan/wekan/blob/main/CHANGELOG.md) are added to here yet.
## Kanban
### WIP Limits
![Wekan WIP Limits screenshot](https://wekan.github.io/screenshot-wip-limit.png)
### Boards: List of all your public and private boards, board shortcuts at top of page
![Wekan boards screenshot](https://wekan.github.io/screenshot-boards.png)
### Wekan full screen or window on desktop (without browser buttons etc)
[Info about browser standalone app mode](https://github.com/wekan/wekan/pull/1184)
### Wekan full screen on mobile Firefox
[Instructions and screenshot](https://github.com/wekan/wekan/issues/953#issuecomment-336537875)
### Restore archived board
![Wekan boards screenshot](https://wekan.github.io/screenshot-restore-board.png)
### Star board
![Wekan star board screenshot](https://wekan.github.io/screenshot-star-board.png)
### Watch board
![Wekan watch board screenshot](https://wekan.github.io/screenshot-muted-watch.png)
### Keyboard shortcuts button at bottom right corner
![Wekan watch board screenshot](https://wekan.github.io/screenshot-keyboard-shortcuts.png)
### Board menu when clicking 3 lines "hamburger" menu on right
![Wekan board menu screenshot](https://wekan.github.io/screenshot-board-menu.png)
### Member setting when clicking your username on top right corner
![Wekan member settings screenshot](https://wekan.github.io/screenshot-member-settings.png)
NOTE: Edit Notification duplicate was removed from above menu at https://github.com/wekan/wekan/pull/1948 so Edit Notification is only available at below menu screenshot.
### Member settings / Edit Notification
![Wekan edit notification screenshot](https://wekan.github.io/screenshot-member-settings-edit-notification.png)
### Member settings / Change settings
![Wekan hide system messages screenshot](https://wekan.github.io/screenshot-member-settings-hide-system-messages.png)
### Members: Click member initials or avatar
![Wekan members screenshot](https://wekan.github.io/screenshot-member-filter.png)
### Members: Click member initials or avatar => Permissions Admin/Normal/Comment only
![Wekan boards permissions screenshot](https://wekan.github.io/screenshot-member-comment-only.png)
### Lists: Add, archive and restore archived, delete list.
![Wekan kanban screenshot](https://wekan.github.io/screenshot-member-settings-archive.png)
### Cards: Description, Customizable Labels, Checklists, Attachment images and files, Comments. Archive and restore archived card. Delete card.
Tip: Normally you archive a card so you can restore it back. If you want to delete cards faster, drag cards to new list, and delete that new list. Deleting cannot be undone, more clicks are by design. There was previously easily clicked button to delete a list and people deleted important list by accident, and that bug report was fixed.
### [Markdown in card description and comments](https://github.com/wekan/wekan/issues/1038)
### [International Date Formatting for Due Date according to language](https://github.com/wekan/wekan/issues/838)
![Wekan kanban screenshot](https://wekan.github.io/screenshot.png)
### Cards: Drag and drop images to card. Paste images with Ctrl-V.
### 1) First attachment: Select Card 3 lines "hamburger" menu / Edit Attachments
![Wekan kanban screenshot](https://wekan.github.io/screenshot-drag1.png)
### 2) Select: Clipboard or drag and drop
![Wekan kanban screenshot](https://wekan.github.io/screenshot-drag4.png)
### 3) Drag and drop image, or Ctrl-V.
![Wekan kanban screenshot](https://wekan.github.io/screenshot-drag2.png)
### 4) Second image attachment and others can be added from Add Attachment button near first attachment.
![Wekan kanban screenshot](https://wekan.github.io/screenshot-drag3.png)
### Multi-selection => Checkmark select cards => drag-drop all selected to some list
![Wekan multi-selection screenshot](https://wekan.github.io/screenshot-multi-selection.png)
### Filtered views
![Wekan multi-selection screenshot](https://wekan.github.io/screenshot-filter.png)
## Authentication, Admin Panel, SMTP Settings
NOTE: There is user admin as "People" in Admin Panel, but no screenshot here yet.
* Source and Docker platforms: [Admin Panel](https://github.com/wekan/wekan/blob/main/CHANGELOG.md#v0111-rc2-2017-03-05-wekan-prerelease): Self-registration, or change to invite-only and inviting users to boards. SMTP Settings.
![Wekan Admin Panel registration disable screenshot](https://wekan.github.io/screenshot-admin-panel-registration.png)
![Wekan Admin Panel email screenshot](https://wekan.github.io/screenshot-admin-panel-email.png)
* Sandstorm Platform: Admin: LDAP, passwordless email, SAML, GitHub and Google Auth. Add and remove users. SMTP Settings. Wekan, Rocket.Chat, etc apps available with one click install.
## Import
* Import Trello board: Text, labels, images, comments, checklists. Not imported yet: stickers, etc.
* [Import Wekan board](https://github.com/wekan/wekan/pull/1117): Text, labels, images, comments, checklists.
## Export
* Export Wekan board: [Export menu item above the board archive item, when you click the sandwich bar icon on the top right](https://github.com/wekan/wekan/pull/1059). If Export menu is not visible, you can change [Export menu to be visible by setting yourself as board admin in MongoDB](https://github.com/wekan/wekan/issues/1060).
## Working with big boards
* [JSON tools, copying files to clipboard](https://github.com/wekan/wekan/issues/610#issuecomment-310862951)
## API
* [REST API Issue](https://github.com/wekan/wekan/issues/1037)
* [REST API Docs](REST-API)
* [Python client to REST API](https://github.com/wekan/wekan-python-api-client)
* [Wekan Sandstorm cards to CSV using Python](Wekan-Sandstorm-cards-to-CSV-using-Python)
## Webhooks
Sending notifications for board activities. Tested with [Slack](https://slack.com/) and [Rocket.chat](https://rocket.chat/).
```
Content-type: application/json
{
"text": "board activities"
[...]
}
```
Different activities send different webhook data. You can find the details in the wiki page [Webhook data](Webhook-data)
* [Outgoing Webhooks](https://github.com/wekan/wekan/pull/1119)
### Enabled
#### 1) Board menu when clicking 3 lines "hamburger" menu on right
![Wekan board menu screenshot](https://wekan.github.io/screenshot-board-menu.png)
#### 2) Outgoing Webhooks
![Wekan Outgoing Webhooks screenshot](https://wekan.github.io/screenshot-outgoing-webhooks.png)
### Disabled
Leave the URL field blank.
## Cleanup
* [Wekan database cleanup script](https://github.com/wekan/wekan-cleanup)
* [Docker cleanup](https://github.com/wekan/wekan/issues/985)
## Stats
* [Daily export of Wekan changes as JSON to Logstash and
ElasticSearch / Kibana (ELK)](https://github.com/wekan/wekan-logstash)
* [Statistics Python script for Wekan Dashboard](https://github.com/wekan/wekan-stats)
* [Console, file, and zulip logger on database changes](https://github.com/wekan/wekan/pull/1010) with [fix to replace console.log by winston logger](https://github.com/wekan/wekan/pull/1033)
## Versions of Meteor and Node
* Upgraded to [Meteor 1.4](https://github.com/wekan/wekan/pull/957) and [Node v4](https://github.com/wekan/wekan/issues/788) on [meteor-1.4 branch](https://github.com/wekan/wekan/tree/meteor-1.4)
## Translations
* [Translate Wekan at Transifex](https://app.transifex.com/wekan/)
![Wekan translations screenshot](https://wekan.github.io/screenshot-change-language.png)
# Already merged, will be at next version
* [Changelog](https://github.com/wekan/wekan/blob/main/CHANGELOG.md)
# Wishes for pull requests
### Existing pull requests, cleanup/cherry-picking/new pull requests welcome
* [Export/Import Excel TSV/CSV data](https://github.com/wekan/wekan/pull/413)
* [Move/Clone Board/List](https://github.com/wekan/wekan/pull/446) and [Move or copy cards from one board to another](https://github.com/wekan/wekan/issues/797) that [needs help in implementation](https://github.com/wekan/wekan/issues/979)
* [Replace CollectionFS with meteor-file-collection](https://github.com/wekan/wekan/pull/875)
### Wishes for API pull requests
* [Using API to script Email to board/card, notifications on cards to email, etc](https://github.com/wekan/wekan/issues/794)
### Wishes for Admin Panel
* [SMTP test, show possible errors on that test webpage](https://github.com/wekan/wekan/issues/949)
* [Teams/Organizations](https://github.com/wekan/wekan/issues/802) including Add/Modify/Remove Teams/Users/Passwords and Private/Public Team settings
* [Themes](https://github.com/wekan/wekan/issues/781) and making custom apps with Themes
### Wishes for Boards
* [Custom fields](https://github.com/wekan/wekan/issues/807)
* [Children/Related cards](https://github.com/wekan/wekan/issues/709), subtasks. Dependencies.
* [Top Level Projects](https://github.com/wekan/wekan/issues/641)
* [Swimlanes (rows)](https://github.com/wekan/wekan/issues/955)
* Kanban workflows
* Gantt charts
* [WIP limits](https://github.com/wekan/wekan/issues/783)
* [Timesheet/Time tracking](https://github.com/wekan/wekan/issues/812)
* Managing website
* [Same cards, multiple column sets](https://github.com/wekan/wekan/issues/211), related to [Themes](https://github.com/wekan/wekan/issues/781)
* [Calendar view](https://github.com/wekan/wekan/issues/808)
* [Vote on cards, number of votes, average](https://github.com/wekan/wekan/issues/796)
* [Board templates](https://github.com/wekan/wekan/issues/786)
* [Checklist templates](https://github.com/wekan/wekan/issues/904)
# More
[Platforms](Platforms)
[Integrations](Integrations)

209
docs/wekan.wiki/Forgot-Password.md Normal file
View file

@ -0,0 +1,209 @@
## Snap
**a) Wekan Snap**
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan/current/lib/x86_64-linux-gnu
export PATH="$PATH:/snap/wekan/current/bin"
mongo --port 27019
```
If you have disabled new user registration at Admin Panel, you can enable it, and create new user your https://wekan.example.com/sign-up :
```
db.settings.update({},{$set: {"disableRegistration":false}})
```
Find what users there are:
```
db.users.find()
```
Set some user as admin:
```
db.users.update({username:'admin-username-here'},{$set:{isAdmin:true}})
```
Check are there any failed logins with wrong password, that brute force login prevention has denied login:
```
db.AccountsLockout.Connections.find()
```
If there are, delete all those login preventions:
```
db.AccountsLockout.Connections.deleteMany({})
```
Then exit:
```
exit
```
Then login to Wekan and change any users passwords at `Admin Panel / People / People`.
**b) Wekan Gantt GPL Snap**
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/snap/wekan-gantt-gpl/current/lib/x86_64-linux-gnu
export PATH="$PATH:/snap/wekan-gantt-gpl/current/bin"
mongo --port 27019
```
If you have disabled new user registration at Admin Panel, you can enable it, and create new user your https://wekan.example.com/sign-up :
```
db.settings.update({},{$set: {"disableRegistration":false}})
```
Find what users there are:
```
db.users.find()
```
Set some user as admin:
```
db.users.update({username:'admin-username-here'},{$set:{isAdmin:true}})
```
Check are there any failed logins with wrong password, that brute force login prevention has denied login:
```
db.AccountsLockout.Connections.find()
```
If there are, delete all those login preventions:
```
db.AccountsLockout.Connections.deleteMany({})
```
Then exit:
```
exit
```
Then login to Wekan and change any users passwords at `Admin Panel / People / People`.
**c) Use DBGate or Nosqlbooster** to edit wekan database users table to have admin true:
- https://github.com/wekan/wekan/wiki/Backup#dbgate-open-source-mongodb-gui
- https://github.com/wekan/wekan/wiki/Forgot-Password
## Set user as BoardAdmin on all boards user is member of
[Source](https://github.com/wekan/wekan/issues/2413#issuecomment-1239249563)
```
db.boards.updateMany(
{ members: { $elemMatch: { userId: “USER-ID-HERE”, isAdmin: false } } },
{
$set: { “members.$.isAdmin”: true },
}
);
```
## Docker
1. Change to inside of wekan database Docker container:
```
docker exec -it wekan-db bash
```
2. Start MongoDB Shell
```
/bin/mongosh
```
3. List databases
```
show dbs
```
4. Change to wekan database
```
use wekan
```
5. Show collections/tables
```
show collections
```
6. Count users
```
db.users.count()
```
7. If you have disabled new user registration at Admin Panel, you can enable it, and create new user your https://wekan.example.com/sign-up :
```
db.settings.update({},{$set: {"disableRegistration":false}})
```
8. Find what users there are:
```
db.users.find()
```
9. Set some user as admin:
```
db.users.update({username:'admin-username-here'},{$set:{isAdmin:true}})
```
10. Check are there any failed logins with wrong password, that brute force login prevention has denied login:
```
db.AccountsLockout.Connections.find()
```
11. If there are, delete all those login preventions:
```
db.AccountsLockout.Connections.deleteMany({})
```
12. Then exit:
```
exit
```
13. Then login to Wekan and change any users passwords at `Admin Panel / People / People`.
More info:
- https://github.com/wekan/wekan/wiki/Backup
- https://github.com/wekan/wekan/wiki/Docker
***
## OLD INFO BELOW:
1) Download [Robo 3T](https://robomongo.org) on your Linux or Mac computer. Or, using ssh shell to server, [login to MongoDB database using mongo cli](Backup#mongodb-shell-on-wekan-snap)
2) Make SSH tunnel to your server, from your local port 9000 (or any other) to server MongoDB port 27019:
```
ssh -L 9000:localhost:27019 user@example.com
```
3) Open Robo 3T, create new connection: Name, address: localhost : 9000
a) If you don't have self-registration disabled, register new account at /sign-up, and make yourself admin in MongoDB database:
1) Use database that has wekan data, for example:
```
use wekan
```
2) Add Admin rights to some Wekan username:
```
db.users.update({username:'admin-username-here'},{$set:{isAdmin:true}})
```
b) If someone else remembers their password, and his/her login works, copy their bcrypt hashed password to your password using Robo 3T.
c) Install Wekan elsewhere, create new user, copy bcrypt hashed password to your password.
d) Backup, New install, Create User, Copy Password, Restore:
1. [Backup Snap](https://github.com/wekan/wekan-snap/wiki/Backup-and-restore)
2. stop wekan `sudo snap stop wekan.wekan`
3a. Empty database by dropping wekan database in Mongo 3T
3b. Empty database in [mongo cli](mongo cli](Backup#mongodb-shell-on-wekan-snap):
```
mongo --port 27019
```
Look what databases there are:
```
show dbs
```
Probably database is called wekan, so use it:
```
use wekan
```
Delete database:
```
db.dropDatabase()
```
4. Start wekan:
```
sudo snap stop wekan.wekan
```
5. Register at /sign-up
6. Copy bcrypt hashed password to text editor
7. [Restore your backup](https://github.com/wekan/wekan-snap/wiki/Backup-and-restore)
8. Change to database your new bcrypt password.
## Don't have Admin Rights to board
1. In Robo 3T, find where your ID that your username has:
```
db.getCollection('users').find({username: "YOUR-USERNAME-HERE"})
```
2. Find board where you are not admin, using user ID you found above:
```
db.getCollection('boards').find({members: {$elemMatch: { userId: "YOUR-USER-ID-HERE", isAdmin: false} } })
```
And set yourself as admin.

8
docs/wekan.wiki/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

214
docs/wekan.wiki/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:

26
docs/wekan.wiki/From-Previous-Export.md Normal file
View file

@ -0,0 +1,26 @@
## Paste big JSON in Linux
1. Copy WeKan board JSON to clipboard
```
sudo apt install xclip
cat board.json | xclip -se c
```
2. At some Chromium-based browser, click right top your username / All Boards / New Board / From Previous Export.
3. At input field, right click / Paste as Text.
4. Click Import.
## JSON to SQLite3
```
sqlite3 wekan.db
.mode json
.load wekan-export-board.json board
```
To be continued

123
docs/wekan.wiki/Gantt.md Normal file
View file

@ -0,0 +1,123 @@
# What is this?
Original WeKan is MIT-licensed software.
This different Gantt version here currently uses Gantt chart component that has GPL license, so this Wekan Gantt version is GPL licensed.
Sometime later if that GPL licensed Gantt chart component will be changed to MIT licensed one, then that original MIT-licensed WeKan will get Gantt feature, and maybe this GPL version will be discontinued.
# How to use
[Source](https://github.com/wekan/wekan/issues/2870#issuecomment-721690105)
At cards, both Start and End dates should be set (not Due date) for the tasks to be displayed.
# Funding for more features?
You can fund development of more features of Gantt at https://wekan.team/commercial-support, like for example:
- more of day/week/month/year views
- drag etc
# Issue
https://github.com/wekan/wekan/issues/2870
# Install
Wekan GPLv2 Gantt version:
- https://github.com/wekan/wekan-gantt-gpl
- https://snapcraft.io/wekan-gantt-gpl
- https://hub.docker.com/repository/docker/wekanteam/wekan-gantt-gpl
- https://quay.io/wekan/wekan-gantt-gpl
## How to install Snap
[Like Snap install](https://github.com/wekan/wekan-snap/wiki/Install) but with commands like:
```
sudo snap install wekan-gantt-gpl
sudo snap set wekan-gantt-gpl root-url='http://localhost'
sudo snap set wekan-gantt-gpl port='80'
```
Stopping all:
```
sudo snap stop wekan-gantt-gpl
```
Stopping only some part:
```
sudo snap stop wekan-gantt-gpl.caddy
sudo snap stop wekan-gantt-gpl.mongodb
sudo snap stop wekan-gantt-gpl.wekan
```
## Changing from Wekan to Wekan Gantt GPL
1) Install newest MongoDB to have also mongorestore available
2) Backup database and settings:
```
sudo snap stop wekan.wekan
mongodump --port 27019
snap get wekan > snap-set.sh
sudo snap remove wekan
sudo snap install wekan-gantt-gpl
sudo snap stop wekan-gantt-gpl.wekan
nano snap-set.sh
```
Then edit that textfile so all commands will be similar to this:
```
sudo snap set wekan-gantt-gpl root-url='https://example.com'
```
And run settings:
```
chmod +x snap-set.sh
./snap-set.sh
sudo snap start wekan-gantt-gpl.wekan
```
## Changing from Wekan Gantt GPL to Wekan
1) Install newest MongoDB to have also mongorestore available
2) Backup database and settings:
```
sudo snap stop wekan-gantt-gpl.wekan
mongodump --port 27019
snap get wekan-gantt-gpl > snap-set.sh
sudo snap remove wekan-gantt-gpl
sudo snap install wekan
sudo snap stop wekan.wekan
nano snap-set.sh
```
Then edit that textfile so all commands will be similar to this:
```
sudo snap set wekan root-url='https://example.com'
```
And run settings:
```
chmod +x snap-set.sh
./snap-set.sh
sudo snap start wekan.wekan
```
# UCS
[Gantt feature at UCS](UCS#gantt)

1
docs/wekan.wiki/Google-Cloud.md Normal file
View file

@ -0,0 +1 @@
Needs info how to enable websockets. Wekan requires working websockets support.

29
docs/wekan.wiki/Google-login.md Normal file
View file

@ -0,0 +1,29 @@
### NOTE: BEFORE 2020-09-07 THERE WAS WRONG SETTING BELOW, IT CAUSED LOGIN WITH WRONG USER, YOU SHOULD FIX YOUR SETTINGS
### CORRECT SETTINGS ARE:
### snap set wekan oauth2-email-map='email'
### snap set wekan oauth2-username-map='email'
[Thanks to @mlazzje for this info below](https://github.com/wekan/wekan/issues/2527#issuecomment-654155289)
To create Google OAuth 2 credentials, you can follow this tutorial: https://developers.google.com/identity/sign-in/web/sign-in
Then replace `CLIENT_ID` and `CLIENT_SECRET` below.
The redirect URL is your Wekan root-url+_oauth/oidc like this: https://boards.example.com/_oauth/oidc
If you have existing password account, and would like to switch to Google auth account, you need to rename that username and email address, so you can autoregister with your Google auth email address. Then share your boards from password account to Google auth account and set that to Google auth user as BoardAdmin.
In your wekan config, you have to set the following information in snap:
```
sudo snap set wekan oauth2-enabled='true'
sudo snap set wekan oauth2-client-id='CLIENT_ID'
sudo snap set wekan oauth2-secret='CLIENT_SECRET'
sudo snap set wekan oauth2-auth-endpoint='https://accounts.google.com/o/oauth2/v2/auth'
sudo snap set wekan oauth2-token-endpoint='https://oauth2.googleapis.com/token'
sudo snap set wekan oauth2-userinfo-endpoint='https://openidconnect.googleapis.com/v1/userinfo'
sudo snap set wekan oauth2-id-map='sub'
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-request-permissions='openid https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email'
```

160
docs/wekan.wiki/Hall-of-Shame:-Fake-companies.md Normal file
View file

@ -0,0 +1,160 @@
[Other things that are not related to WeKan kanban](https://github.com/wekan/wekan/wiki/NOT-related-to-Wekan)
## Description
Lauri Ojansivu (xet7) has [trademark to WeKan](https://www.tmdn.org/tmview/#/tmview/detail/FI50202100052006A), as can be seen from bottom of official WeKan webpage https://wekan.github.io . Official domain is https://wekan.team .
Lauri Ojansivu, as maintainer of WeKan Open Source kanban, has added and removed about [4 million lines of code](https://github.com/wekan/wekan/graphs/contributors) to WeKan since December 2016. All changes to WeKan are at [ChangeLog](https://github.com/wekan/wekan/graphs/contributors). WeKan is used at [most countries of the world](https://wekan.github.com)
Lauri Ojansivu has nickname xet7 at many places at Internet, for example:
- https://github.com/xet7
Problem is, fake companies try to register WeKan these domains, or other domains that have these words:
- wekan
- wekan io, virus page
- wekan cn, fake spam company "WeiRong Holdings Ltd" and "Yongchen Holdings Ltd" trying to register
- xet7
- xet7 cn, fake spam company "WeiRong Holdings Ltd" trying to register
Usually those fake companies setup virus webpages, or other fake webpages.
## Fake mobile apps that do not work
SMI TEAMWORK at [iOS App Store](https://itunes.apple.com/de/app/smi-teamwork/id1232167123?mt=8) and [Google Play Store](https://play.google.com/store/apps/details?id=com.siliconmotion.teamwork) . xet7 has notified them to remove it.
## Fake companies trying to register WeKan domains
### 2023-12-27 From chinaregistrar.org.cn , about "Yongchen Holdings Ltd"
Dear Manager,
(If you are not the person who in charge of this, please forward this to your CEO, because this is urgent. Thanks!)This is a formal email.We are the domain registration and solution center in China.
On December 23, 2023, we received an application from Yongchen Holdings Ltd requested “wekan” as their internet keyword and China (CN) domain names( wekan.cn/ wekan.com.cn/ wekan.net.cn/ wekan.org.cn).
After checking it, we find this name conflict with your company name or trademark.In order to deal with this matter better, we send email to you and confirm whether this company is your distributor or business partner in China?
Best Regards
Jason
### 2023-05-22 From Zhihai Ning, zhihaining at 163 dot com, of WeiRong Holdings Ltd
To whom it concerns,
We will register the China domain names "wekan.cn" "wekan.com.cn" "wekan.net.cn" "wekan.org.cn" and internet keyword "wekan" and have submitted our application. We are waiting for Mr. Frank Liu's approval. These CN domains and internet keyword are very important for us to promote our business in China. Although Mr. Frank Liu advised us to change another name, we will persist in this name.
Kind regards
Zhihai Ning
### 2023-12-18 From chinaregistrar.org.cn , about "WeiRong Holdings Ltd"
Dear Manager,
(If you are not the person who in charge of this, please forward this to your CEO, because this is urgent. Thanks!)This is a formal email.We are the domain registration and solution center in China.
On December 18, 2023, we received an application from WeiRong Holdings Ltd requested “wekan” as their internet keyword and China (CN) domain names( wekan.cn/ wekan.com.cn/ wekan.net.cn/ wekan.org.cn).
After checking it, we find this name conflict with your company name or trademark.In order to deal with this matter better, we send email to you and confirm whether this company is your distributor or business partner in China?
Best Regards
Jason
## Fake companies trying to register xet7 domains
### 2023-12-22 From Hunjun Zhang, hunjun_zhang at 163 dot com, of WeiRong Holdings Ltd
To whom it concerns,
We will register the China domain names “xet7.cn” "xet7.com.cn" "xet7.net.cn" "xet7.org.cn" and internet keyword "xet7” and have submitted our application. We are waiting for Mr.Martin Wang approval and think these CN domains and internet keyword are very important for our business. Even though Mr.Martin Wang advises us to change another name, we will persist in this name.
Best Regards
Hunjun Zhang
### 2023-12-20 From tldschina.com , about "WeiRong Holdings Ltd"
Dear Manager,
(If you are not the person who in charge of this, please forward this to your CEO, because this is urgent.Thanks!)
I'm Martin Wang, Services & Operating Manager, from Network Service Company which is the domain name registration center in Shanghai, China.
On December 18, 2023, we received an application from WeiRong Holdings Ltd requested “xet7” as their internet keyword and China (CN) domain names( xet7.cn xet7.com.cn xet7.net.cn xet7.org.cn).
After checking it, we find this name conflict with your company name or trademark. In order to deal with this matter better, we send email to you and confirm whether or not your company have affiliation with this company in china?
Kind regards
Martin
## Other spam from spam company "WeiRong Holdings Ltd" of domain 163 com
From: jackyoptic at 163 dot com
Re: 2.3USD for 1.25G SFP Module 1310nm 20km DDM Cisco Juniper Compatible GLC-LH-SMD
Hello.
We produce the Fiber Optical Module Transceiver for many years, our SFP module could compatibled Cisco, Aruba, HPE, Juniper Mikrotik ADVA .... router, switch for many years,
If you need below equipments, please call me.
SFP Optical Transceiver 155M, 1.25G
SFP+ 10G Optical Transceiver
XFP 10G Optical Transceiver
X2 10G Optical Transceiver
25G QSFP+ Optical Transceiver
40G QSFP+ Optical Transceiver
100G QSFP28, CFP, CFP2, CFP4, CXP Optical Transceiver
SFP+ 10G DAC, AOC Cable
QSFP 40G DAC, AOC Cable
QSFP100G DAC, AOC Cable
.... etc
GLC-LH-SMD, 1.25G 1310NM, 10KM, With DDM
$2.3/PC
10G SFP+ SR, 10G 850NM 300M With DDM
$4.3/PC
All the Optical Transceiver offer 4years warranty, we could offer OEM, print your logo on the labels and offer the SFP code to customer
Our SFP could change the soft code, if you want compatible with Cisco, Finisar, HP, Mikrotik, Juniper, Extreme, HUAWEI, ZTE...., only need change the SFP code, no need keep many stock.
If you need catalog and pricelist, please reply our email, I will send you more information.
Regards,
Jacky
## WeKan Enterprise Solutions
xet7 does not know, what is this company? It is not related to WeKan kanban.
- https://www.wekanenterprisesolutions.com
- https://www.linkedin.com/company/wekanenterprisesolutions/
- https://in.linkedin.com/company/wekanenterprisesolutions/
## Wekan France
xet7 does not know, what is this company? It is not related to WeKan kanban.
- https://www.linkedin.com/company/wekan-france/

5
docs/wekan.wiki/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/wekan.wiki/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

21
docs/wekan.wiki/Home.md Normal file
View file

@ -0,0 +1,21 @@
<img src="https://wekan.github.io/wekan-logo.svg" width="60%" alt="Wekan logo" />
Wekan is an open-source [kanban board][] which allows a card-based task and to-do management.
Wekan allows to create **Boards**, on which **Cards** can be moved around between a number of **Columns**. Boards can have many members, allowing for easy collaboration, just add everyone that should be able to work with you on the board to it, and you are good to go! You can assign colored **Labels** to cards to facilitate grouping and filtering, additionally you can add members to a card, for example to assign a task to someone.
## What is special about Wekan?
Wekan is distributed under the [MIT License], allowing anyone to easily work with it and modify it. It is perfect for anyone that needs a slick kanban board but doesn't want to use third party services, which are out of user control. Wekan can be hosted on your own server with very little effort, guaranteeing that you have all the time full control over your data and can make sure no one else has access to it and that it won't just vanish from one day to another, that is, if you do backups.
## Getting started
There are various ways to get started with Wekan:
* you can use the [Sandstorm app demo],
* you could [[install|Install-and-Update]] it right away on your own server, or
* you could look through our [[contributing guidelines|Developer Documentation]] to get involved in the project.
If you still have questions, check out the [[FAQ]]!
[kanban board]: https://en.wikipedia.org/wiki/Kanban_board
[mit license]: https://github.com/wekan/wekan/blob/main/LICENSE
[sandstorm app demo]: https://demo.sandstorm.io/appdemo/m86q05rdvj14yvn78ghaxynqz7u2svw6rnttptxx49g1785cdv1h

35
docs/wekan.wiki/IFTTT.md Normal file
View file

@ -0,0 +1,35 @@
## 1) Click: Menu item for the rules
<img src="https://wekan.github.io/ifttt/main_menu-ifttt.png" alt="Navigation menu for the rule dialog" />
## 2) Rule Menu: Overview, deleting and adding new rules
<img src="https://wekan.github.io/ifttt/ifttt_main_dialog.PNG" alt="Dialog Overview for the rules" />
## 2a) Add new rule : Triggers
Currently, there are three types of triggers: board, card and checklist
| Board | Card | Checklist |
| ------------- | ------------- | ------------- |
| create card | added/removed label, attachment, person | checklist added/removed |
| card moved to | | check item checked/unchecked |
| card moved from | | checklist completed |
## 2b) Add new rule : Actions
For every trigger, there are 4 types of actions: board, card, checklist and mail
| Board | Card | Checklist | Mail |
| ------------- | ------------- | ------------- | ------------- |
| move card to list | add/remove label, attachment, person | checklist add/remove | send email to |
| move to top/bottom | set title/description | check/uncheck item | |
| archive/unarchive | | checklist complete | |
# Example : How the rule works
* Rule 1: When a card is added to the board -> Add label yellow
* Rule 2: When a card is moved to List 2 -> Add checklist ToDo
* Rule 3: When a card is added to List 1 -> Add label blue
<img src="https://wekan.github.io/ifttt/how_to_work_with_rules.gif" alt="gif animation for rules" />

616
docs/wekan.wiki/IRC-FAQ.md Normal file
View file

@ -0,0 +1,616 @@
# Wekan - Open Souce kanban - IRC FAQ
- [Wekan website](https://wekan.github.io)
### If you are in a hurry, please don't use IRC
Instead, [please search existing open and closed issues or add new issue to Wekan Feature Requests and Bugs](https://github.com/wekan/wekan/issues) (open issues have not been solved yet), or alternatively [read docs](https://github.io/wekan/wekan/wiki). Thanks!
### Required license to enter IRC channel
License:
[_] If you ask something, you will wait patiently on IRC channel for answer, idling for at least a week, and not leave IRC channel immediately.
### Congratulations! If you agree with IRC license above, you can join Wekan IRC channel
Wekan IRC is `#wekan` channel at:
- Libera.Chat
- (or OFTC)
Unfortunately Freenode `#wekan` was taken over by Freenode admins, so it's no longer in use.
***
## QA, answers by [xet7](https://github.com/xet), Maintainer of Wekan
## Answers to IRC questions are added to this wiki page, because most coming to IRC channel leave immediately, and don't wait for answer. Real IRC users know idling and stay at IRC channel. It is required that you read everything in this page before coming to IRC channel.
***
### Q: Max 20 comments visible?
```
[16:11:09] <Dalisay> hi
[16:11:23] <Dalisay> and here we go again, again wekan
has been released without enough testing
[16:11:31] <Dalisay> Comments can NOT be added any more
[16:11:42] <Dalisay> the comments only show in
the comment-counter on the minicard
[16:11:53] <Dalisay> but, the comments are
not visible when scrolling down
```
A: What new Wekan release? I tested newest versions Wekan for Snap/Docker/Sandstorm, and comments can be added to card. Please add new issue with more details https://github.com/wekan/wekan/issues
If you mean bug about [only 20 newest comments visible](https://github.com/wekan/wekan/issues/2377), that bug is fixed on non-public boards. I will add more fixes to that.
### Q: Contributing to Wekan?
```
[16:12:54] <Dalisay> yes, it's open source
[16:12:57] <Dalisay> yes, it's free
[16:13:02] <Dalisay> but this is not okay any more
[16:13:27] <Dalisay> if this does not change, I will
gather a group of developers to make a reasonable fork
```
A: I don't know why you think fork would be necessary. I welcome all new contributors and co-maintainers, and help them to get up to speed. You can send your pull requests to Wekan https://github.com/wekan/wekan/pulls . I do have also [blog post about it](https://blog.wekan.team/2018/02/benefits-of-contributing-your-features-to-upstream-wekan/index.html). All what I do on Wekan is based of feedback at GitHub issues, chats and emails. Wekan is friendly Community driven Open Source project. I do also provide [Commercial Support](https://wekan.team/commercial-support) for features and fixes.
### Q: CPU usage?
```
[16:14:01] <Dalisay> in my opinion, the board is still in
an eary RC state, and not stable by any means
[16:14:04] <Dalisay> so many bugs all the time
[16:14:09] <Dalisay> we are not talking about minor bugs.
[17:50:41] <Dalisay> oh, and the VERY old bug is also back again:
[17:50:42] <Dalisay> https://pastebin.com/raw/qpPiaWp6
[17:50:53] <Dalisay> CPU overload because of wekan
[17:51:43] <Dalisay> this is the fastest server we have
ever run, and wekan is the only software on it
[17:51:48] <Dalisay> yet, it still overpowers the CPU
[17:51:59] <Dalisay> wekan is really not ready to be used on a daily basis
[17:52:12] <Dalisay> We have many boards and many users, and we rely on wekan
[17:52:23] <Dalisay> it disrupts our work life more than it helps us
[17:53:01] <Dalisay> no matter if wekan is open source or not,
some minimum standards of quality should be maintained
[17:55:37] <Dalisay> Here, that's a bug from the year 2016 !
[17:55:38] <Dalisay> https://github.com/wekan/wekan/issues/718
[17:55:44] <Dalisay> this bug is 3 years old
[17:56:00] <Dalisay> that's again not a minor thing
[17:56:11] <Dalisay> that's a major thing that disrupts the work flow
[17:56:20] <Dalisay> it means, that the server admin will be called
all the time to restart the board
```
A: Yes, that bug is back, to fix 2 other bugs. [I added explanation](https://github.com/wekan/wekan/issues/718#issuecomment-561377824). CPU usage is getting improved in newer Wekan releases.
***
### Q: Import multiple Trello boards?
```
[13:15:32] <netopejr> Hello, i there way how to import multiple
Trello booards? I have over 100 boards which i need to migrate
to Wekan. Importing via add board -> import -> from trello
works more or less but its time consuming.
```
A: This will be implemented sometime with [Mass Import from Trello](https://boards.wekan.team/b/D2SzJKZDS4Z48yeQH/wekan-open-source-kanban-board-with-mit-license/RNTZ8NAm46mAeEDev)
### Q: Fork?
```
[15:24:31] <Dalisay> hi
[15:25:13] <Dalisay> I don't mean to come across ungrateful.
[15:25:29] <Dalisay> But I really want to mention, that wekan should be
tested much better before releasing a new version.
[15:25:46] <Dalisay> It's not important to release a new version every day.
[15:25:58] <Dalisay> It's okay if there is a new version only every 2 weeks.
[15:26:09] <Dalisay> But whenever there is a new version, it should be stable.
[15:26:14] <Dalisay> really stable. rocksolid.
[15:26:32] <Dalisay> We can not move cards!
[15:26:35] <Dalisay> We can not add cards
[15:27:00] <Dalisay> and when I run "snap revert wekan", I get the other
version which has the bug of the unsorted columns
[15:28:10] <Dalisay> I really understand that it's open source and
free software.
[15:28:24] <Dalisay> But people trust wekan in real life. They use it
on a daily basis in their work life.
[15:28:36] <Dalisay> It's a nightmare, when you come to work in the
morning, and nothing works any more
[15:28:55] <Dalisay> The previous version has a major bug (the lists
that could not be sorted and showed in the wrong order)
[15:29:06] <Dalisay> and the current version is also buggy
(can't move cards / can't add new cards)
[15:29:20] <Dalisay> These updates come via snap automatically.
[15:29:27] <Dalisay> That involves a lot of trust.
[15:30:51] <Dalisay> There really must be more testing.
[15:31:14] <Dalisay> Also the github issues page has reports already.
[15:32:20] <Dalisay> This user also explains what I just said:
[15:32:21] <Dalisay> https://github.com/wekan/wekan/issues/2814#issuecomment-555427628
[15:33:20] <Dalisay> "snap revert wekan" messes up the list order
because this was a bug in the previous version
[15:33:30] <Dalisay> so there is no bug-free version available now.
[15:33:36] <Dalisay> I am not talking about small bugs.
[15:34:03] <Dalisay> these are all bugs that massively mess up the
functionality to a degree, that it renders the board useless
[15:34:42] <Dalisay> Wekan is such a promising project.
[15:34:47] <Dalisay> But the testing must be much better.
[15:54:46] <Dalisay> aaaaaaaaaaaand OPENING cards on Samsung
phones & tablets stopped working again!
[15:54:55] <Dalisay> it worked in the "edge" version of wekan
[15:54:59] <Dalisay> now it does not work any more
[15:55:12] <Dalisay> cards can NOT be opened any more on Samsung phones & tablets
[15:55:24] <Dalisay> constantly, there is something that breaks
[15:55:53] <Dalisay> Really, wekan could be so promising,
but I think it's time for a fork
[15:58:56] <Dalisay> https://github.com/wekan/wekan/issues/2814
[15:59:22] <Dalisay> https://github.com/wekan/wekan/issues/2810
[16:00:14] <Dalisay> bye, cya later
```
A:
- Please test newest Wekan
- Do you have time to be Wekan co-maintainer?
- What is URL to your fork? Please send it to me with email to x@xet7.org . Thanks! Currently there is about 2200 forks of Wekan, it would be hard to find without exact URL.
- What features and fixes have you implemented to Wekan?
- [What usually happens when Wekan gets broken](Test-Edge#what-usually-happens-when-wekan-gets-broken).
- [Benefits of contributing your features to upstream Wekan](https://blog.wekan.team/2018/02/benefits-of-contributing-your-features-to-upstream-wekan/index.html).
- [What was Wekan fork](FAQ#what-was-wekan-fork--wefork).
***
### Q: Other mobile browsers?
```
[12:48:54] <MarioSC> For example, on an Oppo phone, clicking on cards
works in Google Chrome.
[12:49:12] <MarioSC> On Samsung devices, clicking on cards fails
```
A: Please try newest Wekan.
### Q: Colored text?
```
[13:06:20] <MarioSC> Whenever we want to make titles or
descriptions or comments colored, we must use
outdated (deprecate) html tags
[13:06:43] <MarioSC> <span style="color:#ff0000;">
Important</span> won't work
[13:06:49] <MarioSC> so we have to go with:
[13:06:55] <MarioSC> <font color="red">Important</font>
[13:07:04] <MarioSC> which is really deprecated
[13:07:21] <MarioSC> Ideal would be, if the board
understood all kinds of html...
[13:07:25] <MarioSC> especially things like:
[13:07:42] <MarioSC> font-weight
[13:07:45] <MarioSC> text-decoration
[13:07:51] <MarioSC> font-variant
[13:07:56] <MarioSC> color
[13:08:00] <MarioSC> background-color
```
A: Currently [some GitHub markdown](https://guides.github.com/features/mastering-markdown/)
works. It needs some research is it possible
to enable more html, or have visual editor
elsewhere.
### Q: Wekan on mobile Chrome?
```
[15:49:52] <Rojola1> xet7, I saw your answer to the
mobile card question
[15:50:13] <Rojola1> it really won't work in Chrome
[15:50:19] <Rojola1> everyone in the organization
has the same issue
[15:50:27] <Rojola1> every phone, every tablet
[15:50:40] <Rojola1> Chrome in the newest version,
even in the dev-version
```
A: Please try newest Wekan.
### Q: Older Node version?
```
[16:47:42] <imestin> Is Wekan compatible with older
versions of Node?
```
A: You can try, but older Node versions have
security issues that are fixed in newest Node version.
### Q: Wekan crashing?
```
[15:20:04] <Rojola> hi
[15:20:12] <Rojola> xet7, are you there by any chance?
[15:20:18] <Rojola> I told you about my problems with
wekan
[15:20:23] <Rojola> now, at this very moment, I am having
one
[15:20:30] <Rojola> Normally I just restart the board to
keep working
[15:20:48] <Rojola> but it's a Saturday, so nobody
currently works on the board, and I can let the board
struggle without restarting it
[15:20:54] <Rojola> this gives us time for finding
out what's wrong
[15:21:21] <Rojola> the error in the browser reads:
[15:21:22] <Rojola> ---
[15:21:24] <Rojola> This page isn’t working
[15:21:24] <Rojola> ***.***.***.*** didn’t send any data.
[15:21:24] <Rojola> ERR_EMPTY_RESPONSE
[15:21:25] <Rojola> ---
[15:21:29] <Rojola> ^ I masked the IP
[15:22:03] <Rojola> I added many cards to the board, and
I had no idea, that the server died in the background
[15:22:15] <Rojola> so, if I restart the board now,
I will loose all the cards which I added
[15:23:21] <Rojola> I heavily depend on wekan for
my life, and it scares me when it glitches
[15:23:31] <Rojola> especially since the board
struggles so much so often
[15:23:49] <Rojola> also an issue is, when I add
cards, and then they vanish
[15:24:09] <Rojola> that happened a short while
ago - I added 2 cards, then they were gone
[15:44:02] <Rojola> xet7, I realized, the
server is not dead.
[15:44:08] <Rojola> It's just very, very,
very slow
[15:44:21] <Rojola> after like... an hour...
a board loaded
[15:44:31] <Rojola> most cards are lost, though
[15:44:55] <Rojola> I don't know how to
bugfix this
```
A: You should upgrade to newest Wekan, or
be online when xet7 is online to debug.
xet7's own boards are not crashing.
***
### Q: Unsaved changes indicator?
A: Added Feature Request https://github.com/wekan/wekan/issues/2537
***
### Q: Wekan on Sandstorm features?
At IRC #sandstorm
```
[20:40:57] <pwa2> are desktop notifications from
wekan possible in sandstorm? I see references to
notifications throughout the code, but haven't
been able to answer this question on my own. Thanks.
[21:05:22] <xet7> pwa2: Wekan does not yet have push
notifications https://github.com/wekan/wekan/issues/2026 ,
sometime they will be added. I don't know yet would
they work on Sandstorm, because I can't test yet.
[21:11:38] <pwa2> @xet7 thanks!
[21:12:11] <xet7> :)
[21:16:59] <pwa2> i've read the issue reports regarding
email notifications in wekan, where they have to be
configured both at the board level and at the member
settings level. However, the wekan app in sandstorm does
not have the "Edit Notifications" menu item. So are
email notifications from Wekan under Sandstorm not
implemented either? Or is there some configuration
switch someplace? "Change Password" and
"Change Language" are also missing from Member Settings
under Sandstorm, which makes some sense.
[21:19:58] <xet7> pwa2: I need to add code to Wekan
to enable Wekan to send email at Sandtorm
https://github.com/wekan/wekan/issues/2208#issuecomment-469290305
[21:20:52] <xet7> pwa2: Sandstorm apps need special
code for accessing outside secure sandboxed grain
[21:21:57] <pwa2> @xet7 thanks again!
[21:23:10] <xet7> pwa2: It's not possible to change
password in Sandstorm, because Sandtorm does not store
passwords at all, it has 3rd party auth
Google/LDAP/Passwordless etc. I only recently enabled
multiple boards, not all of user management is
implemented yet https://github.com/wekan/wekan/issues/2405
[21:23:44] <xet7> pwa2: I will fix all those,
but it takes some time to develop.
```
***
### Q: Board crashes?
```
<Rojola> Board crashes on server that has Wekan and RocketChat installed.
<Rojola> /var/log/syslog contains a lot
```
A: Well, what does /var/log/syslog contain?
Without that info it's kind of hard to debug.
You could try export that board to Wekan JSON, and then import that Wekan JSON.
I do have server at AWS LightSail that has 4 GB RAM and 60 GB SSD,
running [Snap versions of Wekan and RocketChat installed this way](OAuth2)
on same server, and it does not crash.
BTW, I did yesterday release [Wekan v2.95 with these new features](https://github.com/wekan/wekan/blob/main/CHANGELOG.md#v295-2019-07-01-wekan-release).
***
### Q: Board cleanup?
```
[18:02:20] <Rojola> hi
[18:02:29] <Rojola> May I please ask for help bugfixing a wekan board?
[18:02:53] <Rojola> There are many boards with many cards,
and since about 2 days, everything got very, very, very slow
[18:03:06] <Rojola> we must restart the board every
2 minutes to be able to access it
[18:03:11] <Rojola> it's a nightmare
[18:03:23] <Rojola> you add a card / comment, just to realize,
it has not been saved to the server
[18:03:38] <Rojola> the board has stopped working after over 1,5 years
[18:17:03] <Rojola> I'm AFK for a while, but I will check
for answers a little later
[23:44:45] <Rojola> is there still nobody around?
[02:25:22] <Rojola1> is anyone here?
[02:25:24] <Rojola1> xet7?
[02:25:27] <Rojola1> anyone?
```
A: I was at meeting or sleeping when you asked. When I came back to IRC you were not online. Anyway, you can [make backup](Backup) and do some [cleanup](https://github.com/wekan/wekan-cleanup) to delete 1,5 years worth of activities etc. Next time, if you have questions, you get faster answers at [GitHub issues](https://github.com/wekan/wekan/issues), because I get email notifications of all new issues and comments on issues.
***
### Q: Rules as code?
```
[23:40:03] <IRC-Source_15> Hey does anyone know
if it is possible to code in rules (as opposed to using the front end UI)?
```
A: Not yet. There are [Rules issues](https://github.com/wekan/wekan/issues?q=is%3Aissue+is%3Aopen+rules+label%3AFeature%3ACards%3AIFTTT-Rules) about Rules variables. If you have ideas how to make translated Rules UI have also translated code, please add new GitHub issue Feature Request or PR.
***
### Q: LDAP Bug: [ERROR] InvalidCredentialsError: 80090308: LdapErr: DSID-0C090400
```
[14:58:26] hello everyone. I am getting this erro:
[14:58:30] Error
[14:58:31] [ERROR] InvalidCredentialsError: 80090308:
LdapErr: DSID-0C090400, comment: AcceptSecurityContext error, data 52e, v1db1
[14:59:19] can someone check this and tell me if I did
something wrong? : https://paste.ee/p/uuUDb
[14:59:33] The credentials are correct
[15:26:09] This is the error in my syslog: https://paste.ee/p/mJdtL
```
A: https://github.com/wekan/wekan/issues/2490
### Q: LDAP Group Filtering
```
[13:17:27] <leOff> hi everyone
[13:18:07] <leOff> was wondering if i could get some help regarding ldap
group filtering .. documentation is pretty much inexistent
[13:19:58] <leOff> in particular, what exactly are the keys
ldap-group-filter-member-attribute ,
ldap-group-filter-member-format and ldap-group-filter-member-name
supposed to point to
[13:21:15] <leOff> ldap-group-filter-member-attribute is it
the membership attribute which is part of the user entry,
or is it the member list attribute in the group entry?
[13:21:59] <leOff> ldap-group-filter-member-format ...
this one i have no idea what might be
[13:23:20] <leOff> and finally, ldap-group-filter-member-name
is it and enumeration of the group names
(related to ldap-group-filter-member-attribute probably)
which are allowed to login?
[13:25:30] <leOff> I REALLY would like to limit my groups
available since i have some very large groups .. up to 15k users
```
A: https://github.com/wekan/wekan/issues/2356#issuecomment-494573761
### Q: Copying Checklists?
```
[09:25:51] <sfielding> I have now about one year of exp with Wekan
usage somewhat daily, and it has become my favourite productivity tool.
[09:27:36] <sfielding> Initially we used it with Sandstorm, but
because of closed sandbox model we changed into standalone snap install.
[09:28:02] <sfielding> Ldap integration works as expected
[09:34:42] <sfielding> Only situation where I end up using tedious
copy & paste string transferring is when moving checklists
from one card to another.
[12:49:45] <xet7> sfielding: click card hamburger menu =>
Copy Checklist Template to Many Cards
```
### Q: LDAP?
A: [LDAP for Standalone is now available](LDAP).
```
[17:56:10] <regdude> Hi! I'm trying to setup Wekan with LDAP,
but can't seem to get it to work.
Where could I found logs for why LDAP is not working?
[17:56:18] <regdude> does not seem to send out any LDAP packets
[17:58:31] <regdude> oh, it does not do anything
```
Please see is there existing issues at [LDAP Bugs and Feature Requests](https://github.com/wekan/wekan-ldap/issues), or add a new one.
### Q: Is there in Wekan: My Cards: List of all boards/lists/cards for every card where person is assigned to card ?
```
[15:25:23] <superlou> If I have a Wekan board per project, with people assigned
cards in multiple projects, is there a way to provide a list of the tasks for
a person across all of their projects?
```
A: Yes. Click right top your username / My Cards.
### Q: Wekan Internal Server Error
2018-11-09
```
[20:45:22] <Rojola> hi
[20:45:35] <Rojola> Before I came here, I tried to find a solution myself
[20:46:17] <Rojola> e.g. I read the error log, read the installation troubleshooting docs, did research, and played around with the SMTP settings
[20:46:52] <Rojola> then I joined #sandstorm but nobody replied
[20:47:07] <Rojola> The problem:
[20:47:31] <Rojola> I always get an "Internal Server Error" when I try to send me the registration email
[20:49:15] <Rojola> https://filebin.net/11q54qsyd7rigpiq/internal_server_error.png?t=ziblx18b
[20:49:28] <Rojola> in theory, sandstorm + wekan is installed
[20:49:35] <Rojola> but, in reality I can not access it
```
A: See 4) at https://github.com/wekan/wekan/wiki/Adding-users . This is Stanalone Wekan (Snap, Docker, Source) email setting. This has nothing to do with Sandstorm.
***
### Q: 2018-11-07 Answer speed
```
[12:50:46] <gros> hey
[12:53:45] <gros> I won't whine, because I know sometimes it is
hard to answers to user's questions, but I'm here
since several days, I see that other users asks some things,
and no one is answering
[12:58:11] <gros> I think that you could close this channel in fact,
it will make win time for users
[12:58:24] <gros> and again I don't whine, thanks for the great Wekan :)
```
A:
- Fastest: If you want fast answers, get [Commercial Support](https://wekan.team/commercial-support/).
- Medium speed: If you have time to wait, [add new GitHub issue](https://github.com/wekan/wekan/issues).
- Slow: [Wekan Community Chat with webbroser and mobile Rocket.Chat](https://chat.vanila.io/channel/wekan)
- Slowest: If you want to chat on IRC, please stay at IRC idling, and ask question again also at some other day. Sometimes there is Internet connectivity issues, if it looks like xet7 is not online. IRC is very nice, some Wekan users prefer it. Answers to IRC questions are added to this wiki page, because most coming to IRC channel leave immediately, and don't wait for answer.
***
### Q: SMTP sending to own domain but not Gmail
```
[16:18:47] <k_sze> Does anybody have an idea why I can send e-mail from Wekan
to my personal domain, but not to a Gmail address?
[17:34:16] <k_sze> And now Wekan doesn't actually work. I set it up
from Snap on Ubuntu 18.04.
[17:34:32] <k_sze> (Wekan doesn't work after I reboot Ubuntu)
[17:38:51] <k_sze> Like, I get 502 Bad Gateway from my nginx reverse proxy
```
A: Did you set your domain SPF records (as TXT records) and DKIM records on your domain that your SMTP server uses? Problem is not in Wekan, it's your SMTP server. For example AWS SES works. Also see [Troubleshooting Email](Troubleshooting-Mail).
***
### Q: Integrating Wekan
```
[03:32:12] <ajay> Hi can anyone tell me how to integrate wekan in
other applications
[03:32:50] <ajay> i am want to integrate it in QGIS for task management
[03:33:01] <ajay> *i want
```
A: Use [Wekan REST API](REST-API). For example, see [Wekan Gogs integration](https://github.com/wekan/wekan-gogs). You can also use [Outgoing Webhooks](Outgoing-Webhook-to-Discord) to send data to some Incoming Webhook. There is also [IFTTT Rules](IFTTT) for some automations.
***
### QA: Rescuing Subtask board
```
[18:33:29] <wekanuser> hello I have a wekan board that
never loads, I just get the spinner. all the other
boards are working fine. This happened after we moved
some subtasks from a subtask board to the main board.
any tips would be appreciated. thanks.
[18:33:58] <xet7> wekanuser: What Wekan version?
[18:34:45] <xet7> Can you move subtasks back to subtask board?
[18:42:02] <wekanuser> v 1.55.0. re: move tasks back to
subtask board - I can't, since the parent board will not load.
[18:42:35] <wekanuser> - I was in subtask board, and moved
manually each subtask over to parent board. Then went to
parent board and it will not load.
[18:43:28] <wekanuser> - the cards would not load on
the main board, but I was able to make an "export"
of the board from the GUI and re-imported it, to another
board but only a fraction of the stories and swimlanes were there.
[18:43:58] <wekanuser> - when I accessed the parent board
via the rest api, I see all my cards, looks like everything is there
[18:44:07] <wekanuser> - so something is hanging on loading the board
[18:44:32] <xet7> Do you still need subtasks on board?
[18:45:09] <wekanuser> no, since the subtasks on the subtasks
board have been moved, there should be nothing "linking" there
[18:46:11] <xet7> Do you see any subtask related in
exported JSON file? So you could remove subtasks from it before importing?
[18:47:06] <wekanuser> thanks, I will check
[18:47:34] <xet7> Does the exported JSON file have all data of
that board? You could check do you see same as with API
[18:47:56] <xet7> You can also create new board that is
similar structure of your exported board, and compare structure
[18:48:52] <xet7> Also please add new issue to
https://github.com/wekan/wekan/issues about what happened,
so somebody can think how to prevent that happening.
[18:52:53] <wekanuser> it appears the json file has all the data
[18:54:04] <xet7> Nice :) Then you can compare it with similar
working board, what is different
[18:54:39] <xet7> Does it have any custom fields?
[18:55:02] <xet7> sometimes removing custom fields makes import work
[18:56:05] <wekanuser> yes there are custom fields, I will consider
trying that. re: removing subtasks, you mean the subtask cards?
or the subtask references in parent cards?
[18:56:27] <xet7> Try first remove subtask references
[18:56:49] <xet7> compare to other exported board JSON that
does not have any subtasks
[18:57:38] <xet7> You don't need to try removing
custom fields yet, there has been some custom fields fixes
[18:58:14] <xet7> I would think that when there is
references to not existing subtasks then that could bring those problems
[19:10:37] <wekanuser> thanks, working on remove subtask refs'
[19:12:31] <wekanuser> I assume that is making
parentId :"" empty,
as I see only subtasks referencing parents,
not parents referencing subtasks
[21:54:39] <wekanuser> update: process of elimination
lead to the import board working if I remove all all
activities from the json file before import
[21:56:47] <xet7> Nice :) Then I think I should not
include activities in export.
[22:03:06] <wekanuser> is there an option to exclude
things from export? I only see the "BUTTON" that does an export
[22:06:16] <xet7> not yet
[22:07:19] <wekanuser> I am probing for possible bad activity item
[22:08:00] <xet7> Probably some activity types are not imported correctly
[19:22:59] <wekanuser> thanks for the help yesterday,
board has been restored. I will document my issue in a real ticket,
hopefully it will help someone else. Thanks again
[19:23:13] <xet7> :)
```
***
### QA: Wekan in iFrame
```
[17:42:12] <siqueira> Hi, I want to embed my Kanban
from wekan in my website using iframe. Does Wekan
support this feature?
[18:13:59] <xet7> siqueira: Yes, set trusted-url to
your web address that iframes Wekan
https://github.com/wekan/wekan-snap/wiki/Supported-settings-keys
[18:15:35] <xet7> siquiera: If you have problems with browser
javascript console, or something not working, you can
also set browser-policy-enabled='false' that enables
all iframing - but that has a little less security
[18:18:13] <xet7> siquiera: Problem with iframing
Wekan is that link to card does not work well.
For that it's better to have Wekan in sub-url, and
add "iframe" replacing HTML/CSS at beginning of
body tag, and at end of body tag, but that
feature is not yet in Wekan, I'm currently developing it.
[19:25:07] <siqueira> xet7, Thanks a lot
for the information! I just want to have my
public tasks on my website. I think the
browser-policy-enabled can solve my problem,
until I wait for the new feature. Thanks :)
[19:25:51] <xet7> siqueira: You can set
board as public, and provide that public link in iframe.
[19:27:32] <siqueira> I will try it :)
```
A: Currently having Wekan in iframe is broken, because browser APIs changed. See [this issue for progress](https://github.com/wekan/wekan/issues/3875).
***
### Q: Docker reverse proxy
```
yogab> Hi! How are you today ? Can i ask
a docker x reverse proxy x wekan question here ?
```
A: Hmm, it seems you did not ask. Just guessing, maybe it's about [Traefik reverse proxy and Docker](Traefik-and-self-signed-SSL-certs).
***
## Still reading?
Wow, you are so cool ! You gonna be an expert guru soon.
Check out here for more wild stuff: https://github.com/wekan/wekan/wiki
There is:
- Info about translations, dev stuff, changelog, and huge amount of Wekan features.

5
docs/wekan.wiki/If-board-does-not-open-and-keeps-loading.md Normal file
View file

@ -0,0 +1,5 @@
1. As Wekan Admin user, at `All Boards` page on top of board, click `Clone Board`
2. If cloned board does open correctly, check does it have any data missing.
3. If original board does not open correctly, at `All Boards` page on top of board icon click `Archive`
4. At `All Boards` page top right if buttons `Archive` and `Templates`. Click `Archive`.
5. If you don't need that original board anymore, click `Delete` to delete that original board permanently.

8
docs/wekan.wiki/Impersonate-user.md Normal file
View file

@ -0,0 +1,8 @@
Admin Panel / People / Click at right side of usename `...` button that is User Settings / Impersonate user.
You will be switched to logged in as that user.
To switch back to your original user, at your webbrowser click `Reload open webpage` round arrow button.
This feature was added to Wekan v4.39 at https://github.com/wekan/wekan/pull/3280

104
docs/wekan.wiki/Install-Wekan-Docker-for-testing.md Normal file
View file

@ -0,0 +1,104 @@
**Purpose**: just to try Wekan on your own Linux workstation
1. [Install Docker](http://docs.docker.com/linux/step_one/)
1. [Install Docker-Compose](http://docs.docker.com/compose/install/)
1. Say we want to save our Wekan data on the host in directory `/home/johndoe/wekan/data`
1. In a given directory (say `/home/johndoe/wekan`), create a `docker-compose.yml` file with:
Use this docker-compose.yml:
https://raw.githubusercontent.com/wekan/wekan/devel/docker-compose.yml
Then, from the directory containing the `docker-compose.yml` (i.e. `/home/johndoe/wekan`), simply run `docker-compose up`. If you want it to be deamonized, you could run `docker-compose up -d`.
Your wekan data are in `/home/johndoe/wekan/data` and thus can be backed up.
**Note**
If the default host port 80 has been used and you would like to set up Wekan for another port, say, 1234, the configuration above
```
ports:
- 80:8080
```
can be replaced by
```
ports:
- 1234:8080
```
also need to change
```
- ROOT_URL=http://localhost
```
to the new port
```
- ROOT_URL=http://localhost:1234
```
(This procedure has been tested on Linux Ubuntu 14.04 and Mac OS 10.11.6.) (Tested on Docker for Windows 17.06.2-ce-win27, MongoDB does not support using mounted Windows volumes, simply remove volumes: from wekandb:)
## Testing with mail server
Above method will create an instance of Wekan without mailing features (users inviting, password recovery, neat registration) because MAIL_URL env var isn't set. This `docker-compose.yml` solves that problem by adding *mailserver* container.
```yaml
wekan:
image: quay.io/wekan/wekan
links:
- wekandb
- mailserver
environment:
- MONGO_URL=mongodb://wekandb/wekan
- ROOT_URL=http://10.2.0.180:8081
- MAIL_URL=smtp://wekan:wekan@mailserver:25
ports:
- 8081:80
wekandb:
image: mongo:3.2.21
volumes:
- /home/wekan/data:/data/db
mailserver:
image: marvambass/versatile-postfix
volumes:
- /home/wekan/dkim:/etc/postfix/dkim/
- /home/wekan/maildirs:/var/mail
command: wekan.com wekan:wekan
environment:
- ALIASES=postmaster:root;hostmaster:root;webmaster:root
```
Several additional steps needed.
1. Create dirs `/home/wekan/dkim`, `/home/wekan/maildirs` that are used by *mailserver* container
```bash
mkdir /home/wekan/dkim
mkdir /home/wekan/maildirs
```
2. Generate DKIM key
```bash
apt-get install opendkim-tools
cd /home/wekan/maildirs
opendkim-genkey -s mail -d example.com
mv mail.private dkim.key
```
## Show mails with a Docker image, without mail configuration
When you did **NOT** setup the `MAIL_URL` environment variable in Wekan, the mail message will be 'sent' to the terminal output instead of sending an actual e-mail. If you are using Docker images, list the containers via:
```sh
docker ps
```
Then display the process output:
```sh
docker logs -f <container_id>
```
With the `-f` flag (`f` for `follow`), you will see the real-time output of the process. You can exit with **CTRL + C** without affecting the Wekan process.
Via the web-interface press the '_forgot your password?_' link and trigger a reset mail. And watch the terminal output for the e-mail.

46
docs/wekan.wiki/Install-Wekan-Docker-in-production.md Normal file
View file

@ -0,0 +1,46 @@
# Different wiki page: [Production setup for thousands of users at AWS](AWS)
***
## Single server install, for small teams
## Also see: [Using same database for both LAN and VPN Wekan](https://github.com/wekan/wekan-mongodb/blob/master/docker-compose.yml#L86-L100)
**Purpose:** run Wekan on a production Linux server with Docker and Apache or Nginx as a front-end server (reverse proxy)
## 1. Install newest Docker and Docker Compose
[Docker website](https://docker.com)
## 2. Use Wekan-MongoDB with Docker Compose
https://github.com/wekan/wekan-mongodb
[External MongoDB authentication](https://github.com/wekan/wekan/issues/1375)
## 3. Email
[Troubleshooting Email](Troubleshooting-Mail)
## 4. Configure webserver as a front-end proxy
* [Caddy](Caddy-Webserver-Config)
* [Nginx](Nginx-Webserver-Config)
* [Apache](Apache)
## 5. Launch Wekan
As `wekan` user and from `/home/wekan`, run `docker-compose up -d`
## 6. Improvements to bring to this doc
* Verify everything works
## 7. Tested on...
This procedure has been tested on:
* [VPS-SSD 2016 from OVH](https://www.ovh.com/fr/vps/vps-ssd.xml) with Ubuntu 14.04

66
docs/wekan.wiki/Install-Wekan-Docker-on-SUSE-Linux-Enterprise-Server-12-SP1.md Normal file
View file

@ -0,0 +1,66 @@
More complete Docker info at:
* [Docker](Docker)
Tested to work on AWS cloud:
```
ec2-user@ip:~> cat /etc/os-release
NAME="SLES"
VERSION="12-SP1"
VERSION_ID="12.1"
PRETTY_NAME="SUSE Linux Enterprise Server 12 SP1"
ID="sles"
ANSI_COLOR="0;32"
CPE_NAME="cpe:/o:suse:sles:12:sp1"
```
As root:
1) Install all updates and Docker (recommended):
```
zypper update
zypper in docker
```
2) Start editing textfile to add rights for Docker to access network:
```
vi /etc/sysconfig/SuSEfirewall2
```
3) In that textfile change FW_ROUTE line to this and save:
```
FW_ROUTE="yes"
```
4) Add rights to use docker as another user, examples: ec2-user, virtual
```
/usr/sbin/usermod -a -G docker ec2-user
```
5) Start Docker and enable it on booting
```
systemctl start docker
chkconfig docker on
```
6) Reboot so updates and firewall changes start working:
```
reboot
```
7) As normal user (examples: ec2-user, virtual) (root works still too), install MongoDB and Wekan, you can change 8080 to be another port:
```
docker run -d --restart=always --name wekan-db -v /volume1/docker/wekan/wekan-db:/data/db mongo:3.2.12
docker run -d --restart=always --name wekan --link "wekan-db:db" -e "MONGO_URL=mongodb://db" -e "ROOT_URL=http://localhost:8080" -p 8080:80 wekanteam/wekan:meteor-1.4
```
8) Now Wekan is available at http://ip-address:port , for example: http://192.168.100.50:8080 . Wekan starts at boot, and restarts on error conditions.

100
docs/wekan.wiki/Install-Wekan-from-source-on-Windows.md Normal file
View file

@ -0,0 +1,100 @@
Also see: [Excel and VBA](Excel-and-VBA)
# THIS WORKS
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)
***
# OLD INFO BELOW, DOES NOT WORK
### 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/wekan.wiki/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/wekan.wiki/Install-and-Update.md Normal file
View file

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

23
docs/wekan.wiki/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/wekan.wiki/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} | egrep -o 'm#:\s[0-9]{5}\sUs' | cut -d' ' -f 2)"
MONGO_PASS="$(echo ${TEMPMDB} | egrep -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 | egrep -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/wekan.wiki/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)

53
docs/wekan.wiki/Integrations.md Normal file
View file

@ -0,0 +1,53 @@
# Current
* [PostgreSQL](https://github.com/wekan/wekan/tree/main/torodb-postgresql)
* [Webhooks](Features#webhooks), works by showing board activities with [Slack](https://slack.com/), [Rocket.chat](https://rocket.chat/) and others that supports Webhooks.
* [Gogs Integration](https://github.com/wekan/wekan-gogs) as separate project.
# Wishes for pull requests
## IFTTT
* [Huginn or Flogo](https://github.com/wekan/wekan/issues/1160)
## Chat
* [Rocket.Chat more integrations](https://github.com/RocketChat/Rocket.Chat/issues/672#issuecomment-328469079)
## Issue / Commit
* [GitLab](https://github.com/wekan/wekan/issues/109)
* GitHub
* Gitea
## Time Tracking
* [Time Tracking](https://github.com/wekan/wekan/issues/812)
* [Super-Productivity](https://github.com/johannesjo/super-productivity/issues/7) after [Themes](https://github.com/wekan/wekan/issues/781) and [API scripting](https://github.com/wekan/wekan/issues/794) is done.
## Complete replacement
* Jira, plan at [Themes](https://github.com/wekan/wekan/issues/781)
## File Sync, Groupware
* [ownCloud / Nextcloud](https://github.com/wekan/wekan/issues/687)
## Authentication
Most are these are already available at [Sandstorm](https://sandstorm.io), for example see
[screenshots of SAML support](https://discourse.wekan.io/t/sso-passing-variables-through-url/493/8).
Following are for Source/Docker installs:
* [Google/GitHub/OAuth](https://github.com/wekan/wekan/issues/234)
* [[LDAP]] ([#119](https://github.com/wekan/wekan/issues/#119))
* [SAML](https://github.com/wekan/wekan/issues/708)
* [OpenID](https://github.com/wekan/wekan/issues/538)
## Import / Export
* [Taskwarrior tasks](https://github.com/wekan/wekan/issues/827)
# More
[Features](Features)

21
docs/wekan.wiki/Java.md Normal file
View file

@ -0,0 +1,21 @@
This page is about using Wekan from Java code.
Wekan is made with Javascript and uses MongoDB database.
## Using Wekan REST API
With Jython, you can use Wekan REST API [like with Python](New-card-with-Python3-and-REST-API)
## Global Webhooks
For Global Webhooks in Admin Panel, Wekan sends all events in all boards to webhook URL, like add card. Although, sending some messages for some events is not yet implemented, more could be added later.
Data is sent in [this kind of JSON format](Webhook-data).
[You can receive webhook data in Java like this](https://github.com/Esri/webhooks-samples/tree/master/java/receiver).
Then for each received data, your code can read content and based on incoming data call Wekan REST API, some Java interface, etc.
Outgoing Webhooks can also go to Slack, RocketChat, NodeRED, PowerShell etc. See right menu webhook links when scrolling down wiki page https://github.com/wekan/wekan/wiki
If you call some Java interface that returns some data, you can then write that data to Wekan card with Wekan REST API.

35
docs/wekan.wiki/Jira.md Normal file
View file

@ -0,0 +1,35 @@
Originally from @webenefits at https://github.com/wekan/wekan/discussions/3504
## Migrate from Jira Server (Atlassian) to Wekan
Hello all,
I wanted to share here my experience with migrating data from Jira (Server) to Wekan. It took me 1 - 2 days to find a solution and I think it makes sense to record it here so that successors have it easier.
In order to not transfer everything manually and still keep all comments and (at least) links to attachments from Jira, my plan was to first migrate everything from **Jira → Trello** and then from **Trello → Wekan**, since importing from Trello works very well. :ok_hand:
Unfortunately there is no "easy" variant to transfer data from Jira to Tello.
First of all, I found "TaskAdpater" through various threads, which allows you to transfer data between different tools (including Jira and Trello). This would have been a nice way to do it, since the data would not have gone through a third party. Unfortunately, this didn't work because of the newer API token authentication in combination with Jira server. Also other suggested things like "Zapier" were not really functional.
## Related
- https://www.theregister.com/2023/10/16/atlassian_cloud_migration_server_deprecation/
- https://news.ycombinator.com/item?id=37897351
When I had almost given up, I had the idea to look for "Power Ups" (Addons) in Trello. And indeed, I found what I was looking for! The power up is called "Unito Sync". It allows you to synchronize individual projects in both directions between tools like Jira and Trello. And the best: There is a 14-day trial version.
That's how it worked in the end. You have to migrate each project separately and make some fine adjustments afterwards. However, all data including comments and attachments (as links) are integrated!
Here again briefly the way:
1. Create a Trello dummy account
2. Create a new board there
3. Install and register Power Up Unito Sync
4. Create a new "flow" for the current project in Unito Sync
5. Synchronize
6. Export data from Trello again afterwards
7. Import JSON into Wekan
I hope I could save you some work with this. Good luck! :four_leaf_clover:
Greetings
Alexander

68
docs/wekan.wiki/Keycloak.md Normal file
View file

@ -0,0 +1,68 @@
[2022 KEYCLOAK CERTIFICATE FIX HERE](https://github.com/wekan/wekan/issues/4525)
[Somebody got Keycloak working](https://github.com/wekan/wekan/issues/3277#issuecomment-696333794)
NOTE: Is that preffered_username setting wrong? Correct settings should be for OIDC login:
```
sudo snap set wekan oauth2-username-map='email'
sudo snap set wekan oauth2-email-map='email'
```
[Outstanding Bug](https://github.com/wekan/wekan/issues/1874#issuecomment-460802250): Create the first user (admin) with the regular process. Then the remaining users can use the Register with OIDC process.
Keycloak settings: [realm-export.zip](https://wekan.github.io/keycloak/realm-export.zip)
[Keycloak at Docker Hub](https://hub.docker.com/r/jboss/keycloak)
Environment Variables that need to be set in your Wekan environment:
> When creating a Client in keycloak, ensure the access type is confidential under the settings tab. After clicking save, you will have a Credentials tab. You can retrieve the secret from that location.
## Snap
Copy below commands to `auth.sh` textfile, make it executeable `chmod +x auth.sh` and run it with `./auth.sh`.
```
sudo snap set wekan oauth2-enabled='true'
sudo snap set wekan oauth2-client-id='<Keycloak create Client ID>'
sudo snap set wekan oauth2-secret='<Keycloak Client secret>'
sudo snap set wekan oauth2-server-url='<Keycloak server name>/auth'
sudo snap set wekan oauth2-auth-endpoint='/realms/<keycloak realm>/protocol/openid-connect/auth'
sudo snap set wekan oauth2-userinfo-endpoint='/realms/<keycloak realm>/protocol/openid-connect/userinfo'
sudo snap set wekan oauth2-token-endpoint='/realms/<keycloak realm>/protocol/openid-connect/token'
sudo snap set wekan oauth2-id-map='preferred_username'
sudo snap set wekan oauth2-username-map='preferred_username'
sudo snap set wekan oauth2-fullname-map='given_name'
sudo snap set wekan oauth2-email-map='email'
```
### Debugging, if Snap OIDC login does not work
```
sudo snap set wekan debug='true'
```
Click Oidc button. Then:
```
sudo snap logs wekan.wekan
sudo systemctl status snap.wekan.wekan
```
## Docker
[docker-compose.yml](https://github.com/wekan/wekan/blob/main/docker-compose.yml)
```
- DEBUG=true
- OAUTH2_ENABLED=true
- OAUTH2_CLIENT_ID=<Keycloak create Client ID>
- OAUTH2_SERVER_URL=<Keycloak server name>/auth
- OAUTH2_AUTH_ENDPOINT=/realms/<keycloak realm>/protocol/openid-connect/auth
- OAUTH2_USERINFO_ENDPOINT=/realms/<keycloak realm>/protocol/openid-connect/userinfo
- OAUTH2_TOKEN_ENDPOINT=/realms/<keycloak realm>/protocol/openid-connect/token
- OAUTH2_SECRET=<keycloak client secret>
- OAUTH2_ID_MAP=preferred_username
- OAUTH2_USERNAME_MAP=preferred_username
- OAUTH2_FULLNAME_MAP=given_name
- OAUTH2_EMAIL_MAP=email
```
### Debugging, if Docker OIDC login does not work
```
docker logs wekan-app
```

89
docs/wekan.wiki/LDAP-AD-Simple-Auth.md Normal file
View file

@ -0,0 +1,89 @@
- [**OTHER LDAP Settings**](LDAP-AD-Simple-Auth) and [**RELATED Search Filter Settings**](https://github.com/wekan/wekan/issues/3908#issuecomment-887545168):
```
- LDAP_USER_SEARCH_FILTER=(objectClass=user)
- LDAP_EMAIL_FIELD=mail
```
- [Original PR](https://github.com/wekan/wekan/pull/3909). Thanks to indika-dev.
- [Added settings for all remainin Wekan Standalone (non-Sandstorm) platforms](https://github.com/wekan/wekan/commit/fe40f35d6d9b6293f3bdbf5bc0f3e8e708c59518) and Docs to this wiki page. Thanks to xet7.
- When enabled, LDAP_BASEDN is not needed. Example: `true`
- Also change `mydomain.com` to your domain.
- If you use LDAP Sync, also change those settings.
## Docker
Uncomment settings lines this wasy at [docker-compose.yml](https://github.com/wekan/wekan/blob/main/docker-compose.yml) to enable:
```
#-----------------------------------------------------------------
# ==== LDAP AD Simple Auth ====
#
# Set to true, if you want to connect with Active Directory by Simple Authentication.
# When using AD Simple Auth, LDAP_BASEDN is not needed.
#
# Example:
#- LDAP_AD_SIMPLE_AUTH=true
#
# === LDAP User Authentication ===
#
# a) Option to login to the LDAP server with the user's own username and password, instead of
# an administrator key. Default: false (use administrator key).
#
# b) When using AD Simple Auth, set to true, when login user is used for binding,
# and LDAP_BASEDN is not needed.
#
# Example:
#- LDAP_USER_AUTHENTICATION=true
#
# Which field is used to find the user for the user authentication. Default: uid.
#- LDAP_USER_AUTHENTICATION_FIELD=uid
#
# === LDAP Default Domain ===
#
# a) In case AD SimpleAuth is configured, the default domain is appended to the given
# loginname for creating the correct username for the bind request to AD.
#
# b) The default domain of the ldap it is used to create email if the field is not map
# correctly with the LDAP_SYNC_USER_DATA_FIELDMAP
#
# Example :
#- LDAP_DEFAULT_DOMAIN=mydomain.com
#
#-----------------------------------------------------------------
```
## Snap
Wekan, enable:
```
sudo snap set wekan ldap-ad-simple-auth='true'
sudo snap set wekan ldap-user-authentication='true'
sudo snap set wekan ldap-default-domain='mydomain.com'
```
Wekan, disable:
```
sudo snap unset wekan ldap-ad-simple-auth
sudo snap unset wekan ldap-user-authentication
sudo snap unset wekan ldap-default-domain
```
[Wekan Gantt GPL](https://github.com/wekan/wekan/issues/2870#issuecomment-721364824), enable:
```
sudo snap set wekan-gantt-gpl ldap-ad-simple-auth='true'
sudo snap set wekan-gantt-gpl ldap-user-authentication='true'
sudo snap set wekan-gantt-gpl ldap-default-domain='mydomain.com'
```
Wekan Gantt GPL, disable:
```
sudo snap unset wekan-gantt-gpl ldap-ad-simple-auth
sudo snap unset wekan-gantt-gpl ldap-user-authentication
sudo snap unset wekan-gantt-gpl ldap-default-domain
```

443
docs/wekan.wiki/LDAP.md Normal file
View file

@ -0,0 +1,443 @@
## LDAP info
- [LDAP sync script, that also correctly removes users](https://github.com/wekan/wekan/blob/main/ldap-sync/ldap-sync.py)
- [LDAP AD Simple Auth](LDAP-AD-Simple-Auth) 2021-07-24 and related [Search Filter Settings](https://github.com/wekan/wekan/issues/3908#issuecomment-887545168):
```
- LDAP_USER_SEARCH_FILTER=(objectClass=user)
- LDAP_EMAIL_FIELD=mail
```
- [MS AD with Windows 2012 server](https://github.com/wekan/wekan/issues/3292#issuecomment-703246384)
- [Additional info about LDAP docs here](https://github.com/wekan/wekan-ldap/issues/77)
- [LDAP issues](https://github.com/wekan/wekan-ldap/issues)
- [Univention LDAP related issues](https://github.com/wekan/univention/issues)
- [Teams/Organizations feature related LDAP plans](https://github.com/wekan/wekan/issues/802). Needs info from LDAP experts to describe how LDAP works.
- [Wekan LDAP code](https://github.com/wekan/wekan/tree/main/packages/wekan-ldap)
***
## Snap
LDAP is available on Snap Stable channel. Settings can be seen with command `wekan.help` and from repo https://github.com/wekan/wekan-ldap . More settings at https://github.com/wekan/wekan-snap/wiki/Supported-settings-keys
You see all settings with:
```
wekan.help | less
```
For root-url, see [Settings](Settings)
For Caddy/Wekan/RocketChat Snap settings, see [Snap install page](https://github.com/wekan/wekan-snap/wiki/Install), [OAuth2 page](OAuth2#snap) and [Caddy page](Caddy-Webserver-Config). Instead of Caddy you can also use [Nginx](Nginx-Webserver-Config) or [Apache](Apache).
## LDAP Filter settings
For better working LDAP filter setting than those below, settings info here:
https://github.com/wekan/univention/issues/5
### Active Directory LDAP part
[Source](https://github.com/wekan/wekan/issues/2822#issuecomment-568314135)
```
sudo snap set wekan ldap-enable='true'
sudo snap set wekan default-authentication-method='ldap'
sudo snap set wekan ldap-port='389'
sudo snap set wekan ldap-host='192.168.1.100'
sudo snap set wekan ldap-basedn='OU=Domain Users,DC=sub,DC=domain,DC=tld'
sudo snap set wekan ldap-login-fallback='false'
sudo snap set wekan ldap-reconnect='true'
sudo snap set wekan ldap-timeout='10000'
sudo snap set wekan ldap-idle-timeout='10000'
sudo snap set wekan ldap-connect-timeout='10000'
sudo snap set wekan ldap-authentication='true'
sudo snap set wekan ldap-authentication-userdn='CN=LDAP-User,OU=Service Accounts,DC=sub,DC=domain,DC=tld'
sudo snap set wekan ldap-authentication-password='<password>'
sudo snap set wekan ldap-log-enabled='true'
sudo snap set wekan ldap-background-sync='true'
sudo snap set wekan ldap-background-sync-interval='every 1 minute'
sudo snap set wekan ldap-background-sync-keep-existant-users-updated='true'
sudo snap set wekan ldap-background-sync-import-new-users='true'
sudo snap set wekan ldap-encryption='false'
sudo snap set wekan ldap-user-search-field='sAMAccountName'
sudo snap set wekan ldap-username-field='sAMAccountName'
sudo snap set wekan ldap-fullname-field='cn'
```
### FreeIPA v4.6.6
[Source](https://github.com/wekan/wekan/issues/3357)
```bash
snap set wekan ldap-enable='true'
snap set wekan ldap-host='ldap.example.com'
# Use 'tls' and port 389 for STARTTLS, which is more secure than standard LDAPS.
snap set wekan ldap-port='389'
snap set wekan ldap-encryption='tls'
snap set wekan ldap-timeout='10000'
snap set wekan ldap-idle-timeout='10000'
snap set wekan ldap-connect-timeout='10000'
snap set wekan ldap-authentication='true'
snap set wekan ldap-authentication-userdn='uid=ldapuser,cn=users,cn=accounts,dc=example, dc=com'
snap set wekan ldap-authentication-password='password'
# This must be set to "false" for self-signed certificates to work - enable it
# for better security if you are using a certificate verified by a commercial
# Certificate Authority (like DigiCert, Let's Encrypt, etc.)
snap set wekan ldap-reject-unauthorized='false'
# This must be the plaintext certificate data, which you can get by running the
# follwing command:
# cat ca.example.com.pem | tr -d '\n'
# This removes the hidden newline characters, and allows you to copy it
# straight from your terminal and past it into the snap set command.
#
# Pointing it to a file doesn't work - I tried.
snap set wekan ldap-ca-cert='-----BEGIN CERTIFICATE-----[blahblahblah]-----END CERTIFICATE-----'
snap set wekan ldap-log-enabled='true'
snap set wekan ldap-basedn='dc=example,dc=com'
snap set wekan ldap-background-sync='true'
snap set wekan ldap-background-sync-keep-existant-users-updated='true'
snap set wekan ldap-background-sync-import-new-users='true'
snap set wekan ldap-background-sync-interval='Every 1 minute'
snap set wekan ldap-merge-existing-users='true'
snap set wekan ldap-user-search-field='uid'
snap set wekan ldap-user-search-filter='(&(objectclass=person))'
snap set wekan ldap-user-search-scope='sub'
snap set wekan ldap-username-field='uid'
snap set wekan ldap-fullname-field='displayName'
snap set wekan ldap-email-field='mail'
snap set wekan ldap-sync-user-data='true'
snap set wekan ldap-sync-user-data-fieldmap='{"displayName":"name", "mail":"email", "initials":"initials"}'
```
### OpenLDAP
[Source](https://github.com/wekan/wekan/issues/2822#issuecomment-564451384)
```
sudo snap set wekan default-authentication-method='ldap'
sudo snap set wekan ldap-authentication='true'
sudo snap set wekan ldap-authentication-password='********'
sudo snap set wekan ldap-authentication-userdn='cn=admin,dc=*******,dc=lan'
sudo snap set wekan ldap-background-sync='true'
sudo snap set wekan ldap-background-sync-import-new-users='true'
sudo snap set wekan ldap-background-sync-interval='Every 1 minute'
sudo snap set wekan ldap-basedn='dc=*****,dc=lan'
sudo snap set wekan ldap-email-field='mail'
sudo snap set wekan ldap-enable='true'
sudo snap set wekan ldap-fullname-field='cn'
sudo snap set wekan ldap-group-filter-enable='false'
sudo snap set wekan ldap-group-filter-id-attribute='cn'
sudo snap set wekan ldap-group-filter-objectclass='groupOfUniqueNames'
sudo snap set wekan ldap-host='192.168.100.7'
sudo snap set wekan ldap-log-enabled='false'
sudo snap set wekan ldap-login-fallback='true'
sudo snap set wekan ldap-merge-existing-users='true'
sudo snap set wekan ldap-port='389'
sudo snap set wekan ldap-sync-admin-groups='administrator'
sudo snap set wekan ldap-user-search-field='uid'
sudo snap set wekan ldap-user-search-filter='(&(objectclass=inetOrgPerson))'
sudo snap set wekan ldap-user-search-scope='sub'
sudo snap set wekan ldap-username-field='uid'
```
## Docker
LDAP login works now by using this docker-compose.yml file:
https://raw.githubusercontent.com/wekan/wekan/edge/docker-compose.yml
adding ROOT_URL, LDAP settings etc to that file.
Using this docker-compose:
https://docs.docker.com/compose/install/
With this command:
```
docker-compose up -d --no-build
```
## Bugs and Feature Requests
[LDAP Bugs and Feature Requests](https://github.com/wekan/wekan-ldap/issues)
## Example LDAP settings for Docker
Note: Some newer settings could be missing from example below. Someone could copy newest missing settings from docker-compose.yml above to example below. Some examples are also at closed and open issues at https://github.com/wekan/wekan-ldap/issues
```
version: '2'
services:
wekandb:
# All Wekan data is stored in MongoDB. For backup and restore, see:
# https://github.com/wekan/wekan/wiki/Export-Docker-Mongo-Data
image: mongo:4.0.3
container_name: wekan-db
restart: always
command: mongod --smallfiles --oplogSize 128
networks:
- wekan-tier
expose:
- 27017
volumes:
- wekan-db:/data/db
- wekan-db-dump:/dump
wekan:
# Wekan container only has Node.js and related code,
# there is no data stored here.
#
# Docker Hub, usually broken:
#image: wekanteam/wekan:latest
#
# Quay, usually works, updates faster:
image: quay.io/wekan/wekan:meteor-1.8
container_name: wekan-app
restart: always
networks:
- wekan-tier
#---------------------------------------------------------------
# For running Wekan in different port like 3000, use: 3000:80
ports:
- 3000:3000
environment:
#---------------------------------------------------------------
# == ROOT_URL SETTING ==
# Change ROOT_URL to your real Wekan URL, for example:
# http://example.com
# http://example.com/wekan
# http://192.168.1.100
#---------------------------------------------------------------
- ROOT_URL=
#---------------------------------------------------------------
# == PORT SETTING ==
# Not needed on Docker, but if you had installed from source,
# you could also have setup Wekan Node.js port at localhost
# with setting: PORT=3001
# and have Nginx proxy to port 3001, see Wekan wiki.
#---------------------------------------------------------------
- PORT=3000
#---------------------------------------------------------------
# == MONGO URL AND OPLOG SETTINGS ==
# 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
# 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
#---------------------------------------------------------------
# == EMAIL SETTINGS ==
# Email settings are required in both MAIL_URL and Admin Panel,
# see https://github.com/wekan/wekan/wiki/Troubleshooting-Mail
# For SSL in email, change smtp:// to smtps://
# NOTE: Special characters need to be url-encoded in MAIL_URL.
#---------------------------------------------------------------
- MAIL_URL='smtp://<mail_url>:25/?ignoreTLS=true&tls={rejectUnauthorized:false}'
- MAIL_FROM='Wekan Notifications <noreply.wekan@mydomain.com>'
#---------------------------------------------------------------
# == WEKAN API ==
# Wekan Export Board works when WITH_API='true'.
# If you disable Wekan API, Export Board does not work.
- WITH_API=true
#---------------------------------------------------------------
## Optional: Integration with Matomo https://matomo.org that is installed to your server
## The address of the server where Matomo is hosted:
# - MATOMO_ADDRESS=https://example.com/matomo
## The value of the site ID given in Matomo server for Wekan
# - MATOMO_SITE_ID=123456789
## The option do not track which enables users to not be tracked by matomo"
# - MATOMO_DO_NOT_TRACK=false
## The option that allows matomo to retrieve the username:
# - MATOMO_WITH_USERNAME=true
#---------------------------------------------------------------
# Enable browser policy and allow one trusted URL that can have iframe that has Wekan embedded inside.
# Setting this to false is not recommended, it also disables all other browser policy protections
# and allows all iframing etc. See wekan/server/policy.js
- BROWSER_POLICY_ENABLED=true
# When browser policy is enabled, HTML code at this Trusted URL can have iframe that embeds Wekan inside.
- TRUSTED_URL=''
#---------------------------------------------------------------
# What to send to Outgoing Webhook, or leave out. Example, that includes all that are default: cardId,listId,oldListId,boardId,comment,user,card,commentId .
# example: WEBHOOKS_ATTRIBUTES=cardId,listId,oldListId,boardId,comment,user,card,commentId
- WEBHOOKS_ATTRIBUTES=''
#---------------------------------------------------------------
# LDAP_ENABLE : Enable or not the connection by the LDAP
# example : LDAP_ENABLE=true
- LDAP_ENABLE=true
# LDAP_PORT : The port of the LDAP server
# example : LDAP_PORT=389
- LDAP_PORT=389
# LDAP_HOST : The host server for the LDAP server
# example : LDAP_HOST=localhost
- LDAP_HOST=<ldap_host_fqdn>
# LDAP_BASEDN : The base DN for the LDAP Tree
# example : LDAP_BASEDN=ou=user,dc=example,dc=org
- LDAP_BASEDN=ou=prod,dc=mydomain,dc=com
# LDAP_LOGIN_FALLBACK : Fallback on the default authentication method
# example : LDAP_LOGIN_FALLBACK=true
- LDAP_LOGIN_FALLBACK=false
# LDAP_RECONNECT : Reconnect to the server if the connection is lost
# example : LDAP_RECONNECT=false
- LDAP_RECONNECT=true
# LDAP_TIMEOUT : Overall timeout, in milliseconds
# example : LDAP_TIMEOUT=12345
- LDAP_TIMEOUT=10000
# LDAP_IDLE_TIMEOUT : Specifies the timeout for idle LDAP connections in milliseconds
# example : LDAP_IDLE_TIMEOUT=12345
- LDAP_IDLE_TIMEOUT=10000
# LDAP_CONNECT_TIMEOUT : Connection timeout, in milliseconds
# example : LDAP_CONNECT_TIMEOUT=12345
- LDAP_CONNECT_TIMEOUT=10000
# LDAP_AUTHENTIFICATION : If the LDAP needs a user account to search
# example : LDAP_AUTHENTIFICATION=true
- LDAP_AUTHENTIFICATION=true
# LDAP_AUTHENTIFICATION_USERDN : The search user DN
# example : LDAP_AUTHENTIFICATION_USERDN=cn=admin,dc=example,dc=org
- LDAP_AUTHENTIFICATION_USERDN=cn=wekan_adm,ou=serviceaccounts,ou=admin,ou=prod,dc=mydomain,dc=com
# LDAP_AUTHENTIFICATION_PASSWORD : The password for the search user
# example : AUTHENTIFICATION_PASSWORD=admin
- LDAP_AUTHENTIFICATION_PASSWORD=pwd
# LDAP_LOG_ENABLED : Enable logs for the module
# example : LDAP_LOG_ENABLED=true
- LDAP_LOG_ENABLED=true
# LDAP_BACKGROUND_SYNC : If the sync of the users should be done in the background
# example : LDAP_BACKGROUND_SYNC=true
- LDAP_BACKGROUND_SYNC=false
# LDAP_BACKGROUND_SYNC_INTERVAL : At which interval does the background task sync
# example : LDAP_BACKGROUND_SYNC_INTERVAL='every 15 minutes'
# for more info: http://bunkat.github.io/later/parsers.html#text
- LDAP_BACKGROUND_SYNC_INTERVAL='every 1 hour'
# LDAP_BACKGROUND_SYNC_KEEP_EXISTANT_USERS_UPDATED :
# example : LDAP_BACKGROUND_SYNC_KEEP_EXISTANT_USERS_UPDATED=true
- LDAP_BACKGROUND_SYNC_KEEP_EXISTANT_USERS_UPDATED=false
# LDAP_BACKGROUND_SYNC_IMPORT_NEW_USERS :
# example : LDAP_BACKGROUND_SYNC_IMPORT_NEW_USERS=true
- LDAP_BACKGROUND_SYNC_IMPORT_NEW_USERS=false
# LDAP_ENCRYPTION : If using LDAPS
# example : LDAP_ENCRYPTION=true
- LDAP_ENCRYPTION=false
# LDAP_CA_CERT : The certification for the LDAPS server
# example : LDAP_CA_CERT=-----BEGIN CERTIFICATE-----MIIE+zCCA+OgAwIBAgIkAhwR/6TVLmdRY6hHxvUFWc0+Enmu/Hu6cj+G2FIdAgIC...-----END CERTIFICATE-----
#- LDAP_CA_CERT=''
# LDAP_REJECT_UNAUTHORIZED : Reject Unauthorized Certificate
# example : LDAP_REJECT_UNAUTHORIZED=true
- LDAP_REJECT_UNAUTHORIZED=false
# LDAP_USER_SEARCH_FILTER : Optional extra LDAP filters. Don't forget the outmost enclosing parentheses if needed
# example : LDAP_USER_SEARCH_FILTER=
- LDAP_USER_SEARCH_FILTER=
# LDAP_USER_SEARCH_SCOPE : Base (search only in the provided DN), one (search only in the provided DN and one level deep), or subtree (search the whole subtree)
# example : LDAP_USER_SEARCH_SCOPE=one
- LDAP_USER_SEARCH_SCOPE=
# LDAP_USER_SEARCH_FIELD : Which field is used to find the user
# example : LDAP_USER_SEARCH_FIELD=uid
- LDAP_USER_SEARCH_FIELD=sAMAccountName
# LDAP_SEARCH_PAGE_SIZE : Used for pagination (0=unlimited)
# example : LDAP_SEARCH_PAGE_SIZE=12345
- LDAP_SEARCH_PAGE_SIZE=0
# LDAP_SEARCH_SIZE_LIMIT : The limit number of entries (0=unlimited)
# example : LDAP_SEARCH_SIZE_LIMIT=12345
- LDAP_SEARCH_SIZE_LIMIT=0
# LDAP_GROUP_FILTER_ENABLE : Enable group filtering
# example : LDAP_GROUP_FILTER_ENABLE=true
- LDAP_GROUP_FILTER_ENABLE=false
# LDAP_GROUP_FILTER_OBJECTCLASS : The object class for filtering
# example : LDAP_GROUP_FILTER_OBJECTCLASS=group
- LDAP_GROUP_FILTER_OBJECTCLASS=
# LDAP_GROUP_FILTER_GROUP_ID_ATTRIBUTE :
# example :
- LDAP_GROUP_FILTER_GROUP_ID_ATTRIBUTE=
# LDAP_GROUP_FILTER_GROUP_MEMBER_ATTRIBUTE :
# example :
- LDAP_GROUP_FILTER_GROUP_MEMBER_ATTRIBUTE=
# LDAP_GROUP_FILTER_GROUP_MEMBER_FORMAT :
# example :
- LDAP_GROUP_FILTER_GROUP_MEMBER_FORMAT=
# LDAP_GROUP_FILTER_GROUP_NAME :
# example :
- LDAP_GROUP_FILTER_GROUP_NAME=
# LDAP_UNIQUE_IDENTIFIER_FIELD : This field is sometimes class GUID (Globally Unique Identifier)
# example : LDAP_UNIQUE_IDENTIFIER_FIELD=guid
- LDAP_UNIQUE_IDENTIFIER_FIELD=
# LDAP_UTF8_NAMES_SLUGIFY : Convert the username to utf8
# example : LDAP_UTF8_NAMES_SLUGIFY=false
- LDAP_UTF8_NAMES_SLUGIFY=true
# LDAP_USERNAME_FIELD : Which field contains the ldap username
# example : LDAP_USERNAME_FIELD=username
- LDAP_USERNAME_FIELD=sAMAccountName
# LDAP_MERGE_EXISTING_USERS :
# example : LDAP_MERGE_EXISTING_USERS=true
- LDAP_MERGE_EXISTING_USERS=false
# LDAP_SYNC_USER_DATA :
# example : LDAP_SYNC_USER_DATA=true
- LDAP_SYNC_USER_DATA=false
# LDAP_SYNC_USER_DATA_FIELDMAP :
# example : LDAP_SYNC_USER_DATA_FIELDMAP={"cn":"name", "mail":"email"}
# LDAP_SYNC_GROUP_ROLES :
# example :
- LDAP_SYNC_GROUP_ROLES=''
# LDAP_DEFAULT_DOMAIN : The default domain of the ldap it is used to create email if the field is not map correctly with the LDAP_SYNC_USER_DATA_FIELDMAP
# example :
- LDAP_DEFAULT_DOMAIN=mydomain.com
#---------------------------------------------------------------
depends_on:
- wekandb
- wekanproxy
wekanproxy:
image: nginx:1.12
container_name: wekan-proxy
restart: always
networks:
- wekan-tier
ports:
- 443:443
- 80:80
volumes:
- ./nginx/nginx.conf:/etc/nginx/conf.d/default.conf:ro
- ./nginx/ssl/ssl.conf:/etc/nginx/conf.d/ssl/ssl.conf:ro
- ./nginx/ssl/testvm-ehu.crt:/etc/nginx/conf.d/ssl/certs/mycert.crt:ro
- ./nginx/ssl/testvm-ehu.key:/etc/nginx/conf.d/ssl/certs/mykey.key:ro
- ./nginx/ssl/pphrase:/etc/nginx/conf.d/ssl/pphrase:ro
#------------------------------------------------------------------
# When using Wekan both at office LAN and remote VPN:
# 1) Have above Wekan docker container config with LAN IP address
# 2) Copy all of above Wekan config below, change name to different
# like wekan2 or wekanvpn, and change ROOT_URL to server VPN IP
# address.
# 3) This way both Wekan containers can use same MongoDB database
# and see the same Wekan boards.
# 4) You could also add 3rd Wekan container for 3rd network etc.
#------------------------------------------------------------------
# wekan2:
# ....COPY CONFIG FROM ABOVE TO HERE...
# environment:
# - ROOT_URL='http://10.10.10.10'
# ...COPY CONFIG FROM ABOVE TO HERE...
volumes:
wekan-db:
driver: local
wekan-db-dump:
driver: local
networks:
wekan-tier:
driver: bridge
```

40
docs/wekan.wiki/LaTeX.md Normal file
View file

@ -0,0 +1,40 @@
[Original issue](https://github.com/wekan/wekan/issues/4589)
[Commit](https://github.com/wekan/wekan/commit/82fa632197a0e3b88d26c557f1dc8cc18b05b18b)
## Examples
[Examples From NPM package](https://www.npmjs.com/package/markdown-it-mathjax3)
**Inline**
Surround your LaTeX with a single $ on each side for inline rendering.
`$\sqrt{3x-1}+(1+x)^2$`
**Block**
Use two ($$) for block rendering. This mode uses bigger symbols and centers the result.
```
$$\begin{array}{c}
\nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} &
= \frac{4\pi}{c}\vec{\mathbf{j}} \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\
\nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\
\nabla \cdot \vec{\mathbf{B}} & = 0
\end{array}$$
```
## Syntax
Math parsing in markdown is designed to agree with the conventions set by pandoc:
```
Anything between two $ characters will be treated as TeX math. The opening $ must
have a non-space character immediately to its right, while the closing $ must
have a non-space character immediately to its left, and must not be followed
immediately by a digit. Thus, $20,000 and $30,000 won’t parse as math. If for some
reason you need to enclose text in literal $ characters, backslash-escape them and
they won’t be treated as math delimiters.
```

12
docs/wekan.wiki/Leo.md Normal file
View file

@ -0,0 +1,12 @@
https://leo-editor.github.io/leo-editor/
Install at Linux arm64:
```
sudo apt -y install build-essential python3-dev pytho3-pip python3-pyqt5*
pip3 install pip --user --upgrade
pip3 install leo --user --upgrade
leo
```

70
docs/wekan.wiki/Let's-Encrypt-and-Google-Auth.md Normal file
View file

@ -0,0 +1,70 @@
Tested on Ubuntu 16.04 based distro.
Wekan installed with https://github.com/wekan/wekan/wiki/Export-Docker-Mongo-Data
## A) Let's Encrypt support, without Google Auth:
1) https://caddyserver.com config Caddyfile:
```bash
my.domain.com {
proxy / localhost:8080
}
```
2) Depending with what user you use to run Caddy, adding privileges to that user:
```bash
sudo setcap cap_net_bind_service=+ep ./caddy
```
## B) Caddy Let's Encrypt => Google Auth only allowed email addresses => Wekan
1) https://caddyserver.com config Caddyfile:
```bash
my.domain.com {
proxy / localhost:7000
}
```
2) Depending with what user you use to run Caddy, adding privileges to that user:
```bash
sudo setcap cap_net_bind_service=+ep ./caddy
```
3) Adding Google Auth, so only those email addresses can login:
https://www.npmjs.com/package/proxybouncer
4) Create nologin user for proxybouncer:
```bash
useradd -M proxybouncer
usermod -L proxyboucer
```
5) /etc/systemd/system/proxybouncer.service:
```bash
[Unit]
Description=Proxybouncer
[Service]
ExecStart=/usr/local/bin/proxybouncer
Restart=always
RestartSec=5 # Restart service after 10 seconds if node service crashes
StandardOutput=syslog # Output to syslog
StandardError=syslog # Output to syslog
SyslogIdentifier=proxybouncer
User=proxybouncer
Group=proxybouncer
Environment=PORT=7000 MY_URL=https://my.domain.com PROXY_TARGET=http://localhost:8080 GOOGLE_CLIENT_ID=... GOOGLE_CLIENT_SECRET=... ALLOWED_EMAILS=.*@domain.com$ COOKIE_SECRET=...
[Install]
WantedBy=multi-user.target
```
6) Enable proxybouncer service:
```bash
sudo systemctl enable proxybouncer
sudo systemclt start proxybouncer
```
Question: Does this setup imply that everyone will be logged in to Wekan as 'proxybouncer'? Is there a way to pass username from Google via headers, etc.?
Answer: First login to Proxybouncer can limit login domain of G Suite. Second login is using Wekan username and password. There is no integrated login yet for standalone Wekan like there is for https://sandstorm.io

Some files were not shown because too many files have changed in this diff Show more