# Urlaubsverwaltung [![Build](https://github.com/urlaubsverwaltung/urlaubsverwaltung/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/urlaubsverwaltung/urlaubsverwaltung/actions/workflows/build.yml) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=urlaubsverwaltung_urlaubsverwaltung&metric=coverage)](https://sonarcloud.io/summary/new_code?id=urlaubsverwaltung_urlaubsverwaltung) [![Docker Pulls](https://badgen.net/docker/pulls/synyx/urlaubsverwaltung?icon=docker&label=pulls)](https://hub.docker.com/r/urlaubsverwaltung/urlaubsverwaltung/) [![Crowdin](https://badges.crowdin.net/urlaubsverwaltung/localized.svg)](https://crowdin.com/project/urlaubsverwaltung)

Die Urlaubsverwaltung ist eine Web-Anwendung, um *Abwesenheiten* elektronisch verwalten zu können.

Anhand von **Urlaubsanträgen** kann ein Mitarbeiter eine Anfrage stellen, die von den jeweils berechtigten Personen genehmigt,
abgelehnt oder storniert werden kann. Jeder Mitarbeiter kann seine **Überstunden** pflegen, um immer den Überblick
zu behalten und falls doch mal eine Person ausfallen sollte, so kann die **Krankmeldung** direkt gepflegt werden.

Wenn du mehr Informationen und Bilder über dieses Projekt sehen möchtest dann schaue auf unserer [Landingpage] vorbei.

**Version 4.x**
Diese Readme bezieht sich auf die 5er-Version der Urlaubsverwaltung. Wenn du Informationen zu der 4er-Version erhalten
möchtest, dann findest du diese [im v4.x Branch](https://github.com/urlaubsverwaltung/urlaubsverwaltung/tree/v4.x).

* [Demo-System](#demo-system)
* [FAQ](#faq)
* [Berechtigungen](#berechtigungen)
* [Betrieb](#betrieb)
  * [Konfiguration](#konfiguration)
* [Demodaten Modus](#demodaten-modus)
* [Entwicklung](#entwicklung)

## Demo-System

Möchtest du die Urlaubsverwaltung **ohne** eine langwierige **Registrierung** ausprobieren?
Dann steige über unsere [Landingpage] direkt in das [Demo-System] ein.

## FAQ

Für Fragen, die bei der Benutzung der Urlaubsverwaltung aufkommen, gibt es ein [Hilfe].
Sollte dieser Fragenkatalog nicht weiterhelfen, kannst du gerne
[ein neue Q&A](https://github.com/urlaubsverwaltung/urlaubsverwaltung/discussions/new?category=q-a) erstellen.

## 🎉 Version 5.x

Die Version 5.0.0 der Urlaubsverwaltung ist verfügbar!

Wir haben größere Anpassungen an der Datenbank und den Security-Providern vorgenommen, sowie die Weichen für die weitere Entwicklung der
Urlaubsverwaltung stellen. Daher gibt es für den ein oder anderen nicht nur gute Nachrichten.

* Keine Unterstützung für MariaDB und MySQL. Wir wechseln komplett auf [PostgreSQL]. Einen Migrationspfad ist bereits im [Migration-Guide-v5] vorhanden.
* Wir haben die security provider LDAP und Active Directory entfernt und unterstützen dafür OIDC noch stärker.

Alle Informationen zum Migrieren von 4.72.1 auf 5.0.0 findet ihr im [Migration-Guide-v5]

## Berechtigungen

In der Urlaubsverwaltung gibt es aktuell folgende Arten von Berechtigungen:

* **inaktiv**: hat keinen Zugang mehr zur Urlaubsverwaltung (Daten des Benutzers bleiben zur Archivierung bestehen)
* **User**: darf Urlaub für sich selbst beantragen
* **Abteilungsleiter**: darf Urlaubsanträge für die Benutzer seiner Abteilungen einsehen, genehmigen und ablehnen
* **Freigabe-Verantwortlicher**: ist bei der zweistufigen Genehmigung von Anträgen verantwortlich für die endgültige Freigabe
* **Chef**: darf Urlaubsanträge aller Benutzer einsehen, genehmigen und ablehnen
* **Office**: darf Einstellungen zur Anwendung vornehmen, Mitarbeiter verwalten, Urlaub für Mitarbeiter
beantragen/stornieren und Krankmeldungen pflegen

Eine aktive Person kann eine oder mehrere Rollen innehaben.

---

## Betrieb

### Voraussetzungen

* [JDK 21](https://adoptium.net)
* [PostgreSQL Datenbank (v15.3)](https://www.postgresql.org/)
* [Security Provider](#security-provider-konfigurieren)

### Download

Die Anwendung steht als
* [Java Archive (.jar)](https://github.com/urlaubsverwaltung/urlaubsverwaltung/releases/latest)
* [Docker Image](https://hub.docker.com/r/urlaubsverwaltung/urlaubsverwaltung)

zur Verfügung.

#### Installation .jar Variante

* [Konfiguration Datenbank](#datenbank-konfigurieren)
* [Konfiguration Security Provider](#security-provider-konfigurieren)
* Lege ein Verzeichnis für die Urlaubsverwaltung an (z.B. `/opt/urlaubsverwaltung`). Kopiere die .jar-Datei dorthin.
* Erstelle in dem Verzeichnis eine Konfigurationsdatei namens `application.yaml`, welche die Konfiguration für
die Urlaubsverwaltung enthält und die Standardwerte überschreibt.
 Die vollständigen Konfigurationsoptionen sind unter [Konfiguration](#konfiguration) dokumentiert.

Nach der [Konfiguration](#konfiguration) lässt sich die Urlaubsverwaltung starten.

```bash
java -jar urlaubsverwaltung.jar
```

Falls es Probleme beim Starten der Anwendung gibt, ist es hilfreich das [Logging der Anwendung](#logging-konfigurieren)
zu konfigurieren, damit erhält man mehr Informationen über den Fehlerzustand.

#### Docker Variante

Alle Informationen zum Betrieb mit unserem Docker Image sind im Ordner [.example](.examples) zu finden.

### Konfiguration

Die Anwendung besitzt im Verzeichnis `src/main/resources` eine [Konfigurationsdatei](https://github.com/urlaubsverwaltung/urlaubsverwaltung/blob/main/src/main/resources/application.yaml).
Diese beinhaltet gewisse Grundeinstellungen und Standardwerte. Diese allein reichen für die Produktivnahme der
Anwendung allerdings nicht aus. Spezifische Konfigurationen wie z.B. die [Datenbank Einstellungen](#datenbank-konfigurieren)
und [Security Provider](#security-provider-konfigurieren) müssen in einer eigenen Konfigurationsdatei hinterlegt werden.

Welche Möglichkeiten es bei Spring Boot gibt, damit die eigene Konfigurationsdatei genutzt wird, kann in der
['External Config' Reference](http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-application-property-files)
nachgelesen werden.

Nachstehend alle spezifischen Konfigurationsmöglichkeiten der Urlaubsverwaltung mit ihren Standartwerten.

```yaml
uv:

  mail:
    from: ''
    fromDisplayName: Urlaubsverwaltung
    replyTo: ''
    replyToDisplayName: Urlaubsverwaltung
    application-url: ''

  development:
    demodata:
      create: 'false'
      additional-active-user: '0'
      additional-inactive-user: '0'

  calendar:
    organizer: ''
    refresh-interval: P1D

  security:
    oidc:
      claim-mappers:
        group-claim:
          enabled: 'false'
          claim-name: groups
        resource-access-claim:
          enabled: 'false'
          resource-app: urlaubsverwaltung
        role-prefix: urlaubsverwaltung_
      post-logout-redirect-uri: '{baseUrl}'

  application:
    upcoming-holiday-replacement-notification:
      cron: 0 0 7 * * *
    reminder-notification:
      cron: 0 0 7 * * *
    upcoming-notification:
      cron: 0 0 7 * * *

  account:
    update:
      cron: 0 0 5 1 1 *

  sick-note:
    end-of-pay-notification:
      cron: 0 0 6 * * *

```

#### Security Provider konfigurieren

Siehe die [Spring Boot oAuth2](https://docs.spring.io/spring-security/reference/servlet/oauth2/login/core.html#oauth2login-boot-property-mappings) konfiguration und für die Konfiguration des [Resource Servers via JWT](https://docs.spring.io/spring-security/reference/servlet/oauth2/resource-server/jwt.html) z.B.

Zudem kann das Verhalten der Urlaubsverwaltung anhand von `uv.security.oidc` beeinflusst werden.

Es wird erwartet, dass der OIDC Provider im Access Token folgende Attribute enthält: `given_name`, `family_name`, `email`. Der client registration muss deshalb mit den Scopes `openid`,`profile` und `email` konfiguriert werden.

Der erste Benutzer, welcher sich erfolgreich bei der Urlaubsverwaltung anmeldet, wird mit der Rolle `Office` angelegt. Dies ermöglicht Benutzer- und Rechteverwaltung und das Pflegen der Einstellungen innerhalb der Anwendung.

#### Datenbank konfigurieren

Die Anwendung verwendet zur Speicherung der Daten ein PostgreSQL-Datenbankmanagementsystem.
Erstelle in deinem PostgreSQL-Datenbankmanagementsystem eine Datenbank sowie einen Benutzer mit Zugriffsrechten für diese Datenbank und konfiguriere diese

```yaml
spring:
  datasource:
    url: jdbc:postgresql://$HOST:$PORT/$NAME_DER_DATENBANK
    username: $BENUTZER
    password: $PASSWORT
```
Wenn Sie die Urlaubsverwaltung das erste Mal starten, werden automatisch alle Datenbanktabellen angelegt.

#### E-Mail-Server konfigurieren

Um den E-Mail-Server zu konfigurieren, müssen folgende Konfigurationen vorgenommen werden.

```yaml
uv:
  mail:
    from: absender@example.org
    fromDisplayName: Urlaubsverwaltung
    replyTo: no-reply@example.org
    replyToDisplayName: Urlaubsverwaltung
    application-url: https://example.org
spring:
  mail:
    host: $HOST
    port: $PORT
    username: $USERNAME
    password: $PASSWORT
```

Alle weiteren `spring.mail.*` Konfigurationen können in der [Spring Dokumentation](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#io.email)
eingesehen werden.

#### Benutzer-Synchronisation konfigurieren

Personen werden nicht mehr automatisch in die Urlaubsverwaltung synchronisiert,
sondern nur noch beim Login der jeweiligen Person in der Urlaubsverwaltung angelegt.

#### Logging konfigurieren

Sollten beim Starten der Anwendung Probleme auftreten, lässt sich in der Konfigurationsdatei eine
ausführliche Debug-Ausgabe konfigurieren, indem das `logging.level.*` pro Paket konfiguriert wird,

```yaml
logging:
  level:
    org.springframework.security: TRACE
    org.synyx.urlaubsverwaltung: TRACE
```

sowie eine Logdatei

```yaml
logging.file.name: logs/urlaubsverwaltung.log
```

geschrieben wird.

#### Info-Banner

Es kann ein Info-Banner konfiguriert werden, um z. B. Wartungsarbeiten anzukündigen.
Der Banner ist dann ganz oben zu sehen.

```properties
uv.info-banner.enabled=true
uv.info-banner.text.de=Wartungsarbeiten ab Freitag 14:00. Es kann zu Beeinträchtigungen kommen.
```

| Property                        | Type    | Description                                          |
|---------------------------------|---------|------------------------------------------------------|
| uv.info-banner.enabled          | Boolean | (default) `false`, `true` zum aktivieren des Banners |
| uv.info-banner.text.de          | String  | Text des Info-Banners für das Deutsche Locale.       |

#### Launchpad

Es kann ein Launchpad konfiguriert werden, welches einen Absprung zu anderen Anwendungen ermöglicht.

```yaml
launchpad:
  name-default-locale: de
  apps[1]:
    icon: ''
    name:
      de: Anwendung 2
      en: App 2
    url: https://example-2.org
  apps[0]:
    icon: ''
    name:
      en: App 1
      de: Anwendung 1
    url: https://example.org
```

| Property                        | Type     | Description                                                                                |
|---------------------------------|----------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
| launchpad.name-default-locale   | Locale   | Standard Name der Anwendung wenn für ein Locale keine Übersetzung gefunden wird.                                                                           |
| launchpad.apps[x].url           | String   | URL der Anwendung.                                                                                |
| launchpad.apps[x].name.[locale] | String   | Name der Anwendung für ein Locale.                                                                                |
| launchpad.apps[x].icon          | String   | URL eines Bildes oder ein base64 encodiertes Bild. Wird in das `<img src="" />` Attribut geschrieben.<br/>Das Bild sollte optimalerweise ein Quadrat sein. |

Das Launchpad hat eigene Übersetzungen. Spring muss entsprechend konfiguriert werden, damit die messages.properties gefunden wird:

```yaml
spring.messages.basename: messages,launchpad-core
```

* **(required)** `messages` standardmäßige application messages properties
* **(required)** `launchpad-core` launchpad message properties

### Anwendung als Service

Da die Anwendung auf Spring Boot basiert, lässt sie sich sehr komfortabel als Service installieren. Wie genau dies
funktioniert, kann den entsprechenden Kapiteln der Spring Boot Dokumentation entnommen werden:

* [Linux Service](https://docs.spring.io/spring-boot/docs/current/reference/html/deployment.html#deployment-service)
* [Windows Service](https://docs.spring.io/spring-boot/docs/current/reference/html/deployment.html#deployment-windows)

---

## Demodaten-Modus

### Starten der Anwendung im Demodaten-Modus

Um die Anwendung möglichst schnell lokal ausprobieren zu können, bietet es sich an
die Datenbank via [Docker Compose](https://docs.docker.com/compose/overview/) zu starten:

```bash
docker-compose up
```

und die Anwendung mit dem Profil `demodata` zu starten:

```bash
java -jar -Dspring.profiles.active=demodata urlaubsverwaltung.jar
```

Auf diese Weise wird die Anwendung mit einer PostgreSQL-Datenbankmanagementsystem gestartet und Demodaten generiert.

Die Demodaten enthalten folgende **Benutzer**, ein Passwort wird nicht benötigt:

| Benutzername                                 | Passwort | Rolle                            |
|----------------------------------------------|----------|----------------------------------|
| user@urlaubsverwaltung.cloud                 | secret   | User                             |
| departmentHead@urlaubsverwaltung.cloud       | secret   | User & Abteilungsleiter          |
| secondStageAuthority@urlaubsverwaltung.cloud | secret   | User & Freigabe-Verantwortlicher |
| boss@urlaubsverwaltung.cloud                 | secret   | User & Chef                      |
| office@urlaubsverwaltung.cloud               | secret   | User & Office                    |
| admin@urlaubsverwaltung.cloud                | secret   | User & Admin                     |

Möchte man, dass beim Starten der Anwendung keine Demodaten generiert werden, muss die Konfiguration

`uv.development.demodata.create`

in den [application-demodata.yaml](https://github.com/urlaubsverwaltung/urlaubsverwaltung/blob/main/src/main/resources/application-demodata.yaml)
auf `false` gesetzt werden.

### Aufrufen der Anwendung

Folgende Systeme sind erreichbar unter `localhost`

| Service                                    | Port |
|--------------------------------------------|------|
| [Urlaubsverwaltung](http://localhost:8080) | 8080 |
| [Mailhog](http://localhost:8025)           | 8025 |
| Mailhog SMTP                               | 1025 |

---

## Entwicklung

Wenn du uns bei der **Entwicklung** der Urlaubsverwaltung **unterstützen** möchtest,
dann schau dir die [Contributing to Urlaubsverwaltung](./CONTRIBUTING.md) Referenz und die folgenden
Abschnitte an. Bei Fragen kannst du gerne [ein neue Q&A](https://github.com/urlaubsverwaltung/urlaubsverwaltung/discussions/new?category=q-a) erstellen.

### Voraussetzungen

* [JDK 21](https://adoptium.net)
* [Docker 20.10.+](https://docs.docker.com/get-docker/)
* [Docker Compose](https://docs.docker.com/compose/install/)

### Repository clonen

Ohne GitHub Account

```bash
https://github.com/urlaubsverwaltung/urlaubsverwaltung.git
```

mit GitHub Account

```bash
git clone git@github.com:urlaubsverwaltung/urlaubsverwaltung.git
```

### git hooks (optional)

Zum Automatisieren verschiedener Dinge bietet dir das Projekt [git hooks](https://git-scm.com/book/uz/v2/Customizing-Git-Git-Hooks)
an. Diese kannst du mit folgendem Befehl installieren:

```bash
git config core.hooksPath '.githooks'
```

Die Git-Hooks sind im [.githooks](./.githooks/) Verzeichnis zu finden.

### Anwendung starten

Die Urlaubsverwaltung ist eine [Spring Boot](http://projects.spring.io/spring-boot/) Anwendung und kann mit dem Maven
Plugin gestartet werden. Alle Abhängigkeiten, wie die Datenbank oder der Mail-Server werden automatisch gestartet.
Es bietet sich an, die Anwendung mit dem Profil `demodata` zu starten, um Testdaten generieren
zu lassen:

```bash
./mvnw clean spring-boot:run -Dspring-boot.run.jvmArguments="-Dspring.profiles.active=demodata"
```

bzw. für Windows Benutzer über:

```bash
./mvnw.cmd clean spring-boot:run -Dspring-boot.run.jvmArguments="-Dspring.profiles.active=demodata"
```

### Anwendung nutzen

Im Browser lässt sich die Anwendung dann über [http://localhost:8080/](http://localhost:8080/) ansteuern.

Mit dem `demodata` Profil wird eine PostgreSQL-Datenbank verwendet und es werden Demodaten angelegt,
d.h. Benutzer, Urlaubsanträge und Krankmeldungen. Daher kann man sich in der Weboberfläche nun mit verschiedenen
[Demodaten-Benutzer](#demodaten-benutzer) anmelden.

### Frontend Entwicklung

Die 'User Experience' einiger Seiten wird zur Laufzeit mit JavaScript weiter verbessert.

Assets sind in `<root>/src/main/javascript` zu finden

* `bundles` sind in den HTML-Seiten zu integrieren
* `components` sind einzelne Komponenten zur Wiederverwendung wie z. B. der _datepicker_
* `js` beinhaltet seitenspezifische Dinge
* `lib` sind third-party Bibliotheken

Der Frontend Build ist in Maven integriert. Isoliert können die Assets aber auch auf der Kommandozeile gebaut werden.

* `npm run build`
  * baut optimierte, minifizierte Assets
  * Info: der Dateiname beinhaltet einen Hash welcher eindeutig zum Inhalt des Assets passt
* `npm run build:dev`
  * baut nicht minifizierte Assets
* `npm run build:watch`
  * baut automatisch nach dem Editieren von JavaScript / CSS Dateien neue Assets

#### Long term caching von Assets

Startet man den Maven Build oder baut man die Assets mit dem NPM Task `npm run build` wird eine JSON Datei `assets-manifest.json` angelegt.
Das Manifest beschreibt ein Mapping der bundles zum generierten Dateinamen inklusive Hash. Dieser gemappte Dateiname muss
in den Html-Seiten integriert werden. Damit das nicht bei jeder Änderung manuell gemacht werden muss, kann der Dateiname mit Hilfe der
Taglib `AssetsHashResolverTag.java` zur Kompilierungszeit automatisiert werden.

```html
<script defer asset:src="npm.jquery.js"></script>
```

Während der Weiterentwicklung ist es sinnvoll das Caching zu deaktivieren. Wird das `demodata` Profil verwendet muss
nichts weiter getan werden. Verwendest du das Profil nicht, kannst du das Caching mit folgenden application Properties
deaktivieren:

```yaml
spring:
  web:
    resources:
      chain:
        cache: 'false'
        strategy:
          content:
            enabled: 'false'
        cache:
          cachecontrol:
            max-age: '0'
```

#### Icons

Wir nutzen das großartige Lucide Icon Set. Vielen Dank! ♥

- https://lucide.dev
- https://github.com/lucide-icons/lucide

### API

Die Urlaubsverwaltung verfügt über eine API, die unter [http://localhost:8080/api](http://localhost:8080/api) erreichbar ist.

### UI Tests mit Playwright

Im [test ui](src/test/java/org/synyx/urlaubsverwaltung/ui) Package befinden sich UI Tests. Diese testen einige
End to End Anwendungsfälle wie z. B. in den Einstellungen etwas aktivieren/deaktivieren und dessen Auswirkungen.

Als Testrunner und auch Assertion Lib wird [Playwright-Java](https://playwright.dev/java/) verwendet.
Details siehe [Playwright for Java Getting Started](https://playwright.dev/java/docs/intro).

#### Headless Browser

Die Tests laufen standardmäßig ohne sichtbaren Browser (headless).
Das kann im [PageParameterResolver](src/test/java/org/synyx/urlaubsverwaltung/ui/extension/PageParameterResolver.java)
mit `BrowserType.LaunchOptions` entsprechend konfiguriert werden.

```java
final Browser browser = playwright.chromium().launch(new BrowserType.LaunchOptions().setHeadless(false));
```

#### Debugging

Playwright bietet einen eigenen Inspector an. Siehe [Playwright Debugging Tests](https://playwright.dev/java/docs/debug)
für weitere Informationen.

Um diesen zu nutzen, muss beim Starten des Tests die Umgebungsvariable `PWDEBUG=1` gesetzt werden.

### Release

### GitHub action

Go to the GitHub action with the name [release trigger][github-action-release-trigger].
* Click on "Run workflow"
* Add the "Milestone ID" (see in the uri of a milestone)
* Add "Release version"
* Add "Next version"
* Run the workflow

[Landingpage]: https://urlaubsverwaltung.cloud "Landingpage"
[Demo-System]: https://urlaubsverwaltung.cloud/demo "Demo-System"
[Hilfe]: https://urlaubsverwaltung.cloud/hilfe/ "Hilfe"
[Migration-Guide-v5]: https://github.com/urlaubsverwaltung/urlaubsverwaltung/wiki/Urlaubsverwaltung-5.0-Migration-Guide "Migration Guide v5"
[github-action-release-trigger]: https://github.com/urlaubsverwaltung/urlaubsverwaltung/actions/workflows/release-trigger.yml "Release Trigger"
[PostgreSQL]: https://www.postgresql.org/ "PostgreSQL"


[![](https://github.com/scijava/script-editor/actions/workflows/build-main.yml/badge.svg)](https://github.com/scijava/script-editor/actions/workflows/build-main.yml)

SciJava Script Editor
---------------------

Script Editor and Interpreter for SciJava script languages.

## Testing from the command line

### Script Editor

```
mvn -Pexec,editor
```

### Script Interpreter

```
mvn -Pexec,interp
```


一个基于 Spring Boot、MyBatis-Plus、MySQL、Redis、ElasticSearch、MongoDB、Docker、RabbitMQ 等技术栈实现的社区系统，采用主流的互联网技术架构、全新的UI设计、支持一键源码部署，拥有完整的文章&教程发布/搜索/评论/统计流程等，代码完全开源，没有任何二次封装，是一个非常适合二次开发/实战的现代化社区项目👍 。

## 一、配套服务

1. **技术派网址**：[https://paicoding.com](https://paicoding.com)
2. **技术派教程**：[https://paicoding.com/column](https://paicoding.com/column) 目前已更新高并发手册、JVM 手册、Java 并发编程手册、二哥的 Java 进阶之路，以及技术派部分免费教程。我们的宗旨是：**学编程，就上技术派**😁
3. **技术派管理端源码**：[paicoding-admin](https://github.com/itwanger/paicoding-admin)
4. **技术派专属学习圈子**：[不走弯路，少采坑，附 120 篇技术派全套教程](https://paicoding.com/article/detail/17)
5. **派聪明AI助手**：AI 时代，怎能掉队，欢迎体验 [技术派的派聪明 AI 助手](https://paicoding.com/chat)
6. **码云仓库**：[https://gitee.com/itwanger/paicoding](https://gitee.com/itwanger/paicoding) （国内访问速度更快）

## 二、项目介绍

### 项目演示

#### 前台社区系统

- 项目仓库（GitHub）：[https://github.com/itwanger/paicoding](https://github.com/itwanger/paicoding)
- 项目仓库（码云）：[https://gitee.com/itwanger/paicoding](https://gitee.com/itwanger/paicoding)
- 项目演示地址：[https://paicoding.com](https://paicoding.com)

![](https://cdn.tobebetterjavaer.com/images/20230602/d7d341c557e7470d9fb41245e5bb4209.png)

#### 后台社区系统

- 项目仓库（GitHub）：[https://github.com/itwanger/paicoding-admin](https://github.com/itwanger/paicoding-admin)
- 项目仓库（码云）：[https://gitee.com/itwanger/paicoding-admin](https://gitee.com/itwanger/paicoding-admin)
- 项目演示地址：[https://paicoding.com/admin-view](https://paicoding.com/admin/)

![](https://cdn.tobebetterjavaer.com/images/20230602/83139e13a4784c0fbf0adedd8e287c5b.png)

#### 代码展示

![](https://cdn.tobebetterjavaer.com/images/20231205/b8f76cb8e09f4ebca84b3ddd3b61c13e.png)

### 架构图

#### 系统架构图

![](https://cdn.tobebetterjavaer.com/paicoding/3da165adfcad0f03d40e13e941ed4afb.png)

#### 业务架构图

![](https://cdn.tobebetterjavaer.com/paicoding/main/paicoding-business.jpg)

### 组织结构

```
paicoding
├── paicoding-api -- 定义一些通用的枚举、实体类，定义 DO\DTO\VO 等
├── paicoding-core -- 核心工具/组件相关模块，如工具包 util， 通用的组件都放在这个模块（以包路径对模块功能进行拆分，如搜索、缓存、推荐等）
├── paicoding-service -- 服务模块，业务相关的主要逻辑，DB 的操作都在这里
├── paicoding-ui -- HTML 前端资源（包括 JavaScript、CSS、Thymeleaf 等）
├── paicoding-web -- Web模块、HTTP入口、项目启动入口，包括权限身份校验、全局异常处理等
```

#### 环境配置说明

资源配置都放在 `paicoding-web` 模块的资源路径下，通过maven的env进行环境选择切换

当前提供了四种开发环境

- resources-env/dev: 本地开发环境，也是默认环境
- resources-env/test: 测试环境
- resources-env/pre: 预发环境
- resources-env/prod: 生产环境

环境切换命令

```bash
# 如切换生产环境
mvn clean install -DskipTests=true -Pprod
```

#### 配置文件说明

- resources
  - application.yml: 主配置文件入口
  - application-config.yml: 全局的站点信息配置文件
  - logback-spring.xml: 日志打印相关配置文件
  - liquibase: 由liquibase进行数据库表结构管理
- resources-env
  - xxx/application-dal.yml: 定义数据库相关的配置信息
  - xxx/application-image.yml: 定义上传图片的相关配置信息
  - xxx/application-web.yml: 定义web相关的配置信息

#### [前端工程结构说明](docs/前端工程结构说明.md)

### 技术选型

后端技术栈

|         技术          | 说明                   | 官网                                                                                |
|:-------------------:|----------------------|----------------------------------------------------------------------------------------------------|
| Spring & SpringMVC  | Java全栈应用程序框架和WEB容器实现 | [https://spring.io/](https://spring.io/)                                                           |
|     SpringBoot      | Spring应用简化集成开发框架     | [https://spring.io/projects/spring-boot](https://spring.io/projects/spring-boot)                   |
|       mybatis       | 数据库orm框架             | [https://mybatis.org](https://mybatis.org)                                                       |
|    mybatis-plus     | 数据库orm框架             | [https://baomidou.com/](https://baomidou.com/)                                                     |
| mybatis PageHelper  | 数据库翻页插件              | [https://github.com/pagehelper/Mybatis-PageHelper](https://github.com/pagehelper/Mybatis-PageHelper) |
|    elasticsearch    | 近实时文本搜索              | [https://www.elastic.co/cn/elasticsearch/service](https://www.elastic.co/cn/elasticsearch/service) |
|        redis        | 内存数据存储               | [https://redis.io](https://redis.io)                                                               |
|      rabbitmq       | 消息队列                 | [https://www.rabbitmq.com](https://www.rabbitmq.com)                                               |
|       mongodb       | NoSql数据库             | [https://www.mongodb.com/](https://www.mongodb.com/)                                               |
|        nginx        | 服务器                  | [https://nginx.org](https://nginx.org)                                                             |
|       docker        | 应用容器引擎               | [https://www.docker.com](https://www.docker.com)                                                   |
|      hikariCP       | 数据库连接                | [https://github.com/brettwooldridge/HikariCP](https://github.com/brettwooldridge/HikariCP)         |
|         oss         | 对象存储                 | [https://help.aliyun.com/document_detail/31883.html](https://help.aliyun.com/document_detail/31883.html)                                               |
|        https        | 证书                   | [https://letsencrypt.org/](https://letsencrypt.org/)                                               |
|         jwt         | jwt登录                | [https://jwt.io](https://jwt.io)                                                                   |
|       lombok        | Java语言增强库            | [https://projectlombok.org](https://projectlombok.org)                                             |
|        guava        | google开源的java工具集     | [https://github.com/google/guava](https://github.com/google/guava)                                 |
|      thymeleaf      | html5模板引擎            | [https://www.thymeleaf.org](https://www.thymeleaf.org)                                             |
|       swagger       | API文档生成工具            | [https://swagger.io](https://swagger.io)                                                           |
| hibernate-validator | 验证框架                 | [hibernate.org/validator/](hibernate.org/validator/)                                               |
|     quick-media     | 多媒体处理                | [https://github.com/liuyueyi/quick-media](https://github.com/liuyueyi/quick-media)                 |
|      liquibase      | 数据库版本管理              | [https://www.liquibase.com](https://www.liquibase.com)                                             |
|       jackson       | json/xml处理           | [https://www.jackson.com](https://www.jackson.com)                                                 |
|      ip2region      | ip地址                 | [https://github.com/zoujingli/ip2region](https://github.com/zoujingli/ip2region)                   |
|      websocket      | 长连接                  | [https://docs.spring.io/spring/reference/web/websocket.html](https://docs.spring.io/spring/reference/web/websocket.html)                   |
|      sensitive-word      | 敏感词                  | [https://github.com/houbb/sensitive-word](https://github.com/houbb/sensitive-word)                   |
|       chatgpt       | chatgpt              | [https://openai.com/blog/chatgpt](https://openai.com/blog/chatgpt)                   |
|        讯飞星火         | 讯飞星火大模型              | [https://www.xfyun.cn/doc/spark/Web.html](https://www.xfyun.cn/doc/spark/Web.html#_1-%E6%8E%A5%E5%8F%A3%E8%AF%B4%E6%98%8E)                   |

## 三、技术派教程
技术派教程共 120+ 篇，从中整理出 20 篇，供大家免费学习。
- [（🌟 新人必看）技术派系统架构&功能模块一览](https://paicoding.com/article/detail/15)
- [（🌟 新人必看）小白如何学习技术派](https://paicoding.com/article/detail/366)
- [（🌟 新人必看）如何将技术派写入简历](https://paicoding.com/article/detail/373)
- [（🌟 新人必看）技术派架构方案设计](https://paicoding.com/column/6/5)
- [（🌟 新人必看）技术派技术方案设计](https://paicoding.com/article/detail/208)
- [（🌟 新人必看）技术派项目管理流程](https://paicoding.com/article/detail/445)
- [（🌟 新人必看）技术派MVC分层架构](https://paicoding.com/article/detail/446)
- [（🌟 新人必看）技术派项目工程搭建手册](https://paicoding.com/article/detail/459)
- [（👍 强烈推荐）技术派微信公众号自动登录](https://paicoding.com/article/detail/448)
- [（👍 强烈推荐）技术派微信扫码登录实现](https://paicoding.com/article/detail/453)
- [（👍 强烈推荐）技术派Session/Cookie身份验证识别](https://paicoding.com/article/detail/449)
- [（👍 强烈推荐）技术派Mysql/Redis缓存一致性](https://paicoding.com/column/6/3)
- [（👍 强烈推荐）技术派Redis实现用户活跃排行榜](https://paicoding.com/article/detail/454)
- [（👍 强烈推荐）技术派消息队列RabbitMQ](https://paicoding.com/column/6/2)
- [（👍 强烈推荐）技术派消息队列RabbitMQ连接池](https://paicoding.com/column/6/1)
- [（👍 强烈推荐）技术派消息队列Kafka](https://paicoding.com/article/detail/460)
- [（👍 强烈推荐）技术派Cancal实现MySQL和ES同步](https://paicoding.com/column/6/8)
- [（👍 强烈推荐）技术派ES实现查询](https://paicoding.com/article/detail/341)
- [（👍 强烈推荐）技术派定时任务实现](https://paicoding.com/article/detail/457)
- [（👍 扬帆起航）送给坚持到最后的自己，一起杨帆起航](https://paicoding.com/article/detail/447)

## 四、环境搭建

### 开发工具

|        工具        | 说明           | 官网                                                                                |
|:----------------:|--------------|--------------------------------------------------------------------------------------------------------------|
|       IDEA       | java开发工具     | [https://www.jetbrains.com](https://www.jetbrains.com)                                                       |
|     Webstorm     | web开发工具      | [https://www.jetbrains.com/webstorm](https://www.jetbrains.com/webstorm)                                     |
|      Chrome      | 浏览器          | [https://www.google.com/intl/zh-CN/chrome](https://www.google.com/intl/zh-CN/chrome)                         |
|   ScreenToGif    | gif录屏        | [https://www.screentogif.com](https://www.screentogif.com)                                                   |
|     SniPaste     | 截图           | [https://www.snipaste.com](https://www.snipaste.com)                                                         |
|     PicPick      | 图片处理工具       | [https://picpick.app](https://picpick.app)                                                                   |
|     MarkText     | markdown编辑器  | [https://github.com/marktext/marktext](https://github.com/marktext/marktext)                                 |
|       curl       | http终端请求     | [https://curl.se](https://curl.se)                                                                           |
|     Postman      | API接口调试      | [https://www.postman.com](https://www.postman.com)                                                           |
|     draw.io      | 流程图、架构图绘制    | [https://www.diagrams.net/](https://www.diagrams.net/)                                                       |
|      Axure       | 原型图设计工具      | [https://www.axure.com](https://www.axure.com)                                                     |
|     navicat      | 数据库连接工具      | [https://www.navicat.com](https://www.navicat.com)                                                           |
|     DBeaver      | 免费开源的数据库连接工具 | [https://dbeaver.io](https://dbeaver.io)                                                                     |
|      iTerm2      | mac终端        | [https://iterm2.com](https://iterm2.com)                                                                     |
| windows terminal | win终端        | [https://learn.microsoft.com/en-us/windows/terminal/install](https://learn.microsoft.com/en-us/windows/terminal/install) |
|   SwitchHosts    | host管理       | [https://github.com/oldj/SwitchHosts/releases](https://github.com/oldj/SwitchHosts/releases)                 |

### 开发环境

|      工具       | 版本        | 下载                                                                                |
|:-------------:|:----------|------------------------------------------------------------------------------------------------------------------------|
|      jdk      | 1.8+      | [https://www.oracle.com/java/technologies/downloads/#java8](https://www.oracle.com/java/technologies/downloads/#java8) |
|     maven     | 3.4+      | [https://maven.apache.org/](https://maven.apache.org/)                                                                 |
|     mysql     | 5.7+/8.0+ | [https://www.mysql.com/downloads/](https://www.mysql.com/downloads/)                                                   |
|     redis     | 5.0+      | [https://redis.io/download/](https://redis.io/download/)                                                               |
| elasticsearch | 8.0.0+    | [https://www.elastic.co/cn/downloads/elasticsearch](https://www.elastic.co/cn/downloads/elasticsearch)                 |
|     nginx     | 1.10+     | [https://nginx.org/en/download.html](https://nginx.org/en/download.html)                                               |
|   rabbitmq    | 3.10.14+  | [https://www.rabbitmq.com/news.html](https://www.rabbitmq.com/news.html)                                               |
|    ali-oss    | 3.15.1    | [https://help.aliyun.com/document_detail/31946.html](https://help.aliyun.com/document_detail/31946.html)               |
|      git      | 2.34.1    | [http://github.com/](http://github.com/)                                                                               |
|    docker     | 4.10.0+   | [https://docs.docker.com/desktop/](https://docs.docker.com/desktop/)                                                   |
| let's encrypt | https证书   | [https://letsencrypt.org/](https://letsencrypt.org/)                                                                   |

### 搭建步骤

#### 本地部署教程

> [本地开发环境手把手教程](docs/本地开发环境配置教程.md)

### 云服务器部署教程

> [环境搭建 & 基于源码的部署教程](docs/安装环境.md)
> [服务器启动教程](docs/服务器启动教程.md)

## 五、友情链接

- [toBeBetterjavaer](https://github.com/itwanger/toBeBetterJavaer) ：一份通俗易懂、风趣幽默的Java学习指南，内容涵盖Java基础、Java并发编程、Java虚拟机、Java企业级开发、Java面试等核心知识点。学Java，就认准二哥的Java进阶之路😄
- [paicoding-admin](https://github.com/itwanger/paicoding-admin) ：🚀🚀🚀 paicoding-admin，技术派管理端，基于 React18、React-Router v6、React-Hooks、Redux、TypeScript、Vite3、Ant-Design 5.x、Hook Admin、ECharts 的一套社区管理系统，够惊艳哦。

## 六、鸣谢

技术派收到了 [Jetbrains](https://jb.gg/OpenSourceSupport) 多份 Licenses（详情戳 [这里](https://paicoding.com/article/detail/331) ），并已分配给项目 [活跃开发者](https://github.com/itwanger/paicoding/graphs/contributors) ，非常感谢 Jetbrains 对开源社区的支持。

![JetBrains Logo (Main) logo](https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.svg)

## 七、star 趋势图

[![Star History Chart](https://api.star-history.com/svg?repos=itwanger/paicoding&type=Date)](https://star-history.com/#itwanger/paicoding&Date)

## 八、公众号

GitHub 上标星 10000+ 的开源知识库《 [二哥的 Java 进阶之路](https://github.com/itwanger/toBeBetterJavaer) 》第一版 PDF 终于来了！包括Java基础语法、数组&字符串、OOP、集合框架、Java IO、异常处理、Java 新特性、网络编程、NIO、并发编程、JVM等等，共计 32 万余字，可以说是通俗易懂、风趣幽默……详情戳：[太赞了，GitHub 上标星 8700+ 的 Java 教程](https://javabetter.cn/overview/)

微信搜 **沉默王二** 或扫描下方二维码关注二哥的原创公众号，回复 **222** 即可免费领取。

![](https://cdn.tobebetterjavaer.com/tobebetterjavaer/images/gongzhonghao.png)

## 九、许可证

[Apache License 2.0](https://github.com/itwanger/paicoding/edit/main/README.md)

Copyright (c) 2022-2023 技术派（楼仔、沉默王二、一灰、小超）


# cryptoshred

![Java CI](https://github.com/prisma-capacity/cryptoshred/workflows/Java%20CI/badge.svg?branch=main)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/333bfd567a6a447895212994b414f077)](https://app.codacy.com/gh/prisma-capacity/cryptoshred?utm_source=github.com&utm_medium=referral&utm_content=prisma-capacity/cryptoshred&utm_campaign=Badge_Grade_Settings)
[![codecov](https://codecov.io/gh/prisma-capacity/cryptoshred/branch/main/graph/badge.svg)](https://codecov.io/gh/prisma-capacity/cryptoshred)
[![MavenCentral](https://img.shields.io/maven-central/v/eu.prismacapacity/cryptoshred)](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22eu.prismacapacity%22)

### Motivation

Cryptoshredding is a well-known technique to 'erase' encrypted data by throwing away the key necessary for decryption.
Two out of numerous advantages are

* You do not have to actually remove (or update) data, so that it can be immutable
* You don't have to keep track of where it is used, as long as it stays encrypted

see https://en.wikipedia.org/wiki/Crypto-shredding

### cryptoshred library

In order to make use of that technique, you need to encrypt data before writing in the first place and maintain keys for the subjects. This is what cryptoshred can do for you.

#### Features

* Pluggable Metrics interface
  * optional Micrometer impl.
* Pluggable CryptoEngine
  * JDK-based impl.
* Pluggable Key Repository
  * optional Amazon DynamoDB impl.
* optional Spring-Boot autoconfiguration module
* Jackson based deserialization to Java Objects
* Evolutionary approach to key definition creation and migration

### Encryption

In order to encrypt a particular piece of data, you wrap it in a CryptoContainer before persisting (serializing).

```java
@Data
public class Person { // might be an Enitity, a POJO you serialize or anything you want to persist
  int age;
  CryptoContainer<String> name;
}
```
In order to wrap the data you'll also need to provide a 'CryptoSubjectId', that references the actual key, that you'd want to throw away in order to do the 'deletion' afterwards)

```java
CryptoSubjectId id = CryptoSubjectId.of(UUID.randomUUID()); // simple value object

Person p = new Person();
p.name = new CryptoContainer<>("Peter", id);
p.age = 30;

// go persist the Person
```
A CryptoContainer consists of the following data:

* SubjectId (which is associated to the actual key used for en/de-cryption)
* Algorithm used
* KeySize used
* Type of Object // String in this example
* Encoded byte array of the serialized form of the Object wrapped.

You can wrap any Jackson-serializable object like for instance

```java
CryptoKeyRepository repo = new InMemCryptoKeyRepository(engine); // don't do this at home
ObjectMapper om = new ObjectMapper();
om.registerModule(new CryptoModule(engine,repo)); // not needed when using Spring Boot autoconfiguration

CryptoSubjectId id = CryptoSubjectId.of(UUID.randomUUID()); // simple value object, you would want to use a userId for that, and not a silly random.

Person p = new Person();
p.name = new CryptoContainer<>("Peter", id);
p.age = 30;
p.creditcard = new CryptoContainer<>(new CreditCardInfo("12341234",CrediCardTypes.VISA),id);
// go persist the Person
```

### Decryption

When using ObjectMapper to deserialize a 'CryptoContainer', all necessary dependencies are injected into the Container automatically, so you can use the 'CryptoContainer' just like an Optional (it copied all the methods from 'java.util.Optional').

```java

String json = om.writeValueAsString(p);

Person p2 = om.readValue(json, Person.class);
assertTrue(p2.name.isPresent());
assertEquals("Peter",p2.name.get());

// if you deleted the key in between, name.isPresent() would be false.
// of course you should rather use p2.name.orElse("unknown") or something rather than get, but you know all that from using Optional...
```

### Spring Boot Compatibility

| Library version | Spring Boot version |
|-----------------|---------------------|
| 1.x.x           | 2.7+                |
| 2.x.x           | 3.1+                |


[![Build and test MR](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_mr.yml/badge.svg)](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_mr.yml)
[![Build and test spark](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_spark.yml/badge.svg)](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_spark.yml)
[![Build and test spark 20](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_spark_20.yml/badge.svg)](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_spark_20.yml)
[![Build and test spark 30](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_spark_30.yml/badge.svg)](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_spark_30.yml)
[![Build and test hive](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_hive.yml/badge.svg)](https://github.com/opensearch-project/opensearch-hadoop/actions/workflows/build_hive.yml)
![PRs welcome!](https://img.shields.io/badge/PRs-welcome!-success)

![OpenSearch logo](OpenSearch.svg)

# OpenSearch Hadoop
OpenSearch real-time search and analytics natively integrated with Hadoop.
Supports [Map/Reduce](#mapreduce), [Apache Hive](#apache-hive), [Apache Spark](#apache-spark).

- [OpenSearch Hadoop](#opensearch-hadoop)
  - [Requirements](#requirements)
  - [Usage](#usage)
  - [Compatibility](#compatibility)
  - [Building the source](#building-the-source)
  - [License](#license)

## Requirements
OpenSearch (__1.3.x__ or higher) cluster accessible through REST. That's it!
If using SigV4 IAM auth features, you would need to include the [aws-sdk-bundle](https://mvnrepository.com/artifact/com.amazonaws/aws-java-sdk-bundle) in your job classpath.

## Usage

Please see the [USER_GUIDE](USER_GUIDE.md) for usage.

## Compatibility

See [Compatibility](COMPATIBILITY.md).

## Building the source

OpenSearch Hadoop uses [Gradle][] for its build system and it is not required to have it installed on your machine. By default (`gradlew`), it automatically builds the package and runs the unit tests. For integration testing, use the `integrationTests` task.
See `gradlew tasks` for more information.

To create a distributable zip, run `gradlew distZip` from the command line; once completed you will find the jar in `build/libs`.

To build the project, JVM 8, JVM 11, and JVM 17 are required. The minimum compiler version is Java 14 and the minimum runtime is Java 8.

## License
This project is released under version 2.0 of the [Apache License][]

```
Licensed to Elasticsearch under one or more contributor
license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright
ownership. Elasticsearch licenses this file to you under
the Apache License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
```

[Hadoop]: http://hadoop.apache.org
[Apache License]: http://www.apache.org/licenses/LICENSE-2.0
[Gradle]: http://www.gradle.org/


:readme:
:branch: 5.21
:docs: https://neo4j.com/docs/apoc/current
:apoc-release: 5.21.0
:neo4j-version: 5.21.0
:img: https://raw.githubusercontent.com/neo4j/apoc/dev/images

https://community.neo4j.com[image:https://img.shields.io/discourse/users?logo=discourse&server=https%3A%2F%2Fcommunity.neo4j.com[Discourse users]]
https://discord.gg/neo4j[image:https://img.shields.io/discord/787399249741479977?logo=discord&logoColor=white[Discord]]

= Awesome Procedures for Neo4j {branch}.x

// tag::readme[]

== Introduction

// tag::intro[]
image::{img}/apoc.png[float=right]

// tag::intro-text[]
Neo4j 3.x introduced the concept of user-defined procedures and functions.
Those are custom implementations of certain functionality, that can't be (easily) expressed in Cypher itself.
They are implemented in Java and can be easily deployed into your Neo4j instance, and then be called from Cypher directly.

As of 5.0 APOC has been split into separate repositories, one being the main, officially supported, APOC Library. The
other belonging to https://github.com/neo4j-contrib/neo4j-apoc-procedures[APOC Extended^]. This repository handles the core part of APOC.

There are over 400 different procedures and functions in the APOC library. Their purpose is to increase
functionality in areas such as data integration, graph algorithms and data conversion.

// end::intro-text[]

=== License

Apache License 2.0

// tag::name-history[]
=== "APOC" Name history

// tag::name-history-text[]
https://matrix.wikia.com/wiki/Apoc[Apoc^] was the technician and driver on board of the Nebuchadnezzar in the Matrix movie. He was killed by Cypher.

*APOC* was also the first bundled https://neo4j.com/blog/convenient-package-neo4j-apoc-0-1-released/[A Package Of Component^] for Neo4j in 2009.

*APOC* also stands for "Awesome Procedures On Cypher"
// end::name-history-text[]
// end::name-history[]

== Installation: With Neo4j Desktop

// tag::install-desktop[]

APOC can be installed with https://neo4j.com/download[Neo4j Desktop], after creating your database, by going to the `Manage` screen, and then the `Plugins` tab.
Click `Install` in the APOC box and wait until you see a green check mark near "APOC".

// end::install-desktop[]
image::{img}/desktop-apoc.jpg[width=800]

== Feedback

// tag::feedback[]
Please provide feedback and report bugs as https://github.com/neo4j/apoc/issues[GitHub issues] or join the https://community.neo4j.com/t5/forums/filteredbylabelpage/board-id/graph_platform/label-name/procedures%20&%20apoc[Neo4j Community Forum and ask in the APOC & Procedures category^].
// end::feedback[]

// tag::calling-procedures[]

== Calling Procedures & Functions within Cypher

// tag::usage[]
User defined *Functions* can be used in *any* expression or predicate, just like built-in functions.

*Procedures* can be called stand-alone with `CALL procedure.name();`

But you can also integrate them into your Cypher statements which makes them so much more powerful.

.Load JSON example
[source,cypher,subs=attributes]
----
WITH 'https://raw.githubusercontent.com/neo4j/apoc/{branch}/core/src/test/resources/person.json' AS url

CALL apoc.load.json(url) YIELD value as person

MERGE (p:Person {name:person.name})
   ON CREATE SET p.age = person.age, p.children = size(person.children)
----
// end::usage[]
// end::calling-procedures[]

// end::intro[]

== APOC Procedures & Functions Overview

All included procedures are listed in the link:{docs}/overview[overview in the documentation^] and detailed in subsequent sections.

=== Built in Help

// tag::help[]
image::{img}/apoc-help.jpg[width=600]

[cols="1m,5"]
|===
| call apoc.help('keyword') | lists name, description, signature, roles, based on keyword
|===

// end::help[]

== Detailed Feature Documentation

See the link:{docs}[APOC User Guide^] for documentation of each of the major features of the library, including data import/export, graph refactoring, data conversion, and more.

// tag::signature[]

== Procedure & Function Signatures

To call procedures correctly, you need to know their parameter names, types and positions.
And for YIELDing their results, you have to know the output column names and types.

INFO:The signatures are shown in error messages, if you use a procedure incorrectly.

You can see the procedure's signature in the output of `CALL apoc.help("name")`

[source,cypher]
----
CALL apoc.help("dijkstra")
----

The signature is always `name : : TYPE`, so in this case:

----
apoc.algo.dijkstra
 (startNode :: NODE?, endNode :: NODE?,
   relationshipTypesAndDirections :: STRING?, weightPropertyName :: STRING?)
:: (path :: PATH?, weight :: FLOAT?)
----

.Parameter Explanation
[opts=header,cols="m,m"]
|===
| Name | Type
h| Procedure Parameters |
| startNode | Node
| endNode | Node
| relationshipTypesAndDirections | String
| weightPropertyName | String
h| Output Return Columns |
| path  |  Path
| weight | Float
|===

// end::signature[]

== Manual Installation: Download the latest release

// tag::install[]

Since APOC relies on Neo4j's internal APIs you need to use the *matching APOC version* for your Neo4j installation.
Make sure that the *first two version numbers match between Neo4j and APOC*.

Go to https://github.com/neo4j/apoc/releases/latest[the latest release] for the matching *Neo4j version* and download the binary jar to place into your `$NEO4J_HOME/plugins` folder.

You can find https://github.com/neo4j/apoc/releases/[all releases here].

// end::install[]

== Manual Configuration

[WARNING]
====
// tag::warnings[]
For security reasons, procedures and functions that use internal APIs are disabled by default.
Loading and enabling APOC procedures and functions can be configured using the Neo4j config file.
For more details, see https://neo4j.com/docs/apoc/current/installation/#restricted[the APOC installation documentation].
// end::warnings[]
====

// tag::version-matrix[]
=== Version Compatibility

Since APOC relies in some places on Neo4j's internal APIs you need to use the right APOC version for your Neo4j installation.

APOC uses a consistent versioning scheme: `<neo4j-version>.<apoc>` version.
The trailing `<apoc>` part of the version number will be incremented with every apoc release.

One should always use the highest patch APOC version available for the related Neo4j Version.

For example:
When using Neo4j 5.4.0, the corresponding APOC version will be 5.4.x, where x is the highest patch version released.
In this case, if an APOC 5.4.0 and 5.4.1 version exist, one should use APOC 5.4.1.
If a Neo4j 5.4.2 version existed, it is still okay to use APOC 5.4.1, as only the first 2 numbers need to match.

For 4.4.x releases of APOC, all releases are found https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases[here].

// end::version-matrix[]
=== Get APOC Version

To know your current `apoc` version you can use the *function* :

[source,cypher]
----
RETURN apoc.version();
----

=== Using APOC with the Neo4j Docker image

// tag::docker[]

APOC can be used with the https://hub.docker.com/_/neo4j/[Neo4j Docker image] via the `NEO4J_PLUGINS` environment variable.
If we use this environment variable, the APOC plugin will be copied from the Docker image and configured at runtime.

[NOTE]
====
This feature is intended to facilitate using APOC in development environments, but it is not recommended for use in production environments.
====

.The following runs Neo4j {apoc-release} in a Docker container with the latest version of the APOC Library
[source,bash,subs=attributes]
----
docker run \
    -p 7474:7474 -p 7687:7687 \
    --name neo4j-apoc \
    -e NEO4J_apoc_export_file_enabled=true \
    -e NEO4J_apoc_import_file_enabled=true \
    -e NEO4J_apoc_import_file_use__neo4j__config=true \
    -e NEO4J_PLUGINS=\[\"apoc\"\] \
    neo4j:{neo4j-version}
----

We should see the following line in the output after running this command:

[source,text,subs=attributes]
----
Installing Plugin 'apoc' from /var/lib/neo4j/labs/apoc-*-core.jar to /var/lib/neo4j/plugins/apoc.jar
----

In a production environment we should download the latest APOC release matching our Neo4j version, and copy it to a local folder. Supplying it as a data volume mounted at `/plugins`.

.The following downloads the APOC Library into the `plugins` directory and then mounts that folder to the Neo4j Docker container
[source,bash,subs=attributes]
----
mkdir plugins
pushd plugins
wget https://github.com/neo4j/apoc/releases/download/{apoc-release}/apoc-{apoc-release}-core.jar
popd
docker run --rm -e NEO4J_AUTH=none -p 7474:7474 -v $PWD/plugins:/plugins -p 7687:7687 neo4j:{neo4j-version}
----

If you want to pass custom APOC config to your Docker instance, you can use environment variables, like here:

[source,bash,subs=attributes]
----
docker run \
    -p 7474:7474 -p 7687:7687 \
    -v $PWD/data:/data -v $PWD/plugins:/plugins \
    --name neo4j-apoc \
    -e apoc.export.file.enabled=true \
    -e apoc.import.file.enabled=true \
    -e apoc.import.file.use_neo4j_config=true \
    neo4j:{neo4j-version}
----

To then use Neo4j with Docker, it is possible to run the Cypher-shell like so:

[source,bash]
----
docker exec -it neo4j-apoc bin/cypher-shell
----

// end::docker[]
// tag::build[]

=== Build & install the current development branch from source

----
git clone https://github.com/neo4j/apoc
cd apoc
./gradlew shadow
cp build/extended/libs/apoc-<version>.jar $NEO4J_HOME/plugins/
$NEO4J_HOME/bin/neo4j restart
----

// If you want to run embedded or use neo4j-shell on a disk store, configure your `plugins` directory in `conf/neo4j.conf` with `dbms.plugin.directory=path/to/plugins`.

A full build including running the tests can be run by `./gradlew build`.

You can either copy the jar (build/libs) into the neo4j target folder (target/neo4j/plugins folder) or launch it in a
dockerized neo4j by mounting the directory containing the apoc-procedures jar as a volume.

// end::build[]
// tag::tests[]

=== Running APOC tests

With intellij - right-click on the test folder, and you will be able to run all tests from there
With gradle - ./gradlew test

Or as normal, click the play button on the test you would like to run.
// end::tests[]
// tag::codestyle[]
=== Applying Code-style

----
./gradlew spotlessApply
----

To apply the https://github.com/diffplug/spotless/tree/main/plugin-gradle#how-do-i-preview-what-spotlessapply-will-do[spotless] code-style, run the above gradle command, this will remove all unused imports

// end::codestyle[]


![TeachUA](images/logo.png)

# TeachUA BackEnd

[![Github Issues](https://img.shields.io/github/issues/ita-social-projects/TeachUA?style=flat-square)](https://github.com/ita-social-projects/TeachUA/issues)
[![Pending Pull-Requests](https://img.shields.io/github/issues-pr/ita-social-projects/TeachUA?style=flat-square)](https://github.com/ita-social-projects/TeachUA/pulls)
[![License](http://img.shields.io/:license-mit-blue.svg?style=flat-square)](http://badges.mit-license.org)

---

## Table of Contents (Optional)

> If your `README` has a lot of info, section headers might be nice.

- [Installation](#installation)
    - [Required to install](#Required-to-install)
    - [Environment](#Environment)
    - [Clone](#Clone)
    - [Setup](#Setup)
    - [How to run local](#How-to-run-local)
- [Usage](#Usage)
    - [How to work with swagger UI](#How-to-work-with-swagger-UI)
    - [How to run tests](#How-to-run-tests)
    - [How to Checkstyle](#How-to-Checkstyle)
- [Documentation](#Documentation))
- [Contributing](#contributing)
    - [git flow](#git-flow)
- [License](#license)

---

## Installation

- All the `code` required to get started
- Images of what it should look like

### Required to install

* JDK 8
* PostgreSQL

### Environment

environmental variables

```properties
WIP
```

### Clone

- Clone this repo to your local machine using `https://github.com/ita-social-projects/TeachUA`

### Setup

WIP

### How to run local

WIP

---

## Usage

### How to work with swagger UI

WIP

### How to run tests

- To tun unit and integration test use `mvn clean verify -D"checkstyle.skip"=true`
- To run unit tests use `mvn test -D"checkstyle.skip"=true`
- To run integration tests use
    - `mvn failsafe:integration-test`
    - `mvn clean verify -DskipUnitTests -D"checkstyle.skip"=true`

Parameters to skip test:

- `-DskipTests`
- `-DskipUnitTests`
- `-DskipIntegrationTests`

### How to Checkstyle

- To run checkstyle use `mvn validate`

To skip checkstyle use

- PowerShell `-D"checkstyle.skip"=true`
- cmd `-Dcheckstyle.skip`

### Setup Checkstyle

[You can read how to set up Checkstyle here](https://github.com/ita-social-projects/TeachUA/wiki/Tech-manuals#checkstyle-configuration-for-intellij-idea)

---

## Documentation

---

## Contributing

### Git flow

> To get started...

#### Step 1

WIP

### Issue flow

---

## FAQ

WIP

---

## License

[![License](http://img.shields.io/:license-mit-blue.svg?style=flat-square)](http://badges.mit-license.org)

- **[MIT license](http://opensource.org/licenses/mit-license.php)**
- Copyright 2020 ©  SoftServe IT Academy.


# Pokecube-Issues-and-Wiki
This is where all issues for the core pokecube mods should go, also this is where the main wiki should be maintained

Useful Documentation about the mod can be found here: https://pokecube.readthedocs.io/en/latest/

# Setting up Pokecube Development

Here are some instructions for setting up a development environment for Pokecube. This instruction set is for Eclipse, it may vary for a different IDE.

### Step 1: download this repository.

This can be easily done via `git clone https://github.com/Pokecube-Development/Pokecube-Issues-and-Wiki.git`, which should produce a Pokecube-Issues-and-Wiki directory, containing this git repository.

### Step 2: Import gradle project into Eclipse

In Eclipse, in `File->Import->Gradle`, select `Existing Gradle Project`, then for `Project root directory` select the directory cloned in Step 1, then press finish. This should start setting up the gradle project in eclipse, and may take a while to run, as it also downloads the forge SDK, and other dependencies.

### Step 3: Wait for Eclipse to finish building

After Step 2, Eclipse should try to build the project, this may also take a while, but once it finishes, you should be able to run Minecraft from inside Eclipse.