it.archiworld.addressbook.AddressbookBean.java Source code

Java tutorial

Introduction

Here is the source code for it.archiworld.addressbook.AddressbookBean.java

Source

/*******************************************************************************
 * Copyright (C) 2008  CS-Computer.
 * 
 * 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/>.
 * 
 * Contributors:
 *     CS-Computer - initial API and implementation
 ******************************************************************************/
package it.archiworld.addressbook;

import it.archiworld.common.Address;
import it.archiworld.common.Company;
import it.archiworld.common.Member;
import it.archiworld.common.Person;
import it.archiworld.common.ServiceMember;
import it.archiworld.common.protocol.Inentry;
import it.archiworld.common.protocol.Outentry;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Order;
import org.jboss.ejb3.entity.HibernateSession;

@Stateless
//@SecurityDomain("other")
public class AddressbookBean implements Addressbook {

    @PersistenceContext
    private EntityManager manager;

    public final void removeAddress(final Address address) throws Throwable {
        try {
            Address reattachedAddress = manager.merge(address);
            manager.remove(reattachedAddress);
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    public final Address saveAddress(final Address address) throws Throwable {
        if (address instanceof Member) {
            if (((Member) address).getRegistration_number() == null) {
                Query query = manager.createNativeQuery("Select max(registration_number) from t_entity");
                Integer registration_number = (Integer) query.getSingleResult();
                if (registration_number == null)
                    registration_number = 0;
                ((Member) address).setRegistration_number(registration_number + 1);
            }
            ((Member) address).setLast_change_date(new Timestamp(System.currentTimeMillis()));
        }
        if (address instanceof ServiceMember) {
            System.out.println("Saving Servicemember");
            if (((ServiceMember) address).getServicemember_number() == null) {
                Query query = manager.createNativeQuery("Select max(servicemember_number) from t_entity");
                Integer servicemember_number = (Integer) query.getSingleResult();
                System.out.println(servicemember_number);
                if (servicemember_number == null)
                    servicemember_number = 0;
                ((ServiceMember) address).setServicemember_number(servicemember_number + 1);
            }
        }

        try {
            return manager.merge(address);
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    @SuppressWarnings({ "unchecked" })
    public final List<Address> getAddresslist() throws Throwable {
        try {
            Query query = manager.createQuery("Select address from Address as address");
            return query.getResultList();
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }

    }

    @SuppressWarnings({ "unchecked" })
    public final List<Company> searchCompanyList(final String pattern) throws Throwable {
        try {
            long time = System.currentTimeMillis();
            Query query = manager.createQuery(
                    "Select new Company(address.entity_id, address.denomination) from Company as address where upper(address.denomination) like upper(?) order by address.denomination")
                    .setParameter(1, pattern);
            List<Company> result = query.getResultList();
            System.out.println("Company: " + (time - System.currentTimeMillis()));
            return result;
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    @SuppressWarnings({ "unchecked" })
    public final List<ServiceMember> searchServiceMemberList(String pattern) throws Throwable {
        try {
            long time = System.currentTimeMillis();
            Query query = manager.createQuery(
                    "Select new ServiceMember(address.entity_id, address.firstname, address.lastname, address.servicemember_number) from ServiceMember as address where (upper(address.firstname) like upper(?) OR upper(address.lastname) like upper(?)) and address.class = ServiceMember order by address.lastname")
                    .setParameter(1, pattern).setParameter(2, pattern);

            List<ServiceMember> result = query.getResultList();
            System.out.println("ServiceMember: " + (time - System.currentTimeMillis()));
            return result;
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    @SuppressWarnings({ "unchecked" })
    public final List<Member> searchMemberList(final String pattern) throws Throwable {
        try {
            long time = System.currentTimeMillis();
            Query query = manager.createQuery(
                    "Select new List(address.entity_id, address.firstname, address.lastname, address.gender, address.registration_number) from Member as address where (upper(address.firstname) like upper(?) or upper(address.lastname) like upper(?)) and address.deregister_date is null order by address.lastname")
                    .setParameter(1, pattern).setParameter(2, pattern);

            List<Member> result = query.getResultList();
            List<Member> data = new ArrayList<Member>();
            for (int i = 0; i < result.size(); i++) {
                Member member = new Member((Long) ((List) result.get(i)).get(0),
                        (String) ((List) result.get(i)).get(1), (String) ((List) result.get(i)).get(2),
                        (String) ((List) result.get(i)).get(3), (Integer) ((List) result.get(i)).get(4));
                data.add(member);
            }
            System.out.println("Member: " + (time - System.currentTimeMillis()));
            return data;
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    @SuppressWarnings({ "unchecked" })
    public final List<Member> searchDeletedMemberList(final String pattern) throws Throwable {
        try {
            long time = System.currentTimeMillis();
            Query query = manager.createQuery(
                    "Select new List(address.entity_id, address.firstname, address.lastname, address.gender, address.registration_number) from Member as address where (upper(address.firstname) like upper(?) or upper(address.lastname) like upper(?)) and address.deregister_date is not null order by address.lastname")
                    .setParameter(1, pattern).setParameter(2, pattern);
            List<Member> result = query.getResultList();
            List<Member> data = new ArrayList<Member>();
            for (int i = 0; i < result.size(); i++) {
                Member member = new Member((Long) ((List) result.get(i)).get(0),
                        (String) ((List) result.get(i)).get(1), (String) ((List) result.get(i)).get(2),
                        (String) ((List) result.get(i)).get(3), (Integer) ((List) result.get(i)).get(4));
                data.add(member);
            }
            System.out.println("Deleted Member: " + (time - System.currentTimeMillis()));

            return data;
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    @SuppressWarnings({ "unchecked" })
    public final List<Person> searchPersonList(String pattern) throws Throwable {
        try {
            long time = System.currentTimeMillis();
            Query query = manager.createQuery(
                    "Select new Person(address.entity_id, address.firstname, address.lastname) from Person as address where (upper(address.firstname) like upper(?) OR upper(address.lastname) like upper(?)) and address.class = Person order by address.lastname")
                    .setParameter(1, pattern).setParameter(2, pattern);
            List<Person> result = query.getResultList();
            System.out.println("Person: " + (time - System.currentTimeMillis()));
            return result;
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    public Address getAddress(Address address) throws Throwable {
        if (address == null || address.getEntity_id() == null)
            return null;
        try {
            System.out.println("Fetching Address");
            Query query = manager.createQuery("Select address from Address as address where address = ?")
                    .setParameter(1, address);
            return (Address) query.getSingleResult();
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    @SuppressWarnings({ "unchecked" })
    public List<Address> searchAddress(Address address) throws Throwable {
        Session session = ((HibernateSession) manager).getHibernateSession();
        Example example = Example.create(address);
        example.ignoreCase();
        example.excludeZeroes();
        example.enableLike();
        if (address instanceof Member)
            return session.createCriteria(Member.class).add(example).addOrder(Order.asc("lastname"))
                    .setFetchMode("renewal", FetchMode.SELECT).setFetchMode("specializations", FetchMode.SELECT)
                    .setFetchMode("formations", FetchMode.SELECT).setFetchMode("committeemembers", FetchMode.SELECT)
                    .list();
        if (address instanceof Person) {
            List<Address> result = session.createCriteria(Person.class).add(example).addOrder(Order.asc("lastname"))
                    .list();
            List<Address> result2 = new ArrayList<Address>();
            for (int i = 0; i < result.size(); i++)
                if (!(result.get(i) instanceof Member) && !(result.get(i) instanceof ServiceMember))
                    result2.add(result.get(i));
            return result2;
        }
        if (address instanceof Company) {
            return session.createCriteria(Company.class).add(example).addOrder(Order.asc("denomination")).list();
        }
        return new ArrayList<Address>();
    }

    @SuppressWarnings({ "unchecked" })
    public List<Address> searchAddress(Class entityClass, Criterion criterion, List<Order> orders)
            throws Throwable {
        Session session = ((HibernateSession) manager).getHibernateSession();
        Criteria criteria = session.createCriteria(entityClass);
        if (orders.size() > 0) {
            criteria.setMaxResults(1);
            Iterator<Order> ordIt = orders.iterator();
            while (ordIt.hasNext() == true) {
                criteria.addOrder(ordIt.next());
            }
        } else {
            criteria.addOrder(Order.asc("lastname"));
        }

        criteria.add(criterion).setFetchMode("renewal", FetchMode.SELECT)
                .setFetchMode("specializations", FetchMode.SELECT).setFetchMode("formations", FetchMode.SELECT)
                .setFetchMode("committeemembers", FetchMode.SELECT);
        return criteria.list();
    }

    @SuppressWarnings("unchecked")
    public Member savePersonAsMember(Person person) throws Throwable {
        try {
            Query query = manager
                    .createQuery("Select inentry from Inentry as inentry where inentry.sender.address=?")
                    .setParameter(1, person);
            List<Inentry> inentries = query.getResultList();
            query = manager.createQuery(
                    "Select outentry from Outentry outentry, IN (outentry.destinations) dest where dest.address=?")
                    .setParameter(1, person);
            List<Outentry> outentries = query.getResultList();
            Member member = new Member(person);

            if (member.getRegistration_number() == null) {
                query = manager.createNativeQuery("Select max(registration_number) from t_entity");
                Integer registration_number = (Integer) query.getSingleResult();
                if (registration_number == null)
                    registration_number = 0;
                member.setRegistration_number(registration_number + 1);
            }
            member.setLast_change_date(new Timestamp(System.currentTimeMillis()));

            member = manager.merge(member);
            for (Inentry entry : inentries) {
                if (entry.getSender().getAddress().equals(person)) {
                    entry.getSender().setAddress(member);

                }
                entry = manager.merge(entry);
            }
            for (Outentry entry : outentries)
                for (int i = 0; i < entry.getDestinations().size(); i++) {
                    if (entry.getDestinations().get(i).getAddress().equals(person)) {
                        entry.getDestinations().get(i).setAddress(member);
                    }
                    entry = manager.merge(entry);
                    System.out.println("********************************************");
                }

            person = manager.merge(person);
            manager.remove(person);
            return member;
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

    @SuppressWarnings("unchecked")
    public ServiceMember savePersonAsServiceMember(Person person) throws Throwable {
        try {
            Query query = manager
                    .createQuery("Select inentry from Inentry as inentry where inentry.sender.address=?")
                    .setParameter(1, person);
            List<Inentry> inentries = query.getResultList();
            query = manager.createQuery(
                    "Select outentry from Outentry outentry, IN (outentry.destinations) dest where dest.address=?")
                    .setParameter(1, person);
            List<Outentry> outentries = query.getResultList();
            ServiceMember member = new ServiceMember(person);
            if (member.getServicemember_number() == null) {
                query = manager.createNativeQuery("Select max(servicemember_number) from t_entity");
                Integer servicemember_number = (Integer) query.getSingleResult();
                System.out.println(servicemember_number);
                if (servicemember_number == null)
                    servicemember_number = 0;
                member.setServicemember_number(servicemember_number + 1);
            }

            member = manager.merge(member);
            for (Inentry entry : inentries) {
                if (entry.getSender().getAddress().equals(person)) {
                    entry.getSender().setAddress(member);
                }
                entry = manager.merge(entry);
            }
            for (Outentry entry : outentries)
                for (int i = 0; i < entry.getDestinations().size(); i++) {
                    if (entry.getDestinations().get(i).getAddress().equals(person)) {
                        entry.getDestinations().get(i).setAddress(member);
                    }
                    entry = manager.merge(entry);
                }

            person = manager.merge(person);
            manager.remove(person);
            return member;
        } catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
    }

}