path: root/core/config/anom_settings.php

<?php

/** CONFIGURATION PATAMETRES
 * -----------------------------------------------------------------------------
 * This is the first file you need to setup
 * in order to start a new application
 * 
 * NOTE:
 * You may rewrite the defines manualy setting any values manualy
 * Here we propose that you use an .env file (with is a very safe option)
 * the env file is saved into `/core/auth` folder
 */

if (file_exists("../core/auth/.env")) {
    $ini = parse_ini_file("../core/auth/.env");
}

// DEFINE WHETTHER THE APP RUNS ON PRODUCTION
// Don't forget to change this setting
// when deploying to a different stage
// -----------------------------------------------------------------------------

# // define by OS parameter
# if (getenv('ENVIRONMENT')) { 
#     if (getenv('ENVIRONMENT') == 'PRODUCTION') {
#         define('PRODUCTION', true);
#     } else {
#         define('PRODUCTION', false);
#     }
# } 

# define by .env file
define('PRODUCTION', ($ini['ENVIRONMENT'] == 'production') );



// Custom Names ////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------------

define('APP_NAME', 'e-Classroom');      // Application Name

define('APP_VERSION', 'v0.2');          // Application version



/** APPLICATION PATHS ///////////////////////////////////////////////////////////
 * -----------------------------------------------------------------------------
 * 
 * Obligarory
 * These are needed in order to run the bare minimum MVC system
 * They also make code easier to read
 * 
 * NOTE:
 * probably you don't need to chage these defines
 * -----------------------------------------------------------------------------
 */

define('APP_ROOT', dirname(get_included_files()[0]) );

define('URL_ROOT', '/');

define('CREDENTIALS', '../core/config/credentials.php');

define('INIT_APPLICATION', '../core/config/init.php');

define('RENDERING_SYSTEM', '../core/helpers/render.php');

define('VIEWS_DIRECTORY', APP_ROOT.'/app/views/');

define('TESTS_DIRECTORY', APP_ROOT."/../tests/");


/** AUTOLOADER /////////////////////////////////////////////////////////////////
 * -----------------------------------------------------------------------------
 * An autoloader for classes is required;
 * 
 * 
 * OPTION 1: COMPOSER
 * Composer is recommended and makes much more than simple autoloding
 */
define('AUTOLOADER' , '../vendor/autoload.php');

/** ...
 * 
 * OPTION 2: Custom Autoloader
 * If Composer is not supported, another autoloading proccess required
 * Comment/Disable the 1st option and uncomment/Enable the next line
 */
# define('AUTOLOADER' , '../core/helpers/autoload.php');

/** CLASSPATHS : array of paths where classes are saved
 * Needed only when the custom autoloader is used
 * (like autoload.classmap section of Composer)
 */
# define('CLASSPATHS', array(
#     '/../core/classes/',
#     '/app/controllers/',
#     '/app/models/',
#     '/../vendor/'
#   )
# );



 /** SESSION HANDLING //////////////////////////////////////////////////////////
  * ----------------------------------------------------------------------------
  * 
  * there are several session drivers for session handling:
  *    
  * 'DefaultSession'  : uses the default (file-based) php session management
  * 'FileSession'     : defines a custom file-based session mechanism
  * 'DatabaseSession' : mechanism that stores Session data into a DataBase
  * ----------------------------------------------------------------------------
  */

define('SESSION_DRIVER', 'DefaultSession');

// if FileSession is selected, a path for session-files is needed
# define('FILESESSION_PATH', '../storage/session');

/* ADVANCED OPTIMIZATION ///////////////////////////////////////////////////////
 * -----------------------------------------------------------------------------
 *
 * APP_CACHE defines the cache-driver;
 * accepted values are the name of the Cache-interface impementations (the exact
 * names of the classes)
 *
 * 'FileCache'  : caching in filesystem; fair if caching on HDD; great on SSD
 * 'RedisCache' : caching in Redis server; generally recommended if available
 * 'MemCachedCache' : caching in Memcached server; recommended if available
 *
 * NOTE: FileCache on a NVMe SDD is the fastest option;
 * Redis and Memcached are really-fast caching options and are available for
 * scaling horizontaly your application (eache one has it's own strngths;
 * study, then choose the one that fulfills your needs;
 * -----------------------------------------------------------------------------
 */

define('CACHE_DRIVER', 'FileCache');


/** Caching expiration times fpr various expensive objects
 * -----------------------------------------------------------------------------
 */

// Root objects like product-categories tree
define('CACHE_ROOT_TTL', 28800);        // 8 hours

// Product Category
define('CACHE_CATEGORY_TTL', 18000);    // 5 hours

// Product
define('CACHE_PRODUCT_TTL', 3600);      // 1 hour




// CONNECTIONS ...

define('FILECACHE_PATH', APP_ROOT.'/../storage/cache/');     // if CACHE_DRIVER is set to 'FileCache'

define('MEDIA_STORAGE_ROOT', APP_ROOT.'/../storage/uploads/');    // Media files root directory

# define('REDIS_HOST', '127.0.0.1');              // if CACHE_DRIVER is set to 'RedisCache'

# define('MEMCAHCED_SERVER', '127.0.0.1');        // if CACHE_DRIVER is set to 'MemCached'



/** SECURITY SETTINGS ///////////////////////////////////////////////////////////
 * -----------------------------------------------------------------------------
 * 
 * Cross Site Request Forgery
 * ---
 * Enables a CSRF cookie token to be set. When set to TRUE, token will be
 * checked on a submitted form. If you are accepting user data, it is strongly
 * recommended CSRF protection be enabled.
 * -----------------------------------------------------------------------------
 */

define('CSRF_PROTCTION', false);

define('CSRF_TOKEN_NAME', 'csrf_test_name');        // token name

define('CSRF_COOKIE_NAME', 'csrf_cookie_name');     // cookie name

define('CSRF_EXPIRE', 7200);            // The number in seconds the token should expire.

define('CSRF_REGENERATE', TRUE);        // Regenerate token on every submission

define('CSRF_EXCLUDE_URIS', array());   // Array of URIs which ignore CSRF checks




/** CREDENTIALS
 * -----------------------------------------------------------------------------
 */

/** SERVICE PARAMETRES
 * -----------------------------------------------------------------------------
 * 
 * Connection parametres and credentials for accssing services 
 * needed by the application; Such services may be..
 * 
 * - RDBMS
 *   -- MySQL
 *   -- PotgresSQL
 * 
 * - Caching services
 *   -- Redis
 *   -- MemCached
 * 
 * Edit only the constants needed by the application;
 * Comment those you do not need;
 * 
 * /////////////////////////////////////////////////////////////////////////////
 */

/** DATABASE CONNECTION PARAMETRES
 * -----------------------------------------------------------------------------
 * Production and staging environments may use different databases.
 * 
 * A safe practice is to keep credentials outside plain files like this one
 * in environmental variable or other secret file etc.
 * 
 * Uncomment/enable each group of definitions suits your case to define
 * the credentials needed for accessing the database
 */

/** This is a SAFE method (define credentials as OS environmental variables)
 * -----------------------------------------------------------------------------
 */
# define('DB_NAME', getenv('DB_NAME'));     // database name
# 
# define('DB_USER', getenv('DB_USER'));     // database user-name
# 
# define('DB_PASS', getenv('DB_PASS'));     // user's pass
# 
# define('PDO_HOST', getenv('PDO_HOST'));   // database host (connection string)


/** This is another SAFE method (keep credentials in an .env file)
 * -----------------------------------------------------------------------------
 */

define('DB_NAME', $ini['DB_NAME']);
 
define('DB_USER', $ini['DB_USER']);
 
define('DB_PASS', $ini['DB_PASS']);
 
define('PDO_HOST', $ini['PDO_HOST']);
 
 
 /** This is just good enough
  * -----------------------------------------------------------------------------
  */
 
 # if (!PRODUCTION) {    // == Deployed on staging
 #
 #   // STAGING SETTINGS:
 #    
 #   define('DB_NAME', 'dev_db_name');
 #
 #   define('DB_USER', 'devUserName');
 #
 #   define('DB_PASS', getenv('DBPASSWORD'));
 #
 #   // PDO_HOST can be a hostname/port combination -or- a unix socket
 #   // ...examples:
 #   // define('PDO_HOST', 'host=/localhost')    ## hostname case
 #   // define('PDO_HOST', 'host=/localhost;port=3456')    ## hostname/port case
 #   // define('PDO_HOST', 'unix_socket=/sql/ex123:europe:some-db');   ## unix socket
 #   define('PDO_HOST', 'unix_socket=/cloudsql/name-123456:europe-west4:name-db-eu');
 #
 # } else {        // == Deployed on production
 #
 #    // PRODUCTION SETTINGS:
 #
 #    define('DB_NAME', 'your_db_name');
 #    define('DB_USER', 'dbusername');
 #    define('DB_PASS', getenv('DBPASSWORD'));
 #    define('PDO_HOST', 'unix_socket=/cloudsql/name-123456:europe-west4:name-db-eu');
 #
 #  }
 
define('DB_TIMEZONE', "SET time_zone = 'Europe/Athens'");
 
 /** NOTE:
  * Both Redis and Memcached configurations are given as a template to work on;
  * In most cases the default values should do the job -- of course you need to
  * read the README file (check the project's root);
  * As these caching services are not fully tested you may need to ochestrate
  * the services in detail or edit the connection strings into the core classes
  * (hosted under the '/core/classes/cacher' folder)
  */
 
 
 /** REDIS SERVICE
  * -----------------------------------------------------------------------------
  * Most of the times Redis is running on 'localhost' (host = '127.0.0.1')
  * When implemented via anom's docker-composer (redis via bridge) then you need
  * do declare the hostname as 'redis'
  */
 #
 # if (!defined('REDIS_HOST'))     define('REDIS_HOST', 'redis');
 # 
 # if (!defined('REDIS_PORT'))     define('REDIS_PORT', 6379);
 # 
 # if (!defined('REDIS_PASS'))     define('REDIS_PASS', null);
 
 
 /** MEMCACHED
  * -----------------------------------------------------------------------------
  * Memcached looks very much like Redis (plus, both are serving from RAM)
  * Usualy Memcashed is running localy so host is 'localhost' ('127.0.0.1')
  * If you use the framework's docker-composer implementation then
  * the hostname is 'anomemcached'
  */
 #
 #if (!defined('MEMCACHE_HOST'))  define('MEMCACHE_HOST', 'anomemcached');