Golang Time.Seconds方法代码示例

func (self *Indexer) decodeNode(schema *superSchema, blobref string) (result interface{}, err os.Error) {
	if schema.Signer == "" {
		return nil, os.NewError("Missing signer")
	}
	var tstruct *time.Time
	tstruct, err = time.Parse(time.RFC3339, schema.Time)
	if err != nil || tstruct == nil {
		return
	}
	t := tstruct.Seconds()
	switch schema.Type {
	case "keep":
		n := &keepNode{blobref: blobref, node: node{time: t, signer: schema.Signer, parent: schema.PermaNode}, dependencies: schema.Dependencies, permission: schema.Permission}
		return n, nil
	case "permanode":
		n := &PermaNode{blobref: blobref, node: node{time: t, signer: schema.Signer, parent: schema.PermaNode}, keeps: make(map[string]string), pendingInvitations: make(map[string]string)}
		return n, nil
	case "mutation":
		if schema.Operation == nil {
			err = os.NewError("mutation is lacking an operation")
			return
		}
		if schema.Site == "" {
			err = os.NewError("mutation is lacking a site identifier")
		}
		n := &mutationNode{node: node{time: t, signer: schema.Signer, parent: schema.PermaNode}}
		n.mutation.Operation = *schema.Operation
		n.mutation.ID = blobref
		n.mutation.Site = schema.Site
		n.mutation.Dependencies = schema.Dependencies
		return n, nil
	case "permission":
		if schema.User == "" {
			err = os.NewError("permission is lacking a target user")
			return
		}
		n := &permissionNode{node: node{time: t, signer: schema.Signer, parent: schema.PermaNode}}
		n.permission.ID = blobref
		n.permission.Dependencies = schema.Dependencies
		n.permission.User = schema.User
		n.permission.Allow = schema.Allow
		n.permission.Deny = schema.Deny
		switch schema.Action {
		case "invite":
			n.action = PermAction_Invite
		case "expel":
			n.action = PermAction_Expel
		case "change":
			n.action = PermAction_Change
		default:
			err = os.NewError("Unknown action type in permission blob")
			return
		}
		return n, nil
	default:
		log.Printf("Unknown schema type")
	}
	return nil, os.NewError("Unknown schema type")
}

func serveFile(c *ServiceContext, file string) bool {
	var err os.Error
	var f *os.File
	var t *time.Time
	var modified int64

	file = path.Clean(file)
	if f, err = os.Open(file, os.O_RDONLY, 0); err != nil {
		c.Status(404)
		return false
	}

	defer f.Close()

	stat, _ := f.Stat()
	modified = stat.Mtime_ns / 1e9

	if v, ok := c.Req.Header["If_Modified_Since"]; ok {
		v = v[0:len(v)-3] + "UTC"

		if t, err = time.Parse(v, time.RFC1123); err != nil {
			fmt.Fprintf(os.Stderr, "Unrecognized time format in If_Modified_Since header: %s", v)
			return false
		}

		if modified > t.Seconds() {
			c.Status(200)
		} else {
			c.Status(304)
		}

		return true
	}

	if ctype := mime.TypeByExtension(path.Ext(file)); ctype != "" {
		c.SetHeaders(200, 2592000, ctype, modified)
	} else {
		var data []byte
		var num int64

		buf := bytes.NewBuffer(data)
		if num, err = io.Copyn(buf, f, 1024); err != nil {
			c.Status(500)
			return false
		}

		data = buf.Bytes()
		if isText(data[0:num]) {
			c.SetHeaders(200, 2592000, "text/plain; charset=utf-8", modified)
		} else {
			c.SetHeaders(200, 2592000, "application/octet-stream", modified)
		}
	}

	_, err = c.SendReadWriter(f)
	return err == nil
}

//returns posts for a certain date
func (md *MongoDB) GetPostsForDate(date time.Time) (posts []BlogPost, err os.Error) {
	date.Hour = 0
	date.Minute = 0
	date.Second = 0

	start := date.Seconds()
	end := start + (24 * 60 * 60)

	return md.GetPostsForTimespan(start, end, -1)
}

// Set Value From HTMLForm Values
func (t *Tasks) SetValue(Id string, r *http.Request) os.Error {

	var err os.Error

	t.UserId = Id
	t.KeyID, err = strconv.Atoi64(r.FormValue(FORM_KEY))
	if err != nil {
		t.KeyID = 0
	}
	t.Status, err = strconv.Atoi(r.FormValue(FORM_STATUS))
	if err != nil {
		log.Println(err)
		return err
	}

	log.Println("Status")

	t.Context = html.EscapeString(r.FormValue(FORM_CONTEXT))
	t.IsUseLimit, err = strconv.Atob(r.FormValue(FORM_LIMIT))
	if err != nil {
		log.Println(err)
		return err
	}

	log.Println("IsUseLimit")

	t.IsComplete = (t.Status == 2)
	t.IsCanceld = (t.Status == 9)

	log.Println("Set Bool Value")

	if t.IsUseLimit {

		log.Println(r.FormValue(FORM_DATE))
		log.Println(time.RFC3339)
		var limit *time.Time
		limit, err = time.Parse("2006-01-02 15:04:05", r.FormValue(FORM_DATE))
		if err == nil {
			t.PlanDate = datastore.SecondsToTime(limit.Seconds())
		} else {
			log.Println(err)
			return err
		}
	}

	log.Println("PostDate")
	t.PostDate = datastore.SecondsToTime(time.Seconds())
	if t.IsComplete {
		t.CompleteDate = datastore.SecondsToTime(time.Seconds())
	}

	return nil

}

func solve(birthday time.Time, today time.Time, lifetime int64) (hour, minute, second int) {
	death := time.Time{Year: birthday.Year + lifetime, Month: birthday.Month, Day: birthday.Day}
	total := death.Seconds() - birthday.Seconds()
	cur := today.Seconds() - birthday.Seconds()
	result_s := 3600 * 24 * cur / total
	return int(result_s / 3600), int((result_s / 60) % 60), int(result_s % 60)
}

func gdate() string {
	now := time.LocalTime()
	now.Hour = 24
	now.Minute = 60
	now.Second = 60
	var ny time.Time
	ny.Year = now.Year
	ny.Month = 1
	ny.Day = 1
	ny.Hour = 0
	ny.Minute = 0
	ny.Second = 0
	ny.Zone = "CST"
	day := (now.Seconds() - ny.Seconds()) / 86400
	return strconv.Itoa64(day) + ", " + strconv.Itoa64(now.Year)
}

// Last-Modified > I-M-S?
func (p *wmDecisionCore) doV3l17() WMDecision {
	t := p.modifiedSince
	var lastModified *time.Time
	var httpCode int
	var httpError os.Error
	lastModified, p.req, p.cxt, httpCode, httpError = p.handler.LastModified(p.req, p.cxt)
	if httpCode > 0 {
		p.writeHaltOrError(httpCode, httpError)
		return wmResponded
	}
	if lastModified == nil || t == nil || lastModified.Seconds() > t.Seconds() {
		return v3m16
	}
	p.resp.WriteHeader(304)
	return wmResponded
}

func gtime() string {
	now := time.LocalTime()
	var tsec int64
	{
		var t time.Time = *now
		t.Hour = 0
		t.Minute = 0
		t.Second = 0
		tsec = (now.Seconds() - t.Seconds()) * 1000
	}
	ms := int64(86400 * 1000)
	hour := int64((float64(tsec) / float64(ms)) * 10)
	tsec -= int64((ms / 10) * hour)
	minute := int64((float64(tsec) / (float64(ms) / 10)) * 100)
	tsec -= int64((ms / 1000) * minute)
	second := int64((float64(tsec) / (float64(ms) / 100)) * 10000)
	return strconv.Itoa64(hour) + ":" + strconv.Itoa64(minute) + ":" + strconv.Itoa64(second)
}

//returns posts for a certain month
func (md *MongoDB) GetPostsForMonth(date time.Time) (posts []BlogPost, err os.Error) {
	date.Hour = 0
	date.Minute = 0
	date.Second = 0
	date.Day = 1

	next_month := date
	next_month.Month++
	if next_month.Month > 12 {
		next_month.Month = 1
		next_month.Year++
	}

	start := date.Seconds()
	end := next_month.Seconds()

	return md.GetPostsForTimespan(start, end, -1)
}

// Last-Modified > I-UM-S?
func (p *wmDecisionCore) doV3h12() WMDecision {
	var lastModified *time.Time
	var httpCode int
	var httpError os.Error
	lastModified, p.req, p.cxt, httpCode, httpError = p.handler.LastModified(p.req, p.cxt)
	if httpCode > 0 {
		p.writeHaltOrError(httpCode, httpError)
		return wmResponded
	}
	t := p.unmodifiedSince
	if t != nil && lastModified != nil {
		log.Print("[WMC]: comparing Last-Modified internal: ", t.Seconds(), " vs. received from client ", lastModified.Seconds())
	}
	if t != lastModified && t != nil && lastModified != nil && lastModified.Seconds() > t.Seconds() {
		p.resp.WriteHeader(412)
		return wmResponded
	}
	return v3i12
}

func DisableLoginAt(ds DataStore, userId string, at *time.Time) os.Error {
	user, err := ds.RetrieveUserAccountById(userId)
	if user == nil || err != nil {
		return err
	}
	if user.AllowLogin {
		now := time.UTC().Seconds()
		if user.DisableLoginAt == 0 || user.DisableLoginAt < now || (at != nil && at.Seconds() < now) {
			user.AllowLogin = false
			user.DisableLoginAt = 0
		} else if at == nil {
			user.DisableLoginAt = 0
		} else {
			user.DisableLoginAt = at.Seconds()
		}
		_, err = ds.UpdateUserAccount(user)
	}
	return err
}

func (mi *Indexer) PathLookup(signer, base *blobref.BlobRef, suffix string, at *time.Time) (*search.Path, os.Error) {
	// TODO: pass along the at time to a new helper function to
	// filter? maybe not worth it, since this list should be
	// small.
	paths, err := mi.PathsLookup(signer, base, suffix)
	if err != nil {
		return nil, err
	}
	var (
		newest    = int64(0)
		atSeconds = int64(0)
		best      *search.Path
	)
	if at != nil {
		atSeconds = at.Seconds()
	}
	for _, path := range paths {
		t, err := time.Parse(time.RFC3339, trimRFC3339Subseconds(path.ClaimDate))
		if err != nil {
			continue
		}
		secs := t.Seconds()
		if atSeconds != 0 && secs > atSeconds {
			// Too new
			continue
		}
		if newest > secs {
			// Too old
			continue
		}
		// Just right
		newest, best = secs, path
	}
	if best == nil {
		return nil, os.ENOENT
	}
	return best, nil
}

//
// See also FreeBSD inetd implementation:
// http://www.freebsd.org/cgi/cvsweb.cgi/src/usr.sbin/inetd/builtins.c?rev=1.45.14.1;content-type=text%2Fplain
// machtime()
//
func RFC868Time(tm time.Time) uint32 {
	tm64 := tm.Seconds()
	// fmt.Println(tm64)
	return uint32((tm64 + TIME_OFFSET) & 0xFFFFFFFF)
}

func (rs *ResultSet) timeSeconds(ord int) (value int64, isNull bool) {
	if rs.conn.LogLevel >= LogVerbose {
		defer rs.conn.logExit(rs.conn.logEnter("*ResultSet.timeSeconds"))
	}

	isNull = rs.isNull(ord)
	if isNull {
		return
	}

	val := rs.values[ord]

	var t *time.Time

	switch rs.fields[ord].format {
	case textFormat:
		var format string
		switch rs.fields[ord].typeOID {
		case _DATEOID:
			format = rs.conn.dateFormat

		case _TIMEOID, _TIMETZOID:
			format = rs.conn.timeFormat

		case _TIMESTAMPOID, _TIMESTAMPTZOID:
			format = rs.conn.timestampFormat
		}

		switch rs.fields[ord].typeOID {
		case _TIMETZOID:
			format += "-07"

		case _TIMESTAMPTZOID:
			format += rs.conn.timestampTimezoneFormat
		}

		s := string(val)

		if rs.fields[ord].typeOID != _DATEOID {
			// The resolution of time.Time is seconds, so we will have to drop
			// fractions, if present.
			lastSemicolon := strings.LastIndex(s, ":")
			lastDot := strings.LastIndex(s, ".")
			if lastSemicolon < lastDot {
				// There are fractions
				plusOrMinus := strings.IndexAny(s[lastDot:], "+-")
				if -1 < plusOrMinus {
					// There is a time zone
					s = s[:lastDot] + s[lastDot+plusOrMinus:]
				} else {
					s = s[:lastDot]
				}
			}
		}

		var err os.Error
		t, err = time.Parse(format, s)
		panicIfErr(err)

	case binaryFormat:
		panicNotImplemented()
	}

	value = t.Seconds()

	return
}

func getCal(args []string) (result string) {
	var start, end *time.Time

	if args == nil {
		start = time.LocalTime()

		end = time.LocalTime()
		end.Month += scheduleHorizon
		if end.Month > 12 {
			end.Month %= 12
			end.Year++
		}
	} else if len(args) == 1 {
		start = parseTime(args[0])

		if start == nil {
			return fmt.Sprintf("Couldn't parse '%s' as a date, expected format %s", args[0], timeFormatHelp)
		}

		end = new(time.Time)
		*end = *start
		end.Hour = 23
		end.Minute = 59
	} else {
		start = parseTime(args[0])

		if start == nil {
			return fmt.Sprintf("Couldn't parse '%s' as a date, expected format %s", args[0], timeFormatHelp)
		}

		end = parseTime(args[1])

		if end == nil {
			return fmt.Sprintf("Couldn't parse '%s' as a date, expected format %s", args[1], timeFormatHelp)
		}

		end.Hour = 23
		end.Minute = 59

		if start.Seconds() > end.Seconds() {
			result = "StartDate > EndDate, swapping.\n"
			start, end = end, start
		}

	}

	response, _, err := http.Get(fmt.Sprintf("http://www.google.com/calendar/feeds/psuacm%%40cs.pdx.edu/public/basic?start-min=%s&start-max=%s&prettyprint=true&fields=openSearch:totalResults,entry(title,content)&orderby=starttime",
		start.Format(time.RFC3339), end.Format(time.RFC3339)))

	if err != nil {
		errors.Printf("Error retrieving calendar: %v\n", err)
		return "Error retrieving calendar from teh google"
	}

	defer response.Body.Close()

	f := &calFeed{}
	err = xml.Unmarshal(response.Body, f)

	if err != nil {
		errors.Printf("Error parsing calendar xml: %v\n", err)
		return "XML Fail:  Go yell at cbeck for not using json."
	}

	for _, event := range f.Entry {
		result = fmt.Sprintf("%s: %s\n", event.Content[6:strings.Index(event.Content, " to")], event.Title) + result
	}

	if f.TotalResults == 0 {
		if start.Day == end.Day && start.Month == end.Month && start.Year == end.Year {
			result += fmt.Sprintf("Nothing scheduled on %s", start.Format(timeFormat))
		} else {
			result += fmt.Sprintf("Nothing scheduled in range %s - %s", start.Format(timeFormat), end.Format(timeFormat))
		}
	}

	return
}