Unnamed

package org.opennms.web.svclayer.outage;

import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.extremecomponents.table.context.Context;
import org.extremecomponents.table.context.HttpServletRequestContext;
import org.extremecomponents.table.limit.Limit;
import org.extremecomponents.table.limit.LimitFactory;
import org.extremecomponents.table.limit.TableLimit;
import org.extremecomponents.table.limit.TableLimitFactory;
import org.opennms.netmgt.model.OnmsIpInterface;
import org.opennms.netmgt.model.OnmsMonitoredService;
import org.opennms.netmgt.model.OnmsOutage;
import org.opennms.netmgt.model.OnmsServiceType;

public class CurrentOutagesBuilder {

    Collection<OnmsOutage> foundOutages;

    Collection<OnmsOutage> viewOutages;

    SuppressOutages m_suppress = new SuppressOutages();

    private OutageListService m_cview = new OutageListBuilder();

    private static final int ROW_LIMIT = 25;

    OutageService m_outageService;

    public void setOutageService(OutageService service) {
        m_outageService = service;
    }

    public Map<String, Object> getOutages(HttpServletRequest request) {

        Context context = new HttpServletRequestContext(request);
        LimitFactory limitFactory = new TableLimitFactory(context,
                                                          "tabledata");
        Limit limit = new TableLimit(limitFactory);

        CurrentOutageParseResponse.findSelectedOutagesIDs(request,
                                                          m_outageService);

        Map<String, Object> myModel = new HashMap<String, Object>();
        Integer totalRows = m_outageService.getCurrentOutageCount();

        myModel.put("request", limit.toString());

        myModel.put("all_params", request.getParameterNames().toString());
        if (limit.getPage() == 1) {
            // no offset set
            myModel.put("rowStart", 0);
            context.setRequestAttribute("rowStart", 0);
            context.setRequestAttribute("rowEnd", ROW_LIMIT);
            myModel.put("rowEnd", ROW_LIMIT);

            if (limit.getSort().getProperty() == null) {
                foundOutages = m_outageService.getCurrentOutagesByRange(
                                                                        1,
                                                                        ROW_LIMIT,
                                                                        "id",
                                                                        "asc");

            } else {
                foundOutages = m_outageService.getCurrentOutagesByRange(
                                                                        0,
                                                                        ROW_LIMIT,
                                                                        "id",
                                                                        "asc");
                // "outages.nodeid,outages."
                // + limit.getSort().getProperty(),
                // limit.getSort().getSortOrder());

            }
            myModel.put("begin", 0);
            myModel.put("end", ROW_LIMIT);

        } else {

            Integer rowstart = null;
            Integer rowend = null;

            // quirky situation... - as we started on 0 (zero)
            rowstart = ((limit.getPage() * ROW_LIMIT + 1) - ROW_LIMIT);
            rowend = (ROW_LIMIT);
            myModel.put("begin", rowstart);
            myModel.put("end", rowend);

            if (limit.getSort().getProperty() == null) {
                foundOutages = m_outageService.getCurrentOutagesByRange(
                                                                        rowstart,
                                                                        rowend,
                                                                        "id",
                                                                        "asc");

            } else {

                foundOutages = m_outageService.getCurrentOutagesByRange(
                                                                        rowstart,
                                                                        rowend,
                                                                        "id",
                                                                        "asc");
                // "outages.nodeid,outages."
                // "id"
                // + limit.getSort().getProperty()
                // + " ",
                // limit.getSort().getSortOrder());

            }
        }

        // Pretty smart to build the collection after any suppressions.....
        // Collection theTable = m_cview.theTable(foundOutages);

        List theTable = new LinkedList();
        Locale locale = Locale.getDefault();
        SimpleDateFormat formatter = new SimpleDateFormat(
                                                          "dd/MM/yyyy HH:mm:ss",
                                                          locale);

        for (Iterator iter = foundOutages.iterator(); iter.hasNext();) {
            OnmsOutage outage = (OnmsOutage) iter.next();
            OnmsMonitoredService monitoredService = outage.getMonitoredService();
            OnmsServiceType serviceType = monitoredService.getServiceType();
            OnmsIpInterface ipInterface = monitoredService.getIpInterface();

            // ips.put(outage.getId(), ipInterface.getIpAddress());
            // nodes.put(outage.getId(), ipInterface.getNode().getLabel());
            // nodeids.put(outage.getId(), monitoredService.getNodeId());
            // services.put(outage.getId(), serviceType.getName());

            Map outagerow = new HashMap();
            outagerow.put("outageid", (String) outage.getId().toString());
            outagerow.put("node", ipInterface.getNode().getLabel());
            outagerow.put("nodeid",
                          (String) monitoredService.getNodeId().toString());
            outagerow.put("ipaddr", ipInterface.getIpAddress());
            outagerow.put("interfaceid", ipInterface.getId());
            outagerow.put("service", serviceType.getName());
            outagerow.put("serviceid", serviceType.getId());
            outagerow.put("eventid", outage.getServiceLostEvent().getId());

            // if (outage.getIfLostService() != null) {
            // outagerow.put("down",
            // formatter.format(outage.getIfLostService()));
            // }

            if (outage.getIfLostService() != null) {
                outagerow.put("iflostservice",
                              formatter.format(outage.getIfLostService()));

                // Long format for searches

                outagerow.put("iflostservicelong",
                              (Long) outage.getIfLostService().getTime());

                // Format the date-output.

            }

            if (outage.getIfRegainedService() != null) {
                outagerow.put("ifregainedservice",
                              formatter.format(outage.getIfRegainedService()));

                outagerow.put("ifregainedservicelong",
                              (Long) outage.getIfRegainedService().getTime());
            }

            if (outage.getSuppressTime() != null) {
                outagerow.put("suppresstime", outage.getSuppressTime());
            }

            outagerow.put("suppressedby", outage.getSuppressedBy());

            // Build a droplist for this outage

            theTable.add(outagerow);
        }

        myModel.put("tabledata", theTable);
        myModel.put("totalRows", totalRows);

        myModel.put(
                    "selected_outages",
                    CurrentOutageParseResponse.findSelectedOutagesIDs(
                                                                      request,
                                                                      m_outageService));

        return myModel;

    }
}