func main() {
email := os.Getenv("SORACOM_EMAIL")
password := os.Getenv("SORACOM_PASSWORD")
if email == "" {
fmt.Println("SORACOM_EMAIL env var is required")
os.Exit(1)
return
}
if password == "" {
fmt.Println("SORACOM_PASSWORD env var is required")
os.Exit(1)
return
}
ac := soracom.NewAPIClient(nil)
err := ac.Auth(email, password)
if err != nil {
fmt.Printf("auth err: %v\n", err.Error())
return
}
subscribers, lek, err := ac.ListSubscribers(nil)
if err != nil {
fmt.Printf("err: %v\n", err.Error())
return
}
pp.Print(subscribers)
pp.Print(lek)
}
func loadConfig() {
_, err := toml.DecodeFile(*conf, &config)
if err != nil {
log.Fatal(err)
}
pp.Print(config)
}
func PointsAround() {
gg := gegeo.GeGeoPoint{
Id: "123",
Title: "Перви",
Location: &gegeo.Location{
Latitude: 55.7099235,
Longitude: 60.5512079,
},
}
log.Printf("%#v", gg)
var query = map[string]interface{}{
"size": 0,
"aggregations": map[string]interface{}{
"around": map[string]interface{}{
// число точек вокруг текущей с группировкой по расстоянию
"geo_distance": map[string]interface{}{
"field": "geopoints.location",
"origin": map[string]interface{}{
"lat": gg.Location.Latitude,
"lon": gg.Location.Longitude,
},
"unit": "km",
"ranges": []interface{}{
map[string]interface{}{
"to": "10",
},
map[string]interface{}{
"from": "10",
"to": "100",
},
map[string]interface{}{
"from": "100",
},
},
},
"aggregations": map[string]interface{}{
"district": map[string]interface{}{
"terms": map[string]interface{}{
"field": "metadate.addr:district",
"size": 3,
},
},
},
},
},
}
extraArgs := make(url.Values, 1)
searchResults, err := connection.Search(query, []string{GEINDEX}, []string{GETYPE}, extraArgs)
if err != nil {
panic(err)
}
pp.Print(searchResults)
}
func main() {
node, err := csv.Crawler("test")
if err != nil {
log.Fatalln(err)
}
const jsonStream = `{
"union": {
"input1": {"selection": {
"input": { "relation": { "name": "dir1/staff2" } },
"attr": "age", "selector": ">=", "arg": 31
}},
"input2": {"selection": {
"input": { "relation": { "name": "dir1/staff2" } },
"attr": "name", "selector": "==", "arg": "山田"
}}
}
}`
m := core.Stream{}
if err := json.NewDecoder(strings.NewReader(jsonStream)).Decode(&m); err != nil {
log.Fatal(err)
}
result, err := core.StreamToRelation(m, node)
if err != nil {
log.Fatalln(err)
}
pp.Print(result)
}
func InfoCommand(c *cli.Context) {
path := c.Args()[0]
qemuImg := cangallo.QemuImg{}
info, _ := qemuImg.Info(path)
pp.Print(info)
}
func main() {
http.Handle("/", http.FileServer(http.Dir(".")))
http.HandleFunc("/send", func(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
pp.Print(r)
//
// out, err := os.Create("test.jpg")
// if err != nil {
// fmt.Printf("error %v", err)
// return
// }
//
// defer out.Close()
//
// _, err = io.Copy(out, r.Body)
// if err != nil {
// fmt.Printf("error %v", err)
// return
// }
file, header, err := r.FormFile("file")
if err != nil {
fmt.Printf("error %v", err)
return
}
defer file.Close()
out, err := os.Create(header.Filename)
if err != nil {
fmt.Printf("error %v", err)
return
}
defer out.Close()
_, err = io.Copy(out, file)
if err != nil {
fmt.Printf("error %v", err)
return
}
fmt.Printf("file upload success! %v", header.Filename)
} else {
fmt.Printf("Method is %v", r.Method)
}
})
err := http.ListenAndServe(":9999", nil)
if err != nil {
log.Fatal("Error listening:", err)
}
}
func handle(ctx context.Context, w http.ResponseWriter, r *http.Request) {
pp.Print(ctx)
authInfo := auth.FromContext(ctx)
authInfo.UpdateHeaders(w.Header())
if authInfo == nil || !authInfo.Authenticated {
http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
return
}
fmt.Fprintf(w, "<html><body><h1>Hello, %s!</h1></body></html>", authInfo.Username)
}
func Search(c projects.ProjectsServiceClient, ctx context.Context, terms string) {
req := &projects.ProjectsSearchRequest{SearchTerms: terms}
log.Printf("Searching for '%s'", terms)
resp, err := c.Search(ctx, req)
if err != nil {
log.Fatalf("could not search: %v", err)
}
log.Printf("Found %d of %d possible", resp.Results, resp.Known)
pp.Print(resp.Projects)
}
func Create(c projects.ProjectsServiceClient, ctx context.Context, id, name string) {
uid := parseID(id)
p := projects.Project{Id: uid, Name: name}
created, err := c.Create(ctx, &p)
if grpc.Code(err) == codes.AlreadyExists {
log.Printf("that ID is taken")
return
} else if err != nil {
log.Fatalf("could not create: %v", err)
return
}
pp.Print(created)
}
func Find(c projects.ProjectsServiceClient, ctx context.Context, id string) {
uid := parseID(id)
log.Printf("Finding '%d'", uid)
proj, err := c.Get(ctx, &projects.ProjectRequest{Id: uid})
if grpc.Code(err) == codes.NotFound {
log.Printf("the project you wanted does not exist")
return
} else if err != nil {
log.Fatalf("could not find: %v", err)
return
}
pp.Print(proj)
}
func SlowSearch(c projects.ProjectsServiceClient, ctx context.Context, terms string) {
req := &projects.ProjectsSearchRequest{SearchTerms: terms}
log.Printf("Slow Searching for '%s'", terms)
stream, err := c.SlowSearch(ctx, req)
if err != nil {
log.Fatalf("could not slow search: %v", err)
}
for {
prj, err := stream.Recv()
if err == io.EOF {
break
}
if err != nil {
log.Fatalf("receiving slow search result: %v", err)
}
pp.Print(prj)
}
}
// RegisterFace : アップロード画像の処理を行う
func RegisterFace(c web.C, w http.ResponseWriter, r *http.Request) {
uuid := uuid.New()
file, _, err := r.FormFile("body")
if err != nil {
fmt.Print(err.Error())
w.WriteHeader(500)
}
defer file.Close()
sourcePath := fmt.Sprintf("./tmp/%s", uuid)
resultPath := fmt.Sprintf("./results/%s.jpg", uuid)
fmt.Print(w, sourcePath)
out, err := os.Create(fmt.Sprintf("./tmp/%s", uuid))
if err != nil {
fmt.Print(w, "fail to create")
fmt.Print(err.Error())
w.WriteHeader(500)
return
}
defer out.Close()
_, err = io.Copy(out, file)
if err != nil {
w.WriteHeader(500)
fmt.Fprintln(w, "faile to copy")
fmt.Fprintln(w, err)
return
}
img := getImg(sourcePath)
defer C.cvReleaseImage(&img)
faces := detect(img)
rects := convertToRectagles(faces)
pp.Print(rects)
addRectanglesToImage(img, faces)
saveImage(resultPath, img)
http.Redirect(w, r, fmt.Sprintf("/face_detect/%s", uuid), http.StatusFound)
}
func callback(c web.C, w http.ResponseWriter, r *http.Request) {
integrationName := c.URLParams["name"]
var integration Integration
for _, intg := range conf.Integrations {
if intg.Name == integrationName {
integration = intg
}
}
if integration.Name == "" {
http.NotFound(w, r)
return
}
code := r.FormValue("code")
authConf := &oauth2.Config{
ClientID: integration.ClientID,
ClientSecret: integration.ClientSecret,
Endpoint: oauth2.Endpoint{
AuthURL: integration.AuthURL,
TokenURL: integration.TokenURL,
},
RedirectURL: integration.RedirectURL,
}
tok, err := authConf.Exchange(oauth2.NoContext, code)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
fmt.Printf("%v\n", tok)
pp.Print(tok)
index(c, w, r)
}
func AddCommand(c *cli.Context) {
image_file := c.Args()[0]
repo := cangallo.Repo{}
repo.Init()
file, err := ioutil.TempFile("/tmp", "canga-")
if err != nil {
fmt.Printf("Can not create tempfile: %v\n", err)
os.Exit(-1)
}
file.Write([]byte(cangallo.BasicImageText))
file_name := file.Name()
file.Close()
data, err := cangallo.OpenEditor(file_name)
GenericError(err)
image := cangallo.Image{}
err = yaml.Unmarshal(data, &image)
if err != nil {
fmt.Printf("Error parsing yaml: %v\n", err)
os.Exit(-1)
}
temp_image_file, err := ioutil.TempFile(".", "canga-")
if err != nil {
fmt.Printf("Can not create tempfile: %v\n", err)
os.Exit(-1)
}
temp_file_name := temp_image_file.Name()
temp_image_file.Close()
qemuImg := cangallo.QemuImg{}
qemuImg.Clone(image_file, temp_file_name)
sha1, err := cangallo.CalculateSHA1(temp_file_name)
if err != nil {
fmt.Printf("Error calculating SHA1: %v\n", err)
os.Exit(-1)
}
dest_file_name := fmt.Sprintf("%s.qcow2", sha1)
os.Rename(temp_file_name, dest_file_name)
info, err := qemuImg.Info(dest_file_name)
image.SHA1 = sha1
image.TotalSize = info[0].ActualSize
image.Size = info[0].VirtualSize
image.Time = time.Now()
pp.Print(image)
repo.AddImage(sha1, image)
pp.Print(repo.Index)
repo.SaveIndex()
}
func ListCommand(c *cli.Context) {
repo := cangallo.Repo{}
repo.Init()
pp.Print(repo)
}
func pprint(obj interface{}) {
pp.Print(obj)
}