func runRevokeTokenTest(t *testing.T, strategy oauth2.AccessTokenStrategy) {
f := compose.Compose(new(compose.Config), fositeStore, strategy, compose.OAuth2ClientCredentialsGrantFactory, compose.OAuth2TokenIntrospectionFactory, compose.OAuth2TokenRevocationFactory)
ts := mockServer(t, f, &fosite.DefaultSession{})
defer ts.Close()
oauthClient := newOAuth2AppClient(ts)
token, err := oauthClient.Token(goauth.NoContext)
assert.Nil(t, err)
resp, _, errs := gorequest.New().Post(ts.URL+"/revoke").
SetBasicAuth(oauthClient.ClientID, oauthClient.ClientSecret).
Type("form").
SendStruct(map[string]string{"token": "asdf"}).End()
assert.Len(t, errs, 0)
assert.Equal(t, 200, resp.StatusCode)
resp, _, errs = gorequest.New().Post(ts.URL+"/revoke").
SetBasicAuth(oauthClient.ClientID, oauthClient.ClientSecret).
Type("form").
SendStruct(map[string]string{"token": token.AccessToken}).End()
assert.Len(t, errs, 0)
assert.Equal(t, 200, resp.StatusCode)
hres, _, errs := gorequest.New().Get(ts.URL+"/info").
Set("Authorization", "bearer "+token.AccessToken).
End()
require.Len(t, errs, 0)
assert.Equal(t, http.StatusUnauthorized, hres.StatusCode)
}
func main() {
request := gorequest.New()
_, body, _ := request.Get("http://127.0.0.1:4001/v2/keys/foo").End()
fmt.Println(body)
//IT WORKS!!
save := gorequest.New()
_, body2, _ := save.Put("http://127.0.0.1:4001/v2/keys/foo?value=hi").End()
fmt.Println(body2)
request = gorequest.New()
_, body, _ = request.Get("http://127.0.0.1:4001/v2/keys/foo").End()
fmt.Println(body)
}
func F5Get(url string, clientconfig BIGIPClient) (*simplejson.Json, error) {
log.Println("[BIGIP] F5Get: " + url)
emptyJson := simplejson.New()
username := clientconfig.RestUsername
password := clientconfig.RestPassword
request := gorequest.New().SetBasicAuth(username, password).TLSClientConfig(&tls.Config{InsecureSkipVerify: true})
resp, body, err := request.Get(url).End()
if err != nil {
log.Println("[BIGIP] err: something broke ")
fmt.Println(err)
return emptyJson, err[0]
} else {
if resp.Status != "200 OK" {
//
return emptyJson, errors.New("Did not get 200 OK - got " + resp.Status)
} else {
log.Println("[BIGIP] RESP: " + resp.Status)
log.Println("[BIGIP] RESP: " + body)
myJson, jsonErr := simplejson.NewFromReader(strings.NewReader(body))
if jsonErr != nil {
log.Println("[BIGIP] jsonErr: something broke ")
fmt.Println(jsonErr)
return emptyJson, jsonErr
} else {
return myJson, nil
//fmt.Println( myJson.Get("kind") )
}
}
}
return emptyJson, errors.New("unknown error")
}
func (d *signin) FetchSession(code string) (Session, error) {
request := gorequest.New()
// FIXME does not work if redirect contains query params
resp, body, errs := request.Get(fmt.Sprintf("%s?verify=%s", d.login, code)).End()
if len(errs) > 0 {
return nil, errors.Errorf("Could not exchange code: %s", errs)
} else if resp.StatusCode != http.StatusOK {
return nil, errors.Errorf("Could not exchange code, received status: %d", resp.StatusCode)
}
var p payload
if err := json.Unmarshal([]byte(body), &p); err != nil {
return nil, errors.Errorf("Could not parse answer: %v", err)
}
if p.Subject == "" {
return nil, errors.Errorf("Field subject is empty, got %s", body)
}
return &DefaultSession{
ForceLocalSubject: p.Subject,
Extra: map[string]interface{}{},
}, nil
}
func NewAPI(username, password string) (*OctosendAPI, error) {
payload, err := json.Marshal(map[string]string{
"username": username,
"password": password,
})
if err != nil {
return nil, err
}
url := strings.Join([]string{APIUrl, "3.0/authenticate"}, "/")
request := gorequest.New().Post(url).Send(string(payload))
if os.Getenv("OCTOSEND_DEBUG") == "1" {
request.SetDebug(true)
}
resp, body, errs := request.EndBytes()
if len(errs) > 0 {
return nil, printErrors(errs)
}
if err := httpHandleError([]int{200}, resp.StatusCode, body); err != nil {
return nil, err
}
var response struct {
Username string `json:"username"`
ApiKey string `json:"api-key"`
Entity string `json:"entity"`
}
if err = json.Unmarshal(body, &response); err != nil {
return nil, err
}
return NewAPIByToken(response.ApiKey), nil
}
func goreq() *gorequest.SuperAgent {
request := gorequest.New()
if os.Getenv("https_proxy") != "" {
request.Proxy(os.Getenv("https_proxy"))
}
return request
}
func getLegueMatches(league_id int) {
resp, body, errs := gorequest.New().
Get("https://api.steampowered.com/IDOTA2Match_570/GetMatchHistory/v0001/").
Query("key=" + conf.Steamapi).
Query("league_id=" + strconv.Itoa(league_id)).
Query("min_players=10").
End()
if errs != nil {
log.Println("(invoker) ERROR:", errs)
return
}
if resp.StatusCode != 200 {
log.Println("(invoker) ERROR:", resp.StatusCode)
return
}
leagueGamesjs, err := simplejson.NewJson([]byte(body))
if err != nil {
log.Println("(invoker) ERROR:", err)
return
}
for i := range leagueGamesjs.Get("result").Get("matches").MustArray() {
match_id := leagueGamesjs.Get("result").Get("matches").GetIndex(i).Get("match_id").MustInt()
series_id := leagueGamesjs.Get("result").Get("matches").GetIndex(i).Get("series_id").MustInt()
series_type := leagueGamesjs.Get("result").Get("matches").GetIndex(i).Get("series_type").MustInt()
start_time := leagueGamesjs.Get("result").Get("matches").GetIndex(i).Get("start_time").MustInt64()
if start_time > time.Now().Unix()-86400 {
seriesIDToSqlite(match_id, series_id, series_type)
getMatch(match_id)
}
}
}
func NewAPIPathwar(token, debug string) *APIPathwar {
return &APIPathwar{
client: gorequest.New(),
token: token,
debug: debug != "",
}
}
func (z *Zone) UpdateRecords(rs []*Record) []error {
c := RRsetContainer{
RRsets: []*RRset{
&RRset{
Name: rs[0].Name, Type: rs[0].Type, ChangeType: "REPLACE",
Records: rs,
},
},
}
_, bytes, errs := gorequest.
New().
Patch(fmt.Sprintf("%s/zones/%s", os.Getenv("API_URL"), z.Name)).
Set("X-API-Key", os.Getenv("API_KEY")).
Send(c).
EndBytes()
if errs != nil {
return errs
}
err := json.Unmarshal(bytes, z)
if err != nil {
return []error{err}
}
return nil
}
func isValidAuthorizeRequest(c *HTTPClient, ar *AuthorizeRequest, retry bool) (bool, error) {
request := gorequest.New()
resp, body, errs := request.Post(pkg.JoinURL(c.ep, "/guard/allowed")).SetBasicAuth(c.clientConfig.ClientID, c.clientConfig.ClientSecret).Set("Content-Type", "application/json").Send(*ar).End()
if len(errs) > 0 {
return false, errors.Errorf("Got errors: %v", errs)
} else if retry && resp.StatusCode == http.StatusUnauthorized {
var err error
if c.clientToken, err = c.clientConfig.Token(oauth2.NoContext); err != nil {
return false, errors.New(err)
} else if c.clientToken == nil {
return false, errors.New("Access token could not be retrieved")
}
return isValidAuthorizeRequest(c, ar, false)
} else if resp.StatusCode != http.StatusOK {
return false, errors.Errorf("Status code %d is not 200: %s", resp.StatusCode, body)
}
if err := json.Unmarshal([]byte(body), &isAllowed); err != nil {
return false, errors.Errorf("Could not unmarshall body because %s", err.Error())
}
if !isAllowed.Allowed {
return false, errors.New("Authroization denied")
}
return isAllowed.Allowed, nil
}
func isValidAuthenticationRequest(c *HTTPClient, token string, retry bool) (bool, error) {
data := url.Values{}
data.Set("token", token)
request := gorequest.New()
resp, body, errs := request.Post(pkg.JoinURL(c.ep, "/oauth2/introspect")).Type("form").SetBasicAuth(c.clientConfig.ClientID, c.clientConfig.ClientSecret).SendString(data.Encode()).End()
if len(errs) > 0 {
return false, errors.Errorf("Got errors: %v", errs)
} else if resp.StatusCode != http.StatusOK {
return false, errors.Errorf("Status code %d is not 200: %s", resp.StatusCode, body)
}
if retry && resp.StatusCode == http.StatusUnauthorized {
var err error
if c.clientToken, err = c.clientConfig.Token(oauth2.NoContext); err != nil {
return false, errors.New(err)
} else if c.clientToken == nil {
return false, errors.New("Access token could not be retrieved")
}
return isValidAuthenticationRequest(c, token, false)
} else if resp.StatusCode != http.StatusOK {
return false, fmt.Errorf("Status code %d is not 200", resp.StatusCode)
}
var introspect struct {
Active bool `json:"active"`
}
if err := json.Unmarshal([]byte(body), &introspect); err != nil {
return false, err
} else if !introspect.Active {
return false, errors.New("Authentication denied")
}
return introspect.Active, nil
}
func getLeaguePrizePool(leagueid int) {
resp, body, errs := gorequest.New().
Get("https://api.steampowered.com/IEconDOTA2_570/GetTournamentPrizePool/v0001/").
Query("key=" + conf.Steamapi).
Query("leagueid=" + strconv.Itoa(leagueid)).
End()
if errs != nil {
log.Fatal(errs)
}
if resp.StatusCode != 200 {
log.Println("(riki) ERROR:", resp.StatusCode)
return
}
pooljs, err := simplejson.NewJson([]byte(body))
if err != nil {
log.Fatal("(riki) ERROR:", err)
return
}
prize_pool := pooljs.Get("result").Get("prize_pool").MustInt()
_, err = db.Exec("update leagues set prize_pool=? where id = ?;", prize_pool, leagueid)
if err != nil {
log.Fatal("(riki) ERROR:", err)
return
}
}
//
// GetHeroes to SQLite db
//
func getHeroes() {
resp, body, errs := gorequest.New().
Get("https://api.steampowered.com/IEconDOTA2_570/GetHeroes/v0001/").
Query("key=" + conf.Steamapi).
Query("language=en_us").
End()
if errs != nil {
log.Fatal(errs)
}
herojs, err := simplejson.NewJson([]byte(body))
if err != nil {
log.Fatal("(riki) ERROR:", err)
return
}
if resp.StatusCode != 200 {
log.Println("(riki) ERROR:", resp.StatusCode)
return
}
for i := range herojs.Get("result").Get("heroes").MustArray() {
id := herojs.Get("result").Get("heroes").GetIndex(i).Get("id").MustInt()
name := herojs.Get("result").Get("heroes").GetIndex(i).Get("name").MustString()
localized_name := herojs.Get("result").Get("heroes").GetIndex(i).Get("localized_name").MustString()
heroToSqlite(id, name[14:], localized_name)
}
}
func writeFare(data []collect.FareData) error {
for _, option := range data {
fmt.Println(option)
request := gorequest.New()
fareLiteral := `{"id":%d,` +
`"service":"%s",` +
`"type":"%s",` +
`"cost":"%d",` +
`"eta":"%d",` +
`"start_lat":%f,` +
`"start_lon":%f,` +
`"end_lat":%f,` +
`"end_lon":%f,` +
`"time":"%s"}`
body := fmt.Sprintf(fareLiteral, option.Id, option.Service, option.Type,
option.Cost, option.Eta,
option.Start.Lat(), option.Start.Lng(),
option.End.Lat(), option.End.Lng(), option.Time)
resp, _, errs := request.Post("https://api-us.clusterpoint.com/100882/car-service-test.json").
SetBasicAuth("*****@*****.**", "angelhack").
Send(body).
End()
if len(errs) > 0 {
fmt.Println(resp)
fmt.Println(errs)
}
}
return nil
}
func (c *FastPushPlugin) FastPush(cliConnection plugin.CliConnection, appName string, dryRun bool) {
// Please check what GetApp returns here
// https://github.com/cloudfoundry/cli/blob/master/plugin/models/get_app.go
authToken := c.GetAppVersionId(cliConnection, appName)
if dryRun {
// NEED TO HANDLE DRY RUN
c.ui.Warn("warning: No changes will be applied, this is a dry run !!")
}
apiEndpoint := c.GetApiEndpoint(cliConnection, appName)
request := gorequest.New()
_, body, err := request.Get(apiEndpoint+"/_fastpush/files").Set("x-auth-token", authToken).End()
if err != nil {
panic(err)
}
remoteFiles := map[string]*lib.FileEntry{}
json.Unmarshal([]byte(body), &remoteFiles)
localFiles := lib.ListFiles()
filesToUpload := c.ComputeFilesToUpload(localFiles, remoteFiles)
payload, _ := json.Marshal(filesToUpload)
_, body, err = request.Put(apiEndpoint+"/_fastpush/files").Set("x-auth-token", authToken).Send(string(payload)).End()
if err != nil {
panic(err)
}
status := lib.Status{}
json.Unmarshal([]byte(body), &status)
c.ui.Say(status.Health)
}
func getTeam(id int) {
resp, body, errs := gorequest.New().
Get("https://api.steampowered.com/IDOTA2Match_570/GetTeamInfoByTeamID/v0001/").
Query("key=" + conf.Steamapi).
Query("start_at_team_id=" + strconv.Itoa(id)).
End()
if errs != nil {
log.Fatal(errs)
}
if resp.StatusCode != 200 {
log.Println("(riki) ERROR:", resp.StatusCode)
return
}
teamjs, err := simplejson.NewJson([]byte(body))
if err != nil {
log.Fatal("(riki) ERROR:", err)
return
}
name := teamjs.Get("result").Get("teams").GetIndex(0).Get("name").MustString()
tag := teamjs.Get("result").Get("teams").GetIndex(0).Get("tag").MustString()
logo := teamjs.Get("result").Get("teams").GetIndex(0).Get("logo").MustInt()
logo_sponsor := teamjs.Get("result").Get("teams").GetIndex(0).Get("logo_sponsor").MustInt()
country_code := teamjs.Get("result").Get("teams").GetIndex(0).Get("country_code").MustString()
url := teamjs.Get("result").Get("teams").GetIndex(0).Get("url").MustString()
teamToSqlite(id, name, tag, logo, logo_sponsor, country_code, url)
}
func GetUsers() ([]auth.User, error) {
_, body, errs := gorequest.New().Get(endpoint).End()
if errs != nil {
return nil, errors.New("Can't get users from Auth provider")
} else {
var loaded []auth.User
json.Unmarshal([]byte(body), &loaded)
exist_users := GetAllUsers()
var user_keys map[string]auth.User = map[string]auth.User{}
for _, value := range exist_users {
user_keys[value.Id] = value
}
var users []auth.User
for _, value := range loaded {
existed, ok := user_keys[value.Id]
fmt.Println(ok)
if !ok {
users = append(users, value)
} else {
users = append(users, existed)
}
}
return users, nil
}
}
func (api cvedictClient) httpGet(key, url string, resChan chan<- response, errChan chan<- error) {
var body string
var errs []error
var resp *http.Response
f := func() (err error) {
// resp, body, errs = gorequest.New().SetDebug(config.Conf.Debug).Get(url).End()
resp, body, errs = gorequest.New().Get(url).End()
if 0 < len(errs) || resp == nil || resp.StatusCode != 200 {
return fmt.Errorf("HTTP GET error: %v, url: %s, resp: %v", errs, url, resp)
}
return nil
}
notify := func(err error, t time.Duration) {
log.Warnf("Failed to HTTP GET. retrying in %s seconds. err: %s", t, err)
}
err := backoff.RetryNotify(f, backoff.NewExponentialBackOff(), notify)
if err != nil {
errChan <- fmt.Errorf("HTTP Error %s", err)
}
cveDetail := cve.CveDetail{}
if err := json.Unmarshal([]byte(body), &cveDetail); err != nil {
errChan <- fmt.Errorf("Failed to Unmarshall. body: %s, err: %s", body, err)
}
resChan <- response{
key,
cveDetail,
}
}
func (api cvedictClient) httpPost(key, url string, query map[string]string) ([]cve.CveDetail, error) {
var body string
var errs []error
var resp *http.Response
f := func() (err error) {
req := gorequest.New().SetDebug(config.Conf.Debug).Post(url)
for key := range query {
req = req.Send(fmt.Sprintf("%s=%s", key, query[key])).Type("json")
}
resp, body, errs = req.End()
if 0 < len(errs) || resp == nil || resp.StatusCode != 200 {
return fmt.Errorf("HTTP POST error: %v, url: %s, resp: %v", errs, url, resp)
}
return nil
}
notify := func(err error, t time.Duration) {
log.Warnf("Failed to HTTP POST. retrying in %s seconds. err: %s", t, err)
}
err := backoff.RetryNotify(f, backoff.NewExponentialBackOff(), notify)
if err != nil {
return []cve.CveDetail{}, fmt.Errorf("HTTP Error %s", err)
}
cveDetails := []cve.CveDetail{}
if err := json.Unmarshal([]byte(body), &cveDetails); err != nil {
return []cve.CveDetail{},
fmt.Errorf("Failed to Unmarshall. body: %s, err: %s", body, err)
}
return cveDetails, nil
}
// Charge - it charges the customer on mpower and returns a response json object which contains the receipt url with other information
// The `confirmToken` is from the customer
// Returns a `boolean` and `error`
// The boolean signifies whether the customer was chargeed or not
// The response json object can be retrieved on the onsite invoice object
//
// Example.
// if ok, err := onsite.Charge(onsite.Token, "4346"); ok {
// //doSomething
// } else {
//
// }
//
func (on *OnsiteInvoice) Charge(oprToken, confirmToken string) (bool, error) {
var respData oprResponse
data := opr{oprToken, confirmToken}
req := gorequest.New()
for key, val := range on.Setup.GetHeaders() {
req.Set(key, val)
}
if dataByte, err := json.Marshal(data); err != nil {
return false, err
} else {
if _, body, err := req.Send(bytes.NewBuffer(dataByte).String()).End(); err != nil {
return false, fmt.Errorf("%v", err)
} else {
if err := json.Unmarshal(bytes.NewBufferString(body).Bytes(), &respData); err != nil {
return false, err
}
on.ResponseText = respData.ResponseText
on.ResponseCode = respData.ResponseCode
if respData.ResponseCode == "00" {
on.Description = respData.Description
on.Status = respData.InvoiceData.Status
on.ReceiptUrl = respData.InvoiceData.ReceiptUrl
return true, nil
} else {
return false, fmt.Errorf("Failed to charge invoice. Check OPR or confirm token and try again.")
}
}
}
}
func diffstatRoute(e *Env, c web.C, w http.ResponseWriter, r *http.Request) error {
if requireAuth(e, w, r) {
return nil
}
sha := r.URL.Query().Get("sha")
_, body, _ := gorequest.New().Get(fmt.Sprintf("https://api.github.com/repos/topscore/topscore/commits/%s", sha)).
Param("access_token", e.Session.GithubToken).
End()
var commit commitType
err := json.Unmarshal([]byte(body), &commit)
check(err)
fmt.Printf("%+v", commit)
respBody, err := json.Marshal(struct {
Stats statsType `json:"stats"`
FilesChanged int `json:"files_changed"`
}{
Stats: commit.Stats,
FilesChanged: len(commit.Files),
})
check(err)
w.Header().Set("Content-Type", "application/json")
w.Write(respBody)
return nil
}
func sendRequest(userName string, id int, jsonSchemaWithTag string) {
request := gorequest.New()
if tag, schema := stringify(jsonSchemaWithTag); tag == "" && schema == "" {
fmt.Println("error")
} else {
str := `{"domainName":"` + userName + `","typeName":` + tag + `,"jsonSchema":` + schema + `}`
fmt.Printf("%s", str)
resp, _, err := request.Post(baseURL).
Set("Content-Type", "application/json").
Send(str).End()
if err != nil {
//spew.Dump(err)
callBackUser(id, "JSON syntax error")
} else {
// spew.Dump(body)
// spew.Dump(resp)
target := Onion{}
processResponser(resp, &target)
spew.Dump(target.Ginger_Id)
var s string = strconv.Itoa(int(target.Ginger_Id))
sendRequestByIdForBuild(s, id)
}
}
}
func Call(args ...string) *simplejson.Json {
method := args[0]
params := "[]"
if len(args) > 1 {
params = args[1]
}
postBody := `{"jsonrpc":"2.0","method":"` + method + `","params":` + params + `}`
// fmt.Println("postBody: " + postBody)
_, body, errs := gorequest.New().Post(apiUrl).
Send(postBody).
End()
if errs != nil {
panic(errs)
}
js, err := simplejson.NewJson([]byte(body))
if err != nil {
log.Fatalln(err)
}
return js
}
func fetchHttp(url string, opts options) response {
var resp gorequest.Response
var body string
var errs []error
client := gorequest.New()
switch opts.Method {
case gorequest.HEAD:
resp, body, errs = client.Head(url).End()
case gorequest.GET:
resp, body, errs = client.Get(url).End()
case gorequest.POST:
resp, body, errs = client.Post(url).Query(opts.Body).End()
case gorequest.PUT:
resp, body, errs = client.Put(url).Query(opts.Body).End()
case gorequest.PATCH:
resp, body, errs = client.Patch(url).Query(opts.Body).End()
case gorequest.DELETE:
resp, body, errs = client.Delete(url).End()
}
result := response{
options: opts,
Status: resp.StatusCode,
StatusText: resp.Status,
Errors: errs,
}
result.Body = body
result.Headers = resp.Header
return result
}
func isMountebankRunning(mountebankBaseUri string) bool {
resp, _, errs := gorequest.New().Get(mountebankBaseUri).End()
Expect(errs).To(HaveLen(0))
return resp.StatusCode == http.StatusOK
}
// GetWithParameters Makes a GET request to shopify with the given endpoint and given parameters
func (shopify *Shopify) GetWithParameters(endpoint string, parameters map[string]string) ([]byte, []error) {
targetURL := shopify.createTargetURLWithParameters(endpoint, parameters)
request := gorequest.New()
_, body, errs := request.Get(targetURL).End()
return []byte(body), errs
}
// Add exposes a container on the service
func (expose Expose) Add(name string, port int) error {
var err error
var query struct {
LocalIP string `json:"localip"`
Services []Service `json:"services"`
}
query.LocalIP, err = localIP()
if err != nil {
return err
}
query.Services = make([]Service, 1)
query.Services[0].Service = expose.ContainerHost(name)
query.Services[0].Port = port
request := gorequest.New().Post("http://"+expose.url+"/api/service").
Set("Auth-Username", expose.username).
Set("Auth-Token", expose.token)
res, _, errs := request.Send(query).End()
if len(errs) > 0 {
return errs[0]
}
if res.StatusCode != 200 {
return fmt.Errorf("Invalid return code from server: %d\n%s", res.StatusCode, res.Body)
}
return nil
}
// List lists currently exposed services
func (expose Expose) List(owned bool) (HostList, error) {
request := gorequest.New().SetBasicAuth(expose.username, expose.token)
res, body, errs := request.Get("http://" + expose.url + "/api/vms").End()
if len(errs) > 0 {
return HostList{}, errs[0]
}
if res.StatusCode != 200 {
return HostList{}, fmt.Errorf("Invalid return code from server: %d", res.StatusCode)
}
el := HostList{}
err := json.Unmarshal([]byte(body), &el)
if err != nil {
return HostList{}, err
}
if owned {
res := HostList{}
for _, eh := range el {
components := strings.Split(eh.Hostname, ".")
user := components[len(components)-1]
project := components[len(components)-2]
if user == expose.username && project == "docker" {
res = append(res, eh)
}
}
return res, nil
}
return el, nil
}
// Delete un-exposes (is that a word?) a container from the service
func (expose Expose) Delete(name string) error {
var query struct {
Services []Service `json:"services"`
}
query.Services = make([]Service, 1)
query.Services[0].Service = expose.ContainerHost(name)
request := gorequest.New().Delete("http://"+expose.url+"/api/service").
Set("Auth-Username", expose.username).
Set("Auth-Token", expose.token).
Set("Content-Type", "application/json")
res, _, errs := request.Send(query).End()
if len(errs) > 0 {
return errs[0]
}
if res.StatusCode != 200 {
return fmt.Errorf("Invalid return code from server: %d\n%s", res.StatusCode, res.Body)
}
return nil
}
func init() {
resp, body, err := gorequest.New().
Get("http://" + config.DbConfig.ServerRoot + ":" +
strconv.FormatUint(uint64(config.DbConfig.Port), 10) +
"/listDatabases").End()
if err != nil {
fmt.Println("listDatabase error:", err)
os.Exit(1)
}
if resp.StatusCode != 200 {
fmt.Println("listDatabase status:", resp.Status)
os.Exit(1)
}
type dblist struct {
Databases []string `json: "databases"`
}
var list dblist
json.Unmarshal([]byte(body), &list)
found := false
for _, db := range list.Databases {
if db == config.DATABASE {
found = true
break
}
}
fmt.Println("found database is", found)
if found == false {
resp, body, err = gorequest.New().Post("http://" +
config.DbConf(config.DbConfig).String() +
"/database/" + config.DATABASE + "/plocal/document").End()
if err != nil {
fmt.Println("create database:", err)
} else {
fmt.Println(body)
fmt.Println(resp.Status)
fmt.Println("Database created")
gorequest.New().Post("http://" + config.DbConf(config.DbConfig).String() + "/class/" + config.DATABASE + "/" + config.PASTECLASS).End()
config.Driver.Command("create property " + config.PASTECLASS + "." + config.USER_ID + " string")
config.Driver.Command("create property " + config.PASTECLASS + "." + config.TITLE + " string")
config.Driver.Command("create property " + config.PASTECLASS + "." + config.CONTENT + " string")
config.Driver.Command("create property " + config.PASTECLASS + "." + config.LANGUAGE + " string")
config.Driver.Command("create property " + config.PASTECLASS + "." + config.PUBLIC + " boolean")
}
} else {
fmt.Println("Database already exists")
}
}