/**
* Loads environment variables from the .env file in the current working directory (getcwd), and puts them in a
* Config container.
*
* @return Config
*/
public static function GetConfig()
{
/*
* Load environment variables (only if we have a .env file)
*/
$envFilename = ".env";
$envDir = getcwd();
$envPath = "{$envDir}/{$envFilename}";
if (file_exists($envPath)) {
\Dotenv::load($envDir, $envFilename);
}
/*
* Make sure required environment variables are set
*/
\Dotenv::required(array("PAYPAL_CLIENT_ID", "PAYPAL_CLIENT_SECRET", "PAYPAL_ENDPOINT_MODE", "PAYPAL_EXPERIENCE_CLI_PROFILES_DIR"));
/*
* Create a config object and return it
*/
$config = new Config(getenv("PAYPAL_CLIENT_ID"), getenv("PAYPAL_CLIENT_SECRET"), getenv("PAYPAL_ENDPOINT_MODE"), getenv("PAYPAL_EXPERIENCE_CLI_PROFILES_DIR"), getenv("PAYPAL_ENABLE_LOG"), getenv("PAYPAL_LOG_FILENAME"));
// make sure the profiles directory is valid
if (!$config->GetProfilesDirAbsolute()) {
die("ERROR / Could not find profiles directory.\n");
}
return $config;
}
public function __construct($path, $file = 'config.php')
{
\Dotenv::load($path);
if (file_exists($path . $file)) {
$this->config = (include $path . $file);
}
}
public function setUp()
{
\Dotenv::load(__DIR__ . '/../');
$app = new \Laravel\Lumen\Application(realpath(__DIR__ . '/../'));
$app->withFacades();
$this->model = 'QueryParser\\Tests\\BaseModel';
}
public function testDotEnvWithConfig()
{
Dotenv::load(__DIR__ . '/_files/');
$config = new Config(__DIR__ . '/_files/', 'dotenv.php');
$this->assertEquals(getenv('MYSQL_USER'), $config->mysql['user']);
$this->assertEquals(getenv('MYSQL_HOST'), $config->mysql['host']);
$this->assertEquals(getenv('CUSTOM_BAR'), $config->custom['bar']);
}
/**
* Creates the application.
*
* @return \Illuminate\Foundation\Application
*/
public function createApplication()
{
$app = (require __DIR__ . '/../bootstrap/app.php');
if (file_exists(dirname(__DIR__) . '/.env.test')) {
Dotenv::load(dirname(__DIR__), '.env.test');
}
$app->make(Illuminate\Contracts\Console\Kernel::class)->bootstrap();
return $app;
}
function testGetOrder()
{
$dotenv = new Dotenv();
$root = dirname(dirname(__FILE__));
$dotenv->load($root);
$dotenv->required(['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'APPLICATION_NAME', 'APPLICATION_VERSION']);
$serviceUrl = "https://mws.amazonservices.com/Orders/2013-09-01";
$config = array('ServiceURL' => $serviceUrl, 'ProxyHost' => null, 'ProxyPort' => -1, 'ProxyUsername' => null, 'ProxyPassword' => null, 'MaxErrorRetry' => 3);
$service = new \Amazon\MWS\Orders\Orders_Client(getenv("AWS_ACCESS_KEY_ID"), getenv("AWS_SECRET_ACCESS_KEY"), getenv("APPLICATION_NAME"), getenv("APPLICATION_VERSION"), $config);
/************************************************************************
* Uncomment to try out Mock Service that simulates MarketplaceWebServiceOrders
* responses without calling MarketplaceWebServiceOrders service.
*
* Responses are loaded from local XML files. You can tweak XML files to
* experiment with various outputs during development
*
* XML files available under MarketplaceWebServiceOrders/Mock tree
*
***********************************************************************/
// $service = new MarketplaceWebServiceOrders_Mock();
/************************************************************************
* Setup request parameters and uncomment invoke to try out
* sample for Get Order Action
***********************************************************************/
// @TODO: set request. Action can be passed as Orders_Model_GetOrder
$request = new \Amazon\MWS\Orders\Model\Orders_Model_GetOrderRequest(['AmazonOrderId' => '114-9172390-8828251', 'SellerId' => getenv("SELLER_ID")]);
// $request->setSellerId(getenv("MERCHANT_ID"));
// $request->setAmazonOrderId('114-9172390-8828251');
// object or array of parameters
/**
* Get Get Order Action Sample
* Gets competitive pricing and related information for a product identified by
* the MarketplaceId and ASIN.
*
* @param MarketplaceWebServiceOrders_Interface $service instance of MarketplaceWebServiceOrders_Interface
* @param mixed $request Orders_Model_GetOrder or array of parameters
*/
try {
$response = $service->GetOrder($request);
echo "Service Response\n";
echo "=============================================================================\n";
$dom = new \DOMDocument();
$dom->loadXML($response->toXML());
$dom->preserveWhiteSpace = false;
$dom->formatOutput = true;
echo $dom->saveXML();
echo "ResponseHeaderMetadata: " . $response->getResponseHeaderMetadata() . "\n";
} catch (MarketplaceWebServiceOrders_Exception $ex) {
echo "Caught Exception: " . $ex->getMessage() . "\n";
echo "Response Status Code: " . $ex->getStatusCode() . "\n";
echo "Error Code: " . $ex->getErrorCode() . "\n";
echo "Error Type: " . $ex->getErrorType() . "\n";
echo "Request ID: " . $ex->getRequestId() . "\n";
echo "XML: " . $ex->getXML() . "\n";
echo "ResponseHeaderMetadata: " . $ex->getResponseHeaderMetadata() . "\n";
}
}
/**
* PHPUnit Setup Function
*
*/
public function setUp()
{
if (file_exists(__DIR__ . '/../.env')) {
Dotenv::load(__DIR__ . '/../');
}
$this->client = new \Cjhbtn\Periscopr\Client();
if ($this->requiresAuth && !$this->setUpAuth()) {
$this->markTestSkipped("Authenticated test skipped - Unable to authenticate with Periscope API");
}
}
/**
* loading envs
*/
private static function _loadEnv()
{
if (getenv('DB_NAME') != null && getenv('DB_NAME') != "") {
return;
}
if (defined('ABSPATH')) {
\Dotenv::load(ABSPATH);
} else {
\Dotenv::load(getenv('HOME'));
}
}
/**
* Register the config provider and load the default configs
*
* @param Application $app
*
* @return void
*/
protected function registerConfigs(Application $app)
{
$base = $app['path.base'];
if (file_exists("{$base}/.env")) {
$dotenv = \Dotenv::load($base);
}
$preloadedVars = ['env.HTTP_CACHE_ENABLED' => $app['http_cache.enabled'], 'env.DEBUG' => $app['debug'], 'env.AUTO_REBUILD' => $app['auto_rebuild'], 'path.base' => $base];
$envVars = $_ENV;
foreach ($envVars as $k => $v) {
$preloadedVars["env.{$k}"] = $v;
}
$app->register(new \Igorw\Silex\ConfigServiceProvider("{$base}/config/site.yaml", $preloadedVars));
}
/**
* @return string
*
* @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
*/
public function getEnvironment()
{
$fileSystem = new Filesystem();
$environment = '';
$environmentPath = app()->getBasePath() . '/.env';
if ($fileSystem->isFile($environmentPath)) {
$environment = trim($fileSystem->get($environmentPath));
$envFile = app()->getBasePath() . '/.' . $environment;
if ($fileSystem->isFile($envFile . '.env')) {
$dotEnv = new Dotenv(app()->getBasePath() . '/', '.' . $environment . '.env');
$dotEnv->load();
}
}
return $environment;
}
function boot($rootDir, $urlDepth = 0, callable $onStartUp = null)
{
$rootDir = normalizePath($rootDir);
// Initialize some settings from environment variables
$dotenv = new Dotenv("{$rootDir}/.env");
try {
$dotenv->load();
} catch (ConfigException $e) {
echo $e->getMessage();
return 1;
}
// Load the kernel's configuration.
/** @var KernelSettings $kernelSettings */
$kernelSettings = $this->kernelSettings = $this->injector->share(KernelSettings::class, 'app')->make(KernelSettings::class);
$kernelSettings->isWebBased = true;
$kernelSettings->setApplicationRoot($rootDir, $urlDepth);
// Setup debugging (must be done before instantiating the kernel, but after instantiating its settings).
$this->setupDebugging($rootDir);
// Boot up the framework's kernel.
$this->injector->execute([KernelModule::class, 'register']);
// Boot up the framework's subsytems and the application's modules.
/** @var KernelInterface $kernel */
$kernel = $this->injector->make(KernelInterface::class);
if ($onStartUp) {
$onStartUp($kernel);
}
// Boot up all modules.
try {
$kernel->boot();
} catch (ConfigException $e) {
$NL = "<br>\n";
echo $e->getMessage() . $NL . $NL;
if ($e->getCode() == -1) {
echo sprintf('Possile error causes:%2$s%2$s- the class name may be misspelled,%2$s- the class may no longer exist,%2$s- module %1$s may be missing or it may be corrupted.%2$s%2$s', str_match($e->getMessage(), '/from module (\\S+)/')[1], $NL);
}
$path = "{$kernelSettings->storagePath}/" . ModulesRegistry::REGISTRY_FILE;
if (file_exists($path)) {
echo "Tip: one possible solution is to remove the '{$path}' file and run 'workman' to rebuild the module registry.";
}
}
// Finalize.
if ($kernel->devEnv()) {
$this->setDebugPathsMap($this->injector->make(ModulesRegistry::class));
}
return $kernel->getExitCode();
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{
/*
This is necessary for frontend servers to perform cleanup
after running their own unit tests
*/
if ($request->has('test_key')) {
if (file_exists(base_path() . '/.env.testing')) {
\Dotenv::load(base_path(), '.env.testing');
}
$inputKey = $request->input('test_key', str_random(32));
$envKey = env('TEST_KEY', str_random(32));
if ($inputKey != $envKey) {
throw new \FatalErrorException('Get outta here.');
}
}
return $next($request);
}
public function envLoad($path = null)
{
if (empty($path)) {
$path = base_path();
}
$dotenv = \Dotenv::load($path);
$this->gitHost = str_replace("\"", "", getenv('GITLAB_HOST'));
$this->gitToken = str_replace("\"", "", getenv('GITLAB_TOKEN'));
$this->hookUrl = str_replace("\"", "", getenv('HOOK_URL'));
$debug = str_replace("\"", "", getenv('APP_DEBUG'));
if (strtolower($debug) === 'true') {
$this->debug = true;
}
$verbose = str_replace("\"", "", getenv('APP_VERBOSE'));
if (strtolower($verbose) === 'true') {
$this->verbose = true;
}
}
/**
* @inheritdoc
*/
public function register(Container $app)
{
$app['env.default_options'] = ['prefix' => 'SILEX', 'use_dotenv' => function () {
return true;
}, 'dotenv_dir' => __DIR__ . '/../../../..', 'var_config' => []];
$app['env.load'] = function ($app) {
if (!isset($app['env.options'])) {
$app['env.options'] = [];
}
$app['env.options'] = array_merge($app['env.default_options'], $app['env.options']);
$this->addEnvVarsToApp($app);
if ($app['env.options']['use_dotenv']()) {
\Dotenv::load($app['env.options']['dotenv_dir']);
//again pls
$this->addEnvVarsToApp($app);
}
$this->applyConfigs($app, $app['env.options']['var_config']);
};
}
public function setUp()
{
parent::setUp();
// Load Dotenv
Dotenv::load(__DIR__);
// Set Laravel configuration parameters
Config::set('elvis.api_endpoint_uri', getenv('ELVIS_API_ENDPOINT_URI'));
Config::set('elvis.username', getenv('ELVIS_USERNAME'));
Config::set('elvis.password', getenv('ELVIS_PASSWORD'));
// Get session Id to user in the queries
$this->sessionId = Elvis::login();
// Upload a randon file to Elvis for various tests
$temporaryFilename = tempnam("/tmp", "ElvisTest");
// Create a file and store asset id
$create = Elvis::create($this->sessionId, $temporaryFilename);
$this->assetId = $create->id;
// Remove temporary file
unlink($temporaryFilename);
}
/**
* Initialize main environment vars and load Yii 2
*/
public static function init()
{
require '/var/www/vendor/autoload.php';
// Load .env file if enabled and if it exists
if (getenv('ENABLE_ENV_FILE') && file_exists(self::APP_DIR . '.env')) {
Dotenv::load(self::APP_DIR);
}
// Define main environment variables
if (isset($_ENV['YII_DEBUG'])) {
define('YII_DEBUG', (bool) $_ENV['YII_DEBUG']);
if (YII_DEBUG) {
error_reporting(E_ALL);
}
}
if (isset($_ENV['YII_ENV'])) {
define('YII_ENV', $_ENV['YII_ENV']);
}
define('YII_ENV_TEST', defined('YII_ENV') && YII_ENV === 'test');
require self::VENDOR_DIR . 'yiisoft/yii2/Yii.php';
}
<?php
// Path to directory that contains the entire app
define('ROOT_DIR', realpath(__DIR__ . '/..'));
// Loads all the environment variables from ROOT_DIR/.env
Dotenv::load(ROOT_DIR);
// Set the default timezone <http://php.net/manual/en/timezones.php>
NConfig::setTimezone(getenv('TIMEZONE'));
// Legacy defines. Environment variables should be used moving forward
define('APP_NAME', 'nterchange');
define('APP_DIR', APP_NAME);
define('CACHE_DIR', realpath(ROOT_DIR . '/var'));
define('EXTERNAL_CACHE', false);
// no trailing slash
define('ASSET_DIR', realpath(ROOT_DIR . '/app'));
define('DOCUMENT_ROOT', ROOT_DIR . '/public_html');
define('ENVIRONMENT', getenv('ENVIRONMENT'));
define('SECURE_SITE', false);
define('ADMIN_SITE', APP_DIR . '/');
define('ADMIN_URL', false);
// this is false by default, or the full domain of the admin (http://admin.example.com/)
define('SITE_DRAFTS', true);
define('SITE_PERMISSIONS', true);
define('SITE_WORKFLOW', false);
define('SITE_PRINTABLE', true);
define('SITE_AUDIT_TRAIL', true);
define('SITE_TIME_ZONE', 'MST7MDT');
// string id of the site's time zone (eg. MST7MDT) - this is case-sensitive!
define('ERROR_EMAIL', '*****@*****.**');
define('CURRENT_SITE', (isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT']) == 443 ? 'secure' : 'public');
define('SITE_NAME', getenv('SITE_NAME'));
<?php
define('APP_START', microtime(true));
define('APP_PATH', realpath(__DIR__ . '/..') . '/');
/*
|--------------------------------------------------------------------------
| Register The Composer Auto Loader
|--------------------------------------------------------------------------
|
| Composer provides a convenient, automatically generated class loader
| for our application. We just need to utilize it! We'll require it
| into the script here so that we do not have to worry about the
| loading of any our classes "manually". Feels great to relax.
|
*/
require APP_PATH . 'vendor/autoload.php';
try {
Dotenv::load(APP_PATH);
} catch (InvalidArgumentException $e) {
//
}
<?php
$root_dir = dirname(__DIR__);
$webroot_dir = $root_dir . '/web';
/**
* Use Dotenv to set required environment variables and load .env file in root
*/
if (file_exists($root_dir . '/.env')) {
Dotenv::load($root_dir);
}
Dotenv::required(array('DB_NAME', 'DB_USER', 'DB_PASSWORD', 'WP_HOME', 'WP_SITEURL'));
/**
* Set up our global environment constant and load its config first
* Default: development
*/
define('WP_ENV', getenv('WP_ENV') ? getenv('WP_ENV') : 'development');
$env_config = dirname(__FILE__) . '/environments/' . WP_ENV . '.php';
if (file_exists($env_config)) {
require_once $env_config;
}
/**
* Custom Content Directory
*/
define('CONTENT_DIR', '/app');
define('WP_CONTENT_DIR', $webroot_dir . CONTENT_DIR);
define('WP_CONTENT_URL', WP_HOME . CONTENT_DIR);
/**
* DB settings
*/
define('DB_CHARSET', 'utf8');
define('DB_COLLATE', '');
/**
* Load the variables using the .env handling
*
* @param string $envPath Path to the .env file
* @return array|boolean Array of data if found, false if load fails
*/
protected static function loadDotEnv($envPath)
{
try {
\Dotenv::load($envPath);
$config = array('username' => $_SERVER['DB_USER'], 'password' => $_SERVER['DB_PASS'], 'name' => $_SERVER['DB_NAME'], 'type' => isset($_SERVER['DB_TYPE']) ? $_SERVER['DB_TYPE'] : 'mysql', 'host' => $_SERVER['DB_HOST']);
if (isset($_SERVER['DB_PREFIX'])) {
$config['prefix'] = $_SERVER['DB_PREFIX'];
}
return $config;
} catch (\Exception $e) {
return false;
}
}
// FALSE.DIRECTORY_SEPARATOR = '/' .. mayhem insues.
if (realpath($plugins)) {
define('PLUGINPATH', realpath($plugins) . DIRECTORY_SEPARATOR);
}
// Define the absolute paths for configured directories
define('APPPATH', realpath($application) . DIRECTORY_SEPARATOR);
define('MODPATH', realpath($modules) . DIRECTORY_SEPARATOR);
define('SYSPATH', realpath($system) . DIRECTORY_SEPARATOR);
define('VENPATH', realpath($vendor) . DIRECTORY_SEPARATOR);
// Clean up the configuration vars
unset($application, $modules, $system);
/**
* Define the start time of the application, used for profiling.
*/
if (!defined('KOHANA_START_TIME')) {
define('KOHANA_START_TIME', microtime(TRUE));
}
/**
* Define the memory usage at the start of the application, used for profiling.
*/
if (!defined('KOHANA_START_MEMORY')) {
define('KOHANA_START_MEMORY', memory_get_usage());
}
// Ushahidi: load transitional code
require APPPATH . '../src/Init' . EXT;
// Load dotenv
if (is_file(APPPATH . '../.env')) {
Dotenv::load(APPPATH . '../');
}
// Bootstrap the application
require APPPATH . 'bootstrap' . EXT;
<?php
date_default_timezone_set('UTC');
// If there is an env file, then load it, so that the configs can use them
if (build_path([__DIR__, '..', '.env'], true)) {
Dotenv::load(build_path([__DIR__, '..']));
}
// Path to config file
$config_file = build_path([__DIR__, '..', 'config', 'generator.php'], true);
// Read the config file if there is one, otherwise set to empty array
$config = (array) ($config_file ? require $config_file : []);
// Return a new generator
return new Spinen\ConnectWise\Generator\Generator($config);
<?php
require 'vendor/autoload.php';
function out($message)
{
echo "\n{$message}\n";
}
Dotenv::load(__DIR__);
$backup_directory_today = "/backup/" . date('Y-m-d');
mkdir($backup_directory_today);
$issue_database_filename = $backup_directory_today . "/issue_database.sql.gz";
// Archive Lendia database
$db_host = getenv('DB_HOST');
$db_database = getenv('DB_DATABASE');
$db_user = getenv('DB_USERNAME');
$db_pass = getenv('DB_PASSWORD');
$dump_command = "mysqldump --host={$db_host} --user={$db_user} --password={$db_pass} {$db_database} | gzip > {$issue_database_filename}";
out("Running Issue database backup");
out($dump_command);
exec($dump_command);
<?php
ini_set('memory_limit', '2048M');
use Alchemy\Zippy\Zippy;
use Aws\S3\S3Client;
use League\Flysystem\AwsS3v2\AwsS3Adapter;
use League\Flysystem\Filesystem;
Dotenv::load(__DIR__, '.env.deploy');
/**
* This is project's console commands configuration for Robo task runner.
*
* @see http://robo.li/
*/
class RoboFile extends \Robo\Tasks
{
/**
* Build task.
*
* @return bool
*/
public function build()
{
$this->say('Build task');
$envFile = __DIR__ . '/.env.dist';
if (!file_exists($envFile)) {
$this->yell(sprintf('The environment "%s" file does not exist!', $envFile));
return false;
}
$buildPath = $this->getBuildPath();
$filename = 'api_' . time() . '.zip';
$this->say("Creating archive {$filename} in {$buildPath}");
<?php
/*
|--------------------------------------------------------------------------
| Detect The Application Environment
|--------------------------------------------------------------------------
|
| Laravel takes a dead simple approach to your application environments
| so you can just specify a machine name for the host that matches a
| given environment, then we will automatically detect it for you.
|
*/
$env = $app->detectEnvironment(function () {
$environmentPath = __DIR__ . '/../.env';
$setEnv = trim(file_get_contents($environmentPath));
if (file_exists($environmentPath)) {
putenv("APP_ENV={$setEnv}");
if (getenv('APP_ENV') && file_exists(__DIR__ . '/../.' . getenv('APP_ENV') . '.env')) {
Dotenv::load(__DIR__ . '/../', '.' . getenv('APP_ENV') . '.env');
}
}
});
function import_db()
{
// Name of the file
$filename = 'application/database/dump.sql';
Dotenv::load(__DIR__);
// MySQL host
$mysql_host = getenv('DB_HOST');
// MySQL username
$mysql_username = getenv('DB_USERNAME');
// MySQL password
$mysql_password = getenv('DB_PASSWORD');
// Database name
$mysql_database = getenv('DB_DATABASE');
// Connect to MySQL server
$connection = mysqli_connect($mysql_host, $mysql_username, $mysql_password) or die('Error connecting to MySQL server: ' . mysql_error());
// Select database
if (!mysqli_select_db($connection, $mysql_database)) {
die('Error selecting MySQL database: ' . mysql_error());
}
// Temporary variable, used to store current query
$templine = '';
// Read in entire file
$lines = file($filename);
// Loop through each line
foreach ($lines as $line) {
// Skip it if it's a comment
if (substr($line, 0, 2) == '--' || $line == '') {
continue;
}
// Add this line to the current segment
$templine .= $line;
// If it has a semicolon at the end, it's the end of the query
if (substr(trim($line), -1, 1) == ';') {
// Perform the query
mysqli_query($connection, $templine) or print 'Error performing query \'<strong>' . $templine . '\': ' . mysqli_error() . '<br /><br />';
// Reset temp variable to empty
$templine = '';
}
}
echo '<span class="success">Successfully Imported Database (<i class="fa fa-check-square-o"></i> PASS)</span>';
new_line();
}
<?php
require dirname(__FILE__) . "/../vendor/autoload.php";
Dotenv::load(__DIR__ . "/../");
use SoftLayer\Messaging;
define('QUEUE_ACCOUNT', getenv('QUEUE_ACCOUNT'));
define('QUEUE_USERNAME', getenv('QUEUE_USERNAME'));
define('QUEUE_API_KEY', getenv('QUEUE_API_KEY'));
define('WAIT', 5);
abstract class BaseTest extends PHPUnit_Framework_TestCase
{
public static $messaging;
public static $queues = array();
public static $topics = array();
public static function setUpBeforeClass()
{
self::$messaging = new Messaging();
self::$messaging->authenticate(QUEUE_ACCOUNT, QUEUE_USERNAME, QUEUE_API_KEY);
self::$queues = array();
self::$topics = array();
}
public static function queueName()
{
array_unshift(self::$queues, "testQueue_" . rand(0, 99999));
return self::$queues[0];
}
public static function topicName()
{
array_unshift(self::$topics, "testTopic_" . rand(0, 99999));
return self::$topics[0];
}
/**
* The base configurations of the WordPress.
*
* This file has the following configurations: MySQL settings, Table Prefix,
* Secret Keys, and ABSPATH. You can find more information by visiting
* {@link https://codex.wordpress.org/Editing_wp-config.php Editing wp-config.php}
* Codex page. You can get the MySQL settings from your web host.
*
* This file is used by the wp-config.php creation script during the
* installation. You don't have to use the web site, you can just copy this file
* to "wp-config.php" and fill in the values.
*
* @package WordPress
*/
require_once dirname(__DIR__) . '/vendor/autoload.php';
Dotenv::load(dirname(__DIR__));
Dotenv::required(['ENVIRONMENT', 'DB_DATABASE', 'DB_USERNAME', 'DB_PASSWORD', 'DB_HOST', 'DB_CHARSET', 'DB_PREFIX']);
// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define('DB_NAME', getenv('DB_DATABASE'));
/** MySQL database username */
define('DB_USER', getenv('DB_USERNAME'));
/** MySQL database password */
define('DB_PASSWORD', getenv('DB_PASSWORD'));
/** MySQL hostname */
define('DB_HOST', getenv('DB_HOST'));
/** Database Charset to use in creating database tables. */
define('DB_CHARSET', getenv('DB_CHARSET'));
/** The Database Collate type. Don't change this if in doubt. */
define('DB_COLLATE', '');
/**#@+
<?php require_once __DIR__ . '/../vendor/autoload.php'; Dotenv::load(__DIR__ . '/../'); /* |-------------------------------------------------------------------------- | Create The Application |-------------------------------------------------------------------------- | | Here we will load the environment and create the application instance | that serves as the central piece of this framework. We'll use this | application as an "IoC" container and router for this framework. | */ $app = new Laravel\Lumen\Application(realpath(__DIR__ . '/../')); $app->withFacades(); $app->withEloquent(); /* |-------------------------------------------------------------------------- | Register Container Bindings |-------------------------------------------------------------------------- | | Now we will register a few bindings in the service container. We will | register the exception handler and the console kernel. You may add | your own bindings here if you like or you can make another file. | */ $app->singleton(Illuminate\Contracts\Debug\ExceptionHandler::class, App\Exceptions\Handler::class); $app->singleton(Illuminate\Contracts\Console\Kernel::class, App\Console\Kernel::class); /* |--------------------------------------------------------------------------
*/
App::error(function (Exception $exception, $code) {
Log::error($exception);
});
/*
|--------------------------------------------------------------------------
| Maintenance Mode Handler
|--------------------------------------------------------------------------
|
| The "down" Artisan command gives you the ability to put an application
| into maintenance mode. Here, you will define what is displayed back
| to the user if maintenance mode is in effect for the application.
|
*/
App::down(function () {
return Response::make("Be right back!", 503);
});
/*
|--------------------------------------------------------------------------
| Require The Filters File
|--------------------------------------------------------------------------
|
| Next we will load the filters file for the application. This gives us
| a nice separate location to store our route and application filter
| definitions instead of putting them all in the main routes file.
|
*/
require app_path() . '/filters.php';
if (is_file(base_path() . '/.env')) {
Dotenv::load(base_path());
}
