func EntitySetNull(
	entity *df.Entity, propertyName string, colInfo *df.ColumnInfo, update bool) {
	switch colInfo.GoType {
	case "string":
		df.SetEntityValue(entity, propertyName, "")
	case "sql.NullString":
		df.SetEntityValue(entity, propertyName, new(sql.NullString))
	case "pq.NullTime":
		nt := new(pq.NullTime)
		nt.Valid = false
		df.SetEntityValue(entity, propertyName, nt)
	case "df.NullDate":
		df.SetEntityValue(entity, propertyName, new(df.NullDate))
	case "df.NullTimestamp":
		df.SetEntityValue(entity, propertyName, new(df.NullTimestamp))
	case "df.NullNumeric":
		df.SetEntityValue(entity, propertyName, new(df.NullNumeric))
	case "df.MysqlNullDate":
		df.SetEntityValue(entity, propertyName, new(df.MysqlNullDate))
	case "df.MysqlNullTime":
		df.SetEntityValue(entity, propertyName, new(df.MysqlNullTime))
	case "df.MysqlNullTimestamp":
		df.SetEntityValue(entity, propertyName, new(df.MysqlNullTimestamp))
	case "sql.NullInt64":
		df.SetEntityValue(entity, propertyName, new(sql.NullInt64))
	case "sql.NullFloat64":
		df.SetEntityValue(entity, propertyName, new(sql.NullFloat64))
	case "sql.NullBool":
		df.SetEntityValue(entity, propertyName, new(sql.NullBool))
	default:
		if update {
			panic("必須項目未入力です。 項目名:" + propertyName)
		}
	}
}

func TestTimeOrNull(t *testing.T) {
	var (
		nullTime pq.NullTime
		value    driver.Value
		err      error
	)

	// When the time is nil
	nullTime = TimeOrNull(nil)

	// nullTime.Valid should be false
	assert.False(t, nullTime.Valid)

	// nullInt.Value() should return nil
	value, err = nullTime.Value()
	assert.Nil(t, err)
	assert.Nil(t, value)

	// When the time is time.Time instance
	now := time.Now()
	nullTime = TimeOrNull(&now)

	// nullTime.Valid should be true
	assert.True(t, nullTime.Valid)

	// nullTime.Value() should return the time.Time
	value, err = nullTime.Value()
	assert.Nil(t, err)
	assert.Equal(t, now, value)
}

func setTimer(rows *sql.Rows) (*Timer, error) {
	var finishedAt pq.NullTime
	var createdAt pq.NullTime

	timer := Timer{}

	err := rows.Scan(&timer.ID, &timer.User, &timer.Name, &createdAt, &finishedAt)
	if err != nil {
		return nil, err
	}

	val, err := createdAt.Value()
	if err != nil {
		return nil, err
	}

	if val != nil {
		timer.CreatedAt = &createdAt.Time
	}

	val, err = finishedAt.Value()
	if err != nil {
		return nil, err
	}

	if val != nil {
		timer.FinishedAt = &finishedAt.Time
	}

	return &timer, nil
}

func CreateNullTime(v time.Time) pq.NullTime {
	var nt pq.NullTime
	nt.Valid = true
	nt.Time = v
	return nt
}

// TimeOrNull returns properly confiigured pq.TimeNull
func TimeOrNull(t interface{}) pq.NullTime {
	nullTime := new(pq.NullTime)
	nullTime.Scan(t)
	return *nullTime
}

// convertArt converts a slurped article into jl form
func convertArt(src *slurp.Article) (*jl.Article, []*jl.UnresolvedJourno) {
	now := time.Now()

	bestURL := src.CanonicalURL
	if bestURL == "" {
		bestURL = src.URLs[0]
	}

	pub := jl.NewPublication(src.Publication.Domain, src.Publication.Name)

	var pubDate pq.NullTime
	t, err := time.Parse(time.RFC3339, src.Published)
	if err == nil {
		pubDate.Time = t
		pubDate.Valid = true
	} // else pubDate is NULL

	wordCnt := sql.NullInt64{0, false}
	rawTxt := ""
	if src.Content != "" {
		// parse and render to raw text
		doc, err := html.Parse(strings.NewReader(src.Content))
		if err == nil {
			rawTxt = htmlutil.RenderNode(doc)
		}
	}

	tags := []jl.Tag{}
	if rawTxt != "" {
		// count words
		cnt := len(wordPat.FindAllString(rawTxt, -1))
		if cnt > 0 {
			wordCnt = sql.NullInt64{int64(cnt), true}
		}

		tags = jl.ExtractTagsFromText(rawTxt)
	}

	art := &jl.Article{
		ID:          0, // note: we generate our own IDs at the JL end
		Title:       src.Headline,
		Byline:      "",
		Description: "",
		Content:     src.Content,
		PubDate:     pubDate,
		FirstSeen:   now,
		LastSeen:    now,
		Permalink:   bestURL,
		SrcURL:      bestURL,
		URLs:        make([]string, len(src.URLs)),
		Publication: pub,
		LastScraped: pq.NullTime{now, true},

		WordCount: wordCnt,
		Status:    'a',
		Tags:      tags,
	}
	copy(art.URLs, src.URLs)

	// authors
	authors := []*jl.UnresolvedJourno{}
	for _, a := range src.Authors {
		u := &jl.UnresolvedJourno{
			Name: a.Name,
			// TODO: Email, rel-author, twitter, etc..
		}
		authors = append(authors, u)
	}
	return art, authors
}