Golang customer.Customer類代碼示例

func GetCustomer(rw http.ResponseWriter, r *http.Request, enc encoding.Encoder, params martini.Params, dtx *apicontext.DataContext) string {
	var err error
	var c customer.Customer

	if err = c.GetCustomerIdFromKey(dtx.APIKey); err != nil {
		apierror.GenerateError("Trouble getting customer ID", err, rw, r)
		return ""
	}

	if err = c.GetCustomer(dtx.APIKey); err != nil {
		apierror.GenerateError("Trouble getting customer", err, rw, r, http.StatusServiceUnavailable)
		return ""
	}

	lowerKey := strings.ToLower(dtx.APIKey)
	for i, u := range c.Users {
		for _, k := range u.Keys {
			if strings.ToLower(k.Key) == lowerKey {
				c.Users[i].Current = true
			}
		}
	}

	return encoding.Must(enc.Encode(c))
}

func approveuser(r *http.Request) bool {
	api := r.URL.Query().Get("key")
	if api == "" {
		return false
	}
	c := customer.Customer{}
	err := c.GetCustomerIdFromKey(api)
	if err != nil || c.Id == 0 {
		return false
	}
	return true
}

func GetByPrivateKey(rw http.ResponseWriter, r *http.Request, enc encoding.Encoder, params martini.Params, dtx *apicontext.DataContext) string {
	var err error
	var webProperties webProperty_model.WebProperties

	privateKey := r.FormValue("key")
	cust := customer.Customer{}

	if err = cust.GetCustomerIdFromKey(privateKey); err != nil {
		apierror.GenerateError("Trouble getting customer", err, rw, r)
		return ""
	}

	if webProperties, err = webProperty_model.GetByCustomer(cust.Id, dtx); err != nil {
		apierror.GenerateError("Trouble getting web property", err, rw, r)
		return ""
	}

	return encoding.Must(enc.Encode(webProperties))
}

func DeleteCustomer(rw http.ResponseWriter, r *http.Request, enc encoding.Encoder, params martini.Params) string {
	var c customer.Customer
	var err error

	id := r.FormValue("id")
	if id == "" {
		id = params["id"]
	}

	if c.Id, err = strconv.Atoi(id); err != nil {
		apierror.GenerateError("Trouble getting customer ID", err, rw, r)
		return ""
	}

	if err = c.Delete(); err != nil {
		apierror.GenerateError("Trouble deleting customer", err, rw, r)
		return ""
	}

	return encoding.Must(enc.Encode(c))
}

func GetPriceByCustomer(rw http.ResponseWriter, r *http.Request, enc encoding.Encoder, params martini.Params) string {
	var err error
	var ps customer.CustomerPrices
	var c customer.Customer

	id := r.FormValue("id")
	if id == "" {
		id = params["id"]
	}

	if c.Id, err = strconv.Atoi(id); err != nil {
		apierror.GenerateError("Trouble getting customer ID", err, rw, r)
		return ""
	}

	if ps, err = c.GetPricesByCustomer(); err != nil {
		apierror.GenerateError("Trouble getting prices by customer ID", err, rw, r)
		return ""
	}

	return encoding.Must(enc.Encode(ps))
}

func GetSales(rw http.ResponseWriter, r *http.Request, enc encoding.Encoder, params martini.Params) string {
	var err error
	var ps customer.Prices
	var c customer.Customer

	id := r.FormValue("id")
	if id == "" {
		id = params["id"]
	}

	if c.Id, err = strconv.Atoi(id); err != nil {
		apierror.GenerateError("Trouble getting customer ID", err, rw, r)
		return ""
	}

	start := r.FormValue("start")
	end := r.FormValue("end")

	startDate, err := time.Parse(inputTimeFormat, start)
	if err != nil {
		apierror.GenerateError("Trouble getting sales start date", err, rw, r)
		return ""
	}

	endDate, err := time.Parse(inputTimeFormat, end)
	if err != nil {
		apierror.GenerateError("Trouble getting sales end date", err, rw, r)
		return ""
	}

	ps, err = c.GetPricesBySaleRange(startDate, endDate)
	if err != nil {
		apierror.GenerateError("Trouble getting prices by sales range", err, rw, r)
		return ""
	}

	return encoding.Must(enc.Encode(ps))
}

func SaveCustomer(rw http.ResponseWriter, r *http.Request, enc encoding.Encoder, params martini.Params, dtx *apicontext.DataContext) string {
	var c customer.Customer
	var err error

	if r.FormValue("id") != "" || params["id"] != "" {
		id := r.FormValue("id")
		if id == "" {
			id = params["id"]
		}

		if c.Id, err = strconv.Atoi(id); err != nil {
			apierror.GenerateError("Trouble getting customer ID", err, rw, r)
			return ""
		}

		if err = c.Basics(dtx.APIKey); err != nil {
			apierror.GenerateError("Trouble getting customer", err, rw, r)
			return ""
		}
	}

	//json
	var requestBody []byte
	if requestBody, err = ioutil.ReadAll(r.Body); err != nil {
		apierror.GenerateError("Trouble reading request body while saving customer", err, rw, r)
		return ""
	}

	if err = json.Unmarshal(requestBody, &c); err != nil {
		apierror.GenerateError("Trouble unmarshalling json request body while saving customer", err, rw, r)
		return ""
	}

	//create or update
	if c.Id > 0 {
		err = c.Update()
	} else {
		err = c.Create()
	}

	if err != nil {
		msg := "Trouble creating customer"
		if c.Id > 0 {
			msg = "Trouble updating customer"
		}
		apierror.GenerateError(msg, err, rw, r)
		return ""
	}

	return encoding.Must(enc.Encode(c))
}

func TestCustomerPrice(t *testing.T) {
	var err error
	var p customer.Price
	var ps customer.Prices
	var c customer.Customer
	c.Name = "Dog Bountyhunter"
	c.Create()

	Convey("Testing customer/Price", t, func() {
		//test create customer price
		form := url.Values{"custID": {strconv.Itoa(c.Id)}, "partID": {"11000"}, "price": {"123456"}}
		v := form.Encode()
		body := strings.NewReader(v)
		thyme := time.Now()
		testThatHttp.Request("post", "/customer/prices", "", "", CreateUpdatePrice, body, "application/x-www-form-urlencoded")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &p)
		So(err, ShouldBeNil)
		So(p, ShouldHaveSameTypeAs, customer.Price{})
		So(p.ID, ShouldBeGreaterThan, 0)

		//test update customer price
		form = url.Values{"isSale": {"true"}, "saleStart": {"01/01/2001"}, "saleEnd": {"01/01/2015"}}
		v = form.Encode()
		body = strings.NewReader(v)
		thyme = time.Now()
		testThatHttp.Request("post", "/customer/prices/", ":id", strconv.Itoa(p.ID), CreateUpdatePrice, body, "application/x-www-form-urlencoded")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &p)
		So(err, ShouldBeNil)
		So(p, ShouldHaveSameTypeAs, customer.Price{})
		So(p.IsSale, ShouldEqual, 1)
		start, _ := time.Parse(inputTimeFormat, "01/01/2001")
		So(p.SaleStart, ShouldResemble, start)

		//test get customer price
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/prices/", ":id", strconv.Itoa(p.ID), GetPrice, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &p)
		So(err, ShouldBeNil)
		So(p, ShouldHaveSameTypeAs, customer.Price{})

		//test get all customer price
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/prices", "", "", GetAllPrices, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()*8) //Long
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &ps)
		So(err, ShouldBeNil)
		So(ps, ShouldHaveSameTypeAs, customer.Prices{})

		//test get customer price by part
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/prices/part/", ":id", strconv.Itoa(p.ID), GetPricesByPart, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &ps)
		So(err, ShouldBeNil)
		So(ps, ShouldHaveSameTypeAs, customer.Prices{})

		//test get customer price by customer
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/pricesByCustomer/", ":id", strconv.Itoa(c.Id), GetPriceByCustomer, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &p)
		So(err, ShouldBeNil)
		So(p, ShouldHaveSameTypeAs, customer.Price{})

		//test get sales
		form = url.Values{"id": {strconv.Itoa(c.Id)}, "start": {"01/01/2000"}, "end": {"01/01/2016"}}
		v = form.Encode()
		body = strings.NewReader(v)
		thyme = time.Now()
		testThatHttp.Request("post", "/customer/prices/sale", "", "", GetSales, body, "application/x-www-form-urlencoded")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &ps)
		So(err, ShouldBeNil)
		So(ps, ShouldHaveSameTypeAs, customer.Prices{})

		//test delete customer price
		thyme = time.Now()
		testThatHttp.Request("delete", "/customer/prices/", ":id", strconv.Itoa(p.ID), DeletePrice, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &p)
		So(err, ShouldBeNil)
		So(p, ShouldHaveSameTypeAs, customer.Price{})
	})
	//teardown
	c.Delete()
}

func BenchmarkCRUDCustomerPrice(b *testing.B) {
	var p customer.Price
	var c customer.Customer
	c.Name = "Axl Rose"
	c.Create()
	qs := make(url.Values, 0)

	Convey("CustomerPrice", b, func() {
		form := url.Values{"custID": {strconv.Itoa(c.Id)}, "partID": {"11000"}, "price": {"123456"}}
		//create
		(&httprunner.BenchmarkOptions{
			Method:             "POST",
			Route:              "/customer/prices",
			ParameterizedRoute: "/customer/prices",
			Handler:            CreateUpdatePrice,
			QueryString:        &qs,
			JsonBody:           p,
			FormBody:           form,
			Runs:               b.N,
		}).RequestBenchmark()

		//get
		(&httprunner.BenchmarkOptions{
			Method:             "GET",
			Route:              "/customer/prices",
			ParameterizedRoute: "/customer/prices/" + strconv.Itoa(p.ID),
			Handler:            GetPrice,
			QueryString:        &qs,
			JsonBody:           p,
			FormBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

		//get all
		(&httprunner.BenchmarkOptions{
			Method:             "GET",
			Route:              "/customer/prices",
			ParameterizedRoute: "/customer/prices",
			Handler:            GetAllPrices,
			QueryString:        &qs,
			JsonBody:           p,
			FormBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

		//get by part
		(&httprunner.BenchmarkOptions{
			Method:             "GET",
			Route:              "/customer/prices/part",
			ParameterizedRoute: "/customer/prices/part/" + strconv.Itoa(p.ID),
			Handler:            GetPricesByPart,
			QueryString:        &qs,
			JsonBody:           p,
			FormBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

		//get by
		(&httprunner.BenchmarkOptions{
			Method:             "GET",
			Route:              "/customer/pricesByCustomer",
			ParameterizedRoute: "/customer/pricesByCustomer/" + strconv.Itoa(c.Id),
			Handler:            GetPriceByCustomer,
			QueryString:        &qs,
			JsonBody:           p,
			FormBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

		//delete
		(&httprunner.BenchmarkOptions{
			Method:             "DELETE",
			Route:              "/customer/prices",
			ParameterizedRoute: "/customer/prices/" + strconv.Itoa(p.ID),
			Handler:            DeleteLocation,
			QueryString:        &qs,
			JsonBody:           p,
			FormBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()
	})
	//teardown
	c.Delete()
}

func TestCustomer(t *testing.T) {
	var err error
	var c customer.Customer
	var cu customer.CustomerUser
	once.Do(initDtx)
	defer apicontextmock.DeMock(dtx)

	cu.Id = dtx.UserID
	err = cu.Get(dtx.APIKey)
	if err != nil {
		t.Log(err)
	}
	c.Users = append(c.Users, cu)

	Convey("Testing customer/Customer", t, func() {
		//test create customer
		c.Name = "Jason Voorhees"
		c.Email = "[email protected]"
		bodyBytes, _ := json.Marshal(c)
		bodyJson := bytes.NewReader(bodyBytes)
		thyme := time.Now()
		testThatHttp.Request("put", "/customer", "", "?key=", SaveCustomer, bodyJson, "application/json")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &c)
		So(err, ShouldBeNil)
		So(c, ShouldHaveSameTypeAs, customer.Customer{})
		So(c.Id, ShouldBeGreaterThan, 0)

		//test update customer
		c.Fax = "666-1313"
		c.State.Id = 1
		bodyBytes, _ = json.Marshal(c)
		bodyJson = bytes.NewReader(bodyBytes)
		thyme = time.Now()
		testThatHttp.Request("put", "/customer/", ":id", strconv.Itoa(c.Id)+"?key=", SaveCustomer, bodyJson, "application/json")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &c)
		So(err, ShouldBeNil)
		So(c, ShouldHaveSameTypeAs, customer.Customer{})
		So(c.Id, ShouldBeGreaterThan, 0)

		thyme = time.Now()
		testThatHttp.RequestWithDtx("post", "/customer", "", "?key=", GetCustomer, nil, "", dtx)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &c)
		So(err, ShouldBeNil)
		So(c, ShouldHaveSameTypeAs, customer.Customer{})
		So(c.Id, ShouldBeGreaterThan, 0)

		// get customer locations
		thyme = time.Now()
		testThatHttp.RequestWithDtx("get", "/customer/locations", "", "?key=", GetLocations, nil, "", dtx)
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()*6)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &c.Locations)
		So(err, ShouldBeNil)
		So(c.Locations, ShouldHaveSameTypeAs, []customer.CustomerLocation{})

		// //get user
		thyme = time.Now()
		testThatHttp.RequestWithDtx("post", "/customer/user", "", "?key="+dtx.APIKey, GetUser, nil, "", nil)
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &cu)
		So(err, ShouldBeNil)
		So(cu, ShouldHaveSameTypeAs, customer.CustomerUser{})

		//get users
		thyme = time.Now()
		testThatHttp.RequestWithDtx("get", "/customer/users", "", "?key=", GetUsers, nil, "", dtx)
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()*5)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		var cus []customer.CustomerUser
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &cus)
		So(err, ShouldBeNil)
		So(cus, ShouldHaveSameTypeAs, []customer.CustomerUser{})

		// get customer price
		// price.CustID = c.Id
		// price.Create()
		// thyme = time.Now()
		// testThatHttp.Request("get", "/new/customer/price/", ":id", strconv.Itoa(p.ID)+"?key="+apiKey, GetCustomerPrice, nil, "")
		// So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		// So(testThatHttp.Response.Code, ShouldEqual, 200)
		// var price float64
		// err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &price)
		// So(err, ShouldBeNil)
		// So(price, ShouldHaveSameTypeAs, 7.1)

		// //get customer cart reference
		// ci.CustID = c.Id
		// ci.Create()
		// thyme = time.Now()
		// testThatHttp.Request("get", "/new/customer/cartRef/", ":id", strconv.Itoa(p.ID)+"?key="+apiKey, GetCustomerCartReference, nil, "")
		// So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		// So(testThatHttp.Response.Code, ShouldEqual, 200)
		// var reference int
		// err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &reference)
//.........這裏部分代碼省略.........

func TestCustomerContent(t *testing.T) {
	flag.Parse()
	//customer - for db setup only
	var c customer.Customer
	var content custcontent.CustomerContent
	var partContent custcontent.PartContent
	var categoryContent custcontent.CustomerContent
	var ct custcontent.ContentType
	var crs custcontent.CustomerContentRevisions
	var contents []custcontent.CustomerContent
	var catContent custcontent.CategoryContent
	var catContents []custcontent.CategoryContent
	var err error
	var apiKey string

	catContent.CategoryId = 1

	ct.Type = "test"
	ct.Create()

	c.Name = "test cust"
	c.Create()

	Convey("Testing customer/Customer_content", t, func() {
		//test create part content
		content.Text = "new content"
		content.ContentType.Id = ct.Id
		bodyBytes, _ := json.Marshal(content)
		bodyJson := bytes.NewReader(bodyBytes)
		thyme := time.Now()
		testThatHttp.Request("post", "/customer/cms/part/", ":id", strconv.Itoa(11000)+"?key="+dtx.APIKey, CreatePartContent, bodyJson, "application/json")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		if testThatHttp.Response.Code == 200 { //returns 500 when ninnemana user doesn't exist
			So(testThatHttp.Response.Code, ShouldEqual, 200)
			err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &content)
			So(err, ShouldBeNil)
			So(content, ShouldHaveSameTypeAs, custcontent.CustomerContent{})
		}

		//create category content
		categoryContent.Text = "new content"
		categoryContent.ContentType.Id = ct.Id
		bodyBytes, _ = json.Marshal(categoryContent)
		bodyJson = bytes.NewReader(bodyBytes)
		thyme = time.Now()
		testThatHttp.Request("post", "/customer/cms/category/", ":id", strconv.Itoa(catContent.CategoryId)+"?key="+apiKey, CreateCategoryContent, bodyJson, "application/json")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &categoryContent)
		So(err, ShouldBeNil)
		So(categoryContent, ShouldHaveSameTypeAs, custcontent.CustomerContent{})

		//test update part content
		content.Text = "newerer content"
		bodyBytes, _ = json.Marshal(content)
		bodyJson = bytes.NewReader(bodyBytes)
		thyme = time.Now()
		testThatHttp.Request("put", "/customer/cms/part/", ":id", strconv.Itoa(11000)+"?key="+apiKey, UpdatePartContent, bodyJson, "application/json")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &content)
		So(err, ShouldBeNil)
		So(content, ShouldHaveSameTypeAs, custcontent.CustomerContent{})

		//test update category content
		categoryContent.Text = "newerer content"
		bodyBytes, _ = json.Marshal(categoryContent)
		bodyJson = bytes.NewReader(bodyBytes)
		thyme = time.Now()
		testThatHttp.Request("put", "/customer/cms/part/", ":id", strconv.Itoa(catContent.CategoryId)+"?key="+apiKey, UpdateCategoryContent, bodyJson, "application/json")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &categoryContent)
		So(err, ShouldBeNil)
		So(categoryContent, ShouldHaveSameTypeAs, custcontent.CustomerContent{})

		//test get part content (unique)
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/cms/part/", ":id", strconv.Itoa(11000)+"?key="+apiKey, UniquePartContent, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &contents)
		So(err, ShouldBeNil)
		So(contents, ShouldHaveSameTypeAs, []custcontent.CustomerContent{})

		//test get all part content
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/cms/part", "", "?key="+apiKey, AllPartContent, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &contents)
		So(err, ShouldBeNil)
		So(contents, ShouldHaveSameTypeAs, []custcontent.CustomerContent{})

		//test get category content (all content)
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/cms/part", "", "?key="+apiKey, AllCategoryContent, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &contents)
//.........這裏部分代碼省略.........

func BenchmarkCRUDCustomer(b *testing.B) {

	qs := make(url.Values, 0)
	qs.Add("key", dtx.APIKey)

	Convey("Customer", b, func() {
		var c customer.Customer
		c.Name = "Freddy Krueger"
		c.Email = "[email protected]"
		// var locs customer.CustomerLocations

		//create
		(&httprunner.BenchmarkOptions{
			Method:             "POST",
			Route:              "/customer",
			ParameterizedRoute: "/customer",
			Handler:            SaveCustomer,
			QueryString:        &qs,
			JsonBody:           c,
			Runs:               b.N,
		}).RequestBenchmark()

		//get
		(&httprunner.BenchmarkOptions{
			Method:             "GET",
			Route:              "/customer",
			ParameterizedRoute: "/customer/" + strconv.Itoa(c.Id),
			Handler:            GetCustomer,
			QueryString:        &qs,
			JsonBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

		//get locations
		(&httprunner.BenchmarkOptions{
			Method:             "GET",
			Route:              "/customer",
			ParameterizedRoute: "/customer",
			Handler:            GetLocations,
			QueryString:        &qs,
			JsonBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

		//get user
		(&httprunner.BenchmarkOptions{
			Method:             "GET",
			Route:              "/customer/user",
			ParameterizedRoute: "/customer/user",
			Handler:            GetUser,
			QueryString:        &qs,
			JsonBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

		//get users
		(&httprunner.BenchmarkOptions{
			Method:             "GET",
			Route:              "/customer/users",
			ParameterizedRoute: "/customer/users",
			Handler:            GetUsers,
			QueryString:        &qs,
			JsonBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

		//delete
		(&httprunner.BenchmarkOptions{
			Method:             "DELETE",
			Route:              "/customer",
			ParameterizedRoute: "/customer/" + strconv.Itoa(c.Id),
			Handler:            DeleteCustomer,
			QueryString:        &qs,
			JsonBody:           nil,
			Runs:               b.N,
		}).RequestBenchmark()

	})

}

func CreateUpdateWebProperty(rw http.ResponseWriter, r *http.Request, enc encoding.Encoder, params martini.Params, dtx *apicontext.DataContext) string {
	var w webProperty_model.WebProperty
	var err error

	cust := customer.Customer{}

	if err = cust.GetCustomerIdFromKey(dtx.APIKey); err != nil {
		apierror.GenerateError("Trouble getting customer ID from API Key", err, rw, r)
		return ""
	}

	w.CustID = cust.Id

	//determine content type
	contType := r.Header.Get("Content-Type")
	if contType == "application/json" {
		//json
		requestBody, err := ioutil.ReadAll(r.Body)
		if err != nil {
			apierror.GenerateError("Trouble reading request body while saving web property", err, rw, r)
			return ""
		}

		if err = json.Unmarshal(requestBody, &w); err != nil {
			apierror.GenerateError("Trouble unmarshalling request body while saving web property", err, rw, r)
			return ""
		}
	} else {
		if r.FormValue("id") != "" || params["id"] != "" {
			idStr := r.FormValue("id")
			if idStr == "" {
				idStr = params["id"]
			}

			if w.ID, err = strconv.Atoi(idStr); err != nil {
				apierror.GenerateError("Trouble getting web property ID", err, rw, r)
				return ""
			}

			if err = w.Get(dtx); err != nil {
				apierror.GenerateError("Trouble getting web property", err, rw, r)
				return ""
			}
		}

		name := r.FormValue("name")
		url := r.FormValue("url")
		isEnabled := r.FormValue("isEnabled")
		sellerID := r.FormValue("sellerID")
		webPropertyTypeID := r.FormValue("webPropertyTypeID")
		isFinalApproved := r.FormValue("isApproved")
		enabledDate := r.FormValue("enabledDate")
		isDenied := r.FormValue("isDenied")
		requestedDate := r.FormValue("requestedDate")
		typeID := r.FormValue("typeID")

		if name != "" {
			w.Name = name
		}
		if url != "" {
			w.Url = url
		}
		if isEnabled != "" {
			if w.IsEnabled, err = strconv.ParseBool(isEnabled); err != nil {
				apierror.GenerateError("Trouble parsing boolean value for webproperty.isEnabled", err, rw, r)
				return ""
			}
		}
		if sellerID != "" {
			w.SellerID = sellerID
		}
		if webPropertyTypeID != "" {
			if w.WebPropertyType.ID, err = strconv.Atoi(webPropertyTypeID); err != nil {
				apierror.GenerateError("Trouble getting web property type ID", err, rw, r)
				return ""
			}
		}
		if isFinalApproved != "" {
			if w.IsFinalApproved, err = strconv.ParseBool(isFinalApproved); err != nil {
				apierror.GenerateError("Trouble parsing boolean value for webproperty.isApproved", err, rw, r)
				return ""
			}
		}
		if enabledDate != "" {
			en, err := time.Parse(timeFormat, enabledDate)
			if err != nil {
				apierror.GenerateError("Trouble parsing date for webproperty.enabledDate", err, rw, r)
				return ""
			}
			w.IsEnabledDate = &en
		}
		if isDenied != "" {
			if w.IsDenied, err = strconv.ParseBool(isDenied); err != nil {
				apierror.GenerateError("Trouble parsing boolean value for webproperty.isDenied", err, rw, r)
				return ""
			}
		}
		if requestedDate != "" {
			req, err := time.Parse(timeFormat, requestedDate)
			if err != nil {
//.........這裏部分代碼省略.........

func TestCustomerUser(t *testing.T) {

	var err error
	var cu customer.CustomerUser
	var c customer.Customer
	c.Name = "Dog Bountyhunter"
	c.BrandIDs = append(c.BrandIDs, 1)
	c.Create()

	var pub, pri, auth apiKeyType.ApiKeyType
	if database.GetCleanDBFlag() != "" {
		t.Log(database.GetCleanDBFlag())
		//setup apiKeyTypes
		pub.Type = "Public"
		pri.Type = "Private"
		auth.Type = "Authentication"
		pub.Create()
		pri.Create()
		auth.Create()
	}
	Convey("Testing customer/User", t, func() {
		//test create customer user
		form := url.Values{"name": {"Mitt Romney"}, "email": {"[email protected]"}, "pass": {"robthepoor"}, "customerID": {strconv.Itoa(c.Id)}, "isActive": {"true"}, "locationID": {"1"}, "isSudo": {"true"}, "cust_ID": {strconv.Itoa(c.Id)}}
		v := form.Encode()
		body := strings.NewReader(v)
		thyme := time.Now()
		testThatHttp.Request("post", "/customer/user/register", "", "", RegisterUser, body, "application/x-www-form-urlencoded")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &cu)
		So(err, ShouldBeNil)
		So(cu, ShouldHaveSameTypeAs, customer.CustomerUser{})
		So(cu.Id, ShouldNotBeEmpty)
		//key stuff - get apiKey
		var apiKey string
		for _, k := range cu.Keys {
			if strings.ToLower(k.Type) == "public" {
				apiKey = k.Key
			}
		}

		//test update customer user
		form = url.Values{"name": {"Michelle Bachman"}}
		v = form.Encode()
		body = strings.NewReader(v)
		thyme = time.Now()
		testThatHttp.Request("post", "/customer/user/", ":id", cu.Id, UpdateCustomerUser, body, "application/x-www-form-urlencoded")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &cu)
		So(err, ShouldBeNil)
		So(cu, ShouldHaveSameTypeAs, customer.CustomerUser{})
		So(cu.Name, ShouldNotEqual, "Mitt Romney")

		//test authenticateUser
		err = c.JoinUser(cu)
		So(err, ShouldBeNil)
		form = url.Values{"email": {"[email protected]"}, "password": {"robthepoor"}}
		v = form.Encode()
		body = strings.NewReader(v)
		thyme = time.Now()
		testThatHttp.Request("post", "/customer/auth", "", "", AuthenticateUser, body, "application/x-www-form-urlencoded")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &c)
		So(err, ShouldBeNil)
		So(c, ShouldHaveSameTypeAs, customer.Customer{})

		//test keyed user authentication
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/auth", "", "?key="+apiKey, KeyedUserAuthentication, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &c)
		So(err, ShouldBeNil)
		So(c, ShouldHaveSameTypeAs, customer.Customer{})

		//test get user by id
		thyme = time.Now()
		testThatHttp.Request("get", "/customer/", ":id", cu.Id+"?key="+apiKey, GetUserById, nil, "")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()/2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &cu)
		So(err, ShouldBeNil)
		So(cu, ShouldHaveSameTypeAs, customer.CustomerUser{})

		//test change user password
		form = url.Values{"email": {"[email protected]"}, "oldPass": {"robthepoor"}, "newPass": {"prolife"}}
		v = form.Encode()
		body = strings.NewReader(v)
		thyme = time.Now()
		testThatHttp.Request("post", "/customer/user/changePassword", "", "?key="+apiKey, ChangePassword, body, "application/x-www-form-urlencoded")
		So(time.Since(thyme).Nanoseconds(), ShouldBeLessThan, time.Second.Nanoseconds()*2)
		So(testThatHttp.Response.Code, ShouldEqual, 200)
		var result string
		err = json.Unmarshal(testThatHttp.Response.Body.Bytes(), &result)
		So(err, ShouldBeNil)
		So(result, ShouldHaveSameTypeAs, "Success")

		//test reset  user password
//.........這裏部分代碼省略.........