def _mark_sold(self, listing, item = None):
if listing.state != "sold_out":
return
if item is None:
item = db.Query(storage.Goods).filter("listing =", listing).get()
if item:
item.status = "sold"
item.sold = dt.datetime.now()
if item.shop.currency == "LVL":
item.price = round(float(item.listing.price) * 0.55789873, 2) #exchange rate usd -> lvl feb-23-2010
else:
item.price = float(item.listing.price)
item.put()
storage.Totals.add_income(item.shop,
appetsy.today(item.shop),
item.price)
self.log("Marked '%s' as sold." % item.name)
listing.sold_on = dt.datetime.now()
listing.put()
appetsy.invalidate_memcache("goods", str(item.shop.id)) #forget UI listings
def progress_box(self):
income_progress = memcache.get("income_progress",
namespace = str(self.shop.id))
plan = memcache.get("week_%s_plans" % appetsy.monday(self.shop).strftime("%U"),
namespace = str(self.shop.id))
if not income_progress or not plan:
# total income for the progress box
data = {}
totals = storage.Totals.all().filter("shop =", self.shop) \
.filter("name =", "shop_income").fetch(1000)
data["total_money"] = sum([total.total for total in totals])
monday = appetsy.monday(self.shop)
goods_week = storage.Goods.all().filter("shop =", self.shop) \
.filter("created >=", monday).fetch(100)
goods_week = [good for good in goods_week if good.status in ("in_stock", "sold")]
days = {}
plan = storage.Counters.get_or_insert("%s:week_%s_plans" % (self.shop.id, appetsy.monday(self.shop).strftime("%U")),
shop = self.shop,
name = "weeks_plan",
count = 10,
timestamp = dt.datetime.combine(appetsy.monday(self.shop), dt.time()))
planned = plan.count
for good in goods_week:
days.setdefault(good.created.weekday(), []).append(good)
day_max = max(2, max([len(goods) for goods in days.values()] or [0]))
weekday_count = max(4, max(days.keys() or [0]))
data["planned"] = planned
data["days"], data["day_max"], data["weekday_count"] = days, day_max, weekday_count
data["goods_week"] = goods_week
if planned > 0:
weekday = appetsy.today(self.shop).weekday()
data["percentage_complete"] = "%d" % (len(goods_week) / ((planned / float(max(5.0, weekday + 1))) * (weekday + 1)) * 100)
else:
data["percentage_complete"] = None
income_progress = appetsy.get_template("index/progress_box.html").render(**data)
memcache.set("income_progress", income_progress, namespace = str(self.shop.id))
return income_progress
def index(self):
"""
fan_list = memcache.get("500fans")
# TODO we are relying on index.py resetting memcache on day change here
if fan_list:
return fan_list
"""
fans = db.Query(storage.ShopFans).filter("shop =", self.shop) \
.order("-favored_on").fetch(limit=500)
fan_counter = storage.Counters.get_by_key_name("%d:fans" % self.shop.id)
if not fan_counter or not fans or fans[0].favored_on > fan_counter.timestamp:
fan_counter = self._count_fans(fan_counter)
fan_count = fan_counter.count
dates = []
for group in itertools.groupby(fans, lambda entry: appetsy.to_local_time(self.shop, entry.favored_on).date()):
fans = list(group[1])
fans.reverse()
dates.append ({"cur_date": group[0],
"fans": fans
})
#filter out expired and sold listings
data = {
"dates": dates,
"now": appetsy.time(self.shop),
"fan_count": fan_count,
"today": appetsy.today(self.shop),
"yesterday": appetsy.today(self.shop) - dt.timedelta(days=1),
}
fan_list = appetsy.get_template("etsy.html").render(**data)
memcache.set("500fans", fan_list)
return fan_list
def fans_today(self):
today = appetsy.today(self.shop) #- dt.timedelta(days=2)
if today.date() != memcache.get("today", namespace = str(self.shop.id)):
appetsy.invalidate_memcache("fans", namespace = str(self.shop.id))
page = self.request.get("page") or "persons"
fan_list = memcache.get("fan_list", namespace = str(self.shop.id))
if not fan_list: #use cache whenever
data = {}
by_fan = {}
shopfaves = storage.ShopFans.all().filter("shop =", self.shop) \
.filter("favored_on >=", today) \
.fetch(500)
itemfaves = storage.ItemFans.all().filter("shop =", self.shop) \
.filter("favored_on >=", today) \
.fetch(500)
data["shopfave_count"] = len(shopfaves)
for fave in shopfaves:
fan = dict(user_name = fave.fan.user_name,
image_url = fave.fan.image_url,
favored_on = fave.favored_on,
key = str(fave.fan.key()),
count = 0)
by_fan[fave.fan.user_name] = fan
data["itemfave_count"] = len(itemfaves)
by_listing = {}
for fave in itemfaves:
listing = dict(title = fave.listing.title,
key = str(fave.listing.key()),
image_url = fave.listing.image_url,
count = 0,
favored_on = fave.favored_on)
by_listing.setdefault(fave.listing.id, listing)
by_listing[fave.listing.id]["count"] += 1
by_listing[fave.listing.id]["favored_on"] = min(by_listing[fave.listing.id]["favored_on"],
fave.favored_on)
fan = dict(user_name = fave.fan.user_name,
image_url = fave.fan.image_url,
key = str(fave.fan.key()),
favored_on = fave.favored_on,
count = 0)
by_fan.setdefault(fave.fan.user_name, fan)
by_fan[fave.fan.user_name]["favored_on"] = min (by_fan[fave.fan.user_name]["favored_on"],
fave.favored_on)
by_fan[fave.fan.user_name]["count"] += 1
data["shopfaves"] = sorted(by_fan.values(), key = lambda x: x["favored_on"])
data["listingfaves"] = sorted(by_listing.values(), key = lambda x: x["favored_on"])
fan_list = appetsy.get_template("index/fans_today.html").render(**data)
memcache.set("fan_list", fan_list, namespace = str(self.shop.id))
memcache.set("today", today.date(), namespace = str(self.shop.id))
#lame current page hack to avoid breaking the cache
if page == "persons":
fan_list = fan_list.replace('<div id="person_box" style="display: none">', '<div id="person_box">')
else:
fan_list = fan_list.replace('<div id="item_box" style="display: none">', '<div id="item_box">')
return fan_list
def balance(self):
balance_month = self.request.get("month")
if balance_month:
this_month = dt.datetime.strptime(balance_month, "%d-%b-%Y").date()
else:
this_month = appetsy.today(self.shop).replace(day = 1).date()
# timedelta doesn't do month, so we just add maximum possible days and roll back to first one
next_month = (this_month + dt.timedelta(days=31)).replace(day=1)
balance_cache = memcache.get("balance", namespace = str(self.shop.id)) or {}
if this_month not in balance_cache:
expenses = storage.Expenses.all().filter("shop =", self.shop) \
.filter("purchase_date >=", this_month) \
.filter("purchase_date <", next_month) \
.order("purchase_date")
for expense in expenses:
expense.price = -expense.price
goods = storage.Goods.all().filter("status =", "sold") \
.filter("shop =", self.shop) \
.filter("sold >", this_month) \
.filter("sold <", next_month) \
.order("sold") \
.order("status")
moneys = []
for expense in expenses:
moneys.append({"date": expense.purchase_date,
"price": -(expense.price or 0),
"name": expense.name,
"creation_date": None,
"key": expense.key()
})
for good in goods:
moneys.append({"date": good.sold.date(),
"price": good.price or 0,
"name": good.name,
"creation_date": good.created,
"key": good.key(),
"listing": good.listing
})
moneys.sort(key = lambda x: x["date"])
dates = []
for group in itertools.groupby(moneys, lambda entry: entry["date"].month):
dates.append ({"month": group[0],
"moneys": [z for z in group[1]]
})
dates.reverse()
prev_totals = storage.Totals.all().filter("shop =", self.shop) \
.filter("name in", ["shop_income"]) \
.fetch(500)
prev_totals = appetsy.totals(prev_totals,
lambda x: x.date.date().replace(day=1),
lambda x: x.total)
balance_cache[this_month] = appetsy.get_template("expenses/index.html").render(dates = dates, prev = prev_totals)
memcache.set("balance", balance_cache, namespace = str(self.shop.id))
spotlight = self.request.get("spotlight")
balance = balance_cache[this_month]
if spotlight:
balance = balance.decode("utf-8").replace("balance_spotlight = null",
"balance_spotlight = \"%s\"" % spotlight).encode("utf-8")
return balance
def faves(self, key):
if isinstance(key, db.Model):
item = key
else:
key = db.Key(key)
if not key:
return "need key"
item = db.get(key)
data = dict(today = [], other_days = [])
data['shop'] = self.shop
today = appetsy.today(self.shop)
if item.kind() == "Fans":
faves = storage.ItemFans.all() \
.filter("fan =", item) \
.order("-favored_on").fetch(500)
for fave in faves:
fave.image_url = fave.listing.image_url
fave.str_key = fave.listing.key()
fave.user_name = ""
if appetsy.zero_timezone(fave.favored_on) >= today:
data["today"].append(fave)
else:
data["other_days"].append(fave)
shopfave = storage.ShopFans.all() \
.filter("fan =", item) \
.filter("shop =", self.shop).get()
if shopfave:
shopfave.image_url = "veikals"
shopfave.str_key = ""
shopfave.user_name = ""
if appetsy.zero_timezone(shopfave.favored_on) >= today:
data["today"].append(shopfave)
data["today"] = sorted(data["today"], key=lambda x:x.favored_on, reverse = True)
else:
data["other_days"].append(shopfave)
data["other_days"] = sorted(data["other_days"], key=lambda x:x.favored_on, reverse = True)
else:
itemfans = storage.ItemFans.all() \
.filter("listing =", item) \
.filter("shop =", item.shop) \
.order("-favored_on").fetch(500)
for item in itemfans:
fave = item.fan
fave.str_key = item.fan.key()
fave.user_name = item.fan.user_name
if appetsy.zero_timezone(item.favored_on) >= today:
data["today"].append(fave)
else:
data["other_days"].append(fave)
return appetsy.get_template("/fans/faves.html").render(**data)
