Skip to content

张磊 / FileStorageBeego

Go to a project
Toggle navigation
Toggle navigation pinning
afebcd89 by xiemengjun
Options

删除老的文件

1 parent 818a34dd
Inline Side-by-side
Showing 20 changed files with 0 additions and 326 deletions
.DS_Store 0 → 100644
No preview for this file type
beego/beego.go deleted 100644 → 0
package beego
import {
"net"
"net/http"
"net/http/fcgi"
"log"
"strconv"
"./core"
}
type C struct {
core.Content
}
type M struct{
core.Model
}
type D struct{
core.Config
}
type U struct{
core.URL
}
type A struct{
core.Controller
}
type V struct{
core.View
}
type BeegoApp struct{
Port int
}
func (app *BeegoApp) BeeListen(port int) {
app.Port = port
err := http.ListenAndServe(":"+strconv.Itoa(app.Port), nil)
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
}
func (app *BeegoApp) BeeListenFcgi(port int) {
app.Port = port
l, err := net.Listen("tcp", "127.0.0.1:"+strconv.Itoa(port))
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
fcgi.Serve(l, app.Handler)
}
func Run() {
rootPath, _ := os.Getwd()
}
\ No newline at end of file
beego/core/acl.go deleted 100644 → 0
File mode changed
beego/core/controller.go deleted 100644 → 0
package beego
// Interface for controller types that handle requests
type Controller interface {
// When implemented, handles the request
HandleRequest(c *Context)
}
// The ControllerFunc type is an adapter to allow the use of
// ordinary functions as goweb handlers. If f is a function
// with the appropriate signature, ControllerFunc(f) is a
// Controller object that calls f.
type ControllerFunc func(*Context)
// HandleRequest calls f(c).
func (f ControllerFunc) HandleRequest(c *Context) {
f(c)
}
\ No newline at end of file
beego/core/router.go deleted 100644 → 0
package beego
import (
"regexp"
"strings"
)
/*
Route
*/
// Represents a single route mapping
type Route struct {
pattern string
parameterKeys ParameterKeyMap
extension string
Path string
Controller Controller
MatcherFuncs []RouteMatcherFunc
}
func (r *Route) String() string {
return "{Route:'" + r.Path + "'}"
}
// Makes a new route from the given path
func makeRouteFromPath(path string) *Route {
// get the path segments
segments := getPathSegments(path)
regexSegments := make([]string, len(segments))
// prepare the parameter key map
var paramKeys ParameterKeyMap = make(ParameterKeyMap)
var extension string
// pull out any dynamic segments
for index, _ := range segments {
if isDynamicSegment(segments[index]) {
// e.g. {id}
paramKeys[strings.Trim(segments[index], "{}")] = index
regexSegments[index] = ROUTE_REGEX_PLACEHOLDER
} else if isExtensionSegment(segments[index]) {
// e.g. .json
extension = segments[index]
// trim off the last space (we don't need it)
regexSegments = regexSegments[0 : len(regexSegments)-1]
} else {
// e.g. "groups"
regexSegments[index] = segments[index]
}
}
patternString := "/" + strings.Join(regexSegments, "/")
// return a new route
var route *Route = new(Route)
route.pattern = patternString
route.extension = extension
route.parameterKeys = paramKeys
route.Path = path
route.Controller = nil
return route
}
// Gets the parameter values for the route from the specified path
func (route *Route) getParameterValueMap(path string) ParameterValueMap {
return getParameterValueMap(route.parameterKeys, path)
}
// Checks whether a path matches a route or not
func (route *Route) DoesMatchPath(path string) bool {
match, error := regexp.MatchString(route.pattern, path)
if error == nil {
if match {
if len(route.extension) > 0 {
// make sure the extensions match too
return strings.HasSuffix(strings.ToLower(path), strings.ToLower(route.extension))
} else {
return match
}
} else {
return false
}
}
// error :-(
return false
}
// Checks whether the context for this request matches the route
func (route *Route) DoesMatchContext(c *Context) bool {
// by default, we match
var match bool = true
if len(route.MatcherFuncs) > 0 {
// there are some matcher functions, so don't automatically
// match by default - let the matchers decide
match = false
// loop through the matcher functions
for _, f := range route.MatcherFuncs {
// modify 'match' based on the result of the matcher function
switch f(c) {
case NoMatch:
match = false
case Match:
match = true
}
}
}
// return the result
return match
}
\ No newline at end of file
beego/helper/config.go deleted 100644 → 0
package helper
import (
"json"
"io/ioutil"
"log"
)
var config map[string]string
func ReadConfig(filename string) {
contents, err := ioutil.ReadFile(filename)
if err != nil {
log.Exitf("Impossible to read %s", filename, err)
}
data, err := json.Decode(string(contents))
if err != nil {
log.Exitf("Can't parse %s as JSON", filename, err)
}
config = map[string]string{ }
for key, value := range data.(map[string]interface{ }) {
config[key] = value.(string)
}
}
func GetConfig(key string) string {
return config[key];
}
\ No newline at end of file
beego/server/server.go deleted 100644 → 0
package server
import (
"bufio"
"bytes"
"errors"
"io"
"log"
"net"
"net/url"
"runtime/debug"
"strconv"
"strings"
)
\ No newline at end of file
examples/blog/blog.go deleted 100644 → 0
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package guestbook
import (
"../../beego"
)
func init() {
beego.C.loadconfig()
}
func main() {
app:=beego.App
app.Run()
}
\ No newline at end of file
examples/blog/configs/app.yaml deleted 100644 → 0
application: blog
handlers:
- url: "/user"
handlefun:"user.Index"
- url: "/blog"
handlefun:"blog.Index"
\ No newline at end of file
examples/blog/controller/user.go deleted 100644 → 0
package controller
import (
"github.com/astaxie/beego/beego"
"../model"
)
func UserIndex(w beego.A) {
userinfo :=model.User.getAll()
beego.V.Render(w,"users/index")
}
\ No newline at end of file
examples/blog/model/user.go deleted 100644 → 0
package model
import (
"./beego"
)
type Users struct {
username string
password string
beego.M
}
func NewUsers() (a *Users) {
return &Users{}
}
\ No newline at end of file
examples/hello/hello.go deleted 100644 → 0
package helloworld
import (
"fmt"
"net/http"
)
func init() {
http.HandleFunc("/", handle)
}
func handle(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "<html><body>Hello, World! 세상아 안녕!</body></html>")
}
Styling with Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!