[jfinancials-war.git] /

/*
 * Copyright (C) 2016, 2017 Roland Häder
 *
 * 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;

import fish.payara.cdi.jsr107.impl.NamedCache;
import java.text.MessageFormat;
import java.util.Comparator;
import java.util.Date;
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.context.RequestScoped;
import javax.enterprise.event.Event;
import javax.enterprise.event.Observes;
import javax.enterprise.inject.Any;
import javax.faces.view.facelets.FaceletException;
import javax.inject.Inject;
import javax.inject.Named;
import org.mxchange.jcontactsbusiness.model.branchoffice.BranchOffice;
import org.mxchange.jcontactsbusiness.model.employee.Employee;
import org.mxchange.jfinancials.beans.BaseFinancialsBean;
import org.mxchange.jfinancials.beans.user.login.FinancialsUserLoginWebSessionController;
import org.mxchange.jfinancials.events.receipt.added.ObservableReceiptAddedEvent;
import org.mxchange.jfinancials.events.receipt.added.ReceiptAddedEvent;
import org.mxchange.jfinancials.exceptions.ReceiptAlreadyAddedException;
import org.mxchange.jfinancials.model.receipt.BillableReceipt;
import org.mxchange.jfinancials.model.receipt.FinancialReceipt;
import org.mxchange.jfinancials.model.receipt.FinancialReceiptSessionBeanRemote;
import org.mxchange.jproduct.model.payment.PaymentType;
import org.mxchange.juserlogincore.events.login.ObservableUserLoggedInEvent;

/**
 * An administrative financial receipt bean (controller)
 * <p>
 * @author Roland Häder<roland@mxchange.org>
 */
@Named ("receiptController")
@RequestScoped
public class FinancialsReceiptWebRequestBean extends BaseFinancialsBean implements FinancialsReceiptWebRequestController {

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

        /**
         * Event being fired when user has added a new receipt
         */
        @Inject
        @Any
        private Event<ObservableReceiptAddedEvent> addedReceiptEvent;

        /**
         * All receipts list
         */
        private final List<BillableReceipt> allReceipts;

        /**
         * Filtered receipts list
         */
        private List<BillableReceipt> filteredReceipts;

        /**
         * Bar-code number
         */
        private Long receiptBarCodeNumber;

        /**
         * EJB for general financial receipt purposes
         */
        @EJB (lookup = "java:global/jfinancials-ejb/financialReceipt!org.mxchange.jfinancials.model.receipt.FinancialReceiptSessionBeanRemote")
        private FinancialReceiptSessionBeanRemote receiptBean;

        /**
         * Recipient issuing company (for example where the user went shopping to)
         */
        private BranchOffice receiptBranchOffice;

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

        /**
         * Date/time the receipt has been issued
         */
        private Date receiptIssued;

        /**
         * Receipt number (only numbers)
         */
        private Long receiptNumber;

        /**
         * Payment type being used for this receipt
         */
        private PaymentType receiptPaymentType;

        /**
         * Register number
         */
        private Long receiptRegisterNumber;

        /**
         * Selling employee
         */
        private Employee receiptSellerEmployee;

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

        /**
         * User's receipts
         */
        private final List<BillableReceipt> userReceipts;

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

                // Init lists
                this.allReceipts = new LinkedList<>();
                this.userReceipts = new LinkedList<>();
        }

        /**
         * Adds the completed receipt to database by calling an EJB business method.
         * If not all required fields are set, a proper exception is being thrown.
         * <p>
         * @return Link outcome
         */
        public String addReceipt () {
                // Are all required fields set?
                if (!this.userLoginController.isUserLoggedIn()) {
                        // Not logged-in
                        throw new IllegalStateException("User is not logged-in"); //NOI18N
                } else if (this.getReceiptBranchOffice() == null) {
                        // Is not set
                        throw new NullPointerException("this.receiptBranchOffice is not set."); //NOI18N
                } else if (this.getReceiptBranchOffice().getBranchId() == null) {
                        // It must be an already peristed instance
                        throw new NullPointerException("this.receiptBranchOffice.businessContactId is not set."); //NOI18N
                } else if (this.getReceiptBranchOffice().getBranchId() < 1) {
                        // It must be an already peristed instance
                        throw new IllegalArgumentException(MessageFormat.format("this.receiptBranchOffice.businessContactId={0} is not valid.", this.getReceiptBranchOffice().getBranchId())); //NOI18N
                } else if (this.getReceiptPaymentType() == null) {
                        // Is not set
                        throw new NullPointerException("this.receiptPaymentType is not set."); //NOI18N
                } else if (this.getReceiptIssued() == null) {
                        // Is not set
                        throw new NullPointerException("this.receiptIssued is not set."); //NOI18N
                }

                // Prepare receipt instance
                final BillableReceipt receipt = this.createReceiptInstance();

                // Is the receipt already there?
                if (this.isReceiptAdded(receipt)) {
                        // Receipt has already been added
                        throw new FaceletException(MessageFormat.format("Receipt for receiptBranchOffice={0},receiptIssued={1},receiptNumber={2} has already been added.", this.getReceiptBranchOffice().getBranchId(), this.getReceiptIssued().toString(), this.getReceiptNumber())); //NOI18N
                }

                // Init variable
                final BillableReceipt updatedReceipt;

                // All is set, then try to call EJB
                try {
                        // Add it
                        updatedReceipt = this.receiptBean.addReceipt(receipt);
                } catch (final ReceiptAlreadyAddedException ex) {
                        // Throw it again
                        throw new FaceletException(ex);
                }

                // Fire event with updated instance
                this.addedReceiptEvent.fire(new ReceiptAddedEvent(updatedReceipt));

                // Return redirect outcome
                return "add_receipt_item?faces-redirect=true"; //NOI18N
        }

        /**
         * Observes events being fired when a new receipt has been added
         * <p>
         * @param event Event being fired
         */
        public void afterAddedReceiptEvent (@Observes final ObservableReceiptAddedEvent event) {
                // Validate parameter
                if (null == event) {
                        // Throw NPE
                        throw new NullPointerException("event is null"); //NOI18N
                } else if (event.getReceipt() == null) {
                        // Throw NPE again
                        throw new NullPointerException("event.receipt is null"); //NOI18N
                } else if (event.getReceipt().getReceiptId() == null) {
                        // Throw it again
                        throw new NullPointerException("event.receipt.receiptId is null"); //NOI18N
                } else if (event.getReceipt().getReceiptId() < 1) {
                        // Throw IAE
                        throw new IllegalArgumentException(MessageFormat.format("event.receipt.receiptId={0} is invalid", event.getReceipt().getReceiptId())); //NOI18N
                }

                // Add to cache and general list
                this.receiptCache.put(event.getReceipt().getReceiptId(), event.getReceipt());
                this.allReceipts.add(event.getReceipt());

                // Is same user?
                if (this.userLoginController.isUserLoggedIn() && Objects.equals(event.getReceipt().getReceiptUser(), this.userLoginController.getLoggedInUser())) {
                        // Same user, then add it
                        this.userReceipts.add(event.getReceipt());
                }
        }

        /**
         * Event observer for logged-in user
         * <p>
         * @param event Event instance
         */
        public void afterUserLoginEvent (@Observes final ObservableUserLoggedInEvent event) {
                // event 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 BillableReceipt receipt : this.allReceipts) {
                        // Is same user?
                        if (Objects.equals(receipt.getReceiptUser(), event.getLoggedInUser())) {
                                // Yes, then add it
                                this.userReceipts.add(receipt);
                        }
                }
        }

        /**
         * Returns all receipts
         * <p>
         * @return All receipts
         */
        @SuppressWarnings ("ReturnOfCollectionOrArrayField")
        public List<BillableReceipt> allReceipts () {
                return this.allReceipts;
        }

        /**
         * Getter for filtered receipts
         * <p>
         * @return Filtered receipts
         */
        @SuppressWarnings ("ReturnOfCollectionOrArrayField")
        public List<BillableReceipt> getFilteredReceipts () {
                return this.filteredReceipts;
        }

        /**
         * Setter for filtered receipts
         * <p>
         * @param filteredReceipts Filtered receipts
         */
        @SuppressWarnings ("AssignmentToCollectionOrArrayFieldFromParameter")
        public void setFilteredReceipts (final List<BillableReceipt> filteredReceipts) {
                this.filteredReceipts = filteredReceipts;
        }

        /**
         * Getter for receipt's bar-code number
         * <p>
         * @return Receipt's bar-code number
         */
        public Long getReceiptBarCodeNumber () {
                return this.receiptBarCodeNumber;
        }

        /**
         * Setter for receipt's bar-code number
         * <p>
         * @param receiptBarCodeNumber Receipt's bar-code number
         */
        public void setReceiptBarCodeNumber (final Long receiptBarCodeNumber) {
                this.receiptBarCodeNumber = receiptBarCodeNumber;
        }

        /**
         * Getter for receipt issuing branch office
         * <p>
         * @return Receipt issuing branch office
         */
        public BranchOffice getReceiptBranchOffice () {
                return this.receiptBranchOffice;
        }

        /**
         * Setter for receipt issuing branch office
         * <p>
         * @param receiptBranchOffice Receipt issuing branch office
         */
        public void setReceiptBranchOffice (final BranchOffice receiptBranchOffice) {
                this.receiptBranchOffice = receiptBranchOffice;
        }

        /**
         * Getter for receipt issue date and time
         * <p>
         * @return Receipt issue date and time
         */
        @SuppressWarnings ("ReturnOfDateField")
        public Date getReceiptIssued () {
                return this.receiptIssued;
        }

        /**
         * Setter for receipt issue date and time
         * <p>
         * @param receiptIssued Receipt issue date and time
         */
        @SuppressWarnings ("AssignmentToDateFieldFromParameter")
        public void setReceiptIssued (final Date receiptIssued) {
                this.receiptIssued = receiptIssued;
        }

        /**
         * Getter for receipt number
         * <p>
         * @return Receipt number
         */
        public Long getReceiptNumber () {
                return this.receiptNumber;
        }

        /**
         * Setter for receipt number
         * <p>
         * @param receiptNumber Receipt number
         */
        public void setReceiptNumber (final Long receiptNumber) {
                this.receiptNumber = receiptNumber;
        }

        /**
         * Getter for payment type
         * <p>
         * @return Payment type
         */
        public PaymentType getReceiptPaymentType () {
                return this.receiptPaymentType;
        }

        /**
         * Setter for payment type
         * <p>
         * @param receiptPaymentType Payment type
         */
        public void setReceiptPaymentType (final PaymentType receiptPaymentType) {
                this.receiptPaymentType = receiptPaymentType;
        }

        /**
         * Getter for receipt register's number
         * <p>
         * @return Receipt register's number
         */
        public Long getReceiptRegisterNumber () {
                return this.receiptRegisterNumber;
        }

        /**
         * Setter for receipt register's number
         * <p>
         * @param receiptRegisterNumber Receipt register's number
         */
        public void setReceiptRegisterNumber (final Long receiptRegisterNumber) {
                this.receiptRegisterNumber = receiptRegisterNumber;
        }

        /**
         * Getter for receipt seller employee
         * <p>
         * @return Receipt seller employee
         */
        public Employee getReceiptSellerEmployee () {
                return this.receiptSellerEmployee;
        }

        /**
         * Setter for receipt seller employee
         * <p>
         * @param receiptSellerEmployee Receipt seller employee
         */
        public void setReceiptSellerEmployee (final Employee receiptSellerEmployee) {
                this.receiptSellerEmployee = receiptSellerEmployee;
        }

        @PostConstruct
        public void initCache () {
                // Is cache there?
                if (!this.receiptCache.iterator().hasNext()) {
                        // Get whole list
                        final List<BillableReceipt> list = this.receiptBean.allReceipts();

                        // Add all
                        for (final Iterator<BillableReceipt> iterator = list.iterator(); iterator.hasNext();) {
                                // Get next element
                                final BillableReceipt next = iterator.next();

                                // Add it to cache
                                this.receiptCache.put(next.getReceiptId(), next);
                        }
                }

                // Is the list empty, but filled cache?
                if (this.allReceipts.isEmpty() && this.receiptCache.iterator().hasNext()) {
                        // Get iterator
                        final Iterator<Cache.Entry<Long, BillableReceipt>> iterator = this.receiptCache.iterator();

                        // Build up list
                        while (iterator.hasNext()) {
                                // GEt next element
                                final Cache.Entry<Long, BillableReceipt> next = iterator.next();

                                // Add to list
                                this.allReceipts.add(next.getValue());
                        }

                        // Sort list
                        this.allReceipts.sort(new Comparator<BillableReceipt>() {
                                @Override
                                public int compare (final BillableReceipt o1, final BillableReceipt o2) {
                                        return o1.getReceiptId() > o2.getReceiptId() ? 1 : o1.getReceiptId() < o2.getReceiptId() ? -1 : 0;
                                }
                        }
                        );
                }
        }

        @Override
        public boolean isReceiptAdded (final BillableReceipt receipt) {
                // Always trust the cache
                return this.allReceipts.contains(receipt);
        }

        /**
         * Returns a fully created receipt instance (except primary key, of course)
         * <p>
         * @return Receipt instance
         */
        private BillableReceipt createReceiptInstance () {
                // Init receipt instance
                final BillableReceipt receipt = new FinancialReceipt(this.getReceiptPaymentType(), this.getReceiptBranchOffice(), this.userLoginController.getLoggedInUser(), this.getReceiptIssued());

                // Set optional fields
                receipt.setReceiptNumber(this.getReceiptNumber());
                receipt.setReceiptBarCodeNumber(this.getReceiptBarCodeNumber());
                receipt.setReceiptRegisterNumber(this.getReceiptRegisterNumber());
                receipt.setReceiptSellerEmployee(this.getReceiptSellerEmployee());

                // Return it
                return receipt;
        }
}