// Send a request using the supplied authentication tokens. // Returns an ApiResult that needsto be checked for errors and messages. func (self *Client) SendApiRequest(url, description string) *ApiResult { apiResult := &ApiResult{} apiResult.QueryDescription = description apiResult.Error = false r, _ := http.NewRequest("GET", url, nil) r.SetBasicAuth(self.username, self.apikey) httpResponse, httpError := self.client.Do(r) if httpError != nil { apiResult.HttpError = httpError return apiResult } apiResult.StatusCode = httpResponse.StatusCode apiResult.Status = httpResponse.Status jsonResponse, jsonError := jason.NewObjectFromReader(httpResponse.Body) if jsonError != nil { apiResult.JsonError = jsonError return apiResult } apiResult.Json = jsonResponse httpResponse.Body.Close() obj, notFoundError := jsonResponse.GetObject("error") if notFoundError == nil { apiResult.Error = true apiResult.ErrorMessage = jasonGetString(obj, "message") apiResult.DeveloperMessage = jasonGetString(obj, "developer_message") } return apiResult }
// CheckAPIKey performs a test API call with the API key // provided in the configuration file to determine if the // service should be enabled. func (yt *YouTube) CheckAPIKey() error { var ( response *http.Response v *jason.Object err error ) if viper.GetString("api_keys.youtube") == "" { return errors.New("No YouTube API key has been provided") } url := "https://www.googleapis.com/youtube/v3/videos?part=snippet&id=KQY9zrjPBjo&key=%s" response, err = http.Get(fmt.Sprintf(url, viper.GetString("api_keys.youtube"))) defer response.Body.Close() if err != nil { return err } if v, err = jason.NewObjectFromReader(response.Body); err != nil { return err } if v, err = v.GetObject("error"); err == nil { message, _ := v.GetString("message") code, _ := v.GetInt64("code") errArray, _ := v.GetObjectArray("errors") reason, _ := errArray[0].GetString("reason") return fmt.Errorf("%d: %s (reason: %s)", code, message, reason) } return nil }
func LoadDevices() (devices map[int]*Device, categories map[int]*Category, rooms map[int]*Room) { res, _ := goreq.Request{ Uri: "http://10.0.1.61:3480/data_request?id=sdata&output_format=json", }.Do() json_response, _ := jason.NewObjectFromReader(res.Response.Body) categories_json, _ := json_response.GetObjectArray("categories") devices_json, _ := json_response.GetObjectArray("devices") rooms_json, _ := json_response.GetObjectArray("rooms") devices = make(map[int]*Device) categories = make(map[int]*Category) rooms = make(map[int]*Room) for _, room_json := range rooms_json { room := new(Room) room_bytes, _ := room_json.Marshal() json.Unmarshal(room_bytes, &room) rooms[room.Id] = room } for _, category_json := range categories_json { category := new(Category) category_bytes, _ := category_json.Marshal() json.Unmarshal(category_bytes, &category) categories[category.Id] = category } for _, device_json := range devices_json { device := new(Device) device_bytes, _ := device_json.Marshal() json.Unmarshal(device_bytes, &device) device.RoomName = rooms[device.Room].Name device.CategoryName = categories[device.Category].Name devices[device.Id] = device } return devices, categories, rooms }
func (ia *itemAttributes) GetItemInfo() (*jason.Object, error) { var path = ia.bendoServer + "/item/" + ia.item req, _ := http.NewRequest("GET", path, nil) if ia.token != "" { req.Header.Add("X-Api-Key", ia.token) } r, err := http.DefaultClient.Do(req) if err != nil { return nil, err } defer r.Body.Close() if r.StatusCode != 200 { switch r.StatusCode { case 404: return nil, ErrNotFound case 401: return nil, ErrNotAuthorized default: return nil, fmt.Errorf("Received status %d from Bendo", r.StatusCode) } } v, err := jason.NewObjectFromReader(r.Body) return v, err }
func (ia *itemAttributes) getUploadMeta(fileId string) (*jason.Object, error) { var path = ia.bendoServer + "/upload/" + fileId + "/metadata" req, _ := http.NewRequest("GET", path, nil) if ia.token != "" { req.Header.Add("X-Api-Key", ia.token) } req.Header.Add("Accept-Encoding", "application/json") r, err := http.DefaultClient.Do(req) if err != nil { return nil, err } defer r.Body.Close() if r.StatusCode != 200 { switch r.StatusCode { case 404: return nil, ErrNotFound case 401: return nil, ErrNotAuthorized default: return nil, fmt.Errorf("Received status %d from Bendo", r.StatusCode) } } v, err := jason.NewObjectFromReader(r.Body) return v, err }
func (ia *itemAttributes) getTransactionStatus(transaction string) (*jason.Object, error) { var path = ia.bendoServer + "/transaction/" + transaction req, err := http.NewRequest("GET", path, nil) if err != nil { return nil, err } req.Header.Set("Accept-Encoding", "application/json") if ia.token != "" { req.Header.Add("X-Api-Key", ia.token) } resp, err := http.DefaultClient.Do(req) defer resp.Body.Close() if err != nil { return nil, err } if resp.StatusCode != 200 { switch resp.StatusCode { case 404: return nil, ErrNotFound case 401: return nil, ErrNotAuthorized default: return nil, fmt.Errorf("Received status %d from Bendo", resp.StatusCode) } } v, err := jason.NewObjectFromReader(resp.Body) return v, err }
// GetTracks uses the passed URL to find and return // tracks associated with the URL. An error is returned // if any error occurs during the API call. func (mc *Mixcloud) GetTracks(url string, submitter *gumble.User) ([]interfaces.Track, error) { var ( apiURL string err error resp *http.Response v *jason.Object tracks []interfaces.Track ) apiURL = strings.Replace(url, "www", "api", 1) // Track playback offset is not present in Mixcloud URLs, // so we can safely assume that users will not request // a playback offset in the URL. offset, _ := time.ParseDuration("0s") resp, err = http.Get(apiURL) defer resp.Body.Close() if err != nil { return nil, err } v, err = jason.NewObjectFromReader(resp.Body) if err != nil { return nil, err } id, _ := v.GetString("slug") trackURL, _ := v.GetString("url") title, _ := v.GetString("name") author, _ := v.GetString("user", "username") authorURL, _ := v.GetString("user", "url") durationSecs, _ := v.GetInt64("audio_length") duration, _ := time.ParseDuration(fmt.Sprintf("%ds", durationSecs)) thumbnail, err := v.GetString("pictures", "large") if err != nil { // Track has no artwork, using profile avatar instead. thumbnail, _ = v.GetString("user", "pictures", "large") } track := bot.Track{ ID: id, URL: trackURL, Title: title, Author: author, AuthorURL: authorURL, Submitter: submitter.Name, Service: mc.ReadableName, ThumbnailURL: thumbnail, Filename: id + ".track", Duration: duration, PlaybackOffset: offset, Playlist: nil, } tracks = append(tracks, track) return tracks, nil }
func Add(rend render.Render, req *http.Request) { params, _ := jason.NewObjectFromReader(req.Body) name, _ := params.GetString("name") result, err := group.Add(name) if err != nil { rend.JSON(200, helper.Error(err)) return } rend.JSON(200, helper.Success(result)) }
func YandexTrans(yandexID, in string) string { escapedIn := url.QueryEscape(in) retry := 0 Req: var to string from := YandexDetect(ydTransAPI, in) if from == "zh" { to = "en" } else { to = "zh" } res, err := goreq.Request{ Uri: fmt.Sprintf("https://translate.yandex.net"+ "/api/v1.5/tr.json/translate?"+ "key=%s&lang=%s&text=%s", yandexID, to, escapedIn), Timeout: 17 * time.Second, }.Do() if err != nil { if retry < 2 { retry++ goto Req } else { log.Println("Translation Timeout!") return "群组娘连接母舰失败,请稍后重试" } } jasonObj, _ := jason.NewObjectFromReader(res.Body) code, _ := jasonObj.GetInt64("code") switch code { case 200: text, _ := jasonObj.GetStringArray("text") return strings.Join(text, "\n") case 401: //未授权用户 return "大概男盆友用错API Key啦,大家快去蛤他!σ`∀´)`" case 402: //API被屏蔽 return "可怜的群组娘被母舰放逐了X﹏X" case 403, 404: //请求次数已用完 return "今天弹药不足,明天再来吧(#°Д°)" case 413: //文本太长 return "警报!弹药系统过载!请放宽后重试" case 422: //文本不可翻译 return "咦?这是外星语喵?" case 501: //不支持的语种 return "恭喜你触发了母舰的迷之G点" default: return "发生了理论上不可能出现的错误,你是不是穿越了喵?" } }
func Check(rend render.Render, req *http.Request) { body, _ := jason.NewObjectFromReader(req.Body) clientsId, _ := body.GetInt64Array("clientsId") clientList := client.List(clientsId) results := JSON.Type{} for _, c := range clientList { result, err := c.CallRpc("CheckDeployPath", rpc.CheckDeployPathArgs{c.Id, c.DeployPath}) if err != nil { results[helper.Itoa64(c.Id)] = helper.Error(err) } else { results[helper.Itoa64(c.Id)] = result } } rend.JSON(200, helper.Success(results)) }
func (expvars *Expvars) Fetch(addr string) error { resp, err := expvars.client.Get(addr) if err != nil { return err } defer resp.Body.Close() if resp.StatusCode == http.StatusNotFound { return errors.New("not found") } expvars.Object, err = jason.NewObjectFromReader(resp.Body) if err != nil { return err } return nil }
func BaiduTranslate(apiKey, in string) (out, from string) { in = url.QueryEscape(in) retry := 0 Req: res, err := goreq.Request{ Uri: fmt.Sprintf("http://openapi.baidu.com/public/2.0/bmt/translate?"+ "client_id=%s&q=%s&from=auto&to=auto", apiKey, in), Timeout: 17 * time.Second, }.Do() if err != nil { if retry < 2 { retry++ goto Req } else { log.Println("Translation Timeout!") return "群组娘连接母舰失败,请稍后重试", "" } } jasonObj, _ := jason.NewObjectFromReader(res.Body) from, _ = jasonObj.GetString("from") result, err := jasonObj.GetObjectArray("trans_result") if err != nil { errCode, _ := jasonObj.GetString("error_code") switch errCode { case "52001": //超时 return "转换失败,母舰大概是快没油了Orz", "" case "52002": //翻译系统错误 return "母舰崩坏中...", "" case "52003": //未授权用户 return "大概男盆友用错API Key啦,大家快去蛤他!σ`∀´)`", "" case "52004": //必填参数为空 return "弹药装填系统泄漏,一定不是奴家的锅(╯‵□′)╯", "" default: return "发生了理论上不可能出现的错误,你是不是穿越了喵?", "" } } var outs []string for k := range result { tmp, _ := result[k].GetString("dst") outs = append(outs, tmp) } out = strings.Join(outs, "\n") return out, from }
func RemoveBackup(rend render.Render, req *http.Request, params martini.Params) { id := helper.Int64(params["id"]) host, errResponse := getClientWithAliveOrJSONError(id) if host == nil { rend.JSON(200, errResponse) return } body, _ := jason.NewObjectFromReader(req.Body) path, _ := body.GetString("path") _, err := host.RemoveBackup(path) if err != nil { rend.JSON(200, helper.Error(err)) return } rend.JSON(200, helper.Success()) }
func (yt *YouTube) getTrack(id string, submitter *gumble.User, offset time.Duration) (bot.Track, error) { var ( resp *http.Response err error v *jason.Object ) videoURL := "https://www.googleapis.com/youtube/v3/videos?part=snippet,contentDetails&id=%s&key=%s" resp, err = http.Get(fmt.Sprintf(videoURL, id, viper.GetString("api_keys.youtube"))) defer resp.Body.Close() if err != nil { return bot.Track{}, err } v, err = jason.NewObjectFromReader(resp.Body) if err != nil { return bot.Track{}, err } items, _ := v.GetObjectArray("items") if len(items) == 0 { return bot.Track{}, errors.New("This YouTube video is private") } item := items[0] title, _ := item.GetString("snippet", "title") thumbnail, _ := item.GetString("snippet", "thumbnails", "high", "url") author, _ := item.GetString("snippet", "channelTitle") durationString, _ := item.GetString("contentDetails", "duration") durationConverted, _ := duration.FromString(durationString) duration := durationConverted.ToDuration() return bot.Track{ ID: id, URL: "https://youtube.com/watch?v=" + id, Title: title, Author: author, Submitter: submitter.Name, Service: yt.ReadableName, Filename: id + ".track", ThumbnailURL: thumbnail, Duration: duration, PlaybackOffset: offset, Playlist: nil, }, nil }
func ShortUrl(url string) string { res, err := goreq.Request{ Uri: fmt.Sprintf( "http://is.gd/create.php?format=json&url=%s", url), Timeout: 3 * time.Second, }.Do() if err != nil { loge.Warning("Short Failed!") return url } jasonObj, err := jason.NewObjectFromReader(res.Body) if err != nil { return url } s, err := jasonObj.GetString("shorturl") if err != nil { e, _ := jasonObj.GetString("errormessage") loge.Warning(e) return url } return s }
//Create issue from a reader func (j Jira) Create(reader io.Reader) (i IssueEvent, err error) { v, err := jason.NewObjectFromReader(reader) if err != nil { return i, nil } user, _ := v.GetString("user", "name") userurl, _ := v.GetString("user", "avatarUrls", "24x24") summary, _ := v.GetString("issue", "fields", "summary") event, _ := v.GetString("webhookEvent") id, _ := v.GetString("issue", "id") url, _ := v.GetString("issue", "self") pname, _ := v.GetString("issue", "fields", "project", "name") items, err := v.GetObjectArray("changelog", "items") changes := make(map[string]string) for _, item := range items { field, _ := item.GetString("field") value, _ := item.GetString("toString") changes[field] = value } i = IssueEvent{Event: event, User: user, Userurl: userurl, ID: id, URL: url, Summary: summary, Project: strings.ToLower(pname), Changes: changes} return i, nil }
// Check using key func Check(organizer, project, now, key string) (string, error) { api := fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", organizer, project) res, err := http.Get(api) if err != nil { return "", errors.Wrap(err, "failed to get request: "+api) } defer res.Body.Close() json, err := jason.NewObjectFromReader(res.Body) if err != nil { return "", errors.Wrap(err, "failed to parse json") } isnew, err := json.GetString(key) if err != nil { return "", errors.Wrap(err, "failed to get value related to version from json") } if version.Compare(now, isnew, "<") { return fmt.Sprintf("update available. version: %s", isnew), nil } return fmt.Sprintf("update not available."), nil }
func YandexDetect(yandexID, in string) string { in = url.QueryEscape(in) retry := 0 Req: res, err := goreq.Request{ Uri: fmt.Sprintf("https://translate.yandex.net/api/v1.5/tr.json/detect?"+ "key=%s&text=%s", yandexID, in), Timeout: 17 * time.Second, }.Do() if err != nil { if retry < 2 { retry++ goto Req } else { log.Println("Translation Timeout!") return "群组娘连接母舰失败,请稍后重试" } } jasonObj, _ := jason.NewObjectFromReader(res.Body) code, _ := jasonObj.GetInt64("code") switch code { case 200: lang, _ := jasonObj.GetString("lang") return lang case 401: //未授权用户 return "大概男盆友用错API Key啦,大家快去蛤他!σ`∀´)`" case 402: return "可怜的群组娘被母舰放逐了X﹏X" case 403, 404: //请求次数已用完 return "今天弹药不足,明天再来吧(#°Д°)" default: return "发生了理论上不可能出现的错误,你是不是穿越了喵?" } }
// ParseExpvar parses expvar data from reader. func ParseExpvar(r io.Reader) (*Expvar, error) { object, err := jason.NewObjectFromReader(r) return &Expvar{object}, err }
} } `) req.Body(payload) res := DoRequest(req) Expect(res.StatusCode).To(Equal(200)) getReq := sling.New().Get(hoverflyAdminUrl + "/api/v2/simulation") getRes := DoRequest(getReq) Expect(getRes.StatusCode).To(Equal(200)) defer getRes.Body.Close() schemaObject, err := jason.NewObjectFromReader(getRes.Body) Expect(err).To(BeNil()) dataObject, err := schemaObject.GetObject("data") Expect(err).To(BeNil()) pairsArray, err := dataObject.GetObjectArray("pairs") Expect(err).To(BeNil()) Expect(pairsArray).To(HaveLen(1)) requestObject, err := pairsArray[0].GetObject("request") Expect(err).To(BeNil()) requestType, err := requestObject.GetString("requestType") Expect(err).To(BeNil())
// gather will only download, segment and run the evaluate code, no DB activity func gather(context *cli.Context) { var args []string xml := context.Args().First() args = []string{context.String("extract"), "SeriesInstanceUID", xml} SeriesInstanceUID, err := Run(args...) if err != nil || SeriesInstanceUID == "" { logger.Fatalf("Could not determine SeriesInstanceUID. Command is %v", args) } logger.Info("Processing %v - %v", xml, SeriesInstanceUID) // Check the segmented directory SegmentedDir := filepath.Join(context.String("segmented"), SeriesInstanceUID) ReportFile := filepath.Join(SegmentedDir, "reads.json") if Exists(ReportFile) { logger.Info("reads file exists, continuing (%v)", ReportFile) return } BaseImage := filepath.Join(SegmentedDir, "image.nii.gz") // Download needed? DownloadDir := filepath.Join(context.String("dicom"), SeriesInstanceUID) if !Exists(DownloadDir) { os.MkdirAll(DownloadDir, os.ModePerm|os.ModeDir) logger.Info("will be downloading to %v", DownloadDir) args = []string{context.String("fetch"), "fetch", "image", "--extract", DownloadDir, SeriesInstanceUID} out, err := Run(args...) if err != nil { logger.Error("error running %v: %v", args, out) } logger.Info("Fetch: %v %v", args, out) } else { logger.Info("DICOM exists in %v", DownloadDir) } if !Exists(SegmentedDir) || !Exists(BaseImage) { os.MkdirAll(SegmentedDir, os.ModePerm|os.ModeDir) args = []string{context.String("extract"), "segment", xml, DownloadDir, SegmentedDir} out, err := Run(args...) if err != nil { logger.Error("error running %v: %v", args, out) } } else { logger.Info("Segmented exists in %v", SegmentedDir) } // Copy XML over into the segmented directory data, _ := ioutil.ReadFile(xml) // Write data to dst _, fn := filepath.Split(xml) ioutil.WriteFile(filepath.Join(SegmentedDir, fn), data, 0644) // Now parse the JSON JsonFile := filepath.Join(SegmentedDir, "reads.json") fid, err := os.Open(JsonFile) if err != nil { logger.Fatalf("Error opening %v -- %v", JsonFile, err.Error()) } defer fid.Close() everything, _ := jason.NewObjectFromReader(fid) // Looping over all the reads reads, _ := everything.GetObjectArray("reads") for _, read := range reads { nodules, _ := read.GetObjectArray("nodules") for _, nodule := range nodules { read_id, _ := read.GetInt64("id") normalized_nodule_id, _ := nodule.GetInt64("normalized_nodule_id") centroid, _ := nodule.GetFloat64Array("centroidLPS") label_value, _ := nodule.GetFloat64("label_value") logger.Debug("Nodule id: %v label: %v centroid: %v", normalized_nodule_id, label_value, centroid) // Run the segmentations GroundTruth := filepath.Join(SegmentedDir, fmt.Sprintf("read_%v.nii.gz", read_id)) algorithmDir := context.String("algorithms") suffix := fmt.Sprintf("_read_%v_nodule_%v.nii.gz", read_id, normalized_nodule_id) algorithms, _ := ioutil.ReadDir(algorithmDir) for _, f := range algorithms { if !f.IsDir() { cli := []string{ filepath.Join(algorithmDir, f.Name()), "--dicom", DownloadDir, "--read", fmt.Sprintf("%v", read_id), "--nodule", fmt.Sprintf("%v", normalized_nodule_id), "--segmentation_path", SegmentedDir, "--ground_truth", GroundTruth, "--label_value", fmt.Sprintf("%v", label_value), "--suffix", suffix, filepath.Join(SegmentedDir, "image.nii.gz"), fmt.Sprintf("%v", centroid[0]), fmt.Sprintf("%v", centroid[1]), fmt.Sprintf("%v", centroid[2]), SegmentedDir, } out, err := Run(cli...) logger.Info("running: %v", cli) logger.Info("output: %v", out) if err != nil { logger.Error("Error running %v -- %v\nOutput:%v", cli, err.Error(), out) } } } // Evaluate all the segmentations matching the suffix segmentations, _ := filepath.Glob(filepath.Join(SegmentedDir, "*"+suffix)) for _, match := range segmentations { segmentation := filepath.Base(match) tag := strings.Split(segmentation, suffix)[0] // Process... measures := filepath.Join(SegmentedDir, tag+suffix) args = []string{"python", context.String("evaluate"), "--label", fmt.Sprintf("%v", label_value), "--cli", tag, match, GroundTruth, measures} logger.Info("Running: %v", args) out, err := Run(args...) if err != nil { logger.Error("Error running %v: %v", args, out) } } } } // If we are to clean up, delete the DICOM directory if context.Bool("clean") || context.Bool("clean-dicom") { logger.Debug("Cleaning up %v", DownloadDir) os.RemoveAll(DownloadDir) } if context.Bool("clean") { logger.Debug("Removing all images from %v", SegmentedDir) fileList, err := filepath.Glob(filepath.Join(SegmentedDir, "*.nii.gz")) if err != nil { logger.Fatalf("Error globbing %v", err.Error()) } for _, file := range fileList { os.Remove(file) } } }
// GetTracks uses the passed URL to find and return // tracks associated with the URL. An error is returned // if any error occurs during the API call. func (yt *YouTube) GetTracks(url string, submitter *gumble.User) ([]interfaces.Track, error) { var ( playlistURL string playlistItemsURL string id string err error resp *http.Response v *jason.Object track bot.Track tracks []interfaces.Track ) playlistURL = "https://www.googleapis.com/youtube/v3/playlists?part=snippet&id=%s&key=%s" playlistItemsURL = "https://www.googleapis.com/youtube/v3/playlistItems?part=snippet,contentDetails&playlistId=%s&maxResults=%d&key=%s&pageToken=%s" id, err = yt.getID(url) if err != nil { return nil, err } if yt.isPlaylist(url) { resp, err = http.Get(fmt.Sprintf(playlistURL, id, viper.GetString("api_keys.youtube"))) defer resp.Body.Close() if err != nil { return nil, err } v, err = jason.NewObjectFromReader(resp.Body) if err != nil { return nil, err } items, _ := v.GetObjectArray("items") item := items[0] title, _ := item.GetString("snippet", "title") playlist := &bot.Playlist{ ID: id, Title: title, Submitter: submitter.Name, Service: yt.ReadableName, } maxItems := math.MaxInt32 if viper.GetInt("queue.max_tracks_per_playlist") > 0 { maxItems = viper.GetInt("queue.max_tracks_per_playlist") } pageToken := "" for len(tracks) < maxItems { curResp, curErr := http.Get(fmt.Sprintf(playlistItemsURL, id, maxItems, viper.GetString("api_keys.youtube"), pageToken)) defer curResp.Body.Close() if curErr != nil { // An error occurred, simply skip this track. continue } v, err = jason.NewObjectFromReader(curResp.Body) if err != nil { // An error occurred, simply skip this track. continue } curTracks, _ := v.GetObjectArray("items") for _, track := range curTracks { videoID, _ := track.GetString("snippet", "resourceId", "videoId") // Unfortunately we have to execute another API call for each video as the YouTube API does not // return video durations from the playlistItems endpoint... newTrack, _ := yt.getTrack(videoID, submitter) newTrack.Playlist = playlist tracks = append(tracks, newTrack) if len(tracks) >= maxItems { break } } } if len(tracks) == 0 { return nil, errors.New("Invalid playlist. No tracks were added") } return tracks, nil } track, err = yt.getTrack(id, submitter) if err != nil { return nil, err } tracks = append(tracks, track) return tracks, nil }
// The evaluate function collects all the data and stores it in a database func evaluate(context *cli.Context) { // Create our tables db, err := sqlite3.Open(context.String("db")) if err != nil { logger.Error("Could not open SQLite3 DB %v: %v", context.String("db"), err.Error()) os.Exit(1) } for table, s := range create_tables { err = db.Exec(s) if err != nil { logger.Error("Could not create %v table: %v", table, err.Error()) os.Exit(1) } } for idx, SegmentedDir := range context.Args() { // Check the segmented directory ReportFile := filepath.Join(SegmentedDir, "reads.json") if !Exists(ReportFile) { logger.Info("reads file DOES NOT exist, skipping (%v)", ReportFile) continue } logger.Debug("Processing (%v/%v) %v", idx+1, len(context.Args()), ReportFile) // Now parse the JSON JsonFile := filepath.Join(SegmentedDir, "reads.json") fid, err := os.Open(JsonFile) if err != nil { logger.Error("Error opening %v -- %v", JsonFile, err.Error()) continue } everything, _ := jason.NewObjectFromReader(fid) fid.Close() series_uid, _ := everything.GetString("uid") Save(db, "series", series_uid, everything) // Looping over all the reads reads, _ := everything.GetObjectArray("reads") for _, read := range reads { nodules, _ := read.GetObjectArray("nodules") for _, nodule := range nodules { // Create an entry for the nodule normalized_nodule_id, _ := nodule.GetInt64("normalized_nodule_id") nodule_uid := fmt.Sprintf("%v.%v", series_uid, normalized_nodule_id) db.Exec("insert or ignore into nodules ( uid, series_uid, normalized_nodule_id ) values (?,?,?)", nodule_uid, series_uid, normalized_nodule_id) // Create the read read_id, _ := read.GetInt64("id") logger.Debug("Read %v -- nodule %v", read_id, normalized_nodule_id) read_uid := fmt.Sprintf("%v.%v.%v", series_uid, read_id, normalized_nodule_id) Save(db, "reads", read_uid, nodule) characteristics, _ := nodule.GetObject("characteristics") Save(db, "reads", read_uid, characteristics) db.Exec("update reads set nodule_uid = ? where uid = ?", nodule_uid, read_uid) // evaluate segmentation suffix := fmt.Sprintf("_read_%v_nodule_%v_eval.json", read_id, normalized_nodule_id) files, _ := filepath.Glob(filepath.Join(SegmentedDir, "*"+suffix)) for _, measures := range files { logger.Debug("Looking at results file: %v", measures) // Now, read and combine into a SQLite DB fid, _ := os.Open(measures) measure_object, _ := jason.NewObjectFromReader(fid) fid.Close() // The UID is the SHA1 of the command string command_line, _ := measure_object.GetString("command_line") measure_detail, _ := measure_object.GetObject("measures") measures_uid := fmt.Sprintf("%x", sha1.Sum([]byte(command_line))) Save(db, "measures", measures_uid, measure_detail) db.Exec("update measures set command_line = ? where uid = ?", command_line, measures_uid) db.Exec("update measures set nodule_uid = ? where uid = ?", nodule_uid, measures_uid) db.Exec("update measures set read_uid = ? where uid = ?", read_uid, measures_uid) } } } } }
// GetTracks uses the passed URL to find and return // tracks associated with the URL. An error is returned // if any error occurs during the API call. func (sc *SoundCloud) GetTracks(url string, submitter *gumble.User) ([]interfaces.Track, error) { var ( apiURL string err error resp *http.Response v *jason.Object track bot.Track tracks []interfaces.Track ) urlSplit := strings.Split(url, "#t=") apiURL = "http://api.soundcloud.com/resolve?url=%s&client_id=%s" if sc.isPlaylist(url) { // Submitter has added a playlist! resp, err = http.Get(fmt.Sprintf(apiURL, urlSplit[0], viper.GetString("api_keys.soundcloud"))) defer resp.Body.Close() if err != nil { return nil, err } v, err = jason.NewObjectFromReader(resp.Body) if err != nil { return nil, err } title, _ := v.GetString("title") permalink, _ := v.GetString("permalink_url") playlist := &bot.Playlist{ ID: permalink, Title: title, Submitter: submitter.Name, Service: sc.ReadableName, } var scTracks []*jason.Object scTracks, err = v.GetObjectArray("tracks") if err != nil { return nil, err } dummyOffset, _ := time.ParseDuration("0s") for _, t := range scTracks { track, err = sc.getTrack(t, dummyOffset, submitter) if err != nil { // Skip this track. continue } track.Playlist = playlist tracks = append(tracks, track) } if len(tracks) == 0 { return nil, errors.New("Invalid playlist. No tracks were added") } return tracks, nil } // Submitter has added a track! offset := 0 // Calculate track offset if needed if len(urlSplit) == 2 { timeSplit := strings.Split(urlSplit[1], ":") multiplier := 1 for i := len(timeSplit) - 1; i >= 0; i-- { time, _ := strconv.Atoi(timeSplit[i]) offset += time * multiplier multiplier *= 60 } } playbackOffset, _ := time.ParseDuration(fmt.Sprintf("%ds", offset)) resp, err = http.Get(fmt.Sprintf(apiURL, urlSplit[0], viper.GetString("api_keys.soundcloud"))) defer resp.Body.Close() if err != nil { return nil, err } v, err = jason.NewObjectFromReader(resp.Body) if err != nil { return nil, err } track, err = sc.getTrack(v, playbackOffset, submitter) if err != nil { return nil, err } tracks = append(tracks, track) return tracks, nil }
func TuringBot(apiKey, userid, in string) string { in = url.QueryEscape(in) retry := 0 Req: res, err := goreq.Request{ Uri: fmt.Sprintf("http://www.tuling123.com/openapi/api?"+ "key=%s&info=%s&userid=%s", apiKey, in, userid), Timeout: 17 * time.Second, }.Do() if err != nil { if retry < 2 { retry++ goto Req } else { log.Println("Turing Timeout!") return "群组娘连接母舰失败,请稍后重试" } } jasonObj, err := jason.NewObjectFromReader(res.Body) if err != nil { return "群组娘连接母舰失败,请稍后重试" } errCode, err := jasonObj.GetInt64("code") if err != nil { return "群组娘连接母舰失败,请稍后重试" } switch errCode { case 100000: //文本类数据 out, _ := jasonObj.GetString("text") isWeather, _ := regexp.MatchString("^.{2,10}:.*,.*-.*°.*;.*$", out) if isWeather { replacer := strings.NewReplacer(";", "\n", "晴", "☀️", "多云", "☁️") out = replacer.Replace(out) out = strings.Replace(out, ":", ":\n", 1) } out = strings.Replace(out, "<br>", "\n", -1) return out case 200000: //网址 url, _ := jasonObj.GetString("url") return url case 302000: //新闻 list, _ := jasonObj.GetObjectArray("list") var buf bytes.Buffer for _, v := range list { article, _ := v.GetString("article") url, _ := v.GetString("detailurl") buf.WriteString(fmt.Sprintf("%s\n%s\n", article, url)) } return buf.String() case 305000: //列车 list, _ := jasonObj.GetObjectArray("list") var buf bytes.Buffer for _, v := range list { trainNum, _ := v.GetString("trainnum") start, _ := v.GetString("start") terminal, _ := v.GetString("terminal") startTime, _ := v.GetString("starttime") endTime, _ := v.GetString("endtime") buf.WriteString(fmt.Sprintf("%s|%s->%s|%s->%s\n", trainNum, start, terminal, startTime, endTime)) } return buf.String() case 306000: //航班 list, _ := jasonObj.GetObjectArray("list") var buf bytes.Buffer for _, v := range list { flight, _ := v.GetString("flight") startTime, _ := v.GetString("starttime") endTime, _ := v.GetString("endtime") buf.WriteString(fmt.Sprintf("%s|%s->%s\n", flight, startTime, endTime)) } return buf.String() case 308000: //菜谱、视频、小说 list, _ := jasonObj.GetObjectArray("list") var buf bytes.Buffer for _, v := range list { name, _ := v.GetString("name") url, _ := v.GetString("detailurl") buf.WriteString(fmt.Sprintf("%s\n%s\n", name, url)) } return buf.String() case 40001: //key长度错误 return "大概男盆友用错API Key啦,大家快去蛤他!σ`∀´)`" case 40002: //请求内容为空 return "弹药装填系统泄漏,一定不是奴家的锅(╯‵□′)╯" case 40003: //key错误或帐号未激活 return "大概男盆友用错API Key啦,大家快去蛤他!σ`∀´)`" case 40004: //请求次数已用完 return "今天弹药不足,明天再来吧(#°Д°)" case 40005: //暂不支持该功能 return "恭喜你触发了母舰的迷之G点" case 40006: //服务器升级中 return "母舰升级中..." case 40007: //服务器数据格式异常 return "转换失败,母舰大概是快没油了Orz" default: return "发生了理论上不可能出现的错误,你是不是穿越了喵?" } }