Пример #1
0
func createOrModify(args intf.Command) (result string, err error) {
	subs := args.Subs()
	typeName := subs[0]
	ciName := subs[1]

	ciType, err := metadata.Type(typeName)
	if err != nil {
		return
	}

	// put this as the root in a map containing a map
	// do this AFTER the for loop

	// create new map and put the below in it

	mapProps := make(map[string]interface{})

	props := args.Arguments()
	for _, prop := range props {
		key := prop.Name()

		mapProps[key], err = translateProp(ciType, prop)
		if err != nil {
			return
		}
	}

	id := ciName
	id = AntiAbbreviate(id)
	if ciType.Root != "" && !strings.HasPrefix(id, ciType.Root) {
		id = ciType.Root + "/" + id
	}
	mapProps["-id"] = id

	final := map[string]interface{}{ciType.Type: mapProps}

	// TODO Make this a util?
	json, _ := j2x.MapToJson(final)
	xml, _ := j2x.JsonToXml(json)

	switch args.Main() {
	case "create":
		body, err := http.Create("/repository/ci/"+id, bytes.NewBuffer(xml))
		if err != nil {
			return "error", err
		}
		return Xml2CleanJson(body)
	case "modify-sub":
		body, err := http.Update("/repository/ci/"+id, bytes.NewBuffer(xml))
		if err != nil {
			return "error", err
		}
		return Xml2CleanJson(body)
	}
	return "error", errors.New("Unknown command " + args.Main())

}
Пример #2
0
func modify(args intf.Command) (result string, err error) {
	resultMap, err := ReadAsMap(args)
	if err != nil {
		return "error", err
	}

	content := resultMap["content"]
	mapContent, ok := content.(map[string]interface{})
	if !ok {
		return "error", errors.New("Unable to modify existing content")
	}

	props := args.Arguments()
	for _, prop := range props {
		key := prop.Name()

		split := strings.SplitN(key, "-", 2)
		prefix := split[0]
		switch prefix {
		case "add", "remove", "change":
			if len(split) > 1 {
				key = split[1]
			}
			err = handleAddRemoveChange(mapContent, prefix, key, prop)
			if err != nil {
				return "error", err
			}
		default:
			typeName, ok := resultMap["type"].(string)
			if !ok {
				return "error", errors.New("Cannot resolve type for existing item")
			}

			ciType, err := metadata.Type(typeName)
			if err != nil {
				return "error", err
			}

			err = handleDefault(mapContent, key, prop, ciType)
			if err != nil {
				return "error", err
			}
		}
	}

	json, err := json.MarshalIndent(resultMap, "", "    ")

	createCmd, err := cmd.NewStdinCmd("modify-sub", string(json))
	if err != nil {
		return "error", err
	}
	return createOrModify(createCmd)
}
Пример #3
0
func xml2CleanMap(body []byte) (resultMap map[string]interface{}, err error) {
	values, err := x2j.XmlToMap(body)
	if err != nil {
		return
	}

	cleanProperties := make(map[string]interface{})
	resultMap = make(map[string]interface{})

	for key, value := range values {
		resultMap["type"] = key

		ciType, err := metadata.Type(key)
		if err != nil {
			return nil, err
		}

		valueMap := value.(map[string]interface{})

		for k, v := range valueMap {
			if strings.HasPrefix(k, "-") {

				resultMap[k[1:]] = v

			} else {
				cleanProperties[k], err = readProperty(k, v, ciType)
				if err != nil {
					return nil, err
				}
			}
		}
	}

	resultMap["content"] = cleanProperties
	return resultMap, nil
}