<?php

namespace App\Http\Controllers\Api;

use Illuminate\Support\Facades\DB;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use App\User;
use Auth;
use Ramsey\Uuid\Uuid;
use App\Http\Controllers\Controller;

class StorageController extends Controller
{
    public function getStorage(Request $request)
    {
        $user=Auth::guard('api')->user();
        $headers = apache_request_headers();
        
        return response()->json($headers, 200);

        $storage=DB::connection($headers['cdb'])->select('SELECT t1.ShortName  
                                                       FROM storage t1' );


        return response()->json($storage, 200);
    }
    public function makeSerialNumberRangeStorageIn(Request $request)
    {
        # Elkészíti automatikusan a StorageInRowsRange segéd táblát
        try
        {
            $headers = apache_request_headers();
            $fullarray = array();
            DB::connection($headers['cdb'])->beginTransaction();
            DB::connection($headers['cdb'])->update('UPDATE StorageInRows SET StorageInRowsRange=NULL WHERE StorageInHeader = ?', [$request['storageinheader']]);
            DB::connection($headers['cdb'])->delete('DELETE FROM StorageInRowsRange WHERE StorageInHeader = ?', 
                                                    [
                                                        $request['storageinheader']
                                                    ]);

            $storageinrowsbyproducts=DB::connection($headers['cdb'])->
                           select('SELECT t1.Products 
                                   FROM StorageInRows t1 JOIN Products t2 on
                                        t1.Products=t2.Oid
                                        WHERE t1.StorageInHeader = ? AND t2.IsSerialNumber = 1
                                        GROUP BY t1.Products', 
                                        [
                                            $request['storageinheader']
                                        ]);
            if (count($storageinrowsbyproducts) > 0) 
            {
                foreach ($storageinrowsbyproducts as $key => $storageinrowsbyproduct) {
                    
                
                    $storageinrows=DB::connection($headers['cdb'])->select('SELECT * 
                                                                            FROM StorageInRows t1 JOIN StorageInHeader t2 ON
                                                                                 t1.StorageInHeader = t2.Oid
                                                                            WHERE Products = ? AND t2.Oid = ?
                                                                            ORDER BY t1.SerialNumber ASC',
                                                                            [
                                                                                $storageinrowsbyproduct->Products,
                                                                                $request['storageinheader']
                                                                            ]); 
                    
                    $rangestart='';
                    $rangestop='';
                    $qtt=1;
                    // return response()->json($storageinrows[0+1], 200); 
                    for ($i=0; $i < count($storageinrows); $i++) { 
                    
                    
                        if ($i == 0) {
                            $rangestart=$storageinrows[$i]->SerialNumber;
                            $rangestop=$storageinrows[$i]->SerialNumber;
                        }
                        if ($i < count($storageinrows)-1) {
                            
                            $curnext=(float)($storageinrows[$i+1]->SerialNumber);
                            $cur=(float)($storageinrows[$i]->SerialNumber);
                            if ($cur == $curnext-1) 
                            {
                                $qtt = $qtt +1;
                                $rangestop=$storageinrows[$i+1]->SerialNumber;
                            }
                            else
                            {
                                #Be a tömbbe ... 
                                // $rangestop=$storageinrows[$i]->SerialNumber;
                                $fullarray[$storageinrowsbyproduct->Products][] = ['rangestart' => $rangestart, 'rangestop'=>$rangestop, 'qtt' => $qtt];
                                # Be az adatbázisba ... :)
                                $uuid = Uuid::uuid1();
                                DB::connection($headers['cdb'])->insert('INSERT INTO StorageInRowsRange (Oid, StorageInHeader, Products, QTT, SerialNumberFrom, SerialNumberTo)
                                                                         VALUES (? , ?, ?, ?, ?, ?)',
                                                                          [
                                                                              $uuid,
                                                                              $request['storageinheader'],
                                                                              $storageinrowsbyproduct->Products,
                                                                              $qtt,
                                                                              $rangestart,
                                                                              $rangestop
                                                                          ]);
                                DB::connection($headers['cdb'])->update('UPDATE StorageInRows set StorageInRowsRange = ?
                                                                         WHERE StorageInHeader = ? AND Products = ? And SerialNumber >= ? AND SerialNumber <= ?', 
                                                                         [
                                                                            $uuid,
                                                                            $request['storageinheader'],
                                                                            $storageinrowsbyproduct->Products,
                                                                            $rangestart,
                                                                            $rangestop
                                                                         ]);

                                $rangestart=$storageinrows[$i+1]->SerialNumber;
                                $qtt = 1;
                            }        
                        }
                        if ($i == count($storageinrows) - 1) {
                            $rangestop=$storageinrows[$i]->SerialNumber;
                            #Be a tömbbe ...
                            $fullarray[$storageinrowsbyproduct->Products][] = ['rangestart' => $rangestart, 'rangestop'=>$rangestop, 'qtt' => $qtt];
                            $uuid = Uuid::uuid1();
                            DB::connection($headers['cdb'])->insert('INSERT INTO StorageInRowsRange (Oid, StorageInHeader, Products, QTT, SerialNumberFrom, SerialNumberTo)
                                                                         VALUES (? , ?, ?, ?, ?, ?)',
                                                                          [
                                                                              $uuid,
                                                                              $request['storageinheader'],
                                                                              $storageinrowsbyproduct->Products,
                                                                              $qtt,
                                                                              $rangestart,
                                                                              $rangestop
                                                                          ]);
                            DB::connection($headers['cdb'])->update('UPDATE StorageInRows set StorageInRowsRange = ?
                                                                    WHERE StorageInHeader = ? AND Products = ? And SerialNumber >= ? AND SerialNumber <= ?', 
                                                                    [
                                                                        $uuid,
                                                                        $request['storageinheader'],
                                                                        $storageinrowsbyproduct->Products,
                                                                        $rangestart,
                                                                        $rangestop
                                                                    ]);
 
                        }
                        
                    }
                    
                }
            }                            
            DB::connection($headers['cdb'])->commit();
            return response()->json("OK", 200);                                                        
        }
        catch (Exception $e) 
        {
            return response()->json($e->getMessage(), 500);
        }
    }
    public function makeSerialNumberRangeStorageOut(Request $request)
    {
        # Elkészíti automatikusan a StorageInRowsRange segéd táblát
        try
        {
            $headers = apache_request_headers();
            $fullarray = array();
            DB::connection($headers['cdb'])->beginTransaction();
            DB::connection($headers['cdb'])->update('UPDATE StorageOutRows SET StorageOutRowsRange=NULL WHERE StorageOutHeader = ?', [$request['storageoutheader']]);
            DB::connection($headers['cdb'])->delete('DELETE FROM StorageOutRowsRange WHERE StorageOutHeader = ?', 
                                                    [
                                                        $request['storageoutheader']
                                                    ]);

            $storageoutrowsbyproducts=DB::connection($headers['cdb'])->
                           select('SELECT t1.Products 
                                   FROM StorageOutRows t3 JOIN StorageInRows t1 ON 
                                        t3.StorageInRows = t1.Oid JOIN Products t2 on
                                        t1.Products=t2.Oid
                                        WHERE t3.StorageOutHeader = ? AND t2.IsSerialNumber = 1
                                        GROUP BY t1.Products', 
                                        [
                                            $request['storageoutheader']
                                        ]);
            if (count($storageoutrowsbyproducts) > 0) 
            {
                foreach ($storageoutrowsbyproducts as $key => $storageoutrowsbyproduct) {
                    
                
                    $storageoutrows=DB::connection($headers['cdb'])->select('SELECT * 
                                                                            FROM StorageOutRows t3 JOIN StorageInRows t1 ON
                                                                                 t3.StorageInRows = t1.Oid JOIN StorageInHeader t2 ON
                                                                                 t1.StorageInHeader = t2.Oid
                                                                            WHERE Products = ? AND t3.StorageOutHeader = ?
                                                                            ORDER BY t1.SerialNumber ASC',
                                                                            [
                                                                                $storageoutrowsbyproduct->Products,
                                                                                $request['storageoutheader']
                                                                            ]); 
                    
                    $rangestart='';
                    $rangestop='';
                    $qtt=1;
                    // return response()->json($storageinrows[0+1], 200); 
                    for ($i=0; $i < count($storageoutrows); $i++) { 
                    
                    
                        if ($i == 0) {
                            $rangestart=$storageoutrows[$i]->SerialNumber;
                            $rangestop=$storageoutrows[$i]->SerialNumber;
                        }
                        if ($i < count($storageoutrows)-1) {
                            
                            $curnext=(float)($storageoutrows[$i+1]->SerialNumber);
                            $cur=(float)($storageoutrows[$i]->SerialNumber);
                            if ($cur == $curnext-1) 
                            {
                                $qtt = $qtt +1;
                                $rangestop=$storageoutrows[$i+1]->SerialNumber;
                            }
                            else
                            {
                                #Be a tömbbe ... 
                                // $rangestop=$storageinrows[$i]->SerialNumber;
                                $fullarray[$storageoutrowsbyproduct->Products][] = ['rangestart' => $rangestart, 'rangestop'=>$rangestop, 'qtt' => $qtt];
                                # Be az adatbázisba ... :)
                                $uuid = Uuid::uuid1();
                                DB::connection($headers['cdb'])->insert('INSERT INTO StorageOutRowsRange (Oid, StorageOutHeader, Products, QTT, SerialNumberFrom, SerialNumberTo)
                                                                         VALUES (? , ?, ?, ?, ?, ?)',
                                                                          [
                                                                              $uuid,
                                                                              $request['storageoutheader'],
                                                                              $storageoutrowsbyproduct->Products,
                                                                              $qtt,
                                                                              $rangestart,
                                                                              $rangestop
                                                                          ]);
                                DB::connection($headers['cdb'])->update('UPDATE StorageOutRows t1 JOIN StorageInRows t2 ON 
                                                                                t1.StorageInRows=t2.Oid 
                                                                         SET t1.StorageOutRowsRange = ?
                                                                         WHERE t1.StorageOutHeader = ? AND t2.Products = ? And t2.SerialNumber >= ? AND t2.SerialNumber <= ?', 
                                                                         [
                                                                            $uuid,
                                                                            $request['storageOutheader'],
                                                                            $storageoutrowsbyproduct->Products,
                                                                            $rangestart,
                                                                            $rangestop
                                                                         ]);

                                $rangestart=$storageoutrows[$i+1]->SerialNumber;
                                $qtt = 1;
                            }        
                        }
                        if ($i == count($storageoutrows) - 1) {
                            $rangestop=$storageoutrows[$i]->SerialNumber;
                            #Be a tömbbe ...
                            $fullarray[$storageoutrowsbyproduct->Products][] = ['rangestart' => $rangestart, 'rangestop'=>$rangestop, 'qtt' => $qtt];
                            $uuid = Uuid::uuid1();
                            DB::connection($headers['cdb'])->insert('INSERT INTO StorageOutRowsRange (Oid, StorageOutHeader, Products, QTT, SerialNumberFrom, SerialNumberTo)
                                                                         VALUES (? , ?, ?, ?, ?, ?)',
                                                                          [
                                                                              $uuid,
                                                                              $request['storageoutheader'],
                                                                              $storageoutrowsbyproduct->Products,
                                                                              $qtt,
                                                                              $rangestart,
                                                                              $rangestop
                                                                          ]);
                            DB::connection($headers['cdb'])->update('UPDATE StorageOutRows t1 JOIN StorageInRows t2 ON 
                                                                            t1.StorageInRows=t2.Oid 
                                                                    SET t1.StorageOutRowsRange = ?
                                                                    WHERE t1.StorageOutHeader = ? AND t2.Products = ? And t2.SerialNumber >= ? AND t2.SerialNumber <= ?', 
                                                                    [
                                                                        $uuid,
                                                                        $request['storageoutheader'],
                                                                        $storageoutrowsbyproduct->Products,
                                                                        $rangestart,
                                                                        $rangestop
                                                                    ]);
 
                        }
                        
                    }
                    
                }
            }                            
            DB::connection($headers['cdb'])->commit();
            return response()->json("OK", 200);                                                        
        }
        catch (Exception $e) 
        {
            return response()->json($e->getMessage(), 500);
        }
    }
    
    # Storage In
    public function addItemStorageIn(Request $request)
    {
        try 
        {
            $headers = apache_request_headers();

            $packetnumber="";
            $serialnumber="";
            $responsetext="OK";

            if ($request['packetnumber']==null) { $packetnumber="";}else{$packetnumber=$request['packetnumber'];}
            if ($request['serialnumber']==null) { $serialnumber="";}else{$serialnumber=$request['serialnumber'];}
            
            //return response()->json($request['serialnumber']==null, 200);

            DB::connection($headers['cdb'])->beginTransaction();
            $qtt_will=1;
            $products=DB::connection($headers['cdb'])->select('SELECT * 
                                  FROM Products 
                                  WHERE Oid = ?', [$request['products']]);
            
            //return response()->json($request['products'], 200);
            
            if ($products[0]->IsSerialNumber) {
                $qtt_will=1;
            }
            else 
            {
                $qtt_will=$request['qtt_will'];        
            }         

            $storageinheader=DB::connection($headers['cdb'])->select('SELECT * FROM StorageInHeader 
                                         WHERE Oid=?', [$request['storageinheader']]);
            if ($storageinheader[0]->IsEditable != 1) {
                return response()->json("Nem szerkeszthető kitárolás!", 200);
            }
            
            $storagecomputed=count(DB::connection($headers['cdb'])->select('SELECT * FROM StorageComputed 
                                          WHERE Storage=? AND Products=?', [$storageinheader[0]->Storage,$request['products']]));

            $count=count(DB::connection($headers['cdb'])->select('SELECT * FROM StorageInRows 
                                     WHERE StorageInHeader=?', [$request['storageinheader']]));
            
            if ($products[0]->IsPacketNumber && !$products[0]->IsSerialNumber) {
                # Ha kötegszámos tétel 
                $data=count(DB::connection($headers['cdb'])->select('SELECT * FROM StorageInRows 
                                WHERE StorageInHeader=? AND PacketNumber=? AND Products=? AND PriceHUF=?',
                                [
                                    $request['storageinheader'],
                                    $request['packetnumber'],
                                    $request['products'],
                                    $request['pricehuf']
                                ]));
                if ($data==0) {
                    //StorageInRows beállítása
                    //-----------------------------------------------------------------------------------------------------------------------
                    DB::connection($headers['cdb'])->insert('INSERT INTO StorageInRows (Oid, StorageInHeader, PacketNumber, Products, QTT_Will, QTT_Out, QTT_Out_Will, RowIndex, PriceHUF, PriceAmountHUF) 
                                VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?,? )', 
                                [
                                    $request['storageinheader'], 
                                    $packetnumber,
                                    $request['products'],
                                    $qtt_will,0,0,$count+1,
                                    $request['pricehuf'],
                                    $request['pricehuf']*$qtt_will
                                ]);
                }
                else
                {
                    DB::connection($headers['cdb'])->update('UPDATE StorageInRows set QTT_Will=QTT_Will + ?, PriceAmountHUF=PriceHUF * (QTT_Will + ?) 
                                WHERE StorageInHeader=? AND PacketNumber=? AND Products=?',
                                [
                                    $qtt_will,
                                    $qtt_will,
                                    $request['storageinheader'],
                                    $packetnumber,
                                    $request['products']
                                ]);
                }
                // StorageComputed beállítása            
                //----------------------------------------------------------------------------------------------------------------------
                if ($storagecomputed==0) {
                    DB::connection($headers['cdb'])->insert('INSERT INTO StorageComputed (Oid, Products,Storage,QTT,IsLocked,QTTReservedIn,QTTReservedOut) 
                            VALUES (UUID(), ?, ?, ?, ?, ?, ?)', 
                            [$request['products'],
                            $storageinheader[0]->Storage, 
                            0,0,$qtt_will,0]);
                }else {
                        DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTTReservedIn=QTTReservedIn+? 
                                    WHERE Storage=? AND Products=?', [$qtt_will,$storageinheader[0]->Storage,$request['products']]);
                }                    
            }
            if ($products[0]->IsSerialNumber) {
                # Ha gyáriszámos tétel
                
                
                if ($request['serialnumberinputmode'] == 0) 
                {
                    # Ha egy darab gyáriszámot adott meg
                    $data=count(DB::connection($headers['cdb'])->select('SELECT * FROM StorageInRows 
                    WHERE SerialNumber=? AND Products=? AND ((IFNULL(QTT,0) > IFNULL(QTT_Out,0)) OR IFNULL(QTT_Will,0) > 0)',
                    [
                        $request['serialnumber'],
                        $request['products']
                    ]));    
                    if ($data==0) 
                    {
                        //StorageInRows beállítása
                        //-----------------------------------------------------------------------------------------------------------------------
                        if (!isset($request['storageinrowsrange'])) { $storageinrowsrange=NULL; }else{$storageinrowsrange=$request['storageinrowsrange'];}
                        DB::connection($headers['cdb'])->insert('INSERT INTO 
                                    StorageInRows (Oid, StorageInHeader, SerialNumber, Products, QTT_Will, QTT_Out, QTT_Out_Will, RowIndex, PriceHUF, PriceAmountHUF, StorageInRowsRange) 
                                    VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', 
                                    [
                                        $request['storageinheader'], 
                                        $request['serialnumber'],
                                        $request['products'],
                                        1,0,0,$count+1,
                                        $request['pricehuf'],
                                        $request['pricehuf'],
                                        $storageinrowsrange
                                    ]);
                        
                        // StorageComputed beállítása            
                        //----------------------------------------------------------------------------------------------------------------------
                        if ($storagecomputed==0) {
                            DB::connection($headers['cdb'])->insert('INSERT INTO StorageComputed (Oid, Products, Storage, QTT, IsLocked, QTTReservedIn, QTTReservedOut) 
                                    VALUES (UUID(), ?, ?, ?, ?, ?, ?)', 
                                    [
                                        $request['products'],
                                        $storageinheader[0]->Storage, 
                                        0,0,1,0
                                    ]);
                        }else {
                                DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTTReservedIn=QTTReservedIn+? 
                                            WHERE Storage=? AND Products=?', 
                                            [
                                                $qtt_will,
                                                $storageinheader[0]->Storage,
                                                $request['products']
                                            ]);
                        }
                    }
                    else
                    {
                        $responsetext="Már be lett tárolva ! (".$request['serialnumber'].")";
                        return response()->json($responsetext, 200);    
                    }
                }
                else 
                {
                    $serialnumberfrom=$request['serialnumberfrom'];
                    $serialnumberto=$request['serialnumberto'];

                    // return response()->json($serialnumberto, 200); 
                    DB::insert('INSERT INTO StorageInRowsRange (Oid, StorageInHeader, ) 
                                VALUES (?, ?)', 
                                [
                                    1, 'Dayle'
                                ]);
                    
                    for ($i=$serialnumberfrom; $i<=$serialnumberto; $i++) { 
                        $data=count(DB::connection($headers['cdb'])->select('SELECT * FROM StorageInRows 
                        WHERE SerialNumber=? AND Products=? AND ((IFNULL(QTT,0) > IFNULL(QTT_Out,0)) OR IFNULL(QTT_Will,0) > 0)',
                        [
                            $i,
                            $request['products']
                        ]));    
                        if ($data==0) 
                        {
                            //StorageInRows beállítása
                            //-----------------------------------------------------------------------------------------------------------------------
                            DB::connection($headers['cdb'])->insert('INSERT INTO StorageInRows (Oid, StorageInHeader, SerialNumber, Products, QTT_Will, 
                                                                                                QTT_Out, QTT_Out_Will, RowIndex, PriceHUF, PriceAmountHUF) 
                                        VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?, ?)', 
                                        [
                                            $request['storageinheader'], 
                                            $i,
                                            $request['products'],
                                            1,0,0,$count+1,
                                            $request['pricehuf'],
                                            $request['pricehuf']
                                        ]);
                            
                            // StorageComputed beállítása            
                            //----------------------------------------------------------------------------------------------------------------------
                            if ($storagecomputed==0) {
                                DB::connection($headers['cdb'])->insert('INSERT INTO StorageComputed (Oid, Products,Storage,QTT,IsLocked,QTTReservedIn,QTTReservedOut) 
                                        VALUES (UUID(), ?, ?, ?, ?, ?, ?)', 
                                        [$request['products'],
                                        $storageinheader[0]->Storage, 
                                        0,0,1,0]);
                            }else {
                                    DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTTReservedIn=QTTReservedIn+? 
                                                WHERE Storage=? AND Products=?', [$qtt_will,$storageinheader[0]->Storage,$request['products']]);
                            }
                        }
                        else
                        {
                            $responsetext="Már be lett tárolva ! (".$request['serialnumber'].")";
                            return response()->json($responsetext, 200);    
                        }   
                    }
                }
            }
            if (!$products[0]->IsPacketNumber && !$products[0]->IsSerialNumber) {
                # Ha NEM gyáriszámos és NEM kötegszámos, akkor
                $data=count(DB::connection($headers['cdb'])->select('SELECT * FROM StorageInRows 
                                WHERE StorageInHeader=? AND Products=? AND PriceHUF = ?',
                                [
                                    $request['storageinheader'],
                                    $request['products'],
                                    $request['pricehuf']
                                ]));
                if ($data==0) {
                    //StorageInRows beállítása
                    //-----------------------------------------------------------------------------------------------------------------------
                    DB::connection($headers['cdb'])->insert('INSERT INTO StorageInRows (Oid, StorageInHeader, Products, QTT_Will, QTT_Out, QTT_Out_Will, RowIndex, PriceHUF, PriceAmountHUF) 
                                VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ? )', 
                                [
                                    $request['storageinheader'], 
                                    $request['products'],
                                    $qtt_will,0,0,$count + 1,
                                    $request['pricehuf'],
                                    $request['pricehuf'] * $qtt_will
                                ]);
                }
                else
                {
                    DB::connection($headers['cdb'])->update('UPDATE StorageInRows set QTT_Will = QTT_Will + ?, PriceAmountHUF = PriceHUF * (QTT_Will + ?)
                                WHERE StorageInHeader=? AND Products=? AND PriceHUF = ?',
                                [
                                    $qtt_will,
                                    $qtt_will,
                                    $request['storageinheader'],
                                    $request['products'],
                                    $request['pricehuf']
                                ]);
                }
                // StorageComputed beállítása            
                //----------------------------------------------------------------------------------------------------------------------
                if ($storagecomputed==0) {
                    DB::connection($headers['cdb'])->insert('INSERT INTO StorageComputed (Oid, Products,Storage,QTT,IsLocked,QTTReservedIn,QTTReservedOut) 
                            VALUES (UUID(), ?, ?, ?, ?, ?, ?)', 
                            [$request['products'],
                            $storageinheader[0]->Storage, 
                            0,0,$qtt_will,0]);
                }else {
                        DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTTReservedIn=QTTReservedIn+? 
                                    WHERE Storage=? AND Products=?', [$qtt_will,$storageinheader[0]->Storage,$request['products']]);
                }                
            }
                                   
            
            DB::connection($headers['cdb'])->commit();
            return response()->json($responsetext, 200);    
        } 
        catch (Exception $e) 
        {
            return response()->json($e->getMessage(), 500);
        }
    }
    public function addItemGroupStorageIn(Request $request)
    {
        try
        {
            $headers = apache_request_headers();
            
            DB::connection($headers['cdb'])->beginTransaction();

            $uuid = Uuid::uuid1();
            DB::connection($headers['cdb'])->insert('INSERT INTO StorageInRowsRange (Oid, StorageInHeader, Products, SerialNumberFrom, SerialNumberTo,
                                                                                     PrefixTag, SuffixTag, SerialNumberDigit, QTT ) 
                                                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)', 
                                                    [
                                                        $uuid,
                                                        $request['storageinheader'],
                                                        $request['products'],
                                                        $request['serialnumberfrom'],
                                                        $request['serialnumberto'],
                                                        $request['prefixtag'],
                                                        $request['suffixtag'],
                                                        $request['serialnumberdigit'],
                                                        $request['serialnumberto']-$request['serialnumberfrom']+1
                                                    ]);
            $request->request->add(['packetnumber' => '']);
            $request->request->add(['qtt_will' => '1']);
            $request->request->add(['serialnumberinputmode' => 0]);
            $request->request->add(['storageinrowsrange' => $uuid]);
            foreach ($request['serialnumbers'] as $key => $serialnumber) {
                # Most kell meghívni egyenként a sor hozzáadást.
                $request->request->add(['serialnumber' => $serialnumber]);
                $response = $this->addItemStorageIn($request);
                if ($response->original != 'OK') {
                    return response()->json($response->original, 200);    
                }
            }
            
            $response = $this->makeSerialNumberRangeStorageIn($request);
            if ($response->original != 'OK') {
                return response()->json($response->original, 200);    
            }

            DB::connection($headers['cdb'])->commit();   
            return response()->json("OK", 200);    
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        }
        
    }
    public function removeItemStorageIn(Request $request)
    {
        try
        {
            $headers = apache_request_headers();

            $storageinrows=$request['storageinrows'];

            DB::connection($headers['cdb'])->beginTransaction();
            foreach ($storageinrows as $key => $storageinrow) {
                
                $sir=DB::connection($headers['cdb'])->select('SELECT t2.Storage,t1.Products,t1.RowIndex,t1.StorageInHeader,t2.IsEditable 
                                FROM StorageInRows t1 JOIN StorageInHeader t2 on
                                    t1.StorageInHeader=t2.Oid
                                WHERE t1.Oid = ?', [$storageinrow]);

                if (count($sir)>0) {
                    if ($sir[0]->IsEditable != 1) {
                        return response()->json("Nem szerkeszthető kitárolás!", 200);
                    }
                    DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTTReservedIn=QTTReservedIn-1 
                                WHERE Storage=? AND Products=?', [$sir[0]->Storage,$sir[0]->Products]);
                    DB::connection($headers['cdb'])->delete('DELETE FROM StorageInRows 
                                WHERE Oid = ?', [$storageinrow]);
                    DB::connection($headers['cdb'])->update('UPDATE StorageInRows set RowIndex=RowIndex-1
                                WHERE StorageInHeader=? AND RowIndex>?', [$sir[0]->StorageInHeader,$sir[0]->RowIndex]);            
                
                    $request->request->add(['storageinheader' => $sir[0]->StorageInHeader]);
                    $response = $this->makeSerialNumberRangeStorageIn($request);
                    if ($response->original != 'OK') {
                        return response()->json($response->original, 200);    
                    }
                }
            }
            DB::connection($headers['cdb'])->commit();
            
            return response()->json("OK", 200);
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        }
    }
    public function finalizeStorageIn(Request $request)
    {
        
        try
        {
            $headers = apache_request_headers();

            DB::connection($headers['cdb'])->beginTransaction();
            
            DB::connection($headers['cdb'])->update('UPDATE StorageInHeader set IsEditable=0,IsFinalized=1,
                                                            UserFinalized = ?, DateFinalized = NOW()
                        WHERE Oid = ?', [
                                            $request['usercreated'],
                                            $request['storageinheader']
                                        ]);
            
            $storageinrows=DB::connection($headers['cdb'])->select('SELECT t1.Oid,t2.Storage,t1.Products,t1.QTT_Will,t2.DocumentNumber,t1.SerialNumber,t2.DateExecution 
                                    FROM StorageInRows t1 JOIN StorageInHeader t2 on
                                            t1.StorageInHeader=t2.Oid 
                                    WHERE t1.StorageInHeader = ?', [$request['storageinheader']]);
            foreach ($storageinrows as $key => $storageinrow) {
                
                //StorageInRows frissítése
                DB::connection($headers['cdb'])->update('UPDATE StorageInRows 
                            SET QTT=QTT_Will,
                                QTT_Will=0 
                            WHERE Oid = ?', [$storageinrow->Oid]);
                
                // StorageComputed frissítése
                DB::connection($headers['cdb'])->update('UPDATE StorageComputed 
                            SET QTT=QTT+?,
                                QTTReservedIn=QTTReservedIn-?
                            WHERE Storage=? AND Products=?', [$storageinrow->QTT_Will,
                                                            $storageinrow->QTT_Will,
                                                            $storageinrow->Storage,
                                                            $storageinrow->Products]);   
                // Eseménynapló
                DB::connection($headers['cdb'])->insert('INSERT INTO StorageMoveEvents 
                            (Oid, Storage, Products, DocumentNumber, SerialNumber, DateExecution, MoveEventsType,ObjectCreated,UserCreated) 
                            VALUES (UUID(), ?, ?, ?, ?, ?, ?, NOW(), ?)', 
                            [
                                $storageinrow->Storage,
                                $storageinrow->Products,
                                $storageinrow->DocumentNumber,
                                $storageinrow->SerialNumber,
                                $storageinrow->DateExecution,
                                0,
                                $request['usercreated']
                            ]);

            }                                   


            DB::connection($headers['cdb'])->commit();
            return response()->json("OK", 200);
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        }
    }
    public function getStorageInHeader(Request $request)
    {
        try
        {
            $headers = apache_request_headers();

            // DB::connection($headers['cdb'])->beginTransaction();
            $storageinheader=DB::connection($headers['cdb'])->
            select('SELECT t1.Oid,
                           t1.DocumentNumber,
                           t1.DateExecution,
                           t2.ShortName as Storage_ShortName,
                           t1.IsEditable 
                    FROM StorageInHeader t1 join Storage t2 on
                         t1.Storage=t2.Oid
                    WHERE t1.Oid = ?', 
                    [
                        $request['storageinheader']
                    ]);
            $storageinrows=DB::connection($headers['cdb'])->
            select('SELECT t1.Oid,
                           t2.ProductNumber as Products_ProductNumber,
                           t2.ShortName as Products_ShortName,
                           t1.SerialNumber,
                           t1.PacketNumber,
                           t1.QTT,
                           t1.QTT_Will,
                           t1.QTT_Out,
                           t1.QTT_Out_Will 
                        FROM StorageInRows t1 left join Products t2 on
                             t1.Products=t2.Oid
                        WHERE t1.StorageInHeader = ?', 
                        [
                            $request['storageinheader']
                        ]);
            $vv_storageinrowsprint=DB::connection($headers['cdb'])->
            select('SELECT t1.Oid,
                           t2.ProductNumber as Products_ProductNumber,
                           t2.ShortName as Products_ShortName,
                           t1.SerialNumber,
                           t1.QTT
                        FROM vv_storageinrowsprint t1 left join Products t2 on
                             t1.Products=t2.Oid
                        WHERE t1.StorageInHeader = ?', 
                        [
                            $request['storageinheader']
                        ]);            
            $result=array();
            if (count($storageinheader)>0) {
                $result['storageinheader']=$storageinheader[0];
                $result['storageinrows']=$storageinrows;
                $result['vv_storageinrowsprint']=$vv_storageinrowsprint;
            }
            

            // DB::connection($headers['cdb'])->commit();
            return response()->json($result, 200); 
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        }    
    }
    public function listStorageInHeader($storage,$open)
    {
        # Visszatér a betárolási bizonylatok fejléc kollekciójával
        $user=Auth::guard('api')->user();
        
        $headers = apache_request_headers();
        $storageinheader=DB::connection($headers['cdb'])->
        select('SELECT t1.Oid,
                        t1.DocumentNumber,
                        t1.DateExecution,
                        t2.ShortName as Storage_ShortName,
                        t1.IsEditable 
                FROM StorageInHeader t1 join Storage t2 on
                        t1.Storage=t2.Oid
                WHERE t1.Storage = ? AND t1.IsEditable = ?', 
                [
                    $storage,
                    $open
                ]);
        
        return response()->json(["data"=>$storageinheader], 200);       
    }

    
    # Storage Out
    public function addItemStorageOut(Request $request)
    {
        # Kitárolási sor hozzáadása
        try 
        {
            $headers = apache_request_headers();

            if ($request['outmode'] == "eSerialNumber") 
            {
                # Ha gyáriszámos a kiadás
                DB::connection($headers['cdb'])->beginTransaction();

                $storageoutheader=DB::connection($headers['cdb'])->select('SELECT * FROM StorageOutHeader WHERE Oid = ?', [$request['storageoutheader']]);
                if ($storageoutheader[0]->IsEditable != 1) {
                    return response()->json("Nem szerkeszthető kitárolás!", 200);
                }
                $storageinrows=DB::connection($headers['cdb'])->select('SELECT * 
                                           FROM StorageInRows 
                                           WHERE Oid = ? AND IFNULL(QTT_Out_Will,0)=0 AND IFNULL(QTT_Out,0)=0', [$request['storageinrows']]);
                
                // return response()->json($storageinrows, 200);  
                
                if (count($storageinrows)==1) {
                    # Van cucc, ki lehet adni
                    # StorageComputed
                    DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTT = QTT-1, QTTReservedOut=QTTReservedOut+1 
                                WHERE  Storage = ? AND Products = ?', [$storageoutheader[0]->Storage,$storageinrows[0]->Products]);
                    #StorageOutRows
                    DB::connection($headers['cdb'])->insert('INSERT INTO StorageOutRows (Oid, StorageOutHeader, StorageInRows, QTT_Will, QTT) 
                                VALUES (UUID(), ?, ?, ?, ?)', 
                                [$request['storageoutheader'],
                                 $request['storageinrows'],
                                 1,0
                                ]
                            );
                    #StorageInRows update
                    DB::connection($headers['cdb'])->update('UPDATE StorageInRows set QTT_Out_Will = 1 WHERE  Oid = ?', [$request['storageinrows']]);

                }                           

                
                DB::connection($headers['cdb'])->commit();
                
            }
            if ($request['outmode'] == "ePacketNumber"){
                # Kötegszámos kitárolás
                DB::connection($headers['cdb'])->beginTransaction();

                $storageoutheader=DB::connection($headers['cdb'])->select('SELECT * FROM StorageOutHeader WHERE Oid = ?', 
                                              [
                                                  $request['storageoutheader']
                                              ]);
                if ($storageoutheader[0]->IsEditable != 1) {
                    return response()->json("Nem szerkeszthető kitárolás!", 200);
                }
                $storageinrows=DB::connection($headers['cdb'])->select('SELECT * 
                                           FROM StorageInRows 
                                           WHERE Oid = ? AND IFNULL(QTT_Out_Will,0)=0 AND IFNULL(QTT_Out,0)=0', 
                                           [
                                               $request['storageinrows']
                                           ]);
                
                if (count($storageinrows) == 0) {
                    return response()->json("Nincs raktáron elegendő mennyiség !", 200);    
                }
                
                $qtt_free = $storageinrows[0]->QTT - $storageinrows[0]->QTT_Out - $storageinrows[0]->QTT_Out_Will;
                $qtt_need = floatval($request['qtt_will']);
                if ($qtt_free >= $qtt_need)
                {
                    # Van cucc, ki lehet adni
                    # StorageComputed
                    DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTT = QTT - ?, QTTReservedOut=QTTReservedOut + ? 
                                WHERE  Storage = ? AND Products = ?', 
                                [
                                    $request['qtt_will'],
                                    $request['qtt_will'],
                                    $storageoutheader[0]->Storage,
                                    $storageinrows[0]->Products
                                ]);
                    #StorageOutRows
                    DB::connection($headers['cdb'])->insert('INSERT INTO StorageOutRows (Oid, StorageOutHeader, StorageInRows, QTT_Will, QTT) 
                                VALUES (UUID(), ?, ?, ?, ?)', 
                                [$request['storageoutheader'],
                                 $request['storageinrows'],
                                 $request['qtt_will'],0
                                ]
                            );
                    #StorageInRows update
                    DB::connection($headers['cdb'])->update('UPDATE StorageInRows set QTT_Out_Will = QTT_Out_Will + ? 
                                WHERE  Oid = ?', 
                                [
                                    $request['qtt_will'],
                                    $request['storageinrows']
                                ]);

                }                           

                
                DB::connection($headers['cdb'])->commit();
            }
            if ($request['outmode'] == "eProducts") {
                # Sima termék kiadás FIFO alapján
                
                DB::connection($headers['cdb'])->beginTransaction();

                $storageinrows=DB::connection($headers['cdb'])->select('SELECT t1.QTT,t1.QTT_Out,t1.QTT_Out_Will,t1.Oid 
                                           FROM StorageInRows t1 JOIN StorageInHeader t2 ON 
                                                t1.StorageInHeader = t2.Oid
                                           WHERE t2.Storage = ? AND 
                                                 t1.Products = ? AND 
                                                 t1.QTT > (t1.QTT_Out + t1.QTT_Out_Will) AND
                                                 t2.IsEditable = 0
                                           ORDER BY t2.DateExecution ASC', 
                                           [
                                                $request['storage'],
                                                $request['products']
                                            ]);
                $qtt_free = 0;
                $qtt_need = floatval($request['qtt_will']); 
                foreach ($storageinrows as $key => $storageinrow) 
                {
                    $qtt_free = $qtt_free + $storageinrow->QTT - $storageinrow->QTT_Out - $storageinrow->QTT_Out_Will;
                }

                // return response()->json($qtt_free, 200); 

                if ($qtt_free >= $qtt_need) 
                {
                    foreach ($storageinrows as $key => $storageinrow) 
                    {
                        $qtt_has = $storageinrow->QTT - $storageinrow->QTT_Out - $storageinrow->QTT_Out_Will;
                        if ($qtt_need <= $qtt_has) 
                        {
                            # Most kell a sor rögzítése
                            DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTT = QTT - ?, QTTReservedOut=QTTReservedOut + ? 
                            WHERE  Storage = ? AND Products = ?', 
                            [
                                $qtt_need,
                                $qtt_need,
                                $request['storage'],
                                $request['products']
                            ]);
                            #StorageOutRows
                            DB::connection($headers['cdb'])->insert('INSERT INTO StorageOutRows (Oid, StorageOutHeader, StorageInRows, QTT_Will, QTT) 
                                        VALUES (UUID(), ?, ?, ?, ?)', 
                                        [
                                            $request['storageoutheader'],
                                            $storageinrow->Oid,
                                            $qtt_need,0
                                        ]);
                            #StorageInRows update
                            DB::connection($headers['cdb'])->update('UPDATE StorageInRows set QTT_Out_Will = QTT_Out_Will + ? 
                                        WHERE  Oid = ?', 
                                        [
                                            $qtt_need,
                                            $storageinrow->Oid
                                        ]);

                            break;
                        }
                        else
                        {
                            # Most kell a sor rögzítése
                            DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTT = QTT-1, QTTReservedOut=QTTReservedOut + ? 
                            WHERE  Storage = ? AND Products = ?', 
                            [
                                $qtt_has,
                                $request['storage'],
                                $request['products']
                            ]);
                            #StorageOutRows
                            DB::connection($headers['cdb'])->insert('INSERT INTO StorageOutRows (Oid, StorageOutHeader, StorageInRows, QTT_Will, QTT) 
                                        VALUES (UUID(), ?, ?, ?, ?)', 
                                        [
                                            $request['storageoutheader'],
                                            $storageinrow->Oid,
                                            $qtt_has,0
                                        ]);
                            #StorageInRows update
                            DB::connection($headers['cdb'])->update('UPDATE StorageInRows set QTT_Out_Will = QTT_Out_Will + ? 
                                        WHERE  Oid = ?', 
                                        [
                                            $qtt_has,
                                            $storageinrow->Oid
                                        ]);
                            
                            $qtt_need = $qtt_need - $qtt_has;                            
                        }
                    }   
                }else
                {
                    return response()->json("Nincs raktáron elegendő mennyiség !", 200);    
                }
                DB::connection($headers['cdb'])->commit();                            
            }
            return response()->json("OK", 200);    
        } 
        catch (Exception $e) 
        {
            return response()->json($e->getMessage(), 500);
        }
    }
    public function addItemGroupStorageOut(Request $request)
    {
        try
        {
            $headers = apache_request_headers();
            
            DB::connection($headers['cdb'])->beginTransaction();

            $request->request->add(['packetnumber' => '']);
            $request->request->add(['outmode' => "eSerialNumber"]);
            
            foreach ($request['serialnumbers'] as $key => $serialnumber) {
                # Most kell meghívni egyenként a sor hozzáadást.
                $storageinrows=DB::connection($headers['cdb'])->
                         select('SELECT t1.Oid 
                                 FROM StorageInRows t1 join StorageInHeader t2 on
                                      t1.StorageInHeader=t2.Oid  
                                 WHERE t1.Products = ? AND t1.SerialNumber = ? AND
                                       t2.Storage = ? AND
                                       t1.QTT_Out = 0 AND t1.QTT_Out_Will = 0', 
                                 [
                                     $request['products'],
                                     $serialnumber,
                                     $request['storage']
                                 ]);
                if (count($storageinrows)==1) 
                {
                    $request->request->add(['serialnumber' => $serialnumber]);
                    $request->request->add(['storageinrows' => $storageinrows[0]->Oid]);
                    $response = $this->addItemStorageOut($request);
                    if ($response->original != 'OK') {
                        return response()->json($response->original, 200);    
                    }   
                }
            }
            $response = $this->makeSerialNumberRangeStorageOut($request);
            if ($response->original != 'OK') {
                return response()->json($response->original, 200);    
            }
            DB::connection($headers['cdb'])->commit();   
            return response()->json("OK", 200);    
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        }
        
    }
    public function removeItemStorageOut(Request $request)
    {
        try 
        {
            $headers = apache_request_headers();

            $storageoutrows=$request['storageoutrows'];

            DB::connection($headers['cdb'])->beginTransaction();
            
            foreach ($storageoutrows as $key => $storageoutrow)
            {
                $sor=DB::connection($headers['cdb'])->select('SELECT t2.Storage,t3.Products,t1.StorageOutHeader,t1.StorageInRows,t1.QTT_Will,t2.IsEditable 
                                                                FROM StorageOutRows t1 JOIN StorageOutHeader t2 on
                                                                    t1.StorageOutHeader=t2.Oid JOIN StorageInRows t3 on
                                                                    t1.StorageInRows=t3.Oid
                                                                WHERE t1.Oid = ?', [$storageoutrow]);
                if ($sor[0]->IsEditable != 1) {
                    return response()->json("Nem szerkeszthető kitárolás!", 200);
                }
                
                # StorageInRows update
                DB::connection($headers['cdb'])->update('UPDATE StorageInRows set QTT_Out_Will=QTT_Out_Will-? 
                            WHERE Oid = ?', [$sor[0]->QTT_Will,$sor[0]->StorageInRows]);
                # StorageComputed update
                DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTTReservedOut = QTTReservedOut - ?,QTT = QTT + ?
                            WHERE Products = ? AND Storage=?', 
                            [
                                $sor[0]->QTT_Will,
                                $sor[0]->QTT_Will,
                                $sor[0]->Products,
                                $sor[0]->Storage
                            ]);

                # StorageOutRows delete
                DB::connection($headers['cdb'])->delete('DELETE FROM StorageOutRows 
                            WHERE Oid = ?', [$storageoutrow]);
                $request->request->add(['storageoutheader' => $sor[0]->StorageOutHeader]);
                $response = $this->makeSerialNumberRangeStorageOut($request);
                if ($response->original != 'OK') {
                    return response()->json($response->original, 500);    
                }            
            }
            DB::connection($headers['cdb'])->commit();
            
            return response()->json("OK", 200);  
        } 
        catch (Exception $e) 
        {
            return response()->json($e->getMessage(), 500);
        }  
    }
    public function finalizeStorageOut(Request $request)
    {
        try 
        {
            $headers = apache_request_headers();

            DB::connection($headers['cdb'])->beginTransaction();

            $storageoutheader=DB::connection($headers['cdb'])->select('SELECT * FROM StorageOutHeader WHERE Oid = ?', [$request['storageoutheader']]);

            if (count($storageoutheader)>0) 
            {
                # Kitárolás véglegesítése
                DB::connection($headers['cdb'])->update('UPDATE StorageOutHeader set IsEditable=0,IsFinalized=1
                           WHERE Oid = ?', [$request['storageoutheader']]);

                # StorageInRows frissítése
                $storageoutrows=DB::connection($headers['cdb'])->select('SELECT t1.Oid,t1.QTT_Will,t1.StorageInRows,t3.Products,t2.Storage,t2.DocumentNumber,t3.SerialNumber ,t2.DateExecution
                                            FROM StorageOutRows t1 JOIN StorageOutHeader t2 on
                                            t1.StorageOutHeader=t2.Oid JOIN StorageInRows t3 on
                                            t1.StorageInRows=t3.Oid
                                            where StorageOutHeader = ?', [$request['storageoutheader']]);

                foreach ($storageoutrows as $key => $storageoutrow) 
                {
                    # StorageOutRows frissítése
                    DB::connection($headers['cdb'])->update('UPDATE StorageOutRows set QTT = QTT + QTT_Will, QTT_Will = 0 
                                WHERE Oid = ?', [$storageoutrow->Oid]);
                    #StorageInRows frissítése
                    DB::connection($headers['cdb'])->update('UPDATE StorageInRows set QTT_Out = QTT_Out + ?, QTT_Out_Will = QTT_Out_Will - ? 
                                WHERE Oid = ?', 
                                [
                                    $storageoutrow->QTT_Will,
                                    $storageoutrow->QTT_Will,
                                    $storageoutrow->StorageInRows
                                ]);
                    # StorageComputed frissítése
                    DB::connection($headers['cdb'])->update('UPDATE StorageComputed 
                                SET  QTTReservedOut=QTTReservedOut - ?
                                WHERE Storage=? AND Products=?', 
                                [
                                    $storageoutrow->QTT_Will,
                                    $storageoutrow->Storage,
                                    $storageoutrow->Products
                                ]);   
                    # Eseménynapló
                    DB::connection($headers['cdb'])->insert('INSERT INTO StorageMoveEvents 
                                (Oid, Storage, Products, DocumentNumber, SerialNumber, DateExecution, MoveEventsType,ObjectCreated,UserCreated) 
                                VALUES (UUID(), ?, ?, ?, ?, ?, ?, NOW(), ?)', 
                                [
                                    $storageoutrow->Storage,
                                    $storageoutrow->Products,
                                    $storageoutrow->DocumentNumber,
                                    $storageoutrow->SerialNumber,
                                    $storageoutrow->DateExecution,
                                    3,
                                    $request['usercreated']
                                ]);
                }
            }
            
            DB::connection($headers['cdb'])->commit();
            
            return response()->json("OK", 200);  
        } 
        catch (Exception $e) 
        {
            return response()->json($e->getMessage(), 500);
        }   
    
    
    }
    public function finalizeAndMoveStorageOut(Request $request)
    {
        try
        {
            $headers = apache_request_headers();

            DB::connection($headers['cdb'])->beginTransaction();

            $response=$this->finalizeStorageOut($request);

            $storageoutheader=DB::connection($headers['cdb'])->select('SELECT * FROM StorageOutHeader 
                                          WHERE Oid = ? AND IsEditable = 0 AND IsFinalized = 1', 
                                          [
                                              $request['storageoutheader']
                                          ]);
            if (count($storageoutheader)>0) {
                # code...
                DB::connection($headers['cdb'])->update('UPDATE StorageOutHeader SET DocumentNumber=CONCAT(DocumentNumber,"-ÁTAD") 
                            WHERE Oid = ? AND IsEditable = 0 AND IsFinalized = 1', 
                                          [
                                              $request['storageoutheader']
                                          ]);
                #StorageMoveType ellenőrzése
                $storagemovetype=DB::connection($headers['cdb'])->select('SELECT t1.Oid
                                                                          FROM StorageMoveType t1
                                                                          WHERE t1.MoveType = 6 AND t1.MoveDirection = 0 AND t1.Storage = ?', 
                                                                          [
                                                                            $request['storage']
                                                                          ]);
                if (count($storagemovetype) == 0) {
                    return response()->json("Nincs beállítva a fogadó raktár mozgás tipusa!", 500);      
                }                                                          
                #StorageInHeader előkészítése
                DB::connection($headers['cdb'])->insert('INSERT INTO StorageInHeader (Oid,Storage,DocumentNumber,DateExecution,IsEditable,IsFinalized,StorageOutHeader,StorageMoveType) 
                            VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?)', 
                            [
                                $request['storage'],
                                $storageoutheader[0]->DocumentNumber.'-FOGAD',
                                $storageoutheader[0]->DateExecution,
                                1,0,
                                $request['storageoutheader'],
                                $storagemovetype[0]->Oid
                            ]);
                $storageinheader=DB::connection($headers['cdb'])->select('SELECT Oid,Storage from StorageInHeader WHERE StorageOutHeader = ?', [$request['storageoutheader']]);
                #StorageInRows sorok elkészítése
                $storageoutrows=DB::connection($headers['cdb'])->select('SELECT t2.SerialNumber,t2.Products,t1.QTT,t2.PacketNumber 
                                            FROM StorageOutRows t1 JOIN StorageInRows t2 on
                                                 t1.StorageInRows=t2.Oid 
                                            WHERE StorageOutHeader = ?', 
                                            [
                                                $request['storageoutheader']
                                            ]);
                $rowindex=1;
                foreach ($storageoutrows as $key => $storageoutrow) {
                    DB::connection($headers['cdb'])->insert('INSERT INTO StorageInRows (Oid, StorageInHeader, SerialNumber, Products, QTT, QTT_Will, QTT_Out, QTT_Out_Will, RowIndex, PacketNumber) 
                                VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?, ?)', 
                                [
                                  $storageinheader[0]->Oid,
                                  $storageoutrow->SerialNumber,
                                  $storageoutrow->Products,
                                  0,
                                  $storageoutrow->QTT,
                                  0,
                                  0,
                                  $rowindex,
                                  $storageoutrow->PacketNumber,  
                                ]);
                    $rowindex=$rowindex + 1; 
                    
                    $storagecomputed=DB::connection($headers['cdb'])->select('SELECT * FROM StorageComputed WHERE Storage = ? AND Products = ?', [$storageinheader[0]->Storage,$storageoutrow->Products]);
                    
                    if (count($storagecomputed)==0) {
                        DB::connection($headers['cdb'])->insert('INSERT INTO StorageComputed (Oid, Products,Storage,QTT,IsLocked,QTTReservedIn,QTTReservedOut) 
                                VALUES (UUID(), ?, ?, ?, ?, ?, ?)', 
                                [
                                    $storageoutrow->Products,
                                    $storageinheader[0]->Storage, 
                                    0,0,$storageoutrow->QTT,0
                                ]);
                    }else {
                            DB::connection($headers['cdb'])->update('UPDATE StorageComputed set QTTReservedIn=QTTReservedIn+? 
                                        WHERE Storage=? AND Products=?', [$storageoutrow->QTT,$storageinheader[0]->Storage,$storageoutrow->Products]);
                    }              
                }

                $request->request->add(['storageinheader' => $storageinheader[0]->Oid]);
                
                $this->finalizeStorageIn($request);
                $this->makeSerialNumberRangeStorageIn($request);
                
                DB::connection($headers['cdb'])->commit();
                
                
                return response()->json("OK", 200);  
            }                              

            
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        }
        

    }

    # Inventory
    public function startInventory(Request $request)
    {
        try
        {
            $headers = apache_request_headers();

            DB::connection($headers['cdb'])->beginTransaction();
            $inventoryheader=DB::connection($headers['cdb'])->select('SELECT * 
                                         FROM InventoryHeader t1 
                                         WHERE t1.Oid = ? AND t1.InventoryStatus = 1', 
                                         [
                                             $request['inventoryheader']
                                         ]);
            if (count($inventoryheader)>0) {
                DB::connection($headers['cdb'])->delete('DELETE FROM InventoryStorageInRows WHERE InventoryHeader = ?', [$request['inventoryheader']]);

                DB::connection($headers['cdb'])->insert('INSERT InventoryStorageInRows (Oid, InventoryHeader,StorageInRows,QTT) 
                           SELECT UUID(), ?, t1.Oid,(t1.QTT -  t1.QTT_Out) - t1.QTT_Will
                           FROM StorageInRows t1 JOIN StorageInHeader t2 on
                                t1.StorageInHeader = t2.Oid
                           WHERE t2.IsEditable = 0 AND (t1.QTT -  t1.QTT_Out) > 0',
                           [$request['inventoryheader']]);
                DB::connection($headers['cdb'])->update('UPDATE InventoryHeader set InventoryStatus = 2 WHERE Oid = ?', [$request['inventoryheader']]);           
            }else
            {
                return response()->json("Van már megkezdett leltár !", 200);  
            }                             
            
            DB::connection($headers['cdb'])->commit();
            return response()->json("OK", 200);  
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        }
    }
    public function addItemInventory(Request $request)
    {
        try
        {
            $headers = apache_request_headers();

            DB::connection($headers['cdb'])->beginTransaction();

            if ($request['multitracknumber']=='eFirstTrack') {
                $multitracknumber=0;
            }else{
                $multitracknumber=1;
            }
            $inventoryheader=DB::connection($headers['cdb'])->select('SELECT * 
                                         FROM InventoryHeader t1 
                                         WHERE t1.Oid = ? AND t1.InventoryStatus = 2', 
                                         [
                                             $request['inventoryheader']
                                         ]);
            if (count($inventoryheader)>0) {
                
                if ($request['outmode']=='eSerialNumber') {
                    $inventoryrows=DB::connection($headers['cdb'])->select('SELECT * 
                                               FROM InventoryRows t1 
                                               WHERE t1.InventoryHeader = ? AND t1.SerialNumber = ? AND t1.MultiTrackNumber = ?', 
                                               [
                                                   $request['inventoryheader'],
                                                   $request['serialnumber'],
                                                   $multitracknumber 
                                               ]);
                    if (count($inventoryrows) == 0) {
                        DB::connection($headers['cdb'])->insert('INSERT INTO InventoryRows (Oid, InventoryHeader, HRPerson, MultiTrackNumber, Products, SerialNumber, PacketNumber, QTT, ObjectCreated) 
                                    VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, NOW())', 
                                   [
                                       $request['inventoryheader'],
                                       $request['hrperson'],
                                       $multitracknumber,
                                       $request['products'],
                                       $request['serialnumber'],
                                       $request['packetnumber'],
                                       1
                                   ]);
                    }else
                    {
                        return response()->json("A sorozatszám már rögzítve lett !", 200); 
                    }                           
                }

            }


            DB::connection($headers['cdb'])->commit();
                
            return response()->json("OK", 200); 
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        }
    }
    public function removeItemInventory(Request $request)
    {
        try
        {
            $headers = apache_request_headers();

            $inventoryrows=$request['inventoryrows'];

            DB::connection($headers['cdb'])->beginTransaction();
            foreach ($inventoryrows as $key => $inventoryrow) {
                DB::connection($headers['cdb'])->delete('DELETE FROM InventoryRows WHERE Oid = ?',[$inventoryrow]);
            }
            DB::connection($headers['cdb'])->commit();
            
            return response()->json("OK", 200);
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        } 
    }
    public function createDifferentInventory(Request $request)
    {
        try
        {
            $headers = apache_request_headers();

            DB::connection($headers['cdb'])->beginTransaction();

            DB::connection($headers['cdb'])->update('UPDATE InventoryRows set PacketNumber="" WHERE PacketNumber IS NULL');
            DB::connection($headers['cdb'])->update('UPDATE StorageInRows set PacketNumber="" WHERE PacketNumber IS NULL');

            $inventoryrows=DB::connection($headers['cdb'])->select('SELECT * FROM InventoryRows WHERE InventoryHeader = ?', [$request['inventoryheader']]);
            $inventorystorageinrows=DB::connection($headers['cdb'])->select('SELECT t1.Oid, t2.Products, t2.SerialNumber, t2.PacketNumber, t1.QTT, t1.InventoryHeader
                                                FROM InventoryStorageInRows t1 JOIN StorageInRows t2 on
                                                     t1.StorageInRows=t2.Oid
                                                WHERE InventoryHeader = ?', [$request['inventoryheader']]);
                       
            
            DB::connection($headers['cdb'])->delete('DELETE FROM InventoryDifferent WHERE Oid = ?', [$request['inventoryheader']]);
            
            foreach ($inventoryrows as $key => $inventoryrow) 
            {
                $inventorydifferent=DB::connection($headers['cdb'])->select('SELECT * FROM InventoryDifferent 
                                                WHERE Products = ? AND SerialNumber = ? AND PacketNumber = ? AND InventoryHeader = ?', 
                                                [
                                                    $inventoryrow->Products,
                                                    $inventoryrow->SerialNumber,
                                                    $inventoryrow->PacketNumber,
                                                    $inventoryrow->InventoryHeader
                                                ]);
                if (count($inventorydifferent)==0) {
                    if ($inventoryrow->MultiTrackNumber==0) {
                        $QTT_01=$inventoryrow->QTT;
                        $QTT_02=0;
                    }else
                    {
                        $QTT_02=$inventoryrow->QTT;
                        $QTT_01=0;
                    }
                    DB::connection($headers['cdb'])->insert('INSERT INTO InventoryDifferent (Oid, InventoryHeader, Products, SerialNumber, PacketNumber,
                                                                QTT_01, QTT_02, QTT_StorageInRows) 
                                VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?)', 
                                [
                                    $inventoryrow->InventoryHeader,
                                    $inventoryrow->Products,
                                    $inventoryrow->SerialNumber,
                                    $inventoryrow->PacketNumber,
                                    $QTT_01,
                                    $QTT_02,
                                    0
                                ]);
                }
                else
                {
                    if ($inventoryrow->MultiTrackNumber == 0) 
                    {
                        DB::connection($headers['cdb'])->update('UPDATE InventoryDifferent set QTT_01 = ? WHERE Oid = ?', [$inventoryrow->QTT,$inventorydifferent[0]->Oid]);
                    }
                    if ($inventoryrow->MultiTrackNumber == 1) 
                    {
                        DB::connection($headers['cdb'])->update('UPDATE InventoryDifferent set QTT_02 = ? WHERE Oid = ?', [$inventoryrow->QTT,$inventorydifferent[0]->Oid]);
                    }
                }
            }
            
            foreach ($inventorystorageinrows as $key => $inventorystorageinrow) 
            {
                
                $inventorydifferent=DB::connection($headers['cdb'])->select('SELECT * FROM InventoryDifferent 
                                                WHERE Products = ? AND SerialNumber = ? AND PacketNumber = ? AND InventoryHeader = ?', 
                                                [
                                                    $inventorystorageinrow->Products,
                                                    $inventorystorageinrow->SerialNumber,
                                                    $inventorystorageinrow->PacketNumber,
                                                    $inventorystorageinrow->InventoryHeader
                                                ]);
                if (count($inventorydifferent)==0) {
                    
                    DB::connection($headers['cdb'])->insert('INSERT INTO InventoryDifferent (Oid, InventoryHeader, Products, SerialNumber, PacketNumber,
                                                                QTT_01, QTT_02, QTT_StorageInRows) 
                                VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?)', 
                                [
                                    $inventorystorageinrow->InventoryHeader,
                                    $inventorystorageinrow->Products,
                                    $inventorystorageinrow->SerialNumber,
                                    $inventorystorageinrow->PacketNumber,
                                    0,
                                    0,
                                    $inventorystorageinrow->QTT
                                ]);
                }
                else
                {
                    DB::connection($headers['cdb'])->update('UPDATE InventoryDifferent set QTT_StorageInRows = ? WHERE Oid = ?', [$inventorystorageinrow->QTT,$inventorydifferent[0]->Oid]);
                }
            }
            DB::connection($headers['cdb'])->commit();
            
            
            return response()->json("OK", 200);
        }
        catch (Exception $e)
        {
            return response()->json($e->getMessage(), 500); 
        } 
    }
}