Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
# https://www.playframework.com/documentation/latest/Configuration
app {
secret = ${app.default-secret}
secret=${?IZANAMI_SECRET}
default-secret = "S_iVTvZcJhGxA^jPl2y9FLB/Yfh/OH3j/:ce>xa`wawr44Wufm_H3^u5ln7:tiDn" # default value
containerized="false"
containerized = ${?IZANAMI_CONTAINERIZED}
reporting {
url = "https://reporting.otoroshi.io/izanami/ingest"
url = ${?IZANAMI_REPORTING_URL}
}
webhooks {
retry {
count = 5
count = ${?IZANAMI_WEBHOOK_RETRY_COUNT}
intial-delay = 5
intial-delay = ${?IZANAMI_WEBHOOK_RETRY_INITIAL_DELAY}
max-delay = 600
max-delay = ${?IZANAMI_WEBHOOK_RETRY_MAX_DELAY}
multiplier = 2
multiplier = ${?IZANAMI_WEBHOOK_RETRY_MULTIPLIER}
}
}
wasm {
cache {
ttl = 60000
ttl = ${?IZANAMI_WASM_CACHE_TTL}
}
}
admin {
username = "RESERVED_ADMIN_USER"
username = ${?IZANAMI_ADMIN_DEFAULT_USERNAME}
password = ${?IZANAMI_ADMIN_DEFAULT_PASSWORD}
}
exposition {
url= ${?IZANAMI_EXPOSITION_URL}
backend=${?app.exposition.url}
backend=${?IZANAMI_EXPOSITION_BACKEND}
}
openid {
client-id = ${?IZANAMI_OPENID_CLIENT_ID}
client-secret = ${?IZANAMI_OPENID_CLIENT_SECRET}
authorize-url = ${?IZANAMI_OPENID_AUTHORIZE_URL}
token-url = ${?IZANAMI_OPENID_TOKEN_URL}
redirect-url = ${?app.exposition.url}"/login"
redirect-url = ${?IZANAMI_OPENID_REDIRECT_URL}
scopes = "openid email profile"
scopes = ${?IZANAMI_OPENID_SCOPES}
email-field = "email"
email-field = ${?IZANAMI_OPENID_EMAIL_FIELD}
username-field = "name"
username-field = ${?IZANAMI_OPENID_USERNAME_FIELD}
}
wasmo {
url = ${?IZANAMI_WASMO_URL}
client-id = ${?IZANAMI_WASMO_CLIENT_ID}
client-secret = ${?IZANAMI_WASMO_CLIENT_SECRET}
}
pg {
uri = ${?IZANAMI_PG_URI}
uri = ${?POSTGRESQL_ADDON_URI}
pool-size = 20
pool-size = ${?IZANAMI_PG_POOL_SIZE}
port = 5432
port = ${?IZANAMI_PG_PORT}
port = ${?POSTGRESQL_ADDON_PORT}
//host = "localhost"
host = ${?IZANAMI_PG_HOST}
host = ${?POSTGRESQL_ADDON_HOST}
//database = "postgres"
database = ${?IZANAMI_PG_DATABASE}
database = ${?POSTGRESQL_ADDON_DB}
//user = "postgres"
user = ${?IZANAMI_PG_USER}
user = ${?POSTGRESQL_ADDON_USER}
//password = "postgres"
password = ${?IZANAMI_PG_PASSWORD}
password = ${?POSTGRESQL_ADDON_PASSWORD}
connect-timeout = ${?IZANAMI_PG_CONNECT_TIMEOUT}
idle-timeout = ${?IZANAMI_PG_IDLE_TIMEOUT}
max-lifetime = ${?IZANAMI_PG_MAX_LIFETIME}
log-activity = ${?IZANAMI_PG_LOG_ACTIVITY}
pipelining-limit = ${?IZANAMI_PG_PIPELINING_LIMIT}
ssl {
enabled = false
enabled = ${?IZANAMI_PG_SSL_ENABLED}
mode = "VERIFY_CA"
mode = ${?IZANAMI_PG_SSL_MODE}
trusted-certs-path = []
trusted-certs = []
trusted-cert-path = ${?IZANAMI_PG_SSL_TRUSTED_CERT_PATH}
trusted-cert = ${?IZANAMI_PG_SSL_TRUSTED_CERT}
client-certs-path = []
client-certs = []
client-cert-path = ${?IZANAMI_PG_SSL_CLIENT_CERT_PATH}
client-cert = ${?IZANAMI_PG_SSL_CLIENT_CERT}
trust-all = ${?IZANAMI_PG_SSL_TRUST_ALL}
}
}
authentication {
secret = ${?IZANAMI_TOKEN_SECRET}
secret = ${app.secret}
token-body-secret = ${?IZANAMI_TOKEN_BODY_SECRET}
token-body-secret = ${app.secret}
}
invitations {
ttl = ${?IZANAMI_INVITATIONS_TTL}
ttl = 86400
}
sessions {
ttl = ${?IZANAMI_SESSIONS_TTL}
ttl = 3700
}
password-reset-requests {
ttl = ${IZANAMI_PASSWORD_RESET_REQUEST_TTL}
ttl = 900
}
}
# Copyright (C) Lightbend Inc.
# Configuration for Play's AkkaHttpServer
play {
filters {
cors {
pathPrefixes = ${?IZANAMI_CORS_PATH_PREFIXES}
allowedOrigins = ${?IZANAMI_CORS_ALLOWED_ORIGINS}
allowedHttpMethods = ${?IZANAMI_CORS_ALLOWED_HTTP_METHODS}
allowedHttpHeaders = ${?IZANAMI_CORS_ALLOWED_HTTP_HEADERS}
exposedHeaders = ${?IZANAMI_CORS_EXPOSED_HEADERS}
supportsCredentials = ${?IZANAMI_CORS_SUPPORTS_CREDENTIALS}
preflightMaxAge = ${?IZANAMI_CORS_PREFLIGHT_MAX_AGE}
serveForbiddenOrigins = ${?IZANAMI_CORS_SERVE_FORBIDDEN_ORIGINS}
}
}
server {
# The root directory for the Play server instance. This value can
# be set by providing a path as the first argument to the Play server
# launcher script. See `ServerConfig.loadConfiguration`.
dir = ${?user.dir}
# HTTP configuration
http {
# The HTTP port of the server. Use a value of "disabled" if the server
# shouldn't bind an HTTP port.
port = 9000
port = ${?PLAY_HTTP_PORT}
port = ${?http.port}
# The interface address to bind to.
address = "0.0.0.0"
address = ${?PLAY_HTTP_ADDRESS}
address = ${?http.address}
# The idle timeout for an open connection after which it will be closed
# Set to null or "infinite" to disable the timeout, but notice that this
# is not encouraged since timeout are important mechanisms to protect your
# servers from malicious attacks or programming mistakes.
idleTimeout = 75 seconds # The server provider class name
}
https {
# The HTTPS port of the server.
port = ${?PLAY_HTTPS_PORT}
port = ${?https.port}
# The interface address to bind to
address = "0.0.0.0"
address = ${?PLAY_HTTPS_ADDRESS}
address = ${?https.address}
# The idle timeout for an open connection after which it will be closed
# Set to null or "infinite" to disable the timeout, but notice that this
# is not encouraged since timeout are important mechanisms to protect your
# servers from malicious attacks or programming mistakes.
idleTimeout = ${play.server.http.idleTimeout}
# The SSL engine provider
engineProvider = "play.core.server.ssl.DefaultSSLEngineProvider"
engineProvider = ${?play.http.sslengineprovider}
# HTTPS keystore configuration, used by the default SSL engine provider
keyStore {
# The path to the keystore
path = ${?https.keyStore}
# The type of the keystore
type = "JKS"
type = ${?https.keyStoreType}
# The password for the keystore
password = ""
password = ${?https.keyStorePassword}
# The algorithm to use. If not set, uses the platform default algorithm.
algorithm = ${?https.keyStoreAlgorithm}
}
# HTTPS truststore configuration
trustStore {
# If true, does not do CA verification on client side certificates
noCaVerification = false
}
# Whether JSSE want client auth mode should be used. This means, the server
# will request a client certificate, but won't fail if one isn't provided.
wantClientAuth = false
# Whether JSSE need client auth mode should be used. This means, the server
# will request a client certificate, and will fail and terminate the session
# if one isn't provided.
needClientAuth = false
}
# The path to the process id file created by the server when it runs.
# If set to "/dev/null" then no pid file will be created.
pidfile.path = ${play.server.dir}/RUNNING_PID
pidfile.path = ${?pidfile.path}
websocket {
# Maximum allowable frame payload length. Setting this value to your application's
# requirement may reduce denial of service attacks using long data frames.
frame.maxLength = 64k
frame.maxLength = ${?websocket.frame.maxLength}
# Periodic keep alive may be implemented using by sending Ping frames
# upon which the other side is expected to reply with a Pong frame,
# or by sending a Pong frame, which serves as unidirectional heartbeat.
# Valid values:
# ping - default, for bi-directional ping/pong keep-alive heartbeating
# pong - for uni-directional pong keep-alive heartbeating
periodic-keep-alive-mode = ping
# Interval for sending periodic keep-alives
# If a client does not send a frame within this idle time, the server will sent the the keep-alive frame.
# The frame sent will be the one configured in play.server.websocket.periodic-keep-alive-mode
# `infinite` by default, or a duration that is the max idle interval after which an keep-alive frame should be sent
# The value `infinite` means that *no* keep-alive heartbeat will be sent, as: "the allowed idle time is infinite"
periodic-keep-alive-max-idle = infinite
}
debug {
# If set to true this will attach an attribute to each request containing debug information. If the application
# fails to load (e.g. due to a compile issue in dev mode), then this configuration value is ignored and the debug
# information is always attached.
#
# Note: This configuration option is not part of Play's public API and is subject to change without the usual
# deprecation cycle.
addDebugInfoToRequests = false
}
# The maximum length of the HTTP headers. The most common effect of this is a restriction in cookie length, including
# number of cookies and size of cookie values.
max-header-size = 8k
# If a request contains a Content-Length header it will be checked against this maximum value.
# If the value of a given Content-Length header exceeds this configured value, the request will not be processed
# further but instead the error handler will be called with Http status code 413 "Entity too large".
# If set to infinite or if no Content-Length header exists then no check will take place at all
# and the request will continue to be processed.
# Play uses the concept of a `BodyParser` to enforce this limit, so we set it to infinite.
max-content-length = infinite
}
editor = ${?PLAY_EDITOR}
provider = "play.core.server.AkkaHttpServerProvider"
akka {
# How long to wait when binding to the listening socket
bindTimeout = 5 seconds
# How long a request takes until it times out. Set to null or "infinite" to disable the timeout.
requestTimeout = infinite
# Timeout after which all requests and connections shall be forcefully terminated
# when shutting down the server. It will default to Coordinated Shutdown service-unbind
# phase timeout. Value must be a duration, for example:
# play.server.akka.terminationTimeout = 10 seconds
terminationTimeout = null
# Enables/disables automatic handling of HEAD requests.
# If this setting is enabled the server dispatches HEAD requests as GET
# requests to the application and automatically strips off all message
# bodies from outgoing responses.
# Note that, even when this setting is off the server will never send
# out message bodies on responses to HEAD requests.
transparent-head-requests = off
# If this setting is empty the server only accepts requests that carry a
# non-empty `Host` header. Otherwise it responds with `400 Bad Request`.
# Set to a non-empty value to be used in lieu of a missing or empty `Host`
# header to make the server accept such requests.
# Note that the server will never accept HTTP/1.1 request without a `Host`
# header, i.e. this setting only affects HTTP/1.1 requests with an empty
# `Host` header as well as HTTP/1.0 requests.
# Examples: `www.spray.io` or `example.com:8080`
default-host-header = ""
# The default value of the `Server` header to produce if no
# explicit `Server`-header was included in a response.
# If this value is null and no header was included in
# the request, no `Server` header will be rendered at all.
server-header = null
server-header = ${?play.server.server-header}
# Configures the processing mode when encountering illegal characters in
# header value of response.
#
# Supported mode:
# `error` : default mode, throw an ParsingException and terminate the processing
# `warn` : ignore the illegal characters in response header value and log a warning message
# `ignore` : just ignore the illegal characters in response header value
illegal-response-header-value-processing-mode = warn
# Enables/disables inclusion of an Tls-Session-Info header in parsed
# messages over Tls transports (i.e., HttpRequest on server side and
# HttpResponse on client side).
#
# See Akka HTTP `akka.http.server.parsing.tls-session-info-header` for
# more information about how this works.
tls-session-info-header = on
}
}
play.http.secret.key = ${app.secret}
play.application.loader = fr.maif.izanami.IzanamiLoader
play.http.errorHandler = play.api.http.JsonHttpErrorHandler
# This must be big to accept base64 wasm features
play.http.parser.maxMemoryBuffer=4MB
play.assets.cache."/public/index.html"="no-cache, no-store, must-revalidate"
play.assets.cache."/public/assets/"="max-age=30240000"
