Golang DB.Delete Examples

Example #1

File: routes.go Project: danihodovic/lendico

//Deletes a certain account from the db
func deleteAccountHandler(db *gorm.DB, acc account, rendr render.Render) {
	if err := db.Delete(&acc).Error; err != nil {
		rendr.Text(http.StatusInternalServerError, err.Error())
	} else {
		rendr.Text(http.StatusOK, "Account deleted")
	}
}

Example #2

File: media.go Project: RadioTerminal/podcaster

func MediaDelete(db gorm.DB, r render.Render, params martini.Params) {
	var media models.Media
	if err := db.First(&media, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Media not found"})
		return
	}
	db.Delete(media)
	r.JSON(http.StatusNoContent, nil)
}

Example #3

File: project_controller.go Project: jerryclinesmith/notabbble

func ProjectDelete(db gorm.DB, r render.Render, params martini.Params) {
	var project models.Project
	if err := db.First(&project, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Project not found"})
		return
	}
	db.Delete(project)
	r.JSON(http.StatusNoContent, nil)
}

Example #4

File: group.go Project: RadioTerminal/podcaster

func GroupDelete(db gorm.DB, r render.Render, params martini.Params) {
	var group models.Group
	if err := db.First(&group, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Group not found"})
		return
	}
	db.Delete(group)
	r.JSON(http.StatusNoContent, nil)
}

Example #5

File: dao.go Project: itpkg/base

func (p *AuthDao) DelRole(db *gorm.DB, user uint, name string, resource_type string, resource_id uint) {
	role := p.getRole(db, name, resource_type, resource_id)
	for _, pe := range role.Permissions {
		if pe.UserID == user {
			db.Delete(&pe)
			return
		}
	}

}

Example #6

File: routes.go Project: danihodovic/backend-test

//Deletes a user based on a given path `id` param
func deleteUserHandler(db *gorm.DB, params martini.Params, ren render.Render) {
	u, err := findUserFromIDParam(db, params["id"])
	if err != nil {
		ren.Text(err.toMartiniRender())
		return
	}
	if db.Delete(&u).Error != nil {
		ren.Text(http.StatusInternalServerError, err.Error())
		return
	}
	ren.Text(http.StatusOK, fmt.Sprintf("User with id: %d was deleted", u.ID))
}

Example #7

File: server.go Project: danihodovic/go-martini-gorm-angular-todo

func deleteTodoHandler(params martini.Params, rendr render.Render, db *gorm.DB) {
	id, err := strconv.Atoi(params["id"])
	if err != nil {
		panic(err)
	}

	t, err := findTodo(db, &todo{ID: id})
	if err != nil {
		rendr.Text(http.StatusBadRequest, err.Error())
		return
	}

	db.Delete(&t)
	rendr.JSON(http.StatusOK, t)
}

Example #8

File: task.go Project: seesawlabs/ivan-kirichenko-exercise

// GetDeleteTaskHandler creates HTTP handler for Delete Task operation
func GetDeleteTaskHandler(db *gorm.DB) echo.HandlerFunc {
	return func(c *echo.Context) error {
		id, err := strconv.ParseInt(c.Param("id"), 10, 64)
		if err != nil {
			return c.JSON(http.StatusBadRequest, NewApiError(err.Error()))
		}

		task := model.Task{Id: id}
		if err := db.Delete(&task).Error; err != nil {
			return c.JSON(http.StatusInternalServerError, NewApiError(err.Error()))
		}

		return c.JSON(http.StatusOK, task)
	}
}

Example #9

File: repo.go Project: umschlag/umschlag-api

// BeforeDelete invokes required actions before deletion.
func (u *Repo) BeforeDelete(tx *gorm.DB) error {
	tags := Tags{}

	tx.Model(
		u,
	).Related(
		&tags,
	)

	for _, tag := range tags {
		if err := tx.Delete(tag).Error; err != nil {
			return err
		}
	}

	return nil
}

Example #10

File: transform.go Project: twitchyliquid64/CNC

func upgrade_v3(db gorm.DB) {
	// Hash the passwords
	logging.Info("Migrating 2 => 3")

	var unhashed []user.AuthenticationMethod
	db.Where("method_type = ?", user.AUTH_PASSWD).Find(&unhashed)

	for i := 0; i < len(unhashed); i++ {
		hashed, err := user.HashedPasswordAuth(unhashed[i].Value)
		if err != nil {
			logging.Error("data", "Could not transform password. ID ", unhashed[i].ID)
		} else {
			hashed.UserID = unhashed[i].UserID

			db.Create(&hashed)
			db.Delete(&unhashed[i])
		}
	}
}

Example #11

File: space_setting.go Project: ali-abdalla/humhub-api

func DeleteSpaceSetting(db gorm.DB, router *gin.Engine) {

	router.DELETE("/space_setting/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			space_setting := &model.SpaceSetting{
				SpaceSettingId: model.SpaceSettingId{Id: id},
			}
			if err := db.First(space_setting).Error; err == nil {
				db.Delete(space_setting)
				c.AbortWithStatus(http.StatusOK)
			} else {
				c.AbortWithStatus(http.StatusNotFound)
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}

Example #12

File: wall_entry.go Project: ali-abdalla/humhub-api

func DeleteWallEntry(db gorm.DB, router *gin.Engine) {

	router.DELETE("/wall_entry/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			wall_entry := &model.WallEntry{
				WallEntryId: model.WallEntryId{Id: id},
			}
			if err := db.First(wall_entry).Error; err == nil {
				db.Delete(wall_entry)
				c.AbortWithStatus(http.StatusOK)
			} else {
				c.AbortWithStatus(http.StatusNotFound)
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}

Example #13

File: group_admin.go Project: ali-abdalla/humhub-api

func DeleteGroupAdmin(db gorm.DB, router *gin.Engine) {

	router.DELETE("/group_admin/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			group_admin := &model.GroupAdmin{
				GroupAdminId: model.GroupAdminId{Id: id},
			}
			if err := db.First(group_admin).Error; err == nil {
				db.Delete(group_admin)
				c.AbortWithStatus(http.StatusOK)
			} else {
				c.AbortWithStatus(http.StatusNotFound)
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}

Example #14

File: module_enabled.go Project: ali-abdalla/humhub-api

func DeleteModuleEnabled(db gorm.DB, router *gin.Engine) {

	router.DELETE("/module_enabled/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			module_enabled := &model.ModuleEnabled{
				ModuleEnabledId: model.ModuleEnabledId{Id: id},
			}
			if err := db.First(module_enabled).Error; err == nil {
				db.Delete(module_enabled)
				c.AbortWithStatus(http.StatusOK)
			} else {
				c.AbortWithStatus(http.StatusNotFound)
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}

Example #15

File: user_http_session.go Project: ali-abdalla/humhub-api

func DeleteUserHttpSession(db gorm.DB, router *gin.Engine) {

	router.DELETE("/user_http_session/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			user_http_session := &model.UserHttpSession{
				UserHttpSessionId: model.UserHttpSessionId{Id: id},
			}
			if err := db.First(user_http_session).Error; err == nil {
				db.Delete(user_http_session)
				c.AbortWithStatus(http.StatusOK)
			} else {
				c.AbortWithStatus(http.StatusNotFound)
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}

Example #16

File: like.go Project: ali-abdalla/humhub-api

func DeleteLike(db gorm.DB, router *gin.Engine) {

	router.DELETE("/like/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			like := &model.Like{
				LikeId: model.LikeId{Id: id},
			}
			if err := db.First(like).Error; err == nil {
				db.Delete(like)
				c.AbortWithStatus(http.StatusOK)
			} else {
				c.AbortWithStatus(http.StatusNotFound)
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}

Example #17

File: api.go Project: jinjing750629/rds-broker

// DeleteInstance
// URL: /v2/service_instances/:id
// Request:
// {
//   "service_id": "service-id-here"
//   "plan_id":    "plan-id-here"
// }
func DeleteInstance(p martini.Params, r render.Render, brokerDb *gorm.DB, s *Settings) {
	instance := Instance{}

	brokerDb.Where("uuid = ?", p["id"]).First(&instance)

	if instance.Id == 0 {
		r.JSON(http.StatusNotFound, Response{"Instance not found"})
		return
	}

	var plan *Plan
	plan = FindPlan(instance.PlanId)

	if plan == nil {
		r.JSON(http.StatusBadRequest, Response{"The plan requested does not exist"})
		return
	}
	// Get the correct database logic depending on the type of plan. (shared vs dedicated)
	db, err := s.InitializeAdapter(plan, brokerDb)
	if err != nil {
		desc := "There was an error deleting the instance. Error: " + err.Error()
		r.JSON(http.StatusInternalServerError, Response{desc})
		return
	}
	var status DBInstanceState
	// Delete the database instance.
	if status, err = db.DeleteDB(&instance); status == InstanceNotGone {
		desc := "There was an error deleting the instance."
		if err != nil {
			desc = desc + " Error: " + err.Error()
		}
		r.JSON(http.StatusInternalServerError, Response{desc})
		return
	}
	brokerDb.Delete(&instance)
	r.JSON(http.StatusOK, Response{"The instance was deleted"})
}

Example #18

File: crud.go Project: GoSteelProgrammers/talk-review-orms

func main() {
	var (
		db   gorm.DB
		user *User
	)

	user = new(User)

	db = SetupDb()

	//START CODE OMIT
	db.Save(&User{FirstName: "John", LastName: "Doe", Age: 25})
	PrintTable(db)

	db.First(user, 1)

	user.FirstName = "James"
	db.Save(user)
	PrintTable(db)

	db.Delete(user)
	PrintTable(db)
	//END CODE OMIT
}

Example #19

File: releases.go Project: hobeone/gonab

func deleteBinary(tx *gorm.DB, dbbin *types.Binary) error {
	// Delete Parts
	err := tx.Where("binary_id = ?", dbbin.ID).Delete(types.Part{}).Error
	if err != nil {
		return err
	}

	// Delete segments.
	partids := make([]int64, len(dbbin.Parts))
	for i, p := range dbbin.Parts {
		partids[i] = p.ID
	}
	err = tx.Where("part_id in (?)", partids).Delete(types.Segment{}).Error
	if err != nil {
		return err
	}

	// Delete binary
	err = tx.Delete(dbbin).Error
	if err != nil {
		return err
	}
	return nil
}

Example #20

File: join_table_test.go Project: carriercomm/empire

func (*PersonAddress) Delete(db *gorm.DB, sources ...interface{}) error {
	return db.Delete(&PersonAddress{}).Error
}

Example #21

File: domains.go Project: brianz/empire

func domainsDestroy(db *gorm.DB, domain *Domain) error {
	return db.Delete(domain).Error
}

Example #22

File: feed.go Project: asvins/core

func (e *FeedEvent) Delete(db *gorm.DB) error {
	return db.Delete(e).Error
}

Example #23

File: join_table_test.go Project: roshats/gorm

func (*PersonAddress) Delete(handler gorm.JoinTableHandlerInterface, db *gorm.DB, sources ...interface{}) error {
	return db.Delete(&PersonAddress{}).Error
}

Example #24

File: handler.go Project: theplant/resources

// New creates a new resource that exposes the DBModel returned by
// `single` as a HTTP API. `collection` should return an array of the
// same type as `single`.
func New(db *gorm.DB, single func() DBModel, collection func() interface{}, linker func(id uint) string) Resource {

	r := Resource{}

	r.Collection = func(ctx *gin.Context, owner DBModel) {
		c := collection()
		if err := db.Model(owner).Related(c).Error; err != nil && err != gorm.ErrRecordNotFound {
			panic(err)
		}

		ctx.JSON(http.StatusOK, c)
	}

	r.Post = func(ctx *gin.Context, user User, parent DBModel) {
		s := single()
		if ctx.BindJSON(s) != nil {
			ctx.JSON(HTTPStatusUnprocessableEntity, errToJSON(ErrRequestMissingAttrs))
			return
		}
		if err := s.SetOwner(user); err != nil {
			panic(err)
		}
		if err := s.SetParent(parent); err != nil {
			panic(err)
		}

		if err := db.Create(s).Error; err != nil {
			if reflect.TypeOf(err) == AcceptableError {
				ctx.JSON(HTTPStatusUnprocessableEntity, errToJSON(err))
			} else {
				panic(err)
			}
		}

		ctx.Header("Location", absURL(ctx.Request, linker(s.GetID())))
		ctx.JSON(http.StatusCreated, s)
	}

	r.Get = func(ctx *gin.Context, s DBModel) {
		ctx.JSON(http.StatusOK, s)
	}

	r.Patch = func(ctx *gin.Context, s DBModel) {
		newS := single()
		if ctx.BindJSON(newS) != nil {
			ctx.JSON(HTTPStatusUnprocessableEntity, errToJSON(ErrRequestMissingAttrs))
			return
		}

		if err := db.Model(s).Updates(newS).Error; err != nil {
			panic(err)
		}

		ctx.JSON(http.StatusOK, newS)
	}

	r.Delete = func(ctx *gin.Context, s DBModel) {
		if err := db.Delete(s).Error; err != nil {
			panic(err)
		}

		ctx.AbortWithStatus(http.StatusNoContent)
	}

	r.ProvideModelForKey = func(key string) func(ModelHandler) gin.HandlerFunc {
		return func(handler ModelHandler) gin.HandlerFunc {
			return func(ctx *gin.Context) {
				id := ctx.Param(key)

				if !regexpID.MatchString(id) {
					ctx.AbortWithError(http.StatusNotFound, gorm.ErrRecordNotFound)
					return
				}

				s := single()
				if err := db.Where("id = ?", id).First(s).Error; err == gorm.ErrRecordNotFound {
					ctx.AbortWithError(http.StatusNotFound, gorm.ErrRecordNotFound)
					return
				} else if err != nil {
					panic(err)
				}

				handler(ctx, s)
			}
		}
	}

	r.ProvideModel = r.ProvideModelForKey("id")

	return r
}

Example #25

File: apps.go Project: brianz/empire

// appsDestroy destroys an app.
func appsDestroy(db *gorm.DB, app *App) error {
	return db.Delete(app).Error
}

Example #26

File: box.go Project: asvins/operations

func (b *Box) Delete(db *gorm.DB) error {
	return db.Delete(b).Error
}

Example #27

File: blog.go Project: bishen/blog

func Delete(params martini.Params, db *gorm.DB) string {
	db.Delete(models.Blog{}, params["id"])
	return "<script>alert('删除完成');window.history.back()</script>"
}

Example #28

File: pack.go Project: asvins/operations

func (p *Pack) Delete(db *gorm.DB) error {
	return db.Delete(p).Error
}

Example #29

File: ssl.go Project: yourchanges/empire

func certificatesDestroy(db *gorm.DB, cert *Certificate) error {
	return db.Delete(cert).Error
}

Example #30

File: main.go Project: oblank/go-todo

func (uc ItemController) DeleteItem(db gorm.DB, id int64) string {
	obj := model.Element{ID: id}
	db.Delete(&obj)
	return ""
}