Exemplo n.º 1
0
func (h *Hoverfly) SetRequestTemplates(path string) (responseTemplates *matching.RequestTemplateResponsePairPayload, err error) {

	conf, err := ioutil.ReadFile(path)
	if err != nil {
		return nil, err
	}

	url := h.buildURL("/api/templates")

	slingRequest := sling.New().Post(url).Body(strings.NewReader(string(conf)))
	_, err = h.performAPIRequest(slingRequest)
	if err != nil {
		return nil, err
	}

	slingRequest = sling.New().Get(url).Body(strings.NewReader(string(conf)))
	getResponse, err := h.performAPIRequest(slingRequest)
	if err != nil {
		return nil, err
	}

	requestTemplates, err := unmarshalRequestTemplates(getResponse)
	if err != nil {
		return nil, err
	}

	return requestTemplates, nil
}
Exemplo n.º 2
0
// Set will go the state endpoint in Hoverfly, sending JSON that will set the mode of Hoverfly
func (h *Hoverfly) SetDelays(path string) (rd []ResponseDelaySchema, err error) {

	conf, err := ioutil.ReadFile(path)
	if err != nil {
		return rd, err
	}

	url := h.buildURL("/api/delays")

	slingRequest := sling.New().Put(url).Body(strings.NewReader(string(conf)))

	slingRequest, err = h.addAuthIfNeeded(slingRequest)
	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not authenticate  with Hoverfly")
	}

	request, err := slingRequest.Request()
	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not communicate with Hoverfly")
	}

	response, err := h.httpClient.Do(request)
	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not communicate with Hoverfly")
	}

	slingRequest = sling.New().Get(url).Body(strings.NewReader(string(conf)))

	slingRequest, err = h.addAuthIfNeeded(slingRequest)
	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not authenticate  with Hoverfly")
	}

	request, err = slingRequest.Request()
	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not communicate with Hoverfly")
	}

	response, err = h.httpClient.Do(request)
	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not communicate with Hoverfly")
	}
	apiResponse := createAPIDelaysResponse(response)

	return apiResponse.Data, nil
}
Exemplo n.º 3
0
func (h *Hoverfly) ImportSimulation(simulationData string) error {
	url := h.buildURL("/api/records")

	slingRequest := sling.New().Post(url).Body(strings.NewReader(simulationData))
	slingRequest, err := h.addAuthIfNeeded(slingRequest)
	if err != nil {
		log.Debug(err.Error())
		return errors.New("Could not authenticate  with Hoverfly")
	}

	request, err := slingRequest.Request()
	if err != nil {
		log.Debug(err.Error())
		return errors.New("Could not communicate with Hoverfly")
	}

	response, err := h.httpClient.Do(request)

	if err != nil {
		log.Debug(err.Error())
		return errors.New("Could not communicate with Hoverfly")
	}

	if response.StatusCode == 401 {
		return errors.New("Hoverfly requires authentication")
	}

	if response.StatusCode != 200 {
		return errors.New("Import to Hoverfly failed")
	}

	return nil
}
Exemplo n.º 4
0
// GetMiddle will go the middleware endpoint in Hoverfly, parse the JSON response and return the middleware of Hoverfly
func (h *Hoverfly) GetMiddleware() (string, error) {
	url := h.buildURL("/api/middleware")

	slingRequest := sling.New().Get(url)

	slingRequest, err := h.addAuthIfNeeded(slingRequest)
	if err != nil {
		log.Debug(err.Error())
		return "", errors.New("Could not authenticate with Hoverfly")
	}

	request, err := slingRequest.Request()

	if err != nil {
		log.Debug(err.Error())
		return "", errors.New("Could not communicate with Hoverfly")
	}

	response, err := h.httpClient.Do(request)
	if err != nil {
		log.Debug(err.Error())
		return "", errors.New("Could not communicate with Hoverfly")
	}

	if response.StatusCode == 401 {
		return "", errors.New("Hoverfly requires authentication")
	}

	defer response.Body.Close()

	middlewareResponse := h.createMiddlewareSchema(response)

	return middlewareResponse.Middleware, nil
}
Exemplo n.º 5
0
//func (a PetApi) UpdatePetWithForm (petId int64, name string, status string) (error) {
func (a PetApi) UpdatePetWithForm(petId int64, name string, status string) error {

	_sling := sling.New().Post(a.Configuration.BasePath)

	// create path and map variables
	path := "/v2/pet/{petId}"
	path = strings.Replace(path, "{"+"petId"+"}", fmt.Sprintf("%v", petId), -1)

	_sling = _sling.Path(path)

	// add default headers if any
	for key := range a.Configuration.DefaultHeader {
		_sling = _sling.Set(key, a.Configuration.DefaultHeader[key])
	}

	// accept header
	accepts := []string{"application/xml", "application/json"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	type FormParams struct {
		name   string `url:"name,omitempty"`
		status string `url:"status,omitempty"`
	}
	_sling = _sling.BodyForm(&FormParams{name: name, status: status})

	// We use this map (below) so that any arbitrary error JSON can be handled.
	// FIXME: This is in the absence of this Go generator honoring the non-2xx
	// response (error) models, which needs to be implemented at some point.
	var failurePayload map[string]interface{}

	httpResponse, err := _sling.Receive(nil, &failurePayload)

	if err == nil {
		// err == nil only means that there wasn't a sub-application-layer error (e.g. no network error)
		if failurePayload != nil {
			// If the failurePayload is present, there likely was some kind of non-2xx status
			// returned (and a JSON payload error present)
			var str []byte
			str, err = json.Marshal(failurePayload)
			if err == nil { // For safety, check for an error marshalling... probably superfluous
				// This will return the JSON error body as a string
				err = errors.New(string(str))
			}
		} else {
			// So, there was no network-type error, and nothing in the failure payload,
			// but we should still check the status code
			if httpResponse == nil {
				// This should never happen...
				err = errors.New("No HTTP Response received.")
			} else if code := httpResponse.StatusCode; 200 > code || code > 299 {
				err = errors.New("HTTP Error: " + string(httpResponse.StatusCode))
			}
		}
	}

	return err
}
Exemplo n.º 6
0
func newClient(httpClient *http.Client) *client {
	base := sling.New().Client(httpClient).Base(facebookAPI)
	return &client{
		c:     httpClient,
		sling: base,
	}
}
Exemplo n.º 7
0
/**
 * Returns pet inventories by status
 * Returns a map of status codes to quantities
 * @return map[string]int32
 */
func (a StoreApi) GetInventory() (map[string]int32, error) {

	_sling := sling.New().Get(a.Configuration.BasePath)

	// authentication (api_key) required

	// set key with prefix in header
	_sling.Set("api_key", a.Configuration.GetApiKeyWithPrefix("api_key"))

	// create path and map variables
	path := "/v2/store/inventory"

	_sling = _sling.Path(path)

	// add default headers if any
	for key := range a.Configuration.DefaultHeader {
		_sling = _sling.Set(key, a.Configuration.DefaultHeader[key])
	}

	// accept header
	accepts := []string{"application/json"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	var successPayload = new(map[string]int32)

	// We use this map (below) so that any arbitrary error JSON can be handled.
	// FIXME: This is in the absence of this Go generator honoring the non-2xx
	// response (error) models, which needs to be implemented at some point.
	var failurePayload map[string]interface{}

	httpResponse, err := _sling.Receive(successPayload, &failurePayload)

	if err == nil {
		// err == nil only means that there wasn't a sub-application-layer error (e.g. no network error)
		if failurePayload != nil {
			// If the failurePayload is present, there likely was some kind of non-2xx status
			// returned (and a JSON payload error present)
			var str []byte
			str, err = json.Marshal(failurePayload)
			if err == nil { // For safety, check for an error marshalling... probably superfluous
				// This will return the JSON error body as a string
				err = errors.New(string(str))
			}
		} else {
			// So, there was no network-type error, and nothing in the failure payload,
			// but we should still check the status code
			if httpResponse == nil {
				// This should never happen...
				err = errors.New("No HTTP Response received.")
			} else if code := httpResponse.StatusCode; 200 > code || code > 299 {
				err = errors.New("HTTP Error: " + string(httpResponse.StatusCode))
			}
		}
	}

	return *successPayload, err
}
Exemplo n.º 8
0
// GetMode will go the state endpoint in Hoverfly, parse the JSON response and return the mode of Hoverfly
func (h *Hoverfly) GetDelays() (rd []ResponseDelaySchema, err error) {
	url := h.buildURL("/api/delays")

	slingRequest := sling.New().Get(url)

	slingRequest, err = h.addAuthIfNeeded(slingRequest)
	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not authenticate  with Hoverfly")
	}

	request, err := slingRequest.Request()

	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not communicate with Hoverfly")
	}

	response, err := h.httpClient.Do(request)
	if err != nil {
		log.Debug(err.Error())
		return rd, errors.New("Could not communicate with Hoverfly")
	}

	defer response.Body.Close()

	apiResponse := createAPIDelaysResponse(response)

	return apiResponse.Data, nil
}
Exemplo n.º 9
0
/**
 * Logs user into the system
 *
 * @param username The user name for login
 * @param password The password for login in clear text
 * @return string
 */
func (a UserApi) LoginUser(username string, password string) (string, error) {

	_sling := sling.New().Get(a.Configuration.BasePath)

	// create path and map variables
	path := "/v2/user/login"

	_sling = _sling.Path(path)

	// add default headers if any
	for key := range a.Configuration.DefaultHeader {
		_sling = _sling.Set(key, a.Configuration.DefaultHeader[key])
	}

	type QueryParams struct {
		Username string `url:"username,omitempty"`
		Password string `url:"password,omitempty"`
	}
	_sling = _sling.QueryStruct(&QueryParams{Username: username, Password: password})
	// accept header
	accepts := []string{"application/xml", "application/json"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	var successPayload = new(string)

	// We use this map (below) so that any arbitrary error JSON can be handled.
	// FIXME: This is in the absence of this Go generator honoring the non-2xx
	// response (error) models, which needs to be implemented at some point.
	var failurePayload map[string]interface{}

	httpResponse, err := _sling.Receive(successPayload, &failurePayload)

	if err == nil {
		// err == nil only means that there wasn't a sub-application-layer error (e.g. no network error)
		if failurePayload != nil {
			// If the failurePayload is present, there likely was some kind of non-2xx status
			// returned (and a JSON payload error present)
			var str []byte
			str, err = json.Marshal(failurePayload)
			if err == nil { // For safety, check for an error marshalling... probably superfluous
				// This will return the JSON error body as a string
				err = errors.New(string(str))
			}
		} else {
			// So, there was no network-type error, and nothing in the failure payload,
			// but we should still check the status code
			if httpResponse == nil {
				// This should never happen...
				err = errors.New("No HTTP Response received.")
			} else if code := httpResponse.StatusCode; 200 > code || code > 299 {
				err = errors.New("HTTP Error: " + string(httpResponse.StatusCode))
			}
		}
	}

	return *successPayload, err
}
Exemplo n.º 10
0
func (s *SpectoLab) GetSimulation(simulation Simulation, overrideHost string) ([]byte, error) {
	var url string
	if len(overrideHost) > 0 {
		url = s.buildURL(fmt.Sprintf("/api/v1/users/%v/simulations/%v/versions/%v/data?override-host=%v", simulation.Vendor, simulation.Name, simulation.Version, overrideHost))
	} else {
		url = s.buildURL(fmt.Sprintf("/api/v1/users/%v/simulations/%v/versions/%v/data", simulation.Vendor, simulation.Name, simulation.Version))
	}

	request, err := sling.New().Get(url).Add("Authorization", s.buildAuthorizationHeaderValue()).Add("Content-Type", "application/json").Request()
	if err != nil {
		log.Debug(err.Error())
		return nil, errors.New("Could not create a request to SpectoLab")
	}

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		log.Debug(err.Error())
		return nil, errors.New("Could not communicate with SpectoLab")
	}

	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Simulation not found in SpectoLab")
	}

	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		log.Debug(err.Error())
		return nil, errors.New("Could not pull simulation from SpectoLab")
	}

	return body, nil
}
Exemplo n.º 11
0
func UserGet(userId int) (user User, err error) {
	params := &UserGetParams{UserIds: strconv.Itoa(userId), Version: apiVersion, Fields: "photo_100,status"}
	response := new(UserGetResponse)
	_, err = sling.New().Get(path + "users.get").QueryStruct(params).ReceiveSuccess(response)
	user = response.Users[0]
	return
}
Exemplo n.º 12
0
func (s *SpectoLab) UploadSimulation(simulation Simulation, data []byte) (bool, error) {
	err := s.CreateSimulation(simulation)

	if err != nil {
		log.Debug(err)
		return false, errors.New("Unable to create a simulation on SpectoLab")
	}

	url := s.buildURL(fmt.Sprintf("/api/v1/users/%v/simulations/%v/versions/%v/data", simulation.Vendor, simulation.Name, simulation.Version))

	request, err := sling.New().Put(url).Add("Authorization", s.buildAuthorizationHeaderValue()).Add("Content-Type", "application/json").Body(strings.NewReader(string(data))).Request()

	if err != nil {
		log.Debug(err)
		return false, errors.New("Could not create a request to check API key against SpectoLab")
	}

	response, err := http.DefaultClient.Do(request)

	if err != nil {
		log.Debug(err)
		return false, errors.New("Could not communicate with SpectoLab")
	}

	defer response.Body.Close()

	return response.StatusCode >= 200 && response.StatusCode <= 299, nil
}
Exemplo n.º 13
0
//Create a new project.
//Implementation Notes
//This endpoint is for user to create a new project.
//@param project New created project.
//@return void
//func (a HarborAPI) ProjectsPost (prjUsr UsrInfo, project Project) (int, error) {
func (a HarborAPI) ProjectsPost(prjUsr UsrInfo, project Project) (int, error) {

	_sling := sling.New().Post(a.basePath)

	// create path and map variables
	path := "/api/projects"

	_sling = _sling.Path(path)

	// accept header
	accepts := []string{"application/json", "text/plain"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	// body params
	_sling = _sling.BodyJSON(project)

	req, err := _sling.Request()
	req.SetBasicAuth(prjUsr.Name, prjUsr.Passwd)

	client := &http.Client{}
	httpResponse, err := client.Do(req)
	defer httpResponse.Body.Close()

	return httpResponse.StatusCode, err
}
Exemplo n.º 14
0
//Search for projects and repositories
//Implementation Notes
//The Search endpoint returns information about the projects and repositories
//offered at public status or related to the current logged in user.
//The response includes the project and repository list in a proper display order.
//@param q Search parameter for project and repository name.
//@return []Search
func (a testapi) SearchGet(q string, authInfo ...usrInfo) (int, apilib.Search, error) {
	var httpCode int
	var body []byte
	var err error

	_sling := sling.New().Get(a.basePath)

	// create path and map variables
	path := "/api/search"
	_sling = _sling.Path(path)

	type QueryParams struct {
		Query string `url:"q,omitempty"`
	}

	_sling = _sling.QueryStruct(&QueryParams{Query: q})

	if len(authInfo) > 0 {
		httpCode, body, err = request(_sling, jsonAcceptHeader, authInfo[0])
	} else {
		httpCode, body, err = request(_sling, jsonAcceptHeader)
	}

	var successPayload = new(apilib.Search)
	err = json.Unmarshal(body, &successPayload)
	return httpCode, *successPayload, err
}
Exemplo n.º 15
0
func (h *Hoverfly) generateAuthToken() (string, error) {
	credentials := HoverflyAuthSchema{
		Username: h.Username,
		Password: h.Password,
	}

	jsonCredentials, err := json.Marshal(credentials)
	if err != nil {
		return "", err
	}

	request, err := sling.New().Post(h.buildURL("/api/token-auth")).Body(strings.NewReader(string(jsonCredentials))).Request()
	if err != nil {
		return "", err
	}

	response, err := h.httpClient.Do(request)
	if err != nil {
		return "", err
	}

	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return "", err
	}

	var authToken HoverflyAuthTokenSchema
	err = json.Unmarshal(body, &authToken)
	if err != nil {
		return "", err
	}

	return authToken.Token, nil
}
Exemplo n.º 16
0
//func (a PetApi) FindPetsByStatus (Status []string) ([]Pet, error) {
func (a PetApi) FindPetsByStatus(Status []string) ([]Pet, error) {

	_sling := sling.New().Get(a.basePath)

	// create path and map variables
	path := "/v2/pet/findByStatus"

	_sling = _sling.Path(path)

	type QueryParams struct {
		Status []string `url:"status,omitempty"`
	}
	_sling = _sling.QueryStruct(&QueryParams{Status: Status})
	// accept header
	accepts := []string{"application/json", "application/xml"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	response := new([]Pet)
	_, err := _sling.ReceiveSuccess(response)
	//fmt.Println("FindPetsByStatus response: ", response, resp, err)
	return *response, err
}
Exemplo n.º 17
0
//func (a UserApi) LoginUser (Username string, Password string) (string, error) {
func (a UserApi) LoginUser(Username string, Password string) (string, error) {

	_sling := sling.New().Get(a.basePath)

	// create path and map variables
	path := "/v2/user/login"

	_sling = _sling.Path(path)

	type QueryParams struct {
		Username string `url:"username,omitempty"`
		Password string `url:"password,omitempty"`
	}
	_sling = _sling.QueryStruct(&QueryParams{Username: Username, Password: Password})
	// accept header
	accepts := []string{"application/json", "application/xml"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	response := new(string)
	_, err := _sling.ReceiveSuccess(response)
	//fmt.Println("LoginUser response: ", response, resp, err)
	return *response, err
}
Exemplo n.º 18
0
//func (a PetApi) UpdatePetWithForm (PetId string, Name string, Status string) (error) {
func (a PetApi) UpdatePetWithForm(PetId string, Name string, Status string) error {

	_sling := sling.New().Post(a.basePath)

	// create path and map variables
	path := "/v2/pet/{petId}"
	path = strings.Replace(path, "{"+"petId"+"}", fmt.Sprintf("%v", PetId), -1)

	_sling = _sling.Path(path)

	// accept header
	accepts := []string{"application/json", "application/xml"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	type FormParams struct {
		Name   string `url:"name,omitempty"`
		Status string `url:"status,omitempty"`
	}
	_sling = _sling.BodyForm(&FormParams{Name: Name, Status: Status})

	_, err := _sling.ReceiveSuccess(nil)
	//fmt.Println("UpdatePetWithForm response: void, ", resp, err)
	return err
}
Exemplo n.º 19
0
//func (a PetApi) UploadFile (PetId int64, AdditionalMetadata string, File *os.File) (error) {
func (a PetApi) UploadFile(PetId int64, AdditionalMetadata string, File *os.File) error {

	_sling := sling.New().Post(a.basePath)

	// create path and map variables
	path := "/v2/pet/{petId}/uploadImage"
	path = strings.Replace(path, "{"+"petId"+"}", fmt.Sprintf("%v", PetId), -1)

	_sling = _sling.Path(path)

	// accept header
	accepts := []string{"application/json", "application/xml"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	type FormParams struct {
		AdditionalMetadata string   `url:"additionalMetadata,omitempty"`
		File               *os.File `url:"file,omitempty"`
	}
	_sling = _sling.BodyForm(&FormParams{AdditionalMetadata: AdditionalMetadata, File: File})

	_, err := _sling.ReceiveSuccess(nil)
	//fmt.Println("UploadFile response: void, ", resp, err)
	return err
}
Exemplo n.º 20
0
// Wipe will call the records endpoint in Hoverfly with a DELETE request, triggering Hoverfly to wipe the database
func (h *Hoverfly) DeleteSimulations() error {
	url := h.buildURL("/api/records")

	slingRequest := sling.New().Delete(url)
	slingRequest, err := h.addAuthIfNeeded(slingRequest)
	if err != nil {
		log.Debug(err.Error())
		return errors.New("Could not authenticate  with Hoverfly")
	}

	request, err := slingRequest.Request()

	if err != nil {
		log.Debug(err.Error())
		return errors.New("Could not communicate with Hoverfly")
	}

	response, err := h.httpClient.Do(request)
	if err != nil {
		log.Debug(err.Error())
		return errors.New("Could not communicate with Hoverfly")
	}

	defer response.Body.Close()

	if response.StatusCode == 401 {
		return errors.New("Hoverfly requires authentication")
	}

	if response.StatusCode != 200 {
		return errors.New("Simulations were not deleted from Hoverfly")
	}

	return nil
}
Exemplo n.º 21
0
func (c *Client) start() error {
	c.startOnce.Do(func() {
		// Setup sling
		url := fmt.Sprintf("https://api.keen.io/3.0/projects/%s/", c.ProjectId)
		c.sling = sling.New().Client(c.HttpClient).Base(url).Set("Authorization", c.APIKey)

		pendingWorkCapacity := c.PendingWorkCapacity
		if pendingWorkCapacity == 0 {
			pendingWorkCapacity = defaultPendingWorkCapacity
		}
		maxBatchSize := c.MaxBatchSize
		if maxBatchSize == 0 {
			maxBatchSize = defaultMaxBatchSize
		}
		batchTimeout := c.BatchTimeout
		if int64(batchTimeout) == 0 {
			batchTimeout = defaultBatchTimeout
		}

		c.muster.BatchMaker = func() muster.Batch { return &musterBatch{Client: c} }
		c.muster.BatchTimeout = batchTimeout
		c.muster.MaxBatchSize = maxBatchSize
		c.muster.PendingWorkCapacity = pendingWorkCapacity
		c.startErr = c.muster.Start()
	})
	return c.startErr
}
Exemplo n.º 22
0
func (h *Hoverfly) ImportSimulation(simulationData string, v1 bool) error {
	slingRequest := sling.New().Body(strings.NewReader(simulationData))

	if v1 {
		slingRequest = slingRequest.Post(h.buildURL(v1ApiSimulation))
	} else {
		slingRequest = slingRequest.Put(h.buildURL(v2ApiSimulation))
	}
	slingRequest, err := h.addAuthIfNeeded(slingRequest)
	if err != nil {
		log.Debug(err.Error())
		return errors.New("Could not authenticate  with Hoverfly")
	}

	response, err := h.doRequest(slingRequest)
	if err != nil {
		return err
	}

	if response.StatusCode != 200 {
		body, _ := ioutil.ReadAll(response.Body)
		var errorView ErrorSchema
		json.Unmarshal(body, &errorView)
		return errors.New("Import to Hoverfly failed: " + errorView.ErrorMessage)
	}

	return nil
}
Exemplo n.º 23
0
//Search projects by projectName and isPublic
func (a testapi) ProjectsGet(projectName string, isPublic int32, authInfo ...usrInfo) (int, []apilib.Project, error) {
	_sling := sling.New().Get(a.basePath)

	//create api path
	path := "api/projects"
	_sling = _sling.Path(path)
	type QueryParams struct {
		ProjectName string `url:"project_name,omitempty"`
		IsPubilc    int32  `url:"is_public,omitempty"`
	}
	_sling = _sling.QueryStruct(&QueryParams{ProjectName: projectName, IsPubilc: isPublic})

	var successPayload []apilib.Project

	var httpStatusCode int
	var err error
	var body []byte
	if len(authInfo) > 0 {
		httpStatusCode, body, err = request(_sling, jsonAcceptHeader, authInfo[0])
	} else {
		httpStatusCode, body, err = request(_sling, jsonAcceptHeader)
	}

	if err == nil && httpStatusCode == 200 {
		err = json.Unmarshal(body, &successPayload)
	}

	return httpStatusCode, successPayload, err
}
Exemplo n.º 24
0
//Delete a repository or a tag in a repository.
//Delete a repository or a tag in a repository.
//This endpoint let user delete repositories and tags with repo name and tag.\n
//@param repoName The name of repository which will be deleted.
//@param tag Tag of a repository.
//@return void
//func (a HarborAPI) RepositoriesDelete(prjUsr UsrInfo, repoName string, tag string) (int, error) {
func (a HarborAPI) RepositoriesDelete(prjUsr UsrInfo, repoName string, tag string) (int, error) {
	_sling := sling.New().Delete(a.basePath)

	// create path and map variables
	path := "/api/repositories"

	_sling = _sling.Path(path)

	type QueryParams struct {
		RepoName string `url:"repo_name,omitempty"`
		Tag      string `url:"tag,omitempty"`
	}

	_sling = _sling.QueryStruct(&QueryParams{RepoName: repoName, Tag: tag})
	// accept header
	accepts := []string{"application/json", "text/plain"}
	for key := range accepts {
		_sling = _sling.Set("Accept", accepts[key])
		break // only use the first Accept
	}

	req, err := _sling.Request()
	req.SetBasicAuth(prjUsr.Name, prjUsr.Passwd)
	//fmt.Printf("request %+v", req)

	client := &http.Client{}
	httpResponse, err := client.Do(req)
	defer httpResponse.Body.Close()

	if err != nil {
		// handle error
	}
	return httpResponse.StatusCode, err
}
Exemplo n.º 25
0
func GroupGet(groupId int) (group Community, err error) {
	params := &GroupGetParams{GroupIds: strconv.Itoa(groupId), Version: apiVersion, Fields: "photo_100,description"}
	response := new(GroupGetResponse)
	_, err = sling.New().Get(path + "groups.getById").QueryStruct(params).ReceiveSuccess(response)
	group = response.Groups[0]
	return
}
Exemplo n.º 26
0
func wallGet(params *WallGetParams) (posts []Post, users []User, groups []Community, err error) {
	response := new(WallGetExtendedResponse)
	_, err = sling.New().Get(path + "wall.get").QueryStruct(params).ReceiveSuccess(response)
	posts = response.Response.Posts
	users = response.Response.Profiles
	groups = response.Response.Groups
	return
}
Exemplo n.º 27
0
//Mark a registered user as be removed.
func (a testapi) UsersDelete(userID int, authInfo usrInfo) (int, error) {
	_sling := sling.New().Delete(a.basePath)
	// create path and map variables
	path := "/api/users/" + fmt.Sprintf("%d", userID)
	_sling = _sling.Path(path)
	httpStatusCode, _, err := request(_sling, jsonAcceptHeader, authInfo)
	return httpStatusCode, err
}
Exemplo n.º 28
0
func ResolveScreenName(name string) (objectType string, id int, err error) {
	params := &ResolveScreenNameParams{Version: apiVersion, ScreenName: name}
	response := new(ResolveScreenNameResponse)
	_, err = sling.New().Get(path + "utils.resolveScreenName").QueryStruct(params).ReceiveSuccess(response)
	objectType = response.Response.Type
	id = response.Response.ObjectId
	return
}
Exemplo n.º 29
0
//Delete project role member accompany with  projectID
func (a testapi) DeleteProjectMember(authInfo usrInfo, projectID string, userID string) (int, error) {
	_sling := sling.New().Delete(a.basePath)

	path := "/api/projects/" + projectID + "/members/" + userID
	_sling = _sling.Path(path)
	httpStatusCode, _, err := request(_sling, jsonAcceptHeader, authInfo)
	return httpStatusCode, err

}
Exemplo n.º 30
0
//Delete project by projectID
func (a testapi) ProjectsDelete(prjUsr usrInfo, projectID string) (int, error) {
	_sling := sling.New().Delete(a.basePath)

	//create api path
	path := "api/projects/" + projectID
	_sling = _sling.Path(path)
	httpStatusCode, _, err := request(_sling, jsonAcceptHeader, prjUsr)
	return httpStatusCode, err
}