// EditOrganization modifes an organization record
//
// PATCH /orgs/:org
//
func (c *OrganizationsController) EditOrganization(ctx *gin.Context) {
var json bindings.UpdateOrganization
err := ctx.Bind(&json)
if err != nil {
helpers.JSONResponseValidationFailed(ctx, err)
return
}
org := getOrganizationFromContext(ctx)
orgService, err := services.NewOrganizationService(org, getCurrentUser(ctx))
if err != nil {
if c.WriteTrace {
c.Logger.Printf("Failed to create OrganizationService for org: %v", org)
}
helpers.JSONResponseInternalServerError(ctx, err)
return
}
org, err = orgService.UpdateOrganization(json)
if err != nil {
helpers.JSONResponseInternalServerError(ctx, err)
return
}
helpers.JSONResponseObject(ctx, presenters.OrganizationPresenter(org))
}
// AddOrUpdateMembership adds the user as member to the organization. The authenticated user must be an organization owner.
// If the user is not yet a member of the organization, the membership will be pending until the user accepts the invitation. Otherwise, if
// the user is already a member of the organization, this method will update the role of the member within the organization.
//
// PUT /orgs/:org/memberships/:username
//
func (c *OrganizationsController) AddOrUpdateMembership(ctx *gin.Context) {
var json bindings.AddUpdateMembership
err := ctx.Bind(&json)
if err != nil {
helpers.JSONResponseValidationFailed(ctx, err)
return
}
org := getOrganizationFromContext(ctx)
orgService, err := services.NewOrganizationService(org, getCurrentUser(ctx))
if err != nil {
if c.WriteTrace {
c.Logger.Printf("Failed to create OrganizationService for org: %v", org)
}
helpers.JSONResponseInternalServerError(ctx, err)
return
}
// retrieves the user that was found based on username parameter
user := getUserFromContext(ctx)
member, err := orgService.AddOrUpdateMembership(user, json)
if err != nil {
if err == services.ErrNotAnOrganizationOwner {
helpers.JSONForbidden(ctx, err.Error())
} else {
helpers.JSONResponseInternalServerError(ctx, err)
}
return
}
helpers.JSONResponseObject(ctx, presenters.MemberPresenter(member))
}
// EditMyOrganizationMembership edit your organization membership for the authenticated user
//
// PATCH /user/memberships/orgs/:org
//
func (c *UsersController) EditMyOrganizationMembership(ctx *gin.Context) {
var json bindings.EditMyMembership
err := ctx.Bind(&json)
if err != nil {
helpers.JSONResponseValidationFailed(ctx, err)
}
user := getCurrentUser(ctx)
accountService, err := services.NewAccountService(user)
if err != nil {
if c.WriteTrace {
c.Logger.Printf("Failed to create AccountService for user: %v", user)
}
helpers.JSONResponseInternalServerError(ctx, err)
return
}
org := getOrganizationFromContext(ctx)
member, err := accountService.EditMyMembership(org.ID, json)
if err != nil {
if err == ErrNotFound {
helpers.JSONErrorf(ctx, http.StatusNotFound, "No membership found for this organization")
return
}
helpers.JSONResponseInternalServerError(ctx, err)
return
}
helpers.JSONResponseObject(ctx, presenters.MemberPresenter(member))
}
// DeleteEmail deletes email address for current user
//
// DELETE /user/emails
//
func (c *UsersController) DeleteEmail(ctx *gin.Context) {
var json bindings.UpdateEmail
err := ctx.Bind(&json)
if err != nil {
helpers.JSONResponseValidationFailed(ctx, err)
}
user := getCurrentUser(ctx)
accountService, err := services.NewAccountService(user)
if err != nil {
if c.WriteTrace {
c.Logger.Printf("Failed to create AccountService for user: %v", user)
}
helpers.JSONResponseInternalServerError(ctx, err)
return
}
err = accountService.RemoveEmailAddress(json)
if err != nil {
helpers.JSONResponseInternalServerError(ctx, err)
return
}
helpers.JSONResponseOK(ctx, user.ListOfEmails())
}
// ChangePassword updates the password for authenticated user
//
// POST /change/password
//
// Params:
//
// type ChangePassword struct {
// OldPassword string `json:"old_password" binding:"required"`
// NewPassword string `json:"new_password" binding:"required"`
// }
//
func (c *UsersController) ChangePassword(ctx *gin.Context) {
var json bindings.ChangePassword
if err := ctx.Bind(&json); err != nil {
helpers.JSONResponseValidationFailed(ctx, err)
return
}
user := getCurrentUser(ctx)
accountService, err := services.NewAccountService(user)
if err != nil {
if c.WriteTrace {
c.Logger.Printf("Failed to create AccountService for user: %v", user)
}
helpers.JSONResponseInternalServerError(ctx, err)
return
}
ok, err := accountService.ChangePassword(json)
if err != nil {
helpers.JSONResponseInternalServerError(ctx, err)
return
}
if !ok {
helpers.JSONErrorf(ctx, http.StatusBadRequest, "Failed to change password for user: %s", user.Username)
return
}
helpers.JSONResponseOK(ctx)
}
// RefreshToken generates a new set of authentication tokens for the user to consume the API
//
// GET /token/refresh
//
func (c *SessionController) RefreshToken(ctx *gin.Context) {
var json bindings.RefreshToken
err := ctx.Bind(&json)
if err != nil {
// Missing refresh token
helpers.JSONResponseValidationFailed(ctx, err)
return
}
//TODO: fix this
// user, err := services.Auth.ValidateRefreshToken(json.Token)
// if err != nil {
// helpers.JSONForbidden(ctx, "Unable to validate refresh token")
// return
// }
//
// tokenFields, err := services.Auth.GenerateToken(user)
// if err != nil {
// helpers.JSONResponseInternalServerError(ctx, err)
// return
// }
//
// helpers.JSONResponseOK(ctx, gin.H{
// "user": presenters.UserPresenter(user),
// "tokens": tokenFields,
// })
}
// AuthorizeUser performs the authentication for the API user
//
// GET /authorize
//
func (c *SessionController) AuthorizeUser(ctx *gin.Context) {
var json bindings.AuthorizeUser
err := ctx.Bind(&json)
if err != nil {
// Missing authentication credentials
helpers.JSONResponseValidationFailed(ctx, err)
return
}
user, err := services.Auth.AuthorizeUser(json)
if err != nil {
helpers.JSONForbidden(ctx, "Invalid authentication credentials")
return
}
tokenFields, err := services.Auth.GenerateToken(user)
if err != nil {
helpers.JSONResponseInternalServerError(ctx, err)
return
}
helpers.JSONResponseOK(ctx, gin.H{
"user": presenters.UserPresenter(user),
"tokens": tokenFields,
})
}
// RegisterNewUser creates a new user account
//
// POST /users
//
func (c *UsersController) RegisterNewUser(ctx *gin.Context) {
var json bindings.RegisterNewUser
err := ctx.Bind(&json)
if err != nil {
helpers.JSONResponseValidationFailed(ctx, err)
return
}
user, err := services.RegisterNewUser(json)
if err != nil {
if err == services.ErrNamespaceAlreadyExists {
helpers.JSONErrorf(ctx, http.StatusBadRequest, "Username already exists")
} else {
helpers.JSONResponseInternalServerError(ctx, err)
}
return
}
helpers.JSONResponseObject(ctx, presenters.UserPresenter(user))
}
// CreateOrganization creates a new Organization and makes the current authenticated user the owner
//
// POST /orgs
//
func (c *OrganizationsController) CreateOrganization(ctx *gin.Context) {
var json bindings.CreateOrganization
err := ctx.Bind(&json)
if err != nil {
helpers.JSONResponseValidationFailed(ctx, err)
return
}
// creates the organization and set the current user as part of Owners Team
org, err := services.CreateOrganization(json, getCurrentUser(ctx))
if err != nil {
if err == services.ErrNamespaceAlreadyExists {
helpers.JSONErrorf(ctx, http.StatusBadRequest, "Organization name already exists")
} else {
helpers.JSONResponseInternalServerError(ctx, err)
}
return
}
helpers.JSONResponseObject(ctx, presenters.OrganizationPresenter(org))
}