/src/ru/eltech/elerning/geotracker/core/services/BaseGeo2TagService.java

https://github.com/e-learning/geotracker · Java · 268 lines · 237 code · 27 blank · 4 comment · 0 complexity · d1f86742291b35411c7f6e6915010b8f MD5 · raw file 

    

  1. package ru.eltech.elerning.geotracker.core.services;
    2. 

  2. 

  3. import org.json.JSONException;
    4. 

  4. import org.json.JSONObject;
    5. 

  5. import ru.eltech.elerning.geotracker.util.ConnectionUtils;
    6. 

  6. import ru.eltech.elerning.geotracker.util.StringUtils;
    7. 

  7. 

  8. import java.io.IOException;
    9. 

  9. import java.text.DateFormat;
    10. 

  10. import java.text.SimpleDateFormat;
    11. 

  11. import java.util.Date;
    12. 

  12. 

  13. import static ru.eltech.elerning.geotracker.core.Geo2TagConstants.Params;
    14. 

  14. import static ru.eltech.elerning.geotracker.core.Geo2TagConstants.Services;
    15. 

  15. 

  16. /**
    17. 

  17.  * Author: Kirill Korgov (korgov@yandex-team.ru)
    18. 

  18.  * Date: 12/18/11
    19. 

  19.  */
    20. 

  20. public class BaseGeo2TagService {
    21. 

  21. 

  22.     private static final String HOST = "http://tracks.osll.spb.ru:81";
    23. 

  23. 

  24.     private static final DateFormat DATE_FORMAT = new SimpleDateFormat("dd MM yyyy HH:mm:ss.SSS");
    25. 

  25. 

  26.     public static JSONObject login(final String userLogin, final String userPassword) {
    27. 

  27.         final JSONObject requestParams = new JSONObject();
    28. 

  28.         try {
    29. 

  29.             requestParams.put(Params.LOGIN, userLogin);
    30. 

  30.             requestParams.put(Params.PASSWORD, userPassword);
    31. 

  31.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.LOGIN, requestParams.toString()));
    32. 

  32.         } catch (JSONException e) {
    33. 

  33.             throw new RuntimeException("Incorrect login or password format: login: {" + userLogin + "}, pwd: {" + userPassword + "}", e);
    34. 

  34.         } catch (IOException e) {
    35. 

  35.             throw new RuntimeException(e);
    36. 

  36.         }
    37. 

  37.     }
    38. 

  38. 

  39. 

  40. 

  41.     public static JSONObject addUser(final String userLogin, final String userPassword) {
    42. 

  42.         final JSONObject requestParams = new JSONObject();
    43. 

  43.         try {
    44. 

  44.             requestParams.put(Params.LOGIN, userLogin);
    45. 

  45.             requestParams.put(Params.PASSWORD, userPassword);
    46. 

  46.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.ADD_USER, requestParams.toString()));
    47. 

  47.         } catch (JSONException e) {
    48. 

  48.             throw new RuntimeException("Incorrect login or password format: login: {" + userLogin + "}, pwd: {" + userPassword + "}", e);
    49. 

  49.         } catch (IOException e) {
    50. 

  50.             throw new RuntimeException(e);
    51. 

  51.         }
    52. 

  52.     }
    53. 

  53. 

  54.     public static JSONObject loadAvailableChannels(final String authToken, final double lat, final double lon, final double radius) {
    55. 

  55.         final JSONObject requestParams = new JSONObject();
    56. 

  56.         try {
    57. 

  57.             requestParams.put(Params.AUTH_TOKEN, authToken);
    58. 

  58.             requestParams.put(Params.LATITUDE, lat);
    59. 

  59.             requestParams.put(Params.LONGITUDE, lon);
    60. 

  60.             requestParams.put(Params.RADIUS, radius);
    61. 

  61.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.CHANNELS, requestParams.toString()));
    62. 

  62.         } catch (JSONException e) {
    63. 

  63.             throw new RuntimeException("Incorrect loadAvailableChannels() params format", e);
    64. 

  64.         } catch (IOException e) {
    65. 

  65.             throw new RuntimeException(e);
    66. 

  66.         }
    67. 

  67.     }
    68. 

  68. 

  69.     public static JSONObject loadSubscribedChannels(final String authToken) {
    70. 

  70.         final JSONObject requestParams = new JSONObject();
    71. 

  71.         try {
    72. 

  72.             requestParams.put(Params.AUTH_TOKEN, authToken);
    73. 

  73.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.SUBSCRIBED, requestParams.toString()));
    74. 

  74.         } catch (JSONException e) {
    75. 

  75.             throw new RuntimeException("Incorrect loadSubscribedChannels() params format", e);
    76. 

  76.         } catch (IOException e) {
    77. 

  77.             throw new RuntimeException(e);
    78. 

  78.         }
    79. 

  79.     }
    80. 

  80. 

  81.     public static JSONObject subscribeChannel(final String authToken, final String channelName) {
    82. 

  82.         final JSONObject requestParams = new JSONObject();
    83. 

  83.         try {
    84. 

  84.             requestParams.put(Params.AUTH_TOKEN, authToken);
    85. 

  85.             requestParams.put(Params.CHANNEL, channelName);
    86. 

  86.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.SUBSCRIBE, requestParams.toString()));
    87. 

  87.         } catch (JSONException e) {
    88. 

  88.             throw new RuntimeException("Incorrect subscribeChannel() params format", e);
    89. 

  89.         } catch (IOException e) {
    90. 

  90.             throw new RuntimeException(e);
    91. 

  91.         }
    92. 

  92.     }
    93. 

  93. 

  94.     public static JSONObject unSubscribeChannel(final String authToken, final String channelName) {
    95. 

  95.         final JSONObject requestParams = new JSONObject();
    96. 

  96.         try {
    97. 

  97.             requestParams.put(Params.AUTH_TOKEN, authToken);
    98. 

  98.             requestParams.put(Params.CHANNEL, channelName);
    99. 

  99.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.UNSUBSCRIBE, requestParams.toString()));
    100. 

  100.         } catch (JSONException e) {
    101. 

  101.             throw new RuntimeException("Incorrect unSubscribeChannel() params format", e);
    102. 

  102.         } catch (IOException e) {
    103. 

  103.             throw new RuntimeException(e);
    104. 

  104.         }
    105. 

  105.     }
    106. 

  106. 

  107.     public static JSONObject applyMark(final String authToken, final String channelName,
    108. 

  108.                                        final String description, final String link,
    109. 

  109.                                        final double lat, final double lon,
    110. 

  110.                                        final Date time, final String title) {
    111. 

  111.         final JSONObject requestParams = new JSONObject();
    112. 

  112.         try {
    113. 

  113.             requestParams.put(Params.AUTH_TOKEN, authToken);
    114. 

  114.             requestParams.put(Params.CHANNEL, channelName);
    115. 

  115.             requestParams.put(Params.DESCRIPTION, description);
    116. 

  116.             requestParams.put(Params.LINK, StringUtils.nvl(link, "unknown"));
    117. 

  117.             requestParams.put(Params.LATITUDE, lat);
    118. 

  118.             requestParams.put(Params.LONGITUDE, lon);
    119. 

  119.             requestParams.put(Params.TIME, DATE_FORMAT.format(time));
    120. 

  120.             requestParams.put(Params.TITLE, title);
    121. 

  121.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.APPLY_MARK, requestParams.toString()));
    122. 

  122.         } catch (JSONException e) {
    123. 

  123.             throw new RuntimeException("Incorrect applyMark() params format", e);
    124. 

  124.         } catch (IOException e) {
    125. 

  125.             throw new RuntimeException(e);
    126. 

  126.         }
    127. 

  127.     }
    128. 

  128. 

  129.     public static JSONObject addChannel(final String authToken, final String channelName,
    130. 

  130.                                        final String description, final String url, final double activeRadius) {
    131. 

  131.         final JSONObject requestParams = new JSONObject();
    132. 

  132.         try {
    133. 

  133.             requestParams.put(Params.AUTH_TOKEN, authToken);
    134. 

  134.             requestParams.put(Params.NAME, channelName);
    135. 

  135.             requestParams.put(Params.DESCRIPTION, description);
    136. 

  136.             requestParams.put(Params.URL, url);
    137. 

  137.             requestParams.put(Params.ACTIVE_RADIUS, activeRadius);
    138. 

  138.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.ADD_CHANNEL, requestParams.toString()));
    139. 

  139.         } catch (JSONException e) {
    140. 

  140.             throw new RuntimeException("Incorrect addChannel() params format", e);
    141. 

  141.         } catch (IOException e) {
    142. 

  142.             throw new RuntimeException(e);
    143. 

  143.         }
    144. 

  144.     }
    145. 

  145. 

  146.     public static JSONObject rssFeed(final String authToken, final double lat, final double lon, final double radius) {
    147. 

  147.         final JSONObject requestParams = new JSONObject();
    148. 

  148.         try {
    149. 

  149.             requestParams.put(Params.AUTH_TOKEN, authToken);
    150. 

  150.             requestParams.put(Params.LATITUDE, lat);
    151. 

  151.             requestParams.put(Params.LONGITUDE, lon);
    152. 

  152.             requestParams.put(Params.RADIUS, radius);
    153. 

  153.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.RSS_FEED, requestParams.toString()));
    154. 

  154.         } catch (JSONException e) {
    155. 

  155.             throw new RuntimeException("Incorrect rssFeed() params format", e);
    156. 

  156.         } catch (IOException e) {
    157. 

  157.             throw new RuntimeException(e);
    158. 

  158.         }
    159. 

  159.     }
    160. 

  160. 

  161.     public static JSONObject getTimeSlotOfChannel(final String authToken, final String channelName) {
    162. 

  162.         final JSONObject requestParams = new JSONObject();
    163. 

  163.         try {
    164. 

  164.             requestParams.put(Params.AUTH_TOKEN, authToken);
    165. 

  165.             requestParams.put(Params.CHANNEL, channelName);
    166. 

  166.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.GET_TIME_SLOT_OF_CHANNEL, requestParams.toString()));
    167. 

  167.         } catch (JSONException e) {
    168. 

  168.             throw new RuntimeException("Incorrect getTimeSlotOfChannel() params format", e);
    169. 

  169.         } catch (IOException e) {
    170. 

  170.             throw new RuntimeException(e);
    171. 

  171.         }
    172. 

  172.     }
    173. 

  173. 

  174.     public static JSONObject setTimeSlotForChannel(final String authToken, final String channelName, final long timeSlotInMinutes) {
    175. 

  175.         final JSONObject requestParams = new JSONObject();
    176. 

  176.         try {
    177. 

  177.             requestParams.put(Params.AUTH_TOKEN, authToken);
    178. 

  178.             requestParams.put(Params.CHANNEL, channelName);
    179. 

  179.             requestParams.put(Params.TIME_SLOT, timeSlotInMinutes);
    180. 

  180.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.SET_TIME_SLOT_FOR_CHANNEL, requestParams.toString()));
    181. 

  181.         } catch (JSONException e) {
    182. 

  182.             throw new RuntimeException("Incorrect setTimeSlotForChannel() params format", e);
    183. 

  183.         } catch (IOException e) {
    184. 

  184.             throw new RuntimeException(e);
    185. 

  185.         }
    186. 

  186.     }
    187. 

  187. 

  188.     public static JSONObject setDefaultTimeSlotForChannel(final String authToken, final String channelName) {
    189. 

  189.         final JSONObject requestParams = new JSONObject();
    190. 

  190.         try {
    191. 

  191.             requestParams.put(Params.AUTH_TOKEN, authToken);
    192. 

  192.             requestParams.put(Params.CHANNEL, channelName);
    193. 

  193.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.SET_DEFAULT_TIME_SLOT_FOR_CHANNEL, requestParams.toString()));
    194. 

  194.         } catch (JSONException e) {
    195. 

  195.             throw new RuntimeException("Incorrect setDefaultTimeSlotForChannel() params format", e);
    196. 

  196.         } catch (IOException e) {
    197. 

  197.             throw new RuntimeException(e);
    198. 

  198.         }
    199. 

  199.     }
    200. 

  200. 

  201.     public static JSONObject getTimeSlotOfMark(final String authToken, final long markId) {
    202. 

  202.         final JSONObject requestParams = new JSONObject();
    203. 

  203.         try {
    204. 

  204.             requestParams.put(Params.AUTH_TOKEN, authToken);
    205. 

  205.             requestParams.put(Params.MARK_ID, markId);
    206. 

  206.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.GET_TIME_SLOT_OF_MARK, requestParams.toString()));
    207. 

  207.         } catch (JSONException e) {
    208. 

  208.             throw new RuntimeException("Incorrect getTimeSlotOfMark() params format", e);
    209. 

  209.         } catch (IOException e) {
    210. 

  210.             throw new RuntimeException(e);
    211. 

  211.         }
    212. 

  212.     }
    213. 

  213. 

  214.     public static JSONObject setTimeSlotForMark(final String authToken, final long markId, final long timeSlotInMinutes) {
    215. 

  215.         final JSONObject requestParams = new JSONObject();
    216. 

  216.         try {
    217. 

  217.             requestParams.put(Params.AUTH_TOKEN, authToken);
    218. 

  218.             requestParams.put(Params.MARK_ID, markId);
    219. 

  219.             requestParams.put(Params.TIME_SLOT, timeSlotInMinutes);
    220. 

  220.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.SET_TIME_SLOT_FOR_MARK, requestParams.toString()));
    221. 

  221.         } catch (JSONException e) {
    222. 

  222.             throw new RuntimeException("Incorrect setTimeSlotForMark() params format", e);
    223. 

  223.         } catch (IOException e) {
    224. 

  224.             throw new RuntimeException(e);
    225. 

  225.         }
    226. 

  226.     }
    227. 

  227. 

  228.     public static JSONObject setDefaultTimeSlotForMark(final String authToken, final long markId) {
    229. 

  229.         final JSONObject requestParams = new JSONObject();
    230. 

  230.         try {
    231. 

  231.             requestParams.put(Params.AUTH_TOKEN, authToken);
    232. 

  232.             requestParams.put(Params.MARK_ID, markId);
    233. 

  233.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.SET_DEFAULT_TIME_SLOT_FOR_MARK, requestParams.toString()));
    234. 

  234.         } catch (JSONException e) {
    235. 

  235.             throw new RuntimeException("Incorrect setDefaultTimeSlotForMark() params format", e);
    236. 

  236.         } catch (IOException e) {
    237. 

  237.             throw new RuntimeException(e);
    238. 

  238.         }
    239. 

  239.     }
    240. 

  240. 

  241.     @Deprecated
    242. 

  242.     public static JSONObject rssSession(final String authToken) {
    243. 

  243.         final JSONObject requestParams = new JSONObject();
    244. 

  244.         try {
    245. 

  245.             requestParams.put(Params.AUTH_TOKEN, authToken);
    246. 

  246.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.RSS_SESSION, requestParams.toString()));
    247. 

  247.         } catch (JSONException e) {
    248. 

  248.             throw new RuntimeException("Incorrect rssSession() params format", e);
    249. 

  249.         } catch (IOException e) {
    250. 

  250.             throw new RuntimeException(e);
    251. 

  251.         }
    252. 

  252.     }
    253. 

  253. 

  254.     @Deprecated
    255. 

  255.     public static JSONObject logout(final String authToken) {
    256. 

  256.         final JSONObject requestParams = new JSONObject();
    257. 

  257.         try {
    258. 

  258.             requestParams.put(Params.AUTH_TOKEN, authToken);
    259. 

  259.             return new JSONObject(ConnectionUtils.sendPostRequest(HOST + Services.QUIT, requestParams.toString()));
    260. 

  260.         } catch (JSONException e) {
    261. 

  261.             throw new RuntimeException("Incorrect auth_token format: {" + authToken + "}", e);
    262. 

  262.         } catch (IOException e) {
    263. 

  263.             throw new RuntimeException(e);
    264. 

  264.         }
    265. 

  265.     }
    266. 

  266. 

  267. 

  268. }
    269.