e2c9f3480d
- **Peningkatan Validasi:**
- Menambahkan validasi kompleks pada field `account_number` untuk memastikan input wajib jika `stmt_sent_type` tidak diisi.
- Validasi baru untuk `stmt_sent_type` mendukung array nilai dengan parameter `in` yang diperbolehkan.
- Menambahkan pengecekan duplikasi pada `PrintStatementRequest` dengan filter tambahan `user_id` untuk scope yang lebih jelas.
- **Peningkatan Logging:**
- Mengganti penggunaan `\Log` dengan `Log` untuk konsistensi namespace.
- Menambahkan logging user pada query statement log di controller.
- Logging lebih terperinci pada proses ekspor dan error handling.
- **Perubahan UI pada Form `statements/index`:**
- Menambahkan highlight warna merah pada field input yang memiliki error validasi (`border-danger`, `bg-danger-light`).
- Memperbaiki tampilan dropdown untuk `branch_id` dan `stmt_sent_type`, termasuk pesan error yang lebih spesifik.
- Menghapus validasi wajib pada field `stmt_sent_type` dan menambah fleksibilitas form pengisian.
- **Optimalisasi Query Backend:**
- Menambah filter `whereNotNull('user_id')` pada query `PrintStatementLog` untuk meminimalisir data invalid.
- **Updated Blade Template:**
- Tombol dan validasi form lebih ramah pengguna dengan feedback langsung.
- Menambahkan badge status styling untuk kolom status otorisasi di datatable.
- Dinamika field seperti dropdown bebas error dalam kondisi tertentu.
Perubahan ini meningkatkan keakuratan validasi, logging proses lebih rinci untuk debugging, dan memberikan pengalaman pengguna yang lebih baik pada interface request statement.
Signed-off-by: Daeng Deni Mardaeni <ddeni05@gmail.com>
848 lines
38 KiB
PHP
848 lines
38 KiB
PHP
<?php
|
|
|
|
namespace Modules\Webstatement\Http\Controllers;
|
|
|
|
use App\Http\Controllers\Controller;
|
|
use Carbon\Carbon;
|
|
use Exception;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Validation\Rule;
|
|
use Illuminate\Support\Facades\{Auth, DB, Log, Mail, Storage};
|
|
use Modules\Basicdata\Models\Branch;
|
|
use Modules\Webstatement\{
|
|
Http\Requests\PrintStatementRequest,
|
|
Mail\StatementEmail,
|
|
Models\PrintStatementLog,
|
|
Models\Account,
|
|
Models\AccountBalance,
|
|
Jobs\ExportStatementPeriodJob
|
|
};
|
|
use ZipArchive;
|
|
|
|
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
|
|
$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.');
|
|
}
|
|
|
|
DB::beginTransaction();
|
|
|
|
try {
|
|
$validated = $request->validated();
|
|
|
|
// 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['request_type'] = 'single_account'; // Default untuk request manual
|
|
$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'] = $branch_code; // Awal tidak tersedia
|
|
|
|
// 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->account_number,$statement->period_from,$statement->period_to,$statement->stmt_sent_type);
|
|
}
|
|
|
|
$statement = PrintStatementLog::find($statement->id);
|
|
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.');
|
|
}
|
|
|
|
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 $disk->download($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()->hasRole('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->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,
|
|
];
|
|
});
|
|
|
|
// 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";
|
|
}
|
|
|
|
|
|
function printStatementRekening($accountNumber, $period, $periodTo = null, $stmtSentType = null) {
|
|
$period = $period ?? 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($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()
|
|
]);
|
|
}
|
|
}
|
|
}
|