You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
985 lines
38 KiB
985 lines
38 KiB
<?php
|
|
|
|
// (c) Copyright by authors of the Tiki Wiki CMS Groupware Project
|
|
//
|
|
// All Rights Reserved. See copyright.txt for details and a complete list of authors.
|
|
// Licensed under the GNU LESSER GENERAL PUBLIC LICENSE. See license.txt for details.
|
|
|
|
|
|
class CartLib
|
|
{
|
|
private \TikiLib $tikilib;
|
|
private \TrackerLib $trklib;
|
|
private \UsersLib $userslib;
|
|
private \PaymentLib $paymentlib;
|
|
private \Services_Tracker_Utilities $utilities;
|
|
|
|
private int $productTracker;
|
|
private int $productInventoryTypeField;
|
|
private int $productInventoryTotalField;
|
|
private int $productInventoryLessHoldField;
|
|
|
|
private int $orderTracker;
|
|
private int $orderUserField;
|
|
private int $orderDateField;
|
|
private int $orderTotalField;
|
|
private int $orderInvoiceField;
|
|
private int $orderWeightField;
|
|
|
|
private int $orderitemsTracker;
|
|
private int $orderitemsOrderField;
|
|
private int $orderitemsProductField;
|
|
private int $orderitemsPriceField;
|
|
private int $orderitemsQuantityField;
|
|
private int $orderitemsUserField;
|
|
private int $orderitemsInputtedPriceField;
|
|
private int $orderitemsParentCodeField;
|
|
|
|
|
|
private bool $inventoryEnabled;
|
|
private bool $bundlesEnabled;
|
|
|
|
final public function __construct()
|
|
{
|
|
global $prefs;
|
|
|
|
$this->tikilib = TikiLib::lib('tiki');
|
|
$this->userslib = TikiLib::lib('user');
|
|
/** @var TrackerLib trklib */
|
|
$this->trklib = TikiLib::lib('trk');
|
|
/** @var PaymentLib paymentlib */
|
|
$this->paymentlib = TikiLib::lib('payment');
|
|
|
|
$this->utilities = new \Services_Tracker_Utilities();
|
|
|
|
$this->productTracker = (int)$prefs['payment_cart_product_tracker'] ?? 0;
|
|
$this->productInventoryTypeField = (int)$prefs['payment_cart_inventory_type_field'] ?? 0;
|
|
$this->productInventoryTotalField = (int)$prefs['payment_cart_inventory_total_field'] ?? 0;
|
|
$this->productInventoryLessHoldField = (int)$prefs['payment_cart_inventory_lesshold_field'] ?? 0;
|
|
|
|
$this->orderTracker = (int)$prefs['payment_cart_order_tracker'] ?? 0;
|
|
$this->orderUserField = (int)$prefs['payment_cart_order_user_field'] ?? 0;
|
|
$this->orderDateField = (int)$prefs['payment_cart_order_date_field'] ?? 0;
|
|
$this->orderTotalField = (int)$prefs['payment_cart_order_total_field'] ?? 0;
|
|
$this->orderInvoiceField = (int)$prefs['payment_cart_order_invoice_field'] ?? 0;
|
|
$this->orderWeightField = (int)$prefs['payment_cart_order_weight_field'] ?? 0;
|
|
|
|
$this->orderitemsTracker = (int)$prefs['payment_cart_orderitems_tracker'] ?? 0;
|
|
|
|
$this->orderitemsOrderField = (int)$prefs['payment_cart_orderitems_order_field'] ?? 0;
|
|
$this->orderitemsProductField = (int)$prefs['payment_cart_orderitems_product_field'] ?? 0;
|
|
$this->orderitemsPriceField = (int)$prefs['payment_cart_orderitems_price_field'] ?? 0;
|
|
$this->orderitemsQuantityField = (int)$prefs['payment_cart_orderitems_quantity_field'] ?? 0;
|
|
$this->orderitemsUserField = (int)$prefs['payment_cart_orderitems_user_field'] ?? 0;
|
|
$this->orderitemsInputtedPriceField = (int)$prefs['payment_cart_orderitems_inputedprice_field'] ?? 0;
|
|
$this->orderitemsParentCodeField = (int)$prefs['payment_cart_orderitems_parentcode_field'] ?? 0;
|
|
|
|
$this->inventoryEnabled = $prefs['payment_cart_inventory'] === 'y';
|
|
$this->bundlesEnabled = $prefs['payment_cart_bundles'] === 'y';
|
|
}
|
|
|
|
|
|
/**
|
|
* Called when addtocart button clicked. Adds a quantity of a specified product to the cart
|
|
*
|
|
* @param array $product_info wikiplugin_addtocart params
|
|
* @param jitFilter $input request input (POST)
|
|
*
|
|
* @return bool success
|
|
*/
|
|
final public function add_to_cart(array $product_info, jitFilter $input): bool
|
|
{
|
|
global $prefs, $user, $globalperms;
|
|
|
|
$quantity = $input->quantity->int();
|
|
|
|
if ($input->code->text() !== $product_info['code']) {
|
|
Feedback::error(tra('Cart: Product code mismatch.'));
|
|
return false;
|
|
}
|
|
|
|
if (! empty($params['exchangeorderitemid']) && ! empty($params['exchangetoproductid'])) {
|
|
if (
|
|
$input->exchangeorderitemid->int() !== $params['exchangeorderitemid'] ||
|
|
$input->exchangetoproductid->int() !== $params['exchangetoproductid']
|
|
) {
|
|
Feedback::error(tra('Cart: Product exchange mismatch.'));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ($prefs['payment_cart_anonymous'] === 'y' && (! $user || $product_info['forceanon'] == 'y') && empty($_SESSION['shopperinfo'])) {
|
|
// There needs to be a shopperinfo plugin on the page
|
|
Feedback::error(tr('Please enter your shopper information first'));
|
|
return false;
|
|
}
|
|
|
|
if ($globalperms->payment_admin && $input->buyonbehalf->text() && $this->userslib->user_exists($input->buyonbehalf->text())) {
|
|
$product_info['onbehalf'] = $input->buyonbehalf->text();
|
|
} else {
|
|
$product_info['onbehalf'] = '';
|
|
}
|
|
|
|
// Generate behavior for exchanges
|
|
if (! empty($product_info['exchangeorderitemid']) && ! empty($product_info['exchangetoproductid'])) {
|
|
$product_info['behaviors'][] = [
|
|
'event' => 'complete',
|
|
'behavior' => 'cart_exchange_product',
|
|
'arguments' => [$product_info["exchangeorderitemid"], $product_info["exchangetoproductid"]]
|
|
];
|
|
if (! isset($product_info['exchangeorderamount']) || ! $product_info['exchangeorderamount']) {
|
|
$product_info['exchangeorderamount'] = 1;
|
|
}
|
|
}
|
|
|
|
// Now add product to cart
|
|
return $this->add_product($product_info['code'], $quantity, $product_info);
|
|
}
|
|
|
|
//Used for putting new items in the cart, to modify an already existing item in the cart, use update_quantity
|
|
final public function add_product(int $code, int $quantity, array $info, int $parentCode = 0, int $childInputedPrice = 0): bool
|
|
{
|
|
$this->init_cart();
|
|
|
|
$current = $this->get_quantity($code);
|
|
|
|
if ($parentCode) {
|
|
$this->init_product($code, $info, $parentCode, $quantity, $childInputedPrice);
|
|
if ($this->inventoryEnabled) {
|
|
$currentInventory = $this->get_inventory($code);
|
|
if ($currentInventory < $quantity) {
|
|
// Abort entire bundle if one of the child products is out of stock
|
|
$this->update_quantity($parentCode, 0, $info);
|
|
}
|
|
}
|
|
return false;
|
|
} elseif (! $current) {
|
|
$this->init_product($code, $info, $parentCode);
|
|
}
|
|
|
|
$current += $quantity;
|
|
|
|
$this->add_bundle($code, $quantity, $info);
|
|
|
|
$this->update_quantity($code, $current, $info);
|
|
return true;
|
|
}
|
|
|
|
final public function get_product_info(int $code): array
|
|
{
|
|
// This function is used by several advanced cart features (e.g. bundled products, associated events)
|
|
global $prefs;
|
|
if (empty($prefs['payment_cart_product_tracker_name'])) {
|
|
return [];
|
|
}
|
|
|
|
$array = $this->trklib->get_tracker_item($code);
|
|
|
|
$info = [];
|
|
$info['code'] = $code;
|
|
while ($result = current($array)) {
|
|
$key = key($array);
|
|
switch ($key) {
|
|
case $prefs['payment_cart_product_name_fieldname']:
|
|
$key = "description";
|
|
break;
|
|
case $prefs['payment_cart_associated_event_fieldname']:
|
|
$key = "eventcode";
|
|
break;
|
|
case $prefs['payment_cart_product_classid_fieldname']:
|
|
$key = "productclass";
|
|
break;
|
|
case $prefs['payment_cart_products_inbundle_fieldname']:
|
|
$key = "productsinbundle";
|
|
break;
|
|
case $prefs['payment_cart_product_price_fieldname']:
|
|
$key = "price";
|
|
break;
|
|
}
|
|
$info[$key] = $result;
|
|
next($array);
|
|
}
|
|
return $info;
|
|
}
|
|
|
|
final public function add_bundle(int $code, int $quantity, array $info): void
|
|
{
|
|
if (! $this->bundlesEnabled) {
|
|
return;
|
|
}
|
|
$moreInfo = $this->get_product_info($code);
|
|
if (! empty($moreInfo['productsinbundle'])) {
|
|
$products = explode(",", $moreInfo['productsinbundle']);
|
|
foreach ($products as $product) {
|
|
$p = explode(":", $product);
|
|
if (count($p) == 1) {
|
|
$p[1] = 1; // quantity
|
|
$p[2] = ''; // inputted price
|
|
} elseif (count($p) == 2) {
|
|
$p[2] = ''; // inputted price
|
|
}
|
|
list($productId, $productQuantity, $childInputedPrice) = $p;
|
|
if (is_numeric($productId)) {
|
|
$infoProduct = $this->get_product_info($productId);
|
|
if ($childInputedPrice == '') {
|
|
$childInputedPrice = $info['price'] / count($products) / $productQuantity;
|
|
// default evenly split between products in the bundle (regardless of individual quantities)
|
|
}
|
|
$infoProduct['price'] = 0;
|
|
if (! empty($info['onbehalf'])) {
|
|
$infoProduct['onbehalf'] = $info['onbehalf'];
|
|
}
|
|
$this->add_product($productId, $productQuantity, $infoProduct, $code, $childInputedPrice);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
final public function get_tracker_value_custom(string $trackerName, string $fieldName, ?int $itemId): ?string
|
|
{
|
|
$value = $this->tikilib->getOne(
|
|
"SELECT tiki_tracker_item_fields.value
|
|
FROM tiki_tracker_item_fields
|
|
LEFT JOIN tiki_tracker_fields ON tiki_tracker_fields.fieldId = tiki_tracker_item_fields.fieldId
|
|
LEFT JOIN tiki_trackers ON tiki_trackers.trackerId = tiki_tracker_fields.trackerId
|
|
LEFT JOIN tiki_tracker_items ON tiki_tracker_items.itemId = tiki_tracker_item_fields.itemId
|
|
WHERE tiki_trackers.name = ? AND
|
|
tiki_tracker_fields.name = ? AND
|
|
tiki_tracker_item_fields.itemId = ?",
|
|
[$trackerName, $fieldName, $itemId]
|
|
);
|
|
|
|
return $value;
|
|
}
|
|
|
|
final public function get_total(): float
|
|
{
|
|
$this->init_cart();
|
|
|
|
$total = 0.0;
|
|
|
|
foreach ($_SESSION['cart'] as $info) {
|
|
$total += (float) $info['quantity'] * (float) $info['price'];
|
|
}
|
|
if ($total < 0.0) {
|
|
$total = 0.0;
|
|
}
|
|
|
|
return $total;
|
|
}
|
|
|
|
final public function get_total_padded(): string
|
|
{
|
|
return number_format($this->get_total(), 2, '.', '');
|
|
}
|
|
|
|
final public function get_quantity(int $code): int
|
|
{
|
|
$this->init_cart();
|
|
|
|
if (isset($_SESSION['cart'][ $code ])) {
|
|
return $_SESSION['cart'][ $code ]['quantity'];
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
final public function get_hash(int $code): string
|
|
{
|
|
$this->init_cart();
|
|
|
|
if (isset($_SESSION['cart'][ $code ])) {
|
|
return $_SESSION['cart'][ $code ]['hash'];
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
final public function generate_item_description(array $item, int $parentCode = 0): string
|
|
{
|
|
$wiki = '';
|
|
|
|
if ($item['href']) {
|
|
$label = "[{$item['href']}|{$item['description']}]";
|
|
} else {
|
|
$label = $item['description'];
|
|
}
|
|
if (! empty($item['onbehalf'])) {
|
|
$label .= " " . tra('for') . " " . $item['onbehalf'];
|
|
}
|
|
if ($parentCode) {
|
|
$label = tra('Bundled Product') . ' - ' . $label;
|
|
if ($item['quantity'] > 1) {
|
|
$label .= ' (x' . $item['quantity'] . ')';
|
|
}
|
|
$item['quantity'] = ' ';
|
|
$item['price'] = ' ';
|
|
}
|
|
$wiki .= "{$item['code']}|{$label}|{$item['quantity']}|{$item['price']}\n";
|
|
return $wiki;
|
|
}
|
|
|
|
final public function get_description(): string
|
|
{
|
|
$id_label = tra('ID');
|
|
$product_label = tra('Product');
|
|
$quantity_label = tra('Quantity');
|
|
$price_label = tra('Unit Price');
|
|
|
|
$wiki = "||__{$id_label}__|__{$product_label}__|__{$quantity_label}__|__{$price_label}__\n";
|
|
|
|
foreach ($this->get_content() as $item) {
|
|
$wiki .= $this->generate_item_description($item);
|
|
if ($bundledProducts = $this->get_bundled_products($item['code'])) {
|
|
foreach ($bundledProducts as $b) {
|
|
$wiki .= $this->generate_item_description($b, $item['code']);
|
|
}
|
|
}
|
|
}
|
|
|
|
$wiki .= "||\n";
|
|
|
|
return $wiki;
|
|
}
|
|
|
|
final public function get_total_weight(): int
|
|
{
|
|
$this->init_cart();
|
|
|
|
$total = 0;
|
|
|
|
foreach ($_SESSION['cart'] as $info) {
|
|
if (! empty($info['weight'])) {
|
|
$total += (int)$info['quantity'] * (float)$info['weight'];
|
|
}
|
|
}
|
|
|
|
return $total;
|
|
}
|
|
|
|
final public function get_count(): int
|
|
{
|
|
$this->init_cart();
|
|
|
|
$total = 0;
|
|
|
|
foreach ($_SESSION['cart'] as $info) {
|
|
if (! empty($info['quantity'])) {
|
|
$total += (int)$info['quantity'];
|
|
}
|
|
}
|
|
|
|
return $total;
|
|
}
|
|
|
|
final public function product_in_cart(int $code): bool
|
|
{
|
|
return isset($_SESSION['cart'][$code]);
|
|
}
|
|
|
|
//Used for adjusting already added items in the cart
|
|
final public function update_quantity(int $code, int $quantity, array $info = ['exchangetoproductid' => 0, 'exchangeorderamount' => 0]): void
|
|
{
|
|
$currentQuantity = $this->get_quantity($code);
|
|
if ($this->inventoryEnabled) {
|
|
// Prevent going below 0 inventory
|
|
$currentInventory = $this->get_inventory($code);
|
|
if ($quantity - $currentQuantity > $currentInventory) {
|
|
if ($currentQuantity == 0) {
|
|
unset($_SESSION['cart'][ $code ]);
|
|
}
|
|
|
|
Feedback::error(tra('There is insufficient inventory to meet your request'));
|
|
}
|
|
|
|
if ($currentQuantity > 0) {
|
|
if ($this->unhold_inventory($code, $currentQuantity)) {
|
|
$this->remove_from_onhold_list($code);
|
|
}
|
|
if ($info['exchangetoproductid'] && $info['exchangeorderamount']) {
|
|
if ($this->unhold_inventory($info['exchangetoproductid'], $info['exchangeorderamount'])) {
|
|
$this->remove_from_onhold_list('XC' . $info['exchangetoproductid']);
|
|
}
|
|
}
|
|
}
|
|
if ($quantity > 0) {
|
|
$currentInventory = $this->get_inventory($code);
|
|
if ($quantity > $currentInventory) {
|
|
$quantity = $currentInventory;
|
|
}
|
|
if ($this->hold_inventory($code, $quantity)) {
|
|
$this->add_to_onhold_list($code, $quantity);
|
|
}
|
|
|
|
if ($info['exchangetoproductid'] && $info['exchangeorderamount']) {
|
|
if ($this->hold_inventory($info['exchangetoproductid'], $info['exchangeorderamount'])) {
|
|
$this->add_to_onhold_list('XC' . $info['exchangetoproductid'], $info['exchangeorderamount']);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$this->init_cart();
|
|
|
|
if (isset($_SESSION['cart'][ $code ]) && $quantity != 0) {
|
|
$_SESSION['cart'][ $code ]['quantity'] = abs($quantity);
|
|
} else {
|
|
unset($_SESSION['cart'][ $code ]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called from modules/mod-func-cart.php on post
|
|
* @return int
|
|
* @throws Exception
|
|
*/
|
|
final public function requestPayment(): int
|
|
{
|
|
global $prefs, $user;
|
|
|
|
$total = $this->get_total();
|
|
|
|
if ($total > 0) {
|
|
// if anonymous shopping to set pref as to which shopperinfo to show in description
|
|
if (empty($user) && $prefs['payment_cart_anonymous'] === 'y') {
|
|
$shopperinfo_descvar = 'email'; // TODO: make this a pref
|
|
if (! empty($_SESSION['shopperinfo'][$shopperinfo_descvar])) {
|
|
$shopperinfo_desc = $_SESSION['shopperinfo'][$shopperinfo_descvar];
|
|
$description = tra($prefs['payment_cart_heading']) . " ($shopperinfo_desc)";
|
|
} else {
|
|
$description = tra($prefs['payment_cart_heading']);
|
|
}
|
|
} else {
|
|
$description = tra($prefs['payment_cart_heading']) . " ($user)";
|
|
}
|
|
$invoice = $this->paymentlib->request_payment($description, $total, $prefs['payment_default_delay'], $this->get_description());
|
|
foreach ($this->get_behaviors() as $behavior) {
|
|
$this->paymentlib->register_behavior($invoice, $behavior['event'], $behavior['behavior'], $behavior['arguments']);
|
|
}
|
|
} else {
|
|
$invoice = 0;
|
|
foreach ($this->get_behaviors() as $behavior) {
|
|
if ($behavior['event'] == 'complete') {
|
|
$name = $behavior['behavior'];
|
|
$file = __DIR__ . "/behavior/$name.php";
|
|
$function = 'payment_behavior_' . $name;
|
|
require_once $file;
|
|
call_user_func_array($function, $behavior['arguments']);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($prefs['payment_system'] == 'ilp') {
|
|
$ilpinvoicepayment = TikiLib::lib('ilpinvoicepayment');
|
|
if ($ilpinvoicepayment->isEnabled() && isset($invoice)) {
|
|
$ilpinvoicepayment->createInvoice($invoice, $user, $total);
|
|
}
|
|
}
|
|
|
|
// Handle anonymous user (not logged in) shopping that require only email
|
|
if (! $user || isset($_SESSION['forceanon']) && $_SESSION['forceanon'] == 'y') {
|
|
if (! empty($_SESSION['shopperinfo'])) { // should also check for pref that this anonymous shopping feature is on
|
|
// First create shopper info in shopper tracker
|
|
global $record_profile_items_created;
|
|
$record_profile_items_created = [];
|
|
if (! empty($_SESSION['shopperinfoprofile'])) {
|
|
$shopper_profile_name = $_SESSION['shopperinfoprofile'];
|
|
} else {
|
|
$shopper_profile_name = $prefs['payment_cart_anonshopper_profile'];
|
|
}
|
|
$shopperprofile = Tiki_Profile::fromDb($shopper_profile_name);
|
|
$profileinstaller = new Tiki_Profile_Installer();
|
|
$profileinstaller->forget($shopperprofile); // profile can be installed multiple times
|
|
$profileinstaller->setUserData($_SESSION['shopperinfo']);
|
|
$profileinstaller->install($shopperprofile);
|
|
// Then set user to shopper ID
|
|
$cartuser = $record_profile_items_created[0];
|
|
$record_profile_items_created = [];
|
|
} else {
|
|
$this->empty_cart();
|
|
return $invoice;
|
|
}
|
|
} else {
|
|
$cartuser = $user;
|
|
}
|
|
|
|
$orderId = 0;
|
|
|
|
if ($user && $prefs['payment_cart_orders'] == 'y' || ! $user && $prefs['payment_cart_anonymous'] == 'y') {
|
|
$definition = Tracker_Definition::get($this->orderTracker);
|
|
$orderId = $this->utilities->insertItem($definition, [
|
|
'status' => 'p',
|
|
'fields' => [
|
|
$this->orderUserField => $cartuser,
|
|
$this->orderDateField => $this->tikilib->now,
|
|
$this->orderTotalField => $total,
|
|
$this->orderInvoiceField => $invoice,
|
|
$this->orderWeightField => $this->get_total_weight(),
|
|
],
|
|
]);
|
|
}
|
|
|
|
$content = $this->get_content();
|
|
|
|
foreach ($content as $info) {
|
|
$process_info = $this->processItem($invoice, $total, $info, $cartuser, $orderId);
|
|
}
|
|
$email_template_ids = [];
|
|
|
|
if (isset($process_info['product_classes']) && is_array($process_info['product_classes'])) {
|
|
$product_classes = array_unique($process_info['product_classes']);
|
|
} else {
|
|
$product_classes = [];
|
|
}
|
|
|
|
foreach ($product_classes as $pc) {
|
|
if ($email_template_id = $this->get_tracker_value_custom($prefs['payment_cart_productclasses_tracker_name'], 'Email Template ID', $pc)) {
|
|
$email_template_ids[] = $email_template_id;
|
|
}
|
|
}
|
|
if (! empty($record_profile_items_created)) {
|
|
if ($total > 0) {
|
|
$this->paymentlib->register_behavior($invoice, 'complete', 'record_cart_order', [ $record_profile_items_created ]);
|
|
$this->paymentlib->register_behavior($invoice, 'cancel', 'cancel_cart_order', [ $record_profile_items_created ]);
|
|
if ($user) {
|
|
$this->paymentlib->register_behavior($invoice, 'complete', 'cart_send_confirm_email', [ $user, $email_template_ids ]);
|
|
}
|
|
} else {
|
|
require_once('lib/payment/behavior/record_cart_order.php');
|
|
payment_behavior_record_cart_order($record_profile_items_created);
|
|
if ($user) {
|
|
require_once('lib/payment/behavior/cart_send_confirm_email.php');
|
|
payment_behavior_cart_send_confirm_email($user, $email_template_ids);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (! $user || isset($_SESSION['forceanon']) && $_SESSION['forceanon'] == 'y') {
|
|
$shopperurl = 'tiki-index.php?page=' . $prefs['payment_cart_anon_reviewpage'] . '&shopper=' . (int)$cartuser;
|
|
global $tikiroot, $prefs;
|
|
$shopperurl = $this->tikilib->httpPrefix(true) . $tikiroot . $shopperurl;
|
|
require_once 'lib/auth/tokens.php';
|
|
$tokenlib = AuthTokens::build($prefs);
|
|
$shopperurl = $tokenlib->includeToken($shopperurl, [$prefs['payment_cart_anon_group'], 'Anonymous']);
|
|
|
|
if (! empty($_SESSION['shopperinfo']['email'])) {
|
|
require_once('lib/webmail/tikimaillib.php');
|
|
$smarty = TikiLib::lib('smarty');
|
|
$smarty->assign('shopperurl', $shopperurl);
|
|
$smarty->assign('email_template_ids', $email_template_ids);
|
|
$mail_subject = $smarty->fetch('mail/cart_order_received_anon_subject.tpl');
|
|
$mail_data = $smarty->fetch('mail/cart_order_received_anon.tpl');
|
|
$mail = new TikiMail();
|
|
$mail->setSubject($mail_subject);
|
|
if ($mail_data == strip_tags($mail_data)) {
|
|
$mail->setText($mail_data);
|
|
} else {
|
|
$mail->setHtml($mail_data);
|
|
}
|
|
$mail->send($_SESSION['shopperinfo']['email']); // the field to use probably needs to be configurable as well
|
|
}
|
|
}
|
|
|
|
$this->empty_cart();
|
|
return $invoice;
|
|
}
|
|
|
|
final public function processItem(
|
|
int $invoice,
|
|
float $total,
|
|
array $info,
|
|
string $cartuser,
|
|
int $orderId = 0,
|
|
int $parentQuantity = 0,
|
|
int $parentCode = 0
|
|
): array {
|
|
global $user, $prefs, $record_profile_items_created;
|
|
|
|
if ($bundledProducts = $this->get_bundled_products($info['code'])) {
|
|
foreach ($bundledProducts as $i) {
|
|
$this->processItem($invoice, $total, $i, $cartuser, $orderId, $info['quantity'], $info['code']);
|
|
}
|
|
}
|
|
if ($parentQuantity) {
|
|
$info['quantity'] = $info['quantity'] * $parentQuantity;
|
|
}
|
|
$product_classes = [];
|
|
if (isset($info['productclass']) && $info['productclass']) {
|
|
$product_classes[] = $info['productclass'];
|
|
}
|
|
if (! empty($info['onbehalf'])) {
|
|
$itemuser = $info['onbehalf'];
|
|
} elseif (! $user || isset($_SESSION['forceanon']) && $_SESSION['forceanon'] == 'y') {
|
|
$itemuser = $cartuser;
|
|
} else {
|
|
$itemuser = $user;
|
|
}
|
|
if (
|
|
$orderId && $user && $prefs['payment_cart_orders'] == 'y' ||
|
|
($orderId && ! $user && $prefs['payment_cart_anonymous'] == 'y')
|
|
) {
|
|
$definition = Tracker_Definition::get($this->orderitemsTracker);
|
|
$this->utilities->insertItem($definition, [
|
|
'status' => 'p',
|
|
'fields' => [
|
|
$this->orderitemsOrderField => $orderId,
|
|
$this->orderitemsProductField => $info['code'],
|
|
$this->orderitemsPriceField => $info['price'],
|
|
$this->orderitemsQuantityField => $info['quantity'],
|
|
$this->orderitemsUserField => $itemuser,
|
|
$this->orderitemsInputtedPriceField => $info['inputedprice'],
|
|
$this->orderitemsParentCodeField => $parentCode,
|
|
],
|
|
]);
|
|
}
|
|
|
|
$this->change_inventory($info['code'], -1 * $info['quantity'], false);
|
|
if (
|
|
(isset($info['exchangetoproductid']) && $info['exchangetoproductid'])
|
|
&& (isset($info['exchangeorderamount']) && $info['exchangeorderamount'])
|
|
) {
|
|
$this->change_inventory($info['exchangetoproductid'], -1 * $info['exchangeorderamount'], false);
|
|
}
|
|
if ($total > 0) {
|
|
$this->paymentlib->register_behavior($invoice, 'cancel', 'replace_inventory', [ $info['code'], $info['quantity'] ]);
|
|
if (
|
|
(isset($info['exchangetoproductid']) && $info['exchangetoproductid'])
|
|
&& (isset($info['exchangeorderamount']) && $info['exchangeorderamount'])
|
|
) {
|
|
$this->paymentlib->register_behavior($invoice, 'cancel', 'replace_inventory', [ $info['exchangetoproductid'], $info['exchangeorderamount'] ]);
|
|
}
|
|
}
|
|
|
|
$ret = ['product_classes' => $product_classes];
|
|
return $ret;
|
|
}
|
|
|
|
final public function empty_cart(): void
|
|
{
|
|
$this->clear_onhold_list();
|
|
$_SESSION['cart'] = [];
|
|
}
|
|
|
|
private function get_behaviors(): array
|
|
{
|
|
$behaviors = [];
|
|
|
|
foreach ($this->get_content() as $item) {
|
|
if (isset($item['behaviors'])) {
|
|
foreach ($item['behaviors'] as $behavior) {
|
|
for ($i = 0; $item['quantity'] > $i; ++$i) {
|
|
$behaviors[] = $behavior;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $behaviors;
|
|
}
|
|
|
|
private function init_cart(): void
|
|
{
|
|
if (! isset($_SESSION['cart'])) {
|
|
$_SESSION['cart'] = [];
|
|
}
|
|
}
|
|
|
|
private function init_product(int $code, array $info, int $parentCode = 0, int $quantity = 0, int $childInputedPrice = 0): void
|
|
{
|
|
|
|
if (! isset($_SESSION['cart'][ $code ]) || ! isset($_SESSION['cart'][ $parentCode ][ 'bundledproducts' ][ $code ])) {
|
|
$info['hash'] = md5($code . time());
|
|
$info['code'] = $code;
|
|
$info['quantity'] = $quantity;
|
|
$info['price'] = number_format($info['price'], 2, '.', '');
|
|
$info['inputedprice'] = number_format(abs($childInputedPrice), 2, '.', '');
|
|
|
|
if (! isset($info['href'])) {
|
|
$info['href'] = null;
|
|
}
|
|
|
|
if (! $parentCode) {
|
|
$_SESSION['cart'][ $code ] = $info;
|
|
} else {
|
|
$_SESSION['cart'][ $parentCode ][ 'bundledproducts' ][ $code ] = $info;
|
|
}
|
|
}
|
|
}
|
|
|
|
final public function get_bundled_products(int $parentCode): ?array
|
|
{
|
|
$cart = $this->get_content();
|
|
if (isset($cart[$parentCode]['bundledproducts'])) {
|
|
return $cart[$parentCode]['bundledproducts'];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
final public function get_content(): array
|
|
{
|
|
$this->init_cart();
|
|
|
|
return $_SESSION['cart'];
|
|
}
|
|
|
|
final public function get_inventory_type(int $productId): string
|
|
{
|
|
return $this->trklib->get_item_value($this->productTracker, $productId, $this->productInventoryTypeField);
|
|
}
|
|
|
|
final public function get_inventory(int $productId, bool $less_hold = true): int
|
|
{
|
|
$inventoryType = $this->get_inventory_type($productId);
|
|
if ($inventoryType == 'none') {
|
|
return 999999999;
|
|
}
|
|
if ($inventoryType == 'shared') {
|
|
// TODO: shared inventory feature not yet exist
|
|
return 0;
|
|
}
|
|
if ($less_hold) {
|
|
$this->expire_onhold_list($productId);
|
|
$inventoryFieldId = $this->productInventoryLessHoldField;
|
|
} else {
|
|
$inventoryFieldId = $this->productInventoryTotalField;
|
|
}
|
|
|
|
return (int) $this->trklib->get_item_value($this->productTracker, $productId, $inventoryFieldId);
|
|
}
|
|
|
|
final public function change_inventory(int $productId, int $amount = 1, bool $changeLessHold = true): bool
|
|
{
|
|
if (! $this->inventoryEnabled) {
|
|
return false;
|
|
}
|
|
$inventoryType = $this->get_inventory_type($productId);
|
|
if ($inventoryType == 'none') {
|
|
return false;
|
|
}
|
|
$currentTotal = $this->get_inventory($productId, false);
|
|
$newTotal = max(0, $currentTotal + $amount);
|
|
$this->set_inventory($productId, $newTotal, false);
|
|
if ($changeLessHold) {
|
|
$currentLessHold = $this->get_inventory($productId);
|
|
$newLessHold = max(0, $currentLessHold + $amount);
|
|
$this->set_inventory($productId, $newLessHold, true);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
final public function hold_inventory(int $productId, int $amount = 1): bool
|
|
{
|
|
if ($bundledProducts = $this->get_bundled_products($productId)) {
|
|
foreach ($bundledProducts as $b) {
|
|
$this->hold_inventory($b['code'], $amount * $b['quantity']);
|
|
}
|
|
}
|
|
$inventoryType = $this->get_inventory_type($productId);
|
|
if ($inventoryType == 'none') {
|
|
return false;
|
|
}
|
|
$currentLessHold = $this->get_inventory($productId);
|
|
$newLessHold = max(0, $currentLessHold - $amount);
|
|
$this->set_inventory($productId, $newLessHold, true);
|
|
return true;
|
|
}
|
|
|
|
final public function unhold_inventory(int $productId, int $amount = 1): bool
|
|
{
|
|
if ($bundledProducts = $this->get_bundled_products($productId)) {
|
|
foreach ($bundledProducts as $b) {
|
|
$this->unhold_inventory($b['code'], $amount * $b['quantity']);
|
|
}
|
|
}
|
|
$inventoryType = $this->get_inventory_type($productId);
|
|
if ($inventoryType == 'none') {
|
|
return false;
|
|
}
|
|
$currentLessHold = $this->get_inventory($productId);
|
|
$currentTotal = $this->get_inventory($productId, false);
|
|
$newLessHold = min($currentTotal, $currentLessHold + $amount);
|
|
$this->set_inventory($productId, $newLessHold, true);
|
|
return true;
|
|
}
|
|
|
|
private function set_inventory(int $productId, int $amount, bool $less_hold = true): bool
|
|
{
|
|
global $prefs;
|
|
$inventoryType = $this->get_inventory_type($productId);
|
|
if ($inventoryType == 'none') {
|
|
return false;
|
|
}
|
|
if ($inventoryType == 'shared') {
|
|
// TODO: shared inventory feature not existing yet
|
|
return false;
|
|
}
|
|
|
|
if ($less_hold) {
|
|
$inventoryFieldId = $this->productInventoryLessHoldField;
|
|
} else {
|
|
$inventoryFieldId = $this->productInventoryTotalField;
|
|
}
|
|
|
|
$this->modify_tracker_item(
|
|
$this->productTracker,
|
|
$productId,
|
|
[
|
|
['fieldId' => $inventoryFieldId, 'value' => $amount]
|
|
]
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
private function modify_tracker_item(int $trackerId, int $itemId, array $trackerFields): bool
|
|
{
|
|
$tracker_fields_info = $this->trklib->list_tracker_fields($trackerId);
|
|
$fieldTypes = [];
|
|
foreach ($tracker_fields_info['data'] as $t) {
|
|
$fieldTypes[$t['fieldId']] = $t['type'];
|
|
$fieldOptionsArray[$t['fieldId']] = $t['options_array'];
|
|
}
|
|
foreach ($trackerFields as &$h) {
|
|
$h['type'] = $fieldTypes[$h['fieldId']];
|
|
$h['options_array'] = $fieldOptionsArray[$h['fieldId']];
|
|
}
|
|
foreach ($trackerFields as $v) {
|
|
$ins_fields["data"][] = ['options_array' => $v['options_array'], 'type' => $v['type'], 'fieldId' => $v['fieldId'], 'value' => $v['value']];
|
|
}
|
|
$this->trklib->replace_item($trackerId, $itemId, $ins_fields);
|
|
return true;
|
|
}
|
|
|
|
private function clear_onhold_list(): bool
|
|
{
|
|
$hashes = [];
|
|
foreach ($this->get_content() as $item) {
|
|
$hashes[] = $item['hash'];
|
|
}
|
|
if (empty($hashes)) {
|
|
return false;
|
|
}
|
|
$mid = implode(',', array_fill(0, count($hashes), '?'));
|
|
$query = "delete from `tiki_cart_inventory_hold` where `hash` in ($mid)";
|
|
$this->tikilib->query($query, $hashes);
|
|
return true;
|
|
}
|
|
|
|
private function expire_onhold_list(int $productId): bool
|
|
{
|
|
global $prefs;
|
|
|
|
$expiry = $prefs['payment_cart_inventoryhold_expiry'] * 60;
|
|
$hash = $this->get_hash($productId);
|
|
$query = "select sum(`quantity`) from `tiki_cart_inventory_hold` where `productId` = ? and `timeHeld` < ?";
|
|
$bindvars = [$productId, $this->tikilib->now - $expiry];
|
|
if ($hash) {
|
|
$query .= " and `hash` != ?";
|
|
$bindvars[] = $hash;
|
|
}
|
|
$quantity = $this->tikilib->getOne($query, $bindvars);
|
|
$query = "delete from `tiki_cart_inventory_hold` where `productId` = ? and `timeHeld` < ?";
|
|
if ($hash) {
|
|
$query .= " and `hash` != ?";
|
|
}
|
|
$this->tikilib->query($query, $bindvars);
|
|
if ($quantity > 0) {
|
|
$this->unhold_inventory($productId, $quantity);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
final public function extend_onhold_list(): bool
|
|
{
|
|
global $prefs;
|
|
$extend = $prefs['payment_cart_inventoryhold_expiry'] * 60;
|
|
$hashes = [];
|
|
foreach ($this->get_content() as $item) {
|
|
$hashes[] = $item['hash'];
|
|
}
|
|
if (empty($hashes)) {
|
|
return false;
|
|
}
|
|
$mid = implode(',', array_fill(0, count($hashes), '?'));
|
|
$query = "select min(`timeHeld`) from `tiki_cart_inventory_hold` where `hash` in ($mid)";
|
|
$earliest = $this->tikilib->getOne($query, $hashes);
|
|
if ($earliest > $this->tikilib->now - $extend) {
|
|
return false;
|
|
}
|
|
$query = "update `tiki_cart_inventory_hold` set `timeHeld` = ? where `hash` in ($mid)";
|
|
$bindvars = array_merge([$this->tikilib->now], $hashes);
|
|
$this->tikilib->query($query, $bindvars);
|
|
return true;
|
|
}
|
|
|
|
private function remove_from_onhold_list(int $code): bool
|
|
{
|
|
$hash = $this->get_hash($code);
|
|
$query = "delete from `tiki_cart_inventory_hold` where `hash` = ?";
|
|
$this->tikilib->query($query, $hash);
|
|
return true;
|
|
}
|
|
|
|
private function add_to_onhold_list(int $code, int $quantity): bool
|
|
{
|
|
$hash = $this->get_hash($code);
|
|
$query = "insert into `tiki_cart_inventory_hold` (`productId`, `quantity`, `timeHeld`, `hash`) values (?,?,?,?)";
|
|
$bindvars = [$code, $quantity, $this->tikilib->now, $hash];
|
|
$this->tikilib->query($query, $bindvars);
|
|
return true;
|
|
}
|
|
|
|
final public function get_missing_user_information_fields(int $product_class_id, string $type = 'required'): array
|
|
{
|
|
global $user, $prefs;
|
|
if ($type == 'required') {
|
|
$fields_str = $this->get_tracker_value_custom($prefs['payment_cart_productclasses_tracker_name'], 'Required Field IDs', $product_class_id);
|
|
} elseif ($type == 'postpurchase') {
|
|
$fields_str = $this->get_tracker_value_custom($prefs['payment_cart_productclasses_tracker_name'], 'Postpurchase Field IDs', $product_class_id);
|
|
}
|
|
$fields = explode(',', str_replace(' ', '', $fields_str));
|
|
$tocheck = [];
|
|
$missing = [];
|
|
foreach ($fields as $f) {
|
|
if (empty($f)) {
|
|
continue;
|
|
}
|
|
$trackerId = $this->trklib->getOne('select `trackerId` from `tiki_tracker_fields` where `fieldId` = ?', $f);
|
|
$tocheck[$trackerId][] = $f;
|
|
}
|
|
foreach ($tocheck as $trackerId => $flds) {
|
|
$definition = Tracker_Definition::get($trackerId);
|
|
if ($fieldId = $definition->getUserField()) {
|
|
$item = $this->trklib->get_item($trackerId, $fieldId, $user);
|
|
foreach ($flds as $f) {
|
|
if (! isset($item[$f]) || ! $item[$f]) {
|
|
$missing[$trackerId][] = $f;
|
|
}
|
|
}
|
|
} else {
|
|
$missing = $tocheck;
|
|
}
|
|
}
|
|
return $missing;
|
|
}
|
|
|
|
final public function get_missing_user_information_form(int $product_class_id, string $type = 'required'): string
|
|
{
|
|
global $prefs;
|
|
if ($type == 'required') {
|
|
return $this->get_tracker_value_custom($prefs['payment_cart_productclasses_tracker_name'], 'Associated Required Form', $product_class_id);
|
|
} else {
|
|
return $this->get_tracker_value_custom($prefs['payment_cart_productclasses_tracker_name'], 'Associated Postpurchase Form', $product_class_id);
|
|
}
|
|
}
|
|
|
|
final public function skip_user_information_form_if_not_missing(int $product_class_id): bool
|
|
{
|
|
global $prefs;
|
|
if ($this->get_tracker_value_custom($prefs['payment_cart_productclasses_tracker_name'], 'Skip Required Form if Filled', $product_class_id) == 'Yes') {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|