// Transform sales DB struct to an outgoing json
// struct
func transformDbSalesToSalesResponse(ordersDb []*dataservice.OrderDocElkType) []*SaleResponseType {

	var sales []*SaleResponseType

	for i := 0; i < len(ordersDb); i++ {

		// Get the cached config details
		session := dataservice.GetSession(ordersDb[i].Doc.Products[0].SessionId, configuration.GetConfig())

		sale := new(SaleResponseType)
		sale.Id = ordersDb[i].Doc.Code
		sale.EventId = session.Event_id
		sale.EventName = session.Event_name
		sale.TransactionDate = ordersDb[i].Doc.Date.Purchased
		sale.TransactionType = TRANSACTION_SALE_TYPE
		sale.BuyerTypeCode = ordersDb[i].Doc.OrderData.ChannelType
		sale.ProductsNumber = len(ordersDb[i].Doc.Products)
		sale.ChannelId = ordersDb[i].Doc.OrderData.ChannelId
		products := transformProductsDbToProductsResponse(ordersDb[i].Doc.Products, session)
		sale.Products = products

		sales = append(sales, sale)
	}

	return sales
}
// Public method to check the Oauth2 authorization with
// a Bearer token header to the oauth server
func Authorize(authheader string) (*dataservice.Oauthtoken, bool) {

	var oauthtoken *dataservice.Oauthtoken
	isAuthorized := false
	s := strings.Split(authheader, " ")
	token := s[len(s)-1]

	if token != "" {

		oauthtoken = dataservice.GetOauthtoken(token)
		for _, username := range configuration.GetConfig().Authorized_usernames_list {

			if username == oauthtoken.UserName {
				isAuthorized = true
				break
			}
		}
	}

	return oauthtoken, isAuthorized
}
/**
 * Prices resource endpoint
 */
func SalesController(w http.ResponseWriter, request *http.Request) {

	uuid := GetUuid()
	start := time.Now()

	// Check authorization
	oauthtoken, isAuthorized := authorization.Authorize(request.Header.Get(AUTH_HEADER))
	if !isAuthorized {
		w.WriteHeader(http.StatusUnauthorized)
		log.Warningf("/sales request error status 401 unauthorized %v", getIP(w, request))
		return
	}
	log.Infof("{%v} /sales request %v received from: %v %v", uuid, request.URL, oauthtoken.UserName, getIP(w, request))

	// GET request params
	saleId := request.URL.Query().Get(SALE_ID) // Empty error if error
	if saleId == "" {

		vars := mux.Vars(request) // Empty error if error
		saleId = vars[ID]

	}
	startDate = request.URL.Query().Get(START_DATE)
	if startDate == "" {
		startDate = time.Now().AddDate(0, -1, 0).Format(DATE_FORMAT_SHORT)
	}
	endDate = request.URL.Query().Get(END_DATE)
	if endDate == "" {
		endDate = time.Now().Format(DATE_FORMAT_SHORT)
	}
	page, err := strconv.Atoi(request.URL.Query().Get(PAGE))
	if err != nil {
		page = 0
	}
	pageSize, err := strconv.Atoi(request.URL.Query().Get(PAGE_SIZE))
	if err != nil {
		pageSize = configuration.GetConfig().Elasticsearch_limit_items
	}
	if pageSize > 250 { // Security upper page size limit
		pageSize = 250
	}
	eventId, err = strconv.Atoi(request.URL.Query().Get(EVENT_ID)) // Return 0 if error

	// Retrieve requested resource information
	dbSales := dataservice.GetSales(startDate, endDate, eventId, saleId, page, uuid, oauthtoken, pageSize)

	// Set json response struct
	var params ParametersResponseType
	params.StartDate = startDate
	params.EndDate = endDate
	params.Page = page
	params.EventId = eventId
	params.SaleId = saleId
	params.TraceId = uuid
	var salesresponse SalesResponseType
	salesresponse.Parameters = params
	salesresponse.RequestDate = time.Now()
	salesresponse.Version = "1.0"
	sales := transformDbSalesToSalesResponse(dbSales)
	salesresponse.Sales = sales
	salesjson, err := json.Marshal(salesresponse)

	// Set response headers
	w.Header().Set("Content-Type", "application/json")

	// Set response body
	w.Write(salesjson)

	elapsed := time.Since(start)
	log.Infof("{%v} /sales response status 200 in %v", uuid, elapsed)

}
/**
 * Prices resource endpoint
 */
func PricesController(w http.ResponseWriter, request *http.Request) {

	uuid := GetUuid()
	start := time.Now()

	// Check authorization
	oauthtoken, isAuthorized := authorization.Authorize(request.Header.Get(AUTH_HEADER))
	if !isAuthorized {
		w.WriteHeader(http.StatusUnauthorized)
		log.Warningf("/prices request error status 401 unauthorized %v", getIP(w, request))
		return
	}
	log.Infof("{%v} /prices request %v received from: %v %v", uuid, request.URL, oauthtoken.UserName, getIP(w, request))

	// GET request params
	priceId, err := strconv.Atoi(request.URL.Query().Get(PRICE_ID)) // Return 0 if error
	if err != nil {

		vars := mux.Vars(request)
		id := vars[ID]
		if id != "" {
			priceId, err = strconv.Atoi(id) // Return 0 if error
			if err != nil {
				priceId = 0
			}
		}
	}
	startDate = request.URL.Query().Get(START_DATE)
	if startDate == "" {
		startDate = time.Now().AddDate(0, -1, 0).Format(DATE_FORMAT_SHORT)
	}
	endDate = request.URL.Query().Get(END_DATE)
	if endDate == "" {
		endDate = time.Now().Format(DATE_FORMAT_SHORT)
	}
	page, err := strconv.Atoi(request.URL.Query().Get(PAGE))
	if err != nil {
		page = 0
	}
	pageSize, err := strconv.Atoi(request.URL.Query().Get(PAGE_SIZE))
	if err != nil {
		pageSize = configuration.GetConfig().Mysql_limit_items
	}
	if pageSize > 250 { // Security upper page size limit
		pageSize = 250
	}
	eventId, err = strconv.Atoi(request.URL.Query().Get(EVENT_ID)) // Return 0 if error

	// Retrieve requested resource information
	prices := dataservice.GetPrices(startDate, endDate, page, configuration.GetConfig(), priceId, eventId, uuid, oauthtoken, pageSize)

	// Set json response struct
	var params ParametersResponseType
	params.StartDate = startDate
	params.EndDate = endDate
	params.Page = page
	params.TraceId = uuid
	var pricesresponse PricesResponseType
	pricesresponse.Parameters = params
	pricesresponse.RequestDate = time.Now()
	pricesresponse.Version = "1.0"
	pricesresponse.Prices = prices

	pricesjson, err := json.Marshal(pricesresponse)
	if err != nil {
		w.WriteHeader(http.StatusNoContent)
		log.Errorf("/prices error status 204 no content.")
		return
	}

	// Set response headers
	w.Header().Set("Content-Type", "application/json")

	// Set response body
	w.Write(pricesjson)

	elapsed := time.Since(start)
	log.Infof("{%v} /prices response status 200 in %v", uuid, elapsed)

}
Ejemplo n.º 5
0
	StartDate string `json:"start_date"`
	EndDate   string `json:"end_date"`
	EventId   int    `json:event_id`
	SaleId    string `json:"sale_id"`
	Page      int    `json:"page"`
	PageSize  int    `json:"page_size"`
	TraceId   string `json:"trace_id"`
}

// Global vars and default values
var (
	log       *logging.Logger = configuration.GetLog()
	startDate string
	endDate   string
	eventId   int
	config    = configuration.GetConfig()
)

// https://blog.golang.org/context/userip/userip.go
// Funtion to retrieve the sender IP from request
// or from forwared headers instead
func getIP(w http.ResponseWriter, req *http.Request) string {

	ip, _, err := net.SplitHostPort(req.RemoteAddr)
	if err != nil {
		log.Debugf("userip: %q is not IP:port", req.RemoteAddr)
	}

	userIP := net.ParseIP(ip)
	if userIP == nil {
		return req.RemoteAddr