// Info endpoint api mocking
// curl http://127.0.0.1:8888/api/v0/malware/info/1234567890abcdef
func infoAPI(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
hash := vars["hash"]
if hash == "1234567890abcdef" {
a := ArtRes{
Ssdeep: "1234567890",
Md5: "1234567890",
Sha1: "1234567890",
Sha256: "1234567890",
Sha512: "1234567890",
Format: "pe",
Symbols: []string{"a", "b"},
Imports: []string{"a", "b"},
Sections: []string{"a", "b"},
Arch: "amd64",
Strain: "",
Mutations: []string{"0987654321", "5647382910", "4536789013"},
Siblings: []string{""},
}
v := DataRes{
302,
"Asset already analysed",
a,
}
json.NewEncoder(w).Encode(v)
return
} else {
v := SearchRes{404, "This element does not exist", ""}
json.NewEncoder(w).Encode(v)
return
}
}
func queryServerIDRetriever(w http.ResponseWriter, ids []string) {
s := make(chan map[string]string, len(ids))
db.ServerDB.GetHostsAndGameFromIDAPIQuery(s, ids)
hostsgames := <-s
if len(hostsgames) == 0 {
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(models.GetDefaultServerList()); err != nil {
writeJSONEncodeError(w, err)
}
return
}
serverlist, err := steam.Query(hostsgames)
if err != nil {
setNotFoundAndLog(w, err)
if err := json.NewEncoder(w).Encode(models.GetDefaultServerList()); err != nil {
writeJSONEncodeError(w, err)
return
}
return
}
if err := json.NewEncoder(w).Encode(serverlist); err != nil {
writeJSONEncodeError(w, err)
logger.LogWebError(err)
}
}
func TodoShow(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
var todoId int
var err error
if todoId, err = strconv.Atoi(vars["todoId"]); err != nil {
panic(err)
}
todo := RepoFindTodo(todoId)
if todo.Id > 0 {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(todo); err != nil {
panic(err)
}
return
}
// If we didn't find it, 404
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusNotFound)
if err := json.NewEncoder(w).Encode(jsonErr{Code: http.StatusNotFound, Text: "Not Found"}); err != nil {
panic(err)
}
}
func (s *ESAPIV0) UpdateIndexSettings(name string, settings map[string]interface{}) error {
log.Debug("update index: ", name, settings)
cleanSettings(settings)
url := fmt.Sprintf("%s/%s/_settings", s.Host, name)
if _, ok := settings["settings"].(map[string]interface{})["index"]; ok {
if set, ok := settings["settings"].(map[string]interface{})["index"].(map[string]interface{})["analysis"]; ok {
log.Debug("update static index settings: ", name)
staticIndexSettings := getEmptyIndexSettings()
staticIndexSettings["settings"].(map[string]interface{})["index"].(map[string]interface{})["analysis"] = set
Post(fmt.Sprintf("%s/%s/_close", s.Host, name), s.Auth, "", s.HttpProxy)
body := bytes.Buffer{}
enc := json.NewEncoder(&body)
enc.Encode(staticIndexSettings)
bodyStr, err := Request("PUT", url, s.Auth, &body, s.HttpProxy)
if err != nil {
log.Error(bodyStr, err)
panic(err)
return err
}
delete(settings["settings"].(map[string]interface{})["index"].(map[string]interface{}), "analysis")
Post(fmt.Sprintf("%s/%s/_open", s.Host, name), s.Auth, "", s.HttpProxy)
}
}
log.Debug("update dynamic index settings: ", name)
body := bytes.Buffer{}
enc := json.NewEncoder(&body)
enc.Encode(settings)
_, err := Request("PUT", url, s.Auth, &body, s.HttpProxy)
return err
}
func listContainersHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
address := r.URL.Query().Get(":address")
if address != "" {
node, err := mainDockerProvisioner.Cluster().GetNode(address)
if err != nil {
return err
}
hasAccess := permission.Check(t, permission.PermNodeRead,
permission.Context(permission.CtxPool, node.Metadata["pool"]))
if !hasAccess {
return permission.ErrUnauthorized
}
containerList, err := mainDockerProvisioner.listContainersByHost(address)
if err != nil {
return err
}
return json.NewEncoder(w).Encode(containerList)
}
appName := r.URL.Query().Get(":appname")
a, err := app.GetByName(appName)
if err != nil {
return err
}
hasAccess := permission.Check(t, permission.PermNodeRead,
permission.Context(permission.CtxPool, a.Pool))
if !hasAccess {
return permission.ErrUnauthorized
}
containerList, err := mainDockerProvisioner.listContainersByApp(appName)
if err != nil {
return err
}
return json.NewEncoder(w).Encode(containerList)
}
func DeleteAbility(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
urlParams := mux.Vars(r)
strID := urlParams["id"]
ability := models.Ability{}
id, err := strconv.Atoi(strID)
if err != nil {
// handle error
message := models.APIMessage{"Id format invalid"}
json.NewEncoder(w).Encode(message)
} else {
database.DB.First(&ability, id)
if ability.ID == 0 {
message := models.APIMessage{"Ability not found"}
json.NewEncoder(w).Encode(message)
} else {
database.DB.Delete(&ability)
message := models.APIMessage{"Ability successful deleted"}
json.NewEncoder(w).Encode(message)
}
}
}
/*
Test with this curl command:
curl -H "Content-Type: application/json" -d '{"name":"New Todo"}' http://localhost:8080/todos
*/
func TodoCreate(w http.ResponseWriter, r *http.Request) {
Cors(w)
var todo Todo
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &todo); err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
panic(err)
}
}
t := RepoCreateTodo(todo)
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusCreated)
if err := json.NewEncoder(w).Encode(t); err != nil {
panic(err)
}
}
func (c *ApiConnection) Login(w http.ResponseWriter, r *http.Request) {
email := r.FormValue("email")
password := r.FormValue("password")
connection := c.dbConnection.LoginWithCredentials(email, password)
userID := fmt.Sprintf("%x", string(connection.Id))
log.Println(userID)
if connection != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusOK)
userMap := make(map[string]string)
userMap["token"] = userID
if err := json.NewEncoder(w).Encode(userMap); err != nil {
panic(err)
}
return
}
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusNotFound)
if err := json.NewEncoder(w).Encode(jsonErr{Code: http.StatusNotFound, Text: "Not Found"}); err != nil {
panic(err)
}
}
/*
Test with this curl command:
*/
func TaskCreate(w http.ResponseWriter, r *http.Request) {
var v Node
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &v); err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusBadRequest) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
panic(err)
}
return
}
uuid := uuid()
tasks[uuid.ID] = &v
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusAccepted)
if err := json.NewEncoder(w).Encode(uuid); err != nil {
panic(err)
}
return
}
func getCLHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
detail, err := getCLDetail(r.FormValue("cl"))
if err != nil {
skutil.ReportError(w, r, err, "")
return
}
if detail.Issue == 0 {
// Return successful empty response, since the user could still be typing.
if err := json.NewEncoder(w).Encode(map[string]interface{}{}); err != nil {
skutil.ReportError(w, r, err, "Failed to encode JSON")
}
return
}
patch, err := getCLPatch(detail, 0)
if err != nil {
skutil.ReportError(w, r, err, "")
return
}
clData, err := gatherCLData(detail, patch)
if err != nil {
skutil.ReportError(w, r, err, "")
return
}
if err = json.NewEncoder(w).Encode(clData); err != nil {
skutil.ReportError(w, r, err, "")
return
}
}
func (s *DockerServer) taskList(w http.ResponseWriter, r *http.Request) {
s.swarmMut.Lock()
defer s.swarmMut.Unlock()
if s.swarm == nil {
w.WriteHeader(http.StatusNotAcceptable)
return
}
filtersRaw := r.FormValue("filters")
var filters map[string][]string
json.Unmarshal([]byte(filtersRaw), &filters)
if filters == nil {
json.NewEncoder(w).Encode(s.tasks)
return
}
var ret []*swarm.Task
for i, task := range s.tasks {
var srvName string
for _, srv := range s.services {
if task.ServiceID == srv.ID {
srvName = srv.Spec.Name
break
}
}
if inFilter(filters["id"], task.ID) ||
inFilter(filters["service"], task.ServiceID) ||
inFilter(filters["service"], srvName) ||
inFilter(filters["node"], task.NodeID) ||
inFilter(filters["desired-state"], string(task.DesiredState)) {
ret = append(ret, s.tasks[i])
}
}
json.NewEncoder(w).Encode(ret)
}
func (a *App) GET_Nodes(w http.ResponseWriter, r *http.Request) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
params := r.URL.Query()
admin_state_str := params.Get("state")
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_NODES)
var nodes models.Nodes
if admin_state_str == "" {
if err := collection.Find(nil).All(&nodes); err != nil {
util.HttpResponse(w, http.StatusInternalServerError, err.Error())
logger.Get().Error("Error getting the nodes list. error: %v", err)
return
}
} else {
nodes, err = getNodesWithState(w, admin_state_str)
if err != nil {
util.HttpResponse(w, http.StatusInternalServerError, err.Error())
logger.Get().Error("Error getting the nodes list. error: %v", err)
return
}
}
if len(nodes) == 0 {
json.NewEncoder(w).Encode([]models.Node{})
} else {
json.NewEncoder(w).Encode(nodes)
}
}
// SubmissionCreate accepts POST request
func SubmissionCreate(w http.ResponseWriter, r *http.Request) {
var submission Submission
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &submission); err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
panic(err)
}
}
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusCreated)
if err := json.NewEncoder(w).Encode(submission); err != nil {
panic(err)
}
}
func GetPhoto(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
var photoId string
var ok bool
if photoId, ok = vars["photoId"]; !ok {
panic("cannot find {photoId}")
}
photo, err := persistence.RepoFindPhoto(photoId)
if err == nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(photo); err != nil {
panic(err)
}
return
}
// If we didn't find it, 404
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusNotFound)
if err := json.NewEncoder(w).Encode(responseErrors.JSONErr{Code: http.StatusNotFound, Text: "Not Found"}); err != nil {
panic(err)
}
}
func TodoCreate(w http.ResponseWriter, r *http.Request) {
db := InitDB()
var todo Todo
response := TodoResponse{Error: true}
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
spew.Dump(body)
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
if err := json.Unmarshal(body, &todo); err != nil {
w.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
panic(err)
}
} else {
db.Create(&todo)
response.Error = false
response.Data = &todo
}
json.NewEncoder(w).Encode(response)
}
//handlers for municipality
func MunicipalIndex(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
var lat float64
var lon float64
var err error
if lat, err = strconv.ParseFloat(vars["lat"], 64); err != nil {
panic(err)
}
if lon, err = strconv.ParseFloat(vars["lon"], 64); err != nil {
panic(err)
}
m := RepoFindCourtByAddress(lat, lon)
if m.Id >= 0 {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(m); err != nil {
panic(err)
}
return
}
// If we didn't find it, 404
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusNotFound)
if err := json.NewEncoder(w).Encode(jsonErr{Code: http.StatusNotFound, Text: "Not Found"}); err != nil {
panic(err)
}
}
func (c *ChatService) onGetChatHistory(w http.ResponseWriter, req *http.Request, p httprouter.Params) {
log.Println("Get chat history...")
groupId := p.ByName("id")
queryParams := req.URL.Query()
var offset uint = 0
var limit uint = 20
if o, err := strconv.ParseUint(queryParams.Get("offset"), 10, 32); err == nil {
offset = uint(o)
}
if l, err := strconv.ParseUint(queryParams.Get("limit"), 10, 32); err == nil {
limit = uint(l)
}
log.Println("Limit =", limit, "Offset =", offset)
log, err := c.chatStore.GetMessagesFor(groupId, offset, limit)
if err == nil {
response := make(map[string]interface{})
response["limit"] = limit
response["offset"] = offset
response["messages"] = log
response["id"] = groupId
json.NewEncoder(w).Encode(response)
} else {
w.WriteHeader(http.StatusInternalServerError)
json.NewEncoder(w).Encode(ErrorMessage{
Error: err.Error(),
})
}
}
//handlers for Ticket
func TicketIndex(w http.ResponseWriter, r *http.Request) {
params := r.URL.Query()
driver_licenses, ok := params["driver_license"]
if ok {
driver_license := string(driver_licenses[0])
tic := RepoFindTicketByDriverLicenseNumber(driver_license)
if tic.Id > 0 {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(tic); err != nil {
panic(err)
}
} else {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusNotFound)
if err := json.NewEncoder(w).Encode(jsonErr{Code: http.StatusNotFound, Text: "Not Found"}); err != nil {
panic(err)
}
}
} else {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(gTickets); err != nil {
panic(err)
}
}
}
func CreateAbility(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
var newAbility models.NewAbility
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048676))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &newAbility); err != nil {
message := models.APIMessage{"Input format invalid"}
json.NewEncoder(w).Encode(message)
} else {
var ability models.Ability
ability.Name = newAbility.Name
database.DB.Create(&ability)
if database.DB.NewRecord(ability) {
message := models.APIMessage{"Error creating ability"}
json.NewEncoder(w).Encode(message)
} else {
json.NewEncoder(w).Encode(ability)
}
}
}
func CourtCreate(w http.ResponseWriter, r *http.Request) {
var court Court
var err error
//Check if malicious user is trying to overload the server
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &court); err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
panic(err)
}
}
if court, err = RepoCreateCourt(court); err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
panic(err)
}
}
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusCreated)
if err := json.NewEncoder(w).Encode(court); err != nil {
panic(err)
}
}
func ServerCreate(w http.ResponseWriter, r *http.Request) {
if authentication.IsAllowed(w, r) {
var server pulp.Server
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
logger.Log("could not read POST body, Error: "+err.Error(), logger.ERROR)
}
if err := r.Body.Close(); err != nil {
logger.Log("could not close POST body, Error: "+err.Error(), logger.ERROR)
}
if err := json.Unmarshal(body, &server); err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
logger.Log("could not json/encode error, Error: "+err.Error(), logger.ERROR)
}
}
session, collection := db.InitServerCollection()
defer session.Close()
server.Added = time.Now()
err = collection.Insert(server)
if err != nil {
logger.Log("could not insert server to DB, Error: "+err.Error(), logger.ERROR)
}
w.Header().Set("Content-Type", "application/json; charset=UTF=8")
w.WriteHeader(http.StatusCreated)
if err := json.NewEncoder(w).Encode(server); err != nil {
panic(err)
}
}
}
func openLogFile(fileName, fileType string, compress bool, rotateMode int, maxSize int64) (*jsonFile, error) {
fullName := fileName + fileType
if _, err := os.Stat(fullName); err == nil {
os.Rename(fullName, fileName+".01"+fileType)
fullName = fileName + ".02" + fileType
} else if _, err := os.Stat(fileName + ".01" + fileType); err == nil {
for fileId := 1; true; fileId++ {
fullName = fileName + fmt.Sprintf(".%02d", fileId) + fileType
if _, err := os.Stat(fullName); err != nil {
break
}
}
}
file, err := os.OpenFile(fullName, os.O_WRONLY|os.O_CREATE, 0755)
if err != nil {
return nil, err
}
jsonfile := &jsonFile{file: file, curFile: fullName, rotateMode: rotateMode}
if compress {
jsonfile.bufio = bufio.NewWriter(jsonfile.file)
jsonfile.gzip = gzip.NewWriter(jsonfile.bufio)
jsonfile.json = json.NewEncoder(jsonfile.gzip)
} else {
jsonfile.bufio = bufio.NewWriter(jsonfile.file)
jsonfile.json = json.NewEncoder(jsonfile.bufio)
}
if jsonfile.rotateMode == ROTATE_BY_SIZE && maxSize == 0 {
jsonfile.maxSize = 1024 * 1024 * 1024 * 25
} else {
jsonfile.maxSize = maxSize
}
return jsonfile, nil
}
// addNodeHandler can provide an machine and/or register a node address.
// If register flag is true, it will just register a node.
// It checks if node address is valid and accessible.
func addNodeHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
params, err := unmarshal(r.Body)
if err != nil {
return err
}
if templateName, ok := params["template"]; ok {
params, err = iaas.ExpandTemplate(templateName)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
}
}
pool := params["pool"]
if pool == "" {
w.WriteHeader(http.StatusBadRequest)
return json.NewEncoder(w).Encode(map[string]string{"error": "pool is required"})
}
if !permission.Check(t, permission.PermNodeCreate, permission.Context(permission.CtxPool, pool)) {
return permission.ErrUnauthorized
}
isRegister, _ := strconv.ParseBool(r.URL.Query().Get("register"))
if !isRegister {
canCreateMachine := permission.Check(t, permission.PermMachineCreate,
permission.Context(permission.CtxIaaS, params["iaas"]))
if !canCreateMachine {
return permission.ErrUnauthorized
}
}
response, err := mainDockerProvisioner.addNodeForParams(params, isRegister)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
response["error"] = err.Error()
}
return json.NewEncoder(w).Encode(response)
}
// Login login user
func (c AuthController) Login(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
model := &models.LoginModel{}
if err := json.NewDecoder(r.Body).Decode(model); err != nil {
c.Logger.Log("AuthController login json decode.", err)
json.NewEncoder(w).Encode(models.Response{ErrorCode: 1})
return
}
conn := factory.NewDatabase().Connection()
if err := conn.Open(); err != nil {
c.Logger.Log("AuthController login could not open db connection.", err)
json.NewEncoder(w).Encode(models.Response{ErrorCode: 2})
return
}
defer conn.Close()
user, err := factory.NewDatabase().User(conn).FindByEmail(model.Email)
if err != nil || user == nil {
c.Logger.Log("AuthController login find by email.", err)
json.NewEncoder(w).Encode(models.Response{ErrorCode: 3})
return
}
if user.Email != strings.ToLower(model.Email) || user.Password != model.Password {
c.Logger.Log("AuthController login invalid username or password.", nil)
json.NewEncoder(w).Encode(models.Response{ErrorCode: 4})
return
}
json.NewEncoder(w).Encode(models.Response{Data: user, Success: true})
}
func CreateUser(w http.ResponseWriter, r *http.Request) {
ctx := getContext(r)
if name, ok := ctx.jsonBody["name"]; ok {
if password, ok := ctx.jsonBody["password"]; ok {
err := db.SaveUser(name.(string), password.(string))
if err != nil {
res := responses.UnknownError(err.Error())
w.WriteHeader(res.Code)
json.NewEncoder(w).Encode(res)
return
} else {
res := responses.Success{Ok: true}
w.Header().Add("Content-Type", "application/json")
w.WriteHeader(201)
json.NewEncoder(w).Encode(res)
return
}
}
}
res := responses.BadRequest(`You must send a JSON body with "name" and "password".`)
w.WriteHeader(res.Code)
json.NewEncoder(w).Encode(res)
}
func addFoxToStorage(w http.ResponseWriter, r *http.Request, status int, uuid string) {
var fox Fox
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
util.SendHeaders(w)
if err := json.Unmarshal(body, &fox); err != nil {
w.WriteHeader(422)
if err := json.NewEncoder(w).Encode(Error{Code: 422, Message: err.Error()}); err != nil {
panic(err)
}
return
}
w.WriteHeader(status)
s := StoreFox(fox, uuid)
if err := json.NewEncoder(w).Encode(s); err != nil {
log.Critical("Error encoding the UUID")
panic(err)
}
}
/**
* GET A LANGUAGE BY ITS ID
*/
func goGetLanguageById(w http.ResponseWriter, r *http.Request) {
//parse array of input from request message
vars := mux.Vars(r)
//get id input
var langId string
langId = vars["languageId"]
//execute get method
lang := getLanguageById(langId)
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
if lang.Id != "" {
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(lang); err != nil {
panic(err)
}
return
}
// If we didn't find it, 404
w.WriteHeader(http.StatusNotFound)
if err := json.NewEncoder(w).Encode(jsonErr{Code: http.StatusNotFound, Text: "Not Found"}); err != nil {
panic(err)
}
}
func Register(w http.ResponseWriter, r *http.Request) {
user := models.User{}
if r.FormValue("displayName") != "" {
user.DisplayName = r.FormValue("displayName")
} else {
user.DisplayName = "NULL"
}
_email := r.FormValue("email")
if _email != "" {
user.Email.Scan(_email)
}
if r.FormValue("password") != "" {
user.Password = r.FormValue("password")
} else {
user.Password = "******"
}
createUserToken(&user)
if err := repository.CreateUser(&user).Error; err != nil {
w.WriteHeader(http.StatusForbidden)
json.NewEncoder(w).Encode(err)
return
}
log.Println(user)
json.NewEncoder(w).Encode(user)
}
func PostsCreateHandler(rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
// fmt.Fprintln(rw, "posts index")
//String id;
var todo Todo
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &todo); err != nil {
rw.Header().Set("Content-Type", "application/json; charset=UTF-8")
rw.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(rw).Encode(err); err != nil {
panic(err)
}
}
/*
todos := Todos{
Todo{Name: r.FormValue("name")},
Todo{Name: "Host meetup"},
}*/
var newtodo NewTodo
newtodo.Greeting = "Hello, " + todo.Name + "!"
json.NewEncoder(rw).Encode(newtodo)
}
func TestMain(m *testing.M) {
generateMetrics()
masterRouter := http.NewServeMux()
masterRouter.HandleFunc("/metrics/snapshot", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(masterMetrics)
})
masterTestServer = httptest.NewServer(masterRouter)
slaveRouter := http.NewServeMux()
slaveRouter.HandleFunc("/metrics/snapshot", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(slaveMetrics)
})
slaveRouter.HandleFunc("/monitor/statistics", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode([]map[string]interface{}{slaveTaskMetrics})
})
slaveTestServer = httptest.NewServer(slaveRouter)
rc := m.Run()
masterTestServer.Close()
slaveTestServer.Close()
os.Exit(rc)
}