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 Command(db.EmbeddedDocument, Executable):
NAVIGATE = "Navigate"
CLICK = "Click"
SENDKEYS = "SendKeys"
VERIFY = "Verify"
COMMANDS = (NAVIGATE, CLICK, SENDKEYS, VERIFY)
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
command = db.StringField(required=True, choices=COMMANDS)
element = db.ReferenceField(ElementState, required=False)
config_key = db.StringField(required=False)
execution_results = []
def get_steps(self):
return self
execution_results = []
def execute(self, driver, config):
try:
if self.config_key == None:
self.param = ""
else:
if self.config_key in config.params:
self.param = config.params[self.config_key]
else:
raise Exception(
"Cannot execute command %s as there was no key named %s in the config params"
% (self.command, self.config_key))
self.driver = driver
result = Result(passed=True,
message="Execute %s %s" %
(self.__repr__(), self.param))
logging.debug("Execute : %s %s" % (self.__repr__(), self.param))
if self.command == self.NAVIGATE:
self.driver.get(self.param)
elif self.command == self.CLICK:
WebElement(self.driver, self.element.locators).click()
elif self.command == self.SENDKEYS:
WebElement(self.driver,
self.element.locators).send_keys(self.param)
elif self.command == self.VERIFY:
WebElement(self.driver, self.element.locators).highlight()
else:
raise ValueError("Command not supported: %s" % self.command)
except Exception as e:
logging.debug("Exception : %s" % str(e))
result = Result(passed=False,
message="Command raised an exception %s" % str(e),
exception=str(e))
finally:
self.execution_results.append(result)
return result
def __repr__(self):
return "Command(%s %s %s)" % (str(self.command), str(
self.element), self.param)
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 Result(db.EmbeddedDocument):
total_indents = 0
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
passed = db.BooleanField(required=True)
message = db.StringField(required=True)
exception = db.StringField(max_length=255, required=False)
step_results = db.ListField(db.EmbeddedDocumentField('self'))
failed_state = db.ReferenceField('State', required=False)
actual_state = db.ReferenceField('State', required=False)
html = db.StringField(required=False)
screenshot = db.StringField(required=False)
def __str__(self):
Result.total_indents += 1
message = "Executable Passed=%s %s \r\n" % (self.passed, self.message)
for result in self.step_results:
for indent in range(0, Result.total_indents):
message += " "
message += str(result)
Result.total_indents -= 1
return message
def __repr__(self):
return "Result(%s,%s)" % (self.passed, self.message)
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 Role(db.Document, RoleMixin):
name = db.StringField(max_length=80, unique=True)
description = db.StringField(max_length=255)
def __unicode__(self):
return self.name
def __repr__(self):
return self.name
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 Ingredient(db.Document):
ingredient = db.StringField(maxlength=225)
recipe_quantity = db.StringField(maxlength=225)
apc_unit = db.DecimalField(precision=2)
yield_ratio = db.DecimalField(precision=2)
epc_unit = db.DecimalField(precision=2)
total_cost = db.DecimalField(precision=2)
def __repr__(self):
return "<MongoEngine Document: Ingredient>"
class Post(db.Document):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
title = db.StringField(max_length=255, required=True)
body = db.StringField(required=True)
comments = db.ListField(db.EmbeddedDocumentField('Comment'))
meta = {
'allow_inheritance': True,
'indexes': ['-created_at'],
'ordering': ['-created_at']
}
class User(db.Document, UserMixin):
email = db.StringField(max_length=255)
password = db.StringField(max_length=500)
active = db.BooleanField(default=True)
confirmed_at = db.DateTimeField()
roles = db.ListField(db.ReferenceField(Role), default=[])
def save(self, *args, **kwargs):
self.password = encrypt_password(self.password)
self.confirmed_at = datetime.now()
super(User, 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 Action(db.Document, Executable):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
name = db.StringField(required=True)
start_state = db.ReferenceField("State", required=True)
end_state = db.ReferenceField("State", required=True)
steps = db.ListField(db.EmbeddedDocumentField(Command), required=False)
execution_results = []
def execute(self, driver, config):
logging.debug("Executing Action %s" % self.name)
# if not self.start_state.is_state_present(driver):
# result =Result(step_results=self.execution_results,passed=False,message="State %s not present" % self.start_state)
# result.failed_state = self.start_state
# result.actual_state = self.start_state.get_current_state(driver)
# result.actual_state.save()
# result.html = driver.html
# result.screenshot = driver.get_screenshot_as_base64()
# return result
result = Executable.execute(self, driver, config)
if not result.passed:
result.failed_state = self.start_state
result.actual_state = self.start_state.get_current_state(driver)
result.actual_state.save()
result.html = driver.html
result.screenshot = driver.get_screenshot_as_base64()
return result
class Visibility(db.Document):
query_class = VisibilityQuery
name = db.StringField()
def isPublic(self):
return self.name == 'Public'
def __repr__(self):
return self.name
class Locator(db.EmbeddedDocument):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
by = db.StringField(required=True)
value = db.StringField(required=True)
def __repr__(self):
return self.__str__()
def __str__(self):
return "(%s, %s)" % (self.by, self.value)
def __eq__(self, other):
if other is None:
return False
if self.by == other.by and self.value == other.value:
return True
else:
return False
class Page(db.Document):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
url = db.StringField(max_length=255, required=False)
default_state = db.ReferenceField(State, required=True)
states = db.ListField(db.ReferenceField(State))
meta = {
'allow_inheritance': True,
'indexes': ['-created_at'],
'ordering': ['-created_at']
}
class SuiteRun(db.Document, Executable):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
name = db.StringField(max_length=255, required=False)
suite = db.ReferenceField(Suite, required=True)
config = db.ReferenceField(SuiteConfig, required=True)
start_after = db.DateTimeField(default=datetime.datetime.now, required=True)
started_time = db.DateTimeField(default=datetime.datetime.now, required=True)
ended_time = db.DateTimeField(default=datetime.datetime.now, required=True)
status = db.StringField(max_length=25,required=True, choices=Status.ALL_STATUS)
message = db.StringField(max_length=255,required=True)
user = db.StringField(max_length=255, required=True)
suite_results = db.ListField(db.EmbeddedDocumentField(Result), required=False)
meta = {
'allow_inheritance': True,
'indexes': ['-created_at'],
'ordering': ['-created_at']
}
def execute(self, driver):
logging.debug("Executing Suite %s" % self.name)
self.driver = driver
suite_result = Result(passed=True,message="Passed",exception="Passed")
for test in self.tests:
test_result = test.execute(driver)
suite_result.step_results.append(test_result)
if not test_result.passed:
suite_result.passed = False
suite_result.message = str(self.__class__)
suite_result.exception = test_result.exception
suite_result.failed_state = test_result.failed_state
suite_result.actual_state = test_result.actual_state
suite_result.html = self.driver.page_source
suite_result.screenshot = self.driver.get_screenshot_as_base64()
self.suite_results.append(suite_result)
self.cascade_save()
return suite_result
class AssistanceEvent(db.Document):
tag = db.StringField()
name = db.StringField()
venue = db.StringField()
time = db.StringField()
date = db.StringField()
image = db.StringField()
class ElementState(db.Document):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
html = db.StringField(required=False)
locators = db.ListField(db.EmbeddedDocumentField(Locator))
screenshot = db.StringField(required=False)
location = db.EmbeddedDocumentField(Location, required=False)
type = db.StringField(required=False)
def __unicode__(self):
return self.locators
meta = {
'allow_inheritance': True,
'indexes': ['-created_at'],
'ordering': ['-created_at']
}
def __str__(self):
repr = "ElementState: "
for locator in self.locators:
repr += "{}, ".format(str(locator))
return repr
def __eq__(self, other):
if other is None:
return False
for locator in self.locators:
if locator in other.locators:
return True
return False
def __ne__(self, other):
return not self.__eq__(other)
def set_location(self, element):
self.location = Location(x=element.location['x'],
y=element.location['y'],
width=element.size['width'],
height=element.size['height'])
class User(db.Document):
username = db.StringField(maxlength=255, required=True)
password_hash = db.StringField(maxlength=255, required=True)
def __init__(self, password=None, **data):
if password is not None:
data["password_hash"] = generate_password_hash(password)
super(User, self).__init__(**data)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
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 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 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 Test(db.Document, Executable):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
name = db.StringField(max_length=255, required=False)
actions = db.ListField(db.ReferenceField(Action))
meta = {
'allow_inheritance': True,
'indexes': ['-created_at'],
'ordering': ['-created_at']
}
def execute(self, driver, config):
logging.debug("Executing Test %s" % self.name)
self.steps = self.actions
suite_results = Executable.execute(self, driver, config)
return suite_results
def get_steps(self):
return self.actions
class CrawlerTask(db.Document):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
start_after = db.DateTimeField(default=datetime.datetime.now,
required=True)
started_time = db.DateTimeField(default=datetime.datetime.now,
required=True)
ended_time = db.DateTimeField(default=datetime.datetime.now, required=True)
status = db.StringField(max_length=25,
required=True,
choices=Status.ALL_STATUS)
message = db.StringField(max_length=255, required=True)
user = db.StringField(max_length=255, required=True)
url = db.StringField(max_length=255, required=True)
default_username = db.StringField(max_length=255, required=False)
default_password = db.StringField(max_length=255, required=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 User(db.Document):
query_class = UserQuery
username = db.StringField()
password = db.StringField()
email = db.StringField()
phone = db.StringField()
firstName = db.StringField()
lastName = db.StringField()
def generate_hashed_password(self):
self.password = generate_password_hash(self.password)
def check_password(self, password):
return check_password_hash(self.password, password)
def __repr__(self):
return self.username
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 Assistance(db.Document):
query_class = AssistanceQuery
eventTag = db.StringField()
event = db.DocumentField(AssistanceEvent)
user = db.StringField()
requirements = db.ListField(db.DocumentField(Requirement))
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>"
