def __init__(self):
self.connODM = conection().conODM()
self.connORM = conection().conORM()
self.status = 200
self.msg = None
self.type = "text/plain"
Session = sessionmaker(bind=self.connORM)
self.session = Session()
def exec_code(self, codeName, inputs, environ):
method_class = codeName.split(".")[0]
method = codeName.split(".")[1]
self.connODM = conection().conODM()
ClsPckg = {
"general": general,
"Company": Company,
"General": General,
"login": login,
"ManContact": ManContact,
"Accounting": Accounting,
"Bills": Bills,
"Items": Items,
"Accounts": Accounts,
"WareHouse": warehouse,
"Clients": Clients,
"Recepie": Recepie,
"supplier": supplier,
"Table": Table,
"TableArea": TableArea,
"Types": Types,
"Level": LevelProc,
"Status": StatusProc,
"Categories": Categories
}
retVal = getattr(ClsPckg[method_class](), method)(inputs)
return retVal
def __init__(self, inputs):
self.connODM = conection().conODM()
self.connORM = conection().conORM()
self.status = 200
self.msg = "0"
self.type = "text/plain"
Session = sessionmaker(bind=self.connORM)
self.session = Session()
if inputs["company"] in self.endpoints:
#This just will apply to systems registred on the endpoint handle
targetCls=self.endpoints[inputs["company"]]()
retVal=getattr(targetCls, "process")(inputs)
self.msg= retVal["value"]
self.type=retVal["type"]
self.status=retVal["status"]
class main:
connORM = conection().conORM()
def __init__(self, inputs, environ):
from tools.Utilities import getNewPage
self.getPage = getNewPage
self.callObjects(inputs, environ)
def callObjects(self, inputs, environ):
self.result = ""
inputs["__documentroot__"] = environ["DOCUMENT_ROOT"]
if "md" in inputs:
self.result = {
"status": 200,
"value": self.getPage(inputs["md"], inputs,
environ).getResult(),
"type": "text/html"
}
elif "classname" in inputs and "md" not in inputs:
codeName = inputs["classname"]
inputs.pop("classname", None)
self.result = self.exec_code(codeName, inputs, environ)
def getResult(self):
return self.result
def exec_code(self, codeName, inputs, environ):
method_class = codeName.split(".")[0]
method = codeName.split(".")[1]
self.connODM = conection().conODM()
ClsPckg = {
"general": general,
"Company": Company,
"General": General,
"login": login,
"ManContact": ManContact,
"Accounting": Accounting,
"Bills": Bills,
"Items": Items,
"Accounts": Accounts,
"WareHouse": warehouse,
"Clients": Clients,
"Recepie": Recepie,
"supplier": supplier,
"Table": Table,
"TableArea": TableArea,
"Types": Types,
"Level": LevelProc,
"Status": StatusProc,
"Categories": Categories
}
retVal = getattr(ClsPckg[method_class](), method)(inputs)
return retVal
class ComapnyEarnings(Base):
metadata = MetaData()
__tablename__ = "companyearnings_reg"
__table_args__ = {"useexisting": True}
id = Column('id', BIGINT, primary_key=True)
code = Column("code", BIGINT, nullable=True)
company = Column("company", BIGINT, nullable=True)
total_earnings = Column("total_earnings", NUMERIC(20, 2), nullable=True)
_date = Column("_date", NUMERIC(20, 2), nullable=True)
company_earnings = Column("company_earnings",
NUMERIC(20, 2),
nullable=True,
default=0.00)
status = Column("status", BIGINT, nullable=True)
ComapnyEarnings_tbl = Table(__tablename__, metadata, id, code, company,
total_earnings, _date, status)
def __repr__(self):
return "<ComapnyEarnings(id='%s',code='%s',total_earnings='%s',_date='%s'," \
"comapany_earnings='%s',status='%s',company='%s')>" % \
(self.id,self.code,self.total_earnings, self._date,
self.company_earnings, self.status, self.company)
engine = conection().conORM()
metadata.create_all(engine)
engine.connect().close()
def __Publish__(self):
data = {}
for column in self.__table__.columns.keys():
value = self.__dict__[self.__table__.columns[column].name]
if self.__table__.columns[column].type == "BIGINT":
data[self.__table__.columns[column].name] = int(value)
elif self.__table__.columns[column].type == "Integer":
data[self.__table__.columns[column].name] = int(value)
elif self.__table__.columns[column].type == "NUMERIC":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type == "Decimal":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type == "time":
data[self.__table__.columns[column].name] = str(
value.strftime('%H:%M:%S'))
elif self.__table__.columns[column].type == "datetime":
data[self.__table__.columns[column].name] = str(
value.strftime('%H:%M:%S'))
else:
data[self.__table__.columns[column].name] = str(value)
return data
class productSale(Base):
metadata = MetaData()
__tablename__ = "productsale_reg"
__table_args__ = {"useexisting": True}
id = Column('id', BIGINT, primary_key=True, autoincrement=True)
prod_name = Column("prod_name", Text, nullable=False)
amount = Column("amount", NUMERIC(20,2), nullable=False)
product = Column("product", BIGINT, nullable=False)
bill = Column("bill", BIGINT, nullable=False)# Product ordered
category = Column("category", BIGINT, nullable=False)# The amount of product ordered
productSale_Tbl = Table(__tablename__, metadata, id, prod_name, amount,
product, category, bill)
def __repr__(self):
return "<decreaseItems(id='%s', prod_name='%s',amount='%s'," \
"product='%s',bill='%s',category='%s')>" % \
(self.id, self.prod_name, self.amount,
self.product,self.bill,self.category)
engine = conection().conORM()
metadata.create_all(engine)
engine.connect().close()
def __Publish__(self):
data={}
for column in self.__table__.columns.keys():
value=self.__dict__[self.__table__.columns[column].name]
if self.__table__.columns[column].type =="BIGINT":
data[self.__table__.columns[column].name]=int(value)
elif self.__table__.columns[column].type =="Integer":
data[self.__table__.columns[column].name]=int(value)
elif self.__table__.columns[column].type=="NUMERIC":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type=="Decimal":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type=="time":
data[self.__table__.columns[column].name] = str(value.strftime('%H:%M:%S'))
elif self.__table__.columns[column].type=="datetime":
data[self.__table__.columns[column].name] = str(value.strftime('%H:%M:%S'))
else:
data[self.__table__.columns[column].name] = str(value)
return data
class Level(Base):
"""The level of the type,
means the classification of any
type in the system."""
metadata = MetaData(conection().conORM())
__tablename__="level_reg"
__table_args__ = {"useexisting": True}
id = Column('id',BIGINT, primary_key=True)
level_name = Column('lvl_name',Text, nullable=False)
code = Column('code',BIGINT, nullable=False, unique=True)
level_tbl = Table(__tablename__, metadata, id, level_name,code)
def __repr__(self):
return "<level_reg(id='%s', level_name='%s', " \
"code='%s')>"%(self.id, self.level_name,
self.code)
metadata.create_all()
def __Publish__(self):
data={}
for column in self.__table__.columns.keys():
value=self.__dict__[self.__table__.columns[column].name]
if self.__table__.columns[column].type =="BIGINT":
data[self.__table__.columns[column].name]=int(value)
elif self.__table__.columns[column].type =="Integer":
data[self.__table__.columns[column].name]=int(value)
elif self.__table__.columns[column].type=="NUMERIC":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type=="Decimal":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type=="time":
data[self.__table__.columns[column].name] = str(value.strftime('%H:%M:%S'))
elif self.__table__.columns[column].type=="datetime":
data[self.__table__.columns[column].name] = str(value.strftime('%H:%M:%S'))
else:
data[self.__table__.columns[column].name] = str(value)
return data
class AccountsTbl(Base):
metadata = MetaData()
__tablename__ = "accounts_reg"
__table_args__ = {"useexisting": True}
id = Column('id', BIGINT, primary_key=True)
code = Column("code", BIGINT, nullable=False)
account_name = Column("account_name", Text, nullable=False)
current_amount = Column("current_amount",
NUMERIC(20, 2),
default=0.00,
nullable=False)
classification = Column("classification", Text, nullable=False)
account_type = Column("account_type", Text, nullable=False)
position = Column("position", Text)
status = Column("status", BIGINT, nullable=False, default=11)
Accounts_tbl = Table(__tablename__, metadata, id, code, account_name,
current_amount, classification, account_type,
position, status)
def __repr__(self):
return "<Accounts (id='%s', code='%s', " \
"account_name='%s', current_amount='%s'," \
"classification='%s',account_type='%s'," \
"position='%s',status='%s')>" % \
(self.id, self.code,
self.account_name, self.current_amount,
self.classification, self.account_type,
self.position,self.status)
engine = conection().conORM()
metadata.create_all(engine)
engine.connect().close()
class ProductRecepie(Base):
metadata = MetaData()
__tablename__ = "productrecepie_reg"
__table_args__ = {"useexisting": True}
id = Column('id', BIGINT, primary_key=True)
code = Column("code",
BIGINT,
nullable=False,
unique=True,
default=sa.text("setcode('" + __tablename__ +
"'::text, 'code'::text)"))
product = Column("product", BIGINT, nullable=False)
item_recipe = Column("item_recipe", BIGINT, nullable=False)
item_name = Column("item_name", Text, nullable=False)
unit = Column("unit", BIGINT, nullable=False)
unit_name = Column("unit_name", Text, nullable=False, default="")
amount = Column("amount", NUMERIC(20, 2), nullable=False, default=0.00)
status = Column("status", BIGINT, nullable=False, default=11)
product_rec_rel = relationship(Item, backref=backref("product"))
item_recipe_rec_rel = relationship(Item, backref=backref("item_recipe"))
ProductRecepie_tbl = Table(__tablename__, metadata, id, code, item_recipe,
item_name, unit_name, unit, amount, status,
product)
def __repr__(self):
return "<ProductRecepie(id='%s',code='%s',item_recipe='%s',item_recipe_name='%s'," \
"unit='%s',unit_name='%s',amount='%s',status='%s',product='%s')>" % \
(self.id,self.code,self.item_recipe,self.item_recipe_name,self.unit,
self.unit_name,self.amount, self.status,self.product)
def __Publish__(self):
data = {}
for column in self.__table__.columns.keys():
value = self.__dict__[self.__table__.columns[column].name]
if self.__table__.columns[column].type == "BIGINT":
data[self.__table__.columns[column].name] = int(value)
elif self.__table__.columns[column].type == "Integer":
data[self.__table__.columns[column].name] = int(value)
elif self.__table__.columns[column].type == "NUMERIC":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type == "Decimal":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type == "time":
data[self.__table__.columns[column].name] = str(
value.strftime('%H:%M:%S'))
elif self.__table__.columns[column].type == "datetime":
data[self.__table__.columns[column].name] = str(
value.strftime('%H:%M:%S'))
else:
data[self.__table__.columns[column].name] = str(value)
return data
engine = conection().conORM()
metadata.create_all(engine)
engine.connect().close()
@staticmethod
def get_all(db):
s = db.session.query(ProductRecepie)
return s.__dict__
def exist(self, db):
exists = db.session.query(
db.session.query(ProductRecepie).filter_by(
code=self.code).exists()).scalar()
return exists
@staticmethod
def insert(data, db):
db.session.add(ProductRecepie(**data))
db.session.commit()
@staticmethod
def bulk_insert(data, db):
db.session.bulk_save_objects(data)
db.session.commit()
class GetProducts(Base):
def __init__(self, name):
self.name = name
metadata = MetaData()
__tablename__ = "getproducts"
__table_args__ = {"useexisting": True}
item_reg_item_id= Column('item_reg_item_id', BIGINT, primary_key=True)
item_name = Column('item_name', Text)
code= Column('code', BIGINT)
price = Column('price', Text)
item_reg_status = Column('item_reg_status', BIGINT)
category=Column('category', BIGINT)
status_reg_description = Column('status_reg_description', Text)
type_reg_tpname = Column('type_reg_tpname', Text)
item_reg_item_type= Column('item_reg_item_type', BIGINT)
subtotal = Column('subtotal', Text)
tax = Column('tax', Text)
cat_name= Column('cat_name', Text)
cat_typename= Column('cat_typename', Text)
printer= Column('printer', Text)
category_reg_avatar= Column('category_reg_avatar', Text)
category_reg_cat_type= Column('category_reg_cat_type', BIGINT)
category_reg_status = Column('category_reg_status', BIGINT)
category_code = Column('category_code', BIGINT)
type_product= Column('type_product', BIGINT)
item_reg_avatar= Column('item_reg_avatar', Text)
tp_avatar= Column('tp_avatar', Text)
GetProducts_tbl = Table(__tablename__, metadata, item_reg_item_id,item_name, code,price,
item_reg_status,category,status_reg_description,type_reg_tpname,item_reg_item_type,
subtotal,tax,cat_name,printer,category_reg_avatar,
category_reg_cat_type,type_product,item_reg_avatar,tp_avatar,
category_reg_status,cat_typename)
engine = conection().conORM()
metadata.create_all(engine)
engine.connect().close()
def __Publish__(self):
data = {}
for column in self.__table__.columns.keys():
value = self.__dict__[self.__table__.columns[column].name]
if self.__table__.columns[column].type == "BIGINT":
data[self.__table__.columns[column].name] = int(value)
elif self.__table__.columns[column].type == "Integer":
data[self.__table__.columns[column].name] = int(value)
elif self.__table__.columns[column].type == "NUMERIC":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type == "Decimal":
data[self.__table__.columns[column].name] = float(value)
elif self.__table__.columns[column].type == "time":
data[self.__table__.columns[column].name] = str(value.strftime('%H:%M:%S'))
elif self.__table__.columns[column].type == "datetime":
data[self.__table__.columns[column].name] = str(value.strftime('%H:%M:%S'))
else:
data[self.__table__.columns[column].name] = str(value)
return data
class CodeGen:
#This class work with the generation of the code
#On every table.
conn = conection().conORM()
def getCodeLstingCode(self, code=None):
if code == None:
result = self.conn.execute(select([CodeListing]))
valCurrentCode = self.conn.execute(select([CodeListing]).where(CodeListing.code == len(result.fetchall())+1))
if valCurrentCode == None:
return len(valCurrentCode.fetchall())+1
else:
_futureCode = self.getCodeLstingCode(len(valCurrentCode.fetchall())+2)
return _futureCode
else:
valCurrentCode = self.conn.execute(select([CodeListing]).where(CodeListing.code == code))
if len(valCurrentCode.fetchall())==0:
return code
else:
_futureCode = self.getCodeLstingCode(code+1)
return _futureCode
def GenCode(self, kwargs):
getCurrCode = select([CodeListing]).where(CodeListing.name_tbl == kwargs["table"])
codeTbl = 0
result = self.conn.execute(getCurrCode).fetchone()
currentCode = 1
if result != None:
currentCode = int(result.curCode)+1
self.conn.execute(update(CodeListing).where(CodeListing.code == int(result.code)).values(curCode=currentCode))
else:
if "column" not in kwargs:
kwargs["column"] = "code"
description = ""
headCode = 0
code = CodeGen().getCodeLstingCode()
if "description" in kwargs:
description = kwargs["description"]
elif "headCode" in kwargs:
headCode=int(kwargs["headCode"])
self.conn.execute(insert(CodeListing).values(curCode=currentCode, name_tbl=kwargs["table"], name_col=kwargs["column"],
description=description, headCode=headCode, code=code))
return currentCode
#this method will generate and save a new code,
#And will find if that code is in use, if not in use will returned.
def RollBackCode(self, kwargs):
getCurrCode = select([CodeListing]).where(CodeListing.name_tbl == kwargs["table"])
codeTbl = 0
result = self.conn.execute(getCurrCode).fetchone()
currentCode = 1
if result != None:
currentCode = (int(result.curCode)-1)
self.conn.execute(update(CodeListing).where(CodeListing.code == int(result.code)).values(curCode=currentCode))
else:
currentCode=0
return currentCode
company_code = LongField(required=True)
rule_name = StringField(required=True)
# HELPER AREA##########################################
# Here I complete some table that were designed in
# a way and now change it will brake the system apart
class product_type(Document):
prod_type = LongField(required=True)
avatar = StringField(required=False, default="dinner.png")
if __name__ == '__main__':
###Testing area
myConn = conection().conODM()
print(Module.objects())
#UsertypeMenu.objects(id='579cc3748f01b939d41efe0a').delete()
# code = CodeGen().GenCode({"table": "printer", "column": "code"})
# printer_reg(code=code, brand="Smart & Cool", model="POS-5890C", papersize=58).save()
# code = CodeGen().GenCode({"table": "printer", "column": "code"})
# printer_reg(code=code, brand="Star", model="SP200", papersize=90).save()
# code = CodeGen().GenCode({"table": "cashbox", "column": "code"})
#
# cashbox(_name="001", code=code, company=3, branch=1, description="Caja del piso principal.", printer=1).save()
# #UsertypeMenu.objects(id="579cc3748f01b937b857915c").update(set__module=21)
# UsertypeMenu(user_type=74, module=21, created_by=11, created_date=2457634).save()
# for piece in UsertypeMenu.objects(user_type=74):
# print(piece.user_type, piece.module, piece.id, piece.created_by, piece.created_date)
# for piece in Module.objects():
