func createRecord(input interface{}, session *xorm.Session) (statusCode int, err error) {
	_, err = session.Insert(input)
	if err != nil {
		return http.StatusInternalServerError, err
	}
	return http.StatusOK, err
}

func (f *searchADCFPagerFilter) GetPageQuery(tx *xorm.Session) *xorm.Session {
	tx = f.GetQuery(tx)

	offset := (f.Page - 1) * f.PageSize
	tx.Limit(f.PageSize, offset)
	return tx
}

func updateRecordWithUserId(input interface{}, fieldNames map[string]bool, id, userId string, session *xorm.Session) (statusCode int, err error) {
	if _, err := uuid.FromString(id); err != nil {
		return http.StatusBadRequest, errUuidNotValid
	}
	if _, err := uuid.FromString(userId); err != nil {
		return http.StatusBadRequest, errUuidNotValid
	}

	//convert the fields set to array
	array := []string{}
	for k, _ := range fieldNames {
		array = append(array, k)
	}

	//update the database
	affected, err := session.Where("id = ? and user_id = ?", id, userId).Cols(array...).Update(input)
	if err != nil {
		return http.StatusInternalServerError, err
	}
	if affected == 0 {
		return http.StatusNotFound, errors.New("The record is not found.")
	}

	return http.StatusNoContent, nil
}

func (f searchADCFFilter) GetQuery(tx *xorm.Session) *xorm.Session {
	f.CheckUnscoped(tx)

	if f.HasField("AAA") && len(f.AAA) > 0 {
		name := fmt.Sprintf("%%%s%%", f.AAA)
		tx.And("a_a_a like ?", f.AAA)
	}

	if f.HasField("BBB") && len(f.BBB) > 0 {
		name := fmt.Sprintf("%%%s%%", f.BBB)
		tx.And("b_b_b like ?", f.BBB)
	}

	if f.HasField("CCC") {
		tx.And("c_c_c = ?", f.CCC)
	}
	if f.HasField("CCC_In") && len(f.CCC) > 0 {
		tx.In("c_c_c", f.CCC_In)
	}

	if f.HasField("UpdateTime") && f.UpdateTime > 0 {
		tx.And("update_at > ?", utils.UnixtimeToDate(f.UpdateTime, ""))
	}
	return tx
}

// SearchUserByName takes keyword and part of user name to search,
// it returns results in given range and number of total results.
func SearchUserByName(opts *SearchUserOptions) (users []*User, _ int64, _ error) {
	if len(opts.Keyword) == 0 {
		return users, 0, nil
	}
	opts.Keyword = strings.ToLower(opts.Keyword)

	if opts.PageSize <= 0 || opts.PageSize > setting.ExplorePagingNum {
		opts.PageSize = setting.ExplorePagingNum
	}
	if opts.Page <= 0 {
		opts.Page = 1
	}

	searchQuery := "%" + opts.Keyword + "%"
	users = make([]*User, 0, opts.PageSize)
	// Append conditions
	sess := x.Where("LOWER(lower_name) LIKE ?", searchQuery).
		Or("LOWER(full_name) LIKE ?", searchQuery).
		And("type = ?", opts.Type)

	var countSess xorm.Session
	countSess = *sess
	count, err := countSess.Count(new(User))
	if err != nil {
		return nil, 0, fmt.Errorf("Count: %v", err)
	}

	if len(opts.OrderBy) > 0 {
		sess.OrderBy(opts.OrderBy)
	}
	return users, count, sess.Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).Find(&users)
}

func (this *ContentPuzzleActivityComponentPuzzleDbModel) AddForTrans(sess *xorm.Session, data ContentPuzzleActivityComponentPuzzle) ContentPuzzleActivityComponentPuzzle {
	_, err := sess.Insert(&data)
	if err != nil {
		panic(err)
	}
	return data
}

// Mark old articles read.
func MarkOldArticlesRead(session *xorm.Session) (affected int64, err error) {

	list, err := GetFeedListWithAmount(session)
	if err != nil {
		return
	}

	for _, item := range list {
		if int(*item.MaxUnread) > 0 && item.Unread > uint64(*item.MaxUnread) {
			n := int(item.Unread) - int(*item.MaxUnread)

			sql := "update Item set read=1 where id in (select id from Item where Fid = ? and Read = 0 order by Id asc limit ?)"
			result, e := session.Exec(sql, item.Id, n)
			if e != nil {
				err = e
				return
			}
			num, e := result.RowsAffected()
			if e != nil {
				err = e
				return
			}
			global.Logger.Infof("[TRIM DATA] in transaction: mark old articles read: feed id: %d, affected: %d", item.Id, num)
			affected += num
		}
	}

	return
}

// Delete old articles which read=1.
func DeleteOldArticles(session *xorm.Session) (affected int64, err error) {

	list, err := GetFeedListWithAmount(session)
	if err != nil {
		return
	}

	for _, item := range list {
		if int(*item.MaxKeep) > 0 && (item.Amount-item.Unread > uint64(*item.MaxKeep)) {
			n := int(item.Amount - item.Unread - uint64(*item.MaxKeep))

			sql := "delete from Item where id in (select id from Item where Fid = ? and Read = 1 and starred = 0 order by Id asc limit ?)"
			result, e := session.Exec(sql, item.Id, n)
			if e != nil {
				err = e
				return
			}
			num, e := result.RowsAffected()
			if e != nil {
				err = e
				return
			}
			global.Logger.Infof("[TRIM DATA] in transaction: delete old articles which is read: feed id: %d, affected: %d", item.Id, num)
			affected += num
		}
	}

	return
}

func deletePublicKey(e *xorm.Session, keyID int64) error {
	sshOpLocker.Lock()
	defer sshOpLocker.Unlock()

	key := &PublicKey{ID: keyID}
	has, err := e.Get(key)
	if err != nil {
		return err
	} else if !has {
		return nil
	}

	if _, err = e.Id(key.ID).Delete(new(PublicKey)); err != nil {
		return err
	}

	fpath := filepath.Join(SSHPath, "authorized_keys")
	tmpPath := filepath.Join(SSHPath, "authorized_keys.tmp")
	if err = rewriteAuthorizedKeys(key, fpath, tmpPath); err != nil {
		return err
	} else if err = os.Remove(fpath); err != nil {
		return err
	}
	return os.Rename(tmpPath, fpath)
}

func deletePublicKey(e *xorm.Session, keyID int64) error {
	sshOpLocker.Lock()
	defer sshOpLocker.Unlock()

	key := &PublicKey{ID: keyID}
	has, err := e.Get(key)
	if err != nil {
		return err
	} else if !has {
		return nil
	}

	if _, err = e.Id(key.ID).Delete(new(PublicKey)); err != nil {
		return err
	}

	// Don't need to rewrite this file if builtin SSH server is enabled.
	if setting.StartSSHServer {
		return nil
	}

	fpath := filepath.Join(setting.SSHRootPath, "authorized_keys")
	tmpPath := filepath.Join(setting.SSHRootPath, "authorized_keys.tmp")
	if err = rewriteAuthorizedKeys(key, fpath, tmpPath); err != nil {
		return err
	} else if err = os.Remove(fpath); err != nil {
		return err
	}
	return os.Rename(tmpPath, fpath)
}

// UpdateAccess updates access information with session for rolling back.
func UpdateAccessWithSession(sess *xorm.Session, access *Access) error {
	if _, err := sess.Id(access.Id).Update(access); err != nil {
		sess.Rollback()
		return err
	}
	return nil
}

func newIssueUsers(e *xorm.Session, repo *Repository, issue *Issue) error {
	users, err := repo.GetAssignees()
	if err != nil {
		return err
	}

	iu := &IssueUser{
		IssueID: issue.ID,
		RepoID:  repo.ID,
	}

	// Poster can be anyone.
	isNeedAddPoster := true
	for _, u := range users {
		iu.ID = 0
		iu.UID = u.Id
		iu.IsPoster = iu.UID == issue.PosterID
		if isNeedAddPoster && iu.IsPoster {
			isNeedAddPoster = false
		}
		iu.IsAssigned = iu.UID == issue.AssigneeID
		if _, err = e.Insert(iu); err != nil {
			return err
		}
	}
	if isNeedAddPoster {
		iu.ID = 0
		iu.UID = issue.PosterID
		iu.IsPoster = true
		if _, err = e.Insert(iu); err != nil {
			return err
		}
	}
	return nil
}

func getOrgsByUserID(sess *xorm.Session, userID int64, showAll bool) ([]*User, error) {
	orgs := make([]*User, 0, 10)
	if !showAll {
		sess.And("`org_user`.is_public=?", true)
	}
	return orgs, sess.And("`org_user`.uid=?", userID).
		Join("INNER", "`org_user`", "`org_user`.org_id=`user`.id").Find(&orgs)
}

// deletePublicKeys does the actual key deletion but does not update authorized_keys file.
func deletePublicKeys(e *xorm.Session, keyIDs ...int64) error {
	if len(keyIDs) == 0 {
		return nil
	}

	_, err := e.In("id", strings.Join(base.Int64sToStrings(keyIDs), ",")).Delete(new(PublicKey))
	return err
}

func (this *ContentPuzzleActivityComponentPuzzleDbModel) GetByComponentIdForTrans(sess *xorm.Session, componentId int) []ContentPuzzleActivityComponentPuzzle {
	result := []ContentPuzzleActivityComponentPuzzle{}
	err := sess.Sql("select * from t_content_puzzle_activity_component_puzzle where contentPuzzleActivityComponentId = ? for update", componentId).Find(&result)
	if err != nil {
		panic(err)
	}
	return result
}

func (this *PuzzleActivityComponentDbModel) SetStateForTrans(sess *xorm.Session, componentId int, state int) {
	data := ContentPuzzleActivityComponent{
		State: state,
	}
	_, err := sess.Where("contentPuzzleActivityComponentId=?", componentId).Update(&data)
	if err != nil {
		panic(err)
	}
}

func updateIsDefaultFlag(ds *m.DataSource, sess *xorm.Session) error {
	// Handle is default flag
	if ds.IsDefault {
		rawSql := "UPDATE data_source SET is_default=? WHERE org_id=? AND id <> ?"
		if _, err := sess.Exec(rawSql, false, ds.OrgId, ds.Id); err != nil {
			return err
		}
	}
	return nil
}

//获取系统参数表
func GetValueFromSysConfig(txn *xorm.Session, key string) (models.SystemConfig, error) {
	var val models.SystemConfig
	val.Ename = key
	has, err := txn.Get(&val)
	if !has || !CheckError(err, "取系统参数失败") {
		log.Error("取系统参数失败:", key)
		return val, errors.New("failed")
	}
	return val, nil
}

func DeleteAlertDefinition(dashboardId int64, sess *xorm.Session) error {
	alerts := make([]*m.Alert, 0)
	sess.Where("dashboard_id = ?", dashboardId).Find(&alerts)

	for _, alert := range alerts {
		deleteAlertByIdInternal(alert.Id, "Dashboard deleted", sess)
	}

	return nil
}

func GetAlertsByDashboardId2(dashboardId int64, sess *xorm.Session) ([]*m.Alert, error) {
	alerts := make([]*m.Alert, 0)
	err := sess.Where("dashboard_id = ?", dashboardId).Find(&alerts)

	if err != nil {
		return []*m.Alert{}, err
	}

	return alerts, nil
}