Example #1
0
// AfterSave invokes required actions after persisting.
func (u *Repo) AfterSave(db *gorm.DB) (err error) {
	tags := Tags{}

	err = db.Model(
		u,
	).Related(
		&tags,
	).Error

	if err != nil {
		return err
	}

	for _, tag := range tags {
		err = db.Save(
			tag,
		).Error

		if err != nil {
			return err
		}
	}

	return nil
}
Example #2
0
func (pp *PurchaseProduct) UpdateValue(db *gorm.DB, value float64) error {
	pps, err := pp.Retreive(db)
	if err != nil {
		return err
	}

	if len(pps) != 1 {
		return errors.New("record not found")
	}

	*pp = pps[0]

	if err := VerifyUpdatePurchaseProduct(db, pp); err != nil {
		return err
	}

	err = db.Model(pp).UpdateColumn(PurchaseProduct{Value: value}).Error
	if err != nil {
		return err
	}

	pp.Value = value

	return nil
}
Example #3
0
// AfterSave invokes required actions after persisting.
func (u *Registry) AfterSave(db *gorm.DB) (err error) {
	orgs := Orgs{}

	err = db.Model(
		u,
	).Related(
		&orgs,
	).Error

	if err != nil {
		return err
	}

	for _, org := range orgs {
		err = db.Save(
			org,
		).Error

		if err != nil {
			return err
		}
	}

	return nil
}
Example #4
0
func New(db *gorm.DB) i18n.Backend {
	db.AutoMigrate(&Translation{})
	if err := db.Model(&Translation{}).AddUniqueIndex("idx_translations_key_with_locale", "locale", "key").Error; err != nil {
		fmt.Printf("Failed to create unique index for translations key & locale, got: %v\n", err.Error())
	}
	return &Backend{DB: db}
}
Example #5
0
func FacultiesDepartments(db *gorm.DB) ([]json_models.FacultiesDepartments, error) {
	var result []json_models.FacultiesDepartments

	err := db.Model(&models.Faculties{}).Select("id as faculty_id, short_name as faculty_name").Scan(&result).Error

	if err != nil {
		return nil, err
	}

	for i, faculty := range result {
		var records []models.Departments
		err := db.Preload("Faculty").Where("faculty_id = ?", faculty.FacultyId).Find(&records).Error
		if err != nil {
			return nil, err
		}

		if len(records) != 0 {
			for _, record := range records {
				val := json_models.Department{Id: record.Id, Name: record.Name}
				result[i].Departments = append(result[i].Departments, val)
			}
		} else {
			result[i].Departments = []json_models.Department{}
		}
	}

	return result, nil
}
Example #6
0
func (pp *PurchaseProduct) UpdateQuantity(db *gorm.DB, quantity int) error {
	pps, err := pp.Retreive(db)
	if err != nil {
		return err
	}

	if len(pps) != 1 {
		return errors.New("record not found")
	}

	*pp = pps[0]

	if err := VerifyUpdatePurchaseProduct(db, pp); err != nil {
		return err
	}

	err = db.Model(pp).UpdateColumn(PurchaseProduct{Quantity: quantity}).Error
	if err != nil {
		return err
	}

	pp.Quantity = quantity

	return nil
}
Example #7
0
File: dao.go Project: itpkg/base
func (p *SettingDao) Set(db *gorm.DB, key string, val interface{}, enc bool) error {
	dt, err := web.ToBits(val)
	if err != nil {
		db.Rollback()
		return err
	}

	if enc {
		dt, err = p.Aes.Encode(dt)
		if err != nil {
			db.Rollback()
			return err
		}
	}

	st := Setting{ID: key}
	var cn int
	db.Model(st).Count(&cn)
	if cn == 0 {
		st.Val = dt
		db.Create(&st)
	} else {
		db.Model(&st).Updates(Setting{Val: dt})
	}
	return nil
}
Example #8
0
File: dao.go Project: itpkg/base
func (p *AuthDao) getRole(db *gorm.DB, name string, resource_type string, resource_id uint) *Role {
	role := Role{}
	db.FirstOrCreate(&role, Role{Name: name, ResourceType: resource_type, ResourceID: resource_id})

	db.Model(&role).Related(&role.Permissions)
	return &role
}
Example #9
0
func UpdateTask(db *gorm.DB, data models.Tasks) error {
	err := db.Model(data).Updates(data).Error
	if err != nil {
		return err
	}
	return nil
}
Example #10
0
// AfterSave invokes required actions after persisting.
func (u *Org) AfterSave(db *gorm.DB) (err error) {
	repos := Repos{}

	err = db.Model(
		u,
	).Related(
		&repos,
	).Error

	if err != nil {
		return err
	}

	for _, repo := range repos {
		err = db.Save(
			repo,
		).Error

		if err != nil {
			return err
		}
	}

	return nil
}
Example #11
0
func FeedForGroupGet(db gorm.DB, params martini.Params, res http.ResponseWriter) (int, string) {
	podcast := models.Group{}
	var media = []models.Media{}
	if err := db.Where(&models.Group{Slug: params["slug"]}).First(&podcast).Error; err != nil {
		res.Header().Set(ContentType, PlainType)
		return http.StatusNotFound, "Feed not found"
	}
	db.Model(&podcast).Order("created_at desc").Limit(15).Related(&media)

	tpl, err := template.New("xml_feed").Funcs(template.FuncMap{"short": ShortenString}).Parse(xml_feed_t)
	if err != nil {
		res.Header().Set(ContentType, PlainType)
		return http.StatusInternalServerError, "Generating XML failed"
	}
	data := Feed{&podcast, &media}
	buf := new(bytes.Buffer)
	err = tpl.Execute(buf, data)
	log.Println(err)
	if err != nil {
		res.Header().Set(ContentType, PlainType)
		return http.StatusInternalServerError, "Generating XML failed"
	}
	res.Header().Set(ContentType, RSSType)
	return http.StatusOK, buf.String()
}
Example #12
0
// GetRepo retrieves a specific repo from the database.
func (db *data) GetRepo(id string) (*model.Repo, *gorm.DB) {
	var (
		record = &model.Repo{}
		query  *gorm.DB
	)

	if match, _ := regexp.MatchString("^([0-9]+)$", id); match {
		val, _ := strconv.ParseInt(id, 10, 64)

		query = db.Where(
			"id = ?",
			val,
		)
	} else {
		query = db.Where(
			"slug = ?",
			id,
		)
	}

	res := query.Model(
		&record,
	).Preload(
		"Org",
	).Preload(
		"Org.Registry",
	).Preload(
		"Tags",
	).First(
		&record,
	)

	return record, res
}
Example #13
0
// SaveBinary will efficently save a binary and it's associated parts.
// Having to do this for efficency is probably a good sign that I should just
// use sqlx or something.
func saveBinary(tx *gorm.DB, b *types.Binary) error {
	var txerr error
	if tx.NewRecord(b) {
		parts := b.Parts
		b.Parts = []types.Part{}
		txerr = tx.Save(b).Error
		if txerr != nil {
			return txerr
		}
		pids := make([]int64, len(parts))
		for i, p := range parts {
			pids[i] = p.ID
		}
		txerr = tx.Model(types.Part{}).Where("id IN (?)", pids).Updates(map[string]interface{}{"binary_id": b.ID}).Error
		if txerr != nil {
			return txerr
		}
	} else {
		pids := make([]int64, len(b.Parts))
		for i, p := range b.Parts {
			pids[i] = p.ID
		}
		txerr = tx.Model(types.Part{}).Where("id IN (?)", pids).Updates(map[string]interface{}{"binary_id": b.ID}).Error
		if txerr != nil {
			return txerr
		}

	}
	return nil
}
Example #14
0
func CreateClient(db gorm.DB, options *Options) (id int64) {

	var c Client

	db.Where(
		&Client{
			Hostname:  options.Hostname,
			Interface: options.Interface,
			MacAddr:   options.InterfaceData.HardwareAddr.String(),
			Ip:        options.Ip,
		},
	).First(&c)

	if c.Id != 0 {
		db.Model(&c).Update(
			&Client{
				LastSeen: time.Now().Unix(),
			},
		)
	} else {
		c.LastSeen = time.Now().Unix()
		c.Hostname = options.Hostname
		c.MacAddr = options.InterfaceData.HardwareAddr.String()
		c.Interface = options.Interface
		c.Ip = options.Ip

		db.Table("clients").Create(&c)
	}

	options.Client = &c

	return c.Id
}
Example #15
0
// Retreive purchase from database
func (purch *Purchase) Retreive(db *gorm.DB) ([]Purchase, error) {
	var purchs []Purchase
	err := db.Where(purch).Find(&purchs).Error
	if err != nil {
		return nil, err
	}

	for i, p := range purchs {
		order := Order{}
		order.ID = p.OrderId

		if err := db.Model(&p).Related(&order, "OrderId").Error; err != nil {
			return nil, err
		}

		pproducts := []PurchaseProduct{}
		if err := db.Model(order).Related(&pproducts, "Pproducts").Error; err != nil {
			fmt.Println("[ERROR] ", err.Error())
			return nil, err
		}
		order.Pproducts = pproducts

		p.PurschaseOrder = order
		purchs[i] = p
	}

	return purchs, err
}
Example #16
0
//Migrate db:migrate
func (p *Engine) Migrate(db *gorm.DB) {
	db.AutoMigrate(
		&Article{}, &Tag{}, &Comment{}, &Attachment{},
	)

	db.Model(&Tag{}).AddUniqueIndex("idx_cms_tag_name_lang", "name", "lang")

}
Example #17
0
// Conclude purchase
func (purch *Purchase) Conclude(db *gorm.DB) error {
	rowsAffected := db.Model(purch).Where("confirmed_at != ?", 0).UpdateColumn(Purchase{ConcludedAt: int(time.Now().Unix())}).RowsAffected
	if rowsAffected != 1 {
		return errors.New("[ERROR] Purchase must be confirmed before conlcuded")
	}

	return nil
}
Example #18
0
func FacultyGroupsIds(db *gorm.DB, faculty_id int64, year int) []int64 {
	var groups []int64
	err := db.Model(&models.Groups{}).Where(&models.Groups{FacultyId: faculty_id, Year: year}).Pluck("id", &groups).Error
	if err != nil {
		panic(err)
	}
	return groups
}
Example #19
0
//Stop the task
func (t *Task) Stop(txn *gorm.DB) error {
	if t.CronID != 0 {
		entryID := cron.EntryID(t.CronID)
		MasterCron.Remove(entryID)
		utils.Log.Infof("The task %s has been stopped", t.ID)
		return txn.Model(t).UpdateColumn("cron_id", 0).Error
	}
	return nil
}
Example #20
0
func GroupUpdate(db gorm.DB, r render.Render, params martini.Params, updatedGroup models.Group) {
	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.Model(&group).Update(&updatedGroup)
	r.JSON(http.StatusOK, group)
}
Example #21
0
func MediaUpdate(db gorm.DB, r render.Render, params martini.Params, updatedMedia models.Media) {
	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.Model(&media).Update(&updatedMedia)
	r.JSON(http.StatusOK, media)
}
Example #22
0
// CreateTUFTable creates the DB table for TUFFile
func CreateTUFTable(db gorm.DB) error {
	// TODO: gorm
	query := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&TUFFile{})
	if query.Error != nil {
		return query.Error
	}
	query = db.Model(&TUFFile{}).AddUniqueIndex(
		"idx_gun", "gun", "role", "version")
	return query.Error
}
Example #23
0
func MediaPlay(db gorm.DB, r render.Render, params martini.Params) {
	media := models.Media{}
	id, _ := strconv.Atoi(params["id"])
	if err := db.First(&media, id).Error; err != nil {
		r.Error(http.StatusNotFound)
		return
	}
	db.Model(&media).Update(&models.Media{Played: media.Played + 1})
	r.Redirect(media.Url)
}
Example #24
0
func MediaForGroupGet(db gorm.DB, r render.Render, params martini.Params) {
	podcast := models.Group{}
	media := []models.Media{}
	if err := db.Where("slug = ?", params["slug"]).First(&podcast).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Group not found"})
		return
	}
	db.Model(&podcast).Order("created_at desc").Related(&media)
	r.JSON(http.StatusOK, media)
}
Example #25
0
func (u *Media) BeforeCreate(tx *gorm.DB) (err error) {
	var count int
	tx.Model(u).Where("name = ?", u.Name).Count(&count)
	if count > 0 {
		err = errors.New("Media exists!")
		return
	}
	u.Slug = slug.Slug(u.Name)
	return
}
Example #26
0
func (u *Group) BeforeUpdate(tx *gorm.DB) (err error) {
	var count int
	tx.Model(u).Where("name = ?", u.Name).Count(&count)
	if count > 1 {
		err = errors.New("Conflicting Name!")
		return
	}
	u.Slug = slug.Slug(u.Name)
	return
}
Example #27
0
// BeforeDelete invokes required actions before deletion.
func (u *Team) BeforeDelete(tx *gorm.DB) error {
	if err := tx.Model(u).Association("Users").Clear().Error; err != nil {
		return err
	}

	// TODO(tboerger): Prevent delete if team is last owner
	if err := tx.Model(u).Association("Orgs").Clear().Error; err != nil {
		return err
	}

	return nil
}
Example #28
0
//Migrate db:migrate
func (p *Engine) Migrate(db *gorm.DB) {
	i18n.Migrate(db)

	db.AutoMigrate(
		&Setting{}, &Notice{},
		&User{}, &Role{}, &Permission{}, &Log{},
	)

	db.Model(&User{}).AddUniqueIndex("idx_user_provider_type_id", "provider_type", "provider_id")
	db.Model(&Role{}).AddUniqueIndex("idx_roles_name_resource_type_id", "name", "resource_type", "resource_id")
	db.Model(&Permission{}).AddUniqueIndex("idx_permissions_user_role", "user_id", "role_id")
}
Example #29
0
func (user *User) Validate(db *gorm.DB) {
	govalidator.CustomTypeTagMap.Set("uniqEmail", govalidator.CustomTypeValidator(func(email interface{}, context interface{}) bool {
		var count int
		if db.Model(&User{}).Where("email = ?", email).Count(&count); count == 0 || email == "" {
			return true
		}
		return false
	}))
	if user.Name == "invalid" {
		db.AddError(validations.NewError(user, "Name", "invalid user name"))
	}
}
Example #30
-1
File: dao.go Project: itpkg/base
func (p *LocaleDao) Set(db *gorm.DB, lang, code, message string) {
	var l Locale
	if db.Select("id").Where("lang = ? AND code = ?", lang, code).First(&l).RecordNotFound() {
		db.Create(&Locale{Lang: lang, Code: code, Message: message})
	} else {
		db.Model(Locale{}).Where("id = ?", l.ID).Updates(Locale{Message: message})
	}
}