Golang beego.DateParse函数代码示例

//get specify week points.
//@ w param specify how many weeks data to get (not include this week)
func (this *Point) GetWeekPoints(w int) ([]string, interface{}) {
	var points []orm.Params
	o := orm.NewOrm()
	index_keys := []string{}
	result := make(map[string]interface{})

	t := time.Now()
	sunday_str := this.GetSunday(t)
	t, _ = beego.DateParse(sunday_str, "Y-m-d")
	for i := w; i >= 0; i-- {
		last_sunday := t.AddDate(0, 0, -7*i)
		last_monday := last_sunday.AddDate(0, 0, -6)
		last_sunday = last_sunday.Add(time.Hour*time.Duration(23) + time.Minute*time.Duration(59) + time.Second*time.Duration(59))
		end_time := beego.Date(last_sunday, "Y-m-d H:i:s")
		end_date := beego.Date(last_sunday, "Y-m-d")
		start_time := beego.Date(last_monday, "Y-m-d")

		data := make(map[string]interface{})
		data["start_time"] = start_time
		data["end_date"] = end_date
		data["end_time"] = end_time
		data["time_str"] = start_time + "_" + end_time
		o.QueryTable(new(Point)).Filter("start_time__gte", start_time).Filter("end_time__lte", end_time).Filter("status", 10).Values(&points)

		data["point"] = points
		result[end_time] = data

		// index_keys[w-i] = end_time
		index_keys = append(index_keys, end_time)
	}

	return index_keys, result
}

//返回当前时区的当前时间
func TimeLocal() time.Time {
	stime := "2006-01-02 15:04:05 -07:00 "
	datastring := beego.DateFormat(time.Now(), stime)
	rtime, _ := beego.DateParse(datastring, stime)
	fmt.Println(datastring, rtime)
	return rtime
}

// create a time limit code
// code format: 12 length date time string + 6 minutes string + 40 sha1 encoded string
func CreateTimeLimitCode(data string, minutes int, startInf interface{}) string {
	format := "YmdHi"

	var start, end time.Time
	var startStr, endStr string

	if startInf == nil {
		// Use now time create code
		start = time.Now()
		startStr = beego.Date(start, format)
	} else {
		// use start string create code
		startStr = startInf.(string)
		start, _ = beego.DateParse(startStr, format)
		startStr = beego.Date(start, format)
	}

	end = start.Add(time.Minute * time.Duration(minutes))
	endStr = beego.Date(end, format)

	// create sha1 encode string
	sh := sha1.New()
	sh.Write([]byte(data + setting.SecretKey + startStr + endStr + ToStr(minutes)))
	encoded := hex.EncodeToString(sh.Sum(nil))

	code := fmt.Sprintf("%s%06d%s", startStr, minutes, encoded)
	return code
}

//新增频道
func (this *Article) Create() {

	//Get方法
	if this.methodGet {
		this.Data["token"] = this.token()
		//所属频道选项
		this.Data["chs"] = channels.GetChannelSelectItems(0 /*, utils.ChNews*/)

		this.TplNames = this.getTplFileName("create")
		this.Render()
		return
	}
	//Post方法
	//签名错误，返回重复提交错误
	if this.invalidToken() {
		this.renderLoseToken()
		return
	}
	//数据模型
	m := new(models.Articles)

	models.Extend(m, this.xm)

	m.Channelid, _ = this.GetInt("channelid")
	m.Title = this.GetString("title")
	m.Subtitle = this.GetString("subtitle")
	m.Intro = this.GetString("intro")
	m.Content = this.GetString("content")
	m.Keywords = this.GetString("keywords")
	m.Description = this.GetString("description")
	m.Author = this.GetString("author")

	if this.GetString("status") == "on" {
		m.Status = 1
	} else {
		m.Status = 0
	}

	if t, err := beego.DateParse(this.GetString("published"), "Y-n-j H:i:s"); err == nil {
		m.Published = utils.Millisecond(t)
	} else {
		m.Published = utils.Millisecond(time.Now())
	}

	//数据合法性检验
	if data, inv := this.invalidModel(m); inv {
		this.renderJson(data)
		return
	}
	//提交DDL
	var data interface{}
	_, err := articles.Add(m)

	if err != nil {
		data = utils.JsonMessage(false, "", err.Error())
	} else {
		data = utils.JsonMessage(true, "", "")
	}
	this.renderJson(data)
}

func (m *Image) DecodeToken(token string) error {
	number := utils.NumberDecode(token, setting.ImageLinkAlphabets)
	if len(number) < 9 {
		return fmt.Errorf("token `%s` too short <- `%s`", token, number)
	}

	if t, err := beego.DateParse(number[:8], "ymds"); err != nil {
		return fmt.Errorf("token `%s` date parse error <- `%s`", token, number)
	} else {
		m.Created = t
	}

	var err error
	m.Id, err = utils.StrTo(number[8:]).Int()
	if err != nil {
		return fmt.Errorf("token `%s` id parse error <- `%s`", token, err)
	}

	return nil
}

// verify time limit code
func VerifyTimeLimitCode(data string, minutes int, code string) bool {
	if len(code) <= 18 {
		return false
	}

	// split code
	start := code[:12]
	lives := code[12:18]
	if d, err := StrTo(lives).Int(); err == nil {
		minutes = d
	}

	// right active code
	retCode := CreateTimeLimitCode(data, minutes, start)
	if retCode == code && minutes > 0 {
		// check time is expired or not
		before, _ := beego.DateParse(start, "YmdHi")
		now := time.Now()
		if before.Add(time.Minute*time.Duration(minutes)).Unix() > now.Unix() {
			return true
		}
	}
	return false
}

// parse request.Form values to form
func ParseForm(form interface{}, values url.Values) {
	val := reflect.ValueOf(form)
	elm := reflect.Indirect(val)

	panicAssertStructPtr(val)

outFor:
	for i := 0; i < elm.NumField(); i++ {
		f := elm.Field(i)
		fT := elm.Type().Field(i)

		fName := fT.Name

		for _, v := range strings.Split(fT.Tag.Get("form"), ";") {
			v = strings.TrimSpace(v)
			if v == "-" {
				continue outFor
			} else if i := strings.Index(v, "("); i > 0 && strings.Index(v, ")") == len(v)-1 {
				tN := v[:i]
				v = strings.TrimSpace(v[i+1 : len(v)-1])
				switch tN {
				case "name":
					fName = v
				}
			}
		}

		value := ""
		var vs []string
		if v, ok := values[fName]; ok {
			vs = v
			if len(v) > 0 {
				value = v[0]
			}
		}

		switch fT.Type.Kind() {
		case reflect.Bool:
			b, _ := StrTo(value).Bool()
			f.SetBool(b)
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			x, _ := StrTo(value).Int64()
			f.SetInt(x)
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			x, _ := StrTo(value).Uint64()
			f.SetUint(x)
		case reflect.Float32, reflect.Float64:
			x, _ := StrTo(value).Float64()
			f.SetFloat(x)
		case reflect.Struct:
			if fT.Type.String() == "time.Time" {
				if len(value) > 10 {
					t, err := beego.DateParse(value, setting.DateTimeFormat)
					if err != nil {
						continue
					}
					f.Set(reflect.ValueOf(t))
				} else {
					t, err := beego.DateParse(value, setting.DateFormat)
					if err != nil {
						continue
					}
					f.Set(reflect.ValueOf(t))
				}
			}
		case reflect.String:
			f.SetString(value)
		case reflect.Slice:
			f.Set(reflect.ValueOf(vs))
		}
	}
}

//.........这里部分代码省略.........
		}

		if no > 3 && !bingo {
			break
		}

		if no > 20 && bingo {
			return fmt.Errorf("document %s not contained ended tag `---`", path)
		}

		data := string(bytes.TrimSpace(line))

		if len(data) == 3 && data == "---" {

			if bingo {
				if doc.root {
					if len(docDir.FilePath) > 0 {
						return fmt.Errorf("node %s has a document %s, can not replicate by %s",
							docDir.Path, docDir.FilePath, path)
					}

					docDir.Name = doc.Name
					docDir.Date = doc.Date
					docDir.Link = doc.Link
					docDir.Sort = doc.Sort

				mFor:
					for {
						l, _, er := rd.ReadLine()
						if er != nil {
							break mFor
						}
						if len(bytes.TrimSpace(l)) > 0 {
							docDir.FilePath = path
							break mFor
						}
					}

					if len(docDir.Link) == 0 {
						docDir.Link = docDir.RelPath + "/"
					}

					docDir.FileRelPath = relPath

					doc = docDir
				} else {
					doc.RelPath = relPath
					doc.FilePath = path
					if len(doc.Link) == 0 {
						doc.Link = doc.RelPath
						// doc.Link = strings.TrimSuffix(doc.RelPath, filepath.Ext(doc.RelPath))
					}

					docDir.Docs = append(docDir.Docs, doc)
				}

				if dc, ok := d.links[doc.Link]; ok {
					return fmt.Errorf("document %s's link %s is already used by %s", path, doc.Link, dc.Path)
				}

				d.links[doc.Link] = doc

				break
			}

			doc = new(DocNode)
			doc.Path = path
			doc.Root = d
			doc.Parent = docDir

			bingo = true
		}

		if bingo {
			parts := strings.SplitN(data, ":", 2)
			if len(parts) == 2 {
				name := strings.TrimSpace(parts[0])
				value := strings.TrimSpace(parts[1])
				switch name {
				case "root":
					doc.root, _ = strconv.ParseBool(value)
				case "name":
					doc.Name = value
				case "date":
					doc.Date, err = beego.DateParse(value, "Y-m-d H:i")
					if err != nil {
						return err
					}
				case "link":
					doc.Link = value
				case "sort":
					n, _ := strconv.ParseInt(value, 10, 64)
					doc.Sort = int(n)
				}
			}
		}
	}

	return nil
}

//修改账户信息
func (this *Article) Edit() {

	//Get方法
	if this.methodGet {
		this.Data["token"] = this.token()

		id, err := this.getParamsInt64(":id")
		if err != nil {
			this.errorHandle(utils.JsonMessage(false, "invalidRequestParams", this.lang("invalidRequestParams")))
			return
		}

		c, err := articles.Get(id)

		if err != nil {
			this.errorHandle(utils.JsonMessage(false, "", err.Error()))
			return
		}
		this.Data["article"] = c
		//所属频道选项
		//this.Data["chs"] = channels.GetChannelSelectItems(-1, utils.ChNews, c.Channelid)
		this.Data["chs"] = channels.GetChannelSelectItems(0, -1, c.Channelid)

		this.TplNames = this.getTplFileName("edit")
		this.Render()
		return
	}
	//Post方法
	//签名错误，返回重复提交错误
	if this.invalidToken() {
		this.renderLoseToken()
		return
	}
	//提交DDL
	var data interface{}

	id, err := this.GetInt("id")
	if err != nil || id == 0 {
		this.errorHandle(utils.JsonMessage(false, "invalidRequestParams", this.lang("invalidRequestParams")))
		return
	}

	//获取原始数据模型
	m, err := articles.Get(id)
	if err != nil {
		this.errorHandle(utils.JsonMessage(false, "", err.Error()))
		return
	}
	//赋值
	m.Channelid, _ = this.GetInt("channelid")
	m.Title = this.GetString("title")
	m.Subtitle = this.GetString("subtitle")
	m.Intro = this.GetString("intro")
	m.Content = this.GetString("content")
	m.Keywords = this.GetString("keywords")
	m.Description = this.GetString("description")
	m.Author = this.GetString("author")
	m.Updated = this.xm.Updated
	m.Updator = this.xm.Updator
	m.Ip = this.xm.Ip

	if this.GetString("status") == "on" {
		m.Status = 1
	} else {
		m.Status = 0
	}

	if t, err := beego.DateParse(this.GetString("published"), "Y-n-j"); err == nil {
		m.Published = utils.Millisecond(t)
	} else {
		m.Published = utils.Millisecond(time.Now())
	}

	//数据合法性检验
	if data, inv := this.invalidModel(m); inv {
		this.renderJson(data)
		return
	}
	//提交DDL
	_, err = articles.Update(m)

	if err != nil {
		data = utils.JsonMessage(false, "", err.Error())
	} else {
		data = utils.JsonMessage(true, "", "")
	}
	this.renderJson(data)
}

//返回当前时区的当前时间
func DateLocal() time.Time {
	sdate := "2006-01-02"
	datastring := beego.DateFormat(time.Now(), sdate)
	rtime, _ := beego.DateParse(datastring, sdate)
	return rtime
}