56665cd77a
Perubahan yang dilakukan: - Menambahkan pengecekan tipe request multi_account pada PrintStatementController. - Menambahkan logika unduhan file zip melalui metode downloadMultiAccountZip(). - Memastikan alur unduhan file zip tidak mengganggu proses unduhan statement untuk tipe lainnya. Tujuan perubahan: - Mendukung fitur baru untuk mengunduh file zip pada permintaan multi_account. - Menjaga kompatibilitas dengan alur unduhan statement yang sudah ada.
1562 lines
65 KiB
PHP
1562 lines
65 KiB
PHP
<?php
|
|
|
|
namespace Modules\Webstatement\Http\Controllers;
|
|
|
|
use App\Http\Controllers\Controller;
|
|
use Carbon\Carbon;
|
|
use Exception;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Support\Facades\{Auth, DB, Log, Mail, Storage};
|
|
use Illuminate\Validation\Rule;
|
|
use Modules\Basicdata\Models\Branch;
|
|
use Modules\Webstatement\Http\Requests\PrintStatementRequest;
|
|
use Modules\Webstatement\Jobs\{ExportStatementPeriodJob, GenerateMultiAccountPdfJob};
|
|
use Modules\Webstatement\Mail\StatementEmail;
|
|
use Modules\Webstatement\Models\{Account, AccountBalance, PrintStatementLog, ProcessedStatement};
|
|
use Spatie\Browsershot\Browsershot;
|
|
use ZipArchive;
|
|
ini_set('memory_limit', '2G'); // Atau '1G' untuk data yang sangat besar
|
|
ini_set('max_execution_time', 300000);
|
|
|
|
class PrintStatementController extends Controller
|
|
{
|
|
/**
|
|
* Display a listing of the statements.
|
|
*/
|
|
public function index(Request $request)
|
|
{
|
|
$branches = Branch::whereNotNull('customer_company')
|
|
->where('code', '!=', 'ID0019999')
|
|
->orderBy('name')
|
|
->get();
|
|
|
|
$branch = Branch::find(Auth::user()->branch_id);
|
|
$multiBranch = session('MULTI_BRANCH') ?? false;
|
|
|
|
return view('webstatement::statements.index', compact('branches', 'branch', 'multiBranch'));
|
|
}
|
|
|
|
/**
|
|
* Store a newly created statement request.
|
|
* Menangani pembuatan request statement baru dengan logging dan transaksi database
|
|
*/
|
|
public function store(PrintStatementRequest $request)
|
|
{
|
|
// Add account verification before storing
|
|
$accountNumber = $request->input('account_number'); // Assuming this is the field name for account number
|
|
// First, check if the account exists and get branch information
|
|
$request_type = "single_account";
|
|
if($request->input('branch_code') && !empty($request->input('stmt_sent_type'))){
|
|
$request_type = 'multi_account'; // Default untuk request manual
|
|
}
|
|
|
|
if($request_type=='single_account'){
|
|
$account = Account::where('account_number', $accountNumber)->first();
|
|
if ($account) {
|
|
$branch_code = $account->branch_code;
|
|
$userBranchId = session('branch_id'); // Assuming branch ID is stored in session
|
|
$multiBranch = session('MULTI_BRANCH');
|
|
|
|
if (!$multiBranch) {
|
|
// Check if account branch matches user's branch
|
|
if ($account->branch_id !== $userBranchId) {
|
|
return redirect()->route('statements.index')
|
|
->with('error', 'Nomor rekening tidak sesuai dengan cabang Anda. Transaksi tidak dapat dilanjutkan.');
|
|
}
|
|
}
|
|
|
|
// Check if account belongs to restricted branch ID0019999
|
|
if ($account->branch_id === 'ID0019999') {
|
|
return redirect()->route('statements.index')
|
|
->with('error', 'Nomor rekening terdaftar pada cabang khusus. Silakan hubungi bagian HC untuk informasi lebih lanjut.');
|
|
}
|
|
|
|
// If all checks pass, proceed with storing data
|
|
// Your existing store logic here
|
|
|
|
} else {
|
|
// Account not found
|
|
return redirect()->route('statements.index')
|
|
->with('error', 'Nomor rekening tidak ditemukan dalam sistem.');
|
|
}
|
|
} else {
|
|
if($request->input('branch_code')=== 'ID0019999') {
|
|
return redirect()->route('statements.index')
|
|
->with('error', 'tidak dapat dilakukan print statement unruk cabang khusus. Silakan hubungi bagian HC untuk informasi lebih lanjut.');
|
|
}
|
|
}
|
|
|
|
DB::beginTransaction();
|
|
|
|
try {
|
|
$validated = $request->validated();
|
|
|
|
$validated['request_type'] = 'single_account'; // Default untuk request manual
|
|
if($validated['branch_code'] && !empty($validated['stmt_sent_type'])){
|
|
$validated['request_type'] = 'multi_account'; // Default untuk request manual
|
|
}
|
|
|
|
// Add user tracking data dan field baru untuk single account request
|
|
$validated['user_id'] = Auth::id();
|
|
$validated['created_by'] = Auth::id();
|
|
$validated['ip_address'] = $request->ip();
|
|
$validated['user_agent'] = $request->userAgent();
|
|
|
|
$validated['status'] = 'pending'; // Status awal
|
|
$validated['authorization_status'] = 'approved'; // Status otorisasi awal
|
|
$validated['total_accounts'] = 1; // Untuk single account
|
|
$validated['processed_accounts'] = 0;
|
|
$validated['success_count'] = 0;
|
|
$validated['failed_count'] = 0;
|
|
$validated['stmt_sent_type'] = $request->input('stmt_sent_type') ? implode(",",$request->input('stmt_sent_type')) : '';
|
|
$validated['branch_code'] = $validated['branch_code'] ?? $branch_code; // Awal tidak tersedia
|
|
$validated['password'] = $request->input('password') ?? '';
|
|
// Create the statement log
|
|
$statement = PrintStatementLog::create($validated);
|
|
|
|
// Log aktivitas
|
|
Log::info('Statement request created', [
|
|
'statement_id' => $statement->id,
|
|
'user_id' => Auth::id(),
|
|
'account_number' => $statement->account_number,
|
|
'request_type' => $statement->request_type
|
|
]);
|
|
|
|
// Process statement availability check
|
|
$this->checkStatementAvailability($statement);
|
|
if(!$statement->is_available){
|
|
$this->printStatementRekening($statement);
|
|
}
|
|
|
|
//if($statement->email){
|
|
// $this->sendEmail($statement->id);
|
|
//}
|
|
DB::commit();
|
|
|
|
return redirect()->route('statements.index')
|
|
->with('success', 'Statement request has been created successfully.');
|
|
} catch (Exception $e) {
|
|
DB::rollBack();
|
|
|
|
Log::error('Failed to create statement request', [
|
|
'error' => $e->getMessage(),
|
|
'user_id' => Auth::id()
|
|
]);
|
|
|
|
return redirect()->back()
|
|
->withInput()
|
|
->with('error', 'Failed to create statement request: ' . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Show the form for creating a new statement request.
|
|
*/
|
|
public function create()
|
|
{
|
|
$branches = Branch::orderBy('name')->get();
|
|
return view('webstatement::statements.create', compact('branches'));
|
|
}
|
|
|
|
/**
|
|
* Check if the statement is available in the system.
|
|
* Memperbarui status availability dengan logging
|
|
*/
|
|
protected function checkStatementAvailability(PrintStatementLog $statement)
|
|
{
|
|
DB::beginTransaction();
|
|
|
|
try {
|
|
$disk = Storage::disk('sftpStatement');
|
|
$filePath = "{$statement->period_from}/{$statement->branch_code}/{$statement->account_number}_{$statement->period_from}.pdf";
|
|
|
|
// Log untuk debugging
|
|
Log::info('Checking SFTP file path', [
|
|
'file_path' => $filePath,
|
|
'sftp_root' => config('filesystems.disks.sftpStatement.root'),
|
|
'full_path' => config('filesystems.disks.sftpStatement.root') . '/' . $filePath
|
|
]);
|
|
|
|
if ($statement->is_period_range && $statement->period_to) {
|
|
$periodFrom = Carbon::createFromFormat('Ym', $statement->period_from);
|
|
$periodTo = Carbon::createFromFormat('Ym', $statement->period_to);
|
|
|
|
$missingPeriods = [];
|
|
$availablePeriods = [];
|
|
|
|
for ($period = clone $periodFrom; $period->lte($periodTo); $period->addMonth()) {
|
|
$periodFormatted = $period->format('Ym');
|
|
$periodPath = $periodFormatted . "/{$statement->branch_code}/{$statement->account_number}_{$periodFormatted}.pdf";
|
|
|
|
if ($disk->exists($periodPath)) {
|
|
$availablePeriods[] = $periodFormatted;
|
|
} else {
|
|
$missingPeriods[] = $periodFormatted;
|
|
}
|
|
}
|
|
|
|
if (count($missingPeriods) > 0) {
|
|
$notes = "Missing periods: " . implode(', ', $missingPeriods);
|
|
$statement->update([
|
|
'is_available' => false,
|
|
'remarks' => $notes,
|
|
'updated_by' => Auth::id(),
|
|
'status' => 'failed'
|
|
]);
|
|
|
|
Log::warning('Statement not available - missing periods', [
|
|
'statement_id' => $statement->id,
|
|
'missing_periods' => $missingPeriods
|
|
]);
|
|
} else {
|
|
$statement->update([
|
|
'is_available' => true,
|
|
'updated_by' => Auth::id(),
|
|
'status' => 'completed',
|
|
'processed_accounts' => 1,
|
|
'success_count' => 1
|
|
]);
|
|
|
|
Log::info('Statement available - all periods found', [
|
|
'statement_id' => $statement->id,
|
|
'available_periods' => $availablePeriods
|
|
]);
|
|
}
|
|
} else if ($disk->exists($filePath)) {
|
|
$statement->update([
|
|
'is_available' => true,
|
|
'updated_by' => Auth::id(),
|
|
'status' => 'completed',
|
|
'processed_accounts' => 1,
|
|
'success_count' => 1
|
|
]);
|
|
|
|
Log::info('Statement available', [
|
|
'statement_id' => $statement->id,
|
|
'file_path' => $filePath
|
|
]);
|
|
} else {
|
|
$statement->update([
|
|
'is_available' => false,
|
|
'updated_by' => Auth::id(),
|
|
'status' => 'failed',
|
|
'processed_accounts' => 1,
|
|
'failed_count' => 1,
|
|
'error_message' => 'Statement file not found'
|
|
]);
|
|
|
|
Log::warning('Statement not available', [
|
|
'statement_id' => $statement->id,
|
|
'file_path' => $filePath
|
|
]);
|
|
}
|
|
|
|
DB::commit();
|
|
} catch (Exception $e) {
|
|
DB::rollBack();
|
|
|
|
Log::error('Error checking statement availability', [
|
|
'statement_id' => $statement->id,
|
|
'error' => $e->getMessage()
|
|
]);
|
|
|
|
$statement->update([
|
|
'is_available' => false,
|
|
'status' => 'failed',
|
|
'error_message' => $e->getMessage(),
|
|
'updated_by' => Auth::id()
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Display the specified statement.
|
|
*/
|
|
public function show(PrintStatementLog $statement)
|
|
{
|
|
$statement->load(['user', 'branch', 'creator', 'authorizer']);
|
|
return view('webstatement::statements.show', compact('statement'));
|
|
}
|
|
|
|
/**
|
|
* Download the statement if available and authorized.
|
|
* Memperbarui status download dengan logging dan transaksi
|
|
*/
|
|
public function download(PrintStatementLog $statement)
|
|
{
|
|
if (!$statement->is_available) {
|
|
return back()->with('error', 'Statement is not available for download.');
|
|
}
|
|
|
|
if($statement->request_type=='multi_account'){
|
|
return $this->downloadMultiAccountZip($statement->id);
|
|
}
|
|
|
|
if($statement->is_generated){
|
|
return $this->generated($statement->id);
|
|
}
|
|
|
|
DB::beginTransaction();
|
|
|
|
try {
|
|
// Update download status
|
|
$statement->update([
|
|
'is_downloaded' => true,
|
|
'downloaded_at' => now(),
|
|
'updated_by' => Auth::id()
|
|
]);
|
|
|
|
Log::info('Statement downloaded', [
|
|
'statement_id' => $statement->id,
|
|
'user_id' => Auth::id(),
|
|
'account_number' => $statement->account_number
|
|
]);
|
|
|
|
DB::commit();
|
|
|
|
// Generate or fetch the statement file
|
|
$disk = Storage::disk('sftpStatement');
|
|
$filePath = "{$statement->period_from}/{$statement->branch_code}/{$statement->account_number}_{$statement->period_from}.pdf";
|
|
|
|
if ($statement->is_period_range && $statement->period_to) {
|
|
// Log: Memulai proses download period range
|
|
Log::info('Starting period range download', [
|
|
'statement_id' => $statement->id,
|
|
'period_from' => $statement->period_from,
|
|
'period_to' => $statement->period_to
|
|
]);
|
|
|
|
/**
|
|
* Handle period range download dengan membuat zip file
|
|
* yang berisi semua statement dalam rentang periode
|
|
*/
|
|
$periodFrom = Carbon::createFromFormat('Ym', $statement->period_from);
|
|
$periodTo = Carbon::createFromFormat('Ym', $statement->period_to);
|
|
|
|
// Loop through each month in the range
|
|
$missingPeriods = [];
|
|
$availablePeriods = [];
|
|
|
|
for ($period = clone $periodFrom; $period->lte($periodTo); $period->addMonth()) {
|
|
$periodFormatted = $period->format('Ym');
|
|
$periodPath = $periodFormatted . "/{$statement->branch_code}/{$statement->account_number}_{$periodFormatted}.pdf";
|
|
|
|
if ($disk->exists($periodPath)) {
|
|
$availablePeriods[] = $periodFormatted;
|
|
Log::info('Period available for download', [
|
|
'period' => $periodFormatted,
|
|
'path' => $periodPath
|
|
]);
|
|
} else {
|
|
$missingPeriods[] = $periodFormatted;
|
|
Log::warning('Period not available for download', [
|
|
'period' => $periodFormatted,
|
|
'path' => $periodPath
|
|
]);
|
|
}
|
|
}
|
|
|
|
// If any period is available, create a zip and download it
|
|
if (count($availablePeriods) > 0) {
|
|
/**
|
|
* Membuat zip file temporary untuk download
|
|
* dengan semua statement yang tersedia dalam periode
|
|
*/
|
|
$zipFileName = "{$statement->account_number}_{$statement->period_from}_to_{$statement->period_to}.zip";
|
|
$zipFilePath = storage_path("app/temp/{$zipFileName}");
|
|
|
|
// Ensure the temp directory exists
|
|
if (!file_exists(storage_path('app/temp'))) {
|
|
mkdir(storage_path('app/temp'), 0755, true);
|
|
Log::info('Created temp directory for zip files');
|
|
}
|
|
|
|
// Create a new zip archive
|
|
$zip = new ZipArchive();
|
|
if ($zip->open($zipFilePath, ZipArchive::CREATE | ZipArchive::OVERWRITE) === true) {
|
|
Log::info('Zip archive created successfully', ['zip_path' => $zipFilePath]);
|
|
|
|
// Add each available statement to the zip
|
|
foreach ($availablePeriods as $period) {
|
|
$periodFilePath = "{$period}/{$statement->branch_code}/{$statement->account_number}_{$period}.pdf";
|
|
$localFilePath = storage_path("app/temp/{$statement->account_number}_{$period}.pdf");
|
|
|
|
try {
|
|
// Download the file from SFTP to local storage temporarily
|
|
file_put_contents($localFilePath, $disk->get($periodFilePath));
|
|
|
|
// Add the file to the zip
|
|
$zip->addFile($localFilePath, "{$statement->account_number}_{$period}.pdf");
|
|
|
|
Log::info('Added file to zip', [
|
|
'period' => $period,
|
|
'local_path' => $localFilePath
|
|
]);
|
|
} catch (Exception $e) {
|
|
Log::error('Failed to add file to zip', [
|
|
'period' => $period,
|
|
'error' => $e->getMessage()
|
|
]);
|
|
}
|
|
}
|
|
|
|
$zip->close();
|
|
Log::info('Zip archive closed successfully');
|
|
|
|
// Return the zip file for download
|
|
$response = response()->download($zipFilePath, $zipFileName)->deleteFileAfterSend(true);
|
|
|
|
// Clean up temporary PDF files
|
|
foreach ($availablePeriods as $period) {
|
|
$localFilePath = storage_path("app/temp/{$statement->account_number}_{$period}.pdf");
|
|
if (file_exists($localFilePath)) {
|
|
unlink($localFilePath);
|
|
Log::info('Cleaned up temporary file', ['file' => $localFilePath]);
|
|
}
|
|
}
|
|
|
|
Log::info('Period range download completed successfully', [
|
|
'statement_id' => $statement->id,
|
|
'available_periods' => count($availablePeriods),
|
|
'missing_periods' => count($missingPeriods)
|
|
]);
|
|
|
|
return $response;
|
|
} else {
|
|
Log::error('Failed to create zip archive', ['zip_path' => $zipFilePath]);
|
|
return back()->with('error', 'Failed to create zip archive for download.');
|
|
}
|
|
} else {
|
|
Log::warning('No statements available for download in period range', [
|
|
'statement_id' => $statement->id,
|
|
'missing_periods' => $missingPeriods
|
|
]);
|
|
return back()->with('error', 'No statements available for download in the specified period range.');
|
|
}
|
|
} else if ($disk->exists($filePath)) {
|
|
/**
|
|
* Handle single period download
|
|
* Download file PDF tunggal untuk periode tertentu
|
|
*/
|
|
Log::info('Single period download', [
|
|
'statement_id' => $statement->id,
|
|
'file_path' => $filePath
|
|
]);
|
|
|
|
return response()->download(
|
|
$disk->path($filePath),
|
|
"{$statement->account_number}_{$statement->period_from}.pdf"
|
|
);
|
|
} else {
|
|
Log::warning('Statement file not found', [
|
|
'statement_id' => $statement->id,
|
|
'file_path' => $filePath
|
|
]);
|
|
return back()->with('error', 'Statement file not found.');
|
|
}
|
|
} catch (Exception $e) {
|
|
DB::rollBack();
|
|
|
|
Log::error('Failed to download statement', [
|
|
'statement_id' => $statement->id,
|
|
'error' => $e->getMessage(),
|
|
'trace' => $e->getTraceAsString()
|
|
]);
|
|
|
|
return back()->with('error', 'Failed to download statement: ' . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Authorize a statement request.
|
|
*/
|
|
public function authorize(Request $request, PrintStatementLog $statement)
|
|
{
|
|
$request->validate([
|
|
'authorization_status' => ['required', Rule::in(['approved', 'rejected'])],
|
|
'remarks' => ['nullable', 'string', 'max:255'],
|
|
]);
|
|
|
|
// Update authorization status
|
|
$statement->update([
|
|
'authorization_status' => $request->authorization_status,
|
|
'authorized_by' => Auth::id(),
|
|
'authorized_at' => now(),
|
|
'remarks' => $request->remarks,
|
|
'updated_by' => Auth::id()
|
|
]);
|
|
|
|
$statusText = $request->authorization_status === 'approved' ? 'approved' : 'rejected';
|
|
|
|
return redirect()->route('statements.show', $statement->id)
|
|
->with('success', "Statement request has been {$statusText} successfully.");
|
|
|
|
}
|
|
|
|
/**
|
|
* Provide data for datatables.
|
|
*/
|
|
public function dataForDatatables(Request $request)
|
|
{
|
|
// Check permissions if needed
|
|
// if (!auth()->user()->can('view_statements')) {
|
|
// abort(403, 'Sorry! You are not allowed to view statements.');
|
|
// }
|
|
|
|
// Retrieve data from the database
|
|
$query = PrintStatementLog::query();
|
|
$query->whereNotNull('user_id');
|
|
|
|
if (!Auth::user()->role === 'administrator') {
|
|
$query->where(function($q) {
|
|
$q->where('user_id', Auth::id())
|
|
->orWhere('branch_code', Auth::user()->branch->code);
|
|
});
|
|
}
|
|
|
|
// Apply search filter if provided
|
|
if ($request->has('search') && !empty($request->get('search'))) {
|
|
$search = $request->get('search');
|
|
$query->where(function ($q) use ($search) {
|
|
$q->where('account_number', 'LIKE', "%$search%")
|
|
->orWhere('branch_code', 'LIKE', "%$search%")
|
|
->orWhere('period_from', 'LIKE', "%$search%")
|
|
->orWhere('period_to', 'LIKE', "%$search%")
|
|
->orWhere('authorization_status', 'LIKE', "%$search%")
|
|
->orWhere('request_type', 'LIKE', "%$search%")
|
|
->orWhere('status', 'LIKE', "%$search%");
|
|
});
|
|
}
|
|
|
|
// Apply column filters if provided
|
|
if ($request->has('filters') && !empty($request->get('filters'))) {
|
|
$filters = json_decode($request->get('filters'), true);
|
|
|
|
foreach ($filters as $filter) {
|
|
if (!empty($filter['value'])) {
|
|
if ($filter['column'] === 'branch_code') {
|
|
$query->where('branch_code', $filter['value']);
|
|
} else if ($filter['column'] === 'authorization_status') {
|
|
$query->where('authorization_status', $filter['value']);
|
|
} else if ($filter['column'] === 'request_type') {
|
|
$query->where('request_type', $filter['value']);
|
|
} else if ($filter['column'] === 'status') {
|
|
$query->where('status', $filter['value']);
|
|
} else if ($filter['column'] === 'is_downloaded') {
|
|
$query->where('is_downloaded', filter_var($filter['value'], FILTER_VALIDATE_BOOLEAN));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply sorting if provided
|
|
if ($request->has('sortOrder') && !empty($request->get('sortOrder'))) {
|
|
$order = $request->get('sortOrder');
|
|
$column = $request->get('sortField');
|
|
|
|
// Map frontend column names to database column names if needed
|
|
$columnMap = [
|
|
'branch' => 'branch_code',
|
|
'account' => 'account_number',
|
|
'period' => 'period_from',
|
|
'auth_status' => 'authorization_status',
|
|
'request_type' => 'request_type',
|
|
'status' => 'status',
|
|
'remarks' => 'remarks',
|
|
];
|
|
|
|
$dbColumn = $columnMap[$column] ?? $column;
|
|
$query->orderBy($dbColumn, $order);
|
|
} else {
|
|
// Default sorting
|
|
$query->latest('created_at');
|
|
}
|
|
|
|
// Get the total count of records
|
|
$totalRecords = $query->count();
|
|
|
|
// Apply pagination if provided
|
|
if ($request->has('page') && $request->has('size')) {
|
|
$page = $request->get('page');
|
|
$size = $request->get('size');
|
|
$offset = ($page - 1) * $size; // Calculate the offset
|
|
|
|
$query->skip($offset)->take($size);
|
|
}
|
|
|
|
// Get the filtered count of records
|
|
$filteredRecords = $query->count();
|
|
|
|
// Eager load relationships to avoid N+1 query problems
|
|
//$query->with(['user', 'branch', 'authorizer']);
|
|
|
|
// Get the data for the current page
|
|
$data = $query->get()->map(function ($item) {
|
|
// Transform data for frontend if needed
|
|
return [
|
|
'id' => $item->id,
|
|
'branch_code' => $item->branch_code,
|
|
'branch_name' => $item->account->branch->name ?? 'N/A',
|
|
'account_number' => $item->account_number,
|
|
'period_from' => $item->period_from,
|
|
'period_to' => $item->is_period_range ? $item->period_to : null,
|
|
'authorization_status' => $item->authorization_status,
|
|
'is_available' => $item->is_available,
|
|
'is_generated' => $item->is_generated,
|
|
'is_downloaded' => $item->is_downloaded,
|
|
'created_at' => dateFormat($item->created_at, 1, 1),
|
|
'created_by' => $item->user->name ?? 'N/A',
|
|
'authorized_by' => $item->authorizer ? $item->authorizer->name : null,
|
|
'authorized_at' => $item->authorized_at ? $item->authorized_at->format('Y-m-d H:i:s') : null,
|
|
'remarks' => $item->remarks,
|
|
'request_type' => $item->request_type ?? 'N/A',
|
|
];
|
|
});
|
|
|
|
// Calculate the page count
|
|
$pageCount = ceil($filteredRecords / ($request->get('size') ?: 1));
|
|
|
|
// Calculate the current page number
|
|
$currentPage = $request->get('page') ?: 1;
|
|
|
|
// Return the response data as a JSON object
|
|
return response()->json([
|
|
'draw' => $request->get('draw'),
|
|
'recordsTotal' => $totalRecords,
|
|
'recordsFiltered' => $filteredRecords,
|
|
'pageCount' => $pageCount,
|
|
'page' => $currentPage,
|
|
'totalCount' => $totalRecords,
|
|
'data' => $data,
|
|
]);
|
|
}
|
|
|
|
public function destroy(PrintStatementLog $statement)
|
|
{
|
|
// Delete the statement
|
|
$statement->delete();
|
|
|
|
return response()->json([
|
|
'message' => 'Statement deleted successfully.',
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Send statement to email
|
|
*/
|
|
public function sendEmail($id)
|
|
{
|
|
$statement = PrintStatementLog::findOrFail($id);
|
|
|
|
// Check if statement has email
|
|
if (empty($statement->email)) {
|
|
return redirect()->back()->with('error', 'No email address provided for this statement.');
|
|
}
|
|
|
|
// Check if statement is available
|
|
if (!$statement->is_available) {
|
|
return redirect()->back()->with('error', 'Statement is not available for sending.');
|
|
}
|
|
|
|
try {
|
|
$disk = Storage::disk('sftpStatement');
|
|
$filePath = "{$statement->period_from}/{$statement->branch_code}/{$statement->account_number}_{$statement->period_from}.pdf";
|
|
|
|
if ($statement->is_period_range && $statement->period_to) {
|
|
$periodFrom = Carbon::createFromFormat('Ym', $statement->period_from);
|
|
$periodTo = Carbon::createFromFormat('Ym', $statement->period_to);
|
|
|
|
// Loop through each month in the range
|
|
$missingPeriods = [];
|
|
$availablePeriods = [];
|
|
|
|
for ($period = clone $periodFrom; $period->lte($periodTo); $period->addMonth()) {
|
|
$periodFormatted = $period->format('Ym');
|
|
$periodPath = $periodFormatted . "/{$statement->branch_code}/{$statement->account_number}_{$periodFormatted}.pdf";
|
|
|
|
if ($disk->exists($periodPath)) {
|
|
$availablePeriods[] = $periodFormatted;
|
|
} else {
|
|
$missingPeriods[] = $periodFormatted;
|
|
}
|
|
}
|
|
|
|
// If any period is available, create a zip and send it
|
|
if (count($availablePeriods) > 0) {
|
|
// Create a temporary zip file
|
|
$zipFileName = "{$statement->account_number}_{$statement->period_from}_to_{$statement->period_to}.zip";
|
|
$zipFilePath = storage_path("app/temp/{$zipFileName}");
|
|
|
|
// Ensure the temp directory exists
|
|
if (!file_exists(storage_path('app/temp'))) {
|
|
mkdir(storage_path('app/temp'), 0755, true);
|
|
}
|
|
|
|
// Create a new zip archive
|
|
$zip = new ZipArchive();
|
|
if ($zip->open($zipFilePath, ZipArchive::CREATE | ZipArchive::OVERWRITE) === true) {
|
|
// Add each available statement to the zip
|
|
foreach ($availablePeriods as $period) {
|
|
$filePath = "{$period}/{$statement->branch_code}/{$statement->account_number}_{$statement->period_from}.pdf";
|
|
$localFilePath = storage_path("app/temp/{$statement->account_number}_{$period}.pdf");
|
|
|
|
// Download the file from SFTP to local storage temporarily
|
|
file_put_contents($localFilePath, $disk->get($filePath));
|
|
|
|
// Add the file to the zip
|
|
$zip->addFile($localFilePath, "{$statement->account_number}_{$period}.pdf");
|
|
}
|
|
|
|
$zip->close();
|
|
|
|
// Send email with zip attachment
|
|
Mail::to($statement->email)
|
|
->send(new StatementEmail($statement, $zipFilePath, true));
|
|
|
|
// Clean up temporary files
|
|
foreach ($availablePeriods as $period) {
|
|
$localFilePath = storage_path("app/temp/{$statement->account_number}_{$period}.pdf");
|
|
if (file_exists($localFilePath)) {
|
|
unlink($localFilePath);
|
|
}
|
|
}
|
|
|
|
// Delete the zip file after sending
|
|
if (file_exists($zipFilePath)) {
|
|
unlink($zipFilePath);
|
|
}
|
|
} else {
|
|
return redirect()->back()->with('error', 'Failed to create zip archive for email.');
|
|
}
|
|
} else {
|
|
return redirect()->back()->with('error', 'No statements available for sending.');
|
|
}
|
|
} else if ($disk->exists($filePath)) {
|
|
// For single period statements
|
|
$localFilePath = storage_path("app/temp/{$statement->account_number}_{$statement->period_from}.pdf");
|
|
|
|
// Ensure the temp directory exists
|
|
if (!file_exists(storage_path('app/temp'))) {
|
|
mkdir(storage_path('app/temp'), 0755, true);
|
|
}
|
|
|
|
// Download the file from SFTP to local storage temporarily
|
|
file_put_contents($localFilePath, $disk->get($filePath));
|
|
|
|
// Send email with PDF attachment
|
|
Mail::to($statement->email)
|
|
->send(new StatementEmail($statement, $localFilePath, false));
|
|
|
|
// Delete the temporary file
|
|
if (file_exists($localFilePath)) {
|
|
unlink($localFilePath);
|
|
}
|
|
} else {
|
|
return redirect()->back()->with('error', 'Statement file not found.');
|
|
}
|
|
|
|
// Update statement record to mark as emailed
|
|
$statement->update([
|
|
'email_sent_at' => now(),
|
|
'updated_by' => Auth::id()
|
|
]);
|
|
|
|
Log::info('Statement email sent successfully', [
|
|
'statement_id' => $statement->id,
|
|
'email' => $statement->email,
|
|
'user_id' => Auth::id()
|
|
]);
|
|
|
|
DB::commit();
|
|
|
|
return redirect()->back()->with('success', 'Statement has been sent to ' . $statement->email);
|
|
} catch (Exception $e) {
|
|
// Log the error
|
|
Log::error('Failed to send statement email: ' . $e->getMessage());
|
|
|
|
return redirect()->back()->with('error', 'Failed to send email: ' . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate or fetch the statement file.
|
|
* This is a placeholder method - implement according to your system.
|
|
*/
|
|
protected function generateStatementFile(PrintStatementLog $statement)
|
|
{
|
|
// This would be implemented based on your system's logic
|
|
// For example, calling an API to generate a PDF or fetching from storage
|
|
|
|
// Placeholder implementation - return a dummy path
|
|
$tempFile = tempnam(sys_get_temp_dir(), 'statement_');
|
|
file_put_contents($tempFile, 'Statement content would go here');
|
|
return $tempFile;
|
|
}
|
|
|
|
/**
|
|
* Send statement to email
|
|
*/
|
|
|
|
/**
|
|
* Generate a filename for the statement download.
|
|
*/
|
|
protected function generateFileName(PrintStatementLog $statement)
|
|
{
|
|
$accountNumber = $statement->account_number;
|
|
|
|
if ($statement->is_period_range) {
|
|
return "statement_{$accountNumber}_{$statement->period_from}_to_{$statement->period_to}.pdf";
|
|
}
|
|
|
|
return "statement_{$accountNumber}_{$statement->period_from}.pdf";
|
|
}
|
|
|
|
/**
|
|
* Generate statement view atau PDF berdasarkan parameter
|
|
*
|
|
* @param string $norek Nomor rekening
|
|
* @param string $period Periode dalam format YYYYMM
|
|
* @param string|null $format Format output: 'html' atau 'pdf'
|
|
* @return \Illuminate\View\View|\Illuminate\Http\Response
|
|
*/
|
|
public function generated($id){
|
|
try {
|
|
$statement = PrintStatementLog::find($id);
|
|
|
|
DB::beginTransaction();
|
|
|
|
$norek = $statement->account_number;
|
|
$period = $statement->period_from;
|
|
$format='pdf';
|
|
|
|
// Generate nama file PDF
|
|
$filename = $this->generatePdfFileName($norek, $period);
|
|
|
|
// Tentukan path storage
|
|
$storagePath = "statements/{$period}/{$norek}";
|
|
$fullStoragePath = "{$storagePath}/{$filename}";
|
|
|
|
// Pastikan direktori storage ada
|
|
Storage::disk('local')->makeDirectory($storagePath);
|
|
|
|
// Path temporary untuk Browsershot
|
|
$tempPath = storage_path("app/{$fullStoragePath}");
|
|
|
|
if(file_exists($tempPath)){
|
|
return response()->download($tempPath, $filename, [
|
|
'Content-Type' => 'application/pdf',
|
|
'Content-Disposition' => 'attachment; filename="' . $filename . '"'
|
|
])->deleteFileAfterSend(false); // Keep file in storage
|
|
}
|
|
|
|
$stmtEntries = ProcessedStatement::where(['account_number' => $norek, 'period' => $period])->orderBy('sequence_no')->get();
|
|
$account = Account::with('customer')->where('account_number', $norek)->first();
|
|
|
|
if (!$account) {
|
|
throw new Exception("Account not found: {$norek}");
|
|
}
|
|
|
|
$customer = $account->customer;
|
|
$branch = Branch::where('code', $account->branch_code)->first();
|
|
|
|
// Cek apakah file gambar ada
|
|
$headerImagePath = public_path('assets/media/images/bg-header-table.png');
|
|
$headerTableBg = file_exists($headerImagePath)
|
|
? base64_encode(file_get_contents($headerImagePath))
|
|
: null;
|
|
|
|
// Logika untuk menentukan period saldo berdasarkan aturan baru
|
|
$saldoPeriod = $this->calculateSaldoPeriod($period);
|
|
|
|
Log::info('Calculated saldo period', [
|
|
'original_period' => $period,
|
|
'saldo_period' => $saldoPeriod
|
|
]);
|
|
|
|
$saldoAwalBulan = AccountBalance::where(['account_number' => $norek, 'period' => $saldoPeriod])->first();
|
|
|
|
if (!$saldoAwalBulan) {
|
|
Log::warning('Saldo awal bulan not found', [
|
|
'account_number' => $norek,
|
|
'saldo_period' => $saldoPeriod
|
|
]);
|
|
$saldoAwalBulan = (object) ['actual_balance' => 0];
|
|
}
|
|
|
|
DB::commit();
|
|
|
|
Log::info('Statement data prepared successfully', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'saldo_period' => $saldoPeriod,
|
|
'saldo_awal' => $saldoAwalBulan->actual_balance ?? 0,
|
|
'entries_count' => $stmtEntries->count()
|
|
]);
|
|
|
|
$periodDates = calculatePeriodDates($period);
|
|
|
|
// Jika format adalah PDF, generate PDF
|
|
if ($format === 'pdf') {
|
|
return $this->generateStatementPdf($norek, $period, $stmtEntries, $account, $customer, $headerTableBg, $branch, $saldoAwalBulan, $statement->id, $tempPath, $filename);
|
|
}
|
|
|
|
// Default return HTML view
|
|
return view('webstatement::statements.stmt', compact('stmtEntries', 'account', 'customer', 'headerTableBg', 'branch', 'period', 'saldoAwalBulan'));
|
|
|
|
} catch (Exception $e) {
|
|
DB::rollBack();
|
|
|
|
Log::error('Failed to generate statement', [
|
|
'error' => $e->getMessage(),
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'format' => $format,
|
|
'trace' => $e->getTraceAsString()
|
|
]);
|
|
|
|
if ($format === 'pdf') {
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'Failed to generate PDF statement',
|
|
'error' => $e->getMessage()
|
|
], 500);
|
|
}
|
|
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate PDF dari statement HTML dan simpan ke storage
|
|
*
|
|
* @param string $norek Nomor rekening
|
|
* @param string $period Periode
|
|
* @param \Illuminate\Database\Eloquent\Collection $stmtEntries Data transaksi
|
|
* @param object $account Data akun
|
|
* @param object $customer Data customer
|
|
* @param string|null $headerTableBg Base64 encoded header image
|
|
* @param object $branch Data cabang
|
|
* @param object $saldoAwalBulan Data saldo awal
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
protected function generateStatementPdf($norek, $period, $stmtEntries, $account, $customer, $headerTableBg, $branch, $saldoAwalBulan, $statementId, $tempPath, $filename)
|
|
{
|
|
try {
|
|
DB::beginTransaction();
|
|
|
|
Log::info('Starting PDF generation with storage', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'user_id' => Auth::id()
|
|
]);
|
|
|
|
// Render HTML view
|
|
$html = view('webstatement::statements.stmt', compact(
|
|
'stmtEntries',
|
|
'account',
|
|
'customer',
|
|
'headerTableBg',
|
|
'branch',
|
|
'period',
|
|
'saldoAwalBulan'
|
|
))->render();
|
|
// Tentukan path storage
|
|
$storagePath = "statements/{$period}/{$norek}";
|
|
$fullStoragePath = "{$storagePath}/{$filename}";
|
|
|
|
// Generate PDF menggunakan Browsershot dan simpan langsung ke storage
|
|
Browsershot::html($html)
|
|
->showBackground()
|
|
->setOption('addStyleTag', json_encode(['content' => '@page { margin: 0; }']))
|
|
->setOption('protocolTimeout', 2147483) // 120000 ms = 2 menit
|
|
->format('A4')
|
|
->margins(0, 0, 0, 0)
|
|
->waitUntil('load')
|
|
->timeout(2147483)
|
|
->save($tempPath);
|
|
|
|
// Verifikasi file berhasil dibuat
|
|
if (!file_exists($tempPath)) {
|
|
throw new Exception('PDF file was not created successfully');
|
|
} else {
|
|
$printLog = PrintStatementLog::find($statementId);
|
|
if($printLog){
|
|
$printLog->update(['is_available' => true]);
|
|
}
|
|
}
|
|
|
|
$fileSize = filesize($tempPath);
|
|
|
|
Log::info('PDF generated and saved to storage', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'storage_path' => $fullStoragePath,
|
|
'file_size' => $fileSize,
|
|
'temp_path' => $tempPath
|
|
]);
|
|
|
|
DB::commit();
|
|
|
|
// Return download response
|
|
return response()->download($tempPath, $filename, [
|
|
'Content-Type' => 'application/pdf',
|
|
'Content-Disposition' => 'attachment; filename="' . $filename . '"'
|
|
])->deleteFileAfterSend(false); // Keep file in storage
|
|
|
|
} catch (Exception $e) {
|
|
DB::rollBack();
|
|
|
|
Log::error('Failed to generate PDF with storage', [
|
|
'error' => $e->getMessage(),
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'trace' => $e->getTraceAsString()
|
|
]);
|
|
|
|
throw new Exception('Failed to generate PDF: ' . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate nama file PDF berdasarkan nomor rekening dan periode
|
|
*
|
|
* @param string $norek Nomor rekening
|
|
* @param string $period Periode
|
|
* @return string
|
|
*/
|
|
protected function generatePdfFileName($norek, $period)
|
|
{
|
|
try {
|
|
$filename = "statement_{$norek}_{$period}.pdf";
|
|
|
|
Log::info('Generated PDF filename', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'filename' => $filename
|
|
]);
|
|
|
|
return $filename;
|
|
|
|
} catch (Exception $e) {
|
|
Log::error('Error generating PDF filename', [
|
|
'error' => $e->getMessage(),
|
|
'account_number' => $norek,
|
|
'period' => $period
|
|
]);
|
|
|
|
// Fallback filename
|
|
return "statement_{$norek}_{$period}.pdf";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Simpan PDF ke storage dengan validasi dan logging
|
|
*
|
|
* @param string $tempPath Path temporary file
|
|
* @param string $storagePath Path di storage
|
|
* @param string $norek Nomor rekening
|
|
* @param string $period Periode
|
|
* @return string|null Path file yang disimpan
|
|
*/
|
|
protected function savePdfToStorage($tempPath, $storagePath, $norek, $period)
|
|
{
|
|
try {
|
|
// Validasi file temporary ada
|
|
if (!file_exists($tempPath)) {
|
|
throw new Exception('Temporary PDF file not found');
|
|
}
|
|
|
|
// Validasi ukuran file
|
|
$fileSize = filesize($tempPath);
|
|
if ($fileSize === 0) {
|
|
throw new Exception('PDF file is empty');
|
|
}
|
|
|
|
// Baca konten file
|
|
$pdfContent = file_get_contents($tempPath);
|
|
if ($pdfContent === false) {
|
|
throw new Exception('Failed to read PDF content');
|
|
}
|
|
|
|
// Simpan ke storage
|
|
$saved = Storage::disk('local')->put($storagePath, $pdfContent);
|
|
|
|
if (!$saved) {
|
|
throw new Exception('Failed to save PDF to storage');
|
|
}
|
|
|
|
// Verifikasi file tersimpan
|
|
if (!Storage::disk('local')->exists($storagePath)) {
|
|
throw new Exception('PDF file not found in storage after save');
|
|
}
|
|
|
|
$savedSize = Storage::disk('local')->size($storagePath);
|
|
|
|
Log::info('PDF successfully saved to storage', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'storage_path' => $storagePath,
|
|
'original_size' => $fileSize,
|
|
'saved_size' => $savedSize,
|
|
'temp_path' => $tempPath
|
|
]);
|
|
|
|
return $storagePath;
|
|
|
|
} catch (Exception $e) {
|
|
Log::error('Failed to save PDF to storage', [
|
|
'error' => $e->getMessage(),
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'storage_path' => $storagePath,
|
|
'temp_path' => $tempPath
|
|
]);
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ambil PDF dari storage untuk download
|
|
*
|
|
* @param string $norek Nomor rekening
|
|
* @param string $period Periode
|
|
* @param string $filename Nama file (optional)
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function downloadFromStorage($norek, $period, $filename = null)
|
|
{
|
|
try {
|
|
// Generate filename jika tidak disediakan
|
|
if (!$filename) {
|
|
$filename = $this->generatePdfFileName($norek, $period);
|
|
}
|
|
|
|
$storagePath = "statements/{$period}/{$norek}/{$filename}";
|
|
|
|
// Cek apakah file ada di storage
|
|
if (!Storage::disk('local')->exists($storagePath)) {
|
|
Log::warning('PDF not found in storage', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'storage_path' => $storagePath
|
|
]);
|
|
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'PDF file not found in storage'
|
|
], 404);
|
|
}
|
|
|
|
$fullPath = Storage::disk('local')->path($storagePath);
|
|
|
|
Log::info('PDF downloaded from storage', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'storage_path' => $storagePath
|
|
]);
|
|
|
|
return response()->download($fullPath, $filename, [
|
|
'Content-Type' => 'application/pdf'
|
|
]);
|
|
|
|
} catch (Exception $e) {
|
|
Log::error('Failed to download PDF from storage', [
|
|
'error' => $e->getMessage(),
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'filename' => $filename
|
|
]);
|
|
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'Failed to download PDF',
|
|
'error' => $e->getMessage()
|
|
], 500);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hapus PDF dari storage
|
|
*
|
|
* @param string $norek Nomor rekening
|
|
* @param string $period Periode
|
|
* @param string $filename Nama file (optional)
|
|
* @return bool
|
|
*/
|
|
public function deleteFromStorage($norek, $period, $filename = null)
|
|
{
|
|
try {
|
|
if (!$filename) {
|
|
$filename = $this->generatePdfFileName($norek, $period);
|
|
}
|
|
|
|
$storagePath = "statements/{$period}/{$norek}/{$filename}";
|
|
|
|
if (Storage::disk('local')->exists($storagePath)) {
|
|
$deleted = Storage::disk('local')->delete($storagePath);
|
|
|
|
Log::info('PDF deleted from storage', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'storage_path' => $storagePath,
|
|
'success' => $deleted
|
|
]);
|
|
|
|
return $deleted;
|
|
}
|
|
|
|
Log::warning('PDF not found for deletion', [
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'storage_path' => $storagePath
|
|
]);
|
|
|
|
return false;
|
|
|
|
} catch (Exception $e) {
|
|
Log::error('Failed to delete PDF from storage', [
|
|
'error' => $e->getMessage(),
|
|
'account_number' => $norek,
|
|
'period' => $period,
|
|
'filename' => $filename
|
|
]);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Menghitung period untuk pengambilan saldo berdasarkan aturan bisnis
|
|
* - Jika period = 202505, gunakan 20250510
|
|
* - Jika period > 202505, ambil tanggal akhir bulan sebelumnya
|
|
*
|
|
* @param string $period Format YYYYMM
|
|
* @return string Format YYYYMMDD
|
|
*/
|
|
private function calculateSaldoPeriod($period)
|
|
{
|
|
try {
|
|
// Jika period adalah 202505, gunakan tanggal 10 Mei 2025
|
|
if ($period === '202505') {
|
|
return '20250510';
|
|
}
|
|
|
|
// Jika period lebih dari 202505, ambil tanggal akhir bulan sebelumnya
|
|
if ($period > '202505') {
|
|
$year = substr($period, 0, 4);
|
|
$month = substr($period, 4, 2);
|
|
|
|
// Buat tanggal pertama bulan ini
|
|
$firstDayOfMonth = Carbon::createFromDate($year, $month, 1);
|
|
|
|
// Ambil tanggal terakhir bulan sebelumnya
|
|
$lastDayPrevMonth = $firstDayOfMonth->subDay();
|
|
|
|
return $lastDayPrevMonth->format('Ymd');
|
|
}
|
|
|
|
// Untuk period sebelum 202505, gunakan logika default (tanggal 10)
|
|
$year = substr($period, 0, 4);
|
|
$month = substr($period, 4, 2);
|
|
|
|
return $year . $month . '10';
|
|
|
|
} catch (Exception $e) {
|
|
Log::error('Error calculating saldo period', [
|
|
'period' => $period,
|
|
'error' => $e->getMessage()
|
|
]);
|
|
|
|
// Fallback ke format default
|
|
return $period . '10';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process statement untuk multi account berdasarkan stmt_sent_type
|
|
*
|
|
* @param PrintStatementLog $statement
|
|
* @return \Illuminate\Http\JsonResponse
|
|
*/
|
|
function printStatementRekening($statement) {
|
|
|
|
try {
|
|
// DB::beginTransaction();
|
|
|
|
Log::info('Starting statement processing', [
|
|
'statement_id' => $statement->id,
|
|
'request_type' => $statement->request_type,
|
|
'stmt_sent_type' => $statement->stmt_sent_type,
|
|
'branch_code' => $statement->branch_code
|
|
]);
|
|
|
|
|
|
if ($statement->request_type === 'multi_account') {
|
|
return $this->processMultiAccountStatement($statement);
|
|
} else {
|
|
return $this->processSingleAccountStatement($statement);
|
|
}
|
|
|
|
} catch (\Exception $e) {
|
|
//DB::rollBack();
|
|
|
|
Log::error('Failed to process statement', [
|
|
'error' => $e->getMessage(),
|
|
'statement_id' => $statement->id,
|
|
'trace' => $e->getTraceAsString()
|
|
]);
|
|
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'Failed to process statement',
|
|
'error' => $e->getMessage()
|
|
], 500);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process multi account statement berdasarkan stmt_sent_type
|
|
*
|
|
* @param PrintStatementLog $statement
|
|
* @return \Illuminate\Http\JsonResponse
|
|
*/
|
|
protected function processMultiAccountStatement($statement)
|
|
{
|
|
try {
|
|
$period = $statement->period_from ?? date('Ym');
|
|
|
|
// Validasi stmt_sent_type
|
|
if (empty($statement->stmt_sent_type)) {
|
|
throw new \Exception('stmt_sent_type is required for multi account processing');
|
|
}
|
|
|
|
// Decode stmt_sent_type jika dalam format JSON array
|
|
$stmtSentTypes = explode(',', $statement->stmt_sent_type);
|
|
|
|
Log::info('Processing multi account statement', [
|
|
'statement_id' => $statement->id,
|
|
'branch_code' => $statement->branch_code,
|
|
'stmt_sent_types' => $stmtSentTypes,
|
|
'period' => $period
|
|
]);
|
|
|
|
|
|
|
|
$clientName = $statement->branch_code.'_'.$period.'_';//.implode('_'.$stmtSentTypes);
|
|
// Ambil accounts berdasarkan branch_code dan stmt_sent_type
|
|
$accounts = Account::where('branch_code', $statement->branch_code)
|
|
->whereIn('stmt_sent_type', $stmtSentTypes)
|
|
->with('customer')
|
|
->limit(5)
|
|
->get();
|
|
|
|
if ($accounts->isEmpty()) {
|
|
throw new \Exception('No accounts found for the specified criteria');
|
|
}
|
|
|
|
Log::info('Found accounts for processing', [
|
|
'total_accounts' => $accounts->count(),
|
|
'branch_code' => $statement->branch_code,
|
|
'stmt_sent_types' => $stmtSentTypes
|
|
]);
|
|
|
|
// Update statement log dengan informasi accounts
|
|
$accountNumbers = $accounts->pluck('account_number')->toArray();
|
|
|
|
$statement->update([
|
|
'target_accounts' => implode(",",$accountNumbers),
|
|
'total_accounts' => $accounts->count(),
|
|
'status' => 'processing',
|
|
'started_at' => now()
|
|
]);
|
|
|
|
// Dispatch job untuk generate PDF multi account
|
|
$job = GenerateMultiAccountPdfJob::dispatch(
|
|
$statement,
|
|
$accounts,
|
|
$period,
|
|
$clientName
|
|
);
|
|
|
|
DB::commit();
|
|
|
|
Log::info('Multi account PDF generation job dispatched', [
|
|
'job_id' => $job->job_id ?? null,
|
|
'statement_id' => $statement->id,
|
|
'total_accounts' => $accounts->count(),
|
|
'period' => $period
|
|
]);
|
|
|
|
return response()->json([
|
|
'success' => true,
|
|
'message' => 'Multi account statement processing queued successfully',
|
|
'data' => [
|
|
'job_id' => $job->job_id ?? null,
|
|
'statement_id' => $statement->id,
|
|
'total_accounts' => $accounts->count(),
|
|
'account_numbers' => $accountNumbers,
|
|
'period' => $period,
|
|
'client_name' => $clientName
|
|
]
|
|
]);
|
|
|
|
} catch (\Exception $e) {
|
|
DB::rollBack();
|
|
|
|
Log::error('Failed to process multi account statement', [
|
|
'error' => $e->getMessage(),
|
|
'statement_id' => $statement->id,
|
|
'trace' => $e->getTraceAsString()
|
|
]);
|
|
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process single account statement (existing logic)
|
|
*
|
|
* @param PrintStatementLog $statement
|
|
* @return \Illuminate\Http\JsonResponse
|
|
*/
|
|
protected function processSingleAccountStatement($statement)
|
|
{
|
|
|
|
$accountNumber = $statement->account_number;
|
|
$period = $statement->period_from ?? date('Ym');
|
|
$balance = AccountBalance::where('account_number', $accountNumber)
|
|
->when($period === '202505', function($query) {
|
|
return $query->where('period', '>=', '20250512')
|
|
->orderBy('period', 'asc');
|
|
}, function($query) use ($period) {
|
|
// Get balance from last day of previous month
|
|
$firstDayOfMonth = Carbon::createFromFormat('Ym', $period)->startOfMonth();
|
|
$lastDayPrevMonth = $firstDayOfMonth->copy()->subDay()->format('Ymd');
|
|
return $query->where('period', $lastDayPrevMonth);
|
|
})
|
|
->first()
|
|
->actual_balance ?? '0.00';
|
|
$clientName = 'client1';
|
|
|
|
try {
|
|
Log::info("Starting statement export for account: {$accountNumber}, period: {$period}, client: {$clientName}");
|
|
|
|
// Validate inputs
|
|
if (empty($accountNumber) || empty($period) || empty($clientName)) {
|
|
throw new \Exception('Required parameters missing');
|
|
}
|
|
|
|
// Dispatch the job
|
|
$job = ExportStatementPeriodJob::dispatch($statement->id, $accountNumber, $period, $balance, $clientName);
|
|
|
|
Log::info("Statement export job dispatched successfully", [
|
|
'job_id' => $job->job_id ?? null,
|
|
'account' => $accountNumber,
|
|
'period' => $period,
|
|
'client' => $clientName
|
|
]);
|
|
|
|
return response()->json([
|
|
'success' => true,
|
|
'message' => 'Statement export job queued successfully',
|
|
'data' => [
|
|
'job_id' => $job->job_id ?? null,
|
|
'account_number' => $accountNumber,
|
|
'period' => $period,
|
|
'client_name' => $clientName
|
|
]
|
|
]);
|
|
|
|
} catch (\Exception $e) {
|
|
Log::error("Failed to export statement", [
|
|
'error' => $e->getMessage(),
|
|
'account' => $accountNumber,
|
|
'period' => $period
|
|
]);
|
|
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'Failed to queue statement export job',
|
|
'error' => $e->getMessage()
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Download ZIP file untuk multi account statement
|
|
*
|
|
* @param int $statementId
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function downloadMultiAccountZip($statementId)
|
|
{
|
|
try {
|
|
$statement = PrintStatementLog::findOrFail($statementId);
|
|
|
|
if ($statement->request_type !== 'multi_account') {
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'This statement is not a multi account request'
|
|
], 400);
|
|
}
|
|
|
|
if (!$statement->is_available) {
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'Statement files are not available for download'
|
|
], 404);
|
|
}
|
|
|
|
// Find ZIP file
|
|
$zipFiles = Storage::disk('local')->files("statements/{$statement->period_from}/multi_account/{$statementId}");
|
|
|
|
$zipFile = null;
|
|
foreach ($zipFiles as $file) {
|
|
if (pathinfo($file, PATHINFO_EXTENSION) === 'zip') {
|
|
$zipFile = $file;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!$zipFile || !Storage::disk('local')->exists($zipFile)) {
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'ZIP file not found'
|
|
], 404);
|
|
}
|
|
|
|
$zipPath = Storage::disk('local')->path($zipFile);
|
|
$filename = basename($zipFile);
|
|
|
|
// Update download status
|
|
$statement->update([
|
|
'is_downloaded' => true,
|
|
'downloaded_at' => now()
|
|
]);
|
|
|
|
Log::info('Multi account ZIP downloaded', [
|
|
'statement_id' => $statementId,
|
|
'zip_file' => $zipFile,
|
|
'user_id' => Auth::id()
|
|
]);
|
|
|
|
return response()->download($zipPath, $filename, [
|
|
'Content-Type' => 'application/zip'
|
|
]);
|
|
|
|
} catch (Exception $e) {
|
|
Log::error('Failed to download multi account ZIP', [
|
|
'statement_id' => $statementId,
|
|
'error' => $e->getMessage()
|
|
]);
|
|
|
|
return response()->json([
|
|
'success' => false,
|
|
'message' => 'Failed to download ZIP file',
|
|
'error' => $e->getMessage()
|
|
], 500);
|
|
}
|
|
}
|
|
}
|