[jfinancials-war.git] /

/*
 * Copyright (C) 2016 - 2022 Free Software Foundation
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.mxchange.jfinancials.beans.financial.model.receipt_item.list;

import fish.payara.cdi.jsr107.impl.NamedCache;
import java.text.MessageFormat;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import javax.annotation.PostConstruct;
import javax.cache.Cache;
import javax.ejb.EJB;
import javax.enterprise.event.Observes;
import javax.faces.view.ViewScoped;
import javax.inject.Inject;
import javax.inject.Named;
import org.mxchange.jfinancials.beans.BaseFinancialsBean;
import org.mxchange.jfinancials.beans.user.login.FinancialsUserLoginWebSessionController;
import org.mxchange.jfinancials.events.receipt_item.added.ObservableAdminReceiptItemAddedEvent;
import org.mxchange.jfinancials.events.receipt_item.updated.ObservableAdminReceiptItemUpdatedEvent;
import org.mxchange.jfinancials.exceptions.receipt_item.ReceiptItemNotFoundException;
import org.mxchange.jfinancials.model.receipt_item.BillableReceiptItem;
import org.mxchange.jfinancials.model.receipt_item.FinancialReceiptItemSessionBeanRemote;
import org.mxchange.jfinancials.model.utils.ReceiptItemUtils;
import org.mxchange.jproduct.events.product.updated.ObservableProductUpdatedEvent;
import org.mxchange.juserlogincore.events.login.ObservableUserLoggedInEvent;

/**
 * A list financial receipt item bean (controller)
 * <p>
 * @author Roland Häder<roland@mxchange.org>
 */
@Named ("receiptItemListController")
@ViewScoped
public class FinancialsReceiptItemListWebViewBean extends BaseFinancialsBean implements FinancialsReceiptItemListWebViewController {

        /**
         * Serial number
         */
        private static final long serialVersionUID = 56_189_028_928_472L;

        /**
         * All receipt items list
         */
        private final List<BillableReceiptItem> allReceiptItems;

        /**
         * Filtered receipt items list
         */
        private List<BillableReceiptItem> filteredReceiptItems;

        /**
         * EJB for general financial receipt purposes
         */
        @EJB (lookup = "java:global/jfinancials-ejb/financialReceiptItem!org.mxchange.jfinancials.model.receipt_item.FinancialReceiptItemSessionBeanRemote")
        private FinancialReceiptItemSessionBeanRemote receiptItemBean;

        /**
         * A list of all branch offices (globally)
         */
        @Inject
        @NamedCache (cacheName = "receiptItemCache")
        private transient Cache<Long, BillableReceiptItem> receiptItemCache;

        /**
         * Selected receipt item
         */
        private BillableReceiptItem selectedReceiptItem;

        /**
         * User instance
         */
        @Inject
        private FinancialsUserLoginWebSessionController userLoginController;

        /**
         * User's receipt items
         */
        private final List<BillableReceiptItem> userReceiptItems;

        /**
         * Constructor
         */
        @SuppressWarnings ("CollectionWithoutInitialCapacity")
        public FinancialsReceiptItemListWebViewBean () {
                // Call super constructor
                super();

                // Init lists
                this.allReceiptItems = new LinkedList<>();
                this.userReceiptItems = new LinkedList<>();
        }

        /**
         * Observes events being fired when an administrator has added a new receipt
         * item.
         * <p>
         * @param event Event being fired
         */
        public void afterAdminAddedReceiptItemEvent (@Observes final ObservableAdminReceiptItemAddedEvent event) {
                // Validate parameter
                if (null == event) {
                        // Throw NPE
                        throw new NullPointerException("event is null"); //NOI18N
                } else if (event.getAddedReceiptItem() == null) {
                        //Throw NPE again
                        throw new NullPointerException("event.addedReceiptItem is null"); //NOI18N
                } else if (event.getAddedReceiptItem().getItemId() == null) {
                        //Throw NPE again
                        throw new NullPointerException("event.addedReceiptItem.itemId is null"); //NOI18N
                } else if (event.getAddedReceiptItem().getItemId() < 1) {
                        //Throw IAE
                        throw new IllegalArgumentException(MessageFormat.format("event.addedReceiptItem.itemId={0} is not valid", event.getAddedReceiptItem().getItemId())); //NOI18N
                }

                // Uniquely add to cache
                this.uniqueAddReceiptItem(event.getAddedReceiptItem());
        }

        /**
         * Observes events being fired when an administrator has updated a receipt
         * item instance.
         * <p>
         * @param event Event being fired
         */
        public void afterAdminUpdatedReceiptItemEvent (final @Observes ObservableAdminReceiptItemUpdatedEvent event) {
                // Validate parameter
                if (null == event) {
                        // Throw NPE
                        throw new NullPointerException("event is null"); //NOI18N
                } else if (event.getUpdatedReceiptItem() == null) {
                        //Throw NPE again
                        throw new NullPointerException("event.updatedReceiptItem is null"); //NOI18N
                } else if (event.getUpdatedReceiptItem().getItemId() == null) {
                        //Throw NPE again
                        throw new NullPointerException("event.updatedReceiptItem.itemId is null"); //NOI18N
                } else if (event.getUpdatedReceiptItem().getItemId() < 1) {
                        //Throw IAE
                        throw new IllegalArgumentException(MessageFormat.format("event.updatedReceiptItem.itemId={0} is not valid", event.getUpdatedReceiptItem().getItemId())); //NOI18N
                }

                // Uniquely update instance
                this.uniqueAddReceiptItem(event.getUpdatedReceiptItem());
        }

        /**
         * Event observer for updated product data by administrators
         * <p>
         * @param event Updated product data event
         */
        public void afterProductUpdatedEvent (@Observes final ObservableProductUpdatedEvent event) {
                // Event and contained entity instance should not be null
                if (null == event) {
                        // Throw NPE
                        throw new NullPointerException("event is null"); //NOI18N
                } else if (event.getUpdatedProduct() == null) {
                        // Throw NPE again
                        throw new NullPointerException("event.updatedProduct is null"); //NOI18N
                } else if (event.getUpdatedProduct().getProductId() == null) {
                        // userId is null
                        throw new NullPointerException("event.updatedProduct.productId is null"); //NOI18N
                } else if (event.getUpdatedProduct().getProductId() < 1) {
                        // Not avalid id
                        throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getUpdatedProduct(), event.getUpdatedProduct().getProductId())); //NOI18N
                }

                // Get iterator from
                final Iterator<Cache.Entry<Long, BillableReceiptItem>> iterator = this.receiptItemCache.iterator();

                // Loop through it
                while (iterator.hasNext()) {
                        // Get next item
                        final Cache.Entry<Long, BillableReceiptItem> current = iterator.next();

                        // Get current product
                        final BillableReceiptItem currentItem = current.getValue();

                        // Is the same product id set?
                        if (event.getUpdatedProduct().getProductId().equals(currentItem.getItemProduct().getProductId())) {
                                // Yes, found it, get key
                                final Long itemId = current.getKey();

                                // Set new instance
                                currentItem.setItemProduct(event.getUpdatedProduct());

                                // Update cache
                                this.receiptItemCache.put(itemId, currentItem);

                                // Stop searching here
                                break;
                        }
                }
        }

        /**
         * Event observer for logged-in user
         * <p>
         * @param event Event instance
         */
        public void afterUserLoginEvent (@Observes final ObservableUserLoggedInEvent event) {
                // Event and contained entity instance should not be null
                if (null == event) {
                        // Throw NPE
                        throw new NullPointerException("event is null"); //NOI18N
                } else if (event.getLoggedInUser() == null) {
                        // Throw NPE again
                        throw new NullPointerException("event.loggedInUser is null"); //NOI18N
                } else if (event.getLoggedInUser().getUserId() == null) {
                        // userId is null
                        throw new NullPointerException("event.loggedInUser.userId is null"); //NOI18N
                } else if (event.getLoggedInUser().getUserId() < 1) {
                        // Not avalid id
                        throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getLoggedInUser(), event.getLoggedInUser().getUserId())); //NOI18N
                }

                // Fill cache with all found user's receipts
                for (final BillableReceiptItem receiptItem : this.allReceiptItems) {
                        // Is same user?
                        if (Objects.equals(receiptItem.getItemReceipt().getReceiptUser(), event.getLoggedInUser())) {
                                // Yes, then add it
                                this.userReceiptItems.add(receiptItem);
                        }
                }
        }

        @Override
        public BillableReceiptItem findReceiptItemById (final Long receiptItemId) throws ReceiptItemNotFoundException {
                // Validate parameter
                if (null == receiptItemId) {
                        // Throw NPE
                        throw new NullPointerException("receiptItemId is null");
                } else if (receiptItemId < 1) {
                        // Throw IAE
                        throw new IllegalArgumentException(MessageFormat.format("receiptItemId={0} is not valid.", receiptItemId));
                }

                // Init instance
                BillableReceiptItem receiptItem = null;

                // Iterate over whole list
                for (final BillableReceiptItem currentReceiptItem : this.getAllReceiptItems()) {
                        // Is the primary key matching?
                        if (Objects.equals(currentReceiptItem.getItemId(), receiptItemId)) {
                                // Yes, then remember and exit iteration
                                receiptItem = currentReceiptItem;
                                break;
                        }
                }

                // Is found?
                if (null == receiptItem) {
                        // Not found
                        throw new ReceiptItemNotFoundException(receiptItemId);
                }

                // Return it
                return receiptItem;
        }

        @Override
        @SuppressWarnings ("ReturnOfCollectionOrArrayField")
        public List<BillableReceiptItem> getAllReceiptItems () {
                return this.allReceiptItems;
        }

        /**
         * Getter for filtered receipt items
         * <p>
         * @return Filtered receipts
         */
        @SuppressWarnings ("ReturnOfCollectionOrArrayField")
        public List<BillableReceiptItem> getFilteredReceiptItems () {
                return this.filteredReceiptItems;
        }

        /**
         * Setter for filtered receipt items
         * <p>
         * @param filteredReceiptItems Filtered receipt items
         */
        @SuppressWarnings ("AssignmentToCollectionOrArrayFieldFromParameter")
        public void setFilteredReceiptItems (final List<BillableReceiptItem> filteredReceiptItems) {
                this.filteredReceiptItems = filteredReceiptItems;
        }

        /**
         * Getter for selected receipt item
         * <p>
         * @return Selected receipt item
         */
        public BillableReceiptItem getSelectedReceiptItem () {
                return this.selectedReceiptItem;
        }

        /**
         * Setter for selected receipt item
         * <p>
         * @param selectedReceiptItem Selected receipt item
         */
        public void setSelectedReceiptItem (final BillableReceiptItem selectedReceiptItem) {
                this.selectedReceiptItem = selectedReceiptItem;
        }

        @PostConstruct
        public void initCache () {
                // Is cache there?
                if (!this.receiptItemCache.iterator().hasNext()) {
                        // Add all
                        for (final BillableReceiptItem receiptItem : this.receiptItemBean.fetchAllReceiptItems()) {
                                // Add it to cache
                                this.receiptItemCache.put(receiptItem.getItemId(), receiptItem);
                        }
                }

                // Is the list empty, but filled cache?
                if (this.getAllReceiptItems().isEmpty() && this.receiptItemCache.iterator().hasNext()) {
                        // Build up list
                        for (final Cache.Entry<Long, BillableReceiptItem> currentEntry : this.receiptItemCache) {
                                // Add to list
                                this.getAllReceiptItems().add(currentEntry.getValue());
                        }

                        // Sort list
                        this.getAllReceiptItems().sort(new Comparator<BillableReceiptItem>() {
                                @Override
                                public int compare (final BillableReceiptItem receiptItem1, final BillableReceiptItem receiptItem2) {
                                        return receiptItem1.getItemId() > receiptItem2.getItemId() ? 1 : receiptItem1.getItemId() < receiptItem2.getItemId() ? -1 : 0;
                                }
                        }
                        );
                }
        }

        @Override
        public boolean isReceiptItemAdded (final BillableReceiptItem receiptItem) {
                // Does it contain the same object?
                if (this.getAllReceiptItems().contains(receiptItem)) {
                        // Yes, skip below code
                        return true;
                }

                // Default is not the same
                boolean alreadyAdded = false;

                // Loop over all
                for (final BillableReceiptItem item : this.getAllReceiptItems()) {
                        // Is the same?
                        if (ReceiptItemUtils.isSameReceiptItem(item, receiptItem)) {
                                // Yes, found it
                                alreadyAdded = true;
                                break;
                        }
                }

                // Return flag
                return alreadyAdded;
        }

        /**
         * Uniquely add a receipt item instance.
         * <p>
         * @param receiptItem To be added/updated receipt item instance
         */
        private void uniqueAddReceiptItem (final BillableReceiptItem receiptItem) {
                // Add to cache and general list
                this.receiptItemCache.put(receiptItem.getItemId(), receiptItem);

                // Get iterator
                final Iterator<BillableReceiptItem> allIterator = this.getAllReceiptItems().iterator();

                // Iterate over all entries
                while (allIterator.hasNext()) {
                        // Get current item
                        final BillableReceiptItem currentReceiptItem = allIterator.next();

                        // It the id matching?
                        if (Objects.equals(receiptItem.getItemId(), currentReceiptItem.getItemId())) {
                                // Yes, then remove it and stop iterating
                                allIterator.remove();
                                break;
                        }
                }

                // Re-add it
                this.getAllReceiptItems().add(receiptItem);

                // Is same user?
                if (this.userLoginController.isUserLoggedIn() && Objects.equals(receiptItem.getItemReceipt().getReceiptUser(), this.userLoginController.getLoggedInUser())) {
                        // Get iterator
                        final Iterator<BillableReceiptItem> userIterator = this.userReceiptItems.iterator();

                        // Iterate over all entries
                        while (userIterator.hasNext()) {
                                // Get current item
                                final BillableReceiptItem currentReceiptItem = userIterator.next();

                                // It the id matching?
                                if (Objects.equals(receiptItem.getItemId(), currentReceiptItem.getItemId())) {
                                        // Yes, then remove it and stop iterating
                                        userIterator.remove();
                                        break;
                                }
                        }

                        // Re-add it
                        this.userReceiptItems.add(receiptItem);
                }
        }
}