/**
  *	delete key registered (Only this seller)
  *	@param	$id 	int|string 	id the virtual product
  *	@param	$res 	Request 	object to validate the type of request, action
  *	@return	json
  */
 public function deleteKey($id, Request $res)
 {
     if (!$res->wantsJson()) {
         return redirect()->back();
     }
     $VirtualProduct = VirtualProduct::find($id);
     if (!count($VirtualProduct->toArray())) {
         return json_encode(['message' => trans('globals.error_not_available')]);
     }
     $product = Product::find($VirtualProduct->product_id);
     if (!count($product->toArray())) {
         return json_encode(['message' => trans('globals.error_not_available')]);
     }
     if ($product->user_id != \Auth::id()) {
         return json_encode(['message' => trans('globals.not_access')]);
     }
     $VirtualProductOrder = VirtualProductOrder::where('virtual_product_id', $VirtualProduct->id)->get();
     if (count($VirtualProductOrder->toArray()) > 0) {
         return json_encode(['message' => trans('product.virtualProductsController_controller.key_been_sold')]);
     }
     $VirtualProduct->status = 'cancelled';
     $VirtualProduct->save();
     $stock = count(VirtualProduct::where('product_id', $product->id)->where('status', 'open')->get()->toArray());
     $product->stock = $stock;
     if ($stock == 0) {
         $product->status = 0;
     }
     $product->save();
     return json_encode(['success' => trans('product.controller.saved_successfully')]);
 }
Exemple #2
0
 /**
  *   function to action to deliver virtual products
  *   @param  $orderId    int|string  id order
  *   @param  $productId  int|string  id product
  *   @param  $request    Request     object to validate the type of request
  *   @return json    message error or message success
  */
 public function deliveryVirtualProduct($orderId, $productId, Request $request, $ajax = true)
 {
     if ($ajax && !$request->wantsJson()) {
         return json_encode(['message' => trans('globals.error_not_available'), 'json' => false]);
     }
     $Order = Order::find($orderId);
     $product = Product::find($productId);
     if (!$Order || !$product) {
         return json_encode(['message' => trans('globals.error_not_available'), 'id' => false]);
     }
     if ($Order->status != 'pending' && $Order->status != 'sent') {
         return json_encode(['message' => trans('globals.error_not_available'), 'status' => false]);
     }
     $virtuals = VirtualProduct::where('product_id', $product->id)->where('status', 'paid')->get();
     if (!count($virtuals->toArray())) {
         return json_encode(['message' => trans('globals.error_not_available'), 'virtual' => false]);
     }
     $detail = OrderDetail::where('order_id', $Order->id)->where('product_id', $product->id)->first();
     $user = User::find($Order->user_id);
     foreach ($virtuals as $row) {
         $virtualOrders = VirtualProductOrder::where('virtual_product_id', $row->id)->where('order_id', $Order->id)->first();
         if ($virtualOrders) {
             if ($virtualOrders->email) {
                 Mail::queue('emails.virtualsProducts', ['product' => $product, 'row' => $row, 'order' => $virtualOrders, 'user' => $user], function ($message) use($virtualOrders) {
                     $message->to($virtualOrders->email)->subject(trans('email.delivery_virtuals_products.subject'));
                 });
             }
             $row->status = 'Sent';
             $row->save();
             $virtualOrders->status = 0;
             $virtualOrders->save();
         }
     }
     $detail->status = 0;
     $detail->delivery_date = DB::raw('NOW()');
     $detail->save();
     if ($ajax) {
         $detail = OrderDetail::where('order_id', $Order->id)->where('status', 1)->first();
     }
     if ($ajax && !$detail) {
         $Order->end_date = DB::raw('NOW()');
         $Order->status = 'Sent';
         $Order->save();
         if (!$ajax) {
             return 'Sent';
         } else {
             return json_encode(['message' => trans('store.delivery_successfully') . ' ' . trans('store.closedOrders'), 'success' => true, 'closed' => true]);
         }
     } else {
         if (!$ajax) {
             return 'success';
         } else {
             return json_encode(['message' => trans('store.delivery_successfully'), 'success' => true]);
         }
     }
 }
 public function showKeyVirtualProductPurchased($idProduct, $idOrder, Request $request)
 {
     if (!$request->wantsJson()) {
         return ['message' => trans('globals.error_not_available')];
     }
     $product = Product::find($idProduct);
     $order = Order::find($idOrder);
     $virtual = VirtualProduct::select('id')->where('product_id', $idProduct)->get()->toArray();
     if (!$product || !$order || !count($virtual)) {
         return ['message' => trans('globals.error_not_available'), 'id' => false];
     }
     if ($order->user_id != \Auth::id()) {
         return ['message' => trans('globals.error_not_available'), 'my' => false];
     }
     $virtualOrder = VirtualProductOrder::where('order_id', $order->id)->whereIn('virtual_product_id', $virtual)->get();
     if (!count($virtualOrder)) {
         return ['message' => trans('globals.error_not_available'), 'order' => false];
     }
     $user = User::find(\Auth::id());
     $return = ['info' => ['name' => $product->name, 'des' => $product->description, 'num' => count($virtualOrder)]];
     foreach ($virtualOrder as $row) {
         if (isset($return['users'][$row['email']])) {
             $key = VirtualProduct::find($row['virtual_product_id']);
             $return['users'][$row['email']]['keys'][] = $key['key'];
         } else {
             $key = VirtualProduct::find($row['virtual_product_id']);
             $return['users'][$row['email']]['keys'][0] = $key['key'];
             $return['users'][$row['email']]['title'] = $row['email'] == $user['email'] ? 'Your Keys' : 'Keys sent to ' . $row['email'];
         }
     }
     return $return;
 }
Exemple #4
0
 /**
  * Start the checkout process for any type of order
  *
  * @param  int  $type_order Type of order to be processed
  * @return Response
  */
 public static function placeOrders($type_order)
 {
     $cart = Order::ofType($type_order)->auth()->whereStatus('open')->orderBy('id', 'desc')->first();
     $show_order_route = $type_order == 'freeproduct' ? 'freeproducts.show' : 'orders.show_cart';
     $cartDetail = OrderDetail::where('order_id', $cart->id)->get();
     $address_id = 0;
     //When address is invalid, it is because it comes from the creation of a free product. You must have a user direction (Default)
     if (is_null($cart->address_id)) {
         $useraddress = UserAddress::auth()->orderBy('default', 'DESC')->first();
         if ($useraddress) {
             $address_id = $useraddress->address_id;
         } else {
             return trans('address.no_registered');
         }
     } else {
         $address_id = $cart->address_id;
     }
     $address = Address::where('id', $address_id)->first();
     //Checks if the user has points for the cart price and the store has stock
     //and set the order prices to the current ones if different
     //Creates the lists or sellers to send mail to
     $total_points = 0;
     $seller_email = array();
     foreach ($cartDetail as $orderDetail) {
         $product = Product::find($orderDetail->product_id);
         $seller = User::find($product->user_id);
         if (!in_array($seller->email, $seller_email)) {
             $seller_email[] = $seller->email;
         }
         $total_points += $orderDetail->quantity * $product->price;
         if ($orderDetail->price != $product->price) {
             $orderDetail->price = $product->price;
             $orderDetail->save();
         }
         if ($product->type != 'item') {
             $virtual = VirtualProduct::where('product_id', $orderDetail->product_id)->get();
             $first = $virtual->first();
             //$first=null;
             //foreach ($virtual as $row){
             //$first=$row;
             //break;
             //}
             switch ($product->type) {
                 case 'key':
                 case 'software_key':
                     $virtualOrder = VirtualProductOrder::where('virtual_product_id', $first->id)->where('order_id', $orderDetail->order_id)->where('status', 1)->get();
                     if (count($virtual) - 1 < count($virtualOrder)) {
                         return trans('store.insufficientStock');
                     }
                     break;
                 default:
                     break;
             }
         } elseif ($product->stock < $orderDetail->quantity) {
             return trans('store.insufficientStock');
         }
     }
     //Checks if the user has points for the cart price
     $user = \Auth::user();
     if ($user->current_points < $total_points && config('app.payment_method') == 'Points') {
         return trans('store.cart_view.insufficient_funds');
     }
     if (config('app.payment_method') == 'Points') {
         $negativeTotal = -1 * $total_points;
         //7 is the action type id for order checkout
         $pointsModified = $user->modifyPoints($negativeTotal, 7, $cart->id);
     } else {
         $pointsModified = true;
     }
     if ($pointsModified) {
         //Separate the order for each seller
         //Looks for all the different sellers in the cart
         $sellers = [];
         foreach ($cartDetail as $orderDetail) {
             if (!in_array($orderDetail->product->user_id, $sellers)) {
                 $sellers[] = $orderDetail->product->user_id;
             }
         }
         foreach ($sellers as $seller) {
             //Creates a new order and address for each seller
             $newOrder = new Order();
             $newOrder->user_id = $user->id;
             $newOrder->address_id = $address->id;
             $newOrder->status = $type_order == 'freeproduct' ? 'paid' : 'open';
             $newOrder->type = $type_order == 'freeproduct' ? 'freeproduct' : 'order';
             $newOrder->seller_id = $seller;
             $newOrder->save();
             $newOrder->sendNotice();
             //moves the details to the new orders
             foreach ($cartDetail as $orderDetail) {
                 if ($orderDetail->product->user_id == $seller) {
                     $orderDetail->order_id = $newOrder->id;
                     $orderDetail->save();
                 }
                 //Increasing product counters.
                 ProductsController::setCounters($orderDetail->product, ['sale_counts' => trans('globals.product_value_counters.sale')], 'orders');
                 //saving tags in users preferences
                 if (trim($orderDetail->product->tags) != '') {
                     UserController::setPreferences('product_purchased', explode(',', $orderDetail->product->tags));
                 }
             }
         }
         //virtual products
         //Changes the stock of each product in the order
         foreach ($cartDetail as $orderDetail) {
             $product = Product::find($orderDetail->product_id);
             $product->stock = $product->stock - $orderDetail->quantity;
             $product->save();
             if ($product->type != 'item') {
                 $virtual = VirtualProduct::where('product_id', $orderDetail->product_id)->where('status', 'open')->get();
                 switch ($product->type) {
                     case 'key':
                         $first = VirtualProduct::where('product_id', $orderDetail->product_id)->where('status', 'cancelled')->first();
                         foreach ($virtual as $row) {
                             $virtualOrder = VirtualProductOrder::where('order_id', $cart->id)->where('virtual_product_id', $first->id)->where('status', 1)->first();
                             if ($virtualOrder) {
                                 $virtualOrder->virtual_product_id = $row->id;
                                 $virtualOrder->order_id = $orderDetail->order_id;
                                 $virtualOrder->status = 2;
                                 $virtualOrder->save();
                                 $row->status = 'paid';
                                 $row->save();
                             } else {
                                 break;
                             }
                         }
                         break;
                     default:
                         break;
                 }
             }
         }
         foreach ($seller_email as $email) {
             $mailed_order = Order::where('id', $newOrder->id)->with('details')->get()->first();
             //Send a mail to the user: Order has been placed
             $data = ['orderId' => $newOrder->id, 'order' => $mailed_order];
             //dd($data['order']->details,$newOrder->id);
             $title = trans('email.new_order_for_user.subject') . " (#{$newOrder->id})";
             Mail::queue('emails.neworder', compact('data', 'title'), function ($message) use($user) {
                 $message->to($user->email)->subject(trans('email.new_order_for_user.subject'));
             });
             //Send a mail to the seller: Order has been placed
             $title = trans('email.new_order_for_seller.subject') . " (#{$newOrder->id})";
             Mail::queue('emails.sellerorder', compact('data', 'title'), function ($message) use($email) {
                 $message->to($email)->subject(trans('email.new_order_for_seller.subject'));
             });
         }
         return;
     } else {
         return trans('store.insufficientFunds');
     }
 }