Elep

<?php
/*
 * SubscriptionFlow Package for SugarCRM
 *
 * Copyright (C) SubscriptionFlow. All rights reserved.
 *
 * Your installation or use of this package is subject to the applicable
 * terms available at https://www.subscriptionflow.com/terms-and-conditions
 * If you do not agree to all of the applicable terms, do not install or use this package.
 * Support: https://support.subscriptionflow.com
 */

require_once("modules/SF_Subscriptions/SF_SubscriptionFlow_Sync.php");
require_once('modules/SF_Subscriptions/license/SugarSubscriptionFlowOutfittersLicense.php');
require_once('include/SugarQuery/SugarQuery.php');
require_once('data/BeanFactory.php');
require_once("include/utils/autoloader.php");

class SF_Subscriptions_Job
{
    public $last_run = null;

/*
     * Start data sync
     * @return void
     * This function gets all the updated customers from SubscriptionFlow and matches their sf_customer_id_c with the accounts in SugarCRM.
     * It will sync subscriptions, invoices for the matched accounts.
     * */
    public function startDataSync()
    {
        global $current_user;
        if ($this->validateLicense()) {
            $sf_sync = new SF_SubscriptionFlow_Sync();
            $sf_sync->loadConnection();
            if ($sf_sync->status && SugarAutoloader::fileExists("custom/Extension/modules/Accounts/Ext/Vardefs/sugarfield_sf_customer_id_c.php")) {
                $customers = $this->getUpdatedCustomers();
                if (is_array($customers) && count($customers) > 0) {
                    $customerIds = [];
                    foreach ($customers as $customer) {
                        $customerIds[] = $customer['id'];
                    }
                    if (is_array($customerIds) && count($customerIds) > 0) {
                        $accountsQuery = "SELECT accounts.id, accounts_cstm.sf_customer_id_c FROM accounts, accounts_cstm WHERE accounts.id=accounts_cstm.id_c AND accounts.deleted=0 AND accounts_cstm.sf_customer_id_c IN ('" . implode("','", $customerIds) . "')";
                        $accountsResult = $GLOBALS['db']->query($accountsQuery);
                        $accounts = [];
                        while ($row = $GLOBALS['db']->fetchByAssoc($accountsResult)) {
                            $accounts[$row['sf_customer_id_c']] = $row['id'];
                        }
                        if (is_array($accounts) && count($accounts) > 0) {
                            foreach ($accounts as $sf_customer_id => $sugar_account_id) {
                                require_once 'include/SugarQueue/SugarJobQueue.php';
                                require_once 'modules/SchedulersJobs/SchedulersJob.php';
                                $sfJobQueue = new SchedulersJob();
                                $sfJobQueue->name = "Sync data for SubscriptionFlow Customer ID: $sf_customer_id and SugarCRM Account ID: $sugar_account_id";
                                $sfJobQueue->assigned_user_id = $current_user->id;
                                $sfJobQueue->data = json_encode(array('sf_customer_id' => $sf_customer_id, 'sugar_account_id' => $sugar_account_id, 'last_run' => $this->last_run));
                                $sfJobQueue->target = "class::SFSubscriptionJobQueue";
                                $sfJobQueue->requeue = true;
                                $sfJobQueue->retry_count = 2;
                                $queue = new SugarJobQueue();
                                $queue->submitJob($sfJobQueue);
                            }
                        }
                    }
                }
            }
        }
    }

private function getUpdatedCustomers()
    {
        if (!$this->last_run) {
            $this->last_run = $this->getLastRun();
        }
        $sf_sync = new SF_SubscriptionFlow_Sync();
        $sf_sync->loadConnection();
        $filters = array('filter[$select]' => "id, name");
        $filters['filter[updated_at][$gte]'] = $this->last_run;
        $customers = [];
        if ($sf_sync->status) {
            $customers = $sf_sync->syncCustomers($filters);
        }
        return $customers;
    }

private function getLastRun()
    {
        $query = "SELECT last_run FROM schedulers WHERE deleted=0 AND status='Active' AND job='function::sf_subscriptions_job'";
        $row = $GLOBALS['db']->fetchOne($query);
        $last_run = $row['last_run'] ?? null;
        if (!$last_run) {
            $last_run = date('Y-m-d H:i:s', strtotime('-24 hours'));
        }
        return $last_run;
    }

private function validateLicense()
    {
        global $current_user, $currentModule, $sugar_config, $sugar_version;
        $validate_license = SugarSubscriptionFlowOutfittersLicense::isValid($currentModule, $current_user->id, false);
        if ($validate_license !== true) {
            return false;
        }
        return true;
    }

private function retrieveBeanBySFId($module, $fieldName, $fieldValue)
    {
        $sugarQuery = new SugarQuery();
        $bean = BeanFactory::newBean($module);
        $sql = new SugarQuery();
        $sql->select('id');
        $sql->from($bean);
        $sql->Where()->equals($fieldName, $fieldValue);
        $result = $sql->execute();
        $count = count($result);
        if ($count == 1) {
            $bean = BeanFactory::getBean($module, $result[0]['id']);
            return $bean;
        }
        return null;
    }

public function process_queue($sf_customer_id, $sugar_account_id, $last_run)
    {
        $sf_sync = new SF_SubscriptionFlow_Sync();
        $sf_sync->loadConnection();
        if ($sf_sync->status) {
            $sf_sync = new SF_SubscriptionFlow_Sync();
            $sf_sync->loadConnection();
            $filters = [];
            $filters['filter[updated_at][$gte]'] = $last_run;
            $filters['filter[customer_id][$equals]'] = $sf_customer_id;
            $subscriptions = $sf_sync->getSubscriptions($filters);
            if (is_array($subscriptions) && count($subscriptions) > 0) {
                foreach ($subscriptions as $subscription) {
                    $this->updateSubscriptionInSugar($subscription);
                }
            }
            $filters['filter[is_oneoff][$equals]'] = 0;
            $filters['filter[status][$not_equals]'] = 'Projected';
            $invoices = $sf_sync->getInvoices($filters);
            if (is_array($invoices) && count($invoices) > 0) {
                foreach ($invoices as $invoice) {
                    $this->updateInvoiceInSugar($invoice, $sugar_account_id);
                }
            }
        }
    }

private function updateSubscriptionInSugar($sfSubscription)
    {
        if (isset($sfSubscription['id']) && !empty($sfSubscription['id'])) {
            $subscription = $this->retrieveBeanBySFId('SF_Subscriptions', 'sf_subscription_id', $sfSubscription['id']);
            if ($subscription && $subscription->id && !empty($subscription->id)) {
                $subscription->name = $sfSubscription['name'];
                $subscription->title = $sfSubscription['display_name'];
                $date_modified = $sfSubscription['updated_at'];
                $date_modified = date('Y-m-d H:i:s', strtotime($date_modified));
                $subscription->date_modified = $date_modified;
                $subscription->is_auto_renew = $sfSubscription['is_auto_renew'];
                $subscription->trigger_date = $sfSubscription['trigger_dates'];
                $subscription->subscription_start_date = $sfSubscription['termed_start_date'];
                $subscription->separate_invoice = $sfSubscription['invoice_separate'];
                $subscription->payment_status = $sfSubscription['payment_status'];
                $subscription->status = $sfSubscription['status'];
                $subscription->order_date = $sfSubscription['termed_start_date'];
                $subscription->subscription_type = $sfSubscription['type'];
                $subscription->sf_subscription_id = $sfSubscription['id'];
                $subscription->term_initial_period = $sfSubscription['termed_initial_period'];
                $subscription->term_initial_period_type = $sfSubscription['termed_initial_period_type'];
                if ($sfSubscription['renewal_type'] == 'Renew with Specific Term') {
                    $subscription->renewal_is_different = 0;
                } else {
                    $subscription->renewal_is_different = 1;
                }
                if ($sfSubscription['trial_period'] && $sfSubscription['trial_period_unit']) {
                    $subscription->enable_trial = 1;
                } else {
                    $subscription->enable_trial = 0;
                }
                $subscription->trial_period = $sfSubscription['trial_period'];
                $subscription->trial_period_unit = $sfSubscription['trial_period_unit'];
                $subscription->next_bill_date = $sfSubscription['next_bill_date'];
                $subscription->billing_end_date = $sfSubscription['billing_end_date'];
                $subscription->suspended_at = $sfSubscription['suspended_at'];
                $subscription->cancelled_at = $sfSubscription['cancelled_at'];
                $subscription->resume_suspended_at = $sfSubscription['resume_suspended_at'];
                $subscription->enable_gift = $sfSubscription['is_gift'];
                $subscription->save();
            }
        }
    }

private function updateInvoiceInSugar($sfInvoice)
    {
        if (isset($sfInvoice['id']) && !empty($sfInvoice['id'])) {
            $invoice = $this->retrieveBeanBySFId('SF_Invoices', 'sf_invoice_id_c', $sfInvoice['id']);
            if ($invoice && $invoice->id && !empty($invoice->id)) { //update existing invoice
                if (isset($invoice->status) && isset($sfInvoice['status']) && $invoice->status != $sfInvoice['status']) {
                    $invoice->name = $sfInvoice['name'];
                    $updated_at = $sfInvoice['updated_at'];
                    $updated_at = date('Y-m-d H:i:s', strtotime($updated_at));
                    $invoice->date_modified = $updated_at;
                    $invoice->invoice_date = $sfInvoice['invoice_date'];
                    $invoice->due_date = $sfInvoice['due_date'];
                    $invoice->terms = $sfInvoice['terms'];
                    $invoice->status = $sfInvoice['status'];
                    $invoice->status_reason = $sfInvoice['note'];
                    $invoice->discount_amount = $sfInvoice['discount_value'];
                    $invoice->tax_amount = $sfInvoice['tax_amount'];
                    $invoice->miscellaneous_charges = $sfInvoice['miscellaneous_charges'];
                    $invoice->sub_total = $sfInvoice['sub_total'];
                    $invoice->total_amount = $sfInvoice['total_amount'];
                    $invoice->received_payment = $sfInvoice['received_payment'];
                    $invoice->additional_info = $sfInvoice['additional_info'];
                    $invoice->opening_balance = $sfInvoice['opening_balance'];
                    $invoice->closing_balance = $sfInvoice['closing_balance'];
                    $invoice->reversed_reference = $sfInvoice['reversed_reference'];
                    $invoice->accounting_resource_id = $sfInvoice['accounting_resource_id'];
                    $invoice->description = $sfInvoice['description'];
                    $invoice->save();
                }
            } else { //add new invoice from SF to Sugar
                $this->syncNewInvoice($sfInvoice['id']);
            }
        }
    }

private function syncNewInvoice($invoice_id)
    {
        $sf_sync = new SF_SubscriptionFlow_Sync();
        $sf_sync->loadConnection();
        $sfInvoice = $sf_sync->getInvoice($invoice_id);
        $subscription = null;
        if (isset($sfInvoice["items"]) && isset($sfInvoice["items"][0]) && isset($sfInvoice["items"][0]["subscription_id"])) {
            $subscription = $this->retrieveBeanBySFId('SF_Subscriptions', 'sf_subscription_id', $sfInvoice["items"][0]["subscription_id"]);
        }
        if ($subscription && $subscription->id && !empty($subscription->id) && isset($sfInvoice["items"]) && is_array($sfInvoice["items"]) && count($sfInvoice["items"]) > 0) {
            $invoice = BeanFactory::newBean('SF_Invoices');
            $invoice->sf_invoice_id_c = $sfInvoice['id'];
            $invoice->name = $sfInvoice['name'];
            $date_entered = $sfInvoice['created_at'];
            $date_entered = date('Y-m-d H:i:s', strtotime($date_entered . ' +1 second'));
            $invoice->date_entered = $date_entered;
            $updated_at = $sfInvoice['updated_at'];
            $updated_at = date('Y-m-d H:i:s', strtotime($updated_at));
            $invoice->date_modified = $updated_at;
            $invoice->created_by = $subscription->created_by;
            $invoice->modified_user_id = $subscription->modified_user_id;
            $invoice->assigned_user_id = $subscription->assigned_user_id;
            $invoice->invoice_date = $sfInvoice['invoice_date'];
            $invoice->due_date = $sfInvoice['due_date'];
            $invoice->terms = $sfInvoice['terms'];
            $invoice->status = $sfInvoice['status'];
            $invoice->status_reason = $sfInvoice['note'];
            $invoice->discount_amount = $sfInvoice['discount_value'];
            $invoice->tax_amount = $sfInvoice['tax_amount'];
            $invoice->miscellaneous_charges = $sfInvoice['miscellaneous_charges'];
            $invoice->sub_total = $sfInvoice['sub_total'];
            $invoice->total_amount = $sfInvoice['total_amount'];
            $invoice->received_payment = $sfInvoice['received_payment'];
            $invoice->additional_info = $sfInvoice['additional_info'];
            $invoice->opening_balance = $sfInvoice['opening_balance'];
            $invoice->closing_balance = $sfInvoice['closing_balance'];
            $invoice->reversed_reference = $sfInvoice['reversed_reference'];
            $invoice->accounting_resource_id = $sfInvoice['accounting_resource_id'];
            $invoice->description = $sfInvoice['description'];
            $invoice->currency_id = $subscription->currency_id;
            $invoice->base_rate = 1.0;
            $invoice->team_id = $subscription->team_id;
            $invoice->team_set_id = $subscription->team_set_id;
            $invoice->acl_team_set_id = $subscription->acl_team_set_id;
            $invoice->save();
            $accounts = $subscription->get_linked_beans('sf_subscriptions_accounts', "Accounts", 0, ['accounts.deleted' => 0]);
            $account_id = $accounts[0]->id;
            $opportunities = $subscription->get_linked_beans('sf_subscriptions_opportunities', "Opportunities", 0, ['opportunities.deleted' => 0]);
            $opportunity_id = $opportunities[0]->id;
            $invoice->load_relationship('sf_invoices_opportunities');
            $invoice->sf_invoices_opportunities->add($opportunity_id);
            $invoice->load_relationship('sf_invoices_accounts');
            $invoice->sf_invoices_accounts->add($account_id);
            if ($subscription->id) {
                $invoice->load_relationship('sf_invoices_sf_subscriptions');
                $invoice->sf_invoices_sf_subscriptions->add($subscription->id);
            }
            foreach ($sfInvoice["items"] as $index => $productPlan) {
                if (isset($productPlan['charges']) && is_array($productPlan['charges']) && count($productPlan['charges']) > 0) {
                    foreach ($productPlan['charges'] as $charge) {
                        $purchased_line_item = BeanFactory::newBean('PurchasedLineItems');
                        $purchased_line_item->name = $charge['name'];
                        $date_entered = $GLOBALS['timedate']->nowDb();
                        $date_entered = date('Y-m-d H:i:s', strtotime($date_entered . ' +1 second'));
                        $purchased_line_item->date_entered = $date_entered;
                        $purchased_line_item->date_modified = $date_entered;
                        $purchased_line_item->created_by = $subscription->created_by;
                        $purchased_line_item->modified_user_id = $subscription->modified_user_id;
                        $purchased_line_item->assigned_user_id = $subscription->assigned_user_id;
                        if (isset($charge['plan_price']['description'])) {
                            $purchased_line_item->description = $charge['plan_price']['description'];
                        } else {
                            $purchased_line_item->description = null;
                        }
                        $charge_price = $charge['charge_price'];
                        $quantity = $charge['default_quantity'] ?? 1;
                        $subtotal = $charge['sub_total'];
                        $purchased_line_item->account_id = $account_id;
                        $purchased_line_item->subtotal = $subtotal;
                        $purchased_line_item->total_amount = $subtotal;
                        $purchased_line_item->product_type_id = null;
                        $purchased_line_item->manufacturer_id = null;
                        $purchased_line_item->category_id = null;
                        $purchased_line_item->mft_part_num = null;
                        $purchased_line_item->cost_price = $charge_price;
                        $purchased_line_item->discount_price = 0;
                        $purchased_line_item->discount_amount = 0;
                        $purchased_line_item->discount_select = 1;
                        $purchased_line_item->deal_calc = 0;
                        $purchased_line_item->deal_calc_usdollar = 0;
                        $purchased_line_item->cost_usdollar = $charge_price;
                        $purchased_line_item->discount_usdollar = 0;
                        $purchased_line_item->list_usdollar = $charge_price;
                        $purchased_line_item->status = null;
                        $purchased_line_item->book_value_usdollar = null;
                        $purchased_line_item->date_closed = null;
                        $purchased_line_item->date_closed_timestamp = null;
                        $purchased_line_item->team_id = $subscription->team_id;
                        $purchased_line_item->team_set_id = $subscription->team_set_id;
                        $purchased_line_item->acl_team_set_id = $subscription->acl_team_set_id;
                        $purchased_line_item->list_price = $charge_price;
                        $purchased_line_item->quantity = $quantity;
                        $purchased_line_item->pricing_factor = 1;
                        if (isset($charge['plan_price']['category']) && $charge['plan_price']['category'] == 'recurring') {
                            $purchased_line_item->renewable = 1;
                        } else {
                            $purchased_line_item->renewable = 0;
                        }
                        $purchased_line_item->renewal = 0;
                        $purchased_line_item->date_support_starts = $charge['service_from'];
                        $purchased_line_item->service_start_date = $charge['service_from'];
                        $purchased_line_item->support_name = "SubscriptionFlow";
                        $purchased_line_item->date_support_expires = $charge['service_to'];
                        $purchased_line_item->service_end_date = $charge['service_to'];
                        $purchased_line_item->service = 1;
                        $purchased_line_item->date_purchased = $date_entered;
                        $purchased_line_item->annual_revenue = null;
                        $purchased_line_item->discount_amount_signed = $charge['discount'];
                        $purchased_line_item->discount_amount_usdollar = $charge['discount'];
                        $purchased_line_item->revenue = null;
                        $purchased_line_item->revenue_usdollar = null;
                        $purchased_line_item->product_template_id = null;
                        $purchased_line_item->lock_duration = null;
                        $purchased_line_item->sync_key = null;
                        $purchased_line_item->asset_number = null;
                        $purchased_line_item->book_value = null;
                        $purchased_line_item->book_value_date = null;
                        $purchased_line_item->serial_number = null;
                        $purchased_line_item->catalog_service_duration_value = null;
                        $purchased_line_item->catalog_service_duration_unit = null;
                        $purchased_line_item->service_duration_multiplier = null;
                        $purchased_line_item->support_contact = null;
                        $purchased_line_item->support_description = null;
                        $purchased_line_item->support_term = null;
                        $purchased_line_item->tax_class = null;
                        $purchased_line_item->vendor_part_num = null;
                        $purchased_line_item->website = null;
                        $purchased_line_item->weight = null;
                        $purchased_line_item->base_rate = 1.0;
                        $purchased_line_item->sf_product_id_c = $productPlan['product_id'] ?? null;
                        $purchased_line_item->sf_plan_id_c = $productPlan['plan_id'] ?? null;
                        $purchased_line_item->sf_price_id_c = $charge['id'] ?? null;
                        $purchased_line_item->currency_id = $subscription->currency_id;
                        $purchased_line_item->save();
                        $purchased_line_item->load_relationship('sf_invoices_purchasedlineitems');
                        $purchased_line_item->sf_invoices_purchasedlineitems->add($invoice->id);
                    }
                }
            }
        }
    }
}