├── src
    ├── main
    │   ├── resources
    │   │   ├── webapp
    │   │   │   └── ROOT
    │   │   ├── META-INF
    │   │   │   └── services
    │   │   │   │   └── com.vaadin.flow.server.VaadinServiceInitListener
    │   │   ├── db
    │   │   │   └── migration
    │   │   │   │   ├── V01__CreateCategory.sql
    │   │   │   │   └── V02__CreateReview.sql
    │   │   └── simplelogger.properties
    │   ├── kotlin
    │   │   └── com
    │   │   │   └── vaadin
    │   │   │       └── starter
    │   │   │           └── beveragebuddy
    │   │   │               ├── Main.kt
    │   │   │               ├── backend
    │   │   │                   ├── RestService.kt
    │   │   │                   ├── Category.kt
    │   │   │                   ├── Review.kt
    │   │   │                   └── DemoData.kt
    │   │   │               ├── ui
    │   │   │                   ├── Toolbar.kt
    │   │   │                   ├── MainLayout.kt
    │   │   │                   ├── categories
    │   │   │                   │   ├── CategoryEditorDialog.kt
    │   │   │                   │   └── CategoriesList.kt
    │   │   │                   ├── EditorDialogFrame.kt
    │   │   │                   └── reviews
    │   │   │                   │   ├── ReviewEditorDialog.kt
    │   │   │                   │   └── ReviewsList.kt
    │   │   │               └── Bootstrap.kt
    │   └── frontend
    │   │   ├── index.html
    │   │   └── themes
    │   │       └── my-theme
    │   │           └── styles.css
    └── test
    │   └── kotlin
    │       └── com
    │           └── vaadin
    │               └── starter
    │                   └── beveragebuddy
    │                       ├── backend
    │                           ├── ReviewTest.kt
    │                           ├── ReviewWithCategoryTest.kt
    │                           ├── CategoryTest.kt
    │                           └── RestServiceTest.kt
    │                       ├── AbstractAppTest.kt
    │                       └── ui
    │                           ├── ReviewsListTest.kt
    │                           ├── CategoryEditorDialogTest.kt
    │                           ├── ReviewEditorDialogTest.kt
    │                           └── CategoriesListTest.kt
├── gradle
    ├── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
    └── libs.versions.toml
├── .gitignore
├── .github
    └── workflows
    │   └── gradle.yml
├── LICENSE
├── Dockerfile
├── gradlew.bat
├── README.md
└── gradlew


/src/main/resources/webapp/ROOT:
--------------------------------------------------------------------------------
1 | Don't delete this file; see Main.java for details.
2 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mvysny/beverage-buddy-vok/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/src/main/resources/META-INF/services/com.vaadin.flow.server.VaadinServiceInitListener:
--------------------------------------------------------------------------------
1 | com.vaadin.starter.beveragebuddy.MyServiceInitListener
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .idea
 2 | build
 3 | .gradle
 4 | classes
 5 | local.properties
 6 | *.iml
 7 | out
 8 | 
 9 | target
10 | src/main/frontend/generated
11 | 


--------------------------------------------------------------------------------
/src/main/resources/db/migration/V01__CreateCategory.sql:
--------------------------------------------------------------------------------
1 | create TABLE CATEGORY (
2 |   id bigint auto_increment PRIMARY KEY,
3 |   name varchar(200) NOT NULL
4 | );
5 | create UNIQUE INDEX idx_category_name ON CATEGORY(name);
6 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-9.1.0-all.zip
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/Main.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy
 2 | 
 3 | import com.github.mvysny.vaadinboot.VaadinBoot
 4 | 
 5 | /**
 6 |  * Run this function to launch your app in Embedded Jetty.
 7 |  */
 8 | fun main() {
 9 |     VaadinBoot().run()
10 | }
11 | 


--------------------------------------------------------------------------------
/src/main/resources/simplelogger.properties:
--------------------------------------------------------------------------------
1 | org.slf4j.simpleLogger.defaultLogLevel = info
2 | org.slf4j.simpleLogger.showDateTime = true
3 | org.slf4j.simpleLogger.dateTimeFormat = yyyy-MM-dd HH:mm:ss.SSS
4 | org.slf4j.simpleLogger.log.org.atmosphere = warn
5 | org.slf4j.simpleLogger.log.org.eclipse.jetty = warn
6 | org.slf4j.simpleLogger.log.org.eclipse.jetty.annotations.AnnotationParser = error
7 | 


--------------------------------------------------------------------------------
/src/main/resources/db/migration/V02__CreateReview.sql:
--------------------------------------------------------------------------------
 1 | create TABLE REVIEW (
 2 |   id bigint auto_increment PRIMARY KEY,
 3 |   name VARCHAR(200) not null,
 4 |   score TINYINT NOT NULL,
 5 |   date DATE not NULL,
 6 |   category BIGINT,
 7 |   count TINYINT not null
 8 | );
 9 | alter table Review add CONSTRAINT r_score_range CHECK (score >= 1 and score <= 5);
10 | alter table Review add FOREIGN KEY (category) REFERENCES Category(ID);
11 | alter table Review add CONSTRAINT r_count_range CHECK (count >= 1 and count <= 99);
12 | create INDEX idx_review_name ON Review(name);
13 | 


--------------------------------------------------------------------------------
/src/main/frontend/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <!--
 3 | This file is auto-generated by Vaadin.
 4 | -->
 5 | 
 6 | <html lang="en">
 7 | <head>
 8 |   <meta charset="UTF-8" />
 9 |   <meta name="viewport" content="width=device-width, initial-scale=1" />
10 |   <style>
11 |     body, #outlet {
12 |       height: 100vh;
13 |       width: 100%;
14 |       margin: 0;
15 |     }
16 |   </style>
17 |   <!-- index.ts is included here automatically (either by the dev server or during the build) -->
18 | </head>
19 | <body>
20 |   <!-- This outlet div is where the views are rendered -->
21 |   <div id="outlet"></div>
22 | </body>
23 | </html>
24 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/backend/ReviewTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.backend
 2 | 
 3 | import org.junit.jupiter.api.Nested
 4 | import org.junit.jupiter.api.Test
 5 | import kotlin.test.expect
 6 | 
 7 | class ReviewTest {
 8 |     @Nested inner class validation() {
 9 |         @Test fun smoke() {
10 |             expect(true) { Review(name = "Foo", category = 1L).isValid }
11 |             expect(false) { Review().isValid }
12 |             expect(false) { Review(category = 1L).isValid }
13 |             expect(false) { Review(name = "Foo").isValid }
14 |             expect(false) { Review(name = "F", category = 1L).isValid }
15 |             expect(false) { Review(score = 10, name = "Foo", category = 1L).isValid }
16 |         }
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/.github/workflows/gradle.yml:
--------------------------------------------------------------------------------
 1 | name: Gradle
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | jobs:
 6 |   build:
 7 | 
 8 |     strategy:
 9 |       matrix:
10 |         os: [ubuntu-latest, windows-latest]
11 |         java: [17]
12 | 
13 |     runs-on: ${{ matrix.os }}
14 | 
15 |     steps:
16 |     - uses: actions/checkout@v3
17 |     - name: Set up JDK ${{ matrix.java }}
18 |       uses: actions/setup-java@v4
19 |       with:
20 |         java-version: ${{ matrix.java }}
21 |         distribution: 'temurin'
22 |     - name: Cache Gradle packages
23 |       uses: actions/cache@v4
24 |       with:
25 |         path: |
26 |           ~/.gradle/caches
27 |           ~/.gradle/wrapper
28 |         key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts', 'gradle/wrapper/gradle-wrapper.properties', 'gradle.properties') }}
29 |     - name: Build with Gradle
30 |       run: ./gradlew clean build '-Pvaadin.productionMode' --stacktrace --info --no-daemon
31 | 
32 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/backend/RestService.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.backend
 2 | 
 3 | import eu.vaadinonkotlin.rest.*
 4 | import io.javalin.Javalin
 5 | import jakarta.servlet.annotation.WebServlet
 6 | import jakarta.servlet.http.HttpServlet
 7 | import jakarta.servlet.http.HttpServletRequest
 8 | import jakarta.servlet.http.HttpServletResponse
 9 | 
10 | /**
11 |  * Provides access to person list. To test, just run `curl http://localhost:8080/rest/categories`
12 |  */
13 | @WebServlet(urlPatterns = ["/rest/*"], name = "JavalinRestServlet", asyncSupported = false)
14 | class JavalinRestServlet : HttpServlet() {
15 |     val javalin = Javalin.createStandalone { it.gsonMapper(VokRest.gson) } .apply {
16 |         get("/rest/categories") { ctx -> ctx.json(Category.findAll()) }
17 |         crud2("/rest/reviews", Review.getCrudHandler(false))
18 |     }.javalinServlet()
19 | 
20 |     override fun service(req: HttpServletRequest, resp: HttpServletResponse) {
21 |         javalin.service(req, resp)
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/gradle/libs.versions.toml:
--------------------------------------------------------------------------------
 1 | [versions]
 2 | vaadin = "24.9.7"
 3 | # https://repo1.maven.org/maven2/org/slf4j/slf4j-api/
 4 | slf4j = "2.0.17"
 5 | vok = "0.18.1"
 6 | 
 7 | [libraries]
 8 | slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 9 | slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
10 | vaadin-boot = "com.github.mvysny.vaadin-boot:vaadin-boot:13.5"
11 | vaadin-core = { module = "com.vaadin:vaadin-core", version.ref = "vaadin" }
12 | karibu-testing = "com.github.mvysny.kaributesting:karibu-testing-v24:2.4.3"
13 | karibu-dsl = "com.github.mvysny.karibudsl:karibu-dsl-v23:2.5.0"
14 | flyway = "org.flywaydb:flyway-core:11.18.0"
15 | h2 = "com.h2database:h2:2.2.224"
16 | hikaricp = "com.zaxxer:HikariCP:7.0.2"
17 | vok-db = { module = "eu.vaadinonkotlin:vok-framework-vokdb", version.ref = "vok" }
18 | vok-rest-server = { module = "eu.vaadinonkotlin:vok-rest", version.ref = "vok" }
19 | vok-rest-client = { module = "eu.vaadinonkotlin:vok-rest-client", version.ref = "vok" }
20 | junit = "org.junit.jupiter:junit-jupiter-engine:6.0.1"
21 | 
22 | [plugins]
23 | vaadin = { id = "com.vaadin", version.ref = "vaadin" }
24 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2020 Martin Vyšný
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | # Allows you to run this app easily as a docker container.
 2 | # See README.md for more details.
 3 | #
 4 | # 1. Build the image with: docker build -t test/beverage-buddy-vok:latest .
 5 | # 2. Run the image with: docker run --rm -ti -p8080:8080 test/beverage-buddy-vok
 6 | #
 7 | # Uses Docker Multi-stage builds: https://docs.docker.com/build/building/multi-stage/
 8 | 
 9 | # The "Build" stage. Copies the entire project into the container, into the /app/ folder, and builds it.
10 | FROM eclipse-temurin:21 AS builder
11 | COPY . /app/
12 | WORKDIR /app/
13 | RUN --mount=type=cache,target=/root/.gradle --mount=type=cache,target=/root/.vaadin ./gradlew clean build -Pvaadin.productionMode --no-daemon --info --stacktrace
14 | WORKDIR /app/build/distributions/
15 | RUN tar xvf app.tar
16 | # At this point, we have the app (executable bash scrip plus a bunch of jars) in the
17 | # /app/build/distributions/app/ folder.
18 | 
19 | # The "Run" stage. Start with a clean image, and copy over just the app itself, omitting gradle, npm and any intermediate build files.
20 | FROM eclipse-temurin:21
21 | COPY --from=builder /app/build/distributions/app /app/
22 | WORKDIR /app/bin
23 | EXPOSE 8080
24 | ENTRYPOINT ["./app"]
25 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/backend/ReviewWithCategoryTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.backend
 2 | 
 3 | import com.github.mvysny.kaributesting.v10.expectList
 4 | import com.gitlab.mvysny.jdbiorm.condition.Condition
 5 | import com.vaadin.flow.data.provider.Query
 6 | import com.vaadin.flow.data.provider.QuerySortOrder
 7 | import com.vaadin.flow.data.provider.SortDirection
 8 | import com.vaadin.starter.beveragebuddy.AbstractAppTest
 9 | import org.junit.jupiter.api.Test
10 | import kotlin.test.expect
11 | 
12 | class ReviewWithCategoryTest : AbstractAppTest() {
13 |     @Test fun smoke() {
14 |         val category = Category(name = "Foo")
15 |         category.save()
16 |         val review = Review(name = "Bar", category = category.id)
17 |         review.save()
18 | 
19 |         expectList(ReviewWithCategory(review, "Foo")) { ReviewWithCategory.dataProvider.fetch(Query()).toList() }
20 |         expect(1) { ReviewWithCategory.dataProvider.size(Query()) }
21 |         val query = Query<ReviewWithCategory, Condition>(
22 |             0,
23 |             30,
24 |             listOf(QuerySortOrder(Review.NAME.toExternalString(), SortDirection.ASCENDING)),
25 |             null,
26 |             null
27 |         )
28 |         expectList(
29 |             ReviewWithCategory(
30 |                 review,
31 |                 "Foo"
32 |             )
33 |         ) { ReviewWithCategory.dataProvider.fetch(query).toList() }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/backend/Category.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.backend
 2 | 
 3 | import com.github.vokorm.*
 4 | import com.gitlab.mvysny.jdbiorm.Dao
 5 | import jakarta.validation.constraints.NotBlank
 6 | import jakarta.validation.constraints.NotEmpty
 7 | import jakarta.validation.constraints.NotNull
 8 | 
 9 | /**
10 |  * Represents a beverage category.
11 |  * @property id
12 |  * @property name the category name
13 |  */
14 | data class Category(
15 |     override var id: Long? = null,
16 | 
17 |     @field:NotBlank
18 |     var name: String = ""
19 | ) : KEntity<Long> {
20 | 
21 |     companion object : Dao<Category, Long>(Category::class.java) {
22 |         fun findByName(name: String): Category? = findSingleBy { Category::name eq name }
23 |         fun getByName(name: String): Category = singleBy { Category::name eq name }
24 |         fun existsWithName(name: String): Boolean = existsBy { Category::name eq name }
25 |         override fun deleteAll() {
26 |             db {
27 |                 handle.createUpdate("update Review set category = NULL").execute()
28 |                 super.deleteAll()
29 |             }
30 |         }
31 |     }
32 | 
33 |     override fun delete() {
34 |         db {
35 |             if (id != null) {
36 |                 handle.createUpdate("update Review set category = NULL where category=:catId")
37 |                         .bind("catId", id!!)
38 |                         .execute()
39 |             }
40 |             super.delete()
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/AbstractAppTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy
 2 | 
 3 | import com.github.mvysny.kaributesting.v10.MockVaadin
 4 | import com.github.mvysny.kaributesting.v10.Routes
 5 | import com.vaadin.starter.beveragebuddy.backend.Category
 6 | import com.vaadin.starter.beveragebuddy.backend.Review
 7 | import org.junit.jupiter.api.AfterAll
 8 | import org.junit.jupiter.api.AfterEach
 9 | import org.junit.jupiter.api.BeforeAll
10 | import org.junit.jupiter.api.BeforeEach
11 | 
12 | /**
13 |  * Properly configures the app in the test context, so that the app is properly initialized, and the database is emptied before every test.
14 |  */
15 | abstract class AbstractAppTest {
16 |     companion object {
17 |         // since there is no servlet environment, Flow won't auto-detect the @Routes. We need to auto-discover all @Routes
18 |         // and populate the RouteRegistry properly.
19 |         private val routes = Routes().autoDiscoverViews("com.vaadin.starter.beveragebuddy")
20 | 
21 |         @BeforeAll @JvmStatic fun startApp() { Bootstrap().contextInitialized(null) }
22 |         @AfterAll @JvmStatic fun stopApp() { Bootstrap().contextDestroyed(null) }
23 |     }
24 | 
25 |     @BeforeEach fun setupVaadin() { MockVaadin.setup(routes) }
26 |     @AfterEach fun teardownVaadin() { MockVaadin.tearDown() }
27 | 
28 |     // it's a good practice to clear up the db before every test, to start every test with a predefined state.
29 |     @BeforeEach @AfterEach fun cleanupDb() { Category.deleteAll(); Review.deleteAll() }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/backend/CategoryTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.backend
 2 | 
 3 | import com.github.mvysny.kaributesting.v10.expectList
 4 | import com.vaadin.starter.beveragebuddy.AbstractAppTest
 5 | import org.junit.jupiter.api.Nested
 6 | import org.junit.jupiter.api.Test
 7 | import java.time.LocalDate
 8 | import kotlin.test.expect
 9 | 
10 | class CategoryTest : AbstractAppTest() {
11 |     @Nested inner class validation {
12 |         @Test fun smoke() {
13 |             expect(false) { Category().isValid }
14 |             expect(false) { Category(name = "  ").isValid }
15 |             expect(true) { Category(name = "F").isValid }
16 |         }
17 |     }
18 | 
19 |     @Nested inner class delete {
20 |         @Test fun smoke() {
21 |             val cat = Category(name = "Foo")
22 |             cat.save()
23 |             cat.delete()
24 |             expectList() { Category.findAll() }
25 |         }
26 |         @Test fun `deleting category fixes foreign keys`() {
27 |             val cat = Category(name = "Foo")
28 |             cat.save()
29 |             val review = Review(name = "Foo", score = 1, date = LocalDate.now(), category = cat.id!!, count = 1)
30 |             review.save()
31 | 
32 |             cat.delete()
33 |             expectList() { Category.findAll() }
34 |             expect(null) { Review.single().category }
35 |         }
36 |     }
37 | 
38 |     @Test fun existsWithName() {
39 |         expect(false) { Category.existsWithName("Foo") }
40 |         Category(name = "Foo").save()
41 |         expect(true) { Category.existsWithName("Foo") }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/ui/ReviewsListTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.ui
 2 | 
 3 | import com.github.mvysny.kaributesting.v10._click
 4 | import com.github.mvysny.kaributesting.v10._expectNone
 5 | import com.github.mvysny.kaributesting.v10._expectOne
 6 | import com.github.mvysny.kaributesting.v10._get
 7 | import com.github.mvysny.kaributesting.v23.expectRows
 8 | import com.vaadin.flow.component.UI
 9 | import com.vaadin.flow.component.button.Button
10 | import com.vaadin.flow.component.virtuallist.VirtualList
11 | import com.vaadin.starter.beveragebuddy.AbstractAppTest
12 | import com.vaadin.starter.beveragebuddy.backend.Category
13 | import com.vaadin.starter.beveragebuddy.backend.Review
14 | import com.vaadin.starter.beveragebuddy.backend.ReviewWithCategory
15 | import org.junit.jupiter.api.Test
16 | 
17 | class ReviewsListTest : AbstractAppTest() {
18 |     @Test fun `no reviews initially`() {
19 |         _get<VirtualList<ReviewWithCategory>>().expectRows(0)
20 |     }
21 | 
22 |     @Test fun reviewsListed() {
23 |         // prepare testing data
24 |         val cat = Category(name = "Beers")
25 |         cat.save()
26 |         Review(score = 1, name = "Good!", category = cat.id).save()
27 |         _get<VirtualList<ReviewWithCategory>>().expectRows(1)
28 |     }
29 | 
30 |     @Test fun `'new review' smoke test`() {
31 |         UI.getCurrent().navigate("")
32 |         _get<Button> { text = "New review (Alt+N)" }._click()
33 | 
34 |         // the dialog should have been opened
35 |         _expectOne<EditorDialogFrame<*>>()
36 | 
37 |         // this is just a smoke test, so let's close the dialog
38 |         _get<Button> { text = "Cancel" }._click()
39 | 
40 |         _expectNone<EditorDialogFrame<*>>()
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/ui/Toolbar.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.ui
 2 | 
 3 | import com.github.mvysny.karibudsl.v10.*
 4 | import com.github.mvysny.kaributools.ModifierKey.*
 5 | import com.github.mvysny.kaributools.addClickShortcut
 6 | import com.github.mvysny.kaributools.setPrimary
 7 | import com.vaadin.flow.component.HasComponents
 8 | import com.vaadin.flow.component.Key.*
 9 | import com.vaadin.flow.component.icon.Icon
10 | import com.vaadin.flow.component.icon.VaadinIcon
11 | import com.vaadin.flow.component.textfield.TextField
12 | import com.vaadin.flow.data.value.ValueChangeMode
13 | 
14 | /**
15 |  * A toolbar with a search box and a "Create New" button. Don't forget to provide proper listeners
16 |  * for [onSearch] and [onCreate].
17 |  * @param createCaption the caption of the "Create New" button.
18 |  */
19 | class Toolbar(createCaption: String) : KComposite() {
20 |     /**
21 |      * Fired when the text in the search text field changes.
22 |      */
23 |     var onSearch: (String)->Unit = {}
24 |     /**
25 |      * Fired when the "Create new" button is clicked.
26 |      */
27 |     var onCreate: ()->Unit = {}
28 |     private lateinit var searchField: TextField
29 |     /**
30 |      * Current search text. Never null, trimmed, may be blank.
31 |      */
32 |     val searchText: String get() = searchField.value.trim()
33 | 
34 |     private val root = ui {
35 |         div("view-toolbar") {
36 |             searchField = textField {
37 |                 prefixComponent = Icon(VaadinIcon.SEARCH)
38 |                 addClassName("view-toolbar__search-field")
39 |                 placeholder = "Search"
40 |                 addValueChangeListener { onSearch(searchText) }
41 |                 valueChangeMode = ValueChangeMode.EAGER
42 |             }
43 |             button("$createCaption (Alt+N)", Icon(VaadinIcon.PLUS)) {
44 |                 setPrimary()
45 |                 addClassName("view-toolbar__button")
46 |                 addClickListener { onCreate() }
47 |                 addClickShortcut(Alt + KEY_N)
48 |             }
49 |         }
50 |     }
51 | }
52 | 
53 | @VaadinDsl
54 | fun (@VaadinDsl HasComponents).toolbarView(createCaption: String, block: (@VaadinDsl Toolbar).() -> Unit = {})
55 |         = init(Toolbar(createCaption), block)
56 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/ui/MainLayout.kt:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2000-2017 Vaadin Ltd.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 5 |  * use this file except in compliance with the License. You may obtain a copy of
 6 |  * the License at
 7 |  *
 8 |  * http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 |  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 |  * License for the specific language governing permissions and limitations under
14 |  * the License.
15 |  */
16 | package com.vaadin.starter.beveragebuddy.ui
17 | 
18 | import com.github.mvysny.karibudsl.v10.*
19 | import com.vaadin.flow.component.Component
20 | import com.vaadin.flow.component.HasElement
21 | import com.vaadin.flow.component.icon.VaadinIcon
22 | import com.vaadin.flow.router.HighlightConditions
23 | import com.vaadin.flow.router.RouterLayout
24 | import com.vaadin.starter.beveragebuddy.ui.categories.CategoriesList
25 | import com.vaadin.starter.beveragebuddy.ui.reviews.ReviewsList
26 | 
27 | /**
28 |  * The main layout contains the header with the navigation buttons, and the
29 |  * child views below that.
30 |  */
31 | class MainLayout : KComposite(), RouterLayout {
32 | 
33 |     private val root = ui {
34 |         verticalLayout(false, false, classNames = "main-layout") {
35 |             setSizeFull()
36 |             content { align(stretch, top) }
37 |             div("main-layout__header") { // header
38 |                 h2("Beverage Buddy") {
39 |                     addClassName("main-layout__title")
40 |                 }
41 |                 div("main-layout__nav") { // navigation
42 |                     routerLink(VaadinIcon.LIST, "Reviews", ReviewsList::class) {
43 |                         addClassName("main-layout__nav-item")
44 |                         highlightCondition = HighlightConditions.sameLocation()
45 |                     }
46 |                     routerLink(VaadinIcon.ARCHIVES, "Categories", CategoriesList::class) {
47 |                         addClassName("main-layout__nav-item")
48 |                         highlightCondition = HighlightConditions.sameLocation()
49 |                     }
50 |                 }
51 |             }
52 |         }
53 |     }
54 | 
55 |     override fun showRouterLayoutContent(content: HasElement) {
56 |         root.add(content as Component)
57 |         content.isExpand = true
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/ui/CategoryEditorDialogTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.ui
 2 | 
 3 | import com.github.mvysny.kaributesting.v10.*
 4 | import com.vaadin.flow.component.button.Button
 5 | import com.vaadin.flow.component.textfield.TextField
 6 | import com.vaadin.starter.beveragebuddy.AbstractAppTest
 7 | import com.vaadin.starter.beveragebuddy.backend.Category
 8 | import com.vaadin.starter.beveragebuddy.ui.categories.CategoryEditorDialog
 9 | import org.junit.jupiter.api.Test
10 | import kotlin.test.expect
11 | 
12 | /**
13 |  * Tests the UI. Uses the Browserless Testing approach as provided by the [Karibu Testing](https://github.com/mvysny/karibu-testing) library.
14 |  */
15 | class CategoryEditorDialogTest : AbstractAppTest() {
16 |     @Test
17 |     fun `create new category`() {
18 |         CategoryEditorDialog {}.createNew()
19 | 
20 |         // make sure that the "New Category" dialog is opened
21 |         _expectOne<EditorDialogFrame<*>>()
22 | 
23 |         // do the happy flow: fill in the form with valid values and click "Save"
24 |         _get<TextField> { label = "Category Name" }.value = "Beer"
25 |         _get<Button> { text = "Create" }._click()
26 |         expectNotifications("Category successfully added.")
27 | 
28 |         _expectNone<EditorDialogFrame<*>>()     // expect the dialog to close
29 |         expect("Beer") { Category.single().name }
30 |     }
31 | 
32 |     @Test
33 |     fun `dont create category with blank name`() {
34 |         CategoryEditorDialog {}.createNew()
35 | 
36 |         // make sure that the "New Category" dialog is opened
37 |         _expectOne<EditorDialogFrame<*>>()
38 | 
39 |         // do the happy flow: fill in the form with valid values and click "Save"
40 |         _get<TextField> { label = "Category Name" }.value = ""
41 |         _get<Button> { text = "Create" }._click()
42 | 
43 |         _expectOne<EditorDialogFrame<*>>()     // expect the dialog to close
44 |         _get<TextField> { label = "Category Name" }._expectInvalid()
45 |         expectList() { Category.findAll() }
46 |     }
47 | 
48 |     @Test
49 |     fun `edit existing category`() {
50 |         val cat = Category(name = "Foo")
51 |         cat.save()
52 | 
53 |         CategoryEditorDialog {}.edit(cat)
54 | 
55 |         // make sure that the "New Category" dialog is opened
56 |         _expectOne<EditorDialogFrame<*>>()
57 | 
58 |         // do the happy flow: fill in the form with valid values and click "Save"
59 |         _get<TextField> { label = "Category Name" }.value = "Beer"
60 |         _get<Button> { text = "Save" }._click()
61 |         expectNotifications("Category successfully saved.")
62 | 
63 |         _expectNone<EditorDialogFrame<*>>()     // expect the dialog to close
64 |         expect("Beer") { Category.single().name }
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/ui/ReviewEditorDialogTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.ui
 2 | 
 3 | import com.github.mvysny.kaributesting.v10.*
 4 | import com.vaadin.flow.component.button.Button
 5 | import com.vaadin.flow.component.combobox.ComboBox
 6 | import com.vaadin.flow.component.textfield.IntegerField
 7 | import com.vaadin.flow.component.textfield.TextField
 8 | import com.vaadin.starter.beveragebuddy.AbstractAppTest
 9 | import com.vaadin.starter.beveragebuddy.backend.Category
10 | import com.vaadin.starter.beveragebuddy.backend.Review
11 | import com.vaadin.starter.beveragebuddy.ui.reviews.ReviewEditorDialog
12 | import org.junit.jupiter.api.Test
13 | import kotlin.test.expect
14 | 
15 | class ReviewEditorDialogTest : AbstractAppTest() {
16 |     @Test fun smoke() {
17 |         ReviewEditorDialog({}).createNew()
18 |         _expectOne<EditorDialogFrame<*>>()
19 |     }
20 | 
21 |     @Test fun `'cancel' closes the dialog`() {
22 |         ReviewEditorDialog({}).createNew()
23 |         _get<Button> { text = "Cancel" }._click()
24 |         _expectNone<EditorDialogFrame<*>>()
25 |     }
26 | 
27 |     @Test fun `simple validation failure`() {
28 |         ReviewEditorDialog({}).createNew()
29 |         _expectOne<EditorDialogFrame<*>>()
30 |         _get<Button> { text = "Create" } ._click()
31 | 
32 |         _expectOne<EditorDialogFrame<*>>()
33 |         expectNotifications("There are errors in the form")
34 |         _get<TextField> { label = "Beverage name"} ._expectInvalid("must not be blank")
35 |     }
36 | 
37 |     @Test fun `create review without setting a category fails`() {
38 |         ReviewEditorDialog({}).createNew()
39 |         _expectOne<EditorDialogFrame<*>>()
40 |         _get<TextField> { label = "Beverage name" } ._value = "FooBar"
41 |         _get<Button> { text = "Create" } ._click()
42 | 
43 |         _expectOne<EditorDialogFrame<*>>()
44 |         // no review has been created
45 |         expectList() { Review.findAll() }
46 |     }
47 | 
48 |     @Test fun `create new review`() {
49 |         val cat = Category(name = "Beers")
50 |         cat.save()
51 | 
52 |         _get<Button> { text = "New review (Alt+N)" }._click()
53 | 
54 |         _expectOne<EditorDialogFrame<*>>()
55 |         _get<TextField> { label = "Beverage name" }._value = "Test"
56 |         _get<IntegerField> { label = "Times tasted" }._value = 1
57 |         _get<ComboBox<Category>> { label = "Choose a category" }._value = cat
58 |         _get<ComboBox<String>> { label = "Mark a score" } .selectByLabel("3")
59 | 
60 |         _get<Button> { text = "Create" } ._click()
61 |         expectNotifications("Beverage successfully added.")
62 | 
63 |         _expectNone<EditorDialogFrame<*>>()     // expect the dialog to close
64 |         val review = Review.single()
65 |         expect("Test") { review.name }
66 |         expect(3) { review.score }
67 |         expect(cat.id) { review.category }
68 |         expect(1) { review.count }
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @rem
 2 | @rem Copyright 2015 the original author or authors.
 3 | @rem
 4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
 5 | @rem you may not use this file except in compliance with the License.
 6 | @rem You may obtain a copy of the License at
 7 | @rem
 8 | @rem      https://www.apache.org/licenses/LICENSE-2.0
 9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 | 
17 | @if "%DEBUG%"=="" @echo off
18 | @rem ##########################################################################
19 | @rem
20 | @rem  Gradle startup script for Windows
21 | @rem
22 | @rem ##########################################################################
23 | 
24 | @rem Set local scope for the variables with windows NT shell
25 | if "%OS%"=="Windows_NT" setlocal
26 | 
27 | set DIRNAME=%~dp0
28 | if "%DIRNAME%"=="" set DIRNAME=.
29 | set APP_BASE_NAME=%~n0
30 | set APP_HOME=%DIRNAME%
31 | 
32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter.
33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
34 | 
35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
37 | 
38 | @rem Find java.exe
39 | if defined JAVA_HOME goto findJavaFromJavaHome
40 | 
41 | set JAVA_EXE=java.exe
42 | %JAVA_EXE% -version >NUL 2>&1
43 | if %ERRORLEVEL% equ 0 goto execute
44 | 
45 | echo.
46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
47 | echo.
48 | echo Please set the JAVA_HOME variable in your environment to match the
49 | echo location of your Java installation.
50 | 
51 | goto fail
52 | 
53 | :findJavaFromJavaHome
54 | set JAVA_HOME=%JAVA_HOME:"=%
55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
56 | 
57 | if exist "%JAVA_EXE%" goto execute
58 | 
59 | echo.
60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
61 | echo.
62 | echo Please set the JAVA_HOME variable in your environment to match the
63 | echo location of your Java installation.
64 | 
65 | goto fail
66 | 
67 | :execute
68 | @rem Setup the command line
69 | 
70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
71 | 
72 | 
73 | @rem Execute Gradle
74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
75 | 
76 | :end
77 | @rem End local scope for the variables with windows NT shell
78 | if %ERRORLEVEL% equ 0 goto mainEnd
79 | 
80 | :fail
81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
82 | rem the _cmd.exe /c_ return code!
83 | set EXIT_CODE=%ERRORLEVEL%
84 | if %EXIT_CODE% equ 0 set EXIT_CODE=1
85 | if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
86 | exit /b %EXIT_CODE%
87 | 
88 | :mainEnd
89 | if "%OS%"=="Windows_NT" endlocal
90 | 
91 | :omega
92 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/backend/RestServiceTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.backend
 2 | 
 3 | import com.github.mvysny.kaributesting.v10.expectList
 4 | import com.vaadin.starter.beveragebuddy.AbstractAppTest
 5 | import eu.vaadinonkotlin.restclient.*
 6 | import org.eclipse.jetty.ee10.webapp.WebAppContext
 7 | import org.eclipse.jetty.server.Server
 8 | import org.junit.jupiter.api.*
 9 | import java.io.FileNotFoundException
10 | import java.net.http.HttpClient
11 | 
12 | /**
13 |  * Uses the VoK `vok-rest-client` module for help with testing of the REST endpoints. See docs on the
14 |  * [vok-rest-client](https://github.com/mvysny/vaadin-on-kotlin/tree/master/vok-rest-client) module for more details.
15 |  */
16 | class PersonRestClient(val baseUrl: String) {
17 |     init {
18 |         require(!baseUrl.endsWith("/")) { "$baseUrl must not end with a slash" }
19 |     }
20 |     private val client: HttpClient = VokRestClient.httpClient
21 |     fun getAllCategories(): List<Category> {
22 |         val request = "$baseUrl/categories".buildUrl().buildRequest()
23 |         return client.exec(request) { response -> response.jsonArray(Category::class.java) }
24 |     }
25 |     fun getAllReviews(): List<Review> {
26 |         val request = "$baseUrl/reviews".buildUrl().buildRequest()
27 |         return client.exec(request) { response -> response.jsonArray(Review::class.java) }
28 |     }
29 |     fun nonexistingEndpoint() {
30 |         val request = "$baseUrl/nonexisting".buildUrl().buildRequest()
31 |         client.exec(request) { }
32 |     }
33 | }
34 | 
35 | /**
36 |  * The REST test. It bootstraps the app, then it starts Javalin with Jetty so that we can access it via the
37 |  * [PersonRestClient].
38 |  */
39 | class RestServiceTest : AbstractAppTest() {
40 |     companion object {
41 |         private lateinit var server: Server
42 |         @BeforeAll @JvmStatic fun startJavalin() {
43 |             val ctx = WebAppContext()
44 |             // This used to be EmptyResource, but it got removed in Jetty 12. Let's use some dummy resource instead.
45 |             ctx.baseResource = ctx.resourceFactory.newClassLoaderResource("java/lang/String.class")
46 |             ctx.addServlet(JavalinRestServlet::class.java, "/rest/*")
47 |             server = Server(9876)
48 |             server.handler = ctx
49 |             server.start()
50 |         }
51 |         @AfterAll @JvmStatic fun stopJavalin() { server.stop() }
52 |     }
53 | 
54 |     private lateinit var client: PersonRestClient
55 |     @BeforeEach fun createClient() { client = PersonRestClient("http://localhost:9876/rest") }
56 | 
57 |     @Test fun `categories smoke test`() {
58 |         expectList() { client.getAllCategories() }
59 |     }
60 | 
61 |     @Test fun `categories retrieval`() {
62 |         val cat = Category(name = "foo").apply { save() }
63 |         expectList(cat) { client.getAllCategories() }
64 |     }
65 | 
66 |     @Test fun `reviews smoke test`() {
67 |         expectList() { client.getAllReviews() }
68 |     }
69 | 
70 |     @Test fun `reviews retrieval`() {
71 |         val cat = Category(name = "Beers")
72 |         cat.save()
73 |         val r = Review(score = 1, name = "Good!", category = cat.id)
74 |         r.save()
75 |         expectList(r) { client.getAllReviews() }
76 |     }
77 | 
78 |     @Test fun `404`() {
79 |         assertThrows<FileNotFoundException> {
80 |             client.nonexistingEndpoint()
81 |         }
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/test/kotlin/com/vaadin/starter/beveragebuddy/ui/CategoriesListTest.kt:
--------------------------------------------------------------------------------
 1 | package com.vaadin.starter.beveragebuddy.ui
 2 | 
 3 | import com.github.mvysny.kaributesting.v10.*
 4 | import com.github.mvysny.kaributools.navigateTo
 5 | import com.vaadin.flow.component.button.Button
 6 | import com.vaadin.flow.component.grid.Grid
 7 | import com.vaadin.flow.component.textfield.TextField
 8 | import com.vaadin.starter.beveragebuddy.AbstractAppTest
 9 | import com.vaadin.starter.beveragebuddy.backend.Category
10 | import com.vaadin.starter.beveragebuddy.ui.categories.CategoriesList
11 | import org.junit.jupiter.api.BeforeEach
12 | import org.junit.jupiter.api.Test
13 | import kotlin.test.expect
14 | 
15 | /**
16 |  * Tests the UI. Uses the Browserless Testing approach as provided by the [Karibu Testing](https://github.com/mvysny/karibu-testing) library.
17 |  */
18 | class CategoriesListTest : AbstractAppTest() {
19 |     @BeforeEach fun navigate() {
20 |         // navigate to the "Categories" list route.
21 |         navigateTo<CategoriesList>()
22 |     }
23 | 
24 |     @Test fun `grid lists all categories`() {
25 |         // prepare testing data
26 |         Category(name = "Beers").save()
27 | 
28 |         // now the "Categories" list should be displayed. Look up the Grid and assert on its contents.
29 |         val grid = _get<Grid<Category>>()
30 |         grid.expectRows(1)
31 |         grid.expectRow(0, "Beers", "0", "Button[text='Edit', icon='vaadin:edit', @class='category__edit', @theme='tertiary']")
32 |     }
33 | 
34 |     @Test fun `create new category`() {
35 |         _get<Button> { text = "New category (Alt+N)" } ._click()
36 | 
37 |         // make sure that the "New Category" dialog is opened
38 |         _expectOne<EditorDialogFrame<*>>()
39 |     }
40 | 
41 |     @Test fun `edit existing category`() {
42 |         val cat: Category = Category(name = "Beers").apply { save() }
43 |         val grid = _get<Grid<Category>>()
44 |         grid.expectRow(0, "Beers", "0", "Button[text='Edit', icon='vaadin:edit', @class='category__edit', @theme='tertiary']")
45 |         grid._clickRenderer(0, "edit")
46 | 
47 |         // make sure that the "Edit Category" dialog is opened
48 |         _expectOne<EditorDialogFrame<*>>()
49 |         expect(cat.name) { _get<TextField> { label = "Category Name" } ._value }
50 |     }
51 | 
52 |     @Test fun `edit existing category via context menu`() {
53 |         val cat: Category = Category(name = "Beers").apply { save() }
54 |         val grid = _get<Grid<Category>>()
55 |         grid.expectRow(0, "Beers", "0", "Button[text='Edit', icon='vaadin:edit', @class='category__edit', @theme='tertiary']")
56 |         _get<CategoriesList>().gridContextMenu._clickItemWithCaption("Edit (Alt+E)", cat)
57 | 
58 |         // make sure that the "Edit Category" dialog is opened
59 |         _expectOne<EditorDialogFrame<*>>()
60 |         expect(cat.name) { _get<TextField> { label = "Category Name" } ._value }
61 |     }
62 | 
63 |     @Test fun `delete existing category via context menu`() {
64 |         val cat: Category = Category(name = "Beers").apply { save() }
65 |         val grid = _get<Grid<Category>>()
66 |         grid.expectRow(0, "Beers", "0", "Button[text='Edit', icon='vaadin:edit', @class='category__edit', @theme='tertiary']")
67 |         _get<CategoriesList>().gridContextMenu._clickItemWithCaption("Delete", cat)
68 | 
69 |         // check that the category has been deleted in the database.
70 |         expectList() { Category.findAll() }
71 |         _get<Grid<Category>>().expectRows(0)
72 |         expectNotifications("Category successfully deleted.")
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Powered By Vaadin on Kotlin](http://vaadinonkotlin.eu/iconography/vok_badge.svg)](http://vaadinonkotlin.eu)
 2 | [![Join the chat at https://gitter.im/vaadin/vaadin-on-kotlin](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/vaadin/vaadin-on-kotlin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 3 | 
 4 | # Beverage Buddy App Starter for Vaadin
 5 | :coffee::tea::sake::baby_bottle::beer::cocktail::tropical_drink::wine_glass:
 6 | 
 7 | This is a [Vaadin-on-Kotlin](http://vaadinonkotlin.eu) example application,
 8 | used to demonstrate features of the Vaadin Flow Java framework.
 9 | A full-stack app: uses the H2 database instead of a dummy service. Requires Java 17+.
10 | 
11 | The Starter demonstrates the core Vaadin Flow concepts:
12 | * [Building UIs in Kotlin](https://github.com/mvysny/karibu-dsl) with components
13 |   such as `TextField`, `Button`, `ComboBox`, `DatePicker`, `VerticalLayout` and `Grid` (see `CategoriesList`)
14 | * [Creating forms with `Binder`](https://github.com/vaadin/free-starter-flow/blob/master/documentation/using-binder-in-review-editor-dialog.asciidoc) (`ReviewEditorDialog`)
15 | * Making reusable Components on server side with `KComposite` (`AbstractEditorDialog`)
16 | * [Creating Navigation with the Router API](https://github.com/vaadin/free-starter-flow/blob/master/documentation/using-annotation-based-router-api.asciidoc) (`MainLayout`, `ReviewsList`, `CategoriesList`)
17 | * [Browserless testing](https://github.com/mvysny/karibu-testing): see the
18 |   [test suite package](src/test/kotlin/com/vaadin/starter/beveragebuddy/ui) for the complete test implementation.
19 | 
20 | This version of Beverage Buddy demoes the possibility of developing a Vaadin
21 | web application purely server-side in the Kotlin language. There is no
22 | JavaScript code in this project. We use Vaadin to avoid touching JavaScript after all.
23 | 
24 | See the [online demo](https://v-herd.eu/beverage-buddy-vok/).
25 | 
26 | # Documentation
27 | 
28 | Please see the [Vaadin Boot](https://github.com/mvysny/vaadin-boot#preparing-environment) documentation
29 | on how you run, develop and package this Vaadin-Boot-based app.
30 | 
31 | ## Database
32 | 
33 | Without the database, we could store the categories and reviews into session only, which would then be gone when the server rebooted.
34 | We will use the [Vaadin-on-Kotlin](http://vaadinonkotlin.eu/)'s SQL database support. To make things easy we'll
35 | use in-memory H2 database which will be gone when the server is rebooted - *touche* :-D
36 | 
37 | We will use [Flyway](https://flywaydb.org/) for database migration. Check out [Bootstrap.kt](src/main/kotlin/com/vaadin/starter/beveragebuddy/Bootstrap.kt)
38 | on how the [migration scripts](src/main/resources/db/migration) are ran when the app is initialized.
39 | 
40 | The [Category](src/main/kotlin/com/vaadin/starter/beveragebuddy/backend/Category.kt)
41 | and [Review](src/main/kotlin/com/vaadin/starter/beveragebuddy/backend/Review.kt)
42 | entities are mapped to the database tables; inheriting from Entity and Dao
43 | will make it inherit bunch of useful methods such as `findAll()` and `save()`. It will also gain means of
44 | providing all of its instances via a `DataProvider`. See the [CategoriesList.kt](src/main/kotlin/com/vaadin/starter/beveragebuddy/ui/categories/CategoriesList.kt)
45 | Grid configuration for details.
46 | 
47 | ## JOOQ
48 | 
49 | For a JOOQ version of this app, please see [beverage-buddy-jooq](https://github.com/mvysny/beverage-buddy-jooq).
50 | 
51 | For a ktorm version of this app, please see [beverage-buddy-ktorm](https://github.com/mvysny/beverage-buddy-ktorm).


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/ui/categories/CategoryEditorDialog.kt:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2000-2017 Vaadin Ltd.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5 |  * use this file except in compliance with the License. You may obtain a copy of
  6 |  * the License at
  7 |  *
  8 |  * http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 12 |  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 13 |  * License for the specific language governing permissions and limitations under
 14 |  * the License.
 15 |  */
 16 | package com.vaadin.starter.beveragebuddy.ui.categories
 17 | 
 18 | import com.github.mvysny.karibudsl.v10.beanValidationBinder
 19 | import com.github.mvysny.karibudsl.v10.bind
 20 | import com.github.mvysny.karibudsl.v10.textField
 21 | import com.github.mvysny.karibudsl.v10.trimmingConverter
 22 | import com.vaadin.flow.component.confirmdialog.ConfirmDialog
 23 | import com.vaadin.flow.component.formlayout.FormLayout
 24 | import com.vaadin.flow.component.notification.Notification
 25 | import com.vaadin.flow.data.binder.Binder
 26 | import com.vaadin.flow.data.validator.StringLengthValidator
 27 | import com.vaadin.starter.beveragebuddy.backend.Category
 28 | import com.vaadin.starter.beveragebuddy.backend.Review
 29 | import com.vaadin.starter.beveragebuddy.ui.EditorForm
 30 | import com.vaadin.starter.beveragebuddy.ui.EditorDialogFrame
 31 | 
 32 | /**
 33 |  * A form for editing [Category] objects.
 34 |  */
 35 | class CategoryEditorForm(val category: Category) : FormLayout(), EditorForm<Category> {
 36 |     private val isEditing get() = category.id != null
 37 |     override val itemType: String get() = "Category"
 38 |     override val binder: Binder<Category> = beanValidationBinder()
 39 |     init {
 40 |         textField("Category Name") {
 41 |             bind(binder)
 42 |                     .trimmingConverter()
 43 |                     .withValidator(StringLengthValidator(
 44 |                             "Category name must contain at least 3 printable characters",
 45 |                             3, null))
 46 |                     .withValidator({ name -> isNameUnique(name) }, "Category name must be unique")
 47 |                     .bind(Category::name)
 48 |         }
 49 |     }
 50 | 
 51 |     private fun isNameUnique(name: String?): Boolean {
 52 |         if (name.isNullOrBlank()) return true
 53 |         if (category.name == name && isEditing) return true
 54 |         return !Category.existsWithName(name)
 55 |     }
 56 | }
 57 | 
 58 | /**
 59 |  * Opens dialogs for editing [Category] objects.
 60 |  * @property onCategoriesChanged called when a category has been created/edited/deleted.
 61 |  */
 62 | class CategoryEditorDialog(private val onCategoriesChanged: (Category) -> Unit) {
 63 |     private fun maybeDelete(frame: EditorDialogFrame<Category>, item: Category) {
 64 |         val reviewCount = Review.getTotalCountForReviewsInCategory(item.id!!).toInt()
 65 |         if (reviewCount == 0) {
 66 |             delete(frame, item)
 67 |         } else {
 68 |             ConfirmDialog(
 69 |                 "Delete Category “${item.name}”?",
 70 |                 "There are $reviewCount reviews associated with this category.\nDeleting the category will mark the associated reviews as “undefined”. You may link the reviews to other categories on the edit page.",
 71 |                 "Delete"
 72 |             ) {
 73 |                 delete(frame, item)
 74 |             } .open()
 75 |         }
 76 |     }
 77 | 
 78 |     private fun delete(frame: EditorDialogFrame<Category>, item: Category) {
 79 |         item.delete()
 80 |         Notification.show("Category successfully deleted.", 3000, Notification.Position.BOTTOM_START)
 81 |         frame.close()
 82 |         onCategoriesChanged(item)
 83 |     }
 84 | 
 85 |     fun createNew() {
 86 |         edit(Category())
 87 |     }
 88 | 
 89 |     fun edit(category: Category) {
 90 |         val frame = EditorDialogFrame(CategoryEditorForm(category))
 91 |         frame.onSaveItem = {
 92 |             val creating: Boolean = category.id == null
 93 |             category.save()
 94 |             val op: String = if (creating) "added" else "saved"
 95 |             Notification.show("Category successfully ${op}.", 3000, Notification.Position.BOTTOM_START)
 96 |             onCategoriesChanged(category)
 97 |         }
 98 |         frame.onDeleteItem = { item -> maybeDelete(frame, item) }
 99 |         frame.open(category, category.id == null)
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/backend/Review.kt:
--------------------------------------------------------------------------------
  1 | package com.vaadin.starter.beveragebuddy.backend
  2 | 
  3 | import com.github.vokorm.*
  4 | import com.gitlab.mvysny.jdbiorm.Dao
  5 | import com.gitlab.mvysny.jdbiorm.DaoOfJoin
  6 | import com.gitlab.mvysny.jdbiorm.TableProperty
  7 | import com.gitlab.mvysny.jdbiorm.condition.Condition
  8 | import com.gitlab.mvysny.jdbiorm.vaadin.EntityDataProvider
  9 | import java.time.LocalDate
 10 | import jakarta.validation.constraints.*
 11 | import org.jdbi.v3.core.mapper.Nested
 12 | import org.jdbi.v3.core.mapper.reflect.ColumnName
 13 | import java.io.Serializable
 14 | 
 15 | /**
 16 |  * Represents a beverage review.
 17 |  * @property name the beverage name
 18 |  * @property score the score, 1..5, 1 being worst, 5 being best
 19 |  * @property date when the review was done
 20 |  * @property category the beverage category [Category.id]. May be null if the category has been deleted.
 21 |  * @property count times tasted, 1..99
 22 |  */
 23 | data class Review(override var id: Long? = null,
 24 |                   
 25 |                   @field:NotNull
 26 |                   @field:Min(1)
 27 |                   @field:Max(5)
 28 |                   var score: Int = 1,
 29 | 
 30 |                   @field:NotBlank
 31 |                   @field:Size(min = 3)
 32 |                   var name: String = "",
 33 | 
 34 |                   @field:NotNull
 35 |                   @field:PastOrPresent
 36 |                   var date: LocalDate = LocalDate.now(),
 37 | 
 38 |                   @field:NotNull
 39 |                   var category: Long? = null,
 40 | 
 41 |                   @field:NotNull
 42 |                   @field:Min(1)
 43 |                   @field:Max(99)
 44 |                   var count: Int = 1) : KEntity<Long> {
 45 | 
 46 |     companion object : Dao<Review, Long>(Review::class.java) {
 47 |         val NAME = TableProperty.of<Review, String>(Review::class.java, "name")
 48 |         val SCORE = TableProperty.of<Review, Int>(Review::class.java, "score")
 49 |         val DATE = TableProperty.of<Review, LocalDate>(Review::class.java, "date")
 50 |         val CATEGORY = TableProperty.of<Review, Long?>(Review::class.java, "category")
 51 |         val COUNT = TableProperty.of<Review, Int>(Review::class.java, "count")
 52 |         /**
 53 |          * Computes the total sum of [count] for all reviews belonging to given [categoryId].
 54 |          * @return the total sum, 0 or greater.
 55 |          */
 56 |         fun getTotalCountForReviewsInCategory(categoryId: Long): Long = db {
 57 |             handle.createQuery("select sum(r.count) from Review r where r.category = :catId")
 58 |                     .bind("catId", categoryId)
 59 |                     .mapTo(Long::class.java).one() ?: 0L
 60 |         }
 61 |     }
 62 | }
 63 | 
 64 | /**
 65 |  * Holds the join of Review and its Category.
 66 |  * @property categoryName the [Category.name]
 67 |  */
 68 | data class ReviewWithCategory(
 69 |     @field:Nested
 70 |     var review: Review? = null,
 71 |     @field:ColumnName("categoryName")
 72 |     var categoryName: String? = null
 73 | ) : Serializable {
 74 |     companion object {
 75 |         /**
 76 |          * Fetches the reviews matching the given filter text.
 77 |          *
 78 |          * This data provider provides sorting/paging/filtering and may be used for
 79 |          * SELECTs returning huge amount of data.
 80 |          */
 81 |         val dataProvider: EntityDataProvider<ReviewWithCategory>
 82 |             // we need to use SQL alias here, since both r.name and c.name exist and H2 would complain of a name clash.
 83 |         get() = EntityDataProvider(DaoOfJoin(ReviewWithCategory::class.java, """select Review.*, IFNULL(c.name, 'Undefined') as categoryName
 84 |                 FROM Review left join Category c on Review.category = c.id"""))
 85 |     }
 86 | }
 87 | 
 88 | /**
 89 |  * This utility function returns a new loader which searches for given [filter] text
 90 |  * in all [Review] and [ReviewWithCategory] fields.
 91 |  */
 92 | fun EntityDataProvider<ReviewWithCategory>.setFilterText(filter: String?) {
 93 |     if (filter.isNullOrBlank()) {
 94 |         this.filter = Condition.NO_CONDITION
 95 |     } else {
 96 |         val normalizedFilter: String = filter.trim().lowercase() + "%"
 97 |         val c: Condition = buildCondition<ReviewWithCategory> {
 98 |             """Review.name ILIKE :filter
 99 |                     or IFNULL(c.name, 'Undefined') ILIKE :filter
100 |                     or CAST(Review.score as VARCHAR) ILIKE :filter
101 |                     or CAST(Review.count as VARCHAR) ILIKE :filter""".trimMargin()("filter" to normalizedFilter)
102 |         }
103 |         this.filter = c
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/Bootstrap.kt:
--------------------------------------------------------------------------------
  1 | package com.vaadin.starter.beveragebuddy
  2 | 
  3 | import com.github.mvysny.kaributools.addMetaTag
  4 | import com.gitlab.mvysny.jdbiorm.JdbiOrm
  5 | import com.vaadin.flow.component.dependency.CssImport
  6 | import com.vaadin.flow.component.notification.Notification
  7 | import com.vaadin.flow.component.notification.NotificationVariant
  8 | import com.vaadin.flow.component.page.AppShellConfigurator
  9 | import com.vaadin.flow.component.page.BodySize
 10 | import com.vaadin.flow.component.page.Viewport
 11 | import com.vaadin.flow.server.ServiceInitEvent
 12 | import com.vaadin.flow.server.VaadinServiceInitListener
 13 | import com.vaadin.flow.server.VaadinSession
 14 | import com.vaadin.flow.theme.Theme
 15 | import eu.vaadinonkotlin.VaadinOnKotlin
 16 | import com.vaadin.starter.beveragebuddy.backend.DemoData
 17 | import com.zaxxer.hikari.HikariConfig
 18 | import com.zaxxer.hikari.HikariDataSource
 19 | import org.flywaydb.core.Flyway
 20 | import org.h2.Driver
 21 | import org.slf4j.LoggerFactory
 22 | import jakarta.servlet.ServletContextEvent
 23 | import jakarta.servlet.ServletContextListener
 24 | import jakarta.servlet.annotation.WebListener
 25 | 
 26 | /**
 27 |  * Boots the app:
 28 |  *
 29 |  * * Makes sure that the database is up-to-date, by running migration scripts with Flyway. This will work even in cluster as Flyway
 30 |  *   automatically obtains a cluster-wide database lock.
 31 |  * * Initializes the VaadinOnKotlin framework.
 32 |  * * Maps Vaadin to `/`, maps REST server to `/rest`
 33 |  * @author mvy
 34 |  */
 35 | @WebListener
 36 | class Bootstrap: ServletContextListener {
 37 |     override fun contextInitialized(sce: ServletContextEvent?) {
 38 |         log.info("Starting up")
 39 | 
 40 |         // this will configure your database. For demo purposes, an in-memory embedded H2 database is used. To use a production-ready database:
 41 |         // 1. fill in the proper JDBC URL here
 42 |         // 2. make sure to include the database driver into the classpath, by adding a dependency on the driver into the build.gradle file.
 43 |         val cfg = HikariConfig().apply {
 44 |             driverClassName = Driver::class.java.name
 45 |             jdbcUrl = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1"
 46 |             username = "sa"
 47 |             password = ""
 48 |         }
 49 |         JdbiOrm.setDataSource(HikariDataSource(cfg))
 50 | 
 51 |         // Initializes the VoK framework
 52 |         log.info("Initializing VaadinOnKotlin")
 53 |         VaadinOnKotlin.init()
 54 | 
 55 |         // Makes sure the database is up-to-date
 56 |         log.info("Running DB migrations")
 57 |         val flyway: Flyway = Flyway.configure()
 58 |             .dataSource(JdbiOrm.getDataSource())
 59 |             .load()
 60 |         flyway.migrate()
 61 | 
 62 |         // pre-populates the database with a demo data
 63 |         log.info("Populating database with testing data")
 64 |         DemoData.createDemoData()
 65 |         log.info("Initialization complete")
 66 |     }
 67 | 
 68 |     override fun contextDestroyed(sce: ServletContextEvent?) {
 69 |         log.info("Shutting down");
 70 |         log.info("Destroying VaadinOnKotlin")
 71 |         VaadinOnKotlin.destroy()
 72 |         log.info("Closing database connections")
 73 |         JdbiOrm.destroy()
 74 |         log.info("Shutdown complete")
 75 |     }
 76 | 
 77 |     companion object {
 78 |         private val log = LoggerFactory.getLogger(Bootstrap::class.java)
 79 |     }
 80 | }
 81 | 
 82 | /**
 83 |  * Configures Vaadin. Registered via the Java Service Loader API.
 84 |  */
 85 | class MyServiceInitListener : VaadinServiceInitListener {
 86 |     override fun serviceInit(event: ServiceInitEvent) {
 87 |         event.addIndexHtmlRequestListener {
 88 |             it.document.head().addMetaTag("apple-mobile-web-app-capable", "yes")
 89 |             it.document.head().addMetaTag("apple-mobile-web-app-status-bar-style", "black")
 90 |         }
 91 |         event.source.addSessionInitListener { initSession(it.session) }
 92 |     }
 93 | 
 94 |     private fun initSession(session: VaadinSession) {
 95 |         session.setErrorHandler {
 96 |             log.error("Internal error", it.throwable)
 97 |             val n = Notification.show("We're sorry, an internal error occurred", 3000, Notification.Position.TOP_CENTER)
 98 |             n.addThemeVariants(NotificationVariant.LUMO_ERROR)
 99 |             n.open()
100 |         }
101 |     }
102 | 
103 |     companion object {
104 |         @JvmStatic
105 |         private val log = LoggerFactory.getLogger(MyServiceInitListener::class.java)
106 |     }
107 | }
108 | 
109 | @BodySize(width = "100vw", height = "100vh")
110 | @Theme("my-theme")
111 | @Viewport("width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes")
112 | class AppShell: AppShellConfigurator
113 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/backend/DemoData.kt:
--------------------------------------------------------------------------------
  1 | package com.vaadin.starter.beveragebuddy.backend
  2 | 
  3 | import com.github.vokorm.db
  4 | import java.time.LocalDate
  5 | import kotlin.random.Random
  6 | 
  7 | internal object DemoData {
  8 | 
  9 |     private const val MINERAL_WATER = "Mineral Water"
 10 |     private const val SOFT_DRINK = "Soft Drink"
 11 |     private const val COFFEE = "Coffee"
 12 |     private const val TEA = "Tea"
 13 |     private const val DAIRY = "Dairy"
 14 |     private const val CIDER = "Cider"
 15 |     private const val BEER = "Beer"
 16 |     private const val WINE = "Wine"
 17 |     private const val OTHER = "Other"
 18 | 
 19 |     /**
 20 |      * Maps beverage name to a beverage category.
 21 |      */
 22 |     private val BEVERAGES: MutableMap<String, String> = LinkedHashMap()
 23 | 
 24 |     init {
 25 |         listOf("Evian",
 26 |                 "Voss",
 27 |                 "Veen",
 28 |                 "San Pellegrino",
 29 |                 "Perrier")
 30 |                 .forEach { name -> BEVERAGES[name] = MINERAL_WATER }
 31 | 
 32 |         listOf("Coca-Cola",
 33 |                 "Fanta",
 34 |                 "Sprite")
 35 |                 .forEach { name -> BEVERAGES[name] = SOFT_DRINK }
 36 | 
 37 |         listOf("Maxwell Ready-to-Drink Coffee",
 38 |                 "Nescafé Gold",
 39 |                 "Starbucks East Timor Tatamailau")
 40 |                 .forEach { name -> BEVERAGES[name] = COFFEE }
 41 | 
 42 |         listOf("Prince Of Peace Organic White Tea",
 43 |                 "Pai Mu Tan White Peony Tea",
 44 |                 "Tazo Zen Green Tea",
 45 |                 "Dilmah Sencha Green Tea",
 46 |                 "Twinings Earl Grey",
 47 |                 "Twinings Lady Grey",
 48 |                 "Classic Indian Chai")
 49 |                 .forEach { name -> BEVERAGES[name] = TEA }
 50 | 
 51 |         listOf("Cow's Milk",
 52 |                 "Goat's Milk",
 53 |                 "Unicorn's Milk",
 54 |                 "Salt Lassi",
 55 |                 "Mango Lassi",
 56 |                 "Airag")
 57 |                 .forEach { name -> BEVERAGES[name] = DAIRY }
 58 | 
 59 |         listOf("Crowmoor Extra Dry Apple",
 60 |                 "Golden Cap Perry",
 61 |                 "Somersby Blueberry",
 62 |                 "Kopparbergs Naked Apple Cider",
 63 |                 "Kopparbergs Raspberry",
 64 |                 "Kingstone Press Wild Berry Flavoured Cider",
 65 |                 "Crumpton Oaks Apple",
 66 |                 "Frosty Jack's",
 67 |                 "Ciderboys Mad Bark",
 68 |                 "Angry Orchard Stone Dry",
 69 |                 "Walden Hollow",
 70 |                 "Fox Barrel Wit Pear")
 71 |                 .forEach { name -> BEVERAGES[name] = CIDER }
 72 | 
 73 |         listOf("Budweiser",
 74 |                 "Miller",
 75 |                 "Heineken",
 76 |                 "Holsten Pilsener",
 77 |                 "Krombacher",
 78 |                 "Weihenstephaner Hefeweissbier",
 79 |                 "Ayinger Kellerbier",
 80 |                 "Guinness Draught",
 81 |                 "Kilkenny Irish Cream Ale",
 82 |                 "Hoegaarden White",
 83 |                 "Barbar",
 84 |                 "Corsendonk Agnus Dei",
 85 |                 "Leffe Blonde",
 86 |                 "Chimay Tripel",
 87 |                 "Duvel",
 88 |                 "Pilsner Urquell",
 89 |                 "Kozel",
 90 |                 "Staropramen",
 91 |                 "Lapin Kulta IVA",
 92 |                 "Kukko Pils III",
 93 |                 "Finlandia Sahti")
 94 |                 .forEach { name -> BEVERAGES[name] = BEER }
 95 | 
 96 |         listOf("Jacob's Creek Classic Shiraz",
 97 |                 "Chateau d’Yquem Sauternes",
 98 |                 "Oremus Tokaji Aszú 5 Puttonyos")
 99 |                 .forEach { name -> BEVERAGES[name] = WINE }
100 | 
101 |         listOf("Pan Galactic Gargle Blaster",
102 |                 "Mead",
103 |                 "Soma")
104 |                 .forEach { name -> BEVERAGES[name] = OTHER }
105 |     }
106 | 
107 |     fun createDemoData() = db {
108 |         // generate categories
109 |         BEVERAGES.values.distinct().forEach { name -> Category(name = name).save() }
110 | 
111 |         /// generate reviews
112 |         val reviewCount: Int = 20 + Random.nextInt(30)
113 |         val beverages: List<MutableMap.MutableEntry<String, String>> = BEVERAGES.entries.toList()
114 | 
115 |         for (i in 0 until reviewCount) {
116 |             val review = Review()
117 |             val beverage: MutableMap.MutableEntry<String, String> = beverages.random()
118 |             val category: Category = Category.getByName(beverage.value)
119 |             review.name = beverage.key
120 |             val testDay: LocalDate = LocalDate.of(
121 |                 1930 + Random.nextInt(88),
122 |                 1 + Random.nextInt(12),
123 |                 1 + Random.nextInt(28))
124 |             review.date = testDay
125 |             review.score = 1 + Random.nextInt(5)
126 |             review.category = category.id
127 |             review.count = 1 + Random.nextInt(15)
128 |             review.save()
129 |         }
130 |     }
131 | }
132 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/ui/EditorDialogFrame.kt:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2000-2017 Vaadin Ltd.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5 |  * use this file except in compliance with the License. You may obtain a copy of
  6 |  * the License at
  7 |  *
  8 |  * http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 12 |  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 13 |  * License for the specific language governing permissions and limitations under
 14 |  * the License.
 15 |  */
 16 | package com.vaadin.starter.beveragebuddy.ui
 17 | 
 18 | import com.github.mvysny.karibudsl.v10.*
 19 | import com.github.mvysny.karibudsl.v23.footer
 20 | import com.github.mvysny.karibudsl.v23.header
 21 | import com.github.mvysny.kaributools.setPrimary
 22 | import com.vaadin.flow.component.Component
 23 | import com.vaadin.flow.component.button.Button
 24 | import com.vaadin.flow.component.button.ButtonVariant
 25 | import com.vaadin.flow.component.dialog.Dialog
 26 | import com.vaadin.flow.component.formlayout.FormLayout
 27 | import com.vaadin.flow.component.html.H3
 28 | import com.vaadin.flow.component.notification.Notification
 29 | import com.vaadin.flow.data.binder.Binder
 30 | import java.io.Serializable
 31 | 
 32 | /**
 33 |  * The editor form which edits beans of type [T]. This class is a Vaadin component
 34 |  * (usually a [FormLayout]) which contains the fields. All fields are also referenced
 35 |  * via [binder]. Nest this into the [EditorDialogFrame].
 36 |  */
 37 | interface EditorForm<T : Serializable> {
 38 |     /**
 39 |      * The displayable name of the item type [T].
 40 |      */
 41 |     val itemType: String
 42 |     /**
 43 |      * All form fields are registered to this binder.
 44 |      */
 45 |     val binder: Binder<T>
 46 | }
 47 | 
 48 | /**
 49 |  * A dialog frame for dialogs adding, editing or deleting items.
 50 |  *
 51 |  * Users are expected to:
 52 |  *  * Set [form] with a proper implementation.
 53 |  *  * Set [onSaveItem] and [onDeleteItem]
 54 |  *  * Call [open] to show the dialog.
 55 |  * @param T the type of the item to be added, edited or deleted
 56 |  * @property form the form itself
 57 |  */
 58 | class EditorDialogFrame<T : Serializable>(private val form: EditorForm<T>) : Dialog() {
 59 | 
 60 |     private lateinit var titleField: H3
 61 |     private lateinit var saveButton: Button
 62 |     private lateinit var cancelButton: Button
 63 |     private lateinit var deleteButton: Button
 64 | 
 65 |     /**
 66 |      * The item currently being edited.
 67 |      */
 68 |     var currentItem: T? = null
 69 |         private set
 70 | 
 71 |     /**
 72 |      * Callback after the edited item has been saved/created. The dialog frame is closed automatically.
 73 |      */
 74 |     lateinit var onSaveItem: (item: T)->Unit
 75 | 
 76 |     /**
 77 |      * Callback to delete the edited item. Should open confirmation dialog (or delete the item directly if possible).
 78 |      * Note that the frame is not closed automatically and must be closed manually.
 79 |      */
 80 |     lateinit var onDeleteItem: (item: T)->Unit
 81 | 
 82 |     init {
 83 |         isCloseOnEsc = true
 84 |         isCloseOnOutsideClick = false
 85 | 
 86 |         header {
 87 |             titleField = h3()
 88 |         }
 89 |         add(form as Component)
 90 |         footer {
 91 |             saveButton = button("Save") {
 92 |                 isAutofocus = true
 93 |                 setPrimary()
 94 |             }
 95 |             cancelButton = button("Cancel") {
 96 |                 addClickListener { close() }
 97 |             }
 98 |             deleteButton = button("Delete") {
 99 |                 addThemeVariants(ButtonVariant.LUMO_ERROR)
100 |                 addClickListener { onDeleteItem(currentItem!!) }
101 |             }
102 |         }
103 |     }
104 | 
105 |     init {
106 |         saveButton.addClickListener { saveClicked() }
107 |     }
108 | 
109 |     /**
110 |      * Opens given item for editing in this dialog.
111 |      *
112 |      * @param item The item to edit; it may be an existing or a newly created instance
113 |      * @param creating if true, the item is being created; if false, the item is being edited.
114 |      */
115 |     fun open(item: T, creating: Boolean) {
116 |         currentItem = item
117 |         val operation = if (creating) "Add new" else "Edit"
118 |         titleField.text = "$operation ${form.itemType}"
119 |         form.binder.readBean(currentItem)
120 | 
121 |         deleteButton.isVisible = !creating
122 |         saveButton.text = if (creating) "Create" else "Save"
123 |         open()
124 |     }
125 | 
126 |     private fun saveClicked() {
127 |         // form.binder.isValid won't set `isInvalid` and `errorMessage` of invalid components - avoid.
128 |         // use form.binder.validate() instead.
129 |         if (form.binder.validate().isOk && form.binder.writeBeanIfValid(currentItem!!)) {
130 |             onSaveItem(currentItem!!)
131 |             close()
132 |         } else {
133 |             Notification.show("There are errors in the form", 3000, Notification.Position.BOTTOM_START)
134 |         }
135 |     }
136 | }
137 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/ui/reviews/ReviewEditorDialog.kt:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2000-2017 Vaadin Ltd.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5 |  * use this file except in compliance with the License. You may obtain a copy of
  6 |  * the License at
  7 |  *
  8 |  * http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 12 |  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 13 |  * License for the specific language governing permissions and limitations under
 14 |  * the License.
 15 |  */
 16 | package com.vaadin.starter.beveragebuddy.ui.reviews
 17 | 
 18 | import com.github.mvysny.karibudsl.v10.*
 19 | import com.vaadin.flow.component.confirmdialog.ConfirmDialog
 20 | import com.vaadin.flow.component.formlayout.FormLayout
 21 | import com.vaadin.flow.component.notification.Notification
 22 | import com.vaadin.flow.data.binder.Binder
 23 | import com.vaadin.starter.beveragebuddy.backend.Category
 24 | import com.vaadin.starter.beveragebuddy.backend.Review
 25 | import com.vaadin.starter.beveragebuddy.ui.EditorDialogFrame
 26 | import com.vaadin.starter.beveragebuddy.ui.EditorForm
 27 | import eu.vaadinonkotlin.vaadin.vokdb.dataProvider
 28 | import eu.vaadinonkotlin.vaadin.vokdb.toId
 29 | import eu.vaadinonkotlin.vaadin.vokdb.withStringFilterOn
 30 | import java.time.LocalDate
 31 | 
 32 | /**
 33 |  * A dialog for editing [Review] objects.
 34 |  */
 35 | class ReviewEditorForm : FormLayout(), EditorForm<Review> {
 36 |     override val itemType: String get() = "Review"
 37 |     // to propagate the changes made in the fields by the user, we will use binder to bind the field to the Review property.
 38 |     override val binder: Binder<Review> = beanValidationBinder()
 39 | 
 40 |     init {
 41 |         responsiveSteps {
 42 |             "0"(1); "50em"(2)
 43 |         }
 44 | 
 45 |         textField("Beverage name") {
 46 |             // no need to have validators here: they are automatically picked up from the bean field.
 47 |             bind(binder).trimmingConverter().bind(Review::name)
 48 |         }
 49 |         integerField("Times tasted") {
 50 |             bind(binder).bind(Review::count)
 51 |         }
 52 |         comboBox<Category>("Choose a category") {
 53 |             // we need to show a list of options for the user to choose from. For every option we need to retain at least:
 54 |             // 1. the category ID (to bind it to Review::category)
 55 |             // 2. the category name (to show it to the user when the combobox's option list is expanded)
 56 |             // since the Category class already provides these values, we will simply use that as the data source for the options.
 57 |             //
 58 |             // now we need to configure the item label generator so that we can extract the name out of Category and display it to the user:
 59 |             setItemLabelGenerator { it.name }
 60 | 
 61 |             // can't create new Categories here
 62 |             isAllowCustomValue = false
 63 | 
 64 |             // provide the list of options as a DataProvider, providing instances of Category
 65 |             setItems(Category.dataProvider.withStringFilterOn(Category::name))
 66 | 
 67 |             // bind the combo box to the Review::category field so that changes done by the user are stored.
 68 |             bind(binder).toId().bind(Review::category)
 69 |         }
 70 |         datePicker("Choose the date") {
 71 |             max = LocalDate.now()
 72 |             min = LocalDate.of(1, 1, 1)
 73 |             bind(binder).bind(Review::date)
 74 |         }
 75 |         comboBox<String>("Mark a score") {
 76 |             isAllowCustomValue = false
 77 |             setItems("1", "2", "3", "4", "5")
 78 |             bind(binder).toInt().bind(Review::score)
 79 |         }
 80 |     }
 81 | }
 82 | 
 83 | /**
 84 |  * A dialog for editing [Review] objects.
 85 |  * @property onReviewsChanged Callback when an item has been created/saved/deleted
 86 |  */
 87 | class ReviewEditorDialog(private val onReviewsChanged: (Review) -> Unit) {
 88 |     fun createNew() {
 89 |         edit(Review())
 90 |     }
 91 | 
 92 |     private fun maybeDelete(frame: EditorDialogFrame<Review>, item: Review) {
 93 |         ConfirmDialog(
 94 |             "Delete beverage",
 95 |             "Are you sure you want to delete beverage '${item.name}'?",
 96 |             "Delete"
 97 |         ) {
 98 |             item.delete()
 99 |             Notification.show("Beverage successfully deleted.", 3000, Notification.Position.BOTTOM_START)
100 |             frame.close()
101 |             onReviewsChanged(item)
102 |         } .open()
103 |     }
104 | 
105 |     fun edit(review: Review) {
106 |         val frame: EditorDialogFrame<Review> = EditorDialogFrame(ReviewEditorForm())
107 |         frame.onSaveItem = {
108 |             val creating: Boolean = review.id == null
109 |             review.save()
110 |             val op = if (creating) "added" else "saved"
111 |             Notification.show("Beverage successfully ${op}.", 3000, Notification.Position.BOTTOM_START)
112 |             onReviewsChanged(review)
113 |         }
114 |         frame.onDeleteItem = { item -> maybeDelete(frame, item) }
115 |         frame.open(review, review.id == null)
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/ui/categories/CategoriesList.kt:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2000-2017 Vaadin Ltd.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5 |  * use this file except in compliance with the License. You may obtain a copy of
  6 |  * the License at
  7 |  *
  8 |  * http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 12 |  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 13 |  * License for the specific language governing permissions and limitations under
 14 |  * the License.
 15 |  */
 16 | package com.vaadin.starter.beveragebuddy.ui.categories
 17 | 
 18 | import com.github.mvysny.karibudsl.v10.*
 19 | import com.github.mvysny.kaributools.ModifierKey.*
 20 | import com.github.mvysny.kaributools.addShortcut
 21 | import com.github.vokorm.buildCondition
 22 | import com.github.vokorm.exp
 23 | import com.vaadin.flow.component.Key.*
 24 | import com.vaadin.flow.component.button.Button
 25 | import com.vaadin.flow.component.button.ButtonVariant
 26 | import com.vaadin.flow.component.grid.Grid
 27 | import com.vaadin.flow.component.grid.contextmenu.GridContextMenu
 28 | import com.vaadin.flow.component.html.H3
 29 | import com.vaadin.flow.component.icon.Icon
 30 | import com.vaadin.flow.component.icon.VaadinIcon
 31 | import com.vaadin.flow.component.notification.Notification
 32 | import com.vaadin.flow.data.renderer.ComponentRenderer
 33 | import com.vaadin.flow.router.PageTitle
 34 | import com.vaadin.flow.router.Route
 35 | import com.vaadin.starter.beveragebuddy.backend.Category
 36 | import com.vaadin.starter.beveragebuddy.backend.Review
 37 | import com.vaadin.starter.beveragebuddy.ui.*
 38 | import eu.vaadinonkotlin.vaadin.setSortProperty
 39 | import eu.vaadinonkotlin.vaadin.vokdb.dataProvider
 40 | 
 41 | /**
 42 |  * Displays the list of available categories, with a search filter as well as
 43 |  * buttons to add a new category or edit existing ones.
 44 |  */
 45 | @Route(value = "categories", layout = MainLayout::class)
 46 | @PageTitle("Categories List")
 47 | class CategoriesList : KComposite() {
 48 | 
 49 |     private lateinit var header: H3
 50 |     private lateinit var toolbar: Toolbar
 51 |     private lateinit var grid: Grid<Category>
 52 |     // can't retrieve GridContextMenu from Grid: https://github.com/vaadin/vaadin-grid-flow/issues/523
 53 |     lateinit var gridContextMenu: GridContextMenu<Category>
 54 | 
 55 |     private val editorDialog = CategoryEditorDialog { updateView() }
 56 | 
 57 |     private val dataProvider = Category.dataProvider
 58 | 
 59 |     private val root = ui {
 60 |         verticalLayout(false) {
 61 |             content { align(stretch, top) }
 62 |             toolbar = toolbarView("New category") {
 63 |                 onSearch = { updateView() }
 64 |                 onCreate = { editorDialog.createNew() }
 65 |             }
 66 |             header = h3()
 67 |             grid = grid(dataProvider) {
 68 |                 // don't put filter components into additional Grid header since we have a dedicated filter TextField in toolbar
 69 |                 isExpand = true
 70 |                 columnFor(Category::name) {
 71 |                     setSortProperty(Category::name.exp)
 72 |                     setHeader("Category")
 73 |                 }
 74 |                 addColumn { it.getReviewCount() }.setHeader("Beverages")
 75 |                 addColumn(ComponentRenderer<Button, Category>({ cat -> createEditButton(cat) })).apply {
 76 |                     flexGrow = 0; key = "edit"
 77 |                 }
 78 |                 element.themeList.add("row-dividers")
 79 | 
 80 |                 gridContextMenu = gridContextMenu {
 81 |                     item("New", { _ -> editorDialog.createNew() })
 82 |                     item("Edit (Alt+E)", { cat -> if (cat != null) edit(cat) })
 83 |                     item("Delete", { cat -> if (cat != null) deleteCategory(cat) })
 84 |                 }
 85 |             }
 86 | 
 87 |             addShortcut(Alt + KEY_E) {
 88 |                 val category = grid.asSingleSelect().value
 89 |                 if (category != null) {
 90 |                     edit(category)
 91 |                 }
 92 |             }
 93 |         }
 94 |     }
 95 | 
 96 |     init {
 97 |         updateView()
 98 |     }
 99 | 
100 |     private fun createEditButton(category: Category): Button =
101 |         Button("Edit").apply {
102 |             icon = Icon(VaadinIcon.EDIT)
103 |             addClassName("category__edit")
104 |             addThemeVariants(ButtonVariant.LUMO_TERTIARY)
105 |             onClick { edit(category) }
106 |         }
107 | 
108 |     private fun edit(category: Category) {
109 |         editorDialog.edit(category)
110 |     }
111 | 
112 |     private fun Category.getReviewCount(): String = Review.getTotalCountForReviewsInCategory(id!!).toString()
113 | 
114 |     private fun updateView() {
115 |         if (toolbar.searchText.isNotBlank()) {
116 |             dataProvider.filter = buildCondition { Category::name likeIgnoreCase "${toolbar.searchText.trim()}%" }
117 |             header.text = "Search for “${toolbar.searchText}”"
118 |         } else {
119 |             dataProvider.filter = null
120 |             header.text = "Categories"
121 |         }
122 |     }
123 | 
124 |     private fun deleteCategory(category: Category) {
125 |         category.delete()
126 |         Notification.show("Category successfully deleted.", 3000, Notification.Position.BOTTOM_START)
127 |         updateView()
128 |     }
129 | }
130 | 


--------------------------------------------------------------------------------
/src/main/kotlin/com/vaadin/starter/beveragebuddy/ui/reviews/ReviewsList.kt:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2000-2017 Vaadin Ltd.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5 |  * use this file except in compliance with the License. You may obtain a copy of
  6 |  * the License at
  7 |  *
  8 |  * http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 12 |  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 13 |  * License for the specific language governing permissions and limitations under
 14 |  * the License.
 15 |  */
 16 | package com.vaadin.starter.beveragebuddy.ui.reviews
 17 | 
 18 | import com.github.mvysny.karibudsl.v10.*
 19 | import com.github.mvysny.karibudsl.v23.virtualList
 20 | import com.vaadin.flow.component.button.ButtonVariant
 21 | import com.vaadin.flow.component.html.H3
 22 | import com.vaadin.flow.component.html.Span
 23 | import com.vaadin.flow.component.icon.VaadinIcon
 24 | import com.vaadin.flow.component.virtuallist.VirtualList
 25 | import com.vaadin.flow.data.provider.Query
 26 | import com.vaadin.flow.data.renderer.ComponentRenderer
 27 | import com.vaadin.flow.router.PageTitle
 28 | import com.vaadin.flow.router.Route
 29 | import com.vaadin.starter.beveragebuddy.backend.Review
 30 | import com.vaadin.starter.beveragebuddy.backend.ReviewWithCategory
 31 | import com.vaadin.starter.beveragebuddy.backend.setFilterText
 32 | import com.vaadin.starter.beveragebuddy.ui.MainLayout
 33 | import com.vaadin.starter.beveragebuddy.ui.Toolbar
 34 | import com.vaadin.starter.beveragebuddy.ui.toolbarView
 35 | 
 36 | /**
 37 |  * Displays the list of available categories, with a search filter as well as
 38 |  * buttons to add a new category or edit existing ones.
 39 |  */
 40 | @Route(value = "", layout = MainLayout::class)
 41 | @PageTitle("Review List")
 42 | class ReviewsList : KComposite() {
 43 | 
 44 |     private lateinit var toolbar: Toolbar
 45 |     private lateinit var header: H3
 46 |     private lateinit var reviewsGrid: VirtualList<ReviewWithCategory>
 47 |     private val editDialog = ReviewEditorDialog { updateList() }
 48 | 
 49 |     private val dataProvider = ReviewWithCategory.dataProvider
 50 | 
 51 |     private val root = ui {
 52 |         verticalLayout(false) {
 53 |             content { align(stretch, top) }
 54 |             toolbar = toolbarView("New review") {
 55 |                 onSearch = { updateList() }
 56 |                 onCreate = { editDialog.createNew() }
 57 |             }
 58 |             header = h3 {
 59 |                 setId("header")
 60 |             }
 61 |             reviewsGrid = virtualList(dataProvider) {
 62 |                 addClassName("reviews")
 63 |                 setRenderer(ComponentRenderer<ReviewItem, ReviewWithCategory> { row ->
 64 |                     val item = ReviewItem(row)
 65 |                     item.onEdit = { editDialog.edit(Review.getById(row.review!!.id!!)) }
 66 |                     item
 67 |                 })
 68 |             }
 69 |         }
 70 |     }
 71 | 
 72 |     init {
 73 |         updateList()
 74 |     }
 75 | 
 76 |     private fun updateList() {
 77 |         dataProvider.setFilterText(toolbar.searchText)
 78 |         val size: Int = dataProvider.size(Query())
 79 |         if (toolbar.searchText.isBlank()) {
 80 |             header.text = "Reviews"
 81 |             header.add(Span("$size in total"))
 82 |         } else {
 83 |             header.text = "Search for “${toolbar.searchText}”"
 84 |             header.add(Span("$size results"))
 85 |         }
 86 |     }
 87 | }
 88 | 
 89 | /**
 90 |  * Shows a single row stripe with information about a single [ReviewWithCategory].
 91 |  */
 92 | class ReviewItem(val row: ReviewWithCategory) : KComposite() {
 93 |     val review: Review get() = row.review!!
 94 |     /**
 95 |      * Fired when this item is to be edited (the "Edit" button is pressed by the User).
 96 |      */
 97 |     var onEdit: () -> Unit = {}
 98 | 
 99 |     private val root = ui {
100 |         div("review") {
101 |             div("review__rating") {
102 |                 p(review.score.toString()) {
103 |                     className = "review__score"
104 |                     element.setAttribute("data-score", review.score.toString())
105 |                 }
106 |                 p(review.count.toString()) {
107 |                     className = "review__count"
108 |                     span("times tasted")
109 |                 }
110 |             }
111 |             div("review__details") {
112 |                 h4(review.name) {
113 |                     addClassName("review__name")
114 |                 }
115 |                 p {
116 |                     className = "review__category"
117 |                     if (review.category != null) {
118 |                         element.themeList.add("badge small")
119 |                         element.style.set("--category", review.category.toString())
120 |                         text = row.categoryName
121 |                     } else {
122 |                         element.style.set("--category", "-1")
123 |                         text = "Undefined"
124 |                     }
125 |                 }
126 |             }
127 |             div("review__date") {
128 |                 h5("Last tasted")
129 |                 p(review.date.toString())
130 |             }
131 |             button("Edit") {
132 |                 icon = VaadinIcon.EDIT.create()
133 |                 className = "review__edit"
134 |                 addThemeVariants(ButtonVariant.LUMO_TERTIARY)
135 |                 onClick { onEdit() }
136 |             }
137 |         }
138 |     }
139 | 
140 |     override fun toString(): String = "ReviewItem($review)"
141 | }
142 | 


--------------------------------------------------------------------------------
/src/main/frontend/themes/my-theme/styles.css:
--------------------------------------------------------------------------------
  1 | .view-toolbar {
  2 |     display: flex;
  3 |     background-color: var(--lumo-base-color);
  4 |     box-shadow: 0 1px 0 0 var(--lumo-contrast-10pct);
  5 |     margin: 0 calc(-50vw + 50%);
  6 |     padding: 8px calc(50vw - 50% + 16px);
  7 |     position: relative;
  8 |     z-index: 1;
  9 |     flex: none;
 10 | }
 11 | 
 12 | .view-toolbar__search-field {
 13 |     flex: auto;
 14 |     min-width: 0;
 15 |     margin-right: 16px;
 16 | }
 17 | 
 18 | html {
 19 |     --main-layout-header-height: 64px;
 20 |     background-color: transparent !important;
 21 | }
 22 | 
 23 | body {
 24 |     background-color: var(--lumo-contrast-5pct);
 25 | }
 26 | 
 27 | .main-layout {
 28 |     display: flex;
 29 |     flex-direction: column;
 30 |     width: 100%;
 31 |     height: 100%;
 32 |     min-height: 100vh;
 33 |     max-width: 960px;
 34 |     margin: 0 auto;
 35 | }
 36 | 
 37 | .main-layout__title {
 38 |     font-size: 1em;
 39 |     margin: 0;
 40 |     /* Allow the nav-items to take all the space so they are centered */
 41 |     width: 0;
 42 |     line-height: 1;
 43 |     letter-spacing: -0.02em;
 44 |     font-weight: 500;
 45 | }
 46 | 
 47 | .main-layout > * {
 48 |     flex: auto;
 49 | }
 50 | 
 51 | .main-layout__header {
 52 |     display: flex;
 53 |     flex: none;
 54 |     align-items: center;
 55 |     height: var(--main-layout-header-height);
 56 | 
 57 |     /* Stretch to fill the entire browser viewport, while keeping the content constrained to
 58 |        parent element max-width */
 59 |     margin: 0 calc(-50vw + 50%);
 60 |     padding: 16px calc(50vw - 50% + 16px);
 61 | 
 62 |     background-color: var(--lumo-base-color);
 63 |     box-shadow: 0 1px 0 0 var(--lumo-contrast-5pct);
 64 | }
 65 | 
 66 | .main-layout__nav {
 67 |     display: flex;
 68 |     flex: 1;
 69 |     justify-content: center;
 70 | }
 71 | 
 72 | .main-layout__nav-item {
 73 |     display: inline-flex;
 74 |     flex-direction: column;
 75 |     align-items: center;
 76 |     padding: 4px 8px;
 77 |     cursor: pointer;
 78 |     transition: 0.3s color, 0.3s transform;
 79 |     will-change: transform;
 80 |     -webkit-user-select: none;
 81 |     -moz-user-select: none;
 82 |     -ms-user-select: none;
 83 |     user-select: none;
 84 |     font-size: var(--lumo-font-size-s);
 85 |     color: var(--lumo-secondary-text-color);
 86 |     font-weight: 500;
 87 |     line-height: 1.3;
 88 | }
 89 | 
 90 | .main-layout__nav-item:hover {
 91 |     text-decoration: none;
 92 | }
 93 | 
 94 | .main-layout__nav-item:not([highlight]):hover {
 95 |     color: inherit;
 96 | }
 97 | 
 98 | .main-layout__nav-item[highlight] {
 99 |     color: var(--lumo-primary-text-color);
100 |     cursor: default;
101 | }
102 | 
103 | .main-layout__nav-item iron-icon {
104 |     /* Vaadin icons are using a 16x16 grid */
105 |     padding: 4px;
106 |     box-sizing: border-box;
107 |     pointer-events: none;
108 | }
109 | 
110 | 
111 | /** Reviews styles **/
112 | #header {
113 |     display: flex;
114 |     justify-content: space-between;
115 |     flex-wrap: wrap;
116 |     align-items: baseline;
117 | }
118 | 
119 | /* Subtitle for the header */
120 | #header span {
121 |     display: block;
122 |     font-size: var(--lumo-font-size-s);
123 |     font-weight: 400;
124 |     color: var(--lumo-secondary-text-color);
125 |     letter-spacing: 0;
126 |     margin-top: 0.3em;
127 |     margin-left: auto;
128 | }
129 | 
130 | .review {
131 |     display: flex;
132 |     align-items: center;
133 |     width: 100%;
134 |     padding: var(--lumo-space-wide-xl);
135 |     padding-right: var(--lumo-space-m);
136 |     box-sizing: border-box;
137 |     margin-bottom: 14px;
138 |     background-color: var(--lumo-base-color);
139 |     box-shadow: 0 0 0 1px var(--lumo-shade-5pct), 0 2px 5px 0 var(--lumo-shade-10pct);
140 |     border-radius: var(--lumo-border-radius);
141 | }
142 | 
143 | .review__rating {
144 |     flex: none;
145 |     align-self: flex-start;
146 |     margin: 0 1em 0 0;
147 |     position: relative;
148 |     cursor: default;
149 | }
150 | 
151 | .review__score {
152 |     display: inline-flex;
153 |     align-items: center;
154 |     justify-content: center;
155 |     border-radius: var(--lumo-border-radius);
156 |     font-weight: 600;
157 |     width: 2.5em;
158 |     height: 2.5em;
159 |     margin: 0;
160 | }
161 | 
162 | [data-score="1"] {
163 |     box-shadow: inset 0 0 0 1px var(--lumo-contrast-10pct);
164 | }
165 | 
166 | [data-score="2"] {
167 |     background-color: var(--lumo-contrast-20pct);
168 | }
169 | 
170 | [data-score="3"] {
171 |     background-color: var(--lumo-contrast-40pct);
172 | }
173 | 
174 | [data-score="4"] {
175 |     background-color: var(--lumo-contrast-60pct);
176 |     color: var(--lumo-base-color);
177 | }
178 | 
179 | [data-score="5"] {
180 |     background-color: var(--lumo-contrast-80pct);
181 |     color: var(--lumo-base-color);
182 | }
183 | 
184 | .review__count {
185 |     position: absolute;
186 |     display: inline-flex;
187 |     align-items: center;
188 |     justify-content: center;
189 |     height: 20px;
190 |     min-width: 8px;
191 |     padding: 0 6px;
192 |     background: var(--lumo-base-color);
193 |     color: var(--lumo-secondary-text-color);
194 |     top: -10px;
195 |     left: -10px;
196 |     border-radius: var(--lumo-border-radius);
197 |     margin: 0;
198 |     font-size: 12px;
199 |     font-weight: 500;
200 |     box-shadow: 0 0 0 1px var(--lumo-contrast-20pct);
201 | }
202 | 
203 | .review__count span {
204 |     width: 0;
205 |     overflow: hidden;
206 |     white-space: nowrap;
207 | }
208 | 
209 | .review__rating:hover .review__count span {
210 |     width: auto;
211 |     margin-left: 0.4em;
212 | }
213 | 
214 | .review__details {
215 |     width: 100%;
216 |     max-width: calc(100% - 8.5em);
217 |     flex: auto;
218 |     line-height: var(--lumo-line-height-xs);
219 |     overflow: hidden;
220 | }
221 | 
222 | .review__name {
223 |     margin: 0 0.5em 0 0;
224 |     white-space: nowrap;
225 |     overflow: hidden;
226 |     text-overflow: ellipsis;
227 | }
228 | 
229 | .review__category {
230 |     display: inline-block;
231 |     margin: 0;
232 |     font-size: 12px;
233 |     font-weight: 500;
234 |     background-color: var(--lumo-primary-color-10pct);
235 |     color: var(--lumo-primary-text-color);
236 |     border-radius: calc(var(--lumo-border-radius) / 2);
237 |     padding: 0 0.5em;
238 | }
239 | 
240 | /* We only expect to have 10 categories at most, after which the colors start to rotate */
241 | .review__category {
242 |     color: hsla(calc(340 + 360 / 10 * var(--category)), 40%, 20%, 1);
243 |     background-color: hsla(calc(340 + 360 / 10 * var(--category)), 60%, 50%, 0.1);
244 | }
245 | 
246 | .review__date {
247 |     white-space: nowrap;
248 |     line-height: var(--lumo-line-height-xs);
249 |     margin: 0 1em;
250 |     width: 30%;
251 | }
252 | 
253 | .review__date h5 {
254 |     font-size: var(--lumo-font-size-s);
255 |     font-weight: 400;
256 |     color: var(--lumo-secondary-text-color);
257 |     margin: 0;
258 | }
259 | 
260 | .review__date p {
261 |     font-size: var(--lumo-font-size-s);
262 |     margin: 0;
263 | }
264 | 
265 | .review__edit {
266 |     margin: 0 0 0 auto;
267 |     width: 6em;
268 | }
269 | 
270 | .category__edit {
271 |     margin: 0 0 0 auto;
272 | }
273 | 
274 | .reviews {
275 |     padding: 0 4px;
276 | }
277 | 
278 | .reviews__no-matches {
279 |     display: flex;
280 |     align-items: center;
281 |     justify-content: center;
282 |     height: 4em;
283 |     font-size: 22px;
284 |     color: var(--lumo-tertiary-text-color);
285 | }
286 | 
287 | /* Small viewport styles */
288 | @media (max-width: 500px) {
289 |     .review {
290 |         padding: var(--lumo-space-m);
291 |         padding-right: var(--lumo-space-s);
292 |         flex-wrap: wrap;
293 |     }
294 | 
295 |     .review__date {
296 |         order: 1;
297 |         margin-left: 3.5em;
298 |         margin-top: 0.5em;
299 |     }
300 | }
301 | 
302 | h3 {
303 |     margin-top: 0;
304 | }
305 | 
306 | vaadin-form-layout {
307 |     max-width: 30em;
308 | }
309 | 
310 | .confirm-buttons {
311 |     justify-content: space-between;
312 |     padding: var(--lumo-space-xs) var(--lumo-space-m);
313 |     margin-top: var(--lumo-space-m);
314 | }
315 | 
316 | .has-padding {
317 |     padding: 0 var(--lumo-space-l);
318 |     margin: 0 calc(var(--lumo-space-l) * -1);
319 | }
320 | 
321 | .confirm-text {
322 |     max-width: 25em;
323 |     line-height: var(--lumo-line-height-s);
324 | }
325 | 
326 | .confirm-text > * {
327 |     margin-bottom: 0.6em;
328 | }
329 | 
330 | .confirm-text div:not(:first-child) {
331 |     color: var(--lumo-secondary-text-color);
332 |     font-size: var(--lumo-font-size-s);
333 | }
334 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | 
  3 | #
  4 | # Copyright © 2015-2021 the original authors.
  5 | #
  6 | # Licensed under the Apache License, Version 2.0 (the "License");
  7 | # you may not use this file except in compliance with the License.
  8 | # You may obtain a copy of the License at
  9 | #
 10 | #      https://www.apache.org/licenses/LICENSE-2.0
 11 | #
 12 | # Unless required by applicable law or agreed to in writing, software
 13 | # distributed under the License is distributed on an "AS IS" BASIS,
 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | # See the License for the specific language governing permissions and
 16 | # limitations under the License.
 17 | #
 18 | 
 19 | ##############################################################################
 20 | #
 21 | #   Gradle start up script for POSIX generated by Gradle.
 22 | #
 23 | #   Important for running:
 24 | #
 25 | #   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
 26 | #       noncompliant, but you have some other compliant shell such as ksh or
 27 | #       bash, then to run this script, type that shell name before the whole
 28 | #       command line, like:
 29 | #
 30 | #           ksh Gradle
 31 | #
 32 | #       Busybox and similar reduced shells will NOT work, because this script
 33 | #       requires all of these POSIX shell features:
 34 | #         * functions;
 35 | #         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
 36 | #           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
 37 | #         * compound commands having a testable exit status, especially «case»;
 38 | #         * various built-in commands including «command», «set», and «ulimit».
 39 | #
 40 | #   Important for patching:
 41 | #
 42 | #   (2) This script targets any POSIX shell, so it avoids extensions provided
 43 | #       by Bash, Ksh, etc; in particular arrays are avoided.
 44 | #
 45 | #       The "traditional" practice of packing multiple parameters into a
 46 | #       space-separated string is a well documented source of bugs and security
 47 | #       problems, so this is (mostly) avoided, by progressively accumulating
 48 | #       options in "$@", and eventually passing that to Java.
 49 | #
 50 | #       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
 51 | #       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
 52 | #       see the in-line comments for details.
 53 | #
 54 | #       There are tweaks for specific operating systems such as AIX, CygWin,
 55 | #       Darwin, MinGW, and NonStop.
 56 | #
 57 | #   (3) This script is generated from the Groovy template
 58 | #       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 59 | #       within the Gradle project.
 60 | #
 61 | #       You can find Gradle at https://github.com/gradle/gradle/.
 62 | #
 63 | ##############################################################################
 64 | 
 65 | # Attempt to set APP_HOME
 66 | 
 67 | # Resolve links: $0 may be a link
 68 | app_path=$0
 69 | 
 70 | # Need this for daisy-chained symlinks.
 71 | while
 72 |     APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
 73 |     [ -h "$app_path" ]
 74 | do
 75 |     ls=$( ls -ld "$app_path" )
 76 |     link=${ls#*' -> '}
 77 |     case $link in             #(
 78 |       /*)   app_path=$link ;; #(
 79 |       *)    app_path=$APP_HOME$link ;;
 80 |     esac
 81 | done
 82 | 
 83 | APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 84 | 
 85 | APP_NAME="Gradle"
 86 | APP_BASE_NAME=${0##*/}
 87 | 
 88 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 89 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 90 | 
 91 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 92 | MAX_FD=maximum
 93 | 
 94 | warn () {
 95 |     echo "$*"
 96 | } >&2
 97 | 
 98 | die () {
 99 |     echo
100 |     echo "$*"
101 |     echo
102 |     exit 1
103 | } >&2
104 | 
105 | # OS specific support (must be 'true' or 'false').
106 | cygwin=false
107 | msys=false
108 | darwin=false
109 | nonstop=false
110 | case "$( uname )" in                #(
111 |   CYGWIN* )         cygwin=true  ;; #(
112 |   Darwin* )         darwin=true  ;; #(
113 |   MSYS* | MINGW* )  msys=true    ;; #(
114 |   NONSTOP* )        nonstop=true ;;
115 | esac
116 | 
117 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
118 | 
119 | 
120 | # Determine the Java command to use to start the JVM.
121 | if [ -n "$JAVA_HOME" ] ; then
122 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
123 |         # IBM's JDK on AIX uses strange locations for the executables
124 |         JAVACMD=$JAVA_HOME/jre/sh/java
125 |     else
126 |         JAVACMD=$JAVA_HOME/bin/java
127 |     fi
128 |     if [ ! -x "$JAVACMD" ] ; then
129 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
130 | 
131 | Please set the JAVA_HOME variable in your environment to match the
132 | location of your Java installation."
133 |     fi
134 | else
135 |     JAVACMD=java
136 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
137 | 
138 | Please set the JAVA_HOME variable in your environment to match the
139 | location of your Java installation."
140 | fi
141 | 
142 | # Increase the maximum file descriptors if we can.
143 | if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
144 |     case $MAX_FD in #(
145 |       max*)
146 |         MAX_FD=$( ulimit -H -n ) ||
147 |             warn "Could not query maximum file descriptor limit"
148 |     esac
149 |     case $MAX_FD in  #(
150 |       '' | soft) :;; #(
151 |       *)
152 |         ulimit -n "$MAX_FD" ||
153 |             warn "Could not set maximum file descriptor limit to $MAX_FD"
154 |     esac
155 | fi
156 | 
157 | # Collect all arguments for the java command, stacking in reverse order:
158 | #   * args from the command line
159 | #   * the main class name
160 | #   * -classpath
161 | #   * -D...appname settings
162 | #   * --module-path (only if needed)
163 | #   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
164 | 
165 | # For Cygwin or MSYS, switch paths to Windows format before running java
166 | if "$cygwin" || "$msys" ; then
167 |     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
168 |     CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
169 | 
170 |     JAVACMD=$( cygpath --unix "$JAVACMD" )
171 | 
172 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
173 |     for arg do
174 |         if
175 |             case $arg in                                #(
176 |               -*)   false ;;                            # don't mess with options #(
177 |               /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
178 |                     [ -e "$t" ] ;;                      #(
179 |               *)    false ;;
180 |             esac
181 |         then
182 |             arg=$( cygpath --path --ignore --mixed "$arg" )
183 |         fi
184 |         # Roll the args list around exactly as many times as the number of
185 |         # args, so each arg winds up back in the position where it started, but
186 |         # possibly modified.
187 |         #
188 |         # NB: a `for` loop captures its iteration list before it begins, so
189 |         # changing the positional parameters here affects neither the number of
190 |         # iterations, nor the values presented in `arg`.
191 |         shift                   # remove old arg
192 |         set -- "$@" "$arg"      # push replacement arg
193 |     done
194 | fi
195 | 
196 | # Collect all arguments for the java command;
197 | #   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
198 | #     shell script including quotes and variable substitutions, so put them in
199 | #     double quotes to make sure that they get re-expanded; and
200 | #   * put everything else in single quotes, so that it's not re-expanded.
201 | 
202 | set -- \
203 |         "-Dorg.gradle.appname=$APP_BASE_NAME" \
204 |         -classpath "$CLASSPATH" \
205 |         org.gradle.wrapper.GradleWrapperMain \
206 |         "$@"
207 | 
208 | # Stop when "xargs" is not available.
209 | if ! command -v xargs >/dev/null 2>&1
210 | then
211 |     die "xargs is not available"
212 | fi
213 | 
214 | # Use "xargs" to parse quoted args.
215 | #
216 | # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
217 | #
218 | # In Bash we could simply go:
219 | #
220 | #   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
221 | #   set -- "${ARGS[@]}" "$@"
222 | #
223 | # but POSIX shell has neither arrays nor command substitution, so instead we
224 | # post-process each arg (as a line of input to sed) to backslash-escape any
225 | # character that might be a shell metacharacter, then use eval to reverse
226 | # that process (while maintaining the separation between arguments), and wrap
227 | # the whole thing up as a single "set" statement.
228 | #
229 | # This will of course break if any of these variables contains a newline or
230 | # an unmatched quote.
231 | #
232 | 
233 | eval "set -- $(
234 |         printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
235 |         xargs -n1 |
236 |         sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
237 |         tr '\n' ' '
238 |     )" '"$@"'
239 | 
240 | exec "$JAVACMD" "$@"
241 | 


--------------------------------------------------------------------------------