Пример #1
1
 /**
  * We will get all column schema from database.
  *
  * @return mixed
  */
 public function getColumns()
 {
     $table = $this->table->connect($this->database, Inflector::tabilize($this->model));
     return $table->{__FUNCTION__}();
 }
Пример #2
1
 /**
  * @param null $number
  * @return $this
  */
 public function setTotalNumberOfPage($number = null)
 {
     if (is_null($number)) {
         $modelClass = Inflector::getClassNameFromNamespace(get_class($this->model));
         $table = Inflector::tabilize($modelClass);
         $numRecords = $this->model->select($this->count() . " AS " . $this->numCount)->findMany();
         $this->totalNumOfPage = $numRecords[0]->{$this->numCount};
         return $this;
     }
     $this->totalNumOfPage = $number;
     return $this;
 }
Пример #3
0
 /**
  * You cannot create an instance of Schema class
  * directly
  *
  * @param $model
  */
 protected function __construct($model)
 {
     $this->klass = $model;
     if (class_exists(get_class($this->klass))) {
         $reflectionClass = new \ReflectionClass(get_class($this->klass));
         /*
         | We will set the database connection name here
         */
         if (property_exists($this->klass, 'database')) {
             $reflectionProperty = $reflectionClass->getProperty('database');
             $reflectionProperty->setAccessible(true);
             $this->database = $reflectionProperty->getValue($this->klass);
         } else {
             $this->database = $this->getDefaultConnection();
         }
         /*
         | We will set the primary key of the table schema
         */
         if (property_exists($this->klass, 'primaryKey')) {
             $reflectionPropertyKey = $reflectionClass->getProperty('primaryKey');
             $reflectionPropertyKey->setAccessible(true);
             $this->primaryKey = $reflectionPropertyKey->getValue($this->klass);
         }
         /*
         | Set database connection name
         */
         $this->setDatabaseConnection($this->database);
         if (!property_exists($this->klass, 'tableName')) {
             $this->tableName = Inflector::tabilize(get_class($this->klass));
         }
     }
 }
Пример #4
0
 /**
  * Get the Queued message and return it
  *
  * @param  string $key
  * @return mixed
  *
  */
 public function getFlash($key = null)
 {
     $messages = $flash = '';
     if (!Session::has('flashMessages')) {
         return false;
     }
     $flashArray = Session::get('flashMessages');
     // Check $key is valid flash type
     if (in_array($key, $this->validFlashTypes)) {
         if (isset($flashArray[$key])) {
             foreach ($flashArray[$key] as $msg) {
                 $messages .= '<p>' . $msg . "</p>\n";
             }
         }
         $flash .= sprintf($this->flashWrapper, strtolower(Inflector::getClassName($this->class)), $key, $messages);
         // clear the viewed messages from browser
         $this->clearViewedMessages($key);
         // Print ALL queued messages
     } elseif (is_null($key)) {
         foreach ($flashArray as $key => $msgArray) {
             $messages = '';
             foreach ($msgArray as $msg) {
                 $messages .= '<p>' . $msg . "</p>\n";
             }
             $flash .= sprintf($this->flashWrapper, strtolower($this->class), $key, $messages);
         }
         // clear already viewed messages
         $this->clearViewedMessages();
         // Invalid message type
     } else {
         return false;
     }
     return $flash;
 }
Пример #5
0
 private function replaceModelTemplate($content)
 {
     $content = str_replace('%StaticModelName%', $this->command->getModel(), $content);
     $primaryKey = $this->command->table()->getPrimaryKey();
     $content = str_replace('{%Apps%}', APP_NS, $content);
     $content = str_replace('{%primaryKey%}', $primaryKey, $content);
     $content = str_replace('%modelName%', Inflector::tabilize($this->command->getModel()), $content);
     $content = str_replace('%databaseName%', $this->command->getDatabase(), $content);
     $content = str_replace('{%rules%}', $this->replaceValidationRules(), $content);
     return $content;
 }
Пример #6
0
 /**
  * We will register user defined events, it will trigger event when matches.
  *
  * @param $events
  *
  * @throws \RuntimeException
  */
 public function registerEvents($events)
 {
     if (empty($events)) {
         throw new \RuntimeException(sprintf('Empty argument passed %s', __FUNCTION__));
     }
     foreach ($events as $event => $namespace) {
         $parts = explode('@', $namespace);
         // attach all before and after event to handler
         $this->attach("{$event}.before", $parts[0] . '@before' . ucfirst(Inflector::pathAction(end($parts))))->attach("{$event}", $parts[0] . '@' . Inflector::pathAction(end($parts)))->attach("{$event}.after", $parts[0] . '@after' . ucfirst(Inflector::pathAction(end($parts))));
     }
 }
Пример #7
0
 /**
  * We will execute the crud command and generate files
  * @param InputInterface  $input
  * @param OutputInterface $output
  * @return int|null|void
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     /** Check for argument database name if not given we will use default
      *  database connection
      */
     $this->database = !is_null($input->getArgument('database')) ? $input->getArgument('database') : $this->tableSchema->getDefaultDatabaseConnection();
     $this->table = !is_null($input->getArgument('name')) ? $input->getArgument('name') : 'Form';
     $this->columns = $this->getColumns();
     $this->applicationDir = CYGNITE_BASE . DS . APPPATH;
     $this->generateForm();
     $output->writeln("<info>Form " . APPPATH . "/components/form/" . Inflector::classify($this->table) . "Form" . EXT . " Generated Successfully By Cygnite Cli.</info>");
 }
Пример #8
0
 /**
  * Set all definitions into array
  * @param $propertyInjections
  * @throws \Exception
  */
 public function setPropertyInjection($propertyInjections)
 {
     if (!is_array($propertyInjections)) {
         throw new \Exception(__METHOD__ . " only accept parameter as array.");
     }
     foreach ($propertyInjections as $controller => $properties) {
         foreach ($properties as $key => $value) {
             $classInstance = Inflector::toNamespace($value);
             $this->definitions["\\" . ucfirst(APPPATH) . $this->namespace . $controller][$key] = new $classInstance();
         }
     }
 }
 /**
  * We will execute the controller command and generate classes
  *
  * @param InputInterface  $input
  * @param OutputInterface $output
  * @throws \Exception
  * @return int|null|void
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     // Your controller name
     $this->controller = Inflector::classify($input->getArgument('name')) . 'Controller';
     // By default we will generate basic controller, if resource set then we will generate
     // REST-ful Resource controller
     $this->setControllerType($input);
     try {
         $this->makeController();
     } catch (\Exception $e) {
         throw $e;
     }
     $output->writeln('<info>Controller ' . $this->controller . ' Generated Successfully By Cygnite Cli.</info>');
 }
 /**
  * We will execute the controller command and generate classes
  *
  * @return mixed|void
  * @throws \Exception
  */
 public function process()
 {
     // Your controller name
     $this->controller = Inflector::classify($this->argument('name')) . 'Controller';
     // By default we will generate basic controller, if resource set then we will generate
     // REST-ful Resource controller
     $this->setControllerType();
     try {
         $this->makeController();
     } catch (\Exception $e) {
         throw $e;
     }
     $this->info('Controller ' . $this->controller . ' Generated Successfully By Cygnite Cli.');
 }
 /**
  * We will inject interface implementation
  *
  * @param $reflectionParam
  * @return array
  */
 public function interfaceInjection($reflectionParam)
 {
     $constructorArgs = null;
     /*
     | Check if constructor dependency is Interface or not.
     | if interface we will check definition for the interface
     | and inject into controller constructor
     */
     if (!$reflectionParam->IsInstantiable() && $reflectionParam->isInterface()) {
         $aliases = $this['definition.config']['register.alias'];
         $interface = Inflector::getClassName($reflectionParam->getName());
         if (array_key_exists($interface, $aliases)) {
             $constructorArgs = $this->makeInstance($aliases[$interface]);
         }
     }
     return $constructorArgs;
 }
Пример #12
0
 /**
  * Generate Form
  */
 public function generate()
 {
     $filePath = '';
     $formName = Inflector::classify($this->formCommand->table);
     if (file_exists($this->getFormTemplatePath() . 'Form' . EXT)) {
         //We will generate Form Component
         $formContent = file_get_contents($this->getFormTemplatePath() . 'Form' . EXT);
     } else {
         die("Form template doesn't exists in " . $this->getFormTemplatePath() . 'Form' . EXT . " directory.");
     }
     $this->controller->isFormGenerator = true;
     $this->controller->updateTemplate();
     $this->controller->controller = $formName;
     $this->controller->applicationDir = CYGNITE_BASE . DS . APPPATH;
     $formContent = str_replace('%controllerName%', $formName, $formContent);
     $formContent = str_replace('{%formElements%}', $this->controller->getForm() . PHP_EOL, $formContent);
     $this->controller->generateFormComponent($formContent);
 }
Пример #13
0
 /**
  * All static methods will get resolve by Proxy Resolver
  *
  * @param       $method
  * @param array $arguments
  * @return mixed
  */
 public static function __callStatic($method, $arguments = array())
 {
     $accessor = $instance = null;
     $accessor = static::getResolver();
     $accessor = Inflector::toNamespace($accessor);
     $instance = new $accessor();
     // calling the method directly is faster then call_user_func_array() !
     switch (count($arguments)) {
         case 0:
             return $instance->{$method}();
         case 1:
             return $instance->{$method}($arguments[0]);
         case 2:
             return $instance->{$method}($arguments[0], $arguments[1]);
         case 3:
             return $instance->{$method}($arguments[0], $arguments[1], $arguments[2]);
         case 4:
             return $instance->{$method}($arguments[0], $arguments[1], $arguments[2], $arguments[3]);
         default:
             return call_user_func_array(array($instance, $method), $arguments);
     }
 }
Пример #14
0
 /**
  * You cannot create an instance of Schema class
  * directly.
  *
  * @param $model
  * @param null $database
  *
  * @throws \ErrorException
  */
 protected function __construct($model = null, $database = null)
 {
     if (!is_null($model) && is_object($model)) {
         $this->klass = $model;
         if (!class_exists(get_class($this->klass))) {
             throw new \ErrorException(sprintf("Class %s doesn't exists", get_class($this->klass)));
         }
         $reflectionClass = new \ReflectionClass(get_class($this->klass));
         /*
         | We will set the database connection name here
         */
         if (property_exists($this->klass, 'database')) {
             $reflectionProperty = $reflectionClass->getProperty('database');
             $reflectionProperty->setAccessible(true);
             $database = $reflectionProperty->getValue($this->klass);
         }
         // If table name not provided we will format and consider class name as table
         if (!property_exists($this->klass, 'tableName')) {
             $model = Inflector::tabilize(get_class($this->klass));
         }
     }
     $this->setDatabase(!is_null($database) ? $database : $this->getDefaultConnection());
     $this->setTableName($model);
 }
Пример #15
0
 /**
  * @param $controller
  * @param $action
  * @return mixed
  */
 protected function setDeleteRoute($controller, $action)
 {
     return $this->mapRoute("/{$controller}/{$action}/{:id}/", Inflector::classify($controller) . '@' . $action);
 }
Пример #16
0
 /**
  * @param $key
  * @return string
  */
 private function convertToFieldName($key)
 {
     return Inflector::underscoreToSpace($key);
 }
Пример #17
0
 public function getPlainUri($name, $prefix)
 {
     return $prefix . '/' . implode('-', array_slice(explode('_', Inflector::deCamelize($name)), 1));
 }
Пример #18
0
 /**
  * Covert dash-dot to namespace
  *
  * @param $key
  * @return string
  */
 public function toNamespace($key)
 {
     $class = null;
     $class = explode('.', $key);
     $class = array_map('ucfirst', Inflector::instance()->classify($class));
     $class = '\\' . implode('\\', $class);
     return $class;
 }
Пример #19
0
 /**
  * Render twig templates
  *
  * @param       $view
  * @param array $param
  * @param bool  $return
  * @return $this
  */
 public function template($view, array $param = [], $return = false)
 {
     $this->setTwigEnvironment();
     $path = $this->getPath(Inflector::toDirectorySeparator($view), true);
     /*
     | We will check if tpl is holding the object of
     | twig, then we will set twig template
     | environment
     */
     if (is_object(static::$twigEnvironment) && is_file($path)) {
         $this->setTwigTemplateInstance($view);
     }
     /*
     | We will check is twig template instance exists
     | then we will render twig template with parameters
     */
     if (is_object(static::$twigEnvironment) && is_object($this['twig_template'])) {
         return $return ? $this['twig_template']->render($param) : $this['twig_template']->display($param);
     }
     return $this;
 }
Пример #20
0
 /**
  * @return mixed
  */
 public function getTotalNumberOfPages()
 {
     $numRecords = null;
     $modelClass = Inflector::getClassNameFromNamespace(get_class($this->model));
     $table = Inflector::tabilize($modelClass);
     $numRecords = $this->model->query("SELECT " . $this->count() . " as " . $this->numCount . " FROM `" . $table . "`")->getAll();
     return $numRecords[0]->{$this->numCount};
 }
Пример #21
0
 /**
  * Resolve all dependencies of your class and return instance of
  * your class
  *
  * @param $class string
  * @throws \Exception
  * @return object
  */
 public function make($class)
 {
     $reflection = new Reflection();
     $reflection->setClass($class);
     if (false === $reflection->reflectionClass->isInstantiable()) {
         throw new DependencyException("Cannot instantiate " . ($reflection->reflectionClass->isInterface() ? 'interface' : 'class') . " '{$class}'");
     }
     $constructor = null;
     $constructorArgsCount = '';
     if ($reflection->reflectionClass->hasMethod('__construct')) {
         $constructor = $reflection->reflectionClass->getConstructor();
         $constructorArgsCount = $constructor->getNumberOfParameters();
         $constructor->setAccessible(true);
     }
     // if class does not have explicitly defined constructor or constructor does not have parameters
     // get the new instance
     if (!isset($constructor) && is_null($constructor) || $constructorArgsCount < 1) {
         $this->stack[$class] = $reflection->reflectionClass->newInstance();
     } else {
         $dependencies = $constructor->getParameters();
         $constructorArgs = array();
         foreach ($dependencies as $dependency) {
             if (!is_null($dependency->getClass())) {
                 //Get constructor class name
                 $resolveClass = $dependency->getClass()->name;
                 $reflectionParam = new ReflectionClass($resolveClass);
                 // Application and Container cannot be injected into controller currently
                 // since Application constructor is protected
                 if ($reflectionParam->IsInstantiable()) {
                     $constructorArgs[] = $this->makeInstance($resolveClass);
                 }
                 /*
                 | Check if constructor dependency is Interface or not.
                 | if interface we will check definition for the interface
                 | and inject into controller constructor
                 */
                 if (!$reflectionParam->IsInstantiable() && $reflectionParam->isInterface()) {
                     $definition = $this->getDefinition();
                     $aliases = $definition()->registerAlias();
                     $interface = Inflector::getClassName($reflectionParam->getName());
                     if (array_key_exists($interface, $aliases)) {
                         $constructorArgs[] = $this->makeInstance($aliases[$interface]);
                     }
                 }
             } else {
                 /*
                 | Check parameters are optional or not
                 | if it is optional we will set the default value
                 */
                 if ($dependency->isOptional()) {
                     $constructorArgs[] = $dependency->getDefaultValue();
                 }
             }
         }
         $this->stack[$class] = $reflection->reflectionClass->newInstanceArgs($constructorArgs);
     }
     return $this->stack[$class];
 }
Пример #22
0
 /**
  * Resolve the class. We will create and return instance if already
  * not exists.
  *
  * @param       $class
  * @param array $arguments
  *
  * @return object
  */
 public function resolve($class, $arguments = [])
 {
     $class = Inflector::toNamespace($class);
     return $this->make($class, $arguments);
 }
Пример #23
0
 /**
  * Quote a string that is used as an identifier
  * (table names, column names etc) or an array containing
  * multiple identifiers. This method can also deal with
  * dot-separated identifiers eg table.column
  */
 protected function quoteIdentifier($identifier)
 {
     if (is_array($identifier)) {
         $result = array_map(array($this, 'quoteOneIdentifier'), $identifier);
         return join(', ', $result);
     } else {
         return Inflector::tabilize($this->quoteOneIdentifier(lcfirst($identifier)));
     }
 }
Пример #24
0
 /**
  * The finder make use of __callStatic() to invoke
  * undefined static methods dynamically. This magic method is mainly used
  * for dynamic finders
  *
  * @param $method    String
  * @param $arguments array
  * @return object
  *
  */
 public static function __callStatic($method, $arguments)
 {
     $params = [];
     $class = self::model();
     switch ($method) {
         case substr($method, 0, 6) == 'findBy':
             if (strpos($method, 'And') !== false) {
                 return self::callFinderBy($method, $class, $arguments, 'And');
                 // findByAnd
             }
             if (strpos($method, 'Or') !== false) {
                 return self::callFinderBy($method, $class, $arguments, 'Or');
                 // findByOr
             }
             $columnName = Inflector::tabilize(substr($method, 6));
             $operator = isset($arguments[1]) ? $arguments[1] : '=';
             $params = [$columnName, $operator, $arguments[0]];
             return self::model()->query()->find('findBy', $params);
             break;
         case 'joinWith':
             return static::$ar->joinWith($class, $arguments);
             break;
     }
     //Use the power of PDO methods directly via static functions
     return static::callDynamicMethod([self::model()->query()->resolveConnection(), $method], $arguments);
 }
Пример #25
0
 /**
  * Set controller and method name here
  * @param $arguments
  */
 private function setUpControllerAndMethodName($arguments)
 {
     $expression = Helper::stringSplit($arguments[0]);
     $this->controller = Inflector::instance()->classify($expression[0]) . 'Controller';
     $this->controllerWithNS = $this->namespace . $this->controller;
     $this->method = Inflector::instance()->toCameCase($expression[1]) . 'Action';
 }
Пример #26
0
 /**
  * @param $actionName
  * @return string
  */
 public function getActionName($actionName)
 {
     return Inflector::camelize(!isset($actionName) ? 'index' : $actionName) . 'Action';
 }
Пример #27
0
 /**
  * We will get all column schema from database.
  *
  * @return mixed
  */
 private function getColumns()
 {
     $table = $this->table->connect($this->database, Inflector::tabilize($this->tableName));
     return $table->getColumns();
 }
Пример #28
0
 public function render($view, $values = array(), $ui_content = false)
 {
     $controller = Inflector::instance()->getClassNameFromNamespace(get_called_class());
     $controller = strtolower(str_replace('Controller', '', $controller));
     $viewPath = null;
     $viewPath = strpos($this->viewsFilePath, '.') == true ? str_replace('.', DS, $this->viewsFilePath) : $this->viewsFilePath;
     $path = getcwd() . DS . APPPATH . DS . $viewPath . DS . $controller . DS;
     if (is_object($this->tpl) && is_file($path . $view . $this->templateExtension)) {
         $this->template = $this->tpl->loadTemplate($controller . DS . $view . $this->templateExtension);
         return $this;
     }
     if (!file_exists($path . $view . '.view' . EXT) && !is_readable($path . $view . '.view' . EXT)) {
         throw new \Exception('The Path ' . $path . $view . '.view' . EXT . ' is invalid.');
     }
     self::$name[strtolower($view)] = $view;
     $viewPage = '';
     $viewPage = $path . self::$name[$view] . '.view' . EXT;
     if (is_readable($viewPage)) {
         $this->layout = Inflector::instance()->toDirectorySeparator($this->layout);
         if ($this->layout !== '') {
             // render view page into the layout
             $layout = getcwd() . DS . APPPATH . DS . $viewPath . DS . $this->layout . '.view' . EXT;
             //$this->view_path = $path.self::$name[$view].'.view'.EXT; // $layout;
             $this->assignToProperties($values);
             ob_start();
             include $viewPage;
             $data = array();
             $data['yield'] = ob_get_contents();
             ob_get_clean();
             extract($data);
             include $layout;
             $data = array();
             $content = null;
             $output = ob_get_contents();
             ob_get_clean();
             echo $output;
             return $this;
         }
         if ($ui_content == true) {
             self::$uiContent = $ui_content;
             $this->view_path = $viewPage;
             $this->loadView();
             return $this->content;
         }
         $this->view_path = $viewPage;
         $this->loadView();
         return $this;
     }
 }
Пример #29
0
 /**
  * Run validation rules and catch errors
  *
  * @return bool
  * @throws \Exception
  */
 public function run()
 {
     $isValid = true;
     if (empty($this->rules)) {
         return true;
     }
     foreach ($this->rules as $key => $val) {
         $rules = explode('|', $val);
         foreach ($rules as $rule) {
             if (!strstr($rule, 'max') && !strstr($rule, 'min')) {
                 $method = Inflector::instance()->toCameCase($rule);
                 if (is_callable(array($this, $method)) === false) {
                     throw new \Exception('Undefined method ' . __CLASS__ . ' ' . $method . ' called.');
                 }
                 //echo $key."<br>";
                 if ($isValid === false) {
                     $this->setErrors($key . self::ERROR, Inflector::camelize(str_replace('_', ' ', $key)));
                 }
                 $isValid = $this->{$method}($key);
                 //$isValid = call_user_func(array($this, $rule[0]), array($key));
             } else {
                 $rule = explode(':', $rule);
                 $method = Inflector::instance()->toCameCase($rule[0]);
                 if (is_callable(array($this, $method)) === false) {
                     throw new \Exception('Undefined method ' . __CLASS__ . ' ' . $method . ' called.');
                 }
                 if ($isValid === false) {
                     $this->setErrors($key . self::ERROR, Inflector::camelize(str_replace('_', ' ', $key)));
                 }
                 //$isValid = call_user_func_array(array($this, $rule[0]), array($key,$rule[1]));
                 $isValid = $this->{$method}($key, $rule[1]);
             }
         }
     }
     return $isValid;
 }
Пример #30
0
 /**
  * We will execute the crud command and generate files
  *
  * @param InputInterface  $input
  * @param OutputInterface $output
  * @throws \Exception
  * @return int|null|void
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     // Your model name
     $this->model = Inflector::classify($input->getArgument('name'));
     // Check for argument database name if not given we will use default
     // database connection
     $this->database = $this->getDatabase($input);
     $this->columns = $this->getColumns();
     if (empty($this->columns)) {
         throw new \Exception("Please check your model name. It seems doesn't exists in the database.");
     }
     $this->applicationDir = CYGNITE_BASE . DS . APPPATH;
     $this->generateModel();
     $modelPath = $this->applicationDir . DS . 'models' . DS . $this->model . EXT;
     $output->writeln("Model {$this->model} generated successfully into " . $modelPath);
 }