105 lines
4.7 KiB
Swift
105 lines
4.7 KiB
Swift
import Vapor
|
|
import Foundation
|
|
import FoundationNetworking
|
|
import Crypto
|
|
import Leaf
|
|
|
|
func routes(_ app: Application) throws {
|
|
// Render home page when root domain is loaded
|
|
app.get { req -> EventLoopFuture<View> in
|
|
// Get data from config file at /Resources/config.json
|
|
let fileData = try String(contentsOfFile: "\(app.directory.resourcesDirectory)/config.json").data(using: .utf8)
|
|
// Decode JSON file to Config struct
|
|
let config: Config = try! JSONDecoder().decode(Config.self, from: fileData!)
|
|
// Check if user is logged in
|
|
let loginStatus = req.session.data["loggedIn"] ?? "false"
|
|
// Change loginStatus to a boolean
|
|
let loginBool = loginStatus == "true" ? true : false
|
|
// Render home.leaf with config and login status as context
|
|
return req.view.render("home", LContext(config: config, loggedIn: loginBool))
|
|
}
|
|
|
|
// Return website status when /status/:url is loaded
|
|
app.get("status", ":url") { req -> [String: String] in
|
|
// Get URL from request parameters
|
|
let url = URL(string: "http://\(req.parameters.get("url")!)")
|
|
// Configure URLSession
|
|
let config = URLSessionConfiguration.default
|
|
// Set request timeouts to 5s, then assume offline
|
|
config.timeoutIntervalForRequest = 5
|
|
config.timeoutIntervalForResource = 5
|
|
// Declare statusDict for storing website status
|
|
var statusDict: [String:String] = [:]
|
|
// Declare URLSession request using URL from request parameters
|
|
var headReq = URLRequest(url: url!)
|
|
// Set HEAD request
|
|
headReq.httpMethod = "HEAD"
|
|
// Set request timeout to 5s, then assume offline
|
|
headReq.timeoutInterval = 5
|
|
// Create DispatchSemaphore to block thread until request is resolved and status stored
|
|
let semaphore = DispatchSemaphore(value: 0)
|
|
// Run Async URLSession dataTask
|
|
URLSession.shared.dataTask(with: headReq, completionHandler: { (_, response, error) in
|
|
// If the response is valid
|
|
if let httpURLResponse = response as? HTTPURLResponse {
|
|
// Store status code in statusDict
|
|
statusDict["code"] = String(httpURLResponse.statusCode)
|
|
// Store website status in statusDict
|
|
statusDict["down"] = "false"
|
|
}
|
|
// Signal DispatchSemaphore to stop blocking
|
|
semaphore.signal()
|
|
}).resume()
|
|
// Wait for semaphore signal
|
|
semaphore.wait()
|
|
// If statusDict is empty, return code 0, down true. Otherwise, return statusdict
|
|
return statusDict.count > 0 ? statusDict : ["code": "0", "down": "true"]
|
|
}
|
|
|
|
// Render login page on GET request to /login
|
|
app.get("login") { req -> EventLoopFuture<View> in
|
|
// Get data from config file at /Resources/config.json
|
|
let fileData = try String(contentsOfFile: "\(app.directory.resourcesDirectory)/config.json").data(using: .utf8)
|
|
// Decode JSON file to Config struct
|
|
let config: Config = try! JSONDecoder().decode(Config.self, from: fileData!)
|
|
// Render home.leaf with config as context
|
|
return req.view.render("login", LContext(config: config, loggedIn: false))
|
|
}
|
|
|
|
// Verify credentials and log in on POST request to /login
|
|
app.post("login") { req -> Response in
|
|
// Decode POST request data into Login struct
|
|
let data = try req.content.decode(Login.self)
|
|
// Get data from config file at /Resources/config.json
|
|
let fileData = try String(contentsOfFile: "\(app.directory.resourcesDirectory)/config.json").data(using: .utf8)
|
|
// Decode JSON file to Config struct
|
|
let config: Config = try! JSONDecoder().decode(Config.self, from: fileData!)
|
|
// Get password from POST request data
|
|
let loginPassData = data.password?.data(using: .utf8)
|
|
// Hash password in POST data using SHA256.hash() from SwiftCrypto
|
|
let loginPassHash = SHA256.hash(data: loginPassData ?? "".data(using: .utf8)!)
|
|
// Convert hash to string
|
|
let stringHash = loginPassHash.map { String(format: "%02hhx", $0) }.joined()
|
|
// If hash in config matches provided hash
|
|
if stringHash == config.passwordHash {
|
|
// Set logged in to true in session
|
|
req.session.data["loggedIn"] = "true"
|
|
// Redirect back to /
|
|
return try req.redirect(to: "/")
|
|
} else {
|
|
// If hashes do not match, return unauthorized error
|
|
throw Abort(.unauthorized)
|
|
}
|
|
}
|
|
|
|
// Destroy session on GET request to logout
|
|
app.get("logout") { req -> Response in
|
|
// Destroy session
|
|
req.session.destroy()
|
|
// Redirect back to /
|
|
return try req.redirect(to: "/")
|
|
}
|
|
|
|
|
|
}
|