//Get a specific project
func getProject(request router.Request) (int, []byte) {
projectDTO, err := GetProjectDTOFromGAE(request.GetPathParams()["project_id"], request.GetContext())
if err != nil && strings.Contains(err.Error(), "no such entity") {
log.Errorf(request.GetContext(), "Error retriving Project: %v", err)
return http.StatusNotFound, []byte("Project Not Found")
} else if err != nil {
log.Errorf(request.GetContext(), "Error retriving project: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
} else {
project, err := projectDTO.GetProject()
if err != nil {
log.Infof(request.GetContext(), "Error %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
projectJSON, err := json.MarshalIndent(project, "", " ")
if err != nil {
log.Infof(request.GetContext(), "Error %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
return http.StatusOK, projectJSON
}
}
func registerUser(request router.Request) (int, []byte) {
var registration UserResgistration
err := json.Unmarshal(request.GetContent(), ®istration)
//Check for correct desrialization
if err != nil {
log.Errorf(request.GetContext(), "error: %v", err)
return http.StatusBadRequest, []byte(err.Error())
}
//check if username already exists
if IsUsernameAvailable(registration.UserName, request.GetContext()) {
// generate a random salt with default rounds of complexity
salt, _ := bcrypt.Salt()
// hash and verify a password with random salt
hash, _ := bcrypt.Hash(registration.Password)
var user = UserData{registration.UserName, nil, salt, hash}
err = SaveUserToGAE(user, request.GetContext())
if err != nil {
log.Errorf(request.GetContext(), "error: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
} else {
return http.StatusOK, nil
}
} else {
return http.StatusConflict, []byte("Username not avaiable")
}
}
//Get all subscriptions for a given project
func getSubscriptions(request router.Request) (int, []byte) {
subscriptions, err := GetSubscriptionsFromGAE(request.GetPathParams()["project_id"], request.GetContext())
if err != nil {
log.Errorf(request.GetContext(), "Error retriving Subscriptions: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
subscriptionBytes, err := json.MarshalIndent(subscriptions, "", " ")
if err != nil {
log.Errorf(request.GetContext(), "Error retriving Subscriptions: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
return http.StatusOK, subscriptionBytes
}
//Get a specific subscription for a project
func getSubscription(request router.Request) (int, []byte) {
subscription, err := GetSubscriptionFromGAE(request.GetPathParams()["project_id"], request.GetPathParams()["subscription_id"], request.GetContext())
if err != nil && strings.Contains(err.Error(), "no such entity") {
return http.StatusNotFound, []byte("Subscription not found")
} else if err != nil {
log.Errorf(request.GetContext(), "Error retriving Subsciption: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
} else {
subscriptionBytes, err := json.MarshalIndent(subscription, "", " ")
if err == nil {
return http.StatusOK, subscriptionBytes
} else {
log.Errorf(request.GetContext(), "Errror %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
}
}
//Get all projects
//TODO: Check for Admin to return all
//TODO: If not admin only return current users projects
func getAllProjects(request router.Request) (int, []byte) {
projectDTOs, err := GetProjectDTOsFromGAE(request.GetContext())
if err != nil {
log.Errorf(request.GetContext(), "Errorf retriving project: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
} else {
//Convert to Projects
var projects []Project
for _, projectDTO := range projectDTOs {
var project, err = projectDTO.GetProject()
if err == nil {
projects = append(projects, project)
} else {
return http.StatusInternalServerError, []byte(err.Error())
}
}
projectBytes, err := json.MarshalIndent(projects, "", " ")
if err != nil {
log.Errorf(request.GetContext(), "Errorf retriving Projects: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
return http.StatusOK, projectBytes
}
}
//TODO: Check if project is enabled
func checkProject(request router.Request) (int, []byte) {
//Get The project
projectId := request.GetPathParams()["project_id"]
projectObj, getProjectStatus, getProjectError := getProject(projectId, request.GetContext())
//Get Alerts
alerts, getAlertStatus, getAlertsError := getAlerts(projectId, request.GetContext())
//Get Subscriptions
subscriptions, getSubsStatus, getSubsError := getSubscriptions(projectId, request.GetContext())
if getProjectError == nil && getAlertsError == nil && getSubsError == nil {
//Check Alerts
return processAlerts(projectObj, alerts, subscriptions, request.GetContext())
} else {
return processError(getProjectStatus, getAlertStatus, getSubsStatus,
getProjectError, getAlertsError, getSubsError)
}
}
//Get all alerts for a given project
func getAlerts(request router.Request) (int, []byte) {
alerts, err := GetAlertsFromGAE(request.GetPathParams()["project_id"], request.GetContext())
if err != nil {
log.Errorf(request.GetContext(), "Error retriving alerts: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
} else {
alertBytes, err := json.MarshalIndent(alerts, "", " ")
if err != nil {
log.Errorf(request.GetContext(), "Error retriving Alerts: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
return http.StatusOK, alertBytes
}
}
func getTick(request router.Request) (int, []byte) {
query := datastore.NewQuery(project.PROJECT_KEY)
projects := make([]project.ProjectDTO, 0)
_, err := query.GetAll(request.GetContext(), &projects)
if err != nil {
log.Errorf(request.GetContext(), "Error retriving projects: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
} else {
for _, project := range projects {
task := taskqueue.NewPOSTTask("/rest/internal/check/"+project.Name, nil)
if _, err := taskqueue.Add(request.GetContext(), task, "alertCheckQueue"); err != nil {
log.Errorf(request.GetContext(), "Error posting to task queue: %v", err)
}
}
return http.StatusOK, nil
}
}
func getUsers(request router.Request) (int, []byte) {
users, err := GetUsersFromGAE(request.GetContext())
if err != nil {
log.Errorf(request.GetContext(), "Error retriving user: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
} else {
userBytes, err := json.MarshalIndent(users, "", " ")
if err == nil {
return http.StatusOK, userBytes
} else {
log.Errorf(request.GetContext(), "Errror %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
}
}
//Create/Update an subscription for the given project
func postSubscription(request router.Request) (int, []byte) {
var subscription Subscription
err := json.Unmarshal(request.GetContent(), &subscription)
if err != nil {
log.Errorf(request.GetContext(), "error: %v", err)
return http.StatusBadRequest, []byte(err.Error())
}
subscription.Project = request.GetPathParams()["project_id"]
err = SaveSubscriptionToGAE(subscription, request.GetContext())
if err != nil {
log.Errorf(request.GetContext(), "error: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
return http.StatusOK, nil
}
//Get a specific alert for a project
func getAlert(request router.Request) (int, []byte) {
alert, err := GetAlertFromGAE(request.GetPathParams()["project_id"], request.GetPathParams()["alert_id"], request.GetContext())
if err != nil && strings.Contains(err.Error(), "no such entity") {
log.Errorf(request.GetContext(), "Error retriving Alert: %v", err)
return http.StatusNotFound, []byte("Alert not found")
} else if err != nil {
log.Errorf(request.GetContext(), "Error retriving alert: %v", err)
return http.StatusBadRequest, []byte(err.Error())
} else {
var alertJSON, err = json.MarshalIndent(alert, "", " ")
if err == nil {
return http.StatusOK, alertJSON
} else {
log.Errorf(request.GetContext(), "Errror %v", err)
return http.StatusBadRequest, []byte(err.Error())
}
}
}
//Create/Update an alert for the given project
func postAlert(request router.Request) (int, []byte) {
var alert Alert
err := json.Unmarshal(request.GetContent(), &alert)
if err != nil {
log.Infof(request.GetContext(), "error: %v", err)
return http.StatusBadRequest, []byte(err.Error())
}
//TODO Check Project Exists
alert.Project = request.GetPathParams()["project_id"]
err = SaveAlertToGAE(alert, request.GetContext())
if err != nil {
log.Infof(request.GetContext(), "error: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
return http.StatusOK, nil
}
//Create/Update a project
//TODO: Check Admin/User Permissions
//TODO: Check required config present
//TODO: If create add to user project list
func updateProject(request router.Request) (int, []byte) {
var project ProjectStruct
err := json.Unmarshal(request.GetContent(), &project)
if err != nil {
log.Infof(request.GetContext(), "error: %v", err)
return http.StatusBadRequest, []byte(err.Error())
}
projectDTO, err := project.GetDTO()
if err != nil {
return http.StatusInternalServerError, []byte(err.Error())
}
err = SaveProjectDTOToGAE(projectDTO, request.GetContext())
if err != nil {
log.Infof(request.GetContext(), "error: %v", err)
return http.StatusInternalServerError, []byte(err.Error())
}
return http.StatusOK, nil
}