芝麻web文件管理V1.00

编辑当前文件:/home/rejoandoctor/medicine.joruridoctor.com/app/Http/Controllers/AdminController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\Rules;

use App\Models\ProductModel;
use App\Models\StockModel;
use App\Models\TempModel;
use App\Models\ProductInModel;
use App\Models\ProductOutModel;
use App\Models\TempOutModel;
use Session;
use DB; 
use Carbon\Carbon;

class AdminController extends Controller
{
    public function index()
    {
        // Code for displaying admin dashboard
        return view('admin.dashboard');
    }

public function addProduct()
    {
        return view('admin.addProduct');
    }

function storeProduct(Request $request)
    {
        // Validate the request
        $request->validate([
            'product_name' => 'required|string|max:255|unique:products',
        ]);

// List of products to be added
        ProductModel::create([
            'products_name' => $request->product_name,
        ]);
        
        session::flash('success', 'Products Added!');
		return redirect()->route('products.manage');
    }

public function manageProduct()
    {
        // Fetch all products (without pagination for DataTables to handle it)
        $products = ProductModel::get();
        return view('admin.manageProduct', compact('products'));
    }

public function editProduct($id)
    {
        $product = ProductModel::findOrFail($id);
        return view('admin.editProduct', compact('product'));
    }

public function updateProduct(Request $request, $id)
    {
        // Validate and update the product
        $request->validate([
            'product_name' => 'required|string|max:255|unique:products',
        ]);

$product = ProductModel::findOrFail($id);
        $product->update([
            'product_name' => $request->product_name,
        ]);

Session::flash('success', 'Products Updated!');
		return redirect()->route('products.manage');
    }

public function deleteProduct($id)
    {
        // Delete the product
        $product = ProductModel::findOrFail($id);
        $product->delete();

Session::flash('success', 'Products Deleted!');
		return redirect()->route('products.manage');
    }

// Product Indent

public function productIn()
    {
           $tempProducts = DB::table('tempin')
            ->join('products', 'tempin.product_id', '=', 'products.id')
            ->select('tempin.*', 'products.product_name')
            ->get();

return view('admin.productIn', compact('tempProducts'));
    }

public function searchProducts(Request $request)
    {
        $query = $request->get('query');
        $products = ProductModel::where('product_name', 'like', "%{$query}%")->get();
        return response()->json($products);
    }
    
    public function searchProductsForStock(Request $request)
    {
        $query = $request->get('query');
    
        $products = ProductModel::where('product_name', 'like', "%{$query}%")
            ->whereHas('stock') // Ensures only products that exist in StockModel are fetched
            ->get();
    
        return response()->json($products);
    }

public function tempStoreProduct(Request $request)
    {
        try {
            $request->validate([
                'product_id' => 'required|exists:products,id',
                'quantity'   => 'required|integer|min:1',
                'date'       => 'required|date',
            ]);

// Generate or reuse invoice number from session
            if (!Session::has('invoice_number')) {
                Session::put('invoice_number', $request->invoice);
            }

$invoice_number = Session::get('invoice_number');

// Check if product already exists in temp
            $exists = TempModel::where('product_id', $request->product_id)
                                ->where('invoice', $invoice_number)
                                ->exists();

if ($exists) {
                return response()->json(['status' => 'exists']);
            }

TempModel::create([
                'invoice'    => $invoice_number,
                'product_id' => $request->product_id,
                'quantity'   => $request->quantity,
                'date'       => $request->date,
            ]);

return response()->json(['status' => 'success']);

} catch (\Exception $e) {
            return response()->json([
                'status' => 'error',
                'message' => $e->getMessage()
            ], 500);
        }
    }

public function removeProductFromTemp($productId)
    {
        TempModel::where('id', $productId)->delete();

return redirect()->back()->with('success', 'Product removed successfully!');
    }

public function updateTempProductQty(Request $request)
    {
        $request->validate([
            'id' => 'required|exists:tempin,id',
            'quantity' => 'required|integer|min:1',
        ]);

TempModel::where('id', $request->id)->update([
            'quantity' => $request->quantity,
        ]);

return response()->json(['status' => 'success']);
    }

public function storeProductIn(Request $request)
    {
        // Fetch all products from temporary table
        $tempProducts = TempModel::all();

if ($tempProducts->isEmpty()) {
            return redirect()->back()->with('error', 'No products to store.');
        }

foreach ($tempProducts as $item) {
            // Store in ProductInModel
            ProductInModel::create([
                'invoice'    => $item->invoice,
                'product_id' => $item->product_id,
                'qty'        => $item->quantity,
                'date'       => $item->date,
            ]);

// Update or create stock entry
            $stock = StockModel::firstOrNew(['product_id' => $item->product_id]);
            $stock->stock_qty = ($stock->stock_qty ?? 0) + $item->quantity;
            $stock->save();
        }

// Clear temporary table after successful insertion
        TempModel::truncate();
        Session::forget('invoice_number');

return redirect()->back()->with('success', 'Products successfully stored and stock updated.');
    }

public function manageProductIn()
    {
        $invoices = ProductInModel::select('invoice', 'date')
            ->distinct()
            ->orderBy('date', 'desc')
            ->get();

return view('admin.manageProductIn', compact('invoices'));
    }

public function invoiceDetails($invoice)
    {
        $invoiceProducts = ProductInModel::with('product')
                            ->where('invoice', $invoice)
                            ->get();

return view('admin.invoiceDetails', compact('invoice', 'invoiceProducts'));
    }

public function editInvoice($invoice)
    {
        $invoiceProducts = ProductInModel::where('invoice', $invoice)->get();

foreach ($invoiceProducts as $item) {
            
            // Move to temp table
            TempModel::create([
                'invoice'    => $item->invoice,
                'product_id' => $item->product_id,
                'quantity'   => $item->qty,
                'date'       => $item->date,
            ]);

// Adjust stock quantity
            $stock = StockModel::where('product_id', $item->product_id)->first();
            if ($stock) {
                $stock->stock_qty -= $item->qty;
                $stock->save();
            }

// Delete from ProductInModel
            $item->delete();
        }

return redirect()->route('productIn')->with('success', 'Invoice moved to temporary editing successfully.');
    }

public function updateInvoice(Request $request, $invoice)
    {
        foreach ($request->items as $itemId => $qty) {
            ProductInModel::where('id', $item_id = $request->id[$item])->update([
                'qty' => $request->quantity[$itemId],
            ]);
        }

return redirect()->route('productIn.manage')->with('success', 'Invoice updated successfully.');
    }

// Stock

public function manageStock()
    {
        $stocks = StockModel::with('product')->get();

return view('admin.stock', compact('stocks'));
    }

// Product Out

public function manageProductOut()
    {
        $invoices = ProductOutModel::select('invoice', 'date')
            ->distinct()
            ->orderBy('date', 'desc')
            ->get();

return view('admin.manageProductOut', compact('invoices'));
    }

public function createProductOut()
    {
        $products = ProductModel::all();
        return view('admin.addProductOut', compact('products'));
    }

public function tempStoreProductOut(Request $request)
    {
        $request->validate([
            'product_id' => 'required|exists:products,id',
            'quantity'   => 'required|integer|min:1',
            'date'       => 'required|date',
        ]);

// Generate or reuse invoice number from session
        if (!Session::has('invoice_number')) {
            Session::put('invoice_number', date("d-M-Yhis"));
        }
        $invoice_number = Session::get('invoice_number');

// Check if product already exists in temp
        $exists = TempOutModel::where('product_id', $request->product_id)->exists();

if ($exists) {
            return response()->json(['status' => 'exists']);
        }

TempOutModel::create([
            'invoice'    => $invoice_number,
            'product_id' => $request->product_id,
            'quantity'   => $request->quantity,
            'date'       => $request->date,
        ]);

return response()->json(['status' => 'success']);
    }

public function fetchTempProducts()
    {
        $tempProducts = TempOutModel::with('product')->get();
        return response()->json($tempProducts);
    }

public function updateTempProductOutQty(Request $request)
    {
        $request->validate([
            'id' => 'required|exists:tempout,id',
            'quantity' => 'required|integer|min:1',
        ]);

TempOutModel::where('id', $request->id)->update([
            'quantity' => $request->quantity,
        ]);

return response()->json(['status' => 'success']);
    }

public function removeProductOutFromTemp($id)
    {
        TempOutModel::where('id', $id)->delete();
        return response()->json(['status' => 'success']);
    }

public function storeProductOut(Request $request)
    {
        try {
            DB::beginTransaction(); // Start transaction

$tempProducts = TempOutModel::all();

if ($tempProducts->isEmpty()) {
                return response()->json(['status' => 'error', 'message' => 'No products to process.']);
            }

foreach ($tempProducts as $item) {
                // Fetch stock before processing
                $stock = StockModel::where('product_id', $item->product_id)->first();

if (!$stock) {
                    return response()->json(['status' => 'error', 'message' => 'Stock entry not found ' . $item->product->product_name]);
                }

if ($stock->stock_qty < $item->quantity) {
                    return response()->json(['status' => 'error', 'message' => 'Input Quantity Insufficient Stock ' . $item->product->product_name]);
                }

// Deduct stock
                $stock->decrement('stock_qty', $item->quantity);

// Store in ProductOutModel
                ProductOutModel::create([
                    'invoice'    => $item->invoice,
                    'product_id' => $item->product_id,
                    'qty'        => $item->quantity,
                    'date'       => $item->date,
                ]);
            }

// Remove only processed products from temp table
            TempOutModel::whereIn('id', $tempProducts->pluck('id'))->delete();
            Session::forget('invoice_number');

DB::commit(); // Commit transaction

return response()->json(['status' => 'success']);

} catch (\Exception $e) {
            DB::rollBack(); // Rollback if something goes wrong
            return response()->json(['status' => 'error', 'message' => $e->getMessage()], 500);
        }
    }

public function productOutInvoiceDetails($invoice)
    {
        $invoiceProducts = ProductOutModel::with('product')
                            ->where('invoice', $invoice)
                            ->get();

return view('admin.invoiceDetails', compact('invoice', 'invoiceProducts'));
    }

public function editProductOutInvoice($invoice)
    {
        $invoiceProducts = ProductOutModel::where('invoice', $invoice)->get();

foreach ($invoiceProducts as $item) {
            
            // Move to temp table
            TempOutModel::create([
                'invoice'    => $item->invoice,
                'product_id' => $item->product_id,
                'quantity'   => $item->qty,
                'date'       => $item->date,
            ]);

// Adjust stock quantity
            $stock = StockModel::where('product_id', $item->product_id)->first();
            if ($stock) {
                $stock->stock_qty += $item->qty;
                $stock->save();
            }

// Delete from ProductInModel
            $item->delete();
        }

return redirect()->route('productOut')->with('success', 'Invoice moved to temporary editing successfully.');
    }

public function updateOutInvoice(Request $request)
{
    try {
        DB::beginTransaction(); // Ensure safe updates

// Fetch the invoice number from tempOut
        $tempProducts = TempOutModel::all();

if ($tempProducts->isEmpty()) {
            return redirect()->back()->with('error', 'No products to update.');
        }

$invoice = $tempProducts->first()->invoice;

foreach ($tempProducts as $item) {
            // Reduce stock before inserting into ProductOutModel
            $stock = StockModel::where('product_id', $item->product_id)->first();

if (!$stock || $stock->stock_qty < $item->quantity) {
                return redirect()->back()->with('error', 'Insufficient stock for product ID: ' . $item->product_id);
            }

// Deduct stock
            $stock->decrement('stock_qty', $item->quantity);

// Save updated product to ProductOutModel
            ProductOutModel::create([
                'invoice'    => $invoice,
                'product_id' => $item->product_id,
                'qty'        => $item->quantity,
                'date'       => $item->date,
            ]);
        }

// Clear tempOut table
        TempOutModel::truncate();

DB::commit();
        return redirect()->route('productOut.manage')->with('success', 'Invoice updated successfully.');

} catch (\Exception $e) {
        DB::rollBack();
        return redirect()->back()->with('error', 'Error updating invoice: ' . $e->getMessage());
    }
}

public function deleteProductOut($id)
    {
        $productOut = ProductOutModel::findOrFail($id);

// Restore stock
        $stock = StockModel::where('product_id', $productOut->product_id)->first();
        if ($stock) {
            $stock->stock_qty += $productOut->quantity;
            $stock->save();
        }

$productOut->delete();

return redirect()->route('productOut.manage')->with('success', 'Product out entry deleted and stock restored.');
    }

}