You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by nd...@apache.org on 2015/05/01 23:33:07 UTC
[20/57] [partial] airavata-php-gateway git commit: AIRAVATA 1632 +
Job Description for Admin Dashboard
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Connectors/SQLiteConnector.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Connectors/SQLiteConnector.php b/vendor/laravel/framework/src/Illuminate/Database/Connectors/SQLiteConnector.php
new file mode 100755
index 0000000..596ef28
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Connectors/SQLiteConnector.php
@@ -0,0 +1,38 @@
+<?php namespace Illuminate\Database\Connectors;
+
+class SQLiteConnector extends Connector implements ConnectorInterface {
+
+ /**
+ * Establish a database connection.
+ *
+ * @param array $config
+ * @return \PDO
+ *
+ * @throws \InvalidArgumentException
+ */
+ public function connect(array $config)
+ {
+ $options = $this->getOptions($config);
+
+ // SQLite supports "in-memory" databases that only last as long as the owning
+ // connection does. These are useful for tests or for short lifetime store
+ // querying. In-memory databases may only have a single open connection.
+ if ($config['database'] == ':memory:')
+ {
+ return $this->createConnection('sqlite::memory:', $config, $options);
+ }
+
+ $path = realpath($config['database']);
+
+ // Here we'll verify that the SQLite database exists before going any further
+ // as the developer probably wants to know if the database exists and this
+ // SQLite driver will not throw any exception if it does not by default.
+ if ($path === false)
+ {
+ throw new \InvalidArgumentException("Database does not exist.");
+ }
+
+ return $this->createConnection("sqlite:{$path}", $config, $options);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Connectors/SqlServerConnector.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Connectors/SqlServerConnector.php b/vendor/laravel/framework/src/Illuminate/Database/Connectors/SqlServerConnector.php
new file mode 100755
index 0000000..d1d9a53
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Connectors/SqlServerConnector.php
@@ -0,0 +1,69 @@
+<?php namespace Illuminate\Database\Connectors;
+
+use PDO;
+
+class SqlServerConnector extends Connector implements ConnectorInterface {
+
+ /**
+ * The PDO connection options.
+ *
+ * @var array
+ */
+ protected $options = array(
+ PDO::ATTR_CASE => PDO::CASE_NATURAL,
+ PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+ PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
+ PDO::ATTR_STRINGIFY_FETCHES => false,
+ );
+
+ /**
+ * Establish a database connection.
+ *
+ * @param array $config
+ * @return \PDO
+ */
+ public function connect(array $config)
+ {
+ $options = $this->getOptions($config);
+
+ return $this->createConnection($this->getDsn($config), $config, $options);
+ }
+
+ /**
+ * Create a DSN string from a configuration.
+ *
+ * @param array $config
+ * @return string
+ */
+ protected function getDsn(array $config)
+ {
+ extract($config);
+
+ // First we will create the basic DSN setup as well as the port if it is in
+ // in the configuration options. This will give us the basic DSN we will
+ // need to establish the PDO connections and return them back for use.
+ if (in_array('dblib', $this->getAvailableDrivers()))
+ {
+ $port = isset($config['port']) ? ':'.$port : '';
+
+ return "dblib:host={$host}{$port};dbname={$database}";
+ }
+
+ $port = isset($config['port']) ? ','.$port : '';
+
+ $dbName = $database != '' ? ";Database={$database}" : '';
+
+ return "sqlsrv:Server={$host}{$port}{$dbName}";
+ }
+
+ /**
+ * Get the available PDO drivers.
+ *
+ * @return array
+ */
+ protected function getAvailableDrivers()
+ {
+ return PDO::getAvailableDrivers();
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/BaseCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/BaseCommand.php b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/BaseCommand.php
new file mode 100755
index 0000000..7dfef57
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/BaseCommand.php
@@ -0,0 +1,49 @@
+<?php namespace Illuminate\Database\Console\Migrations;
+
+use Illuminate\Console\Command;
+
+class BaseCommand extends Command {
+
+ /**
+ * Get the path to the migration directory.
+ *
+ * @return string
+ */
+ protected function getMigrationPath()
+ {
+ $path = $this->input->getOption('path');
+
+ // First, we will check to see if a path option has been defined. If it has
+ // we will use the path relative to the root of this installation folder
+ // so that migrations may be run for any path within the applications.
+ if ( ! is_null($path))
+ {
+ return $this->laravel['path.base'].'/'.$path;
+ }
+
+ $package = $this->input->getOption('package');
+
+ // If the package is in the list of migration paths we received we will put
+ // the migrations in that path. Otherwise, we will assume the package is
+ // is in the package directories and will place them in that location.
+ if ( ! is_null($package))
+ {
+ return $this->packagePath.'/'.$package.'/src/migrations';
+ }
+
+ $bench = $this->input->getOption('bench');
+
+ // Finally we will check for the workbench option, which is a shortcut into
+ // specifying the full path for a "workbench" project. Workbenches allow
+ // developers to develop packages along side a "standard" app install.
+ if ( ! is_null($bench))
+ {
+ $path = "/workbench/{$bench}/src/migrations";
+
+ return $this->laravel['path.base'].$path;
+ }
+
+ return $this->laravel['path'].'/database/migrations';
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/InstallCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/InstallCommand.php b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/InstallCommand.php
new file mode 100755
index 0000000..d89c0c4
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/InstallCommand.php
@@ -0,0 +1,69 @@
+<?php namespace Illuminate\Database\Console\Migrations;
+
+use Illuminate\Console\Command;
+use Symfony\Component\Console\Input\InputOption;
+use Illuminate\Database\Migrations\MigrationRepositoryInterface;
+
+class InstallCommand extends Command {
+
+ /**
+ * The console command name.
+ *
+ * @var string
+ */
+ protected $name = 'migrate:install';
+
+ /**
+ * The console command description.
+ *
+ * @var string
+ */
+ protected $description = 'Create the migration repository';
+
+ /**
+ * The repository instance.
+ *
+ * @var \Illuminate\Database\Migrations\MigrationRepositoryInterface
+ */
+ protected $repository;
+
+ /**
+ * Create a new migration install command instance.
+ *
+ * @param \Illuminate\Database\Migrations\MigrationRepositoryInterface $repository
+ * @return void
+ */
+ public function __construct(MigrationRepositoryInterface $repository)
+ {
+ parent::__construct();
+
+ $this->repository = $repository;
+ }
+
+ /**
+ * Execute the console command.
+ *
+ * @return void
+ */
+ public function fire()
+ {
+ $this->repository->setSource($this->input->getOption('database'));
+
+ $this->repository->createRepository();
+
+ $this->info("Migration table created successfully.");
+ }
+
+ /**
+ * Get the console command options.
+ *
+ * @return array
+ */
+ protected function getOptions()
+ {
+ return array(
+ array('database', null, InputOption::VALUE_OPTIONAL, 'The database connection to use.'),
+ );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/MigrateCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/MigrateCommand.php b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/MigrateCommand.php
new file mode 100755
index 0000000..035192f
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/MigrateCommand.php
@@ -0,0 +1,130 @@
+<?php namespace Illuminate\Database\Console\Migrations;
+
+use Illuminate\Console\ConfirmableTrait;
+use Illuminate\Database\Migrations\Migrator;
+use Symfony\Component\Console\Input\InputOption;
+
+class MigrateCommand extends BaseCommand {
+
+ use ConfirmableTrait;
+
+ /**
+ * The console command name.
+ *
+ * @var string
+ */
+ protected $name = 'migrate';
+
+ /**
+ * The console command description.
+ *
+ * @var string
+ */
+ protected $description = 'Run the database migrations';
+
+ /**
+ * The migrator instance.
+ *
+ * @var \Illuminate\Database\Migrations\Migrator
+ */
+ protected $migrator;
+
+ /**
+ * The path to the packages directory (vendor).
+ */
+ protected $packagePath;
+
+ /**
+ * Create a new migration command instance.
+ *
+ * @param \Illuminate\Database\Migrations\Migrator $migrator
+ * @param string $packagePath
+ * @return void
+ */
+ public function __construct(Migrator $migrator, $packagePath)
+ {
+ parent::__construct();
+
+ $this->migrator = $migrator;
+ $this->packagePath = $packagePath;
+ }
+
+ /**
+ * Execute the console command.
+ *
+ * @return void
+ */
+ public function fire()
+ {
+ if ( ! $this->confirmToProceed()) return;
+
+ $this->prepareDatabase();
+
+ // The pretend option can be used for "simulating" the migration and grabbing
+ // the SQL queries that would fire if the migration were to be run against
+ // a database for real, which is helpful for double checking migrations.
+ $pretend = $this->input->getOption('pretend');
+
+ $path = $this->getMigrationPath();
+
+ $this->migrator->run($path, $pretend);
+
+ // Once the migrator has run we will grab the note output and send it out to
+ // the console screen, since the migrator itself functions without having
+ // any instances of the OutputInterface contract passed into the class.
+ foreach ($this->migrator->getNotes() as $note)
+ {
+ $this->output->writeln($note);
+ }
+
+ // Finally, if the "seed" option has been given, we will re-run the database
+ // seed task to re-populate the database, which is convenient when adding
+ // a migration and a seed at the same time, as it is only this command.
+ if ($this->input->getOption('seed'))
+ {
+ $this->call('db:seed', ['--force' => true]);
+ }
+ }
+
+ /**
+ * Prepare the migration database for running.
+ *
+ * @return void
+ */
+ protected function prepareDatabase()
+ {
+ $this->migrator->setConnection($this->input->getOption('database'));
+
+ if ( ! $this->migrator->repositoryExists())
+ {
+ $options = array('--database' => $this->input->getOption('database'));
+
+ $this->call('migrate:install', $options);
+ }
+ }
+
+ /**
+ * Get the console command options.
+ *
+ * @return array
+ */
+ protected function getOptions()
+ {
+ return array(
+ array('bench', null, InputOption::VALUE_OPTIONAL, 'The name of the workbench to migrate.', null),
+
+ array('database', null, InputOption::VALUE_OPTIONAL, 'The database connection to use.'),
+
+ array('force', null, InputOption::VALUE_NONE, 'Force the operation to run when in production.'),
+
+ array('path', null, InputOption::VALUE_OPTIONAL, 'The path to migration files.', null),
+
+ array('package', null, InputOption::VALUE_OPTIONAL, 'The package to migrate.', null),
+
+ array('pretend', null, InputOption::VALUE_NONE, 'Dump the SQL queries that would be run.'),
+
+ array('seed', null, InputOption::VALUE_NONE, 'Indicates if the seed task should be re-run.'),
+ );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/MigrateMakeCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/MigrateMakeCommand.php b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/MigrateMakeCommand.php
new file mode 100644
index 0000000..5fc6933
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/MigrateMakeCommand.php
@@ -0,0 +1,127 @@
+<?php namespace Illuminate\Database\Console\Migrations;
+
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Input\InputArgument;
+use Illuminate\Database\Migrations\MigrationCreator;
+
+class MigrateMakeCommand extends BaseCommand {
+
+ /**
+ * The console command name.
+ *
+ * @var string
+ */
+ protected $name = 'migrate:make';
+
+ /**
+ * The console command description.
+ *
+ * @var string
+ */
+ protected $description = 'Create a new migration file';
+
+ /**
+ * The migration creator instance.
+ *
+ * @var \Illuminate\Database\Migrations\MigrationCreator
+ */
+ protected $creator;
+
+ /**
+ * The path to the packages directory (vendor).
+ *
+ * @var string
+ */
+ protected $packagePath;
+
+ /**
+ * Create a new migration install command instance.
+ *
+ * @param \Illuminate\Database\Migrations\MigrationCreator $creator
+ * @param string $packagePath
+ * @return void
+ */
+ public function __construct(MigrationCreator $creator, $packagePath)
+ {
+ parent::__construct();
+
+ $this->creator = $creator;
+ $this->packagePath = $packagePath;
+ }
+
+ /**
+ * Execute the console command.
+ *
+ * @return void
+ */
+ public function fire()
+ {
+ // It's possible for the developer to specify the tables to modify in this
+ // schema operation. The developer may also specify if this table needs
+ // to be freshly created so we can create the appropriate migrations.
+ $name = $this->input->getArgument('name');
+
+ $table = $this->input->getOption('table');
+
+ $create = $this->input->getOption('create');
+
+ if ( ! $table && is_string($create)) $table = $create;
+
+ // Now we are ready to write the migration out to disk. Once we've written
+ // the migration out, we will dump-autoload for the entire framework to
+ // make sure that the migrations are registered by the class loaders.
+ $this->writeMigration($name, $table, $create);
+
+ $this->call('dump-autoload');
+ }
+
+ /**
+ * Write the migration file to disk.
+ *
+ * @param string $name
+ * @param string $table
+ * @param bool $create
+ * @return string
+ */
+ protected function writeMigration($name, $table, $create)
+ {
+ $path = $this->getMigrationPath();
+
+ $file = pathinfo($this->creator->create($name, $path, $table, $create), PATHINFO_FILENAME);
+
+ $this->line("<info>Created Migration:</info> $file");
+ }
+
+ /**
+ * Get the console command arguments.
+ *
+ * @return array
+ */
+ protected function getArguments()
+ {
+ return array(
+ array('name', InputArgument::REQUIRED, 'The name of the migration'),
+ );
+ }
+
+ /**
+ * Get the console command options.
+ *
+ * @return array
+ */
+ protected function getOptions()
+ {
+ return array(
+ array('bench', null, InputOption::VALUE_OPTIONAL, 'The workbench the migration belongs to.', null),
+
+ array('create', null, InputOption::VALUE_OPTIONAL, 'The table to be created.'),
+
+ array('package', null, InputOption::VALUE_OPTIONAL, 'The package the migration belongs to.', null),
+
+ array('path', null, InputOption::VALUE_OPTIONAL, 'Where to store the migration.', null),
+
+ array('table', null, InputOption::VALUE_OPTIONAL, 'The table to migrate.'),
+ );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/RefreshCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/RefreshCommand.php b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/RefreshCommand.php
new file mode 100755
index 0000000..2adc6e8
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/RefreshCommand.php
@@ -0,0 +1,96 @@
+<?php namespace Illuminate\Database\Console\Migrations;
+
+use Illuminate\Console\Command;
+use Illuminate\Console\ConfirmableTrait;
+use Symfony\Component\Console\Input\InputOption;
+
+class RefreshCommand extends Command {
+
+ use ConfirmableTrait;
+
+ /**
+ * The console command name.
+ *
+ * @var string
+ */
+ protected $name = 'migrate:refresh';
+
+ /**
+ * The console command description.
+ *
+ * @var string
+ */
+ protected $description = 'Reset and re-run all migrations';
+
+ /**
+ * Execute the console command.
+ *
+ * @return void
+ */
+ public function fire()
+ {
+ if ( ! $this->confirmToProceed()) return;
+
+ $database = $this->input->getOption('database');
+
+ $force = $this->input->getOption('force');
+
+ $this->call('migrate:reset', array(
+ '--database' => $database, '--force' => $force
+ ));
+
+ // The refresh command is essentially just a brief aggregate of a few other of
+ // the migration commands and just provides a convenient wrapper to execute
+ // them in succession. We'll also see if we need to re-seed the database.
+ $this->call('migrate', array(
+ '--database' => $database, '--force' => $force
+ ));
+
+ if ($this->needsSeeding())
+ {
+ $this->runSeeder($database);
+ }
+ }
+
+ /**
+ * Determine if the developer has requested database seeding.
+ *
+ * @return bool
+ */
+ protected function needsSeeding()
+ {
+ return $this->option('seed') || $this->option('seeder');
+ }
+
+ /**
+ * Run the database seeder command.
+ *
+ * @param string $database
+ * @return void
+ */
+ protected function runSeeder($database)
+ {
+ $class = $this->option('seeder') ?: 'DatabaseSeeder';
+
+ $this->call('db:seed', array('--database' => $database, '--class' => $class));
+ }
+
+ /**
+ * Get the console command options.
+ *
+ * @return array
+ */
+ protected function getOptions()
+ {
+ return array(
+ array('database', null, InputOption::VALUE_OPTIONAL, 'The database connection to use.'),
+
+ array('force', null, InputOption::VALUE_NONE, 'Force the operation to run when in production.'),
+
+ array('seed', null, InputOption::VALUE_NONE, 'Indicates if the seed task should be re-run.'),
+
+ array('seeder', null, InputOption::VALUE_OPTIONAL, 'The class name of the root seeder.'),
+ );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/ResetCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/ResetCommand.php b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/ResetCommand.php
new file mode 100755
index 0000000..f81fa90
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/ResetCommand.php
@@ -0,0 +1,91 @@
+<?php namespace Illuminate\Database\Console\Migrations;
+
+use Illuminate\Console\Command;
+use Illuminate\Console\ConfirmableTrait;
+use Illuminate\Database\Migrations\Migrator;
+use Symfony\Component\Console\Input\InputOption;
+
+class ResetCommand extends Command {
+
+ use ConfirmableTrait;
+
+ /**
+ * The console command name.
+ *
+ * @var string
+ */
+ protected $name = 'migrate:reset';
+
+ /**
+ * The console command description.
+ *
+ * @var string
+ */
+ protected $description = 'Rollback all database migrations';
+
+ /**
+ * The migrator instance.
+ *
+ * @var \Illuminate\Database\Migrations\Migrator
+ */
+ protected $migrator;
+
+ /**
+ * Create a new migration rollback command instance.
+ *
+ * @param \Illuminate\Database\Migrations\Migrator $migrator
+ * @return void
+ */
+ public function __construct(Migrator $migrator)
+ {
+ parent::__construct();
+
+ $this->migrator = $migrator;
+ }
+
+ /**
+ * Execute the console command.
+ *
+ * @return void
+ */
+ public function fire()
+ {
+ if ( ! $this->confirmToProceed()) return;
+
+ $this->migrator->setConnection($this->input->getOption('database'));
+
+ $pretend = $this->input->getOption('pretend');
+
+ while (true)
+ {
+ $count = $this->migrator->rollback($pretend);
+
+ // Once the migrator has run we will grab the note output and send it out to
+ // the console screen, since the migrator itself functions without having
+ // any instances of the OutputInterface contract passed into the class.
+ foreach ($this->migrator->getNotes() as $note)
+ {
+ $this->output->writeln($note);
+ }
+
+ if ($count == 0) break;
+ }
+ }
+
+ /**
+ * Get the console command options.
+ *
+ * @return array
+ */
+ protected function getOptions()
+ {
+ return array(
+ array('database', null, InputOption::VALUE_OPTIONAL, 'The database connection to use.'),
+
+ array('force', null, InputOption::VALUE_NONE, 'Force the operation to run when in production.'),
+
+ array('pretend', null, InputOption::VALUE_NONE, 'Dump the SQL queries that would be run.'),
+ );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/RollbackCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/RollbackCommand.php b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/RollbackCommand.php
new file mode 100755
index 0000000..c11198f
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Console/Migrations/RollbackCommand.php
@@ -0,0 +1,86 @@
+<?php namespace Illuminate\Database\Console\Migrations;
+
+use Illuminate\Console\Command;
+use Illuminate\Console\ConfirmableTrait;
+use Illuminate\Database\Migrations\Migrator;
+use Symfony\Component\Console\Input\InputOption;
+
+class RollbackCommand extends Command {
+
+ use ConfirmableTrait;
+
+ /**
+ * The console command name.
+ *
+ * @var string
+ */
+ protected $name = 'migrate:rollback';
+
+ /**
+ * The console command description.
+ *
+ * @var string
+ */
+ protected $description = 'Rollback the last database migration';
+
+ /**
+ * The migrator instance.
+ *
+ * @var \Illuminate\Database\Migrations\Migrator
+ */
+ protected $migrator;
+
+ /**
+ * Create a new migration rollback command instance.
+ *
+ * @param \Illuminate\Database\Migrations\Migrator $migrator
+ * @return void
+ */
+ public function __construct(Migrator $migrator)
+ {
+ parent::__construct();
+
+ $this->migrator = $migrator;
+ }
+
+ /**
+ * Execute the console command.
+ *
+ * @return void
+ */
+ public function fire()
+ {
+ if ( ! $this->confirmToProceed()) return;
+
+ $this->migrator->setConnection($this->input->getOption('database'));
+
+ $pretend = $this->input->getOption('pretend');
+
+ $this->migrator->rollback($pretend);
+
+ // Once the migrator has run we will grab the note output and send it out to
+ // the console screen, since the migrator itself functions without having
+ // any instances of the OutputInterface contract passed into the class.
+ foreach ($this->migrator->getNotes() as $note)
+ {
+ $this->output->writeln($note);
+ }
+ }
+
+ /**
+ * Get the console command options.
+ *
+ * @return array
+ */
+ protected function getOptions()
+ {
+ return array(
+ array('database', null, InputOption::VALUE_OPTIONAL, 'The database connection to use.'),
+
+ array('force', null, InputOption::VALUE_NONE, 'Force the operation to run when in production.'),
+
+ array('pretend', null, InputOption::VALUE_NONE, 'Dump the SQL queries that would be run.'),
+ );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Console/SeedCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Console/SeedCommand.php b/vendor/laravel/framework/src/Illuminate/Database/Console/SeedCommand.php
new file mode 100755
index 0000000..cba115b
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Console/SeedCommand.php
@@ -0,0 +1,100 @@
+<?php namespace Illuminate\Database\Console;
+
+use Illuminate\Console\Command;
+use Illuminate\Console\ConfirmableTrait;
+use Symfony\Component\Console\Input\InputOption;
+use Illuminate\Database\ConnectionResolverInterface as Resolver;
+
+class SeedCommand extends Command {
+
+ use ConfirmableTrait;
+
+ /**
+ * The console command name.
+ *
+ * @var string
+ */
+ protected $name = 'db:seed';
+
+ /**
+ * The console command description.
+ *
+ * @var string
+ */
+ protected $description = 'Seed the database with records';
+
+ /**
+ * The connection resolver instance.
+ *
+ * @var \Illuminate\Database\ConnectionResolverInterface
+ */
+ protected $resolver;
+
+ /**
+ * Create a new database seed command instance.
+ *
+ * @param \Illuminate\Database\ConnectionResolverInterface $resolver
+ * @return void
+ */
+ public function __construct(Resolver $resolver)
+ {
+ parent::__construct();
+
+ $this->resolver = $resolver;
+ }
+
+ /**
+ * Execute the console command.
+ *
+ * @return void
+ */
+ public function fire()
+ {
+ if ( ! $this->confirmToProceed()) return;
+
+ $this->resolver->setDefaultConnection($this->getDatabase());
+
+ $this->getSeeder()->run();
+ }
+
+ /**
+ * Get a seeder instance from the container.
+ *
+ * @return \Illuminate\Database\Seeder
+ */
+ protected function getSeeder()
+ {
+ $class = $this->laravel->make($this->input->getOption('class'));
+
+ return $class->setContainer($this->laravel)->setCommand($this);
+ }
+
+ /**
+ * Get the name of the database connection to use.
+ *
+ * @return string
+ */
+ protected function getDatabase()
+ {
+ $database = $this->input->getOption('database');
+
+ return $database ?: $this->laravel['config']['database.default'];
+ }
+
+ /**
+ * Get the console command options.
+ *
+ * @return array
+ */
+ protected function getOptions()
+ {
+ return array(
+ array('class', null, InputOption::VALUE_OPTIONAL, 'The class name of the root seeder', 'DatabaseSeeder'),
+
+ array('database', null, InputOption::VALUE_OPTIONAL, 'The database connection to seed'),
+
+ array('force', null, InputOption::VALUE_NONE, 'Force the operation to run when in production.'),
+ );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/DatabaseManager.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/DatabaseManager.php b/vendor/laravel/framework/src/Illuminate/Database/DatabaseManager.php
new file mode 100755
index 0000000..e30d5d3
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/DatabaseManager.php
@@ -0,0 +1,324 @@
+<?php namespace Illuminate\Database;
+
+use Illuminate\Support\Str;
+use Illuminate\Database\Connectors\ConnectionFactory;
+
+class DatabaseManager implements ConnectionResolverInterface {
+
+ /**
+ * The application instance.
+ *
+ * @var \Illuminate\Foundation\Application
+ */
+ protected $app;
+
+ /**
+ * The database connection factory instance.
+ *
+ * @var \Illuminate\Database\Connectors\ConnectionFactory
+ */
+ protected $factory;
+
+ /**
+ * The active connection instances.
+ *
+ * @var array
+ */
+ protected $connections = array();
+
+ /**
+ * The custom connection resolvers.
+ *
+ * @var array
+ */
+ protected $extensions = array();
+
+ /**
+ * Create a new database manager instance.
+ *
+ * @param \Illuminate\Foundation\Application $app
+ * @param \Illuminate\Database\Connectors\ConnectionFactory $factory
+ * @return void
+ */
+ public function __construct($app, ConnectionFactory $factory)
+ {
+ $this->app = $app;
+ $this->factory = $factory;
+ }
+
+ /**
+ * Get a database connection instance.
+ *
+ * @param string $name
+ * @return \Illuminate\Database\Connection
+ */
+ public function connection($name = null)
+ {
+ list($name, $type) = $this->parseConnectionName($name);
+
+ // If we haven't created this connection, we'll create it based on the config
+ // provided in the application. Once we've created the connections we will
+ // set the "fetch mode" for PDO which determines the query return types.
+ if ( ! isset($this->connections[$name]))
+ {
+ $connection = $this->makeConnection($name);
+
+ $this->setPdoForType($connection, $type);
+
+ $this->connections[$name] = $this->prepare($connection);
+ }
+
+ return $this->connections[$name];
+ }
+
+ /**
+ * Parse the connection into an array of the name and read / write type.
+ *
+ * @param string $name
+ * @return array
+ */
+ protected function parseConnectionName($name)
+ {
+ $name = $name ?: $this->getDefaultConnection();
+
+ return Str::endsWith($name, ['::read', '::write'])
+ ? explode('::', $name, 2) : [$name, null];
+ }
+
+ /**
+ * Disconnect from the given database and remove from local cache.
+ *
+ * @param string $name
+ * @return void
+ */
+ public function purge($name = null)
+ {
+ $this->disconnect($name);
+
+ unset($this->connections[$name]);
+ }
+
+ /**
+ * Disconnect from the given database.
+ *
+ * @param string $name
+ * @return void
+ */
+ public function disconnect($name = null)
+ {
+ if (isset($this->connections[$name = $name ?: $this->getDefaultConnection()]))
+ {
+ $this->connections[$name]->disconnect();
+ }
+ }
+
+ /**
+ * Reconnect to the given database.
+ *
+ * @param string $name
+ * @return \Illuminate\Database\Connection
+ */
+ public function reconnect($name = null)
+ {
+ $this->disconnect($name = $name ?: $this->getDefaultConnection());
+
+ if ( ! isset($this->connections[$name]))
+ {
+ return $this->connection($name);
+ }
+
+ return $this->refreshPdoConnections($name);
+ }
+
+ /**
+ * Refresh the PDO connections on a given connection.
+ *
+ * @param string $name
+ * @return \Illuminate\Database\Connection
+ */
+ protected function refreshPdoConnections($name)
+ {
+ $fresh = $this->makeConnection($name);
+
+ return $this->connections[$name]
+ ->setPdo($fresh->getPdo())
+ ->setReadPdo($fresh->getReadPdo());
+ }
+
+ /**
+ * Make the database connection instance.
+ *
+ * @param string $name
+ * @return \Illuminate\Database\Connection
+ */
+ protected function makeConnection($name)
+ {
+ $config = $this->getConfig($name);
+
+ // First we will check by the connection name to see if an extension has been
+ // registered specifically for that connection. If it has we will call the
+ // Closure and pass it the config allowing it to resolve the connection.
+ if (isset($this->extensions[$name]))
+ {
+ return call_user_func($this->extensions[$name], $config, $name);
+ }
+
+ $driver = $config['driver'];
+
+ // Next we will check to see if an extension has been registered for a driver
+ // and will call the Closure if so, which allows us to have a more generic
+ // resolver for the drivers themselves which applies to all connections.
+ if (isset($this->extensions[$driver]))
+ {
+ return call_user_func($this->extensions[$driver], $config, $name);
+ }
+
+ return $this->factory->make($config, $name);
+ }
+
+ /**
+ * Prepare the database connection instance.
+ *
+ * @param \Illuminate\Database\Connection $connection
+ * @return \Illuminate\Database\Connection
+ */
+ protected function prepare(Connection $connection)
+ {
+ $connection->setFetchMode($this->app['config']['database.fetch']);
+
+ if ($this->app->bound('events'))
+ {
+ $connection->setEventDispatcher($this->app['events']);
+ }
+
+ // The database connection can also utilize a cache manager instance when cache
+ // functionality is used on queries, which provides an expressive interface
+ // to caching both fluent queries and Eloquent queries that are executed.
+ $app = $this->app;
+
+ $connection->setCacheManager(function() use ($app)
+ {
+ return $app['cache'];
+ });
+
+ // We will setup a Closure to resolve the paginator instance on the connection
+ // since the Paginator isn't used on every request and needs quite a few of
+ // our dependencies. It'll be more efficient to lazily resolve instances.
+ $connection->setPaginator(function() use ($app)
+ {
+ return $app['paginator'];
+ });
+
+ // Here we'll set a reconnector callback. This reconnector can be any callable
+ // so we will set a Closure to reconnect from this manager with the name of
+ // the connection, which will allow us to reconnect from the connections.
+ $connection->setReconnector(function($connection)
+ {
+ $this->reconnect($connection->getName());
+ });
+
+ return $connection;
+ }
+
+ /**
+ * Prepare the read write mode for database connection instance.
+ *
+ * @param \Illuminate\Database\Connection $connection
+ * @param string $type
+ * @return \Illuminate\Database\Connection
+ */
+ protected function setPdoForType(Connection $connection, $type = null)
+ {
+ if ($type == 'read')
+ {
+ $connection->setPdo($connection->getReadPdo());
+ }
+ elseif ($type == 'write')
+ {
+ $connection->setReadPdo($connection->getPdo());
+ }
+
+ return $connection;
+ }
+
+ /**
+ * Get the configuration for a connection.
+ *
+ * @param string $name
+ * @return array
+ *
+ * @throws \InvalidArgumentException
+ */
+ protected function getConfig($name)
+ {
+ $name = $name ?: $this->getDefaultConnection();
+
+ // To get the database connection configuration, we will just pull each of the
+ // connection configurations and get the configurations for the given name.
+ // If the configuration doesn't exist, we'll throw an exception and bail.
+ $connections = $this->app['config']['database.connections'];
+
+ if (is_null($config = array_get($connections, $name)))
+ {
+ throw new \InvalidArgumentException("Database [$name] not configured.");
+ }
+
+ return $config;
+ }
+
+ /**
+ * Get the default connection name.
+ *
+ * @return string
+ */
+ public function getDefaultConnection()
+ {
+ return $this->app['config']['database.default'];
+ }
+
+ /**
+ * Set the default connection name.
+ *
+ * @param string $name
+ * @return void
+ */
+ public function setDefaultConnection($name)
+ {
+ $this->app['config']['database.default'] = $name;
+ }
+
+ /**
+ * Register an extension connection resolver.
+ *
+ * @param string $name
+ * @param callable $resolver
+ * @return void
+ */
+ public function extend($name, callable $resolver)
+ {
+ $this->extensions[$name] = $resolver;
+ }
+
+ /**
+ * Return all of the created connections.
+ *
+ * @return array
+ */
+ public function getConnections()
+ {
+ return $this->connections;
+ }
+
+ /**
+ * Dynamically pass methods to the default connection.
+ *
+ * @param string $method
+ * @param array $parameters
+ * @return mixed
+ */
+ public function __call($method, $parameters)
+ {
+ return call_user_func_array(array($this->connection(), $method), $parameters);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/DatabaseServiceProvider.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/DatabaseServiceProvider.php b/vendor/laravel/framework/src/Illuminate/Database/DatabaseServiceProvider.php
new file mode 100755
index 0000000..4926422
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/DatabaseServiceProvider.php
@@ -0,0 +1,45 @@
+<?php namespace Illuminate\Database;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\ServiceProvider;
+use Illuminate\Database\Connectors\ConnectionFactory;
+
+class DatabaseServiceProvider extends ServiceProvider {
+
+ /**
+ * Bootstrap the application events.
+ *
+ * @return void
+ */
+ public function boot()
+ {
+ Model::setConnectionResolver($this->app['db']);
+
+ Model::setEventDispatcher($this->app['events']);
+ }
+
+ /**
+ * Register the service provider.
+ *
+ * @return void
+ */
+ public function register()
+ {
+ // The connection factory is used to create the actual connection instances on
+ // the database. We will inject the factory into the manager so that it may
+ // make the connections while they are actually needed and not of before.
+ $this->app->bindShared('db.factory', function($app)
+ {
+ return new ConnectionFactory($app);
+ });
+
+ // The database manager is used to resolve various connections, since multiple
+ // connections might be managed. It also implements the connection resolver
+ // interface which may be used by other components requiring connections.
+ $this->app->bindShared('db', function($app)
+ {
+ return new DatabaseManager($app, $app['db.factory']);
+ });
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Builder.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Builder.php b/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Builder.php
new file mode 100755
index 0000000..088b1c5
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Builder.php
@@ -0,0 +1,987 @@
+<?php namespace Illuminate\Database\Eloquent;
+
+use Closure;
+use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Eloquent\Relations\Relation;
+use Illuminate\Database\Query\Builder as QueryBuilder;
+
+class Builder {
+
+ /**
+ * The base query builder instance.
+ *
+ * @var \Illuminate\Database\Query\Builder
+ */
+ protected $query;
+
+ /**
+ * The model being queried.
+ *
+ * @var \Illuminate\Database\Eloquent\Model
+ */
+ protected $model;
+
+ /**
+ * The relationships that should be eager loaded.
+ *
+ * @var array
+ */
+ protected $eagerLoad = array();
+
+ /**
+ * All of the registered builder macros.
+ *
+ * @var array
+ */
+ protected $macros = array();
+
+ /**
+ * A replacement for the typical delete function.
+ *
+ * @var \Closure
+ */
+ protected $onDelete;
+
+ /**
+ * The methods that should be returned from query builder.
+ *
+ * @var array
+ */
+ protected $passthru = array(
+ 'toSql', 'lists', 'insert', 'insertGetId', 'pluck', 'count',
+ 'min', 'max', 'avg', 'sum', 'exists', 'getBindings',
+ );
+
+ /**
+ * Create a new Eloquent query builder instance.
+ *
+ * @param \Illuminate\Database\Query\Builder $query
+ * @return void
+ */
+ public function __construct(QueryBuilder $query)
+ {
+ $this->query = $query;
+ }
+
+ /**
+ * Find a model by its primary key.
+ *
+ * @param mixed $id
+ * @param array $columns
+ * @return \Illuminate\Database\Eloquent\Model|static|null
+ */
+ public function find($id, $columns = array('*'))
+ {
+ if (is_array($id))
+ {
+ return $this->findMany($id, $columns);
+ }
+
+ $this->query->where($this->model->getQualifiedKeyName(), '=', $id);
+
+ return $this->first($columns);
+ }
+
+ /**
+ * Find a model by its primary key.
+ *
+ * @param array $id
+ * @param array $columns
+ * @return \Illuminate\Database\Eloquent\Model|Collection|static
+ */
+ public function findMany($id, $columns = array('*'))
+ {
+ if (empty($id)) return $this->model->newCollection();
+
+ $this->query->whereIn($this->model->getQualifiedKeyName(), $id);
+
+ return $this->get($columns);
+ }
+
+ /**
+ * Find a model by its primary key or throw an exception.
+ *
+ * @param mixed $id
+ * @param array $columns
+ * @return \Illuminate\Database\Eloquent\Model|static
+ *
+ * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
+ */
+ public function findOrFail($id, $columns = array('*'))
+ {
+ if ( ! is_null($model = $this->find($id, $columns))) return $model;
+
+ throw (new ModelNotFoundException)->setModel(get_class($this->model));
+ }
+
+ /**
+ * Execute the query and get the first result.
+ *
+ * @param array $columns
+ * @return \Illuminate\Database\Eloquent\Model|static|null
+ */
+ public function first($columns = array('*'))
+ {
+ return $this->take(1)->get($columns)->first();
+ }
+
+ /**
+ * Execute the query and get the first result or throw an exception.
+ *
+ * @param array $columns
+ * @return \Illuminate\Database\Eloquent\Model|static
+ *
+ * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
+ */
+ public function firstOrFail($columns = array('*'))
+ {
+ if ( ! is_null($model = $this->first($columns))) return $model;
+
+ throw (new ModelNotFoundException)->setModel(get_class($this->model));
+ }
+
+ /**
+ * Execute the query as a "select" statement.
+ *
+ * @param array $columns
+ * @return \Illuminate\Database\Eloquent\Collection|static[]
+ */
+ public function get($columns = array('*'))
+ {
+ $models = $this->getModels($columns);
+
+ // If we actually found models we will also eager load any relationships that
+ // have been specified as needing to be eager loaded, which will solve the
+ // n+1 query issue for the developers to avoid running a lot of queries.
+ if (count($models) > 0)
+ {
+ $models = $this->eagerLoadRelations($models);
+ }
+
+ return $this->model->newCollection($models);
+ }
+
+ /**
+ * Pluck a single column from the database.
+ *
+ * @param string $column
+ * @return mixed
+ */
+ public function pluck($column)
+ {
+ $result = $this->first(array($column));
+
+ if ($result) return $result->{$column};
+ }
+
+ /**
+ * Chunk the results of the query.
+ *
+ * @param int $count
+ * @param callable $callback
+ * @return void
+ */
+ public function chunk($count, callable $callback)
+ {
+ $results = $this->forPage($page = 1, $count)->get();
+
+ while (count($results) > 0)
+ {
+ // On each chunk result set, we will pass them to the callback and then let the
+ // developer take care of everything within the callback, which allows us to
+ // keep the memory low for spinning through large result sets for working.
+ call_user_func($callback, $results);
+
+ $page++;
+
+ $results = $this->forPage($page, $count)->get();
+ }
+ }
+
+ /**
+ * Get an array with the values of a given column.
+ *
+ * @param string $column
+ * @param string $key
+ * @return array
+ */
+ public function lists($column, $key = null)
+ {
+ $results = $this->query->lists($column, $key);
+
+ // If the model has a mutator for the requested column, we will spin through
+ // the results and mutate the values so that the mutated version of these
+ // columns are returned as you would expect from these Eloquent models.
+ if ($this->model->hasGetMutator($column))
+ {
+ foreach ($results as $key => &$value)
+ {
+ $fill = array($column => $value);
+
+ $value = $this->model->newFromBuilder($fill)->$column;
+ }
+ }
+
+ return $results;
+ }
+
+ /**
+ * Get a paginator for the "select" statement.
+ *
+ * @param int $perPage
+ * @param array $columns
+ * @return \Illuminate\Pagination\Paginator
+ */
+ public function paginate($perPage = null, $columns = array('*'))
+ {
+ $perPage = $perPage ?: $this->model->getPerPage();
+
+ $paginator = $this->query->getConnection()->getPaginator();
+
+ if (isset($this->query->groups))
+ {
+ return $this->groupedPaginate($paginator, $perPage, $columns);
+ }
+
+ return $this->ungroupedPaginate($paginator, $perPage, $columns);
+ }
+
+ /**
+ * Get a paginator for a grouped statement.
+ *
+ * @param \Illuminate\Pagination\Factory $paginator
+ * @param int $perPage
+ * @param array $columns
+ * @return \Illuminate\Pagination\Paginator
+ */
+ protected function groupedPaginate($paginator, $perPage, $columns)
+ {
+ $results = $this->get($columns)->all();
+
+ return $this->query->buildRawPaginator($paginator, $results, $perPage);
+ }
+
+ /**
+ * Get a paginator for an ungrouped statement.
+ *
+ * @param \Illuminate\Pagination\Factory $paginator
+ * @param int $perPage
+ * @param array $columns
+ * @return \Illuminate\Pagination\Paginator
+ */
+ protected function ungroupedPaginate($paginator, $perPage, $columns)
+ {
+ $total = $this->query->getPaginationCount();
+
+ // Once we have the paginator we need to set the limit and offset values for
+ // the query so we can get the properly paginated items. Once we have an
+ // array of items we can create the paginator instances for the items.
+ $page = $paginator->getCurrentPage($total);
+
+ $this->query->forPage($page, $perPage);
+
+ return $paginator->make($this->get($columns)->all(), $total, $perPage);
+ }
+
+ /**
+ * Get a paginator only supporting simple next and previous links.
+ *
+ * This is more efficient on larger data-sets, etc.
+ *
+ * @param int $perPage
+ * @param array $columns
+ * @return \Illuminate\Pagination\Paginator
+ */
+ public function simplePaginate($perPage = null, $columns = array('*'))
+ {
+ $paginator = $this->query->getConnection()->getPaginator();
+
+ $page = $paginator->getCurrentPage();
+
+ $perPage = $perPage ?: $this->model->getPerPage();
+
+ $this->query->skip(($page - 1) * $perPage)->take($perPage + 1);
+
+ return $paginator->make($this->get($columns)->all(), $perPage);
+ }
+
+ /**
+ * Update a record in the database.
+ *
+ * @param array $values
+ * @return int
+ */
+ public function update(array $values)
+ {
+ return $this->query->update($this->addUpdatedAtColumn($values));
+ }
+
+ /**
+ * Increment a column's value by a given amount.
+ *
+ * @param string $column
+ * @param int $amount
+ * @param array $extra
+ * @return int
+ */
+ public function increment($column, $amount = 1, array $extra = array())
+ {
+ $extra = $this->addUpdatedAtColumn($extra);
+
+ return $this->query->increment($column, $amount, $extra);
+ }
+
+ /**
+ * Decrement a column's value by a given amount.
+ *
+ * @param string $column
+ * @param int $amount
+ * @param array $extra
+ * @return int
+ */
+ public function decrement($column, $amount = 1, array $extra = array())
+ {
+ $extra = $this->addUpdatedAtColumn($extra);
+
+ return $this->query->decrement($column, $amount, $extra);
+ }
+
+ /**
+ * Add the "updated at" column to an array of values.
+ *
+ * @param array $values
+ * @return array
+ */
+ protected function addUpdatedAtColumn(array $values)
+ {
+ if ( ! $this->model->usesTimestamps()) return $values;
+
+ $column = $this->model->getUpdatedAtColumn();
+
+ return array_add($values, $column, $this->model->freshTimestampString());
+ }
+
+ /**
+ * Delete a record from the database.
+ *
+ * @return mixed
+ */
+ public function delete()
+ {
+ if (isset($this->onDelete))
+ {
+ return call_user_func($this->onDelete, $this);
+ }
+
+ return $this->query->delete();
+ }
+
+ /**
+ * Run the default delete function on the builder.
+ *
+ * @return mixed
+ */
+ public function forceDelete()
+ {
+ return $this->query->delete();
+ }
+
+ /**
+ * Register a replacement for the default delete function.
+ *
+ * @param \Closure $callback
+ * @return void
+ */
+ public function onDelete(Closure $callback)
+ {
+ $this->onDelete = $callback;
+ }
+
+ /**
+ * Get the hydrated models without eager loading.
+ *
+ * @param array $columns
+ * @return \Illuminate\Database\Eloquent\Model[]
+ */
+ public function getModels($columns = array('*'))
+ {
+ // First, we will simply get the raw results from the query builders which we
+ // can use to populate an array with Eloquent models. We will pass columns
+ // that should be selected as well, which are typically just everything.
+ $results = $this->query->get($columns);
+
+ $connection = $this->model->getConnectionName();
+
+ $models = array();
+
+ // Once we have the results, we can spin through them and instantiate a fresh
+ // model instance for each records we retrieved from the database. We will
+ // also set the proper connection name for the model after we create it.
+ foreach ($results as $result)
+ {
+ $models[] = $model = $this->model->newFromBuilder($result);
+
+ $model->setConnection($connection);
+ }
+
+ return $models;
+ }
+
+ /**
+ * Eager load the relationships for the models.
+ *
+ * @param array $models
+ * @return array
+ */
+ public function eagerLoadRelations(array $models)
+ {
+ foreach ($this->eagerLoad as $name => $constraints)
+ {
+ // For nested eager loads we'll skip loading them here and they will be set as an
+ // eager load on the query to retrieve the relation so that they will be eager
+ // loaded on that query, because that is where they get hydrated as models.
+ if (strpos($name, '.') === false)
+ {
+ $models = $this->loadRelation($models, $name, $constraints);
+ }
+ }
+
+ return $models;
+ }
+
+ /**
+ * Eagerly load the relationship on a set of models.
+ *
+ * @param array $models
+ * @param string $name
+ * @param \Closure $constraints
+ * @return array
+ */
+ protected function loadRelation(array $models, $name, Closure $constraints)
+ {
+ // First we will "back up" the existing where conditions on the query so we can
+ // add our eager constraints. Then we will merge the wheres that were on the
+ // query back to it in order that any where conditions might be specified.
+ $relation = $this->getRelation($name);
+
+ $relation->addEagerConstraints($models);
+
+ call_user_func($constraints, $relation);
+
+ $models = $relation->initRelation($models, $name);
+
+ // Once we have the results, we just match those back up to their parent models
+ // using the relationship instance. Then we just return the finished arrays
+ // of models which have been eagerly hydrated and are readied for return.
+ $results = $relation->getEager();
+
+ return $relation->match($models, $results, $name);
+ }
+
+ /**
+ * Get the relation instance for the given relation name.
+ *
+ * @param string $relation
+ * @return \Illuminate\Database\Eloquent\Relations\Relation
+ */
+ public function getRelation($relation)
+ {
+ // We want to run a relationship query without any constrains so that we will
+ // not have to remove these where clauses manually which gets really hacky
+ // and is error prone while we remove the developer's own where clauses.
+ $query = Relation::noConstraints(function() use ($relation)
+ {
+ return $this->getModel()->$relation();
+ });
+
+ $nested = $this->nestedRelations($relation);
+
+ // If there are nested relationships set on the query, we will put those onto
+ // the query instances so that they can be handled after this relationship
+ // is loaded. In this way they will all trickle down as they are loaded.
+ if (count($nested) > 0)
+ {
+ $query->getQuery()->with($nested);
+ }
+
+ return $query;
+ }
+
+ /**
+ * Get the deeply nested relations for a given top-level relation.
+ *
+ * @param string $relation
+ * @return array
+ */
+ protected function nestedRelations($relation)
+ {
+ $nested = array();
+
+ // We are basically looking for any relationships that are nested deeper than
+ // the given top-level relationship. We will just check for any relations
+ // that start with the given top relations and adds them to our arrays.
+ foreach ($this->eagerLoad as $name => $constraints)
+ {
+ if ($this->isNested($name, $relation))
+ {
+ $nested[substr($name, strlen($relation.'.'))] = $constraints;
+ }
+ }
+
+ return $nested;
+ }
+
+ /**
+ * Determine if the relationship is nested.
+ *
+ * @param string $name
+ * @param string $relation
+ * @return bool
+ */
+ protected function isNested($name, $relation)
+ {
+ $dots = str_contains($name, '.');
+
+ return $dots && starts_with($name, $relation.'.');
+ }
+
+ /**
+ * Add a basic where clause to the query.
+ *
+ * @param string $column
+ * @param string $operator
+ * @param mixed $value
+ * @param string $boolean
+ * @return $this
+ */
+ public function where($column, $operator = null, $value = null, $boolean = 'and')
+ {
+ if ($column instanceof Closure)
+ {
+ $query = $this->model->newQueryWithoutScopes();
+
+ call_user_func($column, $query);
+
+ $this->query->addNestedWhereQuery($query->getQuery(), $boolean);
+ }
+ else
+ {
+ call_user_func_array(array($this->query, 'where'), func_get_args());
+ }
+
+ return $this;
+ }
+
+ /**
+ * Add an "or where" clause to the query.
+ *
+ * @param string $column
+ * @param string $operator
+ * @param mixed $value
+ * @return \Illuminate\Database\Eloquent\Builder|static
+ */
+ public function orWhere($column, $operator = null, $value = null)
+ {
+ return $this->where($column, $operator, $value, 'or');
+ }
+
+ /**
+ * Add a relationship count condition to the query.
+ *
+ * @param string $relation
+ * @param string $operator
+ * @param int $count
+ * @param string $boolean
+ * @param \Closure|null $callback
+ * @return \Illuminate\Database\Eloquent\Builder|static
+ */
+ public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null)
+ {
+ if (strpos($relation, '.') !== false)
+ {
+ return $this->hasNested($relation, $operator, $count, $boolean, $callback);
+ }
+
+ $relation = $this->getHasRelationQuery($relation);
+
+ $query = $relation->getRelationCountQuery($relation->getRelated()->newQuery(), $this);
+
+ if ($callback) call_user_func($callback, $query);
+
+ return $this->addHasWhere($query, $relation, $operator, $count, $boolean);
+ }
+
+ /**
+ * Add nested relationship count conditions to the query.
+ *
+ * @param string $relations
+ * @param string $operator
+ * @param int $count
+ * @param string $boolean
+ * @param \Closure $callback
+ * @return \Illuminate\Database\Eloquent\Builder|static
+ */
+ protected function hasNested($relations, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
+ {
+ $relations = explode('.', $relations);
+
+ // In order to nest "has", we need to add count relation constraints on the
+ // callback Closure. We'll do this by simply passing the Closure its own
+ // reference to itself so it calls itself recursively on each segment.
+ $closure = function ($q) use (&$closure, &$relations, $operator, $count, $boolean, $callback)
+ {
+ if (count($relations) > 1)
+ {
+ $q->whereHas(array_shift($relations), $closure);
+ }
+ else
+ {
+ $q->has(array_shift($relations), $operator, $count, $boolean, $callback);
+ }
+ };
+
+ return $this->whereHas(array_shift($relations), $closure);
+ }
+
+ /**
+ * Add a relationship count condition to the query.
+ *
+ * @param string $relation
+ * @param string $boolean
+ * @param \Closure|null $callback
+ * @return \Illuminate\Database\Eloquent\Builder|static
+ */
+ public function doesntHave($relation, $boolean = 'and', Closure $callback = null)
+ {
+ return $this->has($relation, '<', 1, $boolean, $callback);
+ }
+
+ /**
+ * Add a relationship count condition to the query with where clauses.
+ *
+ * @param string $relation
+ * @param \Closure $callback
+ * @param string $operator
+ * @param int $count
+ * @return \Illuminate\Database\Eloquent\Builder|static
+ */
+ public function whereHas($relation, Closure $callback, $operator = '>=', $count = 1)
+ {
+ return $this->has($relation, $operator, $count, 'and', $callback);
+ }
+
+ /**
+ * Add a relationship count condition to the query with where clauses.
+ *
+ * @param string $relation
+ * @param \Closure|null $callback
+ * @return \Illuminate\Database\Eloquent\Builder|static
+ */
+ public function whereDoesntHave($relation, Closure $callback = null)
+ {
+ return $this->doesntHave($relation, 'and', $callback);
+ }
+
+ /**
+ * Add a relationship count condition to the query with an "or".
+ *
+ * @param string $relation
+ * @param string $operator
+ * @param int $count
+ * @return \Illuminate\Database\Eloquent\Builder|static
+ */
+ public function orHas($relation, $operator = '>=', $count = 1)
+ {
+ return $this->has($relation, $operator, $count, 'or');
+ }
+
+ /**
+ * Add a relationship count condition to the query with where clauses and an "or".
+ *
+ * @param string $relation
+ * @param \Closure $callback
+ * @param string $operator
+ * @param int $count
+ * @return \Illuminate\Database\Eloquent\Builder|static
+ */
+ public function orWhereHas($relation, Closure $callback, $operator = '>=', $count = 1)
+ {
+ return $this->has($relation, $operator, $count, 'or', $callback);
+ }
+
+ /**
+ * Add the "has" condition where clause to the query.
+ *
+ * @param \Illuminate\Database\Eloquent\Builder $hasQuery
+ * @param \Illuminate\Database\Eloquent\Relations\Relation $relation
+ * @param string $operator
+ * @param int $count
+ * @param string $boolean
+ * @return \Illuminate\Database\Eloquent\Builder
+ */
+ protected function addHasWhere(Builder $hasQuery, Relation $relation, $operator, $count, $boolean)
+ {
+ $this->mergeWheresToHas($hasQuery, $relation);
+
+ if (is_numeric($count))
+ {
+ $count = new Expression($count);
+ }
+
+ return $this->where(new Expression('('.$hasQuery->toSql().')'), $operator, $count, $boolean);
+ }
+
+ /**
+ * Merge the "wheres" from a relation query to a has query.
+ *
+ * @param \Illuminate\Database\Eloquent\Builder $hasQuery
+ * @param \Illuminate\Database\Eloquent\Relations\Relation $relation
+ * @return void
+ */
+ protected function mergeWheresToHas(Builder $hasQuery, Relation $relation)
+ {
+ // Here we have the "has" query and the original relation. We need to copy over any
+ // where clauses the developer may have put in the relationship function over to
+ // the has query, and then copy the bindings from the "has" query to the main.
+ $relationQuery = $relation->getBaseQuery();
+
+ $hasQuery = $hasQuery->getModel()->removeGlobalScopes($hasQuery);
+
+ $hasQuery->mergeWheres(
+ $relationQuery->wheres, $relationQuery->getBindings()
+ );
+
+ $this->query->mergeBindings($hasQuery->getQuery());
+ }
+
+ /**
+ * Get the "has relation" base query instance.
+ *
+ * @param string $relation
+ * @return \Illuminate\Database\Eloquent\Builder
+ */
+ protected function getHasRelationQuery($relation)
+ {
+ return Relation::noConstraints(function() use ($relation)
+ {
+ return $this->getModel()->$relation();
+ });
+ }
+
+ /**
+ * Set the relationships that should be eager loaded.
+ *
+ * @param mixed $relations
+ * @return $this
+ */
+ public function with($relations)
+ {
+ if (is_string($relations)) $relations = func_get_args();
+
+ $eagers = $this->parseRelations($relations);
+
+ $this->eagerLoad = array_merge($this->eagerLoad, $eagers);
+
+ return $this;
+ }
+
+ /**
+ * Parse a list of relations into individuals.
+ *
+ * @param array $relations
+ * @return array
+ */
+ protected function parseRelations(array $relations)
+ {
+ $results = array();
+
+ foreach ($relations as $name => $constraints)
+ {
+ // If the "relation" value is actually a numeric key, we can assume that no
+ // constraints have been specified for the eager load and we'll just put
+ // an empty Closure with the loader so that we can treat all the same.
+ if (is_numeric($name))
+ {
+ $f = function() {};
+
+ list($name, $constraints) = array($constraints, $f);
+ }
+
+ // We need to separate out any nested includes. Which allows the developers
+ // to load deep relationships using "dots" without stating each level of
+ // the relationship with its own key in the array of eager load names.
+ $results = $this->parseNested($name, $results);
+
+ $results[$name] = $constraints;
+ }
+
+ return $results;
+ }
+
+ /**
+ * Parse the nested relationships in a relation.
+ *
+ * @param string $name
+ * @param array $results
+ * @return array
+ */
+ protected function parseNested($name, $results)
+ {
+ $progress = array();
+
+ // If the relation has already been set on the result array, we will not set it
+ // again, since that would override any constraints that were already placed
+ // on the relationships. We will only set the ones that are not specified.
+ foreach (explode('.', $name) as $segment)
+ {
+ $progress[] = $segment;
+
+ if ( ! isset($results[$last = implode('.', $progress)]))
+ {
+ $results[$last] = function() {};
+ }
+ }
+
+ return $results;
+ }
+
+ /**
+ * Call the given model scope on the underlying model.
+ *
+ * @param string $scope
+ * @param array $parameters
+ * @return \Illuminate\Database\Query\Builder
+ */
+ protected function callScope($scope, $parameters)
+ {
+ array_unshift($parameters, $this);
+
+ return call_user_func_array(array($this->model, $scope), $parameters) ?: $this;
+ }
+
+ /**
+ * Get the underlying query builder instance.
+ *
+ * @return \Illuminate\Database\Query\Builder|static
+ */
+ public function getQuery()
+ {
+ return $this->query;
+ }
+
+ /**
+ * Set the underlying query builder instance.
+ *
+ * @param \Illuminate\Database\Query\Builder $query
+ * @return void
+ */
+ public function setQuery($query)
+ {
+ $this->query = $query;
+ }
+
+ /**
+ * Get the relationships being eagerly loaded.
+ *
+ * @return array
+ */
+ public function getEagerLoads()
+ {
+ return $this->eagerLoad;
+ }
+
+ /**
+ * Set the relationships being eagerly loaded.
+ *
+ * @param array $eagerLoad
+ * @return void
+ */
+ public function setEagerLoads(array $eagerLoad)
+ {
+ $this->eagerLoad = $eagerLoad;
+ }
+
+ /**
+ * Get the model instance being queried.
+ *
+ * @return \Illuminate\Database\Eloquent\Model
+ */
+ public function getModel()
+ {
+ return $this->model;
+ }
+
+ /**
+ * Set a model instance for the model being queried.
+ *
+ * @param \Illuminate\Database\Eloquent\Model $model
+ * @return $this
+ */
+ public function setModel(Model $model)
+ {
+ $this->model = $model;
+
+ $this->query->from($model->getTable());
+
+ return $this;
+ }
+
+ /**
+ * Extend the builder with a given callback.
+ *
+ * @param string $name
+ * @param \Closure $callback
+ * @return void
+ */
+ public function macro($name, Closure $callback)
+ {
+ $this->macros[$name] = $callback;
+ }
+
+ /**
+ * Get the given macro by name.
+ *
+ * @param string $name
+ * @return \Closure
+ */
+ public function getMacro($name)
+ {
+ return array_get($this->macros, $name);
+ }
+
+ /**
+ * Dynamically handle calls into the query instance.
+ *
+ * @param string $method
+ * @param array $parameters
+ * @return mixed
+ */
+ public function __call($method, $parameters)
+ {
+ if (isset($this->macros[$method]))
+ {
+ array_unshift($parameters, $this);
+
+ return call_user_func_array($this->macros[$method], $parameters);
+ }
+ elseif (method_exists($this->model, $scope = 'scope'.ucfirst($method)))
+ {
+ return $this->callScope($scope, $parameters);
+ }
+
+ $result = call_user_func_array(array($this->query, $method), $parameters);
+
+ return in_array($method, $this->passthru) ? $result : $this;
+ }
+
+ /**
+ * Force a clone of the underlying query builder when cloning.
+ *
+ * @return void
+ */
+ public function __clone()
+ {
+ $this->query = clone $this->query;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Collection.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Collection.php b/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Collection.php
new file mode 100755
index 0000000..dc520e5
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Collection.php
@@ -0,0 +1,253 @@
+<?php namespace Illuminate\Database\Eloquent;
+
+use Illuminate\Support\Collection as BaseCollection;
+
+class Collection extends BaseCollection {
+
+ /**
+ * Find a model in the collection by key.
+ *
+ * @param mixed $key
+ * @param mixed $default
+ * @return \Illuminate\Database\Eloquent\Model
+ */
+ public function find($key, $default = null)
+ {
+ if ($key instanceof Model)
+ {
+ $key = $key->getKey();
+ }
+
+ return array_first($this->items, function($itemKey, $model) use ($key)
+ {
+ return $model->getKey() == $key;
+
+ }, $default);
+ }
+
+ /**
+ * Load a set of relationships onto the collection.
+ *
+ * @param mixed $relations
+ * @return $this
+ */
+ public function load($relations)
+ {
+ if (count($this->items) > 0)
+ {
+ if (is_string($relations)) $relations = func_get_args();
+
+ $query = $this->first()->newQuery()->with($relations);
+
+ $this->items = $query->eagerLoadRelations($this->items);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Add an item to the collection.
+ *
+ * @param mixed $item
+ * @return $this
+ */
+ public function add($item)
+ {
+ $this->items[] = $item;
+
+ return $this;
+ }
+
+ /**
+ * Determine if a key exists in the collection.
+ *
+ * @param mixed $key
+ * @return bool
+ */
+ public function contains($key)
+ {
+ return ! is_null($this->find($key));
+ }
+
+ /**
+ * Fetch a nested element of the collection.
+ *
+ * @param string $key
+ * @return static
+ */
+ public function fetch($key)
+ {
+ return new static(array_fetch($this->toArray(), $key));
+ }
+
+ /**
+ * Get the max value of a given key.
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function max($key)
+ {
+ return $this->reduce(function($result, $item) use ($key)
+ {
+ return (is_null($result) || $item->{$key} > $result) ? $item->{$key} : $result;
+ });
+ }
+
+ /**
+ * Get the min value of a given key.
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function min($key)
+ {
+ return $this->reduce(function($result, $item) use ($key)
+ {
+ return (is_null($result) || $item->{$key} < $result) ? $item->{$key} : $result;
+ });
+ }
+
+ /**
+ * Get the array of primary keys
+ *
+ * @return array
+ */
+ public function modelKeys()
+ {
+ return array_map(function($m) { return $m->getKey(); }, $this->items);
+ }
+
+ /**
+ * Merge the collection with the given items.
+ *
+ * @param \ArrayAccess|array $items
+ * @return static
+ */
+ public function merge($items)
+ {
+ $dictionary = $this->getDictionary();
+
+ foreach ($items as $item)
+ {
+ $dictionary[$item->getKey()] = $item;
+ }
+
+ return new static(array_values($dictionary));
+ }
+
+ /**
+ * Diff the collection with the given items.
+ *
+ * @param \ArrayAccess|array $items
+ * @return static
+ */
+ public function diff($items)
+ {
+ $diff = new static;
+
+ $dictionary = $this->getDictionary($items);
+
+ foreach ($this->items as $item)
+ {
+ if ( ! isset($dictionary[$item->getKey()]))
+ {
+ $diff->add($item);
+ }
+ }
+
+ return $diff;
+ }
+
+ /**
+ * Intersect the collection with the given items.
+ *
+ * @param \ArrayAccess|array $items
+ * @return static
+ */
+ public function intersect($items)
+ {
+ $intersect = new static;
+
+ $dictionary = $this->getDictionary($items);
+
+ foreach ($this->items as $item)
+ {
+ if (isset($dictionary[$item->getKey()]))
+ {
+ $intersect->add($item);
+ }
+ }
+
+ return $intersect;
+ }
+
+ /**
+ * Return only unique items from the collection.
+ *
+ * @return static
+ */
+ public function unique()
+ {
+ $dictionary = $this->getDictionary();
+
+ return new static(array_values($dictionary));
+ }
+
+ /**
+ * Returns only the models from the collection with the specified keys.
+ *
+ * @param mixed $keys
+ * @return static
+ */
+ public function only($keys)
+ {
+ $dictionary = array_only($this->getDictionary(), $keys);
+
+ return new static(array_values($dictionary));
+ }
+
+ /**
+ * Returns all models in the collection except the models with specified keys.
+ *
+ * @param mixed $keys
+ * @return static
+ */
+ public function except($keys)
+ {
+ $dictionary = array_except($this->getDictionary(), $keys);
+
+ return new static(array_values($dictionary));
+ }
+
+ /**
+ * Get a dictionary keyed by primary keys.
+ *
+ * @param \ArrayAccess|array $items
+ * @return array
+ */
+ public function getDictionary($items = null)
+ {
+ $items = is_null($items) ? $this->items : $items;
+
+ $dictionary = array();
+
+ foreach ($items as $value)
+ {
+ $dictionary[$value->getKey()] = $value;
+ }
+
+ return $dictionary;
+ }
+
+ /**
+ * Get a base Support collection instance from this collection.
+ *
+ * @return \Illuminate\Support\Collection
+ */
+ public function toBase()
+ {
+ return new BaseCollection($this->items);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Database/Eloquent/MassAssignmentException.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Database/Eloquent/MassAssignmentException.php b/vendor/laravel/framework/src/Illuminate/Database/Eloquent/MassAssignmentException.php
new file mode 100755
index 0000000..c7fe78e
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Database/Eloquent/MassAssignmentException.php
@@ -0,0 +1,3 @@
+<?php namespace Illuminate\Database\Eloquent;
+
+class MassAssignmentException extends \RuntimeException {}