Golang DB.FirstOrCreate方法代码示例

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
}

func tailLog(db gorm.DB, eventSample *stripe.Event) error {
	// Start paging from after the event sample that we capture before we
	// started loading from snapshot.
	params := &stripe.EventListParams{}
	params.Filters.AddFilter("limit", "", strconv.Itoa(PageSize))
	params.Filters.AddFilter("starting_after", "", eventSample.ID)

	var apiDuration, dbDuration time.Duration
	numProcessed := 0
	totalStart := time.Now()

	iterator := event.List(params)
	timeIterator := func() bool {
		start := time.Now()
		ret := iterator.Next()
		apiDuration = apiDuration + time.Now().Sub(start)
		return ret
	}

	for timeIterator() {
		start := time.Now()
		event := iterator.Event()

		switch event.Type {
		case "charge.created":
			charge := Charge{
				// TODO: deserialize to proper charge object
				ID:      event.Data.Obj["id"].(string),
				Amount:  event.Data.Obj["amount"].(uint64),
				Created: time.Unix(event.Data.Obj["created"].(int64), 0),
			}
			db.FirstOrCreate(&charge)
			dbDuration = dbDuration + time.Now().Sub(start)
			if db.Error != nil {
				return db.Error
			}

			numProcessed = numProcessed + 1
			if numProcessed%ReportingIncrement == 0 {
				log.Printf("Working. Processed %v record(s).", ReportingIncrement)
			}
		}
	}
	if err := iterator.Err(); err != nil {
		return err
	}

	log.Printf("")
	log.Printf("== Log Tailing Results")
	log.Printf("API duration:            %v", apiDuration)
	log.Printf("DB duration:             %v", dbDuration)
	log.Printf("Total duration:          %v", time.Now().Sub(totalStart))
	log.Printf("Total records processed: %v", numProcessed)
	return nil
}

func loadSnapshot(db gorm.DB) error {
	params := &stripe.ChargeListParams{}
	params.Filters.AddFilter("limit", "", strconv.Itoa(PageSize))

	var apiDuration, dbDuration time.Duration
	numProcessed := 0
	totalStart := time.Now()

	iterator := charge.List(params)
	timeIterator := func() bool {
		start := time.Now()
		ret := iterator.Next()
		apiDuration = apiDuration + time.Now().Sub(start)
		return ret
	}

	for timeIterator() {
		start := time.Now()
		charge := convertCharge(iterator.Charge())
		db.FirstOrCreate(&charge)
		dbDuration = dbDuration + time.Now().Sub(start)

		if db.Error != nil {
			return db.Error
		}

		numProcessed = numProcessed + 1
		if numProcessed%ReportingIncrement == 0 {
			log.Printf("Working. Processed %v record(s).", ReportingIncrement)
		}
	}
	if err := iterator.Err(); err != nil {
		return err
	}

	log.Printf("")
	log.Printf("== Snapshot Loading Results")
	log.Printf("API duration:            %v", apiDuration)
	log.Printf("DB duration:             %v", dbDuration)
	log.Printf("Total duration:          %v", time.Now().Sub(totalStart))
	log.Printf("Total records processed: %v", numProcessed)
	return nil
}

func getTumblrBlog(name string, db *gorm.DB) *TumblrBlog {
	blog := new(TumblrBlog)
	db.FirstOrCreate(blog, TumblrBlog{Name: name})
	return blog
}

// EnsureRepository inserts a Repository into the database if it doesn't exist and returns that Repository
func EnsureRepository(db *gorm.DB, given Repository) (repo Repository) {
	db.FirstOrCreate(&repo, given)
	return
}

func ListenAndServe(addr string, auth Auth, dbType DatabaseType) {
	var db *gorm.DB
	var err error

	if dbType == DB_MySQL {
		dbConn := fmt.Sprintf("%s:%[email protected](127.0.0.1:3306)", auth.UserName, auth.Password)
		db, err = gorm.Open("mysql", dbConn+"/hugocms_"+auth.UserName+"?charset=utf8&parseTime=True&loc=Local")
	} else {
		db, err = gorm.Open("sqlite3", "hugocms_"+auth.UserName+".db")
	}

	if err != nil {
		handleError(err)
	}
	db.LogMode(true)

	// to reset to an empty database drop the settings table
	if !db.HasTable(&models.Settings{}) {
		for _, table := range hugocms_qor.Tables {
			if err := db.DropTableIfExists(table).Error; err != nil {
				handleError(err)
			}
		}
	}

	for _, table := range hugocms_qor.Tables {
		if err := db.AutoMigrate(table).Error; err != nil {
			handleError(err)
		}
	}

	// Because this is a singleton a single record must already exist in the database (there is no create through QOR admin just update)
	db.FirstOrCreate(&models.Settings{})

	siteName := fmt.Sprintf("%s - Hugo CMS", auth.UserName)
	if err := setupConfig(addr, siteName, db, auth); err != nil {
		handleError(err)
	}

	// Add session support - used by Auth
	sessionLifetime := 3600 // session lifetime in seconds
	SessionManager, err = session.NewManager("memory", fmt.Sprintf(`{"cookieName":"gosessionid","gclifetime":%d}`, sessionLifetime))
	if err != nil {
		handleError(err)
	}
	go SessionManager.GC()

	// Create Hugo's content directory if it doesnt exist
	// TODO read content dir from config
	if _, err := os.Stat("./content"); os.IsNotExist(err) {
		err = os.MkdirAll("./content", os.ModePerm)
	}

	mux := http.NewServeMux()

	mux.Handle("/", http.FileServer(http.Dir("public")))

	adm := hugocms_qor.SetupAdmin()

	adm.MountTo("/admin", mux)
	adm.GetRouter().Post("/auth", func(ctx *admin.Context) {
		// we will only hit this on succesful login - redirect to admin dashboard
		w := ctx.Writer
		r := ctx.Request
		http.Redirect(w, r, "/admin", http.StatusFound)
	})
	adm.GetRouter().Get("/logout", func(ctx *admin.Context) {
		w := ctx.Writer
		r := ctx.Request
		sess, err := SessionManager.SessionStart(w, r)
		if err != nil {
			handleError(err)
		}
		defer sess.SessionRelease(w)
		sess.Delete("User")
		http.Redirect(w, r, "/login", http.StatusFound)
	})

	// NOTE: `system` is where QOR admin will upload files e.g. images - we map this to Hugo's static dir along with our other static assets
	// TODO read static dir from config
	// TODO read static assets list from config
	for _, path := range []string{"system", "css", "fonts", "images", "js", "login"} {
		mux.Handle(fmt.Sprintf("/%s/", path), http.FileServer(http.Dir("static")))
	}

	if err := http.ListenAndServe(config.QOR.Addr, mux); err != nil {
		handleError(err)
	}

	// to re-generate site delete `config.json`
	if _, err := os.Stat("config.json"); os.IsNotExist(err) {
		hugocms_qor.CallSave(adm)
	}

	fmt.Printf("Listening on: %s\n", config.QOR.Addr)
}

func (s *Subscriber) Create(db *gorm.DB) error {
	return db.FirstOrCreate(s).Error
}

func FillSrcInfo(path string, db *gorm.DB) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()
	info, err := srcinfo.ParseSrcInfo(f)
	if err != nil {
		return err
	}
	var oldPkgBase PackageBase
	db.Select("id").First(&oldPkgBase, "pkg_base = ?", info.Global.PkgBase)
	pkgBase := PackageBase{
		ID:          oldPkgBase.ID,
		PkgBase:     info.Global.PkgBase,
		Packages:    []Package{},
		Version:     info.Global.PkgVer,
		Release:     info.Global.PkgRel,
		Depenencies: []Package{},
		Directory:   filepath.Dir(path),
	}
	log.Printf("  {%s}", pkgBase.PkgBase)
	depend := func(dependency string) {
		pkgName := StripDependencyPkgName(dependency)
		log.Printf("    %s => %s", dependency, pkgName)
		var dep Package
		db.FirstOrCreate(&dep, Package{Name: pkgName})
		log.Printf("    %+v", dep)
		pkgBase.Depenencies = append(pkgBase.Depenencies, dep)
	}
	for _, dependency := range info.Global.Depends {
		depend(dependency)
	}
	for _, dependency := range info.Global.MakeDepends {
		depend(dependency)
	}
	for _, pkginfo := range info.Packages {
		for _, dependency := range pkginfo.Depends {
			depend(dependency)
		}
		var pkg Package
		db.FirstOrCreate(&pkg, Package{
			PackageBaseID: pkgBase.ID,
			Name:          pkginfo.PkgName,
		})
		log.Printf("  %s", pkginfo.PkgName)
		pkgBase.Packages = append(pkgBase.Packages, pkg)
	}
	db.Save(&pkgBase)
	return nil
}