def test_should_add_a_product_into_already_existing_category(self):
existingCategory = Category('existingCategory')
firstProduct = Product('firstProduct', 100.0, existingCategory)
secondProduct = Product('secondProduct', 200.0, existingCategory)
self.cart.addItem(firstProduct, 1)
self.cart.addItem(secondProduct, 1)
expectedCategoryProductCount = 2
expectedCategoryCurrentPrice = 300.0
expectedSecondProductCount = 1
expectedSecondProductCurrentPrice = 200.0
self.assertEqual(
self.cart.categories['existingCategory']['productCount'],
expectedCategoryProductCount)
self.assertEqual(
self.cart.categories['existingCategory']['currentPrice'],
expectedCategoryCurrentPrice)
self.assertEqual(
self.cart.categories['existingCategory']['products']
['secondProduct']['count'], expectedSecondProductCount)
self.assertEqual(
self.cart.categories['existingCategory']['products']
['secondProduct']['currentPrice'],
expectedSecondProductCurrentPrice)
def get(self):
try:
service = session.query(ServiceModel, Client, Product).join(
Client,
Product).filter(ServiceModel.id == self._service._id).first()
if service is None:
return None
else:
c = ClientClass(service.Client.name, service.Client.cpf,
service.Client.segment)
c._id = service.Client.id
p = ProductClass(service.Product.name,
service.Product.description,
service.Product.image)
p._id = service.Product.id
s = ServiceClass(service.Service.request_date,
service.Service.cancel_date)
s._id = service.Service.id
s._client = c
s._product = p
return s
except Exception as e:
print "Erro: ", e
def parse_products(url, product_list, sub_catalog):
next_url = url + PAGE
products_exist = True
while products_exist:
products_exist = False
html_data = get_html_data(url=next_url)
try:
if len(html_data) < 3:
products_exist = True
print(sub_catalog.name)
continue
except TypeError:
products_exist = True
print(sub_catalog.name)
continue
for tag in (html_data('div', {'class': PRODUCTS_LINK})):
name = tag.get(PRODUCT_NAME)
price = tag.get(PRODUCT_PRICE)
url = complete_url_fullness(url=tag.get(PRODUCT_URL))
product = Product(name=name, price=price, url=url, available=True)
product_list.append(
Product(name=name, price=price, url=url, available=True))
add_product_to_file(product, FILE)
products_exist = True
try:
next_url = complete_url_fullness(
(html_data.find('a', {'class': NEXT_PAGE_LINK})).get('href'))
except AttributeError:
products_exist = False
def AddProduct(self,Commands:list):
for Command in Commands:
NewProduct = Product()
Events = NewProduct.processForProductCreationCommand(Command)
NewProduct.applyForProductCreationEvent(Events[0])
ProductRepository().Create((NewProduct,),Events)
return f'Products inserted successfully'
def load(self, path):
tree = et.parse(path)
elem = tree.getroot()
for productElem in elem.iter("product"):
product = Product()
product.load(productElem)
self._products.append(product)
def parseProductsDetail(bu, productsContentBlockList):
buProductsBlockList = []
for productsContentBlock in productsContentBlockList:
buProductsBlockList = productsContentBlock.find_all(
'div', itemindex=bu.itemIndex)
if len(buProductsBlockList) != 0:
break
if len(buProductsBlockList) == 0:
return []
productsTable = buProductsBlockList[0].table
productRowList = productsTable.find_all('tr')
if len(productRowList) > 0:
products = []
for index in range(1, len(productRowList)):
row = productRowList[index]
columns = row.find_all('td')
if len(columns) == 2:
products.append(
Product(bu.name, columns[0].get_text(),
columns[1].get_text()))
elif len(columns) == 4:
products.append(
Product(bu.name, columns[0].get_text(),
columns[1].get_text(), columns[2].get_text(),
columns[3].get_text()))
else:
pass
return products
else:
return []
def readStore(self): # yuki
with open('database.json', 'r') as infile:
savedStore = json.loads(infile.read())
for productData in savedStore['products']:
productId = productData['id']
productName = productData['name']
productUnit = productData['unit']
productOriginalPrice = productData['originalPrice']
productSource = productData['source']
productShelfLife = productData['shelfLife']
batches = productData['batch']
product = Product(productId, productName, productUnit,
productOriginalPrice, productSource,
productShelfLife)
for batch in batches:
sDate = batch['shelfDate'].split('-')
bShelfDate = datetime.date(int(sDate[0]), int(sDate[1]),
int(sDate[2]))
batchId = batch['batchId']
batchActualPrice = batch['actualPrice']
batchQuantity = batch['quantity']
batchShelfDate = bShelfDate
product.buildBatch(batchId, batchActualPrice, batchQuantity,
batchShelfDate, productShelfLife)
self.products.append(product)
for customerData in savedStore['customers']:
cId = customerData['id']
cPassword = customerData['password']
cName = customerData['name']
cPhoneNumber = customerData['phoneNumber']
cAddress = customerData['address']
cBalance = customerData['balance']
cShoppingCart = customerData['shoppingCart']
customer = CustomerAccount(cId, cPassword, cName, cPhoneNumber,
cAddress, cBalance)
customer.shoppingCart.setProductsInCart(cShoppingCart)
self.customers.append(customer)
for customerId in savedStore['orderHistory']:
cOrderList = savedStore['orderHistory'][customerId]
customerOrders = []
for eachOrder in cOrderList:
orderId = eachOrder['orderId']
orderCId = eachOrder['customerId']
tempShoppingCart = eachOrder['shoppingCart']
orderShoppingCart = ShoppingCart()
orderShoppingCart.setProductsInCart(tempShoppingCart)
orderTotalPrice = eachOrder['totalPrice']
dateS = eachOrder['transactionDate'].split('-')
orderTransactionDate = datetime.datetime(
int(dateS[0]), int(dateS[1]), int(dateS[2]), int(dateS[3]),
int(dateS[4]), int(dateS[5]))
order = Order(orderId, orderCId, orderShoppingCart,
orderTotalPrice, orderTransactionDate)
customerOrders.append(order)
self.orderHistory[customerId] = customerOrders
ownerData = savedStore['owner']
self.owner = OwnerAccount(ownerData['id'], ownerData['name'],
ownerData['password'])
def add_product():
# Retrieve the product from request body
data = request.json
log.debug(f'POST /product with product: {data}')
# Generate an ID for the post
# new_id = max([product['id'] for product in products]) + 1
# Create a new product with id as 'None' since auto increment is set for ID column
product = Product(None, data['name'])
try:
# Save the Product to the database
product.save_to_db()
# Create new product
# new_product = {
# 'id': new_id,
# 'name': data['name']
# }
# add new product to the array
# products.append(new_product)
return jsonify(product.json), 201
except exc.SQLAlchemyError:
log.exception(
f'An exception occurred while creating product with name: {product.name}'
)
return f'An exception occurred while creating product with name: {product.name}', 500
def test_Product_sentinel3_reader_OLCIL1_openProduct_getData_Oa01_radiance_long_lat(
self):
from Product import Product
# Open test product
testProduct = Product(OLCIL1_test_path)
# Get Data for Oa01 radiance
Oa01_radiance = testProduct.getData('Oa01_radiance', 'longitude',
'latitude')
# Assert attributes equal to test attributes
for key in OLCIL1_test_attributes.keys():
self.assertEqual(Oa01_radiance.attrs[key],
OLCIL1_test_attributes[key],
"Problem with %s" % key)
# Assert Oa01_variables attributes equal to test variable attributes
for key in OLCIL1_test_variables['Oa01_radiance'].keys():
self.assertEqual(Oa01_radiance.Oa01_radiance.attrs[key],
OLCIL1_test_variables['Oa01_radiance'][key],
"Problem with %s" % key)
# Assert specific pixel values
self.assertAlmostEqual(
round(float(Oa01_radiance.Oa01_radiance.values[0, 126]), 5),
52.06213)
self.assertAlmostEqual(
round(float(Oa01_radiance.Oa01_radiance.values[342, 567]), 5),
94.15255)
# Assert no coordinates
self.assertItemsEqual(Oa01_radiance.coords.keys(),
['longitude', 'latitude'])
def test_openProduct(self):
from Product import Product
# Create test data and reader
createTestReader_netCDF(test_reader_directory)
writeTestData(test_data_path, test_data, test_variable_name)
# Ensure test data reader generated
self.assertTrue(exists(test_reader_directory), "Test reader missing")
self.assertTrue(exists(test_data_path), "Test data missing")
# Open test product
testProduct = Product(test_data_path)
# Test correct data found
test_data_opened = testProduct.getData(test_variable_name)
for row, test_row in zip(test_data, test_data_opened):
for elem, test_elem in zip(row, test_row):
self.assertEqual(elem, test_elem)
# Assert varaibles default
self.assertEqual(testProduct.variables, test_variables)
# Test attributes found correct
test_attributes_opened = testProduct.attributes
for key in testProduct.attributes.keys():
self.assertEqual(test_attributes[key], test_attributes_opened[key],
key + "incorrect")
# Close product
testProduct.product.close()
# Remove test data reader
shutil.rmtree(test_reader_directory)
shutil.rmtree(dirname(test_data_path))
def add_product(self):
try:
if self.prod_name.text() == "" or self.prod_unit.text() == "":
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Error")
msg.setInformativeText('Please insert data!')
msg.setWindowTitle("Error")
msg.exec_()
else:
new_prod = Product(self.prod_name.text(),
self.prod_unit.text(),
self.purchase_price.text(),
self.sell_price.text())
new_prod.insert_product()
self.update_all_products()
self.prod_name.setText("")
self.prod_unit.setText("")
self.purchase_price.setText("")
self.sell_price.setText("")
except:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Error")
msg.setInformativeText('Please insert data!')
msg.setWindowTitle("Error")
msg.exec_()
def add_product(self,name, measurment_unit, purchase_price, sell_price, listbox):
new_prod = Product(name.get(), measurment_unit.get(), float(purchase_price.get()), float(sell_price.get()))
new_prod.insert_product()
name.delete(0, END)
measurment_unit.delete(0, END)
purchase_price.delete(0, END)
sell_price.delete(0, END)
self.update_list(listbox)
def remove_product(self, product_name):
now = datetime.datetime.now()
date = "{}-{}-{}".format(now.year, now.month, now.day)
if not self._is_product_exists(product_name, date):
raise Exception("[ERROR]::There is no item with shuch name.")
item = Product.select(Product.q.productName == product_name)[0]
Product.delete(item.id)
def setUp(self):
self.s1 = Store()
self.p1 = Product("1", "Apple", "ea", 5.00, "SA", 14)
self.p1.addBatch(10)
self.p1.addBatch(5)
self.p1.batches.append(
Batch("3", 5.00, 10,
datetime.date.today() - datetime.timedelta(days=12), 14))
self.p1.updateDiscount()
def test_jsonify_product(self):
p = Product(id ="test", name = "test", description = "test",price = "test")
encoded_json = p.to_json("test")
print encoded_json
self.assertEqual(encoded_json['prodName'],"test")
self.assertEqual(encoded_json['prodDesc'],"test")
self.assertEqual(encoded_json['price'],"test")
self.assertEqual(encoded_json['quantity'],1)
self.assertEqual(encoded_json['category'],"perishable")
self.assertEqual(encoded_json['vendorId'],"test")
def init_product_list(p_list):
p = Product('1001', 'Apple iPhone', 1088.00)
p_list.append(p)
p = Product('1005', 'HTC Desire', 888.00)
p_list.append(p)
p = Product('1013', 'LG Optimus', 788.00)
p_list.append(p)
p = Product('1022', 'Sony Xperia', 958.00)
p_list.append(p)
p = Product('1027', 'Samsung Galaxy', 988.00)
p_list.append(p)
def testGetCostsPerPerson(self):
groupFactory = OwnerGroupFactory()
infoFactory = OwnerInfoFactory()
info1 = infoFactory.create("Me", 0.25)
info2 = infoFactory.create("You", 0.75)
group = groupFactory.create([info1, info2])
product = Product("Test", 12, group)
self.assertEqual(product.costPerPerson(), {"Me": 3, "You": 9})
def construct_product_items(productItemsArrayList):
productItemsArrayList.append(Product(501,"Chocolate",1,100))
productItemsArrayList.append(Product(502,"PopCorn",1,45))
productItemsArrayList.append(Product(503,"Biscuit",2,18))
productItemsArrayList.append(Product(504,"FaceWash",1,180))
productItemsArrayList.append(Product(505,"Oil",6,30))
productItemsArrayList.append(Product(506,"Soup, 2 Packets",2,50))
productItemsArrayList.append(Product(508,"Pillow Cover",1,300))
productItemsArrayList.append(Product(507,"Mango, 3 Pieces",3,90))
productItemsArrayList.append(Product(509,"Pen Stand",1,50))
productItemsArrayList.append(Product(510,"Milk, 2 Litres",2,2.0))
def delete_product(self):
try:
Product.delete_product_by_name(self.prod_name)
self.close()
except:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Error")
msg.setInformativeText('Please insert data!!!')
msg.setWindowTitle("Error")
msg.exec_()
def change_name(self):
try:
Product.update_product_name(self.prod_name, self.enterName.text())
self.enterName.setText("")
except:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Error")
msg.setInformativeText('Please insert data!!!')
msg.setWindowTitle("Error")
msg.exec_()
def addProduct(self, name, description, manufacturer, wholesale, sale,
stock):
if self.checkNames(name) == False:
id_ = str(uuid.uuid4())
product = Product(id_, name, description, manufacturer, wholesale,
sale, stock)
self.database.update({(id_, name): product})
else:
product = self.getProductByName(name)
product.stock = product.stock + stock
self.database.update({(product.id, product.name): product})
def format_bigbuy_products(self, products, products_categories):
print "Format products to BigBuy format"
formatted_products = []
all_product_images = self.get_products_images()
products_infos = self.get_products_infos()
for item in products:
product = Product(item, products_infos, all_product_images,
products_categories)
if product.is_valid_product:
formatted_products.append(product.to_json())
print "Product added " + str(product.to_json())
return formatted_products
def add_product(self):
img = self.prod_image
name = self.prod_name_entry.get()
date = self.prod_date_entry.get()
num = self.num_entry.get()
endurance = self.endurance_entry.get()
price = self.price_entry.get()
self.new_prod = Product(self.prod_label, img, name, date, num,
endurance, price)
self.new_prod.add_to_label(self.prod_label)
ProductsPage.products.insert(len(ProductsPage.products), self.new_prod)
self.new_prod_frame.destroy()
def scrape_product_page(self) -> None:
for product_sku in self.sku_list:
product_sku = product_sku.strip()
# search_page_url = f"https://www.bestbuy.com/site/searchpage.jsp?st={product_sku}"
product_url = f"https://www.bestbuy.com/site/{product_sku}.p?skuId={product_sku}"
product_activation_url = f"https://www.bestbuy.com/wireless/transaction-types/render/carriers" \
f"?numberOfPayments=1&purchaseType=FULL_SRP&skuId={product_sku} "
product_brand = "-1"
product_model = "-1"
product_name = "-1"
product_unlocked_price = "-1"
product_activation_price = "-1"
product_carrier_compatibility = "-1"
product_pricing = {}
has_multiple_activation_offers = False
self.driver.get(product_url)
self.driver.implicitly_wait(3)
if not self.no_results_flag(self.driver) and not self.multiple_products_flag(self.driver):
html = self.driver.execute_script("return document.documentElement.innerHTML;")
page_contents = BeautifulSoup(html, "html5lib")
try:
product_unlocked_price = self.find_price_in_string(self.get_unlocked_price(page_contents))
product_activation_price = self.find_price_in_string(self.get_activated_price(page_contents))
except AttributeError:
print(f"No activation price for {product_sku} at {product_url}")
product_brand, product_model, product_name, product_carrier_compatibility = [s for s in self.get_product_attrs(page_contents)]
else:
# Skip trying to find attributes of the current sku
continue
self.driver.get(product_activation_url)
self.driver.implicitly_wait(3)
if not self.no_results_flag(self.driver) and not self.multiple_products_flag(self.driver):
html = self.driver.execute_script("return document.documentElement.innerHTML;")
page_contents = BeautifulSoup(html, "html5lib")
product_pricing = self.get_product_activation_attrs(page_contents)
if product_pricing["ATT"]["newline"] == "AT&T":
product_pricing["ATT"]["newline"] = product_activation_price
product = Product(product_sku, product_brand, product_model, product_name, product_carrier_compatibility, product_url,
product_unlocked_price, product_activation_price, product_pricing)
product.disseminate_pricing()
print(product.get_json())
# Close the selenium webdriver on conclusion of the sku list
self.driver.quit()
def GetWarehouseState(self,Command):
Warehouse = {
'Samsung galaxy 9': 0,
'Samsung galaxy A70 Dual': 0,
'Apple iphone 11': 0
}
for Events in ProductRepository().LoadEachProductEvents(Command.Date):
product = Product()
if Events:
product.r(Events)
if product.State not in ['Sold','Validated']:
Warehouse[product.Name] = Warehouse[product.Name] + 1
return Warehouse
def init_data():
customers = [Customer("01223", "Peter Parker", "Qo'yliq", 2.2, "90-932-75-98", ["Silver", 'Gold']),
Customer("75884", "Sherlock Holmes", "Backer street", 31415, "90-987-65-43", ["Regular", 'VIP']),
Customer("70070", "James Bond", "NY City", 450, "90-900-90-90", ["Silver", 'Gold'])]
store = Store('U1510375', "John's Mall", "Ziyolar-9", "90-123-45-67")
staff_members = [Staff("0", "02213", "Uncle Ben", "Manager"),
Staff("1", "45646", "Aunt May", "Cashier"),
Staff('2', "12345", "John Doe", "Owner")]
products = [Product(69, "Cucumber", "Fresh and long cucumber", 69.69, 666),
Product(666, "Tomatoes", "Red and plump", 12.14, 314),
Product(123, "_Candies_", "Sweet sweet candies", 50, 100),
Product(314, "_Bananas_", "My favorite", 42, 450)]
return products, customers, staff_members, store
def makeAll(self):
for i in self.root_shufersal[5]:
product = Product("shufersal", i[3].text, str(i[12].text),
str(i[4].text), i[1].text)
self.data_shufersal.append(product)
for i in self.root_market[4]:
product = Product("market Store", i[3].text, i[12].text,
str(i[4].text), i[1].text)
self.data_market.append(product)
for i in self.root_ramilevi[6]:
product = Product("rami levi Store", i[3].text, i[12].text,
i[4].text, i[1].text)
self.data_ramilevi.append(product)
def update():
counter = shelf.getSize()
node = shelf.head
node = node.next
product_update = []
list_a = []
df = []
product_update.append(Product(None, None, None, None, None, None))
list_a.append(None)
df.append(None)
xlsfile = 'output.xlsx'
writer = pd.ExcelWriter(xlsfile, engine='xlsxwriter')
for i in range(1, counter):
product_update.append(
Product(node.data.sku, node.data.length, node.data.width,
node.data.height, node.data.frag, node.data.weight))
node = node.next
list_a.append([
product_update[i].sku, product_update[i].length,
product_update[i].width, product_update[i].height,
product_update[i].frag, product_update[i].weight
])
df.append([pd.DataFrame(list_a[i])])
header = ['Sku', 'length', 'width', 'height', 'fragile', 'weight']
#header=['a','b']
df1 = pd.DataFrame(header)
# df1.transpose()
df1 = df1.transpose()
df1.to_excel(writer,
sheet_name="Sheet1",
startrow=0,
startcol=0,
header=False,
index=False)
for i in range(0, counter):
df[i] = pd.DataFrame(list_a[i])
# df1.transpose()
df[i] = df[i].transpose()
df[i].to_excel(writer,
sheet_name="Sheet1",
startrow=i,
startcol=0,
header=False,
index=False)
writer.save()
print('successfully export to excel')
def ConnectProductToOrder(self, ProductName): # prepei try catch
for Entity in self.session.execute(
"SELECT MIN(EventTime), EntityId, EntityType FROM Snapshots WHERE SnapshotType = %s and SemantickLock = %s LIMIT 1 ALLOW FILTERING ",
[ProductName, 'Unlock']):
try:
for product in self.session.execute(
"SELECT EntityId, EntityType, SnapshotData FROM Snapshots WHERE EventTime = %s ALLOW FILTERING",
[Entity.system_min_eventtime]):
UpdatedRow = self.session.execute(
"UPDATE Snapshots SET SemantickLock = %s WHERE EntityId = %s and EntityType = %s IF SemantickLock = %s",
[
'Locked', product.entityid, product.entitytype,
'Unlock'
])
if UpdatedRow[0].applied:
return product.snapshotdata
else:
NewProduct = Product()
Event = ProductInsertedEvent(str(randint(0, 1000)),
ProductName, 'Free')
NewProduct.applyForProductCreationEvent(Event)
self.Create((NewProduct, ), (Event, ))
raise NotAvailableProduct()
except Exception:
NewProduct = Product()
Event = ProductInsertedEvent(str(randint(0, 1000)),
ProductName, 'Free')
NewProduct.applyForProductCreationEvent(Event)
self.Create((NewProduct, ), (Event, ))
raise NotAvailableProduct()
def define_test_data(self):
s1 = Shop("Aldi", (10, 10))
s2 = Shop("Real", (200, 200))
p1 = Product(product_name="Butter", price=10.0, barCode=None)
p2 = Product(product_name="Milch", price=0.61, barCode=None)
p3 = Product("Wasser", 1.5, 3057640182693)
p4 = Product("Brot", 2.5, 3057640182693)
s1.stock.append(p1)
s1.stock.append(p2)
s1.stock.append(p3)
s1.stock.append(p4)
p5 = Product("Butter", 9.8, None)
p6 = Product("Milch", 0.65, None)
p7 = Product("Wasser", 1.5, 3057640182693)
p8 = Product("Brot", 2.5, 3057640182693)
s2.stock.append(p5)
s2.stock.append(p6)
s2.stock.append(p7)
s2.stock.append(p8)
self.products = [p1, p2, p3, p4, p5, p6, p7, p8]
self.shops = [s1, s2]
def __init__(self):
self.app = Flask(__name__)
self.host = "0.0.0.0"
self.port = 5001
self.server = ''
self.database = ''
self.url = "http://" + self.host + ":" + str(
self.port) + "/ol-ti-itcpfegem-beta/billService?wsdl"
self.category = Category()
self.client = Client()
self.product = Product()
self.sale = Sale()
self.user = User()
def add_product():
while True:
#se pide la información del producto
try:
name = input('Producto que desea agregar: ')
classification = int(input('Indique si el producto es un alimento(1) o bebida(2): '))
if classification == 1:
classification = 'alimento'
type_of_food = int(input('Indique si el alimento es de empaque(1) o de preparación(2): '))
if type_of_food == 1:
type_of_food = 'empaque'
elif type_of_food == 2:
type_of_food = 'preparación'
else:
raise Exception
beverage_size = 'No aplica'
elif classification == 2:
classification = 'bebida'
beverage_size = int(input('Indique tamaño de la bebida: pequeño(1), mediano(2), grande(3): '))
if beverage_size == 1:
beverage_size = 'pequeño'
elif beverage_size == 2:
beverage_size = 'mediano'
elif beverage_size == 3:
beverage_size = 'grande'
else:
raise Exception
type_of_food = 'No aplica'
else:
raise Exception
raw_price = float(input('Precio: '))
price = Product.product_price(raw_price)
break
except:
print('Error: ingrese una opción válida')
#guardo el producto en una variable y se lo paso a la función que lo va a agregar al menú
product = Product(name, classification, beverage_size, type_of_food, price)
m = ProductMenu(product)
#función de la clase para agregar el producto al menú
m.add_product('product_menu.txt')
print(f'Producto {product.name} agregado exitosamente')
return m.show_menu()
def import_product(self, product, to_append=True):
new_product = Product(product['name'], product['categories'], product['description'], product['image'],
product['start_price'],
product['start_date'], product['end_date'], product['shipping_cost'],
product['vendor_id'], product['is_direct'], product['bidders'], product['bid_count'],
product['current_price'],
product['id'])
for category in new_product.get_categories():
try:
cat = self.categories_mng.get_category_by_id(category)
cat.increase_products_count()
except ValueError:
raise AssertionError('Category with id [' + category.__str__() + '] does not exists')
if to_append:
self.products.append(new_product)
else:
return new_product
def testEncodeProduct(self):
product = Product()
product.name = "name"
product.kids = 0
product.price = 123.45
product.sizes = "sizes"
product.delivery = "delivery"
product.url = "url"
product.img_url = "img_url"
output = json.dumps(product, cls=ProductJsonEncoder)
self.assertEqual('{"kids": 0, "name": "name", "package": "", "kid_adult": 0, "free_porto": 0, "price": 123.45, "sizes": "sizes", "delivery": "delivery", "url": "url", "price_old": 0, "img_url": "img_url", "id": 0, "women": 0}', output)
class TestFridge(unittest.TestCase):
def setUp(self):
self.yaourt = Product('yaourt', 'Danone', "25102000")
self.banana = Product('fruit', 'banana', "25102000")
self.banana2 = Product('fruit', 'banana', "26102000")
self.banana3 = Product('fruit', 'banana', "26102000")
def test_equals(self):
self.assertTrue(self.banana2.equals(self.banana3))
self.assertFalse(self.yaourt.equals(self.banana))
self.assertFalse(self.banana.equals(self.banana2))
def test_get_name(self):
self.assertEqual("Danone", self.yaourt.get_name())
self.assertEqual("banana", self.banana.get_name())
def test_product_type(self):
self.assertEqual("yaourt", self.yaourt.get_product_type())
self.assertEqual("fruit", self.banana2.get_product_type())
def test_get_use_by(self):
self.assertEqual("25102000", self.yaourt.get_use_by())
self.assertEqual("26102000", self.banana3.get_use_by())
def post(self, mode=""):
if mode == "set_ec":
sid = self.request.get("sid")
user_info = memcache.get(sid)
product = Product.getProduct()
nvp_params = {
'L_PAYMENTREQUEST_0_NAME0' : str(product['quantity']) + ' ' + product['units'],
'L_PAYMENTREQUEST_0_AMT0' : str(product['price']),
'L_PAYMENTREQUEST_0_QTY0' : 1,
'L_PAYMENTREQUEST_0_ITEMCATEGORY0' : 'Digital',
'PAYMENTREQUEST_0_AMT' : str(product['price']),
'RETURNURL' : self.request.host_url+"/do_ec_payment?sid="+sid,
'CANCELURL': self.request.host_url+"/cancel_ec?sid="+sid
}
response = EC.set_express_checkout(nvp_params)
if response.status_code != 200:
logging.error("Failure for SetExpressCheckout")
template_values = {
'title' : 'Error',
'operation' : 'SetExpressCheckout'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unknown_error.html')
return self.response.out.write(template.render(path, template_values))
# The remainder of the transaction is completed in context
parsed_qs = cgi.parse_qs(response.content)
redirect_url = EC.generate_express_checkout_digital_goods_redirect_url(parsed_qs['TOKEN'][0])
return self.redirect(redirect_url)
else:
logging.error("Unknown mode for POST request!")
def post(self, mode=""):
if mode == "pay":
sid = self.request.get("sid")
returnUrl = self.request.host_url+"/completed_payment?sid="+sid,
cancelUrl = self.request.host_url+"/cancelled_payment?sid="+sid
product = Product.getProduct()
seller = {'email' : SELLER_EMAIL, 'amount' : product['price']}
response = AP.pay(receiver=[seller], cancelUrl=cancelUrl, returnUrl=returnUrl)
result = json.loads(response.content)
logging.info(result)
if result['responseEnvelope']['ack'] == 'Failure':
logging.error("Failure for Pay")
template_values = {
'title' : 'Error',
'operation' : 'Pay'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unknown_error.html')
return self.response.out.write(template.render(path, template_values))
# Stash away the payKey for later use
user_info = memcache.get(sid)
user_info['payKey'] = result['payKey']
memcache.set(sid, user_info, time=60*10) # seconds
# Redirect to PayPal and allow user to confirm payment details.
redirect_url = AP.generate_adaptive_payment_redirect_url(result['payKey'])
return self.redirect(redirect_url)
else:
logging.error("Unknown mode for POST request!")
def post(self, mode=""):
if mode == "set_ec":
sid = self.request.get("sid")
user_info = memcache.get(sid)
product = Product.getProduct()
nvp_params = {
'PAYMENTREQUEST_0_AMT' : str(product['price']),
'RETURNURL' : self.request.host_url+"/get_ec_details?sid="+sid,
'CANCELURL': self.request.host_url+"/cancel_ec?sid="+sid
}
response = EC.set_express_checkout(nvp_params)
if response.status_code != 200:
logging.error("Failure for SetExpressCheckout")
template_values = {
'title' : 'Error',
'operation' : 'SetExpressCheckout'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unknown_error.html')
return self.response.out.write(template.render(path, template_values))
# Redirect to PayPal and allow user to confirm payment details.
# Then PayPal redirects back to the /get_ec_details or /cancel_ec endpoints.
# Assuming /get_ec_details, we complete the transaction with PayPal.get_express_checkout_details
# and PayPal.do_express_checkout_payment
parsed_qs = cgi.parse_qs(response.content)
redirect_url = EC.generate_express_checkout_redirect_url(parsed_qs['TOKEN'][0])
return self.redirect(redirect_url)
else:
logging.error("Unknown mode for POST request!")
def test_Product_From_Sortable_Challenge(self):
"""
Tests the first entry from the sortable challenge, namely:
"product_name":"Sony_Cyber-shot_DSC-W310",
"manufacturer":"Sony",
"model":"DSC-W310",
"family":"Cyber-shot",
"announced-date":"2010-01-06T19:00:00.000-05:00"
We test if the Product is correctly initiated, if all the
getters work properly, the string representation is right and
the json representation is right.
"""
name = "Sony_Cyber-shot_DSC-W310"
manufacturer = "Sony"
model = "DSC-W310"
family = "Cyber-shot"
a_d ="2010-01-06T19:00:00.000-05:00"
stringRep = """Name: Sony_Cyber-shot_DSC-W310
Manufacturer: Sony
Family: Cyber-shot
Model: DSC-W310
Announced Date: 2010-01-06T19:00:00.000-05:00"""
jsonRep="""{"product_name":"Sony_Cyber-shot_DSC-W310","manufacturer":"Sony","model":"DSC-W310","family":"Cyber-shot","announced-date":"2010-01-06T19:00:00.000-05:00"}"""
try:
testProduct = Product(name,manufacturer,family,model,a_d)
except:
self.fail("Correct product initialization was not possible")
self.assertEqual(name, testProduct.getName(),
"The name did not coincide with the given one")
self.assertEqual(manufacturer,testProduct.getManufacturer(),
"The manufacturer was not stored properly")
self.assertEqual(model,testProduct.getModel(),
"The model name was not stored properly")
self.assertEqual(family,testProduct.getFamily(),
"The family name was not stored properly")
self.assertEqual(a_d,testProduct.getAnnouncementDate(),
"The announcement date was not stored properly")
self.assertEqual(stringRep,str(testProduct),
"String representation was not correct")
self.assertEqual(json.loads(jsonRep),json.loads(testProduct.toJSON()),
"JSON representation was not correct")
product_file = "products.txt" listing_file = "listings.txt" scan_product_f = open(product_file) scan_listing_f = open(listing_file) scan_product_sentinel = True product_list = [] #LOOP INVARIANT: #products.txt has unread products while True: argData = scan_product_f.readline() if not argData: break # reached EOF json_data = json.loads(argData) tempProduct = Product() tempProduct.initializeValues(json_data) product_list.append(tempProduct) feature = Feature_Extractor() for product in product_list: feature.processProduct(product) feature.complete_preprocessing(); ''' #Plotting data analysis feature.plot(10,feature.tags_pname) feature.plot(20,feature.tags_manfact) feature.plot(30,feature.tags_fam) feature.plot(40,feature.tags_model) feature.plot(50,feature.tags_date) feature.draw()
def parse_product(f):
product = Product()
product.name = f['name']
product.description = f['description']
return product
print 'Got all worksheets...'
# product_ids = product_sheet.col_values(2)
product_rows = product_sheet.get_all_values()
print 'Product total: ' + str(len(product_rows) - 1)
print 'Start processing product item...'
for product_index in range(1, len(product_rows)):
product_row = product_rows[product_index]
# create product object
product = Product(id=product_row[1],
name=product_row[2],
eng_name=product_row[3],
detail=product_row[4],
categories=product_row[5].split(','),
status=product_row[0],
table_type=int(product_row[6]))
print '[' + product.id + '] start -----------'
###### Parse data table #######
# print ' parsing data table...'
# if product.table_type == 2:
# product.table_info = parse_table_info(product, data_table_rows)
# elif product.table_type == 1:
# product.table_info = parse_table_junk(product, product_row)
# elif product.table_type == 0:
# print ' No data table exist.'
# else:
def get(self, mode=""):
if mode == "completed_payment":
if memcache.get(self.request.get("sid")) is not None: # Without an account reference, we can't credit the purchase
user_info = memcache.get(self.request.get("sid"))
payKey = user_info["payKey"]
response = AP.get_payment_details(payKey)
result = json.loads(response.content)
logging.info(result)
if result['responseEnvelope']['ack'] == 'Failure' or \
result['status'] != 'COMPLETED': # Something went wrong!
logging.error("Failure for PaymentDetails")
template_values = {
'title' : 'Error',
'operation' : 'ExecutePayment'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unknown_error.html')
return self.response.out.write(template.render(path, template_values))
if result['paymentInfoList']['paymentInfo'][0]['transactionStatus'] != 'COMPLETED': # An eCheck?
logging.error("Payment transaction status is not complete!")
template_values = {
'title' : 'Error',
'details' : 'Sorry, eChecks are not accepted. Please send an instant payment.'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unsuccessful_payment.html')
return self.response.out.write(template.render(path, template_values))
# Credit the user's account
twitter_username = user_info['username']
product = Product.getProduct()
AppHandler.creditUserAccount(twitter_username, product['quantity'])
template_values = {
'title' : 'Successful Payment',
'quantity' : product['quantity'],
'units' : product['units']
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'successful_payment.html')
self.response.out.write(template.render(path, template_values))
else:
logging.error("Invalid/expired session in /completed_payment")
template_values = {
'title' : 'Session Expired',
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'session_expired.html')
self.response.out.write(template.render(path, template_values))
elif mode == "cancelled_payment":
template_values = {
'title' : 'Cancel Purchase',
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'cancel_purchase.html')
self.response.out.write(template.render(path, template_values))
def test_profit(self):
my_product = Product("Laptop", 1000, 1200)
self.assertEqual(200, my_product.profit())
def setUp(self):
self.yaourt = Product('yaourt', 'Danone', "25102000")
self.banana = Product('fruit', 'banana', "25102000")
self.banana2 = Product('fruit', 'banana', "26102000")
self.banana3 = Product('fruit', 'banana', "26102000")
def csvParser(myString):
products = myString.split('\r')
for i in range(len(products)):
products[i] = products[i].split(',')
products.pop(0)
for i in range(len(products)):
try:
int(products[i][7])
except:
continue
else:
temp = Product()
if(products[i][0] != "n/a"):
temp.setSku(products[i][0].upper())
if(products[i][1] != "n/a"):
temp.setDeviceType(products[i][1].upper())
if(products[i][2] != "n/a"):
temp.setColor(products[i][2].upper())
if(products[i][3] != "n/a"):
temp.setCarrier(products[i][3].upper())
if(products[i][4] != "n/a"):
temp.setSize(products[i][4].upper())
if(products[i][5] != "n/a"):
temp.setSpecs(products[i][5].upper())
if(products[i][6] != "n/a"):
temp.setName(products[i][6])
if(products[i][7] != "n/a"):
temp.setNumLabels(int(products[i][7]))
products[i] = temp
return products
def __init__(self, p=None):
Product.__init__(self, path)
print " init class MphProduct, path=%s" % p
self.path=p
self.type=Product.TYPE_MPH
def get(self, mode=""):
client = oauth.TwitterClient(
twitter_config.TWITTER_CONSUMER_KEY,
twitter_config.TWITTER_CONSUMER_SECRET,
"%s/app" % self.request.host_url)
# The /app context ensures that the user's account is in good standing in
# terms of payment, computes relevance for tweets from their home timeline,
# stashes the data and serves up the app. The app then requests the stashed
# data via /data.
if mode == "app":
# Pull out auth token/verifier in order to get an access token
# and in order to get some basic information about the user.
# Subsequent requests will be performed via client.make_request
auth_token = self.request.get("oauth_token")
auth_verifier = self.request.get("oauth_verifier")
user_info = client.get_user_info(auth_token, auth_verifier=auth_verifier)
twitter_username = user_info['username']
# Has a user already used this webapp with twitter_username?
query = User.all().filter("twitter_username ="******"home_timeline" : "http://api.twitter.com/1/statuses/home_timeline.json",
"favorites_timeline" : "http://api.twitter.com/1/favorites.json",
}
# Fetch the first 5 pages of results for the data urls. (More pages could be requested.)
# By default, there are 20 tweets per page for favorites and the home timeline
num_pages = 5
data = {}
for name, url in data_urls.items():
data[name] = []
for page in range(1,num_pages+1):
result = client.make_request(url=url, token=user_info['token'], secret=user_info['secret'], additional_params={'page' : page})
if result.status_code == 200:
data[name] += json.loads(result.content)
else:
# Could do any number of useful things to actually handle this error
logging.error(("Expected 200 response but received %d for request " + url) % (result.status_code, page,))
# Split out the text of the tweets, remove some leading/trailing punctuation, and filter
# common stopwords
terms = [
self._cleanupTerm(term.lower())
for tweet in data['favorites_timeline']
for term in tweet['text'].split()
if self._cleanupTerm(term.lower()) not in self._getStopwords()
]
# Build a frequency map and sort by value
freqs = {}
for term in terms:
freqs[term] = freqs.get(term, 0) + 1
sorted_terms = sorted(freqs.iteritems(), key=operator.itemgetter(1), reverse=True)
# Iterate through each tweet in the home_timeline and assign a relevance score based upon
# the ratio of how many of the top N frequent terms from the favorities appeared in the tweet
n = 200
top_n_terms = set([term for (term, freq) in sorted_terms[:n]])
# Useful for gaining intuition into how the trivial algorithm works
logging.info("\n\nTOP N TERMS FROM FAVORITES:")
logging.info(top_n_terms)
logging.info("\n\n")
for tweet in data['home_timeline']:
tweet_terms = set([ self._cleanupTerm(term.lower())
for term in tweet['text'].split()
if self._cleanupTerm(term.lower()) not in self._getStopwords()
])
num_frequent_terms = len(tweet_terms.intersection(top_n_terms))
tweet['relevance'] = 1.0*num_frequent_terms/len(tweet_terms)
# You could optionally do any number of other things like normalize tweet scores at this point,
# boost relevance scores based upon additional criteria, throw in a random amount of serendipity
# into scores, etc. We'll just be boring and filter out any tweet with a relevance greater than 0.0
# so that only tweets with a relevance of 0.0 or higher are returned in the final response
# The sky is the limit
user_info['relevant_tweets'] = [tweet for tweet in data['home_timeline'] if tweet['relevance'] > 0]
# For purposes of not frustrating users of this sample code who don't have any favorites (and would
# hence not have any "relevant tweets", check to make sure at least one relevant tweet exists and
# if it doesn't, just go ahead and assign all tweets as relevant since we have no information to
# otherwise make a decision
if len(user_info['relevant_tweets']) == 0:
user_info['relevant_tweets'] = data['home_timeline']
# Store the ranked tweets as to user_info as "relevant_tweets" and
# stash the latest results from relevance algorithm so the client app can grab them
# from a subsequent request to /data
memcache.set(sid, user_info, time=60*10) # seconds
db.put(user)
# Redirect to a mobile client application that will use sid to make a request for the
# tweets we just filtered and stashed away
return self.redirect('/tweetview/index.html?sid='+sid)
# If an account exists but no logins are remaining, then direct the user to ante up
# via a PayPal Express Checkout pay flow
else:
# Store the user_info so we can retrieve it in the next request
memcache.set(sid, user_info, time=60*10) # seconds
product = Product.getProduct()
template_values = {
'title' : 'Payment Required',
'msg' : 'Get unlimited access to Tweet Relevance for %s %s for a one-time charge of only $%s!' % (product['quantity'], product['units'], str(product['price'])),
'sid' : sid,
'amt' : str(product['price'])
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'checkout.html')
self.response.out.write(template.render(path, template_values))
# Serves up stashed data (which takes place in a prior request to /app). A ?refresh=true parameter could
# be built in to the /data request to charge the user for another request handle associated details if so
# desired. This /data implementation simply returns the most previously calculated data
elif mode == "data":
user_info = memcache.get(self.request.get("sid"))
self.response.headers.add_header('content-type', 'application/json', charset='utf-8')
self.response.out.write(json.dumps(user_info['relevant_tweets'], indent=2))
elif mode == "login":
return self.redirect(client.get_authorization_url())
else: # root URL context
template_values = {
'title' : 'Tweet Relevance',
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'root.html')
self.response.out.write(template.render(path, template_values))
def get(self, mode=""):
if mode == "get_ec_details":
response = EC.get_express_checkout_details(self.request.get("token"))
if response.status_code != 200:
logging.error("Failure for GetExpressCheckoutDetails")
template_values = {
'title' : 'Error',
'operation' : 'GetExpressCheckoutDetails'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unknown_error.html')
return self.response.out.write(template.render(path, template_values))
product = Product.getProduct()
parsed_qs = cgi.parse_qs(response.content)
template_values = {
'title' : 'Confirm Purchase',
'quantity' : product['quantity'],
'units' : product['units'],
'email' : parsed_qs['EMAIL'][0],
'amount' : parsed_qs['PAYMENTREQUEST_0_AMT'][0],
'query_string_params' : self.request.query_string
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'confirm_purchase.html')
self.response.out.write(template.render(path, template_values))
elif mode == "do_ec_payment":
if memcache.get(self.request.get("sid")) is not None: # Without an account reference, we can't credit the purchase
payerid = self.request.get("PayerID")
product = Product.getProduct()
nvp_params = {
'PAYERID' : payerid,
'PAYMENTREQUEST_0_AMT' : str(product['price'])
}
response = EC.do_express_checkout_payment(
self.request.get("token"),
nvp_params
)
if response.status_code != 200:
logging.error("Failure for DoExpressCheckoutPayment")
template_values = {
'title' : 'Error',
'operation' : 'DoExpressCheckoutPayment'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unknown_error.html')
return self.response.out.write(template.render(path, template_values))
# Ensure that the payment was successful
parsed_qs = cgi.parse_qs(response.content)
if parsed_qs['ACK'][0] != 'Success':
logging.error("Unsuccessful DoExpressCheckoutPayment")
template_values = {
'title' : 'Error',
'details' : parsed_qs['L_LONGMESSAGE0'][0]
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unsuccessful_payment.html')
return self.response.out.write(template.render(path, template_values))
if parsed_qs['PAYMENTINFO_0_PAYMENTSTATUS'][0] != 'Completed': # Probably an eCheck
logging.error("Unsuccessful DoExpressCheckoutPayment")
logging.error(parsed_qs)
template_values = {
'title' : 'Error',
'details' : 'Sorry, eChecks are not accepted. Please send an instant payment.'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unsuccessful_payment.html')
return self.response.out.write(template.render(path, template_values))
# Credit the user's account
user_info = memcache.get(self.request.get("sid"))
twitter_username = user_info['username']
product = Product.getProduct()
AppHandler.creditUserAccount(twitter_username, product['quantity'])
template_values = {
'title' : 'Successful Payment',
'quantity' : product['quantity'],
'units' : product['units']
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'successful_payment.html')
self.response.out.write(template.render(path, template_values))
else:
logging.error("Invalid/expired session in /do_ec_payment")
template_values = {
'title' : 'Session Expired',
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'session_expired.html')
self.response.out.write(template.render(path, template_values))
elif mode == "cancel_ec":
template_values = {
'title' : 'Cancel Purchase',
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'cancel_purchase.html')
self.response.out.write(template.render(path, template_values))
def loadAllProducts():
jsonProducts = json.loads('{"latest": [{"kids": "1", "name": "Nike - Spilletr\u00f8je Classic III B\u00f8rn R\u00f8d/Hvid", "sizes": "140-152 cm/Boys M,152-158 cm/Boys L,158-170 cm/Boys XL", "url": "http://www.unisport.dk/fodboldudstyr/nike-spilletroje-classic-iii-born-rodhvid/50626/", "free_porto": "0", "price": "134,00", "package": "0", "delivery": "5-14 dage", "kid_adult": "0", "price_old": "179,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/50626_mellem.jpg", "id": "50626", "women": "0"}, {"kids": "1", "name": "Puma - Spilletr\u00f8je Vencida Bl\u00e5 B\u00f8rn TILBUD", "sizes": "YXS/116 cm,YM/140 cm,YXL/164 cm", "url": "http://www.unisport.dk/fodboldudstyr/puma-spilletroje-vencida-bla-born-tilbud/59954/", "free_porto": "0", "price": "99,00", "package": "0", "delivery": "1-2 dage", "kid_adult": "0", "price_old": "199,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/59954_mellem.jpg", "id": "59954", "women": "0"}, {"kids": "1", "name": "Puma - Spilletr\u00f8je Vencida Hvid/Bl\u00e5 B\u00f8rn TILBUD", "sizes": "YXS/116 cm,YM/140 cm,YXL/164 cm", "url": "http://www.unisport.dk/fodboldudstyr/puma-spilletroje-vencida-hvidbla-born-tilbud/59961/", "free_porto": "0", "price": "99,00", "package": "0", "delivery": "1-2 dage", "kid_adult": "0", "price_old": "199,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/59961_mellem.jpg", "id": "59961", "women": "0"}, {"kids": "1", "name": "Puma - Shorts Vencida II Bl\u00e5 B\u00f8rn TILBUD", "sizes": "YXS/116 cm,YXL/164 cm", "url": "http://www.unisport.dk/fodboldudstyr/puma-shorts-vencida-ii-bla-born-tilbud/59972/", "free_porto": "0", "price": "79,00", "package": "0", "delivery": "1-2 dage", "kid_adult": "0", "price_old": "159,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/59972_mellem.jpg", "id": "59972", "women": "0"}, {"kids": "1", "name": "Adidas - F10 AdiZero FG Bl\u00e5/Lilla/Hvid B\u00f8rn ", "sizes": "EU 32,EU 33,EU 36/UK 3\u00bd,EU 36\u2154/UK 4,EU 37\u2153/UK 4\u00bd,EU 38/UK 5,EU 38\u2154/UK 5\u00bd", "url": "http://www.unisport.dk/fodboldstoevler/adidas-f10-adizero-fg-blalillahvid-born/95763/", "free_porto": "0", "price": "199,00", "package": "0", "delivery": "1-2 dage", "kid_adult": "0", "price_old": "399,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/95763_mellem.jpg", "id": "95763", "women": "0"}, {"kids": "1", "name": "Macron - Spilles\u00e6t Raven Hvid/Sort B\u00f8rn", "sizes": "140/2XS,152/X-Small", "url": "http://www.unisport.dk/fodboldudstyr/macron-spillesaet-raven-hvidsort-born/65458/", "free_porto": "0", "price": "199,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "0", "price_old": "349,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/65458_mellem.jpg", "id": "65458", "women": "0"}, {"kids": "1", "name": "Macron - Spilles\u00e6t Trend Bordeaux/Hvid B\u00f8rn", "sizes": "116/3XS,140/2XS,152/X-Small", "url": "http://www.unisport.dk/fodboldudstyr/macron-spillesaet-trend-bordeauxhvid-born/65478/", "free_porto": "0", "price": "229,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "0", "price_old": "349,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/65478_mellem.jpg", "id": "65478", "women": "0"}, {"kids": "1", "name": "Macron - Spilles\u00e6t Trend R\u00f8d/Sort B\u00f8rn", "sizes": "116/3XS,140/2XS,152/X-Small", "url": "http://www.unisport.dk/fodboldudstyr/macron-spillesaet-trend-rodsort-born/65480/", "free_porto": "0", "price": "229,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "0", "price_old": "349,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/65480_mellem.jpg", "id": "65480", "women": "0"}, {"kids": "1", "name": "Macron - Spilles\u00e6t Trend Navy/R\u00f8d B\u00f8rn", "sizes": "116/3XS,140/2XS,152/X-Small", "url": "http://www.unisport.dk/fodboldudstyr/macron-spillesaet-trend-marinerod-born/65481/", "free_porto": "0", "price": "229,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "0", "price_old": "299,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/65481_mellem.jpg", "id": "65481", "women": "0"}, {"kids": "0", "name": "Italien - Track Top 70 Italia Copa", "sizes": "Small,Medium,Large,X-Large,XX-Large", "url": "http://www.unisport.dk/fodboldtroejer/italien-track-top-70-italia-copa/24421/", "free_porto": "0", "price": "599,00", "package": "0", "delivery": "5-10 dage", "kid_adult": "0", "price_old": "599,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/24421_mellem.jpg", "id": "24421", "women": "0"}, {"kids": "0", "name": "Puma - King Top DI FG ", "sizes": "EU 38/UK 5,EU 38\u00bd/UK 5\u00bd,EU 39/UK 6,EU 40/UK 6\u00bd,EU 40\u00bd/UK 7,EU 41/UK 7\u00bd,EU 42/UK 8,EU 42\u00bd/UK 8\u00bd,EU 43/UK 9,EU 44/UK 9\u00bd,EU 44\u00bd/UK 10,EU 45/UK 10\u00bd,EU 46/UK 11,EU 46\u00bd/UK 11\u00bd", "url": "http://www.unisport.dk/fodboldstoevler/puma-king-top-di-fg/26487/", "free_porto": "0", "price": "699,00", "package": "0", "delivery": "1-2 dage", "kid_adult": "0", "price_old": "999,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/26487_mellem.jpg", "id": "26487", "women": "0"}, {"kids": "0", "name": "Sells - M\u00e5lmandsbukser Supreme", "sizes": "X-Large", "url": "http://www.unisport.dk/maalmandshandsker/sells-malmandsbukser-supreme/28683/", "free_porto": "0", "price": "299,00", "package": "0", "delivery": "1-2 dage", "kid_adult": "0", "price_old": "349,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/28683_mellem.jpg", "id": "28683", "women": "0"}, {"kids": "0", "name": "Nike - Vest 10 stk Gr\u00f8n", "sizes": "Small/Medium,Large/X-Large", "url": "http://www.unisport.dk/fodboldudstyr/nike-vest-10-stk-gron/45357/", "free_porto": "0", "price": "679,00", "package": "0", "delivery": "5-14 dage", "kid_adult": "0", "price_old": "799,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/45357_mellem.jpg", "id": "45357", "women": "0"}, {"kids": "0", "name": "Hummel - Polo Corporate Basic Hvid", "sizes": "X-Small,Large,X-Large", "url": "http://www.unisport.dk/fodboldudstyr/hummel-polo-corporate-basic-hvid/48286/", "free_porto": "0", "price": "129,00", "package": "0", "delivery": "5-10 dage", "kid_adult": "0", "price_old": "299,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/48286_mellem.jpg", "id": "48286", "women": "0"}, {"kids": "1", "name": "Nike - Spilletr\u00f8je Classic III B\u00f8rn R\u00f8d/Hvid", "sizes": "140-152 cm/Boys M,152-158 cm/Boys L,158-170 cm/Boys XL", "url": "http://www.unisport.dk/fodboldudstyr/nike-spilletroje-classic-iii-born-rodhvid/50626/", "free_porto": "0", "price": "134,00", "package": "0", "delivery": "5-14 dage", "kid_adult": "0", "price_old": "179,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/50626_mellem.jpg", "id": "50626", "women": "0"}, {"kids": "0", "name": "Select - Fodboldstr\u00f8mper Italia Sort", "sizes": "28-32,33-36,37-41,42-47", "url": "http://www.unisport.dk/fodboldudstyr/select-fodboldstromper-italia-sort/51126/", "free_porto": "0", "price": "59,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "1", "price_old": "69,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/51126_mellem.jpg", "id": "51126", "women": "0"}, {"kids": "0", "name": "Select - Fodboldstr\u00f8mper Italia Hvid", "sizes": "28-32,33-36,37-41,42-47", "url": "http://www.unisport.dk/fodboldudstyr/select-fodboldstromper-italia-hvid/51127/", "free_porto": "0", "price": "59,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "1", "price_old": "69,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/51127_mellem.jpg", "id": "51127", "women": "0"}, {"kids": "0", "name": "Select - Fodboldstr\u00f8mper Italia Bl\u00e5", "sizes": "28-32,33-36,37-41,42-47", "url": "http://www.unisport.dk/fodboldudstyr/select-fodboldstromper-italia-bla/51128/", "free_porto": "0", "price": "59,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "1", "price_old": "69,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/51128_mellem.jpg", "id": "51128", "women": "0"}, {"kids": "0", "name": "Select - Fodboldstr\u00f8mper Italia Gr\u00f8n", "sizes": "28-32,33-36,37-41,42-47", "url": "http://www.unisport.dk/fodboldudstyr/select-fodboldstromper-italia-gron/51129/", "free_porto": "0", "price": "59,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "1", "price_old": "69,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/51129_mellem.jpg", "id": "51129", "women": "0"}, {"kids": "0", "name": "Select - Fodboldstr\u00f8mper Italia Lysebl\u00e5", "sizes": "28-32,33-36,37-41,42-47", "url": "http://www.unisport.dk/fodboldudstyr/select-fodboldstromper-italia-lysebla/51130/", "free_porto": "0", "price": "59,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "1", "price_old": "69,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/51130_mellem.jpg", "id": "51130", "women": "0"}, {"kids": "0", "name": "Select - Fodboldstr\u00f8mper Italia Navy", "sizes": "28-32,33-36,37-41,42-47", "url": "http://www.unisport.dk/fodboldudstyr/select-fodboldstromper-italia-navy/51131/", "free_porto": "0", "price": "59,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "1", "price_old": "69,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/51131_mellem.jpg", "id": "51131", "women": "0"}, {"kids": "0", "name": "Select - Fodboldstr\u00f8mper Italia R\u00f8d", "sizes": "28-32,33-36,37-41,42-47", "url": "http://www.unisport.dk/fodboldudstyr/select-fodboldstromper-italia-rod/51132/", "free_porto": "0", "price": "59,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "1", "price_old": "69,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/51132_mellem.jpg", "id": "51132", "women": "0"}, {"kids": "0", "name": "Select - Fodboldstr\u00f8mper Italia Bl\u00e5/hvid", "sizes": "28-32,33-36,37-41", "url": "http://www.unisport.dk/fodboldudstyr/select-fodboldstromper-italia-blahvid/51134/", "free_porto": "0", "price": "59,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "1", "price_old": "69,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/51134_mellem.jpg", "id": "51134", "women": "0"}, {"kids": "0", "name": "Adidas - Spezial Navy/Lysebl\u00e5", "sizes": "EU 36\u2154/UK 4,EU 38/UK 5,EU 38\u2154/UK 5\u00bd,EU 40/UK 6\u00bd,EU 40\u2154/UK 7,EU 41\u2153/UK 7\u00bd,EU 42\u2154/UK 8\u00bd,EU 43\u2153/UK 9,EU 44/UK 9\u00bd,EU 44\u2154/UK 10,EU 46/UK 11,EU 47\u2153/UK 12", "url": "http://www.unisport.dk/fodboldstoevler/adidas-spezial-navylysebla/52041/", "free_porto": "0", "price": "509,00", "package": "0", "delivery": "1-2 dage", "kid_adult": "1", "price_old": "599,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/52041_mellem.jpg", "id": "52041", "women": "0"}, {"kids": "0", "name": "Macron - Spilles\u00e6t Raven Hvid/Sort", "sizes": "Small,Medium", "url": "http://www.unisport.dk/fodboldudstyr/macron-spillesaet-raven-hvidsort/65457/", "free_porto": "0", "price": "199,00", "package": "0", "delivery": "4-8 dage", "kid_adult": "0", "price_old": "349,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/65457_mellem.jpg", "id": "65457", "women": "0"}, {"kids": "0", "name": "Danmark - H\u00f8j Hat", "sizes": "One Size Adult", "url": "http://www.unisport.dk/fodboldtroejer/danmark-hoj-hat/54834/", "free_porto": "0", "price": "49,00", "package": "0", "delivery": "1-2 dage", "kid_adult": "0", "price_old": "0,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/54834_mellem.jpg", "id": "54834", "women": "0"}, {"kids": "0", "name": "Nike - Shorts Woven Dame R\u00f8d", "sizes": "X-Small,Small,Large,X-Large", "url": "http://www.unisport.dk/fodboldudstyr/nike-shorts-woven-dame-rod/57508/", "free_porto": "0", "price": "149,00", "package": "0", "delivery": "5-14 dage", "kid_adult": "0", "price_old": "199,00", "img_url": "http://s3-eu-west-1.amazonaws.com/product-img/57508_mellem.jpg", "id": "57508", "women": "1"}]}')
products = []
for jsonProduct in jsonProducts['latest']:
product = Product()
product.name = toAscii(jsonProduct['name'])
product.kids = int(jsonProduct['kids'])
product.price = toFloatDkInput(jsonProduct['price'])
product.sizes = toAscii(jsonProduct['sizes'])
product.url = toAscii(jsonProduct['url'])
product.free_porto = int(jsonProduct['free_porto'])
product.package = toAscii(jsonProduct['package'])
product.delivery = toAscii(jsonProduct['delivery'])
product.kid_adult = int(jsonProduct['kid_adult'])
product.price_old = toFloatDkInput(jsonProduct['price_old'])
product.img_url = toAscii(jsonProduct['img_url'])
product.id = int(jsonProduct['id'])
product.women = int(jsonProduct['women'])
products.append(product)
return products
def get(self, mode=""):
if mode == "do_ec_payment":
if memcache.get(self.request.get("sid")) is not None: # Without an account reference, we can't credit the purchase
payerid = self.request.get("PayerID")
product = Product.getProduct()
nvp_params = {
'PAYERID' : payerid,
'L_PAYMENTREQUEST_0_NAME0' : str(product['quantity']) + ' ' + product['units'],
'L_PAYMENTREQUEST_0_AMT0' : str(product['price']),
'L_PAYMENTREQUEST_0_QTY0' : 1,
'L_PAYMENTREQUEST_0_ITEMCATEGORY0' : 'Digital',
'PAYMENTREQUEST_0_AMT' : str(product['price'])
}
response = EC.do_express_checkout_payment(
self.request.get("token"),
nvp_params
)
if response.status_code != 200:
logging.error("Failure for DoExpressCheckoutPayment")
template_values = {
'title' : 'Error',
'operation' : 'DoExpressCheckoutPayment'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unknown_error.html')
return self.response.out.write(template.render(path, template_values))
# Ensure that the payment was successful
parsed_qs = cgi.parse_qs(response.content)
if parsed_qs['ACK'][0] != 'Success':
logging.error("Unsuccessful DoExpressCheckoutPayment")
template_values = {
'title' : 'Error',
'details' : parsed_qs['L_LONGMESSAGE0'][0]
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unsuccessful_payment.html')
return self.response.out.write(template.render(path, template_values))
if parsed_qs['PAYMENTINFO_0_PAYMENTSTATUS'][0] != 'Completed':
logging.error("Unsuccessful DoExpressCheckoutPayment")
logging.error(parsed_qs)
template_values = {
'title' : 'Error',
'details' : 'Sorry, but there was an unexpected problem processing your payment.'
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'unsuccessful_payment.html')
return self.response.out.write(template.render(path, template_values))
# Credit the user's account
user_info = memcache.get(self.request.get("sid"))
twitter_username = user_info['username']
product = Product.getProduct()
AppHandler.creditUserAccount(twitter_username, product['quantity'])
template_values = {
'title' : 'Successful Payment',
'quantity' : product['quantity'],
'units' : product['units']
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'successful_payment.html')
self.response.out.write(template.render(path, template_values))
else:
logging.error("Invalid/expired session in /do_ec_payment")
template_values = {
'title' : 'Session Expired',
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'session_expired.html')
self.response.out.write(template.render(path, template_values))
elif mode == "cancel_ec":
template_values = {
'title' : 'Cancel Purchase',
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates', 'cancel_purchase.html')
self.response.out.write(template.render(path, template_values))
def post(self, mode=""):
if mode == "do_direct_payment":
# To be on the safe side, filter through a pre-defined list of fields
# to pass through to DoDirectPayment. i.e. prevent the client from
# potentially overriding IPADDRESS, AMT, etc.
valid_fields = [
"FIRSTNAME",
"LASTNAME",
"STREET",
"CITY",
"STATE",
"ZIP",
"COUNTRYCODE",
"CREDITCARDTYPE",
"ACCT",
"EXPDATE",
"CVV2",
]
product = Product.getProduct()
nvp_params = {"AMT": str(product["price"]), "IPADDRESS": self.request.remote_addr}
for field in valid_fields:
nvp_params[field] = self.request.get(field)
response = DP.do_direct_payment(nvp_params)
if response.status_code != 200:
logging.error("Failure for DoDirectPayment")
template_values = {"title": "Error", "operation": "DoDirectPayment"}
path = os.path.join(os.path.dirname(__file__), "..", "templates", "unknown_error.html")
return self.response.out.write(template.render(path, template_values))
# Ensure that the payment was successful
parsed_qs = cgi.parse_qs(response.content)
if parsed_qs["ACK"][0] != "Success":
logging.error("Unsuccessful DoDirectPayment")
template_values = {"title": "Error", "details": parsed_qs["L_LONGMESSAGE0"][0]}
path = os.path.join(os.path.dirname(__file__), "..", "templates", "unsuccessful_payment.html")
return self.response.out.write(template.render(path, template_values))
# Credit the user's account
user_info = memcache.get(self.request.get("sid"))
twitter_username = user_info["username"]
product = Product.getProduct()
AppHandler.creditUserAccount(twitter_username, product["quantity"])
template_values = {
"title": "Successful Payment",
"quantity": product["quantity"],
"units": product["units"],
}
path = os.path.join(os.path.dirname(__file__), "..", "templates", "successful_payment.html")
self.response.out.write(template.render(path, template_values))
else:
logging.error("Unknown mode for POST request!")
