itmodreamteam / myrest Goto Github PK

Integrate the system with the business process management engine, automate one business process and demonstrate its workflow.

1. Implement AccessTokenProvider and register it

    class AccessTokenProviderImpl : AccessTokenProvider {
        var accessToken: String? {
            print("Retrieve access token from persistent storage")
            return "MyToken"
        }
    }

    AccessTokenProviderCompanion.init().INSTANCE = AccessTokenProviderImpl()

2. Implement UnauthenticatedErrorHandler and register it

    class UnauthenticatedErrorHandlerImpl : UnauthenticatedErrorHandler {
        func handle() {
            print("Redirect user to Sign In")
            print("Retrieve access token and persist it")
        }
    }

    UnauthenticatedErrorHandlerCompanion.init().INSTANCE = UnauthenticatedErrorHandlerImpl()

3. Implement DefaultErrorHandler and register it

    class DefaultErrorHandlerImpl : DefaultErrorHandler {
        func handle(clientException: ClientException) {
            print("Take one error from exception and display it")
        }
    }

    DefaultErrorHandlerCompanion.init().INSTANCE = DefaultErrorHandlerImpl()

4. The Error contains ClientException, handleWithDefaultErrorHandler method of which should be invoked as default error handling strategy
   

Representation of an Error:

5. Extend ErrorHandler<CONTEXT> and implement its abstract methods, where CONTEXT is a type required for opening new UI view/screen. On each client method invocation implement exception handling as follows: errorHandler.handle(context, clientException).

• Session Entity
• Phone number verification
• Access token generation
• Access token verification (token -> User)

Implement RestaurantSearchScene

Implement signUp/signIn

Attributes of DTOs that come to the server via REST API must be validated. However, Spring Validation doesn't suit for those DTOs as they are placed in shared module, where multi-platform Kotlin is used.

To be implemented in #31 and #33

Authentication is performed based on the access token, provided via HTTP header

Types of authorization:

• None (public API)
• Requires authentication
• By user role
• Complex: if user has specific permission for specific domain object

• Build shared module for iOS platform

Make use of report generation tools. Demonstrate report being generated, based on the template and input parameters, and exported, e.g. as PDF.

When user registers restaurant, he/she becomes its manager. RestaurantStatus = PENDING. System admin gets notified.

System admin can change restaurant status (invoking updateStatus method) to any of these values:

enum class RestaurantStatus {
    PENDING,
    ACTIVE,
    BLOCKED,
    HIDDEN,
}

On status change, restaurant managers get notified.

• All restaurant info
• Tables

Implement routing between RestaurantList, SignIn, SignUp and UserInfo scenes.

There are 2 types of messages:

1. notification messages
   automatically displayed when the app is in the background
2. data message
   to be displayed by the app when it is in the foreground

Firebase Cloud Messaging

Demonstrate that the system has secured working API and external systems are able to interact with it.

• Restaurant entity
• CRUD
• Simple search (by name)

• Invite user to a restaurant
• View employees/invitations
• View restaurants/invitations
• Update status by user
• Update status by restaurant

IMHO converter methods should not be in service level classes. It's usually different layer because of SRP.
Service does business logic as well as converting entities.
Why is it bad? Because

1. Entity to be converted (say it "xxx") can contain references to other entities (say it "xxxRef") which should be converted as well. So in you XxxService you need to inject XxxRefService. This can lead to cycle dependencies between services which is pretty ok for spring, but may be a problem in tests (X requires Y, Y requires Z, Z requires X -> how to test X?). Cycle dependencies are evil but they are very common for converters so our services will have cycle dependencies even not for doing real business logic but for converting entities.
2. (this is not really relevant for us, but anyway). What if we would want to have different implementation of TableService. We will need to implement the same logic for conversion what will lead to code duplication.

Originally posted by @AlexIvchenko in #19 (comment)

• View tables of a restaurant
• Create table
• Update table info
• Get table by ID
• Delete table
• Edit list of waiters, responsible for the table
• View waiter's tables

Caused by FCM
GOOGLE_APPLICATION_CREDENTIALS var must be provided

Sign In and Sign Up view for Android

PoC: how clients communicate with server by means of multi-platform Kotlin

When restaurant is created, creator is added to its employees list as manager. RestaurantStatus = ACTIVE. UserStatus = PENDING (must be ACTIVE, too).

RestaurantInfo page

For Kotlin/Native and Kotlin/JS

When an error occurs, we need to log it (appropriate logging level, provide as more info as possible, exception stack trace), convert to a readable message that we will show to user, and send this message in a response.

Page where a user can choose a table and reserve it

• User Entity
• Sign Up
• Sign In

• Reserve table in a restaurant
• Get reservation by ID
• Get reservations of user
• Get reservations of restaurant
• Update status (by manager)
• Confirm guest arrival (manager/waiter scans QR code)