| 23 |
23 |
*/
|
| 24 |
24 |
package org.gvsig.andami.persistence.serverData;
|
| 25 |
25 |
|
| 26 |
|
import java.util.Date;
|
| 27 |
|
import java.util.Iterator;
|
| 28 |
|
import java.util.Properties;
|
| 29 |
|
import java.util.Set;
|
|
26 |
import java.util.ArrayList;
|
|
27 |
import java.util.Arrays;
|
|
28 |
import java.util.List;
|
| 30 |
29 |
|
| 31 |
|
import org.gvsig.andami.PluginServices;
|
| 32 |
|
import org.gvsig.utils.DateTime;
|
| 33 |
|
import org.gvsig.utils.NotExistInXMLEntity;
|
| 34 |
|
import org.gvsig.utils.XMLEntity;
|
|
30 |
import org.gvsig.tools.ToolsLocator;
|
|
31 |
import org.gvsig.tools.dynobject.DynStruct;
|
|
32 |
import org.gvsig.tools.persistence.PersistenceManager;
|
|
33 |
import org.gvsig.tools.persistence.Persistent;
|
|
34 |
import org.gvsig.tools.persistence.PersistentState;
|
|
35 |
import org.gvsig.tools.persistence.exception.PersistenceException;
|
| 35 |
36 |
import org.gvsig.utils.swing.jcomboServer.ServerData;
|
| 36 |
37 |
|
| 37 |
38 |
|
| ... | ... | |
| 45 |
46 |
* @see es.gva.cit.catalogClient.utils.comboserver.ServerData
|
| 46 |
47 |
* @author Jorge Piera Llodra (piera_jor@gva.es)
|
| 47 |
48 |
*/
|
| 48 |
|
public class ServerDataPersistence {
|
| 49 |
|
private XMLEntity xml = null;
|
| 50 |
|
private PluginServices ps = null;
|
| 51 |
|
private String serviceType = null;
|
| 52 |
|
private static final String SERVER_URL = "serverURL";
|
| 53 |
|
private static final String SERVER_ADDED = "added";
|
| 54 |
|
private static final String SERVER_LASTACCESS = "lastAccess";
|
| 55 |
|
private static final String SERVER_TYPE = "type";
|
| 56 |
|
private static final String SERVER_SUBTYPE = "subType";
|
| 57 |
|
private static final String SERVER_DATABASE = "database";
|
|
49 |
public class ServerDataPersistence implements Persistent, Comparable<ServerDataPersistence> {
|
|
50 |
public static final String PERSISTENT_NAME = "ServerDataList_Persistent";
|
|
51 |
public static final String PERSISTENT_DESCRIPTION = "ServerDataList Persistent";
|
|
52 |
|
|
53 |
private String serviceType = null;
|
|
54 |
private List<ServerData> serverList = null;
|
| 58 |
55 |
|
| 59 |
56 |
/**
|
| 60 |
57 |
* Constructor
|
| ... | ... | |
| 63 |
60 |
* @param sevice Type
|
| 64 |
61 |
* Service type to load
|
| 65 |
62 |
*/
|
| 66 |
|
public ServerDataPersistence(Object pluginClassInstance,String serviceType){
|
| 67 |
|
ps = PluginServices.getPluginServices(pluginClassInstance);
|
| 68 |
|
xml = ps.getPersistentXML();
|
|
63 |
public ServerDataPersistence(String serviceType) {
|
| 69 |
64 |
this.serviceType = serviceType;
|
|
65 |
serverList = new ArrayList<ServerData>();
|
| 70 |
66 |
}
|
| 71 |
|
|
| 72 |
|
/**
|
| 73 |
|
* This methos is used to save the information in an XML file
|
| 74 |
|
*/
|
| 75 |
|
public void setPersistent(){
|
| 76 |
|
ps.setPersistentXML(xml);
|
|
67 |
|
|
68 |
public ServerDataPersistence() {
|
| 77 |
69 |
}
|
| 78 |
70 |
|
| 79 |
71 |
/**
|
| 80 |
|
* This method saves an array of ServerData using the Anadami
|
| 81 |
|
* persistence model
|
| 82 |
|
* @param servers
|
| 83 |
|
* Array of servers
|
| 84 |
|
*/
|
| 85 |
|
public void setArrayOfServerData(ServerData[] servers){
|
| 86 |
|
xml.getXmlTag().removeAllXmlTag();
|
| 87 |
|
|
| 88 |
|
for (int i=0 ; i<servers.length ; i++){
|
| 89 |
|
xml.addChild(serverDataToXml(servers[i]));
|
| 90 |
|
}
|
| 91 |
|
|
| 92 |
|
}
|
| 93 |
|
|
| 94 |
|
/**
|
| 95 |
|
* This method adds a ServerData using the Anadami
|
|
72 |
* This method adds a ServerData using the Andami
|
| 96 |
73 |
* persistence model. If the server exists just actualizes
|
| 97 |
74 |
* the type and subtype fileds and changes the last access
|
| 98 |
75 |
* value to the current time.
|
| 99 |
76 |
* @param server
|
| 100 |
77 |
* ServerData
|
| 101 |
78 |
*/
|
| 102 |
|
public void addServerData(ServerData server){
|
| 103 |
|
ServerData[] servers = getArrayOfServerData();
|
| 104 |
|
ServerData[] newServers = new ServerData[servers.length + 1];
|
| 105 |
|
|
| 106 |
|
boolean found = false;
|
| 107 |
|
|
| 108 |
|
for (int i = 0; i < servers.length; i++) {
|
| 109 |
|
if (servers[i].getServerAddress().equals(server.getServerAddress())) {
|
| 110 |
|
found = true;
|
| 111 |
|
servers[i].updateLastAccess();
|
| 112 |
|
servers[i].setServiceSubType(server.getServiceSubType());
|
| 113 |
|
servers[i].setServiceType(server.getServiceType());
|
| 114 |
|
servers[i].setDatabase(server.getDatabase());
|
| 115 |
|
servers[i].setProperies(server.getProperies());
|
| 116 |
|
setArrayOfServerData(servers);
|
| 117 |
|
}
|
| 118 |
|
}
|
| 119 |
|
|
| 120 |
|
if (!found) {
|
| 121 |
|
System.arraycopy(servers, 0, newServers, 0, servers.length);
|
| 122 |
|
newServers[servers.length] = server;
|
| 123 |
|
setArrayOfServerData(newServers);
|
| 124 |
|
|
| 125 |
|
}
|
|
79 |
public void addServerData(ServerData server) {
|
|
80 |
serverList.add(server);
|
| 126 |
81 |
}
|
| 127 |
|
|
| 128 |
|
|
| 129 |
|
|
|
82 |
|
| 130 |
83 |
/**
|
| 131 |
|
* This method returns an array of ServerData objects that
|
| 132 |
|
* have been saved using the Andami persistence model.
|
|
84 |
* Returns true if exists a server in this list
|
|
85 |
* @param address
|
| 133 |
86 |
* @return
|
| 134 |
|
* String[]
|
| 135 |
87 |
*/
|
| 136 |
|
public ServerData[] getArrayOfServerData(){
|
| 137 |
|
ServerData[] servers = new ServerData[xml.getChildrenCount()];
|
| 138 |
|
for (int i=0 ; i<xml.getChildrenCount() ; i++){
|
| 139 |
|
servers[i] = xmlToServerData(xml.getChild(i));
|
|
88 |
public boolean existsServer(String address) {
|
|
89 |
for (int i = 0; i < serverList.size(); i++) {
|
|
90 |
ServerData sd = serverList.get(i);
|
|
91 |
if(sd.getServerAddress().equals(address))
|
|
92 |
return true;
|
| 140 |
93 |
}
|
| 141 |
|
return servers;
|
|
94 |
return false;
|
| 142 |
95 |
}
|
| 143 |
96 |
|
| 144 |
|
|
| 145 |
97 |
/**
|
| 146 |
|
* This method creates and returns a new XMLEntity.
|
| 147 |
|
* @param server
|
| 148 |
|
* ServerData with all the server information
|
|
98 |
* This method returns an array of ServerData objects that
|
|
99 |
* have been saved using the gvsig tools persistence model.
|
| 149 |
100 |
* @return
|
| 150 |
|
* XMLEntity
|
|
101 |
* ServerData[]
|
| 151 |
102 |
*/
|
| 152 |
|
public XMLEntity serverDataToXml(ServerData server){
|
| 153 |
|
String dFormat="Y-m-d H:i:s.Z";
|
| 154 |
|
|
| 155 |
|
XMLEntity xmlEnt = new XMLEntity();
|
| 156 |
|
xmlEnt.putProperty(SERVER_URL,server.getServerAddress());
|
| 157 |
|
xmlEnt.putProperty(SERVER_ADDED,DateTime.dateToString(server.getAdded(),dFormat));
|
| 158 |
|
xmlEnt.putProperty(SERVER_LASTACCESS,DateTime.dateToString(server.getLastAccess(),dFormat));
|
| 159 |
|
xmlEnt.putProperty(SERVER_TYPE,server.getServiceType());
|
| 160 |
|
xmlEnt.putProperty(SERVER_SUBTYPE,server.getServiceSubType());
|
| 161 |
|
if (server.getServiceSubType().equals(ServerData.SERVER_SUBTYPE_CATALOG_Z3950)){
|
| 162 |
|
xmlEnt.putProperty(SERVER_DATABASE,server.getDatabase());
|
| 163 |
|
}
|
| 164 |
|
Set keys = server.getProperies().keySet();
|
| 165 |
|
Iterator it = keys.iterator();
|
| 166 |
|
while (it.hasNext()) {
|
| 167 |
|
String next = (String)it.next();
|
| 168 |
|
xmlEnt.putProperty(next,
|
| 169 |
|
server.getProperies().get(next));
|
| 170 |
|
}
|
| 171 |
|
return xmlEnt;
|
|
103 |
public ServerData[] getArrayOfServerData() {
|
|
104 |
return (ServerData[])serverList.toArray(new ServerData[serverList.size()]);
|
| 172 |
105 |
}
|
| 173 |
|
|
| 174 |
|
/**
|
| 175 |
|
* This method creates a new serverData from a XMLEntity
|
| 176 |
|
* @param xmlEnt
|
| 177 |
|
* XMLRntity that contains the server information
|
| 178 |
|
* @return
|
| 179 |
|
* ServerData
|
| 180 |
|
*/
|
| 181 |
|
public ServerData xmlToServerData(XMLEntity xmlEnt){
|
| 182 |
|
String serverAddress;
|
| 183 |
|
Date added;
|
| 184 |
|
Date lastAccess;
|
| 185 |
|
String serviceType = "";
|
| 186 |
|
String serviceSubType = "";
|
| 187 |
|
String databaseName = "";
|
| 188 |
|
|
| 189 |
|
serverAddress = xmlEnt.getStringProperty(SERVER_URL);
|
| 190 |
|
added = DateTime.stringToDate(xmlEnt.getStringProperty(SERVER_ADDED));
|
| 191 |
|
lastAccess = DateTime.stringToDate(xmlEnt.getStringProperty(SERVER_LASTACCESS));
|
| 192 |
|
serviceType = xmlEnt.getStringProperty(SERVER_TYPE).toUpperCase();
|
| 193 |
|
serviceSubType = xmlEnt.getStringProperty(SERVER_SUBTYPE).toUpperCase();
|
| 194 |
|
|
| 195 |
|
if (serviceSubType.equals(ServerData.SERVER_SUBTYPE_CATALOG_Z3950)){
|
| 196 |
|
try{
|
| 197 |
|
databaseName = xmlEnt.getStringProperty(SERVER_DATABASE);
|
| 198 |
|
}catch(NotExistInXMLEntity e){
|
| 199 |
|
|
| 200 |
|
}
|
| 201 |
|
}
|
| 202 |
|
|
| 203 |
|
ServerData serverData = new ServerData(serverAddress,added,lastAccess,serviceType,serviceSubType,databaseName);
|
| 204 |
|
|
| 205 |
|
Properties props = new Properties();
|
| 206 |
|
for (int i=0 ; i<xmlEnt.getPropertyCount() ; i++){
|
| 207 |
|
String property = xmlEnt.getPropertyName(i);
|
| 208 |
|
if (!((property.equals(SERVER_URL)) ||
|
| 209 |
|
(property.equals(SERVER_ADDED)) ||
|
| 210 |
|
(property.equals(SERVER_LASTACCESS)) ||
|
| 211 |
|
(property.equals(SERVER_TYPE)) ||
|
| 212 |
|
(property.equals(SERVER_SUBTYPE)) ||
|
| 213 |
|
(property.equals(SERVER_DATABASE)))){
|
| 214 |
|
props.put(property,xmlEnt.getStringProperty(property));
|
| 215 |
|
}
|
| 216 |
|
}
|
| 217 |
|
serverData.setProperies(props);
|
| 218 |
|
return serverData;
|
|
106 |
|
|
107 |
public List<ServerData> getServerData() {
|
|
108 |
return serverList;
|
| 219 |
109 |
}
|
|
110 |
|
|
111 |
public void setArrayOfServerData(ServerData[] servers) {
|
|
112 |
if(servers != null)
|
|
113 |
serverList = Arrays.asList(servers);
|
|
114 |
}
|
| 220 |
115 |
|
| 221 |
116 |
public String getServiceType() {
|
| 222 |
117 |
return serviceType;
|
| ... | ... | |
| 226 |
121 |
this.serviceType = serviceType;
|
| 227 |
122 |
}
|
| 228 |
123 |
|
| 229 |
|
public XMLEntity getXml() {
|
| 230 |
|
return xml;
|
|
124 |
public void saveToState(PersistentState state) throws PersistenceException {
|
|
125 |
state.set("serverData", getArrayOfServerData());
|
|
126 |
state.set("serviceType", serviceType);
|
| 231 |
127 |
}
|
| 232 |
128 |
|
| 233 |
|
public void setXml(XMLEntity xml) {
|
| 234 |
|
this.xml = xml;
|
|
129 |
public void loadFromState(PersistentState state)
|
|
130 |
throws PersistenceException {
|
|
131 |
if(state.get("serverData") instanceof List) {
|
|
132 |
serverList = (List<ServerData>)state.get("serverData");
|
|
133 |
}
|
|
134 |
serviceType = state.getString("serviceType");
|
| 235 |
135 |
}
|
|
136 |
|
|
137 |
public static void registerPersistence() {
|
|
138 |
PersistenceManager manager = ToolsLocator.getPersistenceManager();
|
|
139 |
DynStruct definition = manager.getDefinition(PERSISTENT_NAME);
|
|
140 |
if( definition == null ) {
|
|
141 |
definition = manager.addDefinition(
|
|
142 |
ServerDataPersistence.class,
|
|
143 |
PERSISTENT_NAME,
|
|
144 |
PERSISTENT_DESCRIPTION,
|
|
145 |
null,
|
|
146 |
null
|
|
147 |
);
|
|
148 |
}
|
|
149 |
|
|
150 |
definition.addDynFieldList("serverData").setClassOfItems(ServerData.class).setMandatory(false);
|
|
151 |
definition.addDynFieldString("serviceType").setMandatory(true);
|
|
152 |
}
|
|
153 |
|
|
154 |
public int compareTo(ServerDataPersistence a) {
|
|
155 |
if(a.getServiceType().equals(getServiceType())) {
|
|
156 |
if(getServerData().size() != a.getServerData().size())
|
|
157 |
return -1;
|
|
158 |
for (int i = 0; i < getServerData().size(); i++) {
|
|
159 |
ServerData serverData = getServerData().get(i);
|
|
160 |
if(!a.existsServer(serverData.getServerAddress()))
|
|
161 |
return -1;
|
|
162 |
}
|
|
163 |
}
|
|
164 |
return 0;
|
|
165 |
}
|
|
166 |
|
| 236 |
167 |
}
|