API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 2nd, 2017
98
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 36.46 KB | None | 0 0
raw download clone embed print report
  1. package com.example.teaarte.ssc;
  2.  
  3. import com.example.teaarte.ssc.Models.Monitor;
  4. import com.example.teaarte.ssc.Models.ProfileMessage;
  5. import com.example.teaarte.ssc.Models.Tarifs;
  6. import com.google.gson.JsonArray;
  7. import com.google.gson.JsonElement;
  8. import com.google.gson.JsonObject;
  9. import com.google.gson.JsonParseException;
  10. import com.google.gson.JsonParser;
  11. import com.google.gson.internal.Streams;
  12. import com.turbomanage.httpclient.AsyncCallback;
  13. import com.turbomanage.httpclient.HttpResponse;
  14. import com.turbomanage.httpclient.ParameterMap;
  15. import com.turbomanage.httpclient.android.AndroidHttpClient;
  16.  
  17.  
  18. import android.content.Context;
  19. import android.content.SharedPreferences;
  20. import android.preference.PreferenceManager;
  21. import android.util.Log;
  22. import android.widget.Toast;
  23.  
  24. import com.google.gson.Gson;
  25. import com.google.gson.reflect.TypeToken;
  26.  
  27. import java.io.BufferedReader;
  28. import java.io.BufferedWriter;
  29. import java.io.InputStreamReader;
  30. import java.io.OutputStream;
  31. import java.io.OutputStreamWriter;
  32. import java.io.UnsupportedEncodingException;
  33. import java.lang.reflect.Type;
  34. import java.net.HttpURLConnection;
  35. import java.net.URL;
  36. import java.net.URLEncoder;
  37. import java.util.ArrayList;
  38. import java.util.HashMap;
  39. import java.util.Map;
  40. import java.util.TreeMap;
  41.  
  42. import javax.net.ssl.HttpsURLConnection;
  43.  
  44. public class ApiController {
  45.  
  46.     private static ApiController ourInstance = new ApiController();
  47.  
  48.     public static ApiController getInstance() {
  49.         return ourInstance;
  50.     }
  51.  
  52.     private ApiController() {
  53.     }
  54.  
  55.     private String apiURL = "http://pingle.io/api";
  56.     private String apiKey = "WW1hkMvVLkLNeUhYdarL";
  57.     private String token = "";
  58.     public String name = "";
  59.     public String email = "";
  60.     public Boolean registered = false;
  61.     public int tarif_id;
  62.     public String tarif_expiries = "";
  63.     public int sms_left;
  64.     public int sms_all;
  65.     public int sms_additional_left;
  66.     public int sms_additional_all;
  67.     public String device_id;
  68.     public int disabled = 0;
  69.     public int next = 0;
  70.     public ArrayList<ProfileMessage> profileMessages = new ArrayList<>();
  71.  
  72.     public void setSms_all(int sms_all) {
  73.         this.sms_all = sms_all;
  74.     }
  75.  
  76.     public void setSms_additional_left(int sms_additional_left) {
  77.         this.sms_additional_left = sms_additional_left;
  78.     }
  79.  
  80.     public void setSms_additional_all(int sms_additional_all) {
  81.         this.sms_additional_all = sms_additional_all;
  82.     }
  83.  
  84.     public void setSms_left(int sms_left) {
  85.         this.sms_left = sms_left;
  86.     }
  87.  
  88.     public void setTarif_id(int tarif_id) {
  89.         this.tarif_id = tarif_id;
  90.     }
  91.  
  92.     public void setTarif_expiries(String tarif_expiries) {
  93.         this.tarif_expiries = tarif_expiries;
  94.     }
  95.  
  96.     public void setToken(String token) {
  97.         this.token = token;
  98.     }
  99.  
  100.     public void setName(String n) {
  101.         name = n;
  102.     }
  103.  
  104.     public void setEmail(String n) {
  105.         email = n;
  106.     }
  107.  
  108.     public void setDevice_id(String device_id) {
  109.         this.device_id = device_id;
  110.     }
  111.  
  112.     /*сразу извиняюсь что все через полную жопу написано
  113.      *но если ты это читаешь, то кидай нахуй этот проект
  114.      *ты тут хуй разберешься в моем пиздице
  115.      *да еще к тому же заказчик редкостный еблан
  116.      *который не платит и хочет за мизерные деньги конфетку
  117.      **/
  118.  
  119.     public String getToken() {
  120.         if (token == null) {
  121.             Context applicationContext = MainActivity.getContextOfApplication();
  122.             SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(applicationContext);
  123.             token = prefs.getString("user_token", " ");
  124.         }
  125.         return token;
  126.     }
  127.  
  128.  
  129.  
  130.     public abstract class SignGetSmsCallback {
  131.         public abstract void onComplete(String sms_token);
  132.         public abstract void onError(String errorString);
  133.     }
  134.     public void signGetSms(String number, final ApiController.SignGetSmsCallback callback) {
  135.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  136.         httpClient.setMaxRetries(5);
  137.         ParameterMap params = httpClient.newParams()
  138.                 .add("api_key", apiKey)
  139.                 .add("number", number)
  140.                 .add("device_id", device_id)
  141.                 .add("action", "sign_get_sms");
  142.  
  143.         httpClient.post("/", params, new AsyncCallback() {
  144.             @Override
  145.             public void onComplete(HttpResponse httpResponse) {
  146.                 String input = httpResponse.getBodyAsString();
  147.                 JsonParser parser = new JsonParser();
  148.                 try {
  149.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  150.                     Boolean success = mainObject.get("success").getAsBoolean();
  151.                     if (success == true) {
  152.                         String sms_token = mainObject.get("sms_token").getAsString();
  153.                         callback.onComplete(sms_token);
  154.                     } else {
  155.                         String error = mainObject.get("msg").getAsString();
  156.                         next = mainObject.get("next").getAsInt();
  157.                         callback.onError(error);
  158.                     }
  159.                 }
  160.                 catch (JsonParseException e) {
  161.                     callback.onError("Ошибка");
  162.                 }
  163.  
  164.             }
  165.             @Override
  166.             public void onError(Exception e) {
  167.                 callback.onError("Ошибка");
  168.             }
  169.         });
  170.     }
  171.  
  172.     public abstract class SignInCallback {
  173.         public abstract void onComplete(String token);
  174.         public abstract void onError(String errorString);
  175.     }
  176.     public void signIn(String sms_token, String sms_code, final ApiController.SignInCallback callback) {
  177.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  178.         httpClient.setMaxRetries(5);
  179.         ParameterMap params = httpClient.newParams()
  180.                 .add("api_key", apiKey)
  181.                 .add("action", "sign_in")
  182.                 .add("sms_token", sms_token)
  183.                 .add("sms_code", sms_code);
  184.  
  185.         httpClient.post("/", params, new AsyncCallback() {
  186.             @Override
  187.             public void onComplete(HttpResponse httpResponse) {
  188.                 String input = httpResponse.getBodyAsString();
  189.                 JsonParser parser = new JsonParser();
  190.                 try {
  191.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  192.                     Boolean success = mainObject.get("success").getAsBoolean();
  193.                     if (success == true) {
  194.                         JsonObject data = mainObject.get("data").getAsJsonObject();
  195.  
  196.                         registered = data.get("registered").getAsBoolean();
  197.                         //if (reg.equals("registered")) registered = true;
  198.                         String token = mainObject.get("token").getAsString();
  199.                         callback.onComplete(token);
  200.                     } else {
  201.                         String error = mainObject.get("msg").getAsString();
  202.                         callback.onError(error);
  203.                     }
  204.                 }
  205.                 catch (JsonParseException e) {
  206.                     callback.onError("error");
  207.                 }
  208.  
  209.             }
  210.             @Override
  211.             public void onError(Exception e) {
  212.                 callback.onError("Ошибка");
  213.             }
  214.         });
  215.  
  216.     }
  217.  
  218.     public abstract class ProfileUpdateCallback {
  219.         public abstract void onComplete();
  220.         public abstract void onError(String errorString);
  221.     }
  222.     public void ProfileUpdate(final String name, final String email, final ApiController.ProfileUpdateCallback callback) {
  223.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  224.         httpClient.setMaxRetries(5);
  225.         ParameterMap params = httpClient.newParams()
  226.                 .add("api_key", apiKey)
  227.                 .add("action", "profile_update")
  228.                 .add("name", name)
  229.                 .add("email", email)
  230.                 .add("token", token);
  231.  
  232.         httpClient.post("/", params, new AsyncCallback() {
  233.             @Override
  234.             public void onComplete(HttpResponse httpResponse) {
  235.                 String input = httpResponse.getBodyAsString();
  236.                 JsonParser parser = new JsonParser();
  237.                 try {
  238.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  239.                     Boolean success = mainObject.get("success").getAsBoolean();
  240.                     if (success == true) {
  241.                         setName(name);
  242.                         setEmail(email);
  243.                         callback.onComplete();
  244.                     } else {
  245.                         String error = mainObject.get("msg").getAsString();
  246.                         callback.onError(error);
  247.                     }
  248.                 }
  249.                 catch (JsonParseException e) {
  250.                     callback.onError("error");
  251.                 }
  252.  
  253.             }
  254.             @Override
  255.             public void onError(Exception e) {
  256.                 callback.onError("Ошибка");
  257.             }
  258.         });
  259.  
  260.     }
  261.  
  262.     public abstract class ProfileCallback {
  263.         public abstract void onComplete();
  264.         public abstract void onError(String errorString);
  265.     }
  266.     public void profile(final ApiController.ProfileCallback callback) {
  267.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  268.         httpClient.setMaxRetries(5);
  269.         ParameterMap params = httpClient.newParams()
  270.                 .add("api_key", apiKey)
  271.                 .add("action", "profile")
  272.                 .add("token", token);
  273.  
  274.         httpClient.post("/", params, new AsyncCallback() {
  275.             @Override
  276.             public void onComplete(HttpResponse httpResponse) {
  277.                 String input = httpResponse.getBodyAsString();
  278.                 JsonParser parser = new JsonParser();
  279.                 try {
  280.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  281.                     Boolean success = mainObject.get("success").getAsBoolean();
  282.                     if (success == true) {
  283.                         JsonObject data = mainObject.get("data").getAsJsonObject();
  284.                         String name = data.get("name").getAsString();
  285.                         String email = data.get("email").getAsString();
  286.                         String tarif_expiries = data.get("tarif_expiries").getAsString();
  287.                         int tarif = data.get("tarif_id").getAsInt();
  288.                         int sms_left = data.get("sms_left").getAsInt();
  289.                         int sms_all = data.get("sms_all").getAsInt();
  290.  
  291.                         int sms_additional_left = data.get("sms_additional_left").getAsInt();
  292.                         int sms_additional_all = data.get("sms_additional_all").getAsInt();
  293.                         disabled = data.get("blocked").getAsInt();
  294.                         setSms_left(sms_left);
  295.                         setTarif_expiries(tarif_expiries);
  296.                         setTarif_id(tarif);
  297.                         setSms_all(sms_all);
  298.                         setSms_additional_all(sms_additional_all);
  299.                         setSms_additional_left(sms_additional_left);
  300.                         setName(name);
  301.                         setEmail(email);
  302.                         ArrayList<ProfileMessage> messages = new ArrayList<ProfileMessage>();
  303.                         JsonArray messagesJSONArray = data.get("messages").getAsJsonArray();
  304.                         for (JsonElement messageJSON: messagesJSONArray) {
  305.                             ProfileMessage message = new ProfileMessage();
  306.                             JsonObject messageObject = messageJSON.getAsJsonObject();
  307.                             message.title = messageObject.get("title").getAsString();
  308.                             message.text = messageObject.get("text").getAsString();
  309.                             message.type = messageObject.get("type").getAsInt();
  310.                             messages.add(message);
  311.                         }
  312.                         profileMessages = messages;
  313.  
  314.                         callback.onComplete();
  315.                     } else {
  316.                         String error = mainObject.get("msg").getAsString();
  317.                         callback.onError(error);
  318.                     }
  319.                 }
  320.                 catch (JsonParseException e) {
  321.                     callback.onError("error");
  322.                 }
  323.  
  324.             }
  325.             @Override
  326.             public void onError(Exception e) {
  327.                 callback.onError("Ошибка");
  328.             }
  329.         });
  330.  
  331.     }
  332.  
  333.     public abstract class MonitorAddCallback {
  334.         public abstract void onComplete();
  335.         public abstract void onError(String errorString);
  336.     }
  337.     public void monitor_add(boolean update, Monitor monitor, final ApiController.MonitorAddCallback callback) {
  338.         String action = "monitor_add";
  339.         if (update == true) action = "monitor_update";
  340.         String active = "1";
  341.         if (monitor.active) active = "1";
  342.         if (!monitor.active) active = "0";
  343.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  344.         httpClient.setMaxRetries(5);
  345.         ParameterMap params = httpClient.newParams()
  346.                 .add("api_key", apiKey)
  347.                 .add("action", action)
  348.                 .add("active", active)
  349.                 .add("monitor_id", String.valueOf(monitor.id))
  350.                 .add("name", monitor.name)
  351.                 .add("type", String.valueOf(monitor.type))
  352.                 .add("address", monitor.address)
  353.                 .add("address_dns", monitor.address_dns)
  354.                 .add("auth", String.valueOf(monitor.auth))
  355.                 .add("username", monitor.username)
  356.                 .add("password", monitor.password)
  357.                 .add("period", String.valueOf(monitor.period))
  358.                 .add("period_in_error", String.valueOf(monitor.period_in_error))
  359.                 .add("notification", String.valueOf(monitor.notification))
  360.                 .add("notification_event", String.valueOf(monitor.notification_event))
  361.                 .add("notification_chanel", String.valueOf(monitor.notification_chanel))
  362.                 .add("notification_email", monitor.notification_email)
  363.                 .add("timeout", String.valueOf(monitor.timeout))
  364.                 .add("search_in_page",monitor.search_in_page)
  365.                 .add("token", token);
  366.         Log.i("44444444444444444444", String.valueOf(monitor.search_in_page));
  367.  
  368.         httpClient.post("/", params, new AsyncCallback() {
  369.             @Override
  370.             public void onComplete(HttpResponse httpResponse) {
  371.                 String input = httpResponse.getBodyAsString();
  372.                 JsonParser parser = new JsonParser();
  373.                 try {
  374.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  375.                     Boolean success = mainObject.get("success").getAsBoolean();
  376.                     if (success == true) {
  377.                         Log.i("запрос", mainObject.toString());
  378.                         callback.onComplete();
  379.                     } else {
  380.                         String error = mainObject.get("msg").getAsString();
  381.                         callback.onError(error);
  382.                     }
  383.                 }
  384.                 catch (JsonParseException e) {
  385.                     callback.onError("error");
  386.                 }
  387.  
  388.             }
  389.             @Override
  390.             public void onError(Exception e) {
  391.                 callback.onError("Ошибка");
  392.             }
  393.         });
  394.  
  395.     }
  396.  
  397.     public abstract class MonitorsCallback {
  398.         public abstract void onComplete(ArrayList<Monitor> monitors, ArrayList<Integer> errors);
  399.         public abstract void onError(String errorString);
  400.     }
  401.     public void monitors(final ApiController.MonitorsCallback callback)     {
  402.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  403.         httpClient.setMaxRetries(5);
  404.         ParameterMap params = httpClient.newParams()
  405.                 .add("api_key", apiKey)
  406.                 .add("action", "monitors")
  407.                 .add("token", token);
  408.  
  409.         httpClient.post("/", params, new AsyncCallback() {
  410.             @Override
  411.             public void onComplete(HttpResponse httpResponse) {
  412.                 String input = httpResponse.getBodyAsString();
  413.                 JsonParser parser = new JsonParser();
  414.                 try {
  415.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  416.                     Boolean success = mainObject.get("success").getAsBoolean();
  417.                     if (success == true) {
  418.                         JsonArray monitors = mainObject.get("data").getAsJsonObject().get("monitors").getAsJsonArray();
  419.                         ArrayList<Monitor> monitorsArray = new ArrayList();
  420.  
  421.                         ArrayList<Integer> errorsObject = new ArrayList<>();
  422.                         JsonObject allerrors = mainObject.get("errors").getAsJsonObject();
  423.                         for (int i = 1; i <= 6; i++)
  424.                             errorsObject.add(allerrors.get(String.valueOf(i)).getAsInt());
  425.  
  426.                         for (JsonElement mon: monitors) {
  427.                             Monitor monitorObject = new Monitor();
  428.                             JsonObject monitor = mon.getAsJsonObject();
  429.                             monitorObject.name = monitor.get("name").getAsString();
  430.                             monitorObject.active = monitor.get("active").getAsBoolean();
  431.                             monitorObject.id = monitor.get("id").getAsInt();
  432.                             monitorObject.type = monitor.get("type").getAsInt();
  433.                             monitorObject.address = monitor.get("address").getAsString();
  434.                             monitorObject.address_dns = monitor.get("address_dns").getAsString();
  435.                             monitorObject.auth = monitor.get("auth").getAsInt();
  436.                             if (monitorObject.auth == 1) {
  437.                                 monitorObject.username = monitor.get("username").getAsString();
  438.                                 monitorObject.password = monitor.get("password").getAsString();
  439.                             }
  440.                             monitorObject.period = monitor.get("period").getAsInt();
  441.                             monitorObject.period_in_error = monitor.get("period_in_error").getAsInt();
  442.                             monitorObject.notification = monitor.get("notification").getAsInt();
  443.                             monitorObject.notification_event = monitor.get("notification_event").getAsInt();
  444.                             monitorObject.notification_chanel = monitor.get("notification_chanel").getAsInt();
  445.                             monitorObject.timeout = monitor.get("timeout").getAsInt();
  446.                             monitorObject.next_update_in = monitor.get("next_update_in").getAsInt();
  447.                             monitorObject.search_in_page = monitor.get("search_in_page").getAsString();
  448.                             monitorObject.last_update_in = monitor.get("last_update_in").getAsInt();
  449.                             monitorObject.last_has_error = monitor.get("last_has_error").getAsBoolean();
  450.  
  451.                             JsonObject errors = monitor.get("errors").getAsJsonObject();
  452.                             for (int i = 1; i <= 6; i++)
  453.                                 monitorObject.errors.add(errors.get(String.valueOf(i)).getAsInt());
  454.  
  455.                             if (monitor.get("notification_email") != null)
  456.                                 monitorObject.notification_email = monitor.get("notification_email").getAsString();
  457.                             JsonObject info = monitor.get("info").getAsJsonObject();
  458.                             JsonArray connection = info.getAsJsonArray("connection");
  459.                             for (JsonElement el : connection) {
  460.                                 float value = el.getAsFloat();
  461.                                 monitorObject.connection.add(Float.valueOf(value));
  462.                             }
  463.                             JsonArray time = info.getAsJsonArray("time");
  464.                             for (JsonElement el : time) {
  465.                                 float value = el.getAsFloat();
  466.                                 monitorObject.time.add(Float.valueOf(value));
  467.                             }
  468.                             JsonArray speed = info.getAsJsonArray("speed");
  469.                             for (JsonElement el : speed) {
  470.                                 float value = el.getAsFloat();
  471.                                 monitorObject.speed.add(Float.valueOf(value));
  472.                             }
  473.                             JsonArray timeWait = info.getAsJsonArray("wait");
  474.                             for (JsonElement el : timeWait) {
  475.                                 float value = el.getAsFloat();
  476.                                 monitorObject.timeWait.add(Float.valueOf(value));
  477.                             }
  478.                             monitorObject.search_in_page_info = info.get("search_in_page").getAsString();
  479.                             monitorObject.uptime = info.get("uptime").getAsFloat();
  480.                             monitorObject.stats = info.get("stats").getAsString();
  481.                             monitorObject.stats_start_hour = info.get("stats_start_hour").getAsString();
  482.                             monitorsArray.add(monitorObject);
  483.                         }
  484.                         callback.onComplete(monitorsArray, errorsObject);
  485.                     } else {
  486.                         String error = mainObject.get("msg").getAsString();
  487.                         Log.i("errrr", error);
  488.                         //callback.onError(error);
  489.                     }
  490.                 }
  491.                 catch (JsonParseException e) {
  492.                     //callback.onError("error");
  493.                     Log.i("errrr","wwww");
  494.                 }
  495.  
  496.             }
  497.             @Override
  498.             public void onError(Exception e) {
  499.                 callback.onError("Ошибка");
  500.             }
  501.         });
  502.  
  503.     }
  504.  
  505.  
  506.     public class FaqCategory {
  507.         public String name = "";
  508.         public ArrayList<FaqPage> pages = new ArrayList<>();
  509.     }
  510.     public class FaqPage {
  511.         public String name = "";
  512.         public ArrayList<FaqAnswer> answers = new ArrayList<>();
  513.     }
  514.     public class FaqAnswer {
  515.         public String question = "";
  516.         public String answer = "";
  517.     }
  518.  
  519.     public abstract class FaqCallback {
  520.         public abstract void onComplete(ArrayList<FaqCategory> faqCategories);
  521.         public abstract void onError(String errorString);
  522.     }
  523.     public void help_pages(final ApiController.FaqCallback callback) {
  524.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  525.         httpClient.setMaxRetries(5);
  526.         ParameterMap params = httpClient.newParams()
  527.                 .add("api_key", apiKey)
  528.                 .add("action", "help_pages")
  529.                 .add("token", token);
  530.  
  531.         httpClient.post("/", params, new AsyncCallback() {
  532.             @Override
  533.             public void onComplete(HttpResponse httpResponse) {
  534.                 String input = httpResponse.getBodyAsString();
  535.                 JsonParser parser = new JsonParser();
  536.                 try {
  537.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  538.                     Boolean success = mainObject.get("success").getAsBoolean();
  539.                     if (success == true) {
  540.                         JsonArray categories = mainObject.get("data").getAsJsonObject().get("categories").getAsJsonArray();
  541.                         ArrayList<FaqCategory> categoriesArray = new ArrayList();
  542.                         for (JsonElement cat: categories) {
  543.                             FaqCategory categoryObject = new FaqCategory();
  544.                             JsonObject category = cat.getAsJsonObject();
  545.                             categoryObject.name = category.get("name").getAsString();
  546.                             Log.i("000000", categoryObject.name);
  547.                             JsonArray pages = category.get("pages").getAsJsonArray();
  548.                             for (JsonElement pag: pages) {
  549.                                 FaqPage pageObject = new FaqPage();
  550.                                 JsonObject page = pag.getAsJsonObject();
  551.                                 pageObject.name = page.get("name").getAsString();
  552.                                 Log.i("111111", pageObject.name);
  553.                                 JsonArray answers = page.get("answers").getAsJsonArray();
  554.                                 for (JsonElement answe : answers) {
  555.                                     FaqAnswer answerObject = new FaqAnswer();
  556.                                     JsonObject answer = answe.getAsJsonObject();
  557.                                     answerObject.question = answer.get("question").getAsString();
  558.                                     answerObject.answer = answer.get("answer").getAsString();
  559.                                     pageObject.answers.add(answerObject);
  560.                                 }
  561.                                 categoryObject.pages.add(pageObject);
  562.                             }
  563.                             categoriesArray.add(categoryObject);
  564.                         }
  565.                         String as = String.valueOf(categoriesArray);
  566.                         callback.onComplete(categoriesArray);
  567.                     } else {
  568.                         String error = mainObject.get("msg").getAsString();
  569.                         Log.i("errrr", error);
  570.                         //callback.onError(error);
  571.                     }
  572.                 }
  573.                 catch (JsonParseException e) {
  574.                     //callback.onError("error");
  575.                     Log.i("errrr","wwww");
  576.                 }
  577.  
  578.             }
  579.             @Override
  580.             public void onError(Exception e) {
  581.                 callback.onError("Ошибка");
  582.             }
  583.         });
  584.  
  585.     }
  586.  
  587.     public abstract class MonitorDeleteCallback {
  588.         public abstract void onComplete();
  589.         public abstract void onError(String errorString);
  590.     }
  591.     public void monitor_delete(Monitor monitor, final ApiController.MonitorDeleteCallback callback) {
  592.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  593.         httpClient.setMaxRetries(5);
  594.         ParameterMap params = httpClient.newParams()
  595.                 .add("api_key", apiKey)
  596.                 .add("action", "monitor_delete")
  597.                 .add("monitor_id", String.valueOf(monitor.id))
  598.                 .add("token", token);
  599.         Log.i("toke________________n", String.valueOf(monitor.type));
  600.  
  601.         httpClient.post("/", params, new AsyncCallback() {
  602.             @Override
  603.             public void onComplete(HttpResponse httpResponse) {
  604.                 String input = httpResponse.getBodyAsString();
  605.                 JsonParser parser = new JsonParser();
  606.                 try {
  607.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  608.                     Boolean success = mainObject.get("success").getAsBoolean();
  609.                     if (success == true) {
  610.                         callback.onComplete();
  611.                     } else {
  612.                         String error = mainObject.get("msg").getAsString();
  613.                         callback.onError(error);
  614.                     }
  615.                 }
  616.                 catch (JsonParseException e) {
  617.                     callback.onError("error");
  618.                 }
  619.  
  620.             }
  621.             @Override
  622.             public void onError(Exception e) {
  623.                 callback.onError("Ошибка");
  624.             }
  625.         });
  626.  
  627.     }
  628.  
  629.     public abstract class MonitorExportCallback {
  630.         public abstract void onComplete();
  631.         public abstract void onError(String errorString);
  632.     }
  633.     public void monitor_export(String id,String dateFrom, String dateTo, String mail, final ApiController.MonitorExportCallback callback) {
  634.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  635.         httpClient.setMaxRetries(5);
  636.         ParameterMap params = httpClient.newParams()
  637.                 .add("api_key", apiKey)
  638.                 .add("action", "monitor_export")
  639.                 .add("monitor_id", id)
  640.                 .add("date_from", dateFrom)
  641.                 .add("date_to", dateTo)
  642.                 .add("email", mail)
  643.                 .add("token", token);
  644.  
  645.         httpClient.post("/", params, new AsyncCallback() {
  646.             @Override
  647.             public void onComplete(HttpResponse httpResponse) {
  648.                 String input = httpResponse.getBodyAsString();
  649.                 JsonParser parser = new JsonParser();
  650.                 try {
  651.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  652.                     Boolean success = mainObject.get("success").getAsBoolean();
  653.                     if (success == true) {
  654.                         callback.onComplete();
  655.                     } else {
  656.                         String error = mainObject.get("msg").getAsString();
  657.                         callback.onError(error);
  658.                     }
  659.                 }
  660.                 catch (JsonParseException e) {
  661.                     callback.onError("error");
  662.                 }
  663.  
  664.             }
  665.             @Override
  666.             public void onError(Exception e) {
  667.                 callback.onError("Ошибка");
  668.             }
  669.         });
  670.  
  671.     }
  672.  
  673.     public ArrayList<Tarifs> tarifsArray = new ArrayList();
  674.  
  675.     public abstract class TarifsCallback {
  676.         public abstract void onComplete();
  677.         public abstract void onError(String errorString);
  678.     }
  679.     public void tarifs(final ApiController.TarifsCallback callback) {
  680.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  681.         httpClient.setMaxRetries(5);
  682.         ParameterMap params = httpClient.newParams()
  683.                 .add("api_key", apiKey)
  684.                 .add("action", "tarifs")
  685.                 .add("token", token);
  686.  
  687.         httpClient.post("/", params, new AsyncCallback() {
  688.             @Override
  689.             public void onComplete(HttpResponse httpResponse) {
  690.                 String input = httpResponse.getBodyAsString();
  691.                 JsonParser parser = new JsonParser();
  692.                 try {
  693.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  694.                     Boolean success = mainObject.get("success").getAsBoolean();
  695.                     if (success == true) {
  696.                         JsonArray tarifs = mainObject.get("data").getAsJsonObject().get("tarifs").getAsJsonArray();
  697.                         for (JsonElement tarif : tarifs){
  698.                             Tarifs tarifs1 = new Tarifs();
  699.                             JsonObject tar = tarif.getAsJsonObject();
  700.                             tarifs1.id = tar.get("id").getAsInt();
  701.                             tarifs1.name = tar.get("name").getAsString();
  702.                             tarifs1.price = tar.get("price").getAsInt();
  703.                             tarifs1.monitors = tar.get("monitors").getAsInt();
  704.                             tarifs1.sms = tar.get("sms").getAsBoolean();
  705.                             tarifs1.sms_count = tar.get("sms_count").getAsInt();
  706.                             if (tar.get("disabled") != null)
  707.                                 tarifs1.disabled = tar.get("disabled").getAsBoolean();
  708.                             tarifsArray.add(tarifs1.id,tarifs1);
  709.                         }
  710.                         callback.onComplete();
  711.                     } else {
  712.                         String error = mainObject.get("msg").getAsString();
  713.                         callback.onError(error);
  714.                     }
  715.                 }
  716.                 catch (JsonParseException e) {
  717.                     callback.onError("error");
  718.                 }
  719.  
  720.             }
  721.             @Override
  722.             public void onError(Exception e) {
  723.                 callback.onError("Ошибка");
  724.             }
  725.         });
  726.  
  727.     }
  728.  
  729.  
  730.     public abstract class TarifPayCallback {
  731.         public abstract void onComplete(String payToken, int price);
  732.         public abstract void onError(String errorString);
  733.     }
  734.     public void tarif_pay(int tarif_id, int period, final ApiController.TarifPayCallback callback) {
  735.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  736.         httpClient.setMaxRetries(5);
  737.         ParameterMap params = httpClient.newParams()
  738.                 .add("api_key", apiKey)
  739.                 .add("action", "tarif_pay")
  740.                 .add("tarif_id", String.valueOf(tarif_id))
  741.                 .add("period", String.valueOf(period))
  742.                 .add("token", token);
  743.  
  744.         httpClient.post("/", params, new AsyncCallback() {
  745.             @Override
  746.             public void onComplete(HttpResponse httpResponse) {
  747.                 String input = httpResponse.getBodyAsString();
  748.                 JsonParser parser = new JsonParser();
  749.                 try {
  750.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  751.                     Boolean success = mainObject.get("success").getAsBoolean();
  752.                     if (success == true) {
  753.                         JsonObject data = mainObject.get("data").getAsJsonObject();
  754.                         String payToken = data.get("pay_token").getAsString();
  755.                         int price = data.get("price").getAsInt();
  756.                         if (data.get("free") != null) {
  757.                             payToken = "free";
  758.                         }
  759.                         callback.onComplete(payToken, price);
  760.                     } else {
  761.                         String error = mainObject.get("msg").getAsString();
  762.                         callback.onError(error);
  763.                     }
  764.                 }
  765.                 catch (JsonParseException e) {
  766.                     callback.onError("error");
  767.                 }
  768.  
  769.             }
  770.             @Override
  771.             public void onError(Exception e) {
  772.                 callback.onError("Ошибка");
  773.             }
  774.         });
  775.  
  776.     }
  777.  
  778.  
  779.     public void subscribe_push(String push_token) {
  780.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  781.         httpClient.setMaxRetries(5);
  782.         ParameterMap params = httpClient.newParams()
  783.                 .add("api_key", apiKey)
  784.                 .add("action", "subscribe_push")
  785.                 .add("push_token", push_token)
  786.                 .add("push_type", "android")
  787.                 .add("token", token);
  788.  
  789.         httpClient.post("/", params, new AsyncCallback() {
  790.             @Override
  791.             public void onComplete(HttpResponse httpResponse) {
  792.                 String input = httpResponse.getBodyAsString();
  793.                 JsonParser parser = new JsonParser();
  794.                 try {
  795.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  796.                     Boolean success = mainObject.get("success").getAsBoolean();
  797.                     if (success == true) {
  798.                     } else {
  799.                     }
  800.                 }
  801.                 catch (JsonParseException e) {
  802.                 }
  803.  
  804.             }
  805.             @Override
  806.             public void onError(Exception e) {
  807.             }
  808.         });
  809.  
  810.     }
  811.  
  812.  
  813.     public void logout() {
  814.         AndroidHttpClient httpClient = new AndroidHttpClient(apiURL);
  815.         httpClient.setMaxRetries(5);
  816.         ParameterMap params = httpClient.newParams()
  817.                 .add("api_key", apiKey)
  818.                 .add("action", "logout")
  819.                 .add("token", token);
  820.  
  821.         httpClient.post("/", params, new AsyncCallback() {
  822.             @Override
  823.             public void onComplete(HttpResponse httpResponse) {
  824.                 String input = httpResponse.getBodyAsString();
  825.                 JsonParser parser = new JsonParser();
  826.                 try {
  827.                     JsonObject mainObject = parser.parse(input).getAsJsonObject();
  828.                     Boolean success = mainObject.get("success").getAsBoolean();
  829.                     if (success == true) {
  830.                     } else {
  831.                     }
  832.                 }
  833.                 catch (JsonParseException e) {
  834.                 }
  835.  
  836.             }
  837.             @Override
  838.             public void onError(Exception e) {
  839.             }
  840.         });
  841.  
  842.     }
  843. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!