Ümit Tunç
1451 lines
36 KiB
PHP
1451 lines
36 KiB
PHP
<?php
|
||
|
||
namespace App\Http\Controllers;
|
||
|
||
|
||
|
||
use Illuminate\Support\Facades\Auth;
|
||
use Illuminate\Database\Schema\Blueprint;
|
||
use Illuminate\Support\Facades\DB;
|
||
use Illuminate\Http\Request;
|
||
use Illuminate\Support\Facades\Input;
|
||
use App\Contents;
|
||
use App\Types;
|
||
use App\Fields;
|
||
use App\User;
|
||
use Carbon\Carbon;
|
||
use App\DevExtreme\Utils;
|
||
use App\DevExtreme\FilterHelper;
|
||
use App\DevExtreme\DbSet;
|
||
|
||
use Illuminate\Auth\Events\Registered;
|
||
use Maatwebsite\Excel\Facades\Excel;
|
||
use App\Imports\ImportExcel;
|
||
use App\Exports\ExportExcel;
|
||
use Illuminate\Support\Facades\Artisan;
|
||
use Cache;
|
||
use Illuminate\Support\Facades\Storage;
|
||
use App\Models\ColumnComment;
|
||
use Illuminate\Support\Facades\Session;
|
||
use Illuminate\Support\Facades\Log;
|
||
use App\Jobs\ExecuteSaveTriggerJob;
|
||
|
||
class AdminController extends Controller
|
||
{
|
||
private $currentTable;
|
||
|
||
public function __construct()
|
||
{
|
||
$this->middleware('auth');
|
||
}
|
||
|
||
/**
|
||
* Önbelleğe alınmış dashboard sayfasını görüntüler
|
||
* Eğer önbellek dosyası yoksa gerçek zamanlı oluşturur
|
||
*/
|
||
public function cachedDashboard()
|
||
{
|
||
if (Storage::exists('cache/dashboard.blade.php')) {
|
||
$dashboardContent = Storage::get('cache/dashboard.blade.php');
|
||
$lastUpdated = Storage::exists('cache/dashboard_last_updated.txt')
|
||
? Storage::get('cache/dashboard_last_updated.txt')
|
||
: date('Y-m-d H:i:s');
|
||
|
||
return view('admin.dashboard.index', [
|
||
'dashboardContent' => $dashboardContent,
|
||
'lastUpdated' => $lastUpdated
|
||
]);
|
||
} else {
|
||
// Önbellek bulunamadı, cron dosyasını çalıştır
|
||
$dashboardContent = view('admin.dashboard.module.dashboard')->render();
|
||
return view('admin.dashboard.index', [
|
||
'dashboardContent' => $dashboardContent,
|
||
'lastUpdated' => date('Y-m-d H:i:s') . ' (cache not found)'
|
||
]);
|
||
}
|
||
}
|
||
|
||
public function importStatus() {
|
||
$id = session('import');
|
||
return response([
|
||
'started' => filled(cache("start_date_$id")),
|
||
'finished' => filled(cache("end_date_$id")),
|
||
'current_row' => (int) cache("current_row_$id"),
|
||
'total_rows' => (int) cache("total_rows_$id"),
|
||
]);
|
||
|
||
}
|
||
|
||
public function logout() {
|
||
Auth::logout();
|
||
Session::forget('cached_user');
|
||
return redirect('login');
|
||
}
|
||
|
||
public function action2(string $action="",string $type ="") {
|
||
if($type=="types") {
|
||
$types = new Types;
|
||
$types->title = "";
|
||
$types->slug = "";
|
||
$types->save();
|
||
return back();
|
||
|
||
|
||
}
|
||
}
|
||
public function action(string $type="",string $id="",string $action ="") {
|
||
$this->middleware('auth');
|
||
if($type=="contents") {
|
||
switch($action) {
|
||
case "add" :
|
||
$c = Contents::where("slug",$id)->first();
|
||
$content = new Contents;
|
||
$content->title = "";
|
||
$content->slug = rand(1111111,99999999);
|
||
$content->tkid = json_encode(Contents::getTree($id));
|
||
$content->breadcrumb = Contents::getBreadcrumbs($id,"{title} / ");
|
||
if(isset($c->type)) {
|
||
$content->type = $c->type;
|
||
}
|
||
|
||
$content->kid = $id;
|
||
$content->save();
|
||
return redirect("admin/$type/$id");
|
||
break;
|
||
case "delete":
|
||
$content = Contents::where('slug', $id)->orWhere("id",$id)->delete();
|
||
return back();
|
||
break;
|
||
|
||
}
|
||
}
|
||
if($type=="types") {
|
||
switch($action) {
|
||
|
||
case "delete":
|
||
$content = Types::where('id', $id)->delete();
|
||
return back();
|
||
break;
|
||
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
public function new(string $type="") {
|
||
$this->middleware('auth');
|
||
$contents = Contents::where("kid","main")
|
||
->orderBy("s","ASC")
|
||
->get(); // tüm içeriklerdeki ana içerikler gelecek
|
||
$types = Types::orderBy("id", "DESC")->get(); // tüm tipler
|
||
$var = [
|
||
'type' => $type,
|
||
'contents' => $contents,
|
||
"types" => $types
|
||
];
|
||
try {
|
||
return view("admin/new/$type",$var);
|
||
} catch (\Exception $e) {
|
||
return abort(404);
|
||
}
|
||
}
|
||
|
||
public function exportExcel(Request $request, string $tableName, string $fileName="") {
|
||
|
||
|
||
if($fileName=="") {
|
||
$fileName = $tableName;
|
||
}
|
||
if($request->filter) {
|
||
dd($request->filter);
|
||
}
|
||
$columnNames = [];
|
||
if($request->columns) {
|
||
$columnNames = $request->columns;
|
||
}
|
||
|
||
if(!getesit("module","")) {
|
||
$fileName = get("module");
|
||
}
|
||
|
||
$excel = new ExportExcel($tableName, $columnNames);
|
||
$response = Excel::download($excel, $fileName . '.xlsx');
|
||
ob_end_clean();
|
||
return $response;
|
||
}
|
||
|
||
public function importExcel(Request $request, string $tableName) {
|
||
|
||
$id = now()->unix();
|
||
session([ 'import' => $id ]);
|
||
|
||
if(!is_null($request->file('excel-file'))) {
|
||
Excel::queueImport(new ImportExcel($tableName, $id),
|
||
$request->file('excel-file')->store('files'));
|
||
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
public function truncateTable(Request $request, string $tableName) {
|
||
$u = u();
|
||
if($u->level == "Admin") {
|
||
$query = db($tableName);
|
||
if($tableName=="users") {
|
||
$query = $query->where(function($q) {
|
||
$q->orWhereNull("permissions");
|
||
$q->orWhereNull("email");
|
||
$q->orWhereNull("recover");
|
||
|
||
});
|
||
|
||
$jobDesc = db("job_descriptions")->get()->pluck("title")->toArray();
|
||
$jobDesc[] = null;
|
||
$query = $query->whereIn("level", $jobDesc)->delete();
|
||
} else {
|
||
$query->truncate();
|
||
}
|
||
Artisan::call('cache:clear');
|
||
}
|
||
|
||
|
||
|
||
return redirect()->back();
|
||
}
|
||
|
||
public function delete(string $tableName, int $id) {
|
||
$query = db($tableName);
|
||
if($tableName == "users") {
|
||
$query = $query->where(function($q) {
|
||
$q->orWhereNull("permissions");
|
||
$q->orWhereNull("email");
|
||
$q->orWhereNull("recover");
|
||
|
||
});
|
||
|
||
$jobDesc = db("job_descriptions")->get()->pluck("title")->toArray();
|
||
$jobDesc[] = null;
|
||
$query = $query->whereIn("level", $jobDesc);
|
||
}
|
||
echo $query->where("id", $id)->delete();
|
||
}
|
||
|
||
public function exceptionFields($filterColumn, $filterValue) {
|
||
if($filterColumn == "naks_id") {
|
||
$pattern = '/\[(.*?)\]/';
|
||
if (preg_match($pattern, $filterValue, $matches)) {
|
||
$result = $matches[1];
|
||
return $result;
|
||
} else {
|
||
return $filterValue;
|
||
}
|
||
} elseif($filterColumn == "short_number-certificate_no") {
|
||
dd($filterColumn);
|
||
} else {
|
||
return $filterValue;
|
||
}
|
||
}
|
||
|
||
public function responseJSON($data) {
|
||
return response()->json(
|
||
($data),
|
||
200,
|
||
[
|
||
'Content-Type' => 'application/json;charset=UTF-8',
|
||
'Charset' => 'utf-8'
|
||
],
|
||
JSON_UNESCAPED_UNICODE
|
||
);
|
||
}
|
||
|
||
public function autocompleteType(string $type) {
|
||
|
||
$rowData = json_decode(get("row"));
|
||
|
||
if(is_null($rowData))
|
||
{
|
||
$rowData = (object) request()->all();
|
||
}
|
||
|
||
if(getisset('$filter')) {
|
||
$text = get('$filter');
|
||
$pattern = "/'([^']+)'/";
|
||
if (preg_match($pattern, $text, $matches)) {
|
||
$substring = $matches[1];
|
||
// echo $substring;
|
||
$_GET['value'] = $substring;
|
||
}
|
||
}
|
||
if(isset($rowData->naks_technology)) {
|
||
$naksTechDatas = explode(" + ", $rowData->naks_technology);
|
||
$certificateNo = [];
|
||
foreach($naksTechDatas AS $naksTechData) {
|
||
$certificateNo[] = explode("-", $naksTechData)[2];
|
||
}
|
||
}
|
||
$type = str_replace("*", "/", $type);
|
||
include(base_path("app/Http/Controllers/AutoCompleteType/$type.php"));
|
||
return $this->responseJSON($response);
|
||
|
||
|
||
|
||
}
|
||
|
||
public function autocomplete(string $tableName, string $columnName) {
|
||
$query = db($tableName);
|
||
|
||
if(getisset('$filter')) {
|
||
$text = get('$filter');
|
||
$pattern = "/'([^']+)'/";
|
||
if (preg_match($pattern, $text, $matches)) {
|
||
$substring = $matches[1];
|
||
// echo $substring;
|
||
$_GET['value'] = $substring;
|
||
}
|
||
}
|
||
|
||
if(getisset("filter")) {
|
||
$filter = json_decode(get("filter"), true);
|
||
foreach($filter AS $filterColumn => $filterValue) {
|
||
$filterValue = $this->exceptionFields($filterColumn, $filterValue);
|
||
$query = $query->where($filterColumn, $filterValue);
|
||
}
|
||
}
|
||
|
||
if(getisset("filter_multi")) {
|
||
$filter = json_decode(get("filter_multi"), true);
|
||
|
||
foreach($filter AS $filterColumn => $filterValues) {
|
||
$filterValues = explode(",", $filterValues);
|
||
$query = $query->whereIn($filterColumn, $filterValue);
|
||
}
|
||
}
|
||
|
||
|
||
if(!getesit("value", "")) {
|
||
$value = get("value");
|
||
$query = $query->where($columnName,"like","%$value%");
|
||
|
||
}
|
||
|
||
$take = 20;
|
||
if(!getesit("take", "")) {
|
||
$take = get("take");
|
||
}
|
||
$query = $query->take($take);
|
||
|
||
if(!getesit("values", "")) {
|
||
$whereInColumnName = $columnName;
|
||
|
||
if(!getesit("column", "")) {
|
||
$whereInColumnName = get("column");
|
||
}
|
||
|
||
$values = explode(",", get("values"));
|
||
$query = $query->whereIn($whereInColumnName, $values);
|
||
}
|
||
|
||
if(!getesit("pattern", "")) {
|
||
$columns = get_variables_from_pattern(get("pattern"));
|
||
//dd($columns);
|
||
$query = $query->groupBy($columns)->get($columns)->toArray();
|
||
$result = [];
|
||
foreach($query AS $q) {
|
||
$pattern = get("pattern");
|
||
foreach($columns AS $column) {
|
||
$pattern = str_replace("{".$column."}", $q->$column, $pattern);
|
||
}
|
||
/// dd($pattern);
|
||
$result[] = $pattern;
|
||
}
|
||
$query = $result;
|
||
} else {
|
||
if(!getisset("all")) {
|
||
$query = $query->select($columnName);
|
||
$query = $query->groupBy($columnName);
|
||
}
|
||
|
||
|
||
|
||
if(getisset("with-column")) {
|
||
$query = $query->get();
|
||
} else {
|
||
$query = $query->pluck($columnName);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
return $this->responseJSON($query);
|
||
|
||
}
|
||
|
||
public function fuzzyAutocomplete(string $tableName, ?string $columnName = null) {
|
||
if (empty($columnName)) {
|
||
return $this->responseJSON([]);
|
||
}
|
||
|
||
$searchTerm = request('search', '');
|
||
$limit = (int) request('limit', 20);
|
||
|
||
$existingValues = [];
|
||
try {
|
||
$existingValues = db($tableName)
|
||
->whereNotNull($columnName)
|
||
->where($columnName, '!=', '')
|
||
->distinct()
|
||
->pluck($columnName)
|
||
->filter()
|
||
->values()
|
||
->toArray();
|
||
} catch (\Exception $e) {
|
||
dd($e);
|
||
}
|
||
|
||
// Build values array
|
||
$allValues = [];
|
||
foreach ($existingValues as $value) {
|
||
$allValues[] = [
|
||
'value' => $value,
|
||
'display' => $value
|
||
];
|
||
}
|
||
|
||
if (!empty($searchTerm)) {
|
||
$searchTerm = strtolower($searchTerm);
|
||
$results = [];
|
||
|
||
foreach ($allValues as $item) {
|
||
$value = strtolower($item['value']);
|
||
|
||
$score = 0;
|
||
|
||
// Exact match (highest priority)
|
||
if ($value === $searchTerm) {
|
||
$score = 100;
|
||
}
|
||
elseif (strpos($value, $searchTerm) === 0) {
|
||
$score = 80;
|
||
}
|
||
elseif (strpos($value, $searchTerm) !== false) {
|
||
$score = 60;
|
||
}
|
||
else {
|
||
$distance = levenshtein($searchTerm, substr($value, 0, strlen($searchTerm) + 2));
|
||
if ($distance <= 2) {
|
||
$score = 40 - ($distance * 10);
|
||
}
|
||
}
|
||
|
||
if ($score > 0) {
|
||
$item['score'] = $score;
|
||
$results[] = $item;
|
||
}
|
||
}
|
||
|
||
usort($results, function($a, $b) {
|
||
return $b['score'] - $a['score'];
|
||
});
|
||
|
||
$seen = [];
|
||
$uniqueResults = [];
|
||
foreach ($results as $item) {
|
||
if (!in_array($item['value'], $seen)) {
|
||
$seen[] = $item['value'];
|
||
unset($item['score']); // Remove score from output
|
||
$uniqueResults[] = $item;
|
||
}
|
||
if (count($uniqueResults) >= $limit) break;
|
||
}
|
||
|
||
return $this->responseJSON($uniqueResults);
|
||
}
|
||
|
||
$uniqueResults = array_slice($allValues, 0, $limit);
|
||
|
||
return $this->responseJSON($uniqueResults);
|
||
}
|
||
|
||
public function linkCreator(Request $request, string $tableName, string $id) {
|
||
|
||
$prefix = $tableName.$id . md5(get("data"));
|
||
/*
|
||
if(Cache::has($prefix)) {
|
||
return Cache::get($prefix);
|
||
} else {
|
||
*/
|
||
|
||
$thisData = db($tableName)->where("id", $id)->first();
|
||
$data = j($_GET['data']);
|
||
|
||
if(!is_null($thisData)) {
|
||
$data['pattern'] = str_replace(".pdf", ".[pP][dD][fF]", $data['pattern']);
|
||
$pattern = $data['pattern'];
|
||
$pattern2 = $data['pattern'];
|
||
foreach($thisData AS $listColumn => $listValue) {
|
||
$listValue = str_replace("/", "*", $listValue);
|
||
$listValue = str_replace(" ", "*", $listValue);
|
||
// $listValue = str_replace("-", "*", $listValue);
|
||
|
||
if($listValue != "") {
|
||
$pattern = str_replace("{". $listColumn ."}", $listValue, $pattern);
|
||
}
|
||
|
||
|
||
}
|
||
foreach($thisData AS $listColumn => $listValue) {
|
||
$listValue = strtolower($listValue);
|
||
$listValue = str_replace("/", "*", $listValue);
|
||
$listValue = str_replace(" ", "*", $listValue);
|
||
// $listValue = str_replace("-", "*", $listValue);
|
||
|
||
if($listValue != "") {
|
||
$pattern2 = str_replace("{". $listColumn ."}", $listValue, $pattern2);
|
||
}
|
||
|
||
}
|
||
|
||
$fullPath = "storage/documents/" . $data['path'] . $pattern;
|
||
$fullPath2 = "storage/documents/" . $data['path'] . $pattern2;
|
||
$search = glob($fullPath, GLOB_BRACE);
|
||
|
||
if(count($search) == 0) {
|
||
$search = glob($fullPath2);
|
||
|
||
}
|
||
|
||
if(isset($search[0])) {
|
||
$url = url($search[0]);
|
||
Cache::put($prefix, $url);
|
||
return $url;
|
||
} else {
|
||
return response([], 404);
|
||
}
|
||
}
|
||
//}
|
||
|
||
|
||
}
|
||
|
||
public function removeJson(Request $request, string $tableName) {
|
||
$u = u();
|
||
$id = $request['module'];
|
||
|
||
$okPermission = false;
|
||
|
||
if(is_null($id))
|
||
{
|
||
$okPermission = true;
|
||
}
|
||
elseif(isAuth($id, "write"))
|
||
{
|
||
$okPermission = true;
|
||
}
|
||
|
||
if($okPermission) {
|
||
$oldData = db($tableName)->where("id", $request['key'])->first();
|
||
|
||
$path = "app/Http/Controllers/DeleteTrigger/$tableName.php";
|
||
|
||
if(file_exists($path)) {
|
||
include($path);
|
||
}
|
||
|
||
return db($tableName)
|
||
->where("id", $request['key'])
|
||
->delete();
|
||
} else {
|
||
return "permission error";
|
||
}
|
||
|
||
}
|
||
|
||
private function trimData($data) {
|
||
$refactoringData = [];
|
||
foreach($data AS $columnName => $columnValue) {
|
||
if (is_null($columnValue) || $columnValue === "") {
|
||
$refactoringData[$columnName] = null;
|
||
continue;
|
||
}
|
||
|
||
// Eğer string ise trim uygula
|
||
if (is_string($columnValue)) {
|
||
$columnValue = trim($columnValue);
|
||
}
|
||
|
||
$columnType = table_column_type($this->currentTable, $columnName);
|
||
$refactoringData[$columnName] = $this->dateColumnFixer($columnName, $columnValue, $columnType);
|
||
}
|
||
return $refactoringData;
|
||
}
|
||
|
||
public function saveJson(Request $request, string $tableName) {
|
||
$this->currentTable = $tableName; // tableName'i sınıf içinde saklıyoruz
|
||
if(!is_array($request['key']))
|
||
{
|
||
$request['key'] = ['id' => $request['key']];
|
||
}
|
||
|
||
$saveAccept = true;
|
||
|
||
if($saveAccept)
|
||
{
|
||
$updateData = $request['values'];
|
||
$refactoringData = $this->trimData($updateData);
|
||
$refactoringData['updated_at'] = Carbon::now();
|
||
|
||
$beforeData = db($tableName)->where($request['key'])->first();
|
||
|
||
try {
|
||
$result = db($tableName)
|
||
->where($request['key'])
|
||
->update($refactoringData);
|
||
|
||
|
||
// Değişiklikleri ColumnComment tablosuna kaydedelim
|
||
if($result) {
|
||
$record_id = isset($request['key']['id']) ? $request['key']['id'] : $beforeData->id;
|
||
|
||
// Her değişiklik için bir kayıt ekleyelim
|
||
foreach($refactoringData as $column => $value) {
|
||
// Bazı sütunları atlayalım (updated_at, created_at, deleted_at)
|
||
if(in_array($column, ['updated_at', 'created_at', 'deleted_at'])) {
|
||
continue;
|
||
}
|
||
|
||
// Önceki değeri alalım
|
||
$oldValue = isset($beforeData->$column) ? $beforeData->$column : null;
|
||
|
||
// Değer değişmişse kaydet
|
||
if($oldValue != $value) {
|
||
ColumnComment::create([
|
||
'table_name' => $tableName,
|
||
'record_id' => $record_id,
|
||
'column_name' => $column,
|
||
'comment' => 'System updated the value',
|
||
'column_value' => $value,
|
||
'user_id' => u()->id,
|
||
'ip_address' => $request->ip()
|
||
]);
|
||
|
||
// Document Revision REV number changed - send notification
|
||
if($tableName == 'document_revisions' && $column == 'revision_no' && $oldValue !== null && $oldValue !== '') {
|
||
$drawingNo = $beforeData->drawing_no ?? 'Unknown';
|
||
$message = sprintf(
|
||
'Document Revision REV changed from %s to %s for Drawing %s. Please update PDF files.',
|
||
$oldValue,
|
||
$value,
|
||
$drawingNo
|
||
);
|
||
$link = "/admin/types/document-revision?id={$record_id}";
|
||
sendNotification('notification_document_revision_changed', $message, $link, 'Document REV Changed');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
} catch (\Throwable $th) {
|
||
$result = $th->getMessage();
|
||
}
|
||
|
||
// SaveTrigger'ı asenkron olarak çalıştır
|
||
ExecuteSaveTriggerJob::dispatch(
|
||
$tableName,
|
||
$request->all(),
|
||
$request['key'],
|
||
$request['values'] ?? null,
|
||
$beforeData,
|
||
"update"
|
||
);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
public function insertJson(Request $request, string $tableName) {
|
||
$this->currentTable = $tableName; // tableName'i sınıf içinde saklıyoruz
|
||
$data = $_POST;
|
||
unset($data['_token']);
|
||
|
||
$refactoringData = $this->trimData($data);
|
||
unset($refactoringData['id']);
|
||
$refactoringData['created_at'] = Carbon::now();
|
||
|
||
$id = db($tableName)->insertGetId($refactoringData);
|
||
|
||
if(isset($id)) {
|
||
$refactoringData['id'] = $id;
|
||
$request['key'] = ['id' => $id]; // Array formatında set et
|
||
|
||
// Yeni eklenen kayıt için ColumnComment ekleyelim
|
||
foreach($refactoringData as $column => $value) {
|
||
// Bazı sütunları atlayalım
|
||
if(in_array($column, ['created_at', 'updated_at', 'deleted_at', 'id'])) {
|
||
continue;
|
||
}
|
||
|
||
// Null olmayan ve boş string olmayan değerler için kayıt oluştur
|
||
if($value !== null && $value !== '') {
|
||
ColumnComment::create([
|
||
'table_name' => $tableName,
|
||
'record_id' => $id,
|
||
'column_name' => $column,
|
||
'comment' => 'System created the record',
|
||
'column_value' => $value,
|
||
'user_id' => u()->id,
|
||
'ip_address' => $request->ip()
|
||
]);
|
||
}
|
||
}
|
||
|
||
$beforeData = db($tableName)->where($request['key'])->first();
|
||
|
||
// SaveTrigger'ı asenkron olarak çalıştır
|
||
ExecuteSaveTriggerJob::dispatch(
|
||
$tableName,
|
||
$request->all(),
|
||
$request['key'],
|
||
$request['values'] ?? null,
|
||
$beforeData,
|
||
"insert"
|
||
);
|
||
}
|
||
|
||
return response()->json(
|
||
($refactoringData),
|
||
200,
|
||
[
|
||
'Content-Type' => 'application/json;charset=UTF-8',
|
||
'Charset' => 'utf-8'
|
||
],
|
||
JSON_UNESCAPED_UNICODE
|
||
);
|
||
|
||
}
|
||
|
||
public function dateColumnFixer($columnName, $columnValue, $columnType) {
|
||
if($columnType == "date") {
|
||
if($columnValue == "") {
|
||
$columnValue = null;
|
||
} else {
|
||
$columnValue = preg_replace('/\(.*$/', '', $columnValue);
|
||
$carbonTarih = Carbon::parse($columnValue);
|
||
$columnValue = $carbonTarih->toDateString();
|
||
|
||
if(rejected_date($columnValue)) {
|
||
$columnValue = null;
|
||
}
|
||
}
|
||
} else {
|
||
//başlangıç tarafında bir tab girişi vs. varsa onu temizliyoruz
|
||
$columnValue = str_replace('\t', '', $columnValue);
|
||
}
|
||
|
||
|
||
|
||
return $columnValue;
|
||
}
|
||
|
||
|
||
private function rawSQLFixer($rawSQL) {
|
||
$replaceData = [
|
||
"AND ()" => "",
|
||
];
|
||
foreach($replaceData AS $from => $to ) {
|
||
$rawSQL = str_replace($from, $to, $rawSQL);
|
||
}
|
||
return $rawSQL;
|
||
}
|
||
private function sortColumnFixer($selector) {
|
||
$replaceData = [
|
||
"{" => "",
|
||
"}" => "",
|
||
];
|
||
foreach($replaceData AS $from => $to ) {
|
||
$selector = str_replace($from, $to, $selector);
|
||
}
|
||
return $selector;
|
||
}
|
||
|
||
public function tableToJson(Request $request, string $tableName) {
|
||
|
||
$_SESSION['module'] = get("module");
|
||
$path = "app/Http/Controllers/CustomQuery/{$_GET['module']}.php";
|
||
|
||
if(file_exists($path)) {
|
||
include($path);
|
||
} else {
|
||
$query = db($tableName);
|
||
}
|
||
|
||
|
||
$u = u();
|
||
if($tableName == "users") {
|
||
$jobDesc = db("job_descriptions")->get()->pluck("title")->toArray();
|
||
$jobDesc[] = null;
|
||
$jobDesc[] = "";
|
||
if(getesit("module","employees")) {
|
||
$query = $query->whereIn("level", ['Welder (Subcontractor)'])->orWhereNull("level");
|
||
}
|
||
|
||
|
||
}
|
||
|
||
if(!getisset("group")) {
|
||
if(getisset("take")) $query = $query->take(get("take"));
|
||
if(getisset("skip")) $query = $query->skip(get("skip"));
|
||
}
|
||
|
||
if(getisset("columns")) {
|
||
$selectColumns = j(get("columns"));
|
||
if(!in_array("id", $selectColumns)) {
|
||
array_unshift($selectColumns, "id");
|
||
}
|
||
$query = $query->select($selectColumns);
|
||
}
|
||
|
||
|
||
if(getisset("sort")) {
|
||
$sortColumns = j($request->sort);
|
||
foreach($sortColumns AS $sortColumn) {
|
||
$sortType = $sortColumn['desc'] == true ? "ASC" : "DESC";
|
||
$sortColumn['selector'] = $this->sortColumnFixer($sortColumn['selector']);
|
||
//dd($sortColumn);
|
||
$query = $query->orderBy($sortColumn['selector'], $sortType);
|
||
}
|
||
} else {
|
||
$query = $query->orderBy("id","DESC");
|
||
}
|
||
|
||
if(getisset("filter")) {
|
||
|
||
$filterColumns = j($request->filter);
|
||
$allFilterValues = [];
|
||
|
||
$rawSQL = FilterHelper::GetSqlExprByArray($filterColumns);
|
||
$rawSQL = $this->rawSQLFixer($rawSQL);
|
||
|
||
$query = $query->whereRaw($rawSQL);
|
||
/*
|
||
if(!is_array($filterColumns[0])) {
|
||
$allFilterValues[$filterColumns[0]][] = $filterColumns[2];
|
||
} else {
|
||
foreach($filterColumns AS $filterColumn) {
|
||
|
||
if(is_array($filterColumn)) {
|
||
$column = $filterColumn[0];
|
||
foreach($filterColumn AS $subFilterColumn) {
|
||
if(is_array($subFilterColumn)) {
|
||
$allFilterValues[$subFilterColumn[0]][] = $subFilterColumn[2];
|
||
} else {
|
||
//dump($filterColumn);
|
||
if(is_array($filterColumn[0])) {
|
||
$allFilterValues[$filterColumn[0][0]][] = $filterColumn[0][2];
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
}
|
||
|
||
} else {
|
||
//dump()
|
||
//$allFilterValues[$filterColumn[0]][] = $filterColumn[2];
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
foreach($allFilterValues AS $column => $values) {
|
||
if($column != null) {
|
||
$query = $query->whereIn($column, $values);
|
||
}
|
||
|
||
}
|
||
*/
|
||
|
||
|
||
}
|
||
|
||
if(isset($_SESSION['select-columns'][$tableName])) {
|
||
$_SESSION['select-columns'][$tableName][] = "id";
|
||
$query->select($_SESSION['select-columns'][$tableName]);
|
||
}
|
||
|
||
if(getisset("group")) {
|
||
$groupColumnToQuery = $this->groupColumnToQuery($request, $query);
|
||
$query = $groupColumnToQuery['query'];
|
||
}
|
||
|
||
|
||
|
||
$query = $query->get();
|
||
|
||
$widthColumn = false;
|
||
if(getisset("with-column")) {
|
||
$widthColumn = true;
|
||
}
|
||
|
||
$result = [];
|
||
|
||
$except = [
|
||
//'created_at',
|
||
//'updated_at'
|
||
];
|
||
if($query->count()>0) {
|
||
if(getisset("group")) {
|
||
|
||
$groupColumns = j($request->group);
|
||
$key = $groupColumnToQuery['selectorName'];
|
||
// $items = $query->pluck($groupColumns[0]['selector'])->toArray();
|
||
$run = true;
|
||
if(getisset("skip")) {
|
||
if(!getesit("skip", "0")) {
|
||
$run = false;
|
||
}
|
||
}
|
||
|
||
if($run) {
|
||
|
||
$result['data'] = [];
|
||
$result['data'][] = [
|
||
'key' => null,
|
||
'count' => 0,
|
||
];
|
||
$added = [];
|
||
foreach($query AS $q) {
|
||
$keyValue = $q->$key;
|
||
|
||
if(strpos($key, "date") !== false) {
|
||
if($q->$key != "") {
|
||
$keyValue = date("Y/m/d", strtotime($q->$key));
|
||
if(!in_array($keyValue, $added)) {
|
||
$result['data'][] = [
|
||
'key' => $keyValue,
|
||
'count' => $q->total,
|
||
];
|
||
$added[] = $keyValue;
|
||
}
|
||
}
|
||
|
||
|
||
} else {
|
||
if(!in_array($keyValue, $added)) {
|
||
$result['data'][] = [
|
||
'key' => $keyValue,
|
||
'items' => null,
|
||
'count' => $q->total,
|
||
];
|
||
$added[] = $keyValue;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
// $result['data']['totalCount'] = db($tableName)->count();
|
||
} else {
|
||
foreach($query AS $q) {
|
||
$data = [];
|
||
if($widthColumn) {
|
||
foreach($except AS $e) {
|
||
unset($q->$e);
|
||
}
|
||
$data = $q;
|
||
} else {
|
||
foreach($q AS $col => $value) {
|
||
if(!in_array($col, $except)) {
|
||
array_push($data, $value);
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
$result['data'][] = $data;
|
||
}
|
||
}
|
||
|
||
} else {
|
||
$result['data'] = [];
|
||
}
|
||
if(getesit("requireTotalCount", true)) {
|
||
$result['totalCount'] = db($tableName)->count();
|
||
}
|
||
|
||
|
||
//$result['data'] = $query;
|
||
|
||
return response()->json(
|
||
($result),
|
||
200,
|
||
[
|
||
'Content-Type' => 'application/json;charset=UTF-8',
|
||
'Charset' => 'utf-8'
|
||
],
|
||
JSON_UNESCAPED_UNICODE
|
||
);
|
||
|
||
}
|
||
|
||
private function groupColumnToQuery(Request $request, $query) {
|
||
$groupColumns = j($request->group);
|
||
$selector = $groupColumns[0]['selector'];
|
||
$selectorName = $selector;
|
||
$query = $query
|
||
->select(
|
||
$selector,
|
||
DB::raw('count(*) as total')
|
||
)
|
||
->groupBy($selector);
|
||
|
||
return [
|
||
'query' => $query,
|
||
'selectorName' => $selectorName,
|
||
];
|
||
}
|
||
|
||
|
||
|
||
public function rowDetail(Request $request, string $tableName, string $columnName) {
|
||
$result = db($tableName);
|
||
|
||
if(!getesit("order", "")) {
|
||
$order = explode(":", get("order"));
|
||
$result = $result->orderBy($order[0], $order[1]);
|
||
}
|
||
|
||
if(is_array($request->value)) {
|
||
$result = $result->whereIn($columnName, $request->value)->get();
|
||
} else {
|
||
if(getisset("nolike")) {
|
||
$result = $result->where($columnName, $request->value)->first();
|
||
} else {
|
||
$result = $result->where($columnName, "LIKE", "%" . $request->value . "%")->first();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
return response()->json(
|
||
($result),
|
||
200,
|
||
[
|
||
'Content-Type' => 'application/json;charset=UTF-8',
|
||
'Charset' => 'utf-8'
|
||
],
|
||
JSON_UNESCAPED_UNICODE
|
||
);
|
||
|
||
}
|
||
|
||
public function getDetail(Request $request, string $tableName, string $columnName, string $value) {
|
||
$result = db($tableName);
|
||
|
||
$result = $result->where($columnName, $value)->get();
|
||
|
||
return response()->json(
|
||
($result),
|
||
200,
|
||
[
|
||
'Content-Type' => 'application/json;charset=UTF-8',
|
||
'Charset' => 'utf-8'
|
||
],
|
||
JSON_UNESCAPED_UNICODE
|
||
);
|
||
|
||
}
|
||
|
||
|
||
public function create(Request $request, string $tableName) {
|
||
$post = $request->all();
|
||
unset($post['_token']);
|
||
db($tableName)->insert($post);
|
||
|
||
return redirect()->back();
|
||
}
|
||
|
||
public function default(Request $request,string $type="",string $id="" )
|
||
{
|
||
$this->middleware('auth');
|
||
$p = $request -> all();
|
||
$contents = Contents::where("kid","main")
|
||
->orderBy("s","ASC") // s alanı sıralama alanıdır.
|
||
->get(); // tüm içeriklerdeki ana içerikler gelecek
|
||
$types = Types::orderBy("id","DESC")->get(); // tüm tipler
|
||
$alt = null;
|
||
$fields = null;
|
||
$content_fields = null;
|
||
$c = null;
|
||
$j = null;
|
||
$breadcrumb = null;
|
||
$ust = null;
|
||
$q = null;
|
||
$search_contents = null;
|
||
$seviye = null;
|
||
$users = null;
|
||
if(oturumisset("miktar")) {
|
||
$miktar = oturum("miktar");
|
||
} else {
|
||
$miktar = 10;
|
||
}
|
||
if(isset($p['m'])) {
|
||
$miktar = $p['m'];
|
||
oturum("miktar",$p['m']);
|
||
}
|
||
switch($type) {
|
||
case "users" :
|
||
|
||
break;
|
||
case "search" :
|
||
|
||
$q = $p['q'];
|
||
|
||
$searchFields = ['title','html','json','tkid','kid','type'];
|
||
$search_contents = Contents::where(function($query) use($request, $searchFields){
|
||
$searchWildcard = '%' . $request->q . '%';
|
||
foreach($searchFields as $field){
|
||
$query->orWhere($field, 'LIKE', $searchWildcard);
|
||
}
|
||
})
|
||
->get();
|
||
break;
|
||
//ilgili type ın ne olduğuna bakmak gerekli
|
||
case "types":
|
||
$c = Types::where("slug",$id)->first();
|
||
if(!$c) yonlendir("/admin");
|
||
if(isset($p['q'])) {
|
||
|
||
}
|
||
$q = get("q");
|
||
$searchFields = ['title','html','json','tkid','kid','breadcrumb'];
|
||
$alt = Contents::where("type",$c->title)
|
||
->where(function($query) use($request, $searchFields){
|
||
$searchWildcard = '%' . $request->q . '%';
|
||
foreach($searchFields as $field){
|
||
$query->orWhere($field, 'LIKE', $searchWildcard);
|
||
}
|
||
})
|
||
|
||
->orderBy("id","DESC")
|
||
->simplePaginate($miktar);;
|
||
break;
|
||
case "contents":
|
||
//content alanında çalışacak şeyler öncelikle ilgili itemin içeriği ve onun alt içerikleri
|
||
if($id=="") $view = "index";
|
||
else {
|
||
$c = Contents::where("slug",$id)->orWhere("id",$id)->first();
|
||
if($c->kid!="") {
|
||
$breadcrumb = Contents::getBreadcrumbs($c->kid);
|
||
$tree = Contents::getTree($id);
|
||
$breadcrumb2 = Contents::getBreadcrumbs($id,"{title} / ");
|
||
}else {
|
||
$breadcrumb = "";
|
||
$tree = "";
|
||
$breadcrumb2 = "";
|
||
}
|
||
|
||
$ust = Contents::where("slug",$c->kid)->first();
|
||
$j = @json_decode($c->json,true);
|
||
$alt = Contents::where("kid",$id)->orWhere("kid",$c->slug)->orderBy("s","ASC")->simplePaginate($miktar);
|
||
if($c->type!="") {
|
||
$ct = Types::where("title",$c->type)->first(); // content type
|
||
$content_type = $ct ? explode(",",$ct->fields) : [];
|
||
}
|
||
if($c->tkid=="") {
|
||
DB::table("contents")
|
||
->where('id', $id)
|
||
->update([
|
||
'tkid' => json_encode($tree),
|
||
'breadcrumb' => $breadcrumb2
|
||
]);
|
||
|
||
}
|
||
if($c->type!="") {
|
||
$fields = Fields::get();
|
||
$fields = json_decode($fields,true);
|
||
$fields2 = array();
|
||
|
||
//burada ilgili içerik tipine ait alanların değerleri ve tip sistemini alıyoruz. Bunu dinamik form sisteminde kullanacağız
|
||
foreach(@$fields AS $r) {
|
||
if(in_array($r['title'],$content_type)) {
|
||
$fields2[$r['title']] = array(
|
||
"values" => explode(",",$r['values']),
|
||
"type" => $r['input_type']
|
||
);
|
||
}
|
||
|
||
}
|
||
$fields = $fields2;
|
||
if(isset($ct->fields)) {
|
||
$content_fields = explode(",",$ct->fields); // içerik alanları
|
||
}
|
||
}
|
||
} // if
|
||
|
||
|
||
|
||
|
||
break;
|
||
|
||
//bir içerik tipine ait olan alanların input type larının tutulduğu bir tablo bu sistem types tablosuna girilen fieldsları otomatik oluşturuyor.
|
||
case "fields" :
|
||
//input_type alanı boş olanları silelim
|
||
Fields::where('input_type', '=', '')
|
||
->orWhereNull('input_type')
|
||
->delete();
|
||
|
||
//tekrar oluşturalım tüm alanları
|
||
foreach($types AS $t) {
|
||
$fields = explode(",",$t->fields);
|
||
foreach($fields AS $r) {
|
||
$r = trim($r);
|
||
$c = Fields::where("title",$r)->first();
|
||
|
||
if($r!="") {
|
||
if($c == "") {
|
||
$row = new Fields();
|
||
$row->title = $r;
|
||
$row->type = $t->title;
|
||
$row->save();
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
$fields = Fields::get();
|
||
break;
|
||
default:
|
||
$alt = null;
|
||
$c = null;
|
||
break;
|
||
|
||
}
|
||
|
||
//eğer anasayfa geldi ise index gelmedi ise default
|
||
if($id=="" || $id=="index") {
|
||
$view = "index";
|
||
} else {
|
||
$view = "default";
|
||
}
|
||
|
||
//tüm değişkenleri bir dizi olarak aktarıyoruz gönderdiklerimiz mutlaka tanımlanmış olmalı ondan dolayı bazılarında null tanımını verdim yukarıda
|
||
$var = [
|
||
'q' => $q,
|
||
'miktar' => $miktar,
|
||
'type' => $type,
|
||
'users' => $users,
|
||
'seviye' => $seviye,
|
||
'breadcrumb' => $breadcrumb,
|
||
'search_contents' => $search_contents,
|
||
'content_fields' => $content_fields,
|
||
'fields' => $fields,
|
||
'alt' => $alt,
|
||
'id' => $id,
|
||
'c' => $c,
|
||
'ust' => $ust,
|
||
'j' => $j,
|
||
'contents' => $contents,
|
||
"types" => $types
|
||
];
|
||
//try catch hayat kurtarır. Adminde ilgili tipdeki blade lere yönlendiriir yoksa default veya indexe yönlendirir.
|
||
$permissions = userPermissions(); //explode(",",Auth::user()->permissions);
|
||
$permissions2 = array();
|
||
foreach($permissions AS $p) {
|
||
array_push($permissions2,str_slug($p));
|
||
}
|
||
$permissions = $permissions2;
|
||
|
||
if($type=="types") {
|
||
$alan = $id;
|
||
} else {
|
||
$alan = $type;
|
||
}
|
||
|
||
|
||
if($alan=="" && $id!="") {
|
||
|
||
return view('admin/'.$view, $var);
|
||
} else {
|
||
try {
|
||
//echo "$view $type $alan";
|
||
if(($view=="index") && $type=="") {
|
||
|
||
return view('admin/'.$view, $var);
|
||
} else {
|
||
|
||
if(in_array("all-privileges",$permissions)) { // Tüm yetkiler
|
||
return view("admin/$type",$var);
|
||
} else {
|
||
if($id != "devextreme")
|
||
{
|
||
return view("admin/$type",$var);
|
||
}
|
||
else
|
||
{
|
||
if(isAuth($id,"read")) {
|
||
|
||
return view("admin/$type",$var);
|
||
|
||
|
||
} else {
|
||
return view("admin/yetki-yok",$var);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
}
|
||
|
||
} catch (\Exception $e) {
|
||
|
||
return view('admin/'.$view, $var);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
|
||
/**
|
||
* User Guide functionality for module documentation
|
||
*/
|
||
public function userGuide($module = null)
|
||
{
|
||
// Tüm logic view içinde yapılıyor
|
||
return view('admin.user-guide');
|
||
}
|
||
|
||
/**
|
||
* Clone row functionality - includes table-specific logic
|
||
*/
|
||
public function cloneRow(Request $request, string $tableName)
|
||
{
|
||
$u = u();
|
||
if(!isset($u->level)) {
|
||
echo("permission error");
|
||
exit();
|
||
}
|
||
|
||
$data = j(post("data"));
|
||
$originalId = $data['id']; // Orijinal kaydın ID'sini saklayalım
|
||
unset($data['id']);
|
||
|
||
// Table-specific clone logic
|
||
$path = "app/Http/Controllers/CloneTrigger/{$tableName}.php";
|
||
if(file_exists($path)) {
|
||
$table = $tableName; // CloneTrigger dosyaları için $table değişkenini tanımla
|
||
include($path);
|
||
}
|
||
|
||
$data['created_at'] = Carbon::now();
|
||
|
||
try {
|
||
// Kaydı ekleyelim ve yeni ID'yi alalım
|
||
$newId = db($tableName)->insertGetId($data);
|
||
|
||
if($newId) {
|
||
// Klonlanan her alan için ColumnComment kaydı oluşturalım
|
||
foreach($data as $column => $value) {
|
||
// Bazı sütunları atlayalım
|
||
if(in_array($column, ['created_at', 'updated_at', 'deleted_at'])) {
|
||
continue;
|
||
}
|
||
|
||
// Null olmayan ve boş string olmayan değerler için kayıt oluştur
|
||
if($value !== null && $value !== '') {
|
||
ColumnComment::create([
|
||
'table_name' => $tableName,
|
||
'record_id' => $newId,
|
||
'column_name' => $column,
|
||
'comment' => "Cloned from record #$originalId",
|
||
'column_value' => $value,
|
||
'user_id' => Auth::id(),
|
||
'ip_address' => request()->ip()
|
||
]);
|
||
}
|
||
}
|
||
|
||
// Save trigger'larını çalıştırmak için gerekli değişkenleri oluştur
|
||
$beforeData = db($tableName)->where("id", $newId)->first();
|
||
$request = new \Illuminate\Http\Request();
|
||
$request['key'] = ['id' => $newId];
|
||
$request['values'] = $data;
|
||
$request['new_record'] = true;
|
||
|
||
// SaveTrigger'ı asenkron olarak çalıştır
|
||
$job = ExecuteSaveTriggerJob::dispatch(
|
||
$tableName,
|
||
$request->all(),
|
||
$request['key'],
|
||
$request['values'],
|
||
$beforeData,
|
||
"clone"
|
||
);
|
||
}
|
||
} catch (\Throwable $th) {
|
||
dump($th);
|
||
Log::error("$tableName Clone row error:" . $th->getMessage());
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get unique column values for headerFilter
|
||
* Returns all distinct values from a specific column
|
||
*/
|
||
public function getUniqueColumnValues(Request $request, string $tableName, string $columnName) {
|
||
try {
|
||
// Get unique values from column
|
||
$uniqueValues = DB::table($tableName)
|
||
->select($columnName)
|
||
->distinct()
|
||
->whereNotNull($columnName)
|
||
->where($columnName, '!=', '')
|
||
->orderBy($columnName)
|
||
->pluck($columnName)
|
||
->toArray();
|
||
|
||
// Check if column has empty values
|
||
$hasEmpty = DB::table($tableName)
|
||
->where(function($query) use ($columnName) {
|
||
$query->whereNull($columnName)
|
||
->orWhere($columnName, '=', '');
|
||
})
|
||
->exists();
|
||
|
||
// Build result array
|
||
$result = array_map(function($value) {
|
||
return [
|
||
'text' => $value,
|
||
'value' => $value
|
||
];
|
||
}, $uniqueValues);
|
||
|
||
// Add empty option if exists
|
||
if ($hasEmpty) {
|
||
array_unshift($result, [
|
||
'text' => '(Boş)',
|
||
'value' => null
|
||
]);
|
||
}
|
||
|
||
return response()->json($result);
|
||
|
||
} catch (\Exception $e) {
|
||
Log::error("Get unique column values error: " . $e->getMessage());
|
||
return response()->json(['error' => $e->getMessage()], 500);
|
||
}
|
||
}
|
||
}
|