450 lines
14 KiB
PHP
450 lines
14 KiB
PHP
<?php
|
|
|
|
namespace Lucent\Http\Controller;
|
|
|
|
use Carbon\Carbon;
|
|
use Illuminate\Http\Request;
|
|
use Lucent\Account\AccountService;
|
|
use Lucent\Channel\ChannelService;
|
|
use Lucent\Core\Auth\AuthModule;
|
|
use Lucent\Core\Data\RecordField;
|
|
use Lucent\Core\Repository\SchemaRepo;
|
|
use Lucent\Id\Id;
|
|
use Lucent\LucentException;
|
|
use Lucent\Query\Operator\OperatorRegistry;
|
|
use Lucent\Query\Query;
|
|
use Lucent\Record\InputData\EdgeInputData;
|
|
use Lucent\Record\InputData\RecordInputData;
|
|
use Lucent\Record\Manager;
|
|
use Lucent\Core\Repository\RecordRepo;
|
|
use Lucent\Record\RecordService;
|
|
use Lucent\Record\Status;
|
|
use Lucent\Schema\Ui\Reference;
|
|
use Lucent\Schema\Validator\ValidatorException;
|
|
use Lucent\Svelte\Svelte;
|
|
use Lucent\ViewModel\ViewModel;
|
|
use Lucent\Core\Data\Record;
|
|
use function Lucent\Response\fail;
|
|
use function Lucent\Response\ok;
|
|
|
|
class RecordController
|
|
{
|
|
public function __construct(
|
|
private readonly RecordService $recordService,
|
|
private readonly AccountService $accountService,
|
|
private readonly ChannelService $channelService,
|
|
private readonly Svelte $svelte,
|
|
private readonly Query $query,
|
|
private readonly Manager $recordManager,
|
|
private readonly OperatorRegistry $operatorRegistry,
|
|
private readonly ViewModel $viewModel,
|
|
) {}
|
|
|
|
public function index(Request $request)
|
|
{
|
|
$schemaId = $request->route("id");
|
|
$schemas = SchemaRepo::all();
|
|
$schema = collect($schemas)->firstWhere("id", $schemaId);
|
|
// $users = $this->accountService->all();
|
|
$users = [];
|
|
// $schema = $this->channelService->getSchema($schemaName)->get();
|
|
// $urlParams = $request->all();
|
|
// $sort = data_get($urlParams, "sort") ?? $schema->sortBy;
|
|
// $filter = data_get($urlParams, "filter") ?? [];
|
|
|
|
// $arguments = array_merge(
|
|
// [
|
|
// "schema" => $schema->name,
|
|
// "status_in" => "draft,published",
|
|
// ],
|
|
// $filter,
|
|
// );
|
|
|
|
// $skip = data_get($urlParams, "skip") ?? 0;
|
|
$skip = 0;
|
|
$limit = 30;
|
|
$records = [];
|
|
// $graphArray = null;
|
|
|
|
// $graph = $this->query
|
|
// ->filter($arguments)
|
|
// ->notLinked($request->input("notlinked") ?? "")
|
|
// ->limit($limit)
|
|
// ->status(explode(",", $arguments["status_in"]))
|
|
// ->skip($skip)
|
|
// ->sort($sort)
|
|
// ->childrenFields($schema?->visible ?? [])
|
|
// ->childrenDepth(1)
|
|
// ->parentsDepth(0)
|
|
// ->runWithCount();
|
|
|
|
// $records = $graph->getRootRecords()->toArray();
|
|
|
|
$data = [
|
|
"schemas" => $schemas,
|
|
"schema" => $schema,
|
|
"users" => $users,
|
|
"records" => $records,
|
|
// "graph" => toArray($graph),
|
|
// "systemFields" => array_values(System::list()),
|
|
// "operators" => $this->operatorRegistry->all(),
|
|
// "sortParam" => $sort,
|
|
// "sortField" => $schema->fields
|
|
// ->merge(array_values(System::list()))
|
|
// ->firstWhere(
|
|
// fn($field) => $field->name === $sort ||
|
|
// "-" . $field->name === $sort ||
|
|
// "data." . $field->name === $sort ||
|
|
// "-data." . $field->name === $sort,
|
|
// ),
|
|
// "limit" => $limit,
|
|
// "skip" => $skip,
|
|
// "total" => $graph->total ?? 0,
|
|
// "filter" => $request->input("filter") ?? [],
|
|
// "inModal" => true,
|
|
// "isWritable" => in_array(
|
|
// $schemaName,
|
|
// $this->accountService->currentWritableSchemas(),
|
|
// ),
|
|
];
|
|
|
|
// if ($request->ajax()) {
|
|
// $data["modalUrl"] = $request->fullUrl();
|
|
// if (str_starts_with(config("lucent.url"), "https")) {
|
|
// $data["modalUrl"] = str_replace(
|
|
// "http://",
|
|
// "https://",
|
|
// $request->fullUrl(),
|
|
// );
|
|
// }
|
|
// return $data;
|
|
// }
|
|
// $data["inModal"] = false;
|
|
return Svelte::view(
|
|
view: "contentIndex",
|
|
title: "Records",
|
|
data: $data,
|
|
);
|
|
}
|
|
|
|
public function exportCSV(Request $request)
|
|
{
|
|
$schemaName = $request->route("schemaName");
|
|
$schema = $this->channelService->channel->schemas
|
|
->where("name", $schemaName)
|
|
->first();
|
|
|
|
$urlParams = $request->all();
|
|
|
|
$sort = data_get($urlParams, "sort") ?? "-_sys.updatedAt";
|
|
$filter = data_get($urlParams, "filter") ?? [];
|
|
$arguments = array_merge(
|
|
[
|
|
"schema" => $schema->name,
|
|
"status_in" => "draft,published",
|
|
],
|
|
$filter,
|
|
);
|
|
|
|
$records = $this->query
|
|
->filter($arguments)
|
|
->limit(-1)
|
|
->status(explode(",", $arguments["status_in"]))
|
|
->childrenDepth(1)
|
|
// ->skip($skip)
|
|
->sort($sort)
|
|
->run()
|
|
->tree();
|
|
|
|
header("Content-Type: application/csv");
|
|
header(
|
|
'Content-Disposition: attachment; filename="' .
|
|
$schemaName .
|
|
'.csv";',
|
|
);
|
|
$handle = fopen("php://output", "w");
|
|
$relationColumns = $this->makeCsvRelationColumns($schema);
|
|
$csvRow = [
|
|
"id",
|
|
...array_keys($records[0]->data->toArray()),
|
|
...$relationColumns,
|
|
];
|
|
fputcsv($handle, $csvRow, ",");
|
|
foreach ($records as $record) {
|
|
$csvRow = [$record->id, ...$record->data->toArray()];
|
|
$csvRow = array_merge(
|
|
$csvRow,
|
|
$this->makeCsvRelationColumnValues($schema, $record->_children),
|
|
);
|
|
$csvRow = array_values($csvRow);
|
|
fputcsv($handle, $csvRow, ",");
|
|
}
|
|
fclose($handle);
|
|
echo $handle;
|
|
exit();
|
|
}
|
|
|
|
private function makeCsvRelationColumns($schema): array
|
|
{
|
|
return $schema->fields
|
|
->filter(fn($f) => get_class($f) === Reference::class)
|
|
->reduce(function ($c, $f) {
|
|
$c[] = $f->name . " id";
|
|
$c[] = $f->name . " name";
|
|
return $c;
|
|
}, []);
|
|
}
|
|
|
|
private function makeCsvRelationColumnValues($schema, $children): array
|
|
{
|
|
return $schema->fields
|
|
->filter(fn($f) => get_class($f) === Reference::class)
|
|
->reduce(function ($c, $f) use ($children) {
|
|
$fieldRecords = data_get($children, $f->name);
|
|
if (empty($fieldRecords)) {
|
|
$c[] = "";
|
|
$c[] = "";
|
|
} elseif (count($fieldRecords) === 1) {
|
|
$c[] = data_get($fieldRecords, "0.id");
|
|
$c[] = $this->viewModel->getRecordName($fieldRecords[0]);
|
|
} else {
|
|
$c[] = collect($fieldRecords)->pluck("id")->join("::");
|
|
$c[] = collect($fieldRecords)
|
|
->pluck("data.name")
|
|
->join("::");
|
|
}
|
|
return $c;
|
|
}, []);
|
|
}
|
|
|
|
public function edit(Request $request)
|
|
{
|
|
$rid = $request->route("rid");
|
|
|
|
$graph = $this->query
|
|
->filter(["id" => $rid])
|
|
->limit(1)
|
|
->skip(0)
|
|
->childrenDepth(2)
|
|
->childrenLimit(200)
|
|
->parentsDepth(1)
|
|
->parentsLimit(200)
|
|
->run();
|
|
|
|
if ($graph->records->isEmpty()) {
|
|
return $this->svelte->render(
|
|
layout: "channel",
|
|
view: "recordNotFound",
|
|
title: "Record Not Found",
|
|
);
|
|
}
|
|
|
|
$record = $graph->records->first();
|
|
|
|
if (
|
|
!in_array(
|
|
$record->schema,
|
|
$this->accountService->currentReadableSchemas(),
|
|
)
|
|
) {
|
|
return $this->svelte->render(
|
|
layout: "channel",
|
|
view: "recordNotFound",
|
|
title: "Schema Not Found",
|
|
);
|
|
}
|
|
|
|
$schema = $this->channelService->getSchema($record->schema)->get();
|
|
$recordHistory = $this->recordManager
|
|
->fromSession($request->session())
|
|
->push($rid)
|
|
->getRecords($rid);
|
|
return $this->svelte->render(
|
|
layout: "channel",
|
|
view: "recordEdit",
|
|
title: "Edit Record",
|
|
data: [
|
|
"schema" => $schema,
|
|
"graph" => toArray($graph),
|
|
"record" => toArray($record),
|
|
"users" => $this->accountService->all(),
|
|
"recordHistory" => $recordHistory,
|
|
"isWritable" => in_array(
|
|
$record->schema,
|
|
$this->accountService->currentWritableSchemas(),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
public function suggestions(Request $request)
|
|
{
|
|
$arguments = [
|
|
"schema" => $request->input("schema"),
|
|
];
|
|
|
|
if ($request->input("value")) {
|
|
if (in_array($request->input("ui"), ["text", "date"])) {
|
|
$arguments[
|
|
"data." . $request->input("field") . "_regex"
|
|
] = $request->input("value");
|
|
} elseif ($request->input("ui") == "number") {
|
|
$arguments[
|
|
"data." . $request->input("field") . "_eqnum"
|
|
] = floatval($request->input("value"));
|
|
} elseif ($request->input("ui") == "date") {
|
|
} elseif ($request->input("ui") == "search") {
|
|
$arguments["search_regex"] = $request->input("value");
|
|
}
|
|
}
|
|
|
|
$records = $this->query->filter($arguments)->limit(10)->tree();
|
|
|
|
if ($records->isEmpty()) {
|
|
return ok([]);
|
|
}
|
|
|
|
return ok($records->toArray());
|
|
}
|
|
|
|
public function postCreate(Request $request)
|
|
{
|
|
$schemaId = $request->input("schemaId");
|
|
$title = $request->input("title");
|
|
$now = Carbon::now();
|
|
$userId = AuthModule::getCurrentUserId();
|
|
|
|
$titleField = new RecordField(
|
|
id: "_title",
|
|
locale: "main",
|
|
value: $title,
|
|
createdAt: $now,
|
|
createdBy: $userId,
|
|
updatedAt: $now,
|
|
updatedBy: $userId,
|
|
version: 1,
|
|
);
|
|
|
|
$record = new Record(
|
|
id: Id::new(),
|
|
schemaId: $schemaId,
|
|
draftData: [$titleField],
|
|
liveData: [],
|
|
createdAt: $now,
|
|
createdBy: $userId,
|
|
publishedAt: null,
|
|
publishedBy: null,
|
|
trashedAt: null,
|
|
trashedBy: null,
|
|
);
|
|
|
|
RecordRepo::insert($record);
|
|
return ok(toArray($record));
|
|
}
|
|
|
|
public function save(Request $request)
|
|
{
|
|
$recordId = $request->input("record.id");
|
|
try {
|
|
if ($request->input("isCreateMode")) {
|
|
$recordId = $this->recordService->create(
|
|
data: new RecordInputData(
|
|
$request->input("record.schema"),
|
|
$recordId ?? "",
|
|
$request->input("record.data"),
|
|
Status::from($request->input("record.status")),
|
|
),
|
|
edges: array_map(
|
|
EdgeInputData::fromArray(...),
|
|
$request->input("edges") ?? [],
|
|
),
|
|
);
|
|
} else {
|
|
$this->recordService->updateWithEdges(
|
|
id: $request->input("record.id"),
|
|
data: $request->input("record.data"),
|
|
status: Status::from($request->input("record.status")),
|
|
edges: array_map(
|
|
EdgeInputData::fromArray(...),
|
|
$request->input("edges") ?? [],
|
|
),
|
|
);
|
|
}
|
|
|
|
$newGraph = $this->query
|
|
->filter(["id" => $recordId])
|
|
->limit(10)
|
|
->childrenDepth(1)
|
|
->parentsDepth(1)
|
|
->run();
|
|
} catch (ValidatorException $th) {
|
|
return fail($th->getValidatorErrors());
|
|
} catch (LucentException $th) {
|
|
return fail($th);
|
|
}
|
|
return ok(toArray($newGraph));
|
|
}
|
|
|
|
public function clone(Request $request)
|
|
{
|
|
try {
|
|
$newRecordId = $this->recordService->clone(
|
|
recordId: $request->route("rid"),
|
|
);
|
|
} catch (LucentException $th) {
|
|
return fail($th);
|
|
} catch (ValidatorException $e) {
|
|
return fail($e);
|
|
}
|
|
return ok(["id" => $newRecordId]);
|
|
}
|
|
|
|
public function status(Request $request)
|
|
{
|
|
$ids = array_map(fn($rec) => $rec["id"], $request->input("records"));
|
|
|
|
$this->recordService->changeStatusBulk(
|
|
status: $request->route("status"),
|
|
recordsIds: $ids,
|
|
);
|
|
return ok();
|
|
}
|
|
|
|
public function emptyTrash(Request $request)
|
|
{
|
|
$this->recordService->emptyTrash($request->route("schemaName"));
|
|
return redirect(
|
|
$this->channelService->channel->lucentUrl .
|
|
"/content/" .
|
|
$request->route("schemaName"),
|
|
);
|
|
}
|
|
|
|
public function delete(Request $request)
|
|
{
|
|
$ids = $request->input("ids");
|
|
|
|
try {
|
|
$this->recordService->deleteMany($ids);
|
|
} catch (Throwable $th) {
|
|
return fail($th);
|
|
}
|
|
return ok();
|
|
}
|
|
|
|
public function rollback(Request $request)
|
|
{
|
|
try {
|
|
$this->recordService->rollback(
|
|
recordId: $request->route("rid"),
|
|
version: (int) $request->route("version"),
|
|
);
|
|
} catch (ValidatorException $th) {
|
|
return fail($th->getFirstValidatorError());
|
|
} catch (LucentException | Throwable $th) {
|
|
return fail($th);
|
|
}
|
|
return ok();
|
|
}
|
|
}
|