web: Add controllers

Signed-off-by: Eduardo L. Buratti <elb09@c3sl.ufpr.br>

web/app/controllers/Application.java

@@ -14,7 +14,34 @@ public class Application extends Controller {
     public static Result jsRoutes() {
         return ok(Routes.javascriptRouter("jsRoutes",
                     routes.javascript.Application.index(),
-                    routes.javascript.Data.get()
+                    routes.javascript.Attendance.school(),
+                    routes.javascript.Attendance.availabilityBrasil(),
+                    routes.javascript.Attendance.availabilityRegion(),
+                    routes.javascript.Attendance.availabilityState(),
+                    routes.javascript.Attendance.inventoryBrasil(),
+                    routes.javascript.Attendance.inventoryRegion(),
+                    routes.javascript.Attendance.inventoryState(),
+                    routes.javascript.Attendance.auditBrasil(),
+                    routes.javascript.Attendance.auditRegion(),
+                    routes.javascript.Attendance.auditState(),
+                    routes.javascript.Attendance.alertBrasil(),
+                    routes.javascript.Attendance.alertRegion(),
+                    routes.javascript.Attendance.alertState(),
+                    routes.javascript.Reports.availabilityCity(),
+                    routes.javascript.Reports.inventoryCity(),
+                    routes.javascript.Reports.auditCity(),
+                    routes.javascript.Reports.alertCity(),
+                    routes.javascript.Data.netUsage(),
+                    routes.javascript.Data.availability(),
+                    routes.javascript.Data.inventory(),
+                    routes.javascript.Data.audit(),
+                    routes.javascript.Data.alert(),
+                    routes.javascript.Data.os(),
+                    routes.javascript.Combo.projects(),
+                    routes.javascript.Combo.reports(),
+                    routes.javascript.Combo.regions(),
+                    routes.javascript.Combo.states(),
+                    routes.javascript.Combo.cities()
                     )
                 ).as("text/javascript");
     }

web/app/controllers/Attendance.java

 package controllers;
 
+import java.util.ArrayList;
+
 import play.*;
 import play.mvc.*;
+import play.data.*;
 
 import views.html.attendance.*;
+import models.*;
 
 public class Attendance extends Controller {
 
     public static Result index() {
-        return ok(index.render());
+        return redirect(controllers.routes.Attendance.availabilityBrasil("proinfo"));
+    }
+
+    public static Result school(Long id) throws java.sql.SQLException {
+        School school = School.getById(id);
+
+        return ok(views.html.attendance.school.render(school));
+    }
+
+    public static Result searchSchool() throws java.sql.SQLException {
+        DynamicForm requestData = DynamicForm.form().bindFromRequest();
+        String query = requestData.get("query");
+        String region = requestData.get("region");
+        String state = requestData.get("state");
+        String city = requestData.get("city");
+
+        if ((query == null) || (query.length() == 0)) {
+            return ok(views.html.attendance.searchSchool.render(null, null, null, null, null));
+        }
+
+        if ((region == null) || (region.length() == 0)) {
+            ArrayList<SearchResult> results = SearchResult.getByQuery(query);
+            return ok(views.html.attendance.searchSchool.render(query, null, null, null, results));
+        }
+
+        if ((state == null) || (state.length() == 0)) {
+            ArrayList<SearchResult> results = SearchResult.getByQuery(query, region);
+            return ok(views.html.attendance.searchSchool.render(query, region, null, null, results));
+        }
+
+        if ((city == null) || (city.length() == 0)) {
+            ArrayList<SearchResult> results = SearchResult.getByQuery(query, region, state);
+            return ok(views.html.attendance.searchSchool.render(query, region, state, null, results));
+        }
+
+        ArrayList<SearchResult> results = SearchResult.getByQuery(query, region, state, city);
+        return ok(views.html.attendance.searchSchool.render(query, region, state, city, results));
+    }
+
+    public static Result searchReport() {
+        return ok(views.html.attendance.searchReport.render());
+    }
+
+
+
+    public static Result availabilityBrasil(String project) {
+        return ok(availability.render(project, null, null));
+    }
+
+    public static Result availabilityRegion(String project, String region) {
+        return ok(availability.render(project, region, null));
     }
 
-    public static Result availability(String project) {
-        return ok(availability.render(project));
+    public static Result availabilityState(String project, String region, String state) {
+        return ok(availability.render(project, region, state));
     }
 
+
+    public static Result inventoryBrasil(String project) {
+        return ok(inventory.render(project, null, null));
+    }
+
+    public static Result inventoryRegion(String project, String region) {
+        return ok(inventory.render(project, region, null));
+    }
+
+    public static Result inventoryState(String project, String region, String state) {
+        return ok(inventory.render(project, region, state));
+    }
+
+
+    public static Result auditBrasil(String project) {
+        return ok(audit.render(project, null, null));
+    }
+
+    public static Result auditRegion(String project, String region) {
+        return ok(audit.render(project, region, null));
+    }
+
+    public static Result auditState(String project, String region, String state) {
+        return ok(audit.render(project, region, state));
+    }
+
+
+    public static Result alertBrasil(String project) {
+        return ok(alert.render(project, null, null));
+    }
+
+    public static Result alertRegion(String project, String region) {
+        return ok(alert.render(project, region, null));
+    }
+
+    public static Result alertState(String project, String region, String state) {
+        return ok(alert.render(project, region, state));
+    }
+
+
+    public static Result osBrasil(String project) {
+        return ok(os.render(project, null, null));
+    }
 }

web/app/controllers/Combo.java

+package controllers;
+
+import play.*;
+import play.mvc.*;
+import play.libs.Json;
+
+import org.codehaus.jackson.JsonNode;
+import play.mvc.BodyParser;
+
+import models.*;
+
+public class Combo extends Controller {
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result projects() {
+        String options = "[ " +
+            "{ \"value\": \"proinfo\", \"content\": \"Máquina PROINFO\" }," +
+            "{ \"value\": \"uca_classmate\", \"content\": \"UCA Classmate\" }," +
+            "{ \"value\": \"uca_server\", \"content\": \"UCA Server\" }," +
+            "{ \"value\": \"projector\", \"content\": \"Projetor PROINFO\" }" +
+        " ]";
+        return ok(Json.toJson(options)).as("application/json");
+    }
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result reports() {
+        JsonNode json = request().body().asJson();
+        String options;
+
+        String project = json.findPath("project").getTextValue();
+
+        if (project == null)
+            return badRequest("Missing project");
+
+        if (project.equals("proinfo"))
+            return ok("[ " +
+                    "{ \"value\": \"availability\", \"content\": \"Disponibilidade\" }," +
+                    "{ \"value\": \"inventory\", \"content\": \"Inventário\" }," +
+                    "{ \"value\": \"audit\", \"content\": \"Parque computacional instalado\" }," +
+                    "{ \"value\": \"alert\", \"content\": \"Alteração de inventário\" }" +
+                " ]").as("application/json");
+        else if (project.equals("projector"))
+            return ok("[ " +
+                    "{ \"value\": \"availability\", \"content\": \"Disponibilidade\" }," +
+                    "{ \"value\": \"inventory\", \"content\": \"Inventário\" }" +
+                " ]").as("application/json");
+        else
+            return ok("[ ]").as("application/json");
+    }
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result regions() throws java.sql.SQLException {
+        ComboOptions options = ComboOptions.getRegions();
+        return ok(options.toJson()).as("application/json");
+    }
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result states() throws java.sql.SQLException {
+        JsonNode json = request().body().asJson();
+        String region = json.findPath("region").getTextValue();
+
+        ComboOptions options = ComboOptions.getStates(region);
+        return ok(options.toJson()).as("application/json");
+    }
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result cities() throws java.sql.SQLException {
+        JsonNode json = request().body().asJson();
+        String state = json.findPath("state").getTextValue();
+
+        ComboOptions options = ComboOptions.getCities(state);
+        return ok(options.toJson()).as("application/json");
+    }
+
+}

web/app/controllers/Data.java

@@ -3,10 +3,306 @@ package controllers;
 import play.*;
 import play.mvc.*;
 
+import org.codehaus.jackson.JsonNode;
+import play.mvc.BodyParser;
+
+import models.*;
+
 public class Data extends Controller {
 
-    public static Result get() {
-        return ok("{}");
+    public static Result netUsage(Long schoolId) {
+        NetUsage net;
+
+        try {
+            net = NetUsage.getBySchoolId(schoolId);
+        }
+        catch (java.sql.SQLException e) {
+            e.printStackTrace();
+            return badRequest("SQL failed");
+        }
+
+        return ok(net.toJson()).as("application/json");
+    }
+
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result availability() {
+        JsonNode json = request().body().asJson();
+        Availability avail;
+
+        String type = json.findPath("type").getTextValue();
+        String level = json.findPath("level").getTextValue();
+        String project = json.findPath("project").getTextValue();
+        String region = json.findPath("region").getTextValue();
+        String state = json.findPath("state").getTextValue();
+
+        if ((type == null) || (level == null) ||
+            (project == null)) {
+            return badRequest("Missing parameters");
+        }
+
+        try {
+            if (level.equals("brazil")) {
+                if (type.equals("current"))
+                    avail = Availability.getCurrent(project);
+                else if (type.equals("historical"))
+                    avail = Availability.getHistorical(project);
+                else if (type.equals("sub"))
+                    avail = Availability.getCurrentRegions(project);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(avail.toJson()).as("application/json");
+            }
+            else if (level.equals("region")) {
+                if (type.equals("current"))
+                    avail = Availability.getCurrentByRegion(project, region);
+                else if (type.equals("historical"))
+                    avail = Availability.getHistoricalByRegion(project, region);
+                else if (type.equals("sub"))
+                    avail = Availability.getCurrentStatesByRegion(project, region);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(avail.toJson()).as("application/json");
+            }
+            else if (level.equals("state")) {
+                if (type.equals("current"))
+                    avail = Availability.getCurrentByState(project, region, state);
+                else if (type.equals("historical"))
+                    avail = Availability.getHistoricalByState(project, region, state);
+                else if (type.equals("sub"))
+                    avail = Availability.getCurrentCitiesByState(project, region, state);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(avail.toJson()).as("application/json");
+            }
+            else
+                return badRequest("Unknown level");
+        }
+        catch (java.sql.SQLException e) {
+            e.printStackTrace();
+            return badRequest("SQL failed");
+        }
+    }
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result inventory() {
+        JsonNode json = request().body().asJson();
+
+        Inventory inv;
+
+        String type = json.findPath("type").getTextValue();
+        String level = json.findPath("level").getTextValue();
+        String project = json.findPath("project").getTextValue();
+        String region = json.findPath("region").getTextValue();
+        String state = json.findPath("state").getTextValue();
+
+        if ((type == null) || (level == null) ||
+            (project == null)) {
+            return badRequest("Missing parameters");
+        }
+
+        try {
+            if (level.equals("brazil")) {
+                if (type.equals("current"))
+                    inv = Inventory.getCurrent(project);
+                else if (type.equals("historical"))
+                    inv = Inventory.getHistorical(project);
+                else if (type.equals("sub"))
+                    inv = Inventory.getCurrentRegions(project);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(inv.toJson()).as("application/json");
+            }
+            else if (level.equals("region")) {
+                if (type.equals("current"))
+                    inv = Inventory.getCurrentByRegion(project, region);
+                else if (type.equals("historical"))
+                    inv = Inventory.getHistoricalByRegion(project, region);
+                else if (type.equals("sub"))
+                    inv = Inventory.getCurrentStatesByRegion(project, region);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(inv.toJson()).as("application/json");
+            }
+            else if (level.equals("state")) {
+                if (type.equals("current"))
+                    inv = Inventory.getCurrentByState(project, region, state);
+                else if (type.equals("historical"))
+                    inv = Inventory.getHistoricalByState(project, region, state);
+                else if (type.equals("sub"))
+                    inv = Inventory.getCurrentCitiesByState(project, region, state);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(inv.toJson()).as("application/json");
+            }
+            else
+                return badRequest("Unknown level");
+        }
+        catch (java.sql.SQLException e) {
+            e.printStackTrace();
+            return badRequest("SQL failed");
+        }
+    }
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result audit() {
+        JsonNode json = request().body().asJson();
+
+        Audit audit;
+
+        String type = json.findPath("type").getTextValue();
+        String level = json.findPath("level").getTextValue();
+        String project = json.findPath("project").getTextValue();
+        String region = json.findPath("region").getTextValue();
+        String state = json.findPath("state").getTextValue();
+
+        if ((type == null) || (level == null) ||
+            (project == null)) {
+            return badRequest("Missing parameters");
+        }
+
+        try {
+            if (level.equals("brazil")) {
+                if (type.equals("current"))
+                    audit = Audit.getCurrent(project);
+                else if (type.equals("historical"))
+                    audit = Audit.getHistorical(project);
+                else if (type.equals("sub"))
+                    audit = Audit.getCurrentRegions(project);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(audit.toJson()).as("application/json");
+            }
+            else if (level.equals("region")) {
+                if (type.equals("current"))
+                    audit = Audit.getCurrentByRegion(project, region);
+                else if (type.equals("historical"))
+                    audit = Audit.getHistoricalByRegion(project, region);
+                else if (type.equals("sub"))
+                    audit = Audit.getCurrentStatesByRegion(project, region);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(audit.toJson()).as("application/json");
+            }
+            else if (level.equals("state")) {
+                if (type.equals("current"))
+                    audit = Audit.getCurrentByState(project, region, state);
+                else if (type.equals("historical"))
+                    audit = Audit.getHistoricalByState(project, region, state);
+                else if (type.equals("sub"))
+                    audit = Audit.getCurrentCitiesByState(project, region, state);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(audit.toJson()).as("application/json");
+            }
+            else
+                return badRequest("Unknown level");
+        }
+        catch (java.sql.SQLException e) {
+            e.printStackTrace();
+            return badRequest("SQL failed");
+        }
+    }
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result alert() {
+        JsonNode json = request().body().asJson();
+
+        Alert alert;
+
+        String type = json.findPath("type").getTextValue();
+        String level = json.findPath("level").getTextValue();
+        String project = json.findPath("project").getTextValue();
+        String region = json.findPath("region").getTextValue();
+        String state = json.findPath("state").getTextValue();
+
+        if ((type == null) || (level == null) ||
+            (project == null)) {
+            return badRequest("Missing parameters");
+        }
+
+        try {
+            if (level.equals("brazil")) {
+                if (type.equals("current"))
+                    alert = Alert.getCurrent(project);
+                else if (type.equals("historical"))
+                    alert = Alert.getHistorical(project);
+                else if (type.equals("sub"))
+                    alert = Alert.getCurrentRegions(project);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(alert.toJson()).as("application/json");
+            }
+            else if (level.equals("region")) {
+                if (type.equals("current"))
+                    alert = Alert.getCurrentByRegion(project, region);
+                else if (type.equals("historical"))
+                    alert = Alert.getHistoricalByRegion(project, region);
+                else if (type.equals("sub"))
+                    alert = Alert.getCurrentStatesByRegion(project, region);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(alert.toJson()).as("application/json");
+            }
+            else if (level.equals("state")) {
+                if (type.equals("current"))
+                    alert = Alert.getCurrentByState(project, region, state);
+                else if (type.equals("historical"))
+                    alert = Alert.getHistoricalByState(project, region, state);
+                else if (type.equals("sub"))
+                    alert = Alert.getCurrentCitiesByState(project, region, state);
+                else
+                    return badRequest("Unknown type");
+
+                return ok(alert.toJson()).as("application/json");
+            }
+            else
+                return badRequest("Unknown level");
+        }
+        catch (java.sql.SQLException e) {
+            e.printStackTrace();
+            return badRequest("SQL failed");
+        }
+    }
+
+    @BodyParser.Of(BodyParser.Json.class)
+    public static Result os() {
+        JsonNode json = request().body().asJson();
+
+        OS os;
+
+        String type = json.findPath("type").getTextValue();
+        String project = json.findPath("project").getTextValue();
+
+        if ((type == null) || (project == null)) {
+            return badRequest("Missing parameters");
+        }
+
+        try {
+            if (type.equals("current"))
+                os = OS.getCurrent(project);
+            else if (type.equals("historical"))
+                os = OS.getHistorical(project);
+            else
+                return badRequest("Unknown type");
+
+            return ok(os.toJson()).as("application/json");
+        }
+        catch (java.sql.SQLException e) {
+            e.printStackTrace();
+            return badRequest("SQL failed");
+        }
     }
 
 }

web/app/controllers/Doc.java

+package controllers;
+
+import java.util.ArrayList;
+
+import play.*;
+import play.mvc.*;
+import play.data.*;
+
+import views.html.doc.*;
+import models.*;
+
+public class Doc extends Controller {
+
+    public static Result index() {
+        return ok(views.html.doc.index.render());
+    }
+
+}

web/app/controllers/Install.java

+package controllers;
+
+import java.io.*;
+import java.util.ArrayList;
+
+import play.*;
+import play.mvc.*;
+import play.data.*;
+
+import models.*;
+
+public class Install extends Controller {
+
+    private static String MAKE_PACKAGE_BIN = "/home/seed2/agent/make-package.sh";
+    private static String MAKE_OUTPUT_DIR = "/tmp/";
+
+    public static Result index() {
+        return ok(views.html.install.index.render());
+    }
+
+    public static Result makePackage() {
+        DynamicForm requestData = DynamicForm.form().bindFromRequest();
+        String inep = requestData.get("inep");
+
+        String useProxyStr = requestData.get("useProxy");
+        boolean useProxy = false;
+        if (useProxyStr.equals("true")) useProxy = true;
+
+        String proxyHost = requestData.get("proxyHost");
+        String proxyPort = requestData.get("proxyPort");
+        String proxyUser = requestData.get("proxyUser");
+        String proxyPass = requestData.get("proxyPass");
+
+        if ((inep == null) || (inep.length() < 6) || (inep.length() > 12))
+            return badRequest("Inep inválido");
+
+        School school = null;
+
+        try {
+            school = School.getByInep(inep);
+        }
+        catch (java.sql.SQLException e) {
+            e.printStackTrace();
+            return internalServerError();
+        }
+
+        if (school == null)
+            return badRequest("Inep inválido");
+
+
+        // build the package
+        String command = "sh " + MAKE_PACKAGE_BIN + " " + inep;
+        if (useProxy) {
+            command += " " + proxyHost + " " + proxyPort + " " +
+                proxyUser + " " + proxyPass;
+        }
+
+        StringBuffer sb = new StringBuffer();
+        try {
+            Process process = Runtime.getRuntime().exec(command);
+            process.waitFor();
+
+            BufferedReader reader = new BufferedReader(new InputStreamReader(
+					process.getInputStream()));
+
+			String line = reader.readLine();
+            while (line != null) {
+                sb.append(line+'\n');
+				line = reader.readLine();
+			}
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            return internalServerError();
+        }
+
+        String filename = "agent_"+inep+".run";
+        response().setHeader("Content-Disposition", "attachment; filename="+filename);
+        return ok(new File(MAKE_OUTPUT_DIR+filename));
+    }
+
+}

web/app/controllers/Reports.java

+package controllers;
+
+import java.io.*;
+import java.util.*;
+
+import play.*;
+import play.mvc.*;
+
+import lib.reports.*;
+
+public class Reports extends Controller {
+    public static Result availabilityCity(String project, String region, String state, String city) throws Exception {
+        Map params = new HashMap();
+        params.put("REGIAO", region);
+        params.put("ESTADO", state);
+        params.put("CIDADE", city);
+
+        response().setHeader("Content-Disposition", "inline; filename="+project+"Avail.pdf");
+
+        JasperReport report = new JasperReport(project+"AvailCity.jrxml", params);
+        return ok(report.renderAs("application/pdf")).as("application/pdf");
+    }
+
+    public static Result inventoryCity(String project, String region, String state, String city) throws Exception {
+        Map params = new HashMap();
+        params.put("REGIAO", region);
+        params.put("ESTADO", state);
+        params.put("CIDADE", city);
+
+        response().setHeader("Content-Disposition", "inline; filename="+project+"Inventory.pdf");
+
+        JasperReport report = new JasperReport(project+"InventoryCity.jrxml", params);
+        return ok(report.renderAs("application/pdf")).as("application/pdf");
+    }
+
+    public static Result auditCity(String project, String region, String state, String city) throws Exception {
+        Map params = new HashMap();
+        params.put("REGIAO", region);
+        params.put("ESTADO", state);
+        params.put("CIDADE", city);
+
+        response().setHeader("Content-Disposition", "inline; filename="+project+"Audit.pdf");
+
+        JasperReport report = new JasperReport(project+"AuditCity.jrxml", params);
+        return ok(report.renderAs("application/pdf")).as("application/pdf");
+    }
+
+    public static Result alertCity(String project, String region, String state, String city) throws Exception {
+        Map params = new HashMap();
+        params.put("REGIAO", region);
+        params.put("ESTADO", state);
+        params.put("CIDADE", city);
+
+        response().setHeader("Content-Disposition", "inline; filename="+project+"Alert.pdf");
+
+        JasperReport report = new JasperReport(project+"AlertCity.jrxml", params);
+        return ok(report.renderAs("application/pdf")).as("application/pdf");
+    }
+
+}