Golang Row.Time方法代码示例

func (n NewsItem) PopulateNewsItem(row mysql.Row, res mysql.Result, ch chan NewsItem) {
	item := NewsItem{
		ID:           row.Int(res.Map("newsItemID")),
		Title:        row.Str(res.Map("title")),
		Lead:         row.Str(res.Map("lead")),
		Content:      row.Str(res.Map("content")),
		PublishStart: row.Time(res.Map("publishStart"), UTC),
		PublishEnd:   row.Time(res.Map("publishEnd"), UTC),
		Active:       row.Bool(res.Map("active")),
		Slug:         row.Str(res.Map("slug")),
	}
	ch <- item
}

func (c Comment) PopulateComment(row mysql.Row, res mysql.Result, ch chan Comment) {
	comment := Comment{
		ID:       row.Int(res.Map("commentID")),
		PostID:   row.Int(res.Map("blogPostID")),
		Name:     row.Str(res.Map("name")),
		Email:    row.Str(res.Map("email")),
		Comment:  row.Str(res.Map("comment_text")),
		Created:  row.Time(res.Map("createdDate"), UTC),
		Approved: row.Bool(res.Map("approved")),
		Active:   row.Bool(res.Map("active")),
	}
	ch <- comment
}

func (v Video) PopulateVideo(row mysql.Row, res mysql.Result, ch chan Video) {
	video := Video{
		ID:          row.Int(res.Map("videoID")),
		EmbedLink:   row.Str(res.Map("embed_link")),
		DateAdded:   row.Time(res.Map("dateAdded"), UTC),
		Sort:        row.Int(res.Map("sort")),
		Title:       row.Str(res.Map("title")),
		Description: row.Str(res.Map("description")),
		YouTubeID:   row.Str(res.Map("youtubeID")),
		WatchPage:   row.Str(res.Map("watchpage")),
		Screenshot:  row.Str(res.Map("screenshot")),
	}
	ch <- video
}

func (c CustomerUser) PopulateUser(row mysql.Row, res mysql.Result, ch chan CustomerUser) {
	user := CustomerUser{
		ID:          row.Str(res.Map("id")),
		CustID:      row.Int(res.Map("cust_ID")),
		CustomerID:  row.Int(res.Map("customerID")),
		Name:        row.Str(res.Map("name")),
		Email:       row.Str(res.Map("email")),
		DateAdded:   row.Time(res.Map("date_added"), UTC),
		Active:      row.Bool(res.Map("active")),
		LocationID:  row.Int(res.Map("locationID")),
		IsSudo:      row.Bool(res.Map("isSudo")),
		NotCustomer: row.Bool(res.Map("NotCustomer")),
	}
	ch <- user
}

func (t Testimonial) PopulateTestimonial(row mysql.Row, res mysql.Result, ch chan Testimonial) {
	testimonial := Testimonial{
		ID:        row.Int(res.Map("testimonialID")),
		Rating:    row.Float(res.Map("rating")),
		Title:     row.Str(res.Map("title")),
		Content:   row.Str(res.Map("testimonial")),
		DateAdded: row.Time(res.Map("dateAdded"), UTC),
		Approved:  row.Bool(res.Map("approved")),
		Active:    row.Bool(res.Map("active")),
		FirstName: row.Str(res.Map("first_name")),
		LastName:  row.Str(res.Map("last_name")),
		Location:  row.Str(res.Map("location")),
	}
	ch <- testimonial
}

func (c CustomerUser) PopulateKey(row mysql.Row, res mysql.Result, ch chan APIKey) {
	keyType := APIKeyType{
		ID:        row.Str(res.Map("type_id")),
		Type:      row.Str(res.Map("type")),
		DateAdded: row.Time(res.Map("typeDateAdded"), UTC),
	}
	key := APIKey{
		ID:        row.Str(res.Map("id")),
		UserID:    row.Str(res.Map("user_id")),
		Key:       row.Str(res.Map("api_key")),
		TypeID:    keyType.ID,
		DateAdded: row.Time(res.Map("date_added"), UTC),
		KeyType:   keyType,
	}
	ch <- key
}

func (c Contact) PopulateContact(row mysql.Row, res mysql.Result, ch chan Contact) {
	contact := Contact{
		ID:         row.Int(res.Map("contactID")),
		FirstName:  row.Str(res.Map("first_name")),
		LastName:   row.Str(res.Map("last_name")),
		Email:      row.Str(res.Map("email")),
		Phone:      row.Str(res.Map("phone")),
		Subject:    row.Str(res.Map("subject")),
		Message:    row.Str(res.Map("message")),
		Created:    row.Time(res.Map("createdDate"), UTC),
		Type:       row.Str(res.Map("type")),
		Address1:   row.Str(res.Map("address1")),
		Address2:   row.Str(res.Map("address2")),
		City:       row.Str(res.Map("city")),
		PostalCode: row.Str(res.Map("postalcode")),
		Country:    row.Str(res.Map("country")),
	}
	ch <- contact
}

func PopulateRevision(row mysql.Row, res mysql.Result, ch chan ContentRevision) {
	var revision ContentRevision

	id := res.Map("revisionID")
	contentID := res.Map("contentID")
	contentText := res.Map("content_text")
	createdOn := res.Map("createdOn")
	active := res.Map("active")

	revision = ContentRevision{
		ID:          row.Int(id),
		ContentID:   row.Int(contentID),
		ContentText: row.Str(contentText),
		CreatedOn:   row.Time(createdOn, UTC),
		Active:      row.Bool(active),
	}

	ch <- revision
}

func PopulateContent(row mysql.Row, res mysql.Result, ch chan Content) {
	cid := res.Map("contentID")
	contentType := res.Map("content_type")
	pageTitle := res.Map("page_title")
	createdDate := res.Map("createdDate")
	lastModified := res.Map("lastModified")
	metaTitle := res.Map("meta_title")
	metaDesc := res.Map("meta_description")
	keywords := res.Map("keywords")
	isPrimary := res.Map("isPrimary")
	published := res.Map("published")
	active := res.Map("active")
	slug := res.Map("slug")
	requireAuth := res.Map("requireAuthentication")
	canonical := res.Map("canonical")
	var content Content

	id := row.Int(cid)
	revCh := make(chan ContentRevisions)
	go GetContentRevisions(id, revCh)
	revisions := <-revCh
	content = Content{
		ID:              id,
		ContentType:     row.Str(contentType),
		PageTitle:       row.Str(pageTitle),
		CreatedDate:     row.Time(createdDate, UTC),
		LastModified:    row.Time(lastModified, UTC),
		MetaTitle:       row.Str(metaTitle),
		MetaDescription: row.Str(metaDesc),
		Keywords:        row.Str(keywords),
		Primary:         row.Bool(isPrimary),
		Published:       row.Bool(published),
		Active:          row.Bool(active),
		Slug:            row.Str(slug),
		RequireAuth:     row.Bool(requireAuth),
		Canonical:       row.Str(canonical),
		Revisions:       revisions,
		ActiveRevision:  revisions.GetActiveRevision(),
	}
	ch <- content
}

func (l LandingPage) populateLandingPage(row mysql.Row, res mysql.Result, ch chan LandingPage) {
	page := LandingPage{
		ID:              row.Int(res.Map("id")),
		Name:            row.Str(res.Map("name")),
		Start:           row.Time(res.Map("startDate"), UTC),
		End:             row.Time(res.Map("endDate"), UTC),
		URL:             row.Str(res.Map("url")),
		Content:         row.Str(res.Map("pageContent")),
		LinkClasses:     row.Str(res.Map("linkClasses")),
		ConversionID:    row.Str(res.Map("conversionID")),
		ConversionLabel: row.Str(res.Map("conversionLabel")),
		NewWindow:       row.Bool(res.Map("newWindow")),
		MenuPosition:    row.Str(res.Map("menuPosition")),
	}
	dch := make(chan []LandingPageData)
	ich := make(chan LandingPageImages)
	go page.getImages(ich)
	go page.getData(dch)
	page.Images = <-ich
	page.Data = <-dch

	ch <- page
}

func (p Post) PopulatePost(row mysql.Row, res mysql.Result, ch chan Post) {
	post := Post{
		ID:           row.Int(res.Map("blogPostID")),
		Title:        row.Str(res.Map("post_title")),
		Slug:         row.Str(res.Map("slug")),
		Content:      row.Str(res.Map("post_text")),
		Published:    row.Time(res.Map("publishedDate"), UTC),
		Created:      row.Time(res.Map("createdDate"), UTC),
		LastModified: row.Time(res.Map("lastModified"), UTC),
		UserID:       row.Int(res.Map("userID")),
		MetaTitle:    row.Str(res.Map("meta_title")),
		MetaDesc:     row.Str(res.Map("meta_description")),
		Keywords:     row.Str(res.Map("keywords")),
		Active:       row.Bool(res.Map("active")),
	}
	catchan := make(chan BlogCategories)
	comchan := make(chan Comments)
	authchan := make(chan User)
	go func(ch chan User) {
		author, _ := GetUserByID(post.UserID)
		ch <- author
	}(authchan)
	go func(ch chan Comments) {
		comments, _ := post.GetComments()
		ch <- comments
	}(comchan)
	go func(ch chan BlogCategories) {
		categories, _ := post.GetCategories()
		ch <- categories
	}(catchan)

	post.Author = <-authchan
	post.Categories = <-catchan
	post.Comments = <-comchan
	ch <- post
}