Esempio n. 1
0
//构建实体模型的插入函数
func createInsertFunc(modelInfo *modelMeta) EntityCFunc {
	insertFields := fun.Filter(exceptIdPred, modelInfo.fields).([]*modelField)
	columns := strings.Join(fun.Map(func(field *modelField) string {
		return field.column
	}, insertFields).([]string), ",")
	params := strings.Join(toSlice("?", len(insertFields)), ",")

	return func(executor interface{}, entity EntityInterface) error {
		ind := checkEntity(modelInfo, entity, executor)

		paramValues := make([]interface{}, 0, len(insertFields))
		for _, field := range insertFields {
			fv := ind.Field(field.index).Interface()
			paramValues = append(paramValues, fv)
		}

		insertSql := fmt.Sprintf("INSERT INTO %s (%s) VALUES(%s)", entity.TableName(), columns, params)
		c.Debugf("insertSql:%v", insertSql)

		rs, err := exec(executor, insertSql, paramValues)
		if err != nil {
			return err
		}

		if modelInfo.pkField.pkAuto {
			if id, err := rs.LastInsertId(); err == nil {
				ind.Field(modelInfo.pkField.index).SetInt(id)
			} else {
				return err
			}
		}
		return nil
	}
}
Esempio n. 2
0
// LoadCertificateForDomains loads certificates from ACME for given domains
func (a *ACME) LoadCertificateForDomains(domains []string) {
	domains = fun.Map(types.CanonicalDomain, domains).([]string)
	safe.Go(func() {
		operation := func() error {
			if a.client == nil {
				return fmt.Errorf("ACME client still not built")
			}
			return nil
		}
		notify := func(err error, time time.Duration) {
			log.Errorf("Error getting ACME client: %v, retrying in %s", err, time)
		}
		ebo := backoff.NewExponentialBackOff()
		ebo.MaxElapsedTime = 30 * time.Second
		err := backoff.RetryNotify(operation, ebo, notify)
		if err != nil {
			log.Errorf("Error getting ACME client: %v", err)
			return
		}
		account := a.store.Get().(*Account)
		var domain Domain
		if len(domains) == 0 {
			// no domain
			return

		} else if len(domains) > 1 {
			domain = Domain{Main: domains[0], SANs: domains[1:]}
		} else {
			domain = Domain{Main: domains[0]}
		}
		if _, exists := account.DomainsCertificate.exists(domain); exists {
			// domain already exists
			return
		}
		certificate, err := a.getDomainsCertificates(domains)
		if err != nil {
			log.Errorf("Error getting ACME certificates %+v : %v", domains, err)
			return
		}
		log.Debugf("Got certificate for domains %+v", domains)
		transaction, object, err := a.store.Begin()

		if err != nil {
			log.Errorf("Error creating transaction %+v : %v", domains, err)
			return
		}
		account = object.(*Account)
		_, err = account.DomainsCertificate.addCertificateForDomains(certificate, domain)
		if err != nil {
			log.Errorf("Error adding ACME certificates %+v : %v", domains, err)
			return
		}
		if err = transaction.Commit(account); err != nil {
			log.Errorf("Error Saving ACME account %+v: %v", account, err)
			return
		}
	})
}
Esempio n. 3
0
func (sl *simpleLoad) add(line []byte, args ...interface{}) {
	if err := sl.ins.Exec(args...); err != nil {
		toStr := func(v interface{}) string { return sf("%#v", v) }
		logf("Full %s info (that failed to add): %s",
			sl.table, fun.Map(toStr, args).([]string))
		logf("Context: %s", line)
		csql.Panic(ef("Error adding to %s table: %s", sl.table, err))
	}
	sl.count++
}
Esempio n. 4
0
func (s *Searcher) where() string {
	var conj []string
	conj = append(conj, s.whereCredits()...)

	entString := func(e imdb.EntityKind) string { return e.String() }
	ents := fun.Map(entString, s.entities).([]string)
	conj = append(conj, s.inStrs(s.entityColumn(), ents))

	conj = append(conj, s.inStrs("mpaa_rating.rating", s.mpaas))
	conj = append(conj, s.inSubquery("genre", "name", s.genres))

	if !s.subTvshow.empty() {
		conj = append(conj, sf("e.tvshow_atom_id = %d", s.subTvshow.id))
	}
	if s.atom > 0 {
		conj = append(conj, sf("name.atom_id = %d", s.atom))
	}
	if s.year != nil {
		conj = append(conj, s.year.cond("COALESCE(m.year, t.year, e.year, 0)"))
	}
	if s.rating != nil {
		conj = append(conj, s.rating.cond("rating.rank"))
	}
	if s.votes != nil {
		conj = append(conj, s.votes.cond("rating.votes"))
	}
	if s.season != nil {
		cond := sf("(e.atom_id IS NULL OR %s)", s.season.cond("e.season"))
		conj = append(conj, cond)
	}
	if s.episode != nil {
		cond := sf("(e.atom_id IS NULL OR %s)", s.episode.cond("e.episode_num"))
		conj = append(conj, cond)
	}
	if s.noTvMovie {
		conj = append(conj, "(m.atom_id IS NULL OR m.tv = cast(0 as boolean))")
	}
	if s.noVideoMovie {
		conj = append(conj,
			"(m.atom_id IS NULL OR m.video = cast(0 as boolean))")
	}
	if len(s.name) > 0 {
		if s.fuzzy {
			conj = append(conj, "name.name % $1")
		} else {
			if s.db.Driver == "postgres" {
				conj = append(conj, sf("name.name ILIKE $1"))
			} else {
				conj = append(conj, sf("name.name LIKE $1"))
			}
		}
	}
	return strings.Join(conj, " AND ")
}
Esempio n. 5
0
// ParseDomains parses rules expressions and returns domains
func (r *Rules) ParseDomains(expression string) ([]string, error) {
	domains := []string{}
	err := r.parseRules(expression, func(functionName string, function interface{}, arguments []string) error {
		if functionName == "Host" {
			domains = append(domains, arguments...)
		}
		return nil
	})
	if err != nil {
		return nil, fmt.Errorf("Error parsing domains: %v", err)
	}
	return fun.Map(types.CanonicalDomain, domains).([]string), nil
}
Esempio n. 6
0
func cmd_rename(c *command) bool {
	if len(flagRenameTvshow) > 0 {
		return cmd_rename_tvshow(c, flagRenameTvshow)
	}
	firstArg := c.flags.Arg(0)
	if _, err := os.Stat(firstArg); err == nil {
		return cmd_rename_smart(c)
	}

	c.assertLeastNArg(2)
	db := openDb(c.dbinfo())
	defer closeDb(db)

	query := c.flags.Arg(0)
	files := fun.Map(path.Clean, c.flags.Args()[1:]).([]string)
	searcher, err := search.Query(db, query)
	if err != nil {
		pef("%s", err)
		return false
	}
	searcher.Chooser(c.chooser)
	searcher.Limit(len(files))

	results, err := searcher.Results()
	if err != nil {
		pef("%s", err)
		return false
	}
	if len(results) == 0 {
		pef("No search results.")
		return false
	}
	if len(results) < len(files) {
		pef("Omitting last %d file(s) since there are only %d search results.",
			len(files)-len(results), len(results))
		files = files[0:len(results)]
	}

	entities := make([]imdb.Entity, len(results))
	for i, r := range results {
		e, err := r.GetEntity(db)
		if err != nil {
			pef("Could not get entity for '%s': %s", r, err)
			return false
		}
		entities[i] = e
	}
	return doRename(c, db, files, entities)
}
Esempio n. 7
0
func (a *ACME) getDomainsCertificates(domains []string) (*Certificate, error) {
	domains = fun.Map(types.CanonicalDomain, domains).([]string)
	log.Debugf("Loading ACME certificates %s...", domains)
	bundle := true
	certificate, failures := a.client.ObtainCertificate(domains, bundle, nil, OSCPMustStaple)
	if len(failures) > 0 {
		log.Error(failures)
		return nil, fmt.Errorf("Cannot obtain certificates %s+v", failures)
	}
	log.Debugf("Loaded ACME certificates %s", domains)
	return &Certificate{
		Domain:        certificate.Domain,
		CertURL:       certificate.CertURL,
		CertStableURL: certificate.CertStableURL,
		PrivateKey:    certificate.PrivateKey,
		Certificate:   certificate.Certificate,
	}, nil
}
Esempio n. 8
0
func cmd_rename_smart(c *command) bool {
	c.assertLeastNArg(1)
	db := openDb(c.dbinfo())
	defer closeDb(db)

	files := fun.Map(path.Clean, c.flags.Args()).([]string)

	var oldNames []string
	var newNames []imdb.Entity
	for _, file := range files {
		e, err := guessEntity(c, db, file)
		if err != nil {
			pef("Could not guess entity for '%s': %s", file, err)
			continue
		}
		oldNames = append(oldNames, file)
		newNames = append(newNames, e)
	}
	return doRename(c, db, oldNames, newNames)
}
Esempio n. 9
0
func cmd_rename_tvshow(c *command, tvQuery string) bool {
	c.assertLeastNArg(1)
	db := openDb(c.dbinfo())
	defer closeDb(db)

	files := fun.Map(path.Clean, c.flags.Args()).([]string)
	tv, err := searchTvshow(c, db, tvQuery)
	if err != nil {
		pef("%s", err)
		return false
	}
	episodes, err := tvEpisodes(db, tv)
	if err != nil {
		pef("%s", err)
		return false
	}

	var oldNames []string
	var newNames []imdb.Entity
	for _, file := range files {
		baseFile := path.Base(file)
		s, e, _, _, err := episodeNumbers(baseFile, flagRenameRegexEpisode)
		if err != nil {
			pef("Could not find episode numbers in '%s': %s", file, err)
			continue
		}
		if s == 0 || e == 0 {
			pef("Found numbers, but they look wrong: (s: %d, e: %d)", s, e)
			continue
		}
		ep, ok := episodes[episodeKey{s, e}]
		if !ok {
			pef("Could not find episode (%s, S%02dE%02d) for '%s'.",
				tv, s, e, file)
			continue
		}
		oldNames = append(oldNames, file)
		newNames = append(newNames, ep)
	}
	return doRename(c, db, oldNames, newNames)
}
Esempio n. 10
0
//构建查询函数
func createQueryFunc(modelInfo *modelMeta) EntityQFunc {
	columns := strings.Join(fun.Map(func(field *modelField) string {
		return "`" + field.column + "`"
	}, modelInfo.fields).([]string), ",")

	return func(executor interface{}, entity EntityInterface, condition string, params []interface{}) ([]EntityInterface, error) {
		ind := checkEntity(modelInfo, entity, executor)
		querySql := fmt.Sprintf("SELECT %s FROM %s ", columns, entity.TableName())
		if len(condition) > 0 {
			querySql += condition
		}
		c.Debugf("querySql:%v", querySql)

		rows, err := query(executor, querySql, params)
		if err != nil {
			return nil, err
		}
		defer rows.Close()

		var rt = make([]EntityInterface, 0, 10)
		for rows.Next() {
			ptrValue := reflect.New(ind.Type())
			ptrValueInd := reflect.Indirect(ptrValue)
			ptrValueSlice := make([]interface{}, 0, len(modelInfo.fields))
			for _, field := range modelInfo.fields {
				fv := ptrValueInd.Field(field.index).Addr().Interface()
				//c.Debugf("fv:%v,type:%T", fv, fv)
				ptrValueSlice = append(ptrValueSlice, fv)
			}
			if err := rows.Scan(ptrValueSlice...); err == nil {
				rt = append(rt, ptrValue.Interface().(EntityInterface))
			} else {
				return nil, err
			}
		}
		return rt, nil
	}
}
Esempio n. 11
0
//构建实体模型的更新函数
func createUpdateFunc(modelInfo *modelMeta) EntityUFunc {
	updateFields := fun.Filter(exceptIdPred, modelInfo.fields).([]*modelField)
	columns := strings.Join(fun.Map(func(field *modelField) string {
		return field.column + "=?"
	}, updateFields).([]string), ",")

	return func(executor interface{}, entity EntityInterface) (bool, error) {
		ind := checkEntity(modelInfo, entity, executor)

		paramValues := make([]interface{}, 0, len(updateFields)+1)
		for _, field := range updateFields {
			fv := ind.Field(field.index).Interface()
			paramValues = append(paramValues, fv)
		}

		id := ind.Field(modelInfo.pkField.index).Interface()
		paramValues = append(paramValues, id)

		updateSql := fmt.Sprintf("UPDATE %s SET %s where %s = %s", entity.TableName(), columns, modelInfo.pkField.column, "?")
		c.Debugf("updateSql:%v", updateSql)

		rs, err := exec(executor, updateSql, paramValues)
		if err != nil {
			return false, err
		}

		//检查更新的记录数
		if rows, err := rs.RowsAffected(); err == nil {
			if rows != 1 {
				return false, err
			} else {
				return true, err
			}
		} else {
			return false, err
		}
	}
}
Esempio n. 12
0
func Map(xs, f interface{}) interface{} {
	return fun.Map(f, xs)
}