// Like Verify on a parsed URL
func VerifyValues(values url.Values) (grant bool, identifier string, err error) {
err = nil
var postArgs url.Values
postArgs = url.Values(map[string][]string{})
// Create the url
URLEndPoint := values.Get("openid.op_endpoint")
if URLEndPoint == "" {
log.Printf("no openid.op_endpoint")
return false, "", errors.New("no openid.op_endpoint")
}
for k, v := range values {
postArgs[k] = v
}
postArgs.Set("openid.mode", "check_authentication")
postContent := postArgs.Encode()
// Post the request
var client = new(http.Client)
postReader := bytes.NewBuffer([]byte(postContent))
response, err := client.Post(URLEndPoint, "application/x-www-form-urlencoded", postReader)
if err != nil {
log.Printf("VerifyValues failed at post")
return false, "", err
}
// Parse the response
// Convert the reader
// We limit the size of the response to 1024 bytes but it should be large enough for most cases
buffer := make([]byte, 1024)
_, err = response.Body.Read(buffer)
if err != nil {
log.Printf("VerifyValues failed reading response")
return false, "", err
}
// Check for ns
rematch := REVerifyDirectNs.FindSubmatch(buffer)
if rematch == nil {
return false, "", errors.New("VerifyValues: ns value not found on the response of the OP")
}
nsValue := string(rematch[1])
if !bytes.Equal([]byte(nsValue), []byte("http://specs.openid.net/auth/2.0")) {
return false, "", errors.New("VerifyValues: ns value not correct: " + nsValue)
}
// Check for is_valid
match, err := regexp.Match(REVerifyDirectIsValid, buffer)
if err != nil {
return false, "", err
}
identifier = values.Get("openid.claimed_id")
if !match {
log.Printf("no is_valid:true in \"%s\"", buffer)
}
return match, identifier, nil
}
// postPhoto uses the Buzz API to post the image to the user's Buzz stream.
func postPhoto(client *http.Client, photoURL string) error {
const url = "https://www.googleapis.com/buzz/v1/activities/@me/@self"
const text = "Moustachio"
type m map[string]interface{}
post := m{"data": m{"object": m{
"type": "note",
"content": text,
"attachments": []m{{
"type": "photo",
"content": text,
"links": m{
"enclosure": []m{{
"href": photoURL,
"type": "image/jpeg",
}},
},
}},
}}}
b, err := json.Marshal(post)
if err != nil {
return err
}
resp, err := client.Post(url, "application/json", bytes.NewBuffer(b))
if err != nil {
return err
}
if resp.StatusCode != 200 {
return errors.New("invalid post " + resp.Status)
}
return nil
}
func (this *Neo4j) send(url string, data string) (string, os.Error) {
var (
resp *http.Response // http response
buf bytes.Buffer // contains http response body
err os.Error
)
if len(url) < 1 {
url = this.URL + "node" // default path
}
client := new(http.Client)
switch strings.ToLower(this.Method) { // which http method
case "delete":
req, e := http.NewRequest("DELETE", url, nil)
if e != nil {
err = e
break
}
resp, err = client.Do(req)
case "post":
body := strings.NewReader(data)
resp, err = client.Post(url,
"application/json",
body,
)
case "put":
body := strings.NewReader(data)
req, e := http.NewRequest("PUT", url, body)
if e != nil {
err = e
break
}
req.Header.Set("Content-Type", "application/json")
resp, err = client.Do(req)
case "get":
fallthrough
default:
resp, err = client.Get(url)
}
if err != nil {
return "", err
}
defer func() {
if resp.Body != nil {
resp.Body.Close()
}
}()
_, err = buf.ReadFrom(resp.Body)
if err != nil {
return "", err
}
this.StatusCode = resp.StatusCode // the calling method should do more inspection with chkStatusCode() method and determine if the operation was successful or not.
return buf.String(), nil
}
func GetSoapEnvelope(query string, numero uint, mdp string) (envelope *SoapEnvelope) {
httpClient := new(http.Client)
soapRequestContent := fmt.Sprintf(query, numero, mdp)
resp, err := httpClient.Post(MH_SOAP_URL, "text/xml; charset=utf-8", bytes.NewBufferString(soapRequestContent))
if err != nil {
fmt.Println("Erreur : " + err.String())
return nil
}
// là on fait du lourd : on passe par une chaine car j'ai pas le temps ce soir de trouver comment sauter directement un bout du flux jusqu'au début du xml
b, e := ioutil.ReadAll(resp.Body)
if e != nil {
fmt.Println("Erreur lecture :")
fmt.Println(e)
}
in := string(b)
indexDebutXml := strings.Index(in, "<?xml version")
if indexDebutXml > 0 {
fmt.Printf("Erreur message SOAP. Début XML à l'index %d\n", indexDebutXml)
in = in[indexDebutXml:len(in)]
}
//fmt.Print(in)
parser := xml.NewParser(bytes.NewBufferString(in))
parser.CharsetReader = CharsetReader
envelope = new(SoapEnvelope)
err = parser.Unmarshal(&envelope, nil)
if err != nil {
fmt.Println("Erreur au décodage du XML : " + err.String())
return nil
}
resp.Body.Close()
return
}