func CreateMachine(c *echo.Context) error {
rt := &machine{}
err := utils.ParseJSONBody(c, rt)
if err != nil {
log.Error(err.Error())
return err
}
machineType, err := vms.Type(rt.Type)
if err != nil {
return errors.MachineTypeNotFound
}
attr := vm.MachineAttributes{
Type: machineType,
Name: rt.Name,
Username: rt.Username,
Password: rt.AdminPassword,
Ip: rt.Ip,
}
m, err := vms.Create(attr)
if err != nil {
log.Error(err)
return errors.UnableToCreateTheMachine
}
rt, err = getSerializableMachine(m.Id())
if err != nil {
return err
}
return utils.JSON(c, http.StatusOK, rt)
}
func GetUser(c *echo.Context) error {
userId := c.Param("id")
if userId == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "User id needed to retrieve account informations",
},
},
})
}
user, err := users.GetUser(userId)
if err != nil {
return err
}
if user == nil {
return c.JSON(http.StatusNotFound, hash{
"error": [1]hash{
hash{
"detail": "User Not Found",
},
},
})
}
return utils.JSON(c, http.StatusOK, user)
}
// Add a new log entry to the database
func Add(c *echo.Context) error {
history := histories.History{}
err := utils.ParseJSONBody(c, &history)
if err != nil {
return err
}
if history.UserId == "" || history.ConnectionId == "" || history.StartDate == "" || history.EndDate == "" {
log.Error("Missing one or several parameters to create entry")
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "Missing parameters",
},
},
})
}
err = utils.ParseJSONBody(c, &history)
newHistory, err := histories.CreateHistory(
history.UserId,
history.ConnectionId,
history.StartDate,
history.EndDate,
)
if err != nil {
return err
}
return utils.JSON(c, http.StatusCreated, newHistory)
}
func List(c *echo.Context) error {
user := c.Get("user").(*users.User)
winUser, err := user.WindowsCredentials()
if err != nil {
return err
}
sessionList, err := sessions.GetAll(winUser.Sam)
if err != nil {
log.Error(err)
return utils.JSON(c, http.StatusInternalServerError, hash{
"error": [1]hash{
hash{
"detail": err.Error(),
},
},
})
}
var response = make([]hash, len(sessionList))
for i, val := range sessionList {
res := hash{
"id": val.Id,
"type": "session",
"attributes": val,
}
response[i] = res
}
return c.JSON(http.StatusOK, hash{"data": response})
}
func FindAll(c *echo.Context) error {
drivers, err := machinedrivers.FindAll()
if err != nil {
return err
}
return utils.JSON(c, http.StatusOK, drivers)
}
func Update(c *echo.Context) error {
u := users.User{}
err := utils.ParseJSONBody(c, &u)
if err != nil {
return nil
}
user, err := users.GetUser(u.GetID())
if err != nil {
return apiErrors.UserNotFound
}
if u.Password == "" {
return apiErrors.InvalidRequest.Detail("The password field is missing.")
}
err = users.UpdateUserPassword(user.GetID(), u.Password)
if err != nil {
log.Error(err)
return apiErrors.InternalError.Detail("Unable to update the password.")
}
return utils.JSON(c, http.StatusOK, user)
}
// Get a list of all the log entries of the database
func List(c *echo.Context) error {
histories, err := histories.FindAll()
if err != nil {
return err
}
return utils.JSON(c, http.StatusOK, histories)
}
func GetMachine(c *echo.Context) error {
m, err := getSerializableMachine(c.Param("id"))
if err != nil {
return err
}
return utils.JSON(c, http.StatusOK, m)
}
func Get(c *echo.Context) error {
user := c.Get("user").(*users.User)
if c.Query("me") == "true" {
return utils.JSON(c, http.StatusOK, user)
}
if !user.IsAdmin {
return apiErrors.AdminLevelRequired
}
users, err := users.FindUsers()
if err != nil {
log.Error(err)
return apiErrors.InternalError.Detail("Unable to retreive the user list")
}
return utils.JSON(c, http.StatusOK, users)
}
func Update(c *echo.Context) error {
updatedUser := users.User{}
user := c.Get("user").(*users.User)
err := utils.ParseJSONBody(c, &updatedUser)
if err != nil {
return apiErrors.InvalidRequest
}
currentUser, err := users.GetUser(updatedUser.GetID())
if err != nil {
return apiErrors.UserNotFound
}
if !user.IsAdmin && (updatedUser.GetID() != user.GetID()) {
return apiErrors.Unauthorized.Detail("You can only update your account")
}
if updatedUser.IsAdmin != currentUser.IsAdmin {
if currentUser.Id == user.GetID() {
return apiErrors.Unauthorized.Detail("You cannot grant administration rights")
}
err = users.UpdateUserPrivilege(updatedUser.GetID(), updatedUser.IsAdmin)
if err != nil {
log.Error(err)
return apiErrors.InternalError.Detail("Unable to update the rank")
}
} else if updatedUser.Password != "" {
err = users.UpdateUserPassword(updatedUser.GetID(), updatedUser.Password)
if err != nil {
log.Error(err)
return apiErrors.InternalError.Detail("Unable to update the password")
}
} else if updatedUser.Email != currentUser.Email {
err = users.UpdateUserEmail(updatedUser.GetID(), updatedUser.Email)
if err != nil {
log.Error(err)
return apiErrors.InternalError.Detail("Unable to update the email")
}
} else if updatedUser.FirstName != currentUser.FirstName {
err = users.UpdateUserFirstName(updatedUser.GetID(), updatedUser.FirstName)
if err != nil {
log.Error(err)
return apiErrors.InternalError.Detail("Unable to update the first name")
}
} else if updatedUser.LastName != currentUser.LastName {
err = users.UpdateUserLastName(updatedUser.GetID(), updatedUser.LastName)
if err != nil {
log.Error(err)
return apiErrors.InternalError.Detail("Unable to update the last name")
}
} else {
return apiErrors.InvalidRequest.Detail("No field sent")
}
return utils.JSON(c, http.StatusOK, &updatedUser)
}
func PublishApplication(c *echo.Context) error {
app := &apps.Application{}
err := utils.ParseJSONBody(c, app)
if err != nil {
return err
}
user := c.Get("user").(*users.User)
err = apps.PublishApp(user, app)
if err != nil {
return err
}
return utils.JSON(c, http.StatusOK, app)
}
func Machines(c *echo.Context) error {
machines, err := vms.Machines()
if err != nil {
log.Error(err)
return errors.UnableToRetrieveMachineList
}
res := make([]*machine, len(machines))
for i, val := range machines {
m := machine{}
m.Name, err = val.Name()
if err != nil {
log.Error(err)
return errors.UnableToRetrieveMachineList
}
m.Id = val.Id()
status, err := val.Status()
if err != nil {
log.Error(err)
return errors.UnableToRetrieveMachineList
}
m.Platform = val.Platform()
m.Status = vm.StatusToString(status)
progress, err := val.Progress()
if err != nil {
log.Errorf("Unable to get machine progress: %s", err)
} else {
m.Progress = int(progress)
}
ip, _ := val.IP()
if ip != nil {
m.Ip = ip.String()
}
res[i] = &m
}
return utils.JSON(c, http.StatusOK, res)
}
func Post(c *echo.Context) error {
u := users.User{}
err := utils.ParseJSONBody(c, &u)
if err != nil {
return err
}
if u.Email == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "email is missing",
},
},
})
}
if u.FirstName == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "first-name is missing",
},
},
})
}
if u.LastName == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "last-name is missing",
},
},
})
}
if u.Password == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "password is missing",
},
},
})
}
newUser, err := users.CreateUser(
true,
u.Email,
u.FirstName,
u.LastName,
u.Password,
false,
)
switch err {
case users.UserDuplicated:
return c.JSON(http.StatusConflict, hash{
"error": [1]hash{
hash{
"detail": err.Error(),
},
},
})
case users.UserNotCreated:
return err
}
winpass := utils.RandomString(8) + "s4D+"
sam, err := ldap.AddUser(newUser.Id, winpass)
if err != nil {
return err
}
err = users.UpdateUserAd(newUser.Id, sam, winpass, "intra.localdomain.com")
if err != nil {
return err
}
return utils.JSON(c, http.StatusCreated, newUser)
}
func ChangeAppName(c *echo.Context) error {
appId := c.Param("app_id")
if len(appId) < 1 {
return c.JSON(http.StatusBadRequest, hash{
"error": "App id must be specified",
})
}
var Name struct {
Data struct {
Attributes struct {
DisplayName string `json:"display-name"`
}
}
}
body, err := ioutil.ReadAll(c.Request().Body)
if err != nil {
return err
}
err = json.Unmarshal(body, &Name)
if err != nil {
log.Errorf("Unable to parse body request: %s", err.Error())
return err
}
if len(Name.Data.Attributes.DisplayName) < 1 {
log.Errorf("No name provided")
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "No name provided",
},
},
})
}
exists, err := apps.AppExists(appId)
if err != nil {
log.Errorf("Unable to check app existence: %s", err.Error())
return err
}
if !exists {
return c.JSON(http.StatusNotFound, hash{
"error": [1]hash{
hash{
"detail": "App not found",
},
},
})
}
err = apps.ChangeName(appId, Name.Data.Attributes.DisplayName)
if err == apps.FailedNameChange {
return c.JSON(http.StatusInternalServerError, hash{
"error": [1]hash{
hash{
"detail": err.Error(),
},
},
})
}
application, err := apps.GetApp(appId)
if application == nil {
return c.JSON(http.StatusNotFound, hash{
"error": [1]hash{
hash{
"detail": "Application Not Found",
},
},
})
}
return utils.JSON(c, http.StatusOK, application)
}
func PatchMachine(c *echo.Context) error {
b := &machine{}
err := utils.ParseJSONBody(c, b)
if err != nil {
log.Error(err)
return errors.UnableToUpdateMachineStatus
}
m, err := vms.Machine(b.Id)
if err != nil {
log.Error(err)
return errors.UnableToUpdateMachineStatus
}
status, err := m.Status()
if err != nil {
log.Error(err)
return errors.UnableToUpdateMachineStatus
}
switch b.Status {
case "up":
if status != vms.StatusDown {
return errors.UnableToUpdateMachineStatus
}
err = m.Start()
if err != nil {
log.Error(err)
return errors.UnableToUpdateMachineStatus
}
case "down":
if status != vms.StatusUp {
return errors.UnableToUpdateMachineStatus
}
err = m.Stop()
if err != nil {
log.Error(err)
return errors.UnableToUpdateMachineStatus
}
default:
log.Error(err)
return errors.UnableToUpdateMachineStatus
}
m, err = vms.Machine(m.Id())
if err != nil {
log.Error(err)
return errors.UnableToUpdateMachineStatus
}
rt, err := getSerializableMachine(m.Id())
if err != nil {
log.Error(err)
return errors.UnableToUpdateMachineStatus
}
return utils.JSON(c, http.StatusOK, rt)
}