Example #1
0
func DecodeClientToClientMessage(msg []byte) (Type, *UserToUserPackage, error) {
	var m ClientToClientMessage
	err := xml.Unmarshal(msg, &m)
	if err != nil {
		return UNKNOWN_T, nil, err
	}
	switch m.Type {
	case VOTE:
		var v VoteMessage
		err := xml.Unmarshal(msg, &v)
		if err != nil {
			return UNKNOWN_T, nil, errors.New("Couldn't decode the message: Broadcast or direct message malformed")
		}
		uu := UserToUserPackage{
			VoteMessage: &v,
		}
		return VOTE_T, &uu, nil
	case COORDINATOR:
		var v CoordinatorMessage
		err := xml.Unmarshal(msg, &v)
		if err != nil {
			return UNKNOWN_T, nil, errors.New("Couldn't decode the message: Broadcast or direct message malformed")
		}
		uu := UserToUserPackage{
			CoordinatorMessage: &v,
		}
		return COORDINATOR_T, &uu, nil
	}
	return UNKNOWN_T, nil, errors.New("Couldn't decode the message: No matching type")
}
Example #2
0
func RegisterDevice(token string, customData string, userId string,
	userSecret string, region string, applicationArn string) (arn string, err error) {
	values := url.Values{}
	values.Set("Action", "CreatePlatformEndpoint")
	values.Set("CustomUserData", customData)
	values.Set("Token", token)
	values.Set("PlatformApplicationArn", applicationArn)
	values.Set("Timestamp", time.Now().UTC().Format(time.RFC3339))

	response, err := makeRequest("http://sns."+region+".amazonaws.com/",
		values, userId, userSecret, region)

	if err != nil {
		return "", err
	}

	defer response.Body.Close()

	if response.StatusCode != 200 {
		content, _ := ioutil.ReadAll(response.Body)
		var errorResponse aws.ErrorResponse
		xml.Unmarshal(content, &errorResponse)
		return "", errors.New("Unable to register device. " + errorResponse.Error.Code + ": " + errorResponse.Error.Message)
	} else {
		content, _ := ioutil.ReadAll(response.Body)
		var createResponse CreateResponse
		xml.Unmarshal(content, &createResponse)
		return createResponse.CreatePlatformEndpointResult.EndpointArn, nil
	}
}
Example #3
0
func (client *Client) loadCloudFormationResource(action string, params Values, i interface{}) error {
	req, e := client.signedCloudFormationRequest(action, params)

	rsp, e := httpClient.Do(req)
	if e != nil {
		return e
	}
	defer rsp.Body.Close()
	b, e := ioutil.ReadAll(rsp.Body)
	if e != nil {
		return e
	}
	switch rsp.StatusCode {
	case 404:
		return ErrorNotFound
	case 200:
		if i != nil {
			return xml.Unmarshal(b, i)
		}
		return nil
	default:
		ersp := &ErrorResponse{}
		dbg.Printf("ERROR=%q", string(b))
		e = xml.Unmarshal(b, ersp)
		if e != nil {
			return fmt.Errorf("expected status 2xx but got %s (%s)", rsp.Status, string(b))

		}
		if strings.Contains(ersp.Error.Message, "does not exist") {
			return ErrorNotFound
		}
		return fmt.Errorf(ersp.Error.Message)
	}
}
Example #4
0
//解析配置文件内容至内存中
func Analyse() error {

	content, err := ioutil.ReadFile("../etc/config.xml")

	if err != nil {
		Log.Error(err)
		return err
	}

	err = xml.Unmarshal(content, &config)
	if err != nil {
		Log.Error(err)
		return err
	}

	content, err = ioutil.ReadFile("../etc/entity.xml")
	err = xml.Unmarshal(content, &entitys)

	if err != nil {
		Log.Error(err)
		return err
	}

	content, err = ioutil.ReadFile("../etc/url.xml")
	err = xml.Unmarshal(content, &urls)

	if err != nil {
		Log.Error(err)
		return err
	}

	return nil
}
Example #5
0
func WexinHandler(resp http.ResponseWriter, req *http.Request) {

	log.Println("method:", req.Method)
	if req.Method == "GET" {
		weixinValid(resp, req)
	} else {

		data, err := ioutil.ReadAll(req.Body)
		if nil != err {
			log.Println("read body err:", err)
			return
		}
		log.Println("data:", string(data))

		request := &entry.ReqMessage{}
		er := xml.Unmarshal(data, request)
		if nil != er {
			log.Println("decode body err:", er)
			return
		}

		event := request.Event
		msgType := request.MsgType
		ch := make(chan interface{})
		defer close(ch)
		if "event" == msgType && event == "subscribe" {
			//添加关注事件
			go subEventProcess(*request, ch)

		} else if "event" == msgType && event == "unsubscribe" {
			//取消订阅
			go unsubEventProcess(*request, ch)

		} else if "location" == msgType {
			//地理位置
			var msg entry.LocRequest
			err := xml.Unmarshal(data, &msg)
			if nil != err {
				log.Println("decode txt request body err:", err)
				return
			}

			go locMessageProcess(msg, ch)

		} else {
			var msg entry.TxtRequest
			err := xml.Unmarshal(data, &msg)
			if nil != err {
				log.Println("decode txt request body err:", er)
				return
			}

			go txtMessageProcess(msg, ch)
		}

		brespons, _ := xml.Marshal(<-ch)
		log.Println(string(brespons))
		resp.Write(brespons)
	}
}
Example #6
0
func (c *AliOSSClient) GetLocationOfBucket(bucket string) (string, error) {
	uri := fmt.Sprintf("/%s/?location", bucket)
	query := make(map[string]string)
	query["location"] = ""
	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "GET",
		Url:                  fmt.Sprintf("http://%s.%s", bucket, c.EndPoint),
		CanonicalizedHeaders: make(map[string]string),
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              &bytes.Reader{},
		ContentType:          "",
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := ""
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return "", err
	}
	if resp.StatusCode == 200 {
		xml.Unmarshal(xml_result, &v)
		return v, nil
	} else {
		xml.Unmarshal(xml_result, e)
		return "", e
	}
}
Example #7
0
File: rpc.go Project: nowa/OCSS
func callRet(ret interface{}, resp *http.Response) (code int, err error) {
	var (
		b  []byte
		er errRet
	)
	code = resp.StatusCode
	if code/100 == 2 {
		if ret == nil || resp.ContentLength == 0 {
			return
		}
		b, err = ioutil.ReadAll(resp.Body)
		if err != nil {
			return
		}
		ct := resp.Header.Get("Content-Type")
		if strings.Contains(ct, "application/json") {
			err = json.Unmarshal(b, ret)
		} else { // default decoding
			err = xml.Unmarshal(b, ret)
		}
	} else {
		if resp.ContentLength == 0 {
			return
		}
		b, err = ioutil.ReadAll(resp.Body)
		if err != nil {
			return
		}
		if err = xml.Unmarshal(b, &er); err != nil {
			return
		}
		err = errors.New(er.Code)
	}
	return
}
Example #8
0
func main() {
	data, err := ioutil.ReadFile("page.xml")
	if nil != err {
		fmt.Println(err)
	}
	{
		v := new(BlogContainer)
		err = xml.Unmarshal(data, v)
		if nil != err {
			fmt.Println(err)
			return
		}

		fmt.Printf("XMLName: %#v\n", v.XMLName)
		fmt.Printf("XMLName: %#v\n", v.Chapter.XMLName)
		fmt.Printf("Title: %v\n", v.Chapter.Title)
		for i, x := range v.Chapter.Name {
			fmt.Printf("Chapter %d: %v\n", i, x)
		}
	}
	{
		v := new(Blog)
		err = xml.Unmarshal(data, v)
		if nil != err {
			fmt.Println(err)
			return
		}
		fmt.Println(v.Title)
		fmt.Println(v.Tags)
		fmt.Println(v.Chapters)
	}
}
Example #9
0
func (r *Request) cachingReadEntity(contentType string, entityPointer interface{}) (err error) {
	var buffer []byte
	if r.bodyContent != nil {
		buffer = *r.bodyContent
	} else {
		buffer, err = ioutil.ReadAll(r.Request.Body)
		if err != nil {
			return err
		}
		r.bodyContent = &buffer
	}
	if strings.Contains(contentType, MIME_XML) {
		return xml.Unmarshal(buffer, entityPointer)
	}
	if strings.Contains(contentType, MIME_JSON) {
		return json.Unmarshal(buffer, entityPointer)
	}
	if MIME_XML == defaultRequestContentType {
		return xml.Unmarshal(buffer, entityPointer)
	}
	if MIME_JSON == defaultRequestContentType {
		return json.Unmarshal(buffer, entityPointer)
	}
	return NewError(400, "Unable to unmarshal content of type:"+contentType)
}
Example #10
0
func ReadCommandsFile(basedir string) (*CommandsXML, error) {
	commandsdata, err := ioutil.ReadFile(filepath.Join(basedir, "doc", "commands-xml", "commands.xml"))
	if err != nil {
		return nil, err
	}
	cs := &CommandsXMLSimple{}
	err = xml.Unmarshal(commandsdata, cs)
	if err != nil {
		return nil, err
	}

	c := &CommandsXML{}
	c.de = make(map[string]CommandsxmlCommand)
	c.en = make(map[string]CommandsxmlCommand)
	commandTranslationsEnDe = make(map[string]string)

	for _, v := range cs.Commands {
		commandTranslationsEnDe[v.En] = v.De
	}
	err = xml.Unmarshal(commandsdata, c)
	if err != nil {
		return nil, err
	}
	for _, v := range c.Commands {
		c.de[v.De] = v
		c.en[v.En] = v
	}
	return c, err
}
Example #11
0
func ParseFileList(in io.Reader, out *FileListing) (err error) {
	defer func() { out.Name = out.Base }()
	data, err := ioutil.ReadAll(in)
	if err != nil {
		return
	}

	/* First, try just reading it */
	err = xml.Unmarshal(data, out)
	if err == nil {
		return
	}

	/* If that failed, then try to read in another charset. This happens because
	 * microdc2 is known to lie by saying that the content is utf-8 when it's
	 * actually iso-8859-1 */
	translator, err := charset.TranslatorFrom("iso-8859-1")
	if err != nil {
		return
	}
	_, data, err = translator.Translate(data, true)
	if err != nil {
		return
	}
	return xml.Unmarshal(data, out)
}
Example #12
0
//get cores rule
func (c *AliOSSClient) GetCoreRule(bucket string) (*CORSConfiguration, error) {
	uri := fmt.Sprintf("/%s/?cors", bucket)
	query := make(map[string]string)
	header := make(map[string]string)
	query["cors"] = ""
	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "GET",
		Url:                  fmt.Sprintf("http://%s.%s", bucket, c.EndPoint),
		CanonicalizedHeaders: header,
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              &bytes.Reader{},
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := &CORSConfiguration{}
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode/100 == 2 {
		xml.Unmarshal(xml_result, v)
		return v, nil
	} else {
		xml.Unmarshal(xml_result, e)
		return nil, e
	}
}
Example #13
0
//Init multipart upload
func (c *AliOSSClient) GetInitMultipartUpload(bucket string, key string) (*MultiUploadInit, error) {
	uri := fmt.Sprintf("/%s/%s?uploads", bucket, key)
	query := make(map[string]string)
	header := make(map[string]string)
	query["uploads"] = ""
	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "POST",
		Url:                  fmt.Sprintf("http://%s.%s/%s", bucket, c.EndPoint, key),
		CanonicalizedHeaders: header,
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              &bytes.Reader{},
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := &MultiUploadInit{}
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode/100 == 2 {
		xml.Unmarshal(xml_result, v)
		return v, nil
	} else {
		xml.Unmarshal(xml_result, e)
		return nil, e
	}
}
Example #14
0
func main() {
	f, err := ioutil.ReadFile("example.xml")
	check(err)

	a := new(lib.Spells)

	err = xml.Unmarshal(f, &a)
	check(err)
	fmt.Printf("%+v", a)
	fmt.Println(" ")

	result, err := json.MarshalIndent(a, "", "  ")
	check(err)
	fmt.Printf("%+v", string(result))

	data := []byte("<cells><cell><name>Thomas</name></cell><cell><name>Janes</name></cell></cells>")

	b := new(Cells)

	err = xml.Unmarshal(data, &b)
	check(err)
	fmt.Printf("%+v", b)

	dataJson, err := json.MarshalIndent(b, "", "  ")
	check(err)
	fmt.Println(string(dataJson))

	c := new(TmpJson)

	err = json.Unmarshal(dataJson, &c)
	check(err)
	fmt.Printf("\n\n%+v", c)

}
Example #15
0
func (c *AliOSSClient) CloseBucketLogging(name string) error {
	xml_content := `<?xml version="1.0" encoding="UTF-8"?><BucketLoggingStatus></BucketLoggingStatus>`
	uri := fmt.Sprintf("/%s/?logging", name)
	query := make(map[string]string)
	header := make(map[string]string)
	query["logging"] = ""

	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "PUT",
		Url:                  fmt.Sprintf("http://%s.%s", name, c.EndPoint),
		CanonicalizedHeaders: header,
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              bytes.NewReader([]byte(xml_content)),
		ContentType:          "application/xml",
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := &BucketList{}
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return err
	}
	if resp.StatusCode/100 == 2 {
		xml.Unmarshal(xml_result, v)
		return nil
	} else {
		xml.Unmarshal(xml_result, e)
		return e
	}
}
Example #16
0
func (this *ZoneGroupTopology) CheckForUpdate(updateType UpdateType, cachedOnly bool, version string) (updateItem *UpdateItem, err error) {
	type UpdateItemHolder struct {
		XMLName xml.Name
		UpdateItem
	}
	type UpdateItemText struct {
		XMLName xml.Name
		Text    string `xml:",chardata"`
	}
	type Response struct {
		XMLName    xml.Name
		UpdateItem UpdateItemText
		ErrorResponse
	}
	args := []Arg{
		{"UpdateType", updateType},
		{"CachedOnly", cachedOnly},
		{"Version", version},
	}
	response := this.Svc.Call("CheckForUpdate", args)
	doc := Response{}
	xml.Unmarshal([]byte(response), &doc)
	rec := UpdateItemHolder{}
	xml.Unmarshal([]byte(doc.UpdateItem.Text), &rec)
	updateItem = &rec.UpdateItem
	err = doc.Error()
	return
}
Example #17
0
//Delete bucket
func (c *AliOSSClient) DeleteBucket(name string) error {
	uri := fmt.Sprintf("/%s/", name)
	query := make(map[string]string)
	header := make(map[string]string)

	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "DELETE",
		Url:                  fmt.Sprintf("http://%s.%s", name, c.EndPoint),
		CanonicalizedHeaders: header,
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              &bytes.Reader{},
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := &BucketList{}
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return err
	}
	if resp.StatusCode/100 == 2 {
		xml.Unmarshal(xml_result, v)
		return nil
	} else {
		xml.Unmarshal(xml_result, e)
		return e
	}
}
Example #18
0
func (this *ContentDirectory) Browse(req *BrowseRequest) (browseResult *BrowseResult, err error) {
	type Response struct {
		XMLName xml.Name
		Result  string
		BrowseResult
		upnpErrorResponse
	}
	args := []upnpArg{
		{"ObjectID", req.ObjectID},
		{"BrowseFlag", req.BrowseFlag},
		{"Filter", req.Filter},
		{"StartingIndex", req.StartingIndex},
		{"RequestedCount", req.RequestCount},
		{"SortCriteria", req.SortCriteria},
	}
	response := this.Svc.Call("Browse", args)
	doc := Response{}
	xml.Unmarshal([]byte(response), &doc)
	doc.Doc = &didl.Lite{}
	// log.Printf("%s", doc.Result)
	xml.Unmarshal([]byte(doc.Result), doc.Doc)
	browseResult = &doc.BrowseResult
	err = doc.Error()
	return
}
Example #19
0
func (c *AliOSSClient) GetBucketWebsite(name string) (*BucketWebsite, error) {
	uri := fmt.Sprintf("/%s/?website", name)
	query := make(map[string]string)
	header := make(map[string]string)
	query["website"] = ""

	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "GET",
		Url:                  fmt.Sprintf("http://%s.%s", name, c.EndPoint),
		CanonicalizedHeaders: header,
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              &bytes.Reader{},
		ContentType:          "application/xml",
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := &BucketWebsite{}
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode/100 == 2 {
		xml.Unmarshal(xml_result, v)
		return v, nil
	} else {
		xml.Unmarshal(xml_result, e)
		return nil, e
	}
}
Example #20
0
// ReadEntity checks the Accept header and reads the content into the entityPointer
// May be called multiple times in the request-response flow
func (r *Request) ReadEntity(entityPointer interface{}) (err error) {
	contentType := r.Request.Header.Get(HEADER_ContentType)

	var buffer []byte
	if r.bodyContent != nil {
		buffer = *r.bodyContent
	} else {
		buffer, err = ioutil.ReadAll(r.Request.Body)
		r.bodyContent = &buffer
		if err != nil {
			return err
		}
	}
	if strings.Contains(contentType, MIME_XML) {
		return xml.Unmarshal(buffer, entityPointer)
	}
	if strings.Contains(contentType, MIME_JSON) {
		return json.Unmarshal(buffer, entityPointer)
	}
	if MIME_XML == defaultRequestContentType {
		return xml.Unmarshal(buffer, entityPointer)
	}
	if MIME_JSON == defaultRequestContentType {
		return json.Unmarshal(buffer, entityPointer)
	}
	return errors.New("[restful] Unable to unmarshal content of type:" + contentType)
}
Example #21
0
func S3CopyFile(awsAuth *aws.Auth, fromS3Bucket, fromS3Path,
	toS3Bucket, toS3Path, permissionACL string) error {
	client := &http.Client{}
	destinationPath := fmt.Sprintf("http://%v.s3.amazonaws.com/%v",
		toS3Bucket, toS3Path)
	req, err := http.NewRequest("PUT", destinationPath, nil)
	if err != nil {
		return fmt.Errorf("PUT request on %v failed: %v", destinationPath, err)
	}
	req.Header.Add("x-amz-copy-source", fmt.Sprintf("/%v/%v", fromS3Bucket,
		fromS3Path))
	req.Header.Add("x-amz-date", time.Now().Format(time.RFC850))
	if permissionACL != "" {
		req.Header.Add("x-amz-acl", permissionACL)
	}
	signaturePath := fmt.Sprintf("/%v/%v", toS3Bucket, toS3Path)
	SignAWSRequest(*awsAuth, signaturePath, req)

	resp, err := client.Do(req)
	if resp == nil {
		return fmt.Errorf("Nil response received: %v", err)
	}
	defer resp.Body.Close()

	// attempt to read the response body to check for success/error message
	respBody, respBodyErr := ioutil.ReadAll(resp.Body)
	if respBodyErr != nil {
		return fmt.Errorf("Error reading s3 copy response body: %v", respBodyErr)
	}

	// Attempt to unmarshall the response body. If there's no errors, it means
	// that the S3 copy was successful. If there's an error, or a non-200
	// response code, it indicates a copy error
	copyObjectResult := CopyObjectResult{}
	xmlErr := xml.Unmarshal(respBody, &copyObjectResult)
	if xmlErr != nil || resp.StatusCode != http.StatusOK {
		errMsg := ""
		if xmlErr == nil {
			errMsg = fmt.Sprintf("S3 returned status code: %d", resp.StatusCode)
		} else {
			errMsg = fmt.Sprintf("unmarshalling error: %v", xmlErr)
		}
		// an unmarshalling error or a non-200 status code indicates S3 returned
		// an error so we'll now attempt to unmarshall that error response
		copyObjectError := CopyObjectError{}
		xmlErr = xml.Unmarshal(respBody, &copyObjectError)
		if xmlErr != nil {
			// *This should seldom happen since a non-200 status code or a
			// copyObjectResult unmarshall error on a response from S3 should
			// contain a CopyObjectError. An error here indicates possible
			// backwards incompatible changes in the AWS API
			return fmt.Errorf("Unrecognized S3 response: %v: %v", errMsg, xmlErr)
		}
		copyObjectError.ErrMsg = errMsg
		// if we were able to parse out an error reponse, then we can reliably
		// inform the user of the error
		return copyObjectError
	}
	return err
}
Example #22
0
func Open(filename string) (*Epub, error) {
	r, err := zip.OpenReader(filename)
	if err != nil {
		return nil, err
	}
	// We need r to stay open forever

	epub := &Epub{Zip: r}

	mimetype, _ := epub.getFileAsString("mimetype")
	if mimetype != "application/epub+zip" {
		return new(Epub), errors.New("Unsupported mime type.")
	}

	containerFile, _ := epub.getFile("META-INF/container.xml")
	c := new(Container)

	err = xml.Unmarshal(containerFile, c)
	if err != nil {
		return nil, err
	}

	rootFile, _ := epub.getFile(c.Rootfiles[0].Path)
	epub.Opfdir = path.Dir(c.Rootfiles[0].Path)

	pkg := new(Package)
	err = xml.Unmarshal(rootFile, pkg)
	if err != nil {
		return nil, err
	}
	epub.Manifest = pkg.Manifest.Items
	epub.Spine = pkg.Spine.Itemrefs

	return epub, nil
}
Example #23
0
func TestComplexSchema(t *testing.T) {

	ty := &types{
		schemas: []*XSDSchema{},
	}

	data := []byte(complex)
	err := xml.Unmarshal(data, &ty.schemas)
	if err != nil {
		t.Error(err)
	}

	err = xml.Unmarshal(data, &ty.schemaMetas)
	if err != nil {
		t.Error(err)
	}

	if ty.schemaMetas[0].xsdPrefix() != "" {
		t.Error("should have got xsd prefix \"\" got", ty.schemaMetas[0].xsdPrefix())
	}

	if ty.schemaMetas[0].tnsPrefix() != "tns" {
		t.Error("should have got prefix \"tns\" got", ty.schemaMetas[0].tnsPrefix())
	}
	// ty.genTypes()

	t.Log(fmt.Printf("%# v\n\n", pretty.Formatter(ty)))
}
Example #24
0
// Get more detail for a TV show, including information on it's episodes.
func (series *Series) GetDetail() (err error) {
	response, err := http.Get(fmt.Sprintf(GET_DETAIL_URL, API_KEY, strconv.FormatUint(series.Id, 10)))

	if err != nil {
		return
	}

	data, err := ioutil.ReadAll(response.Body)

	if err != nil {
		return
	}

	if err = xml.Unmarshal(data, series); err != nil {
		return
	}

	episodeList := EpisodeList{}

	if err = xml.Unmarshal(data, &episodeList); err != nil {
		return
	}

	if series.Seasons == nil {
		series.Seasons = make(map[uint64][]Episode)
	}

	for _, episode := range episodeList.Episodes {
		series.Seasons[episode.SeasonNumber] = append(series.Seasons[episode.SeasonNumber], episode)
	}

	return
}
Example #25
0
func parseBody(encryptType, timestamp, nonce, msgSignature string, body []byte) (msg *Message, err error) {
	msg = &Message{}
	// 如果报文被加密了,先要验签解密
	if encryptType == "aes" {
		encMsg := &EncMessage{}
		// 解析加密的 xml
		err = xml.Unmarshal(body, encMsg)
		if err != nil {
			return nil, err
		}
		msg.ToUserName = encMsg.ToUserName
		msg.Encrypt = encMsg.Encrypt

		if !CheckSignature(Token, timestamp, nonce, encMsg.Encrypt, msgSignature) {
			return nil, errors.New("check signature error")
		}

		body, err = DecryptMsg(encMsg.Encrypt, EncodingAESKey, AppId)
		if err != nil {
			return nil, err
		}
		log.Debugf("receive: %s", body)
	}

	// 解析 xml
	err = xml.Unmarshal(body, msg)
	if err != nil {
		return nil, err
	}

	return msg, nil
}
Example #26
0
File: soap.go Project: ronindev/dms
func main() {
	raw, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		panic(err)
	}
	var env soap.Envelope
	if err := xml.Unmarshal(raw, &env); err != nil {
		panic(err)
	}
	fmt.Println(env)
	var browse Browse
	err = xml.Unmarshal([]byte(env.Body.Action), &browse)
	if err != nil {
		panic(err)
	}
	fmt.Println(browse)
	raw, err = xml.MarshalIndent(
		GetSortCapabilitiesResponse{
			SortCaps: "dc:title",
		},
		"", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(raw))
}
Example #27
0
//parseRequest emulates the SOAP style rpc call by figuring out
//which "method" is being called
//fix Me: improve performance
func (c2b *C2B) parseRequest(r *http.Request) http.HandlerFunc {
	body, err := ioutil.ReadAll(r.Body)
	fmt.Println(string(body))

	processCheckoutOp := &ProcessCheckoutRequest{}
	confirmTrxOp := &ConfirmTransactionRequest{}
	transStatusOp := &TransactionStatusRequest{}

	err = xml.Unmarshal(body, processCheckoutOp)
	err = xml.Unmarshal(body, confirmTrxOp)
	err = xml.Unmarshal(body, transStatusOp)

	if err != nil {
		fmt.Println(err)
		return func(rw http.ResponseWriter, r *http.Request) {
			rw.WriteHeader(500)
			rw.Write([]byte(err.Error()))
		}
	}
	operation := processCheckoutOp.Body.ProcessCheckout.XMLName.Local
	if strings.Contains(operation, "processCheckOut") {
		return c2b.processCheckout(processCheckoutOp)
	}
	operation = confirmTrxOp.Body.ConfirmTransaction.XMLName.Local
	if strings.Contains(operation, "transactionConfirmRequest") {
		return c2b.confirmTransaction(confirmTrxOp)
	}
	operation = transStatusOp.Body.TransactionStatus.XMLName.Local
	if strings.Contains(operation, "transactionStatusRequest") {
		return c2b.transactionStatus(transStatusOp)
	}
	return c2b.unknownOperation(operation)

}
Example #28
0
func TestProfileConstraints(t *testing.T) {
	Convey("Profile validation should not be nominal", t, func() {
		Convey("there are no tests", func() {
			profileData := `<?xml version="1.0" encoding="UTF-8"?><sg name="Basic example" uid="1"><test name="Profile test" critical="1s" warning="750ms"/></sg>`
			profile := Profile{}
			xml.Unmarshal([]byte(profileData), &profile)
			So(profile.Validate(), ShouldNotBeNil)
		})
		Convey("there cookie forwaring is enabled on top request", func() {
			profileData := `<?xml version="1.0" encoding="UTF-8"?>
			<sg name="Basic example" uid="1">
				<test name="SG test" critical="1s" warning="750ms">
					<description>This is the test for SG.</description>
					<request method="get" responseType="json" repeat="20"
						useParentCookies="true" concurrency="10">
						<url base="http://google.com/search" />
					</request>
				</test>
			</sg>`
			profile := Profile{}
			xml.Unmarshal([]byte(profileData), &profile)
			So(func() { profile.Validate() }, ShouldNotPanic)
		})
	})
}
Example #29
0
func main() {
	content, err := ioutil.ReadFile("studygolang.xml")
	if err != nil {
		log.Fatal(err)
	}
	var result Result
	err = xml.Unmarshal(content, &result)
	if err != nil {
		log.Fatal(err)
	}
	log.Println(result)
	log.Println(result.Persons[0].Name)

	//input := "<?xml version=\"1.0\" encoding=\"GBK\"?><request><head><h_exch_code>800101</h_exch_code><h_bank_no>1111</h_bank_no><h_user_id>1038738897</h_user_id><h_branch_id>B00008211</h_branch_id><h_fact_date>20110321</h_fact_date><h_fact_time>16:28:30</h_fact_time><h_exch_date>20130929</h_exch_date><h_serial_no>123456</h_serial_no><h_rsp_code>hj123545</h_rsp_code><h_rsp_msg>ar</h_rsp_msg></head><body><record><user_pwd>54f9b3396fe28c208d525db21588965c</user_pwd></record></body></request>"
	//inputReader := strings.NewReader(input)
	content, err = ioutil.ReadFile("request.xml")
	decoder := mahonia.NewDecoder("gb18030")
	r := bufio.NewReader(decoder.NewReader(content))
	if err != nil {
		log.Fatal(err)
	}
	log.Println(content)
	var request Request_800101
	err = xml.Unmarshal(content, &request)
	if err != nil {
		log.Fatal(err)
	}
	log.Println(request)
}
Example #30
0
func (client *Client) loadResource(method string, url string, r io.Reader, i interface{}) error {
	dbg.Printf("executing method=%s to url=%s", method, url)
	req, e := http.NewRequest(method, url, r)
	if e != nil {
		return e
	}
	client.SignAwsRequestV2(req, time.Now())
	rsp, e := http.DefaultClient.Do(req)
	if e != nil {
		return e
	}
	defer rsp.Body.Close()
	dbg.Printf("got status %s", rsp.Status)

	b, e := ioutil.ReadAll(rsp.Body)
	if e != nil {
		return e
	}
	dbg.Printf("got response %s", b)

	if rsp.Status[0] != '2' {
		resp := &ErrorResponse{}
		if e = xml.Unmarshal(b, resp); e != nil {
			return e
		}
		return resp.Error
	}
	return xml.Unmarshal(b, i)
}