// 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 "发生了理论上不可能出现的错误，你是不是穿越了喵？"
}
}
