class Orders(db.Document):
# contact info
order_number = db.IntField()
name = db.StringField(maxlength=255)
phone_number = db.StringField(maxlength=10)
# cake info
cake_info = db.ListField()
cake_size = db.StringField(maxlength=255)
price = db.IntField()
flavor_1 = db.StringField(maxlength=255)
flavor_2 = db.StringField(maxlength=255)
filling = db.StringField(maxlength=255)
sales_category = db.StringField(maxlength=255, default="cake")
# delivery info
date_time = db.DateTimeField(default=datetime.utcnow())
# decoration info
decoration = db.StringField(maxlength=255)
print_out = db.BooleanField(default=False)
celebrated_name = db.StringField(maxlength=255)
celebrated_age = db.IntField()
celebrated_text = db.StringField(maxlength=255)
def __repr__(self):
return "<MongoEngine Document: Orders :: New Cake Order>"
class Customer(db.Document):
cid = db.IntField(unique=True)
email = db.StringField(max_length=255, unique=True)
password = db.StringField(max_length=500)
first_name = db.StringField(max_length=100)
last_name = db.StringField(max_length=100)
contact_no = db.IntField(min_value=1000000000, max_value=9999999999)
address = db.StringField(max_length=500)
created_on = db.DateTimeField()
modified_on = db.DateTimeField()
latest_transaction_cost = db.IntField()
driving_licence_link = db.URLField()
QR_CODE_DATA = db.StringField(max_length=200)
vehicles = db.ListField(
db.ReferenceField(Vehicle, dbref=False, reverse_delete_rule=NULLIFY))
transactions = db.ListField(
db.ReferenceField(Transaction,
dbref=False,
reverse_delete_rule=NULLIFY))
def __unicode__(self):
return str(self.cid)
def get_dict(self):
return {
'cid': self.cid,
'first_name': self.first_name,
'last_name': self.last_name,
'contact_no': self.contact_no,
'address': self.address,
'latest_transaction_cost': latest_transaction_cost,
'driving_licence_link': self.driving_licence_link
}
def __repr__(self):
return 'cid ' + str(self.cid)
def save(self, *args, **kwargs):
if self.cid == None:
try:
self.cid = self.__class__.objects.order_by('-cid')[0].cid + 1
except IndexError:
self.cid = Customer.objects.count() + 1
if not self.created_on:
self.created_on = datetime.now()
self.modified_on = datetime.now()
self.password = hashlib.sha1(self.password).hexdigest()
if not self.QR_CODE_DATA:
self.QR_CODE_DATA = hashlib.sha1(
str(self.cid) + str(self.created_on)).hexdigest()
super(Customer, self).save(*args, **kwargs)
class Vehicle(db.Document):
vid = db.IntField(unique=True)
vehicle_type = db.StringField(choices=VEHICLES)
vehicle_number = db.StringField()
vehicle_rc_link = db.URLField()
def __unicode__(self):
return str(self.vehicle_type) + ": " + str(self.vehicle_number)
def get_dict(self):
return {
'vid': self.vid,
'vehicle_type': self.vehicle_type,
'vehicle_number': self.vehicle_number,
'vehicle_rc_link': self.vehicle_rc_link
}
def __repr__(self):
return 'vehicle_type ' + str(
self.vehicle_type) + 'vehicle_number ' + str(self.vehicle_number)
def save(self, *args, **kwargs):
if self.vid == None:
try:
self.vid = self.__class__.objects.order_by('-vid')[0].vid + 1
except IndexError:
self.vid = Vehicle.objects.count() + 1
super(Vehicle, self).save(*args, **kwargs)
class Coupon(db.Document):
coupon_id = db.IntField(unique=True)
coupon_code = db.StringField(max_length=30, unique=True)
amount = db.StringField(max_length=100)
is_valid = db.BooleanField()
QR_CODE_DATA = db.StringField(max_length=200)
created_on = db.DateTimeField()
modified_on = db.DateTimeField()
def __unicode__(self):
return str(self.coupon_id)
def get_dict(self):
return {
'coupon_id': self.coupon_id,
'coupon_code': self.coupon_code,
'amount': self.amount,
'is_valid': self.is_valid,
'QR_CODE_DATA': self.QR_CODE_DATA
}
def __repr__(self):
return 'coupon_code ' + str(self.coupon_code)
def save(self, *args, **kwargs):
if self.coupon_id == None:
try:
self.coupon_id = self.__class__.objects.order_by(
'-coupon_id')[0].coupon_id + 1
except IndexError:
self.coupon_id = Coupon.objects.count() + 1
if not self.created_on:
self.created_on = datetime.now()
self.modified_on = datetime.now()
super(Coupon, self).save(*args, **kwargs)
class ParkingLot(db.Document):
pid = db.IntField(unique=True)
parking_lot_name = db.StringField(max_length=100)
cost = db.ReferenceField(Cost, dbref=False)
two_wheeler_capacity = db.IntField()
four_wheeler_capacity = db.IntField()
heavy_vehicle_capacity = db.IntField()
current_two_wheeler = db.IntField(default=0)
current_four_wheeler = db.IntField(default=0)
current_heavy_vehicle = db.IntField(default=0)
transactions = db.ListField(
db.ReferenceField(Transaction,
dbref=False,
reverse_delete_rule=NULLIFY))
def __str__(self):
return "Parking: {} two_wheeler :{}, four_wheeler: {}, heavy_vehicle: {}".format(
self.parking_lot_name, self.cost.two_wheeler,
self.cost.four_wheeler, self.cost.heavy_vehicle)
def get_dict(self):
return {
'pid': self.pid,
'parking_lot_name': self.parking_lot_name,
'transactions': self.transactions
}
def save(self, *args, **kwargs):
if self.pid == None:
try:
self.pid = self.__class__.objects.order_by('-pid')[0].pid + 1
except IndexError:
self.pid = ParkingLot.objects.count() + 1
super(ParkingLot, self).save(*args, **kwargs)
class Cost(db.Document):
# pid = db.ReferenceField(, dbref=False)
parking_lot_name = db.StringField()
two_wheeler = db.IntField()
four_wheeler = db.IntField()
heavy_vehicle = db.IntField()
def __str__(self):
return "COST FOR two_wheeler :{}, four_wheeler: {}, heavy_vehicle: {}".format(
self.two_wheeler, self.four_wheeler, self.heavy_vehicle)
def get_dict(self):
return {
'parking_lot_name': self.parking_lot_name,
'two_wheeler': self.two_wheeler,
'four_wheeler': self.four_wheeler,
'heavy_vehicle': self.heavy_vehicle
}
class TTY(db.Document):
template = db.StringField(required=True)
username = db.StringField(required=True)
uri = db.DictField(required=True)
readme = db.StringField(required=True)
created = db.DateTimeField(default=datetime.now)
destroyed = db.DateTimeField()
ttl = db.IntField(default=604800) #7 days
active = db.BooleanField(default=True)
dry_run = db.BooleanField(default=False)
class Transaction(db.Document):
cost = db.ReferenceField(Cost, dbref=False)
pid = db.IntField()
QR_CODE_DATA = db.StringField()
total_cost = db.IntField()
entry_time_stamp = db.DateTimeField()
exit_time_stamp = db.DateTimeField()
active = db.BooleanField(default=False)
def __str__(self):
return "total_cost: {}, cost: {}, entry: {}, exit: {}".format(
self.total_cost, self.cost, self.entry_time_stamp,
self.exit_time_stamp)
def get_dict(self):
return {
'total_cost': self.total_cost,
'entry_time_stamp': self.entry_time_stamp,
'exit_time_stamp': self.exit_time_stamp,
'pid': self.pid
}
class FoodCost(db.Document):
category = db.StringField(maxlength=255)
menu_item = db.StringField(maxlength=255)
url = db.StringField(maxlength=255)
created_on_date = db.StringField(maxlength=255)
last_updated_on = db.StringField(maxlength=255)
portions_size = db.StringField(maxlength=255)
cost_per_portion = db.DecimalField(precision=2)
sales_price = db.DecimalField(precision=2)
food_cost_percent = db.StringField()
recipe_quantity = db.IntField()
total_recipe_cost = db.DecimalField(precision=2)
total_gross_sales = db.DecimalField(precision=2)
ingredients = db.ListField(db.DictField(db.ReferenceField(Ingredient)))
def __repr__(self):
return "<MongoEngine Document: FoodCost>"
class Event(db.Document):
query_class = EventQuery
tag = db.StringField()
name = db.StringField()
description = db.StringField()
venue = db.DocumentField(Venue)
time = db.StringField()
date = db.StringField()
image = db.StringField()
owner = db.DocumentField(User)
visibility = db.DocumentField(Visibility)
gests = db.ListField(db.StringField())
requirement = db.ListField(db.DocumentField(Requirement))
capacity = db.IntField()
def hasAccess(self, user):
log.info(
"Verificar acceso del Usuario: {'%s'} al Evento con: {'tag':'%s'}"
% (user, self.tag))
return self.visibility.isPublic() or (
user is not None
and self.owner == user) or user.username in self.gests
def hasAvailability(self):
return self.availability() > 0
def availability(self):
log.info("Calcular la disponibilidad del Evento con: {'tag':'%s'}" %
self.tag)
return self.capacity - Assistance.query.get_amount_by_event(self.tag)
def lackRequirements(self):
log.info(
"Suma todos los requisitos que los usuarios se comprometieron a llevar al evento."
)
lack = []
requirements = Assistance.query.get_requirements_by_event_tag(self.tag)
keyfunc = lambda r: r.name
for req in requirements:
req.quantity = -req.quantity
requirements += self.requirement
requirements.sort(key=keyfunc)
for name, reqs in groupby(requirements, key=keyfunc):
lack.append(
Requirement(name=name,
quantity=sum(req.quantity for req in reqs)))
return lack
def addGest(self, user):
self.gests.append(user.username)
def addGests(self, users):
self.gests.extend(map(lambda user: user.username))
def getAppearanceAssistance(self):
appearance = AssistanceEvent(tag=self.tag,
name=self.name,
venue=self.venue.name,
time=self.time,
date=self.date,
image=self.image)
return appearance
class Requirement(db.Document):
name = db.StringField()
quantity = db.IntField()
def __repr__(self):
return "{0}:{1}".format(self.name, self.quantity)
class Global(db.Document):
count = db.IntField()
message = db.StringField()
def __repr__(self):
return "<MongoEngine Document: Global :: Order Number Counter>"
class Task(db.Document):
description = db.StringField()
order = db.IntField()
done = db.BoolField(default=False)
class Location(db.EmbeddedDocument):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
x = db.IntField(required=True)
y = db.IntField(required=True)
width = db.IntField(required=True)
height = db.IntField(required=True)
