Source code

001/*
002 * This file is part of McIDAS-V
003 *
004 * Copyright 2007-2015
005 * Space Science and Engineering Center (SSEC)
006 * University of Wisconsin - Madison
007 * 1225 W. Dayton Street, Madison, WI 53706, USA
008 * https://www.ssec.wisc.edu/mcidas
009 * 
010 * All Rights Reserved
011 * 
012 * McIDAS-V is built on Unidata's IDV and SSEC's VisAD libraries, and
013 * some McIDAS-V source code is based on IDV and VisAD source code.  
014 * 
015 * McIDAS-V is free software; you can redistribute it and/or modify
016 * it under the terms of the GNU Lesser Public License as published by
017 * the Free Software Foundation; either version 3 of the License, or
018 * (at your option) any later version.
019 * 
020 * McIDAS-V is distributed in the hope that it will be useful,
021 * but WITHOUT ANY WARRANTY; without even the implied warranty of
022 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
023 * GNU Lesser Public License for more details.
024 * 
025 * You should have received a copy of the GNU Lesser Public License
026 * along with this program.  If not, see http://www.gnu.org/licenses.
027 */
028
029package edu.wisc.ssec.mcidasv.chooser;
030
031
032import edu.wisc.ssec.mcidasv.*;
033
034import java.util.ArrayList;
035import java.util.List;
036
037import org.w3c.dom.Document;
038import org.w3c.dom.Element;
039import org.w3c.dom.NodeList;
040
041import ucar.unidata.idv.IntegratedDataViewer;
042import ucar.unidata.idv.IdvResourceManager;
043
044import ucar.unidata.idv.chooser.adde.AddeServer;
045
046import ucar.unidata.xml.XmlResourceCollection;
047import ucar.unidata.xml.XmlUtil;
048
049
050/**
051 * Class ServerInfo Holds has methods for accessing
052 * the contents of servers.xml
053 */
054public class ServerInfo {
055
056    private IntegratedDataViewer myIdv;
057
058    /** tags */
059    public static final String TAG_SERVER = "server";
060    public static final String TAG_SERVERS = "servers";
061    public static final String TAG_GROUP = "group";
062
063    /** attributes */
064    public static final String ATTR_ACTIVE = "active";
065    public static final String ATTR_NAME = "name";
066    public static final String ATTR_NAMES = "names";
067    public static final String ATTR_USER = "user";
068    public static final String ATTR_PROJ = "proj";
069    public static final String ATTR_TYPE = "type";
070
071    private XmlResourceCollection serversXRC;
072    private Document serversDocument;
073    private Element serversRoot;
074
075    private static String user = "idv";
076    private static String proj = "0";
077
078    private List typeList = new ArrayList();
079    private List groups = new ArrayList();
080
081    private List serverDescriptors = new ArrayList();
082
083    private String[] defTypes = {"image", "point", "grid", "text", "nav"};
084
085    /**
086     * Constructor
087     */
088    public ServerInfo(IntegratedDataViewer idv, XmlResourceCollection servers) {
089        myIdv = idv;
090        serversXRC = servers;
091
092        if (serversXRC.hasWritableResource()) {
093            serversDocument = 
094                serversXRC.getWritableDocument("<servers></servers>");
095            serversRoot =
096                serversXRC.getWritableRoot("<servers></servers>");
097            String tagName = serversRoot.getTagName();
098        }
099        getServersFromXml(serversXRC);
100    }
101
102
103    /**
104     * getServersFromXml
105     *  Read and parse servers.xml
106     *
107     *  fill lists:
108     *    typeList - type name Strings
109     */
110    private void getServersFromXml(XmlResourceCollection servers) {
111        servers.clearCache();
112        serverDescriptors.clear();
113        if (serversXRC.hasWritableResource()) {
114            serversDocument =
115                serversXRC.getWritableDocument("<tabs></tabs>");
116            serversRoot =
117                serversXRC.getWritableRoot("<tabs></tabs>");
118            try {
119                Element root = serversRoot;
120                if (root == null) return;
121//                if ((user.equals("")) && (proj.equals(""))) {
122                    if (serversRoot.hasAttribute(ATTR_USER))
123                        user = serversRoot.getAttribute(ATTR_USER);
124                    if (serversRoot.hasAttribute(ATTR_PROJ))
125                        proj = serversRoot.getAttribute(ATTR_PROJ);
126//                }
127                List serverElements = XmlUtil.getElements(root, TAG_SERVER);
128                for (int serverIdx = 0; serverIdx < serverElements.size(); serverIdx++) {
129                    Element serverElement = (Element) serverElements.get(serverIdx);
130                    String nameServer = XmlUtil.getAttribute(serverElement, ATTR_NAME);
131                    String activeServer = XmlUtil.getAttribute(serverElement, ATTR_ACTIVE);
132                    List groupElements = XmlUtil.getElements(serverElement, TAG_GROUP);
133                    for (int groupIdx = 0; groupIdx < groupElements.size(); groupIdx++) {
134                        Element groupElement = (Element) groupElements.get(groupIdx);
135                        String activeGroup = XmlUtil.getAttribute(groupElement, ATTR_ACTIVE);
136                        String nameGroup = XmlUtil.getAttribute(groupElement, ATTR_NAMES);
137                        String type = XmlUtil.getAttribute(groupElement, ATTR_TYPE);
138                        if (!typeList.contains(type)) {
139                            typeList.add(type);
140                        }
141                        ServerDescriptor sd =
142                            new ServerDescriptor(type, nameServer, nameGroup, activeGroup);
143                            serverDescriptors.add(sd);
144                    }
145                }
146            } catch (Exception e) {
147                System.out.println("getServersFromXml e=" + e);
148            }
149        }
150        return;
151    }
152
153    /**
154     * getUser
155     *   return userId, default="idv"
156     */
157    public String getUser() {
158        return user;
159    }
160
161    /**
162     * getProj
163     *   return project number, default="0"
164     */
165    public String getProj() {
166        return proj;
167    }
168
169    public void setUserProj(String user, String proj) {
170        Element serverRoot = serversXRC.getWritableRoot("<tabs></tabs>");
171        Document serverDocument = serversXRC.getWritableDocument("<tabs></tabs>");
172        try {
173            serverRoot.setAttribute(ATTR_USER, user);
174            serverRoot.setAttribute(ATTR_PROJ, proj);
175            serversXRC.setWritableDocument(serverDocument, serverRoot);
176            serversXRC.writeWritable();
177        } catch (Exception e) {
178            System.out.println("updateXml AddeServer.toXml e=" + e);
179        }
180    }
181
182    /**
183     * getServerTypes
184     *    return List of type Strings
185     */
186    public List getServerTypes() {
187        for (int i=0; i<defTypes.length; i++) {
188            if (!typeList.contains(defTypes[i])) typeList.add(defTypes[i]);
189        }
190        return typeList;
191    }
192
193    /**
194     * getServers
195     *    input: type = data type
196     *           all = boolean flag
197     *           includeDuplicates = boolean flag
198     *    return List of ServerDescriptors
199     */
200    public List getServers(String type, boolean all, boolean includeDuplicates) {
201        init();
202        List servers = new ArrayList();
203        List sds = new ArrayList();
204        groups = new ArrayList();
205        for (int i=0; i<serverDescriptors.size(); i++) {
206            ServerDescriptor sd = (ServerDescriptor)serverDescriptors.get(i);
207            if (sd.isDataType(type)) {
208                String name = sd.getServerName();
209                if (!all) {
210                    if (!sd.getIsActive()) continue;
211                    if (!includeDuplicates) {
212                        if (servers.contains(name)) continue;
213                    }
214                }
215                servers.add(name);
216                sds.add(sd);
217                groups.add(sd.getGroupName());
218            }
219        }
220        return sds;
221    }
222
223    /**
224     * getServerNames
225     *    input: type = data type
226     *           all = boolean flag
227     *           includeDuplicates = boolean flag
228     *    return List of server name strings
229     */
230     public List getServerNames(String type, boolean all, boolean includeDuplicates) {
231        if (serverDescriptors == null) init();
232        List servers = new ArrayList();
233        if (typeList.contains(type)) {
234            for (int i=0; i<serverDescriptors.size(); i++) {
235                ServerDescriptor sd = (ServerDescriptor)serverDescriptors.get(i);
236                if (sd.isDataType(type)) {
237                    String name = sd.getServerName();
238                    if (!all) {
239                        if (!sd.getIsActive()) continue;
240                        if (!includeDuplicates) {
241                            if (servers.contains(name)) continue;
242                        }
243                    }
244                    servers.add(name);
245                }
246            }
247        }
248        return servers;
249     }
250
251    /**
252     * getAddeServers
253     *    input: type = data type
254     *           all = boolean flag
255     *           includeDuplicates = boolean flag
256     *    return List of server name strings
257     */
258     public List getAddeServers(String type, boolean all, boolean includeDuplicates) {
259        if (serverDescriptors == null) init();
260        List servers = new ArrayList();
261        List names = new ArrayList();
262        if (typeList.contains(type)) {
263            for (int i=0; i<serverDescriptors.size(); i++) {
264                ServerDescriptor sd = (ServerDescriptor)serverDescriptors.get(i);
265                if (sd.isDataType(type)) {
266                    String name = sd.getServerName();
267                    if (!all) {
268                        if (!sd.getIsActive()) continue;
269                    }
270                    if (!includeDuplicates) {
271                        if (names.contains(name)) continue;
272                    }
273                    AddeServer as = new AddeServer(sd.getServerName());
274                    AddeServer.Group g = new AddeServer.Group(sd.getDataType(), sd.getGroupName(), "");
275                    g.setActive(sd.getIsActive());
276                    as.addGroup(g);
277                    servers.add(as);
278                    names.add(as.getName());
279                }
280            }
281        }
282        return servers;
283     }
284
285    /**
286     * updateAddeServers(String type, boolean all, boolean includeDuplicates) {
287     *    input: type = data type
288     *           all = boolean flag
289     *           includeDuplicates = boolean flag
290     *    return List of server name strings
291     */
292     public List updateAddeServers(String type, boolean all, boolean includeDuplicates) {
293         init();
294         return getAddeServers(type, all, includeDuplicates);
295     }
296
297    /**
298     * init
299     *    read servers.xml and initialize all Lists
300     */
301    private boolean init() {
302       serversXRC =
303           myIdv.getResourceManager().getXmlResources(
304           IdvResourceManager.RSC_ADDESERVER);
305       getServersFromXml(serversXRC);
306       if (serverDescriptors == null) return false;
307       return true;
308    }
309
310    /**
311     * getGroups - return all groups for a given data type
312     *    return List of group name Strings
313     */
314    public List getGroups(String type) {
315        init();
316        getServers(type, false, true);
317        return groups;
318    }
319
320
321    /**
322     * addServers to servers.xml
323     *   input: type = data type
324     *          serverList = alternating strings: name1, group1, name2, group2, etc.
325     */
326    public void addServers(IntegratedDataViewer idv, List serverList) {
327        int num = serverList.size();
328        List addeServers = new ArrayList();
329        if (num > 0) {
330            try {
331                for (int i=0; i<num; i++) {
332                    ServerDescriptor sd = (ServerDescriptor) serverList.get(i);
333                    String servName = sd.getServerName();
334                    AddeServer as = new AddeServer(sd.getServerName());
335                    AddeServer.Group g = new AddeServer.Group(sd.getDataType(), sd.getGroupName(), "");
336                    g.setActive(sd.getIsActive());
337                    as.addGroup(g);
338                    addeServers.add(as);
339                }
340            } catch (Exception e) {
341                System.out.println("addServers e=" + e);
342            };
343        }
344        List serversFinal = AddeServer.coalesce(addeServers);
345
346        XmlResourceCollection serverCollection =
347           idv.getResourceManager().getXmlResources(
348           IdvResourceManager.RSC_ADDESERVER);
349        Element serverRoot = serverCollection.getWritableRoot("<tabs></tabs>");
350        Document serverDocument = serverCollection.getWritableDocument("<tabs></tabs>");
351        try {
352            Element serversEle = AddeServer.toXml(serversFinal, false);
353            serverCollection.setWritableDocument(serverDocument, serversEle);
354            serverCollection.writeWritable();
355        } catch (Exception e) {
356            System.out.println("AddeServer.toXml e=" + e);
357        }
358    }
359
360    /**
361     * Clear servers.xml
362     */
363    public void clear(XmlResourceCollection serversXRC) {
364        List typeElements = XmlUtil.getElements(serversRoot, TAG_SERVER);
365        for (int typeIdx = 0; typeIdx < typeElements.size(); typeIdx++) {
366            Element typeElement = (Element) typeElements.get(typeIdx);
367            XmlUtil.removeChildren(typeElement);
368        }
369        try {
370            serversXRC.writeWritable();
371        } catch (Exception e) {
372        }
373        serversXRC.setWritableDocument(serversDocument, serversRoot);
374    }
375}