private function getExceptionData($exception)
{
$data = [];
$data['host'] = Request::server('HTTP_HOST');
$data['method'] = Request::method();
$data['fullUrl'] = Request::fullUrl();
if (php_sapi_name() === 'cli') {
$data['host'] = parse_url(config('app.url'), PHP_URL_HOST);
$data['method'] = 'CLI';
}
$data['exception'] = $exception->getMessage();
$data['error'] = $exception->getTraceAsString();
$data['line'] = $exception->getLine();
$data['file'] = $exception->getFile();
$data['class'] = get_class($exception);
$data['storage'] = array('SERVER' => Request::server(), 'GET' => Request::query(), 'POST' => $_POST, 'FILE' => Request::file(), 'OLD' => Request::hasSession() ? Request::old() : [], 'COOKIE' => Request::cookie(), 'SESSION' => Request::hasSession() ? Session::all() : [], 'HEADERS' => Request::header());
$data['storage'] = array_filter($data['storage']);
$count = $this->config['count'];
$data['exegutor'] = [];
$data['file_lines'] = [];
$file = new SplFileObject($data['file']);
for ($i = -1 * abs($count); $i <= abs($count); $i++) {
list($line, $exegutorLine) = $this->getLineInfo($file, $data['line'], $i);
$data['exegutor'][] = $exegutorLine;
$data['file_lines'][$data['line'] + $i] = $line;
}
// to make Symfony exception more readable
if ($data['class'] == 'Symfony\\Component\\Debug\\Exception\\FatalErrorException') {
preg_match("~^(.+)' in ~", $data['exception'], $matches);
if (isset($matches[1])) {
$data['exception'] = $matches[1];
}
}
return $data;
}
/**
* Register the application services.
*
* @return void
*/
public function register()
{
$configPath = __DIR__ . '/../config/sql-logging.php';
$this->mergeConfigFrom($configPath, 'sql-logging');
if (config('sql-logging.log', false)) {
Event::listen('illuminate.query', function ($query, $bindings, $time) {
$data = compact('bindings', 'time');
// Format binding data for sql insertion
foreach ($bindings as $i => $binding) {
if ($binding instanceof \DateTime) {
$bindings[$i] = $binding->format('\'Y-m-d H:i:s\'');
} else {
if (is_string($binding)) {
$bindings[$i] = "'{$binding}'";
}
}
}
// Insert bindings into query
$query = str_replace(array('%', '?'), array('%%', '%s'), $query);
$query = vsprintf($query, $bindings);
$log = new Logger('sql');
$log->pushHandler(new StreamHandler(storage_path() . '/logs/sql-' . date('Y-m-d') . '.log', Logger::INFO));
// if log request data
if (config('sql-logging.log_request', false)) {
$data['request_path'] = Request::path();
$data['request_method'] = Request::method();
$data['request_data'] = Request::all();
}
// add records to the log
$log->addInfo($query, $data);
});
}
}
public function anyManageShop()
{
$product_types = ProductTypes::where('hidden', 0)->orderBy('name', 'ASC')->get();
$success_msg = [];
$error_msg = [];
$rules = ['product_name' => 'required', 'product_category' => 'required', 'short_description' => 'required', 'product_description' => 'required', 'price' => 'required', 'quantity' => 'required|numeric'];
$validator = Validator::make(Input::all(), $rules);
if (Request::method() == 'POST') {
if (!$validator->fails()) {
$category_select = Input::get('product_category');
$category = ProductTypes::find($category_select);
if ($category) {
/** @var Products $product */
$product = new Products();
$product->uid = Uuid::generate()->string;
$product->name = Input::get('product_name');
$product->short_description = Input::get('short_description');
$product->description = Input::get('product_description');
$product->price_in_cents = Input::get('price') * 100;
$product->quantity = Input::get('quantity');
$product->product_type_id = $category->id;
$product->allow_review = 1;
$product->save();
if ($product->save()) {
if (Input::file('main_product_image')) {
$filename = Input::file('main_product_image')->getClientOriginalName();
$destination = storage_path() . '/app/upload/';
$file_path = Input::file('main_product_image')->move($destination, $filename);
// $diskLocal = Storage::disk('local');
$product_image = new ProductImages();
$product_image->url = $filename;
$product_image->product_id = $product->id;
$product_image->name = $filename;
$product_image->is_primary = 1;
$product_image->save();
}
}
$success_msg[] = 'Product Added!';
} else {
$error_msg[] = 'Whoops! Sorry, product category not found';
}
} else {
return Redirect::back()->withErrors($validator->messages())->withInput(Input::all());
}
}
return View::make('shop.manage_store', ['product_types' => $product_types, 'success_msg' => $success_msg, 'error_msg' => $error_msg]);
}
public function anyAddInvoiceItems()
{
$invoice_details = InvoiceDetails::get();
$items = InvoiceItems::all();
if (Request::method() == 'POST') {
$invoice_items = new InvoiceItems();
$invoice_items->invoice_id = Input::get('invoice_id');
$invoice_items->quantity = Input::get('quantity');
$invoice_items->product = Input::get('product');
$invoice_items->price_in_cents = Input::get('price') * 100;
$invoice_items->currency_code = Input::get('currency_code');
$invoice_items->save();
return Redirect::back()->with('success', 'Items Added!');
} else {
return View::make('invoice.invoice_items', ['invoices' => $invoice_details, 'invoice_items' => $items]);
}
}
/**
* Transform an exception to attachment array for slack post
*
* @param E $e
*
* @return array
*/
protected static function exceptionToSlackAttach(E $e)
{
$fields = [];
$addToField = function ($name, $value, $short = false) use(&$fields) {
if (!empty($value)) {
$fields[] = ["title" => $name, "value" => $value, "short" => $short];
}
};
$addToField("Exception", get_class($e), true);
$addToField("Hash", ExceptionHelper::hash($e), true);
$addToField("Http code", ExceptionHelper::statusCode($e), true);
$addToField("Code", $e->getCode(), true);
$addToField("File", $e->getFile(), true);
$addToField("Line", $e->getLine(), true);
$addToField("Request url", Request::url(), true);
$addToField("Request method", Request::method(), true);
$addToField("Request param", json_encode(Request::all()), true);
return ["color" => "danger", "title" => $e->getMessage(), "fallback" => !empty($e->getMessage()) ? $e->getMessage() : get_class($e), "fields" => $fields, "text" => $e->getTraceAsString()];
}
/**
* Update item.
*
* @return \Modules\Articles\Entities\Article
*/
public function update($id, &$context)
{
$article = $this->findById($id);
if (Request::method() == 'PATCH') {
// restore
if (Request::has('restore') && (int) Request::get('restore')) {
$article->restore();
$context = 'restored';
return $article;
} else {
$data = array_merge($article->toArray(), Request::except($this->publishing_columns));
// exclude missing keys
$domain_data = CoreRequest::only($this->publishing_columns);
// process domain data
$article_data = is_null($article->data) ? [] : $article->data->toArray();
$domain_data = array_merge(Arr::only($article_data, $this->publishing_columns), $domain_data);
}
} else {
$input = Request::except($this->publishing_columns);
$domain_data = Request::only($this->publishing_columns);
// validate
$data = $this->validate($input, $article->id);
// slug is slug
$data['slug'] = Str::slug(Arr::get($data, 'slug') ?: $data['title']);
}
// update
$article->update($data);
//
// update data
//
// create
if (is_null($article->data)) {
(new ArticleDomainDataRepository())->create($article->toArray() + $domain_data);
} else {
$article->data()->update(ArticleDomainDataRepository::validate($domain_data) + ['modified_by' => Request::header('UID', 0)]);
$article->data()->touch();
}
return $article;
}
public function anyUpdateStatus($booking_uid, $status)
{
$booking = Bookings::where('uid', '=', $booking_uid)->first();
$error_msg = [];
$tz = new \DateTimeZone('NZ');
$now = new \DateTime(date('Y-m-d H:i:s'));
$now->setTimezone($tz);
$current_date_time = $now->format('Y-m-d H:i:s');
$success = false;
$booking_date = Input::get('booking_date');
$booking_time = Input::get('booking_time');
if (Request::method() == 'GET') {
return view('booking.update_status', ['booking' => $booking, 'success' => $success, 'status' => $status, 'error_msg' => $error_msg]);
} else {
if ($booking) {
if ($status == 'consulted') {
$booking->pending = 0;
$booking->consulted = 1;
$booking->completed = 0;
$booking->cancelled = 0;
$booking->consulted_at = $current_date_time;
$booking->save();
$success = true;
} elseif ($status == 'completed') {
if ($booking_date && $booking_time) {
$booking->pending = 0;
$booking->consulted = 0;
$booking->completed = 1;
$booking->cancelled = 0;
$booking->completed_at = $current_date_time;
$booking->booking_date = date('Y-m-d', strtotime($booking_date));
$booking->booking_time = date('H:i:s', strtotime($booking_time));
$booking->save();
$success = true;
} else {
$error_msg[] = 'Booking date and booking time are required.';
$success = false;
}
} elseif ($status == 'cancelled') {
$booking->pending = 0;
$booking->consulted = 0;
$booking->completed = 0;
$booking->cancelled = 1;
$booking->cancelled_at = $current_date_time;
$booking->save();
$success = true;
} else {
$error_msg[] = 'No status selected';
$success = false;
}
if ($success) {
return Redirect::back()->with('success', $success);
} else {
return view('booking.update_status', ['booking' => $booking, 'success' => $success, 'status' => $status, 'error_msg' => $error_msg]);
}
} else {
return Redirect::back()->with(['success', $success, 'error_msg', $error_msg]);
}
}
}
public function validateSignedURL($actual_url, $signed_url, $substitions)
{
$current_route = Request::route();
$current_route_name = $current_route->getName();
if (isset($substitions[$current_route_name])) {
$substition = $substitions[$current_route_name];
// make sure the host of the signed URL matches the host of the substitution URL
if (isset($substition['host'])) {
$signed_host = $this->getHostFromURL($signed_url);
$allowed_host = $substition['host'];
if ($signed_host != $allowed_host) {
Log::debug("HOST MISMATCH: \$signed_host={$signed_host} \$allowed_host={$allowed_host}");
// no host match - return false
return false;
}
}
// check the route
$substitute_route = new Route($current_route->getMethods(), $substition['route'], []);
$signed_request = \Illuminate\Http\Request::create($signed_url, Request::method());
if ($substitute_route->matches($signed_request)) {
// the allowed substitute route matches the signed request
return true;
}
Log::debug("ROUTE MISMATCH: pathinfo=" . json_encode(Request::getFacadeRoot()->getPathInfo()) . " allowed route={$substition['route']}");
}
// this signed URL was not valid
return false;
}
/**
* Gets the Method of the Request
* @return string|null Possible values are null or GET, POST, DELETE, PUT, etc...
*/
protected function getMethod()
{
$method = Request::method();
if (!empty($method)) {
return $method;
} else {
return null;
}
}
public function __construct()
{
$this->result['meta'] = ['url' => Request::url(), 'method' => Request::method()];
}
public function getRulesAttribute()
{
if ($this->rulesParsed) {
return $this->rules;
//Prevents 'required' and update IDS being added many times
}
if ($this->id) {
//Existing record
foreach ($this->unique as $value) {
//Stops the unique values from ruining everything
$this->rules[$value] = $this->rules[$value] . "," . $this->id;
}
$this->rules = AddRule($this->rules, $this->onUpdateRequired, 'required');
//Need to require things after appending the ID
}
if (Request::method() == "POST" || Request::method() == "GET") {
//Initial create
$this->rules = AddRule($this->rules, $this->onCreateRequired, 'required');
//return $this->rules; //DOn't add on things that aren't actual validation rules
}
$this->rulesParsed = true;
return $this->rules;
}
