def issue_listing(bag):
countries = orm_to_json(
g.tran.query(db.Countries).filter_by(_deleted='infinity').all())
currencies = orm_to_json(
g.tran.query(db.Currencies).filter_by(_deleted='infinity').all())
return {'countries': countries, 'currencies': currencies}
def save(bag):
if bag.get('company_type'):
role_supplier = g.tran.query(db.Roles).filter_by(_deleted='infinity') \
.filter(db.Roles.data['code'].astext.cast(TEXT) == bag['company_type']).first()
role_supplier = orm_to_json(role_supplier)
else:
role_supplier = g.tran.query(db.Roles).filter_by(_deleted='infinity') \
.filter(db.Roles.data['code'].astext.cast(TEXT) == 'supplier').first()
role_supplier = orm_to_json(role_supplier)
bag_company = bag['main_info']
bag_company['type'] = 'Companies'
bag_company['user_id'] = g.user.id
if 'roles_id' not in bag_company:
bag_company['roles_id'] = []
bag_company['roles_id'].append(role_supplier['_id'])
bag_company['role'] = 0
bag_company["company_status"] = bag_company["company_status"] if "company_status" in bag_company else 'waiting'
bag_company["company_type"] = role_supplier['data']['code']
company = controller.call(controller_name='data.put', bag=bag_company)
bag_bank = bag['bank_info']
bag_bank['company_id'] = company['id']
bag_bank['type'] = 'Companybank'
bank = controller.call(controller_name='data.put', bag=bag_bank)
bag_employee = {}
if 'roles_id' not in bag_employee:
bag_employee['roles_id'] = []
if bag.get('company_type') and bag['company_type'] == 'purchaser':
role = g.tran.query(db.Roles._id).filter_by(_deleted='infinity') \
.filter(db.Roles.data['code'].astext.cast(TEXT) == 'purhead').first()
else:
role = g.tran.query(db.Roles._id).filter_by(_deleted='infinity') \
.filter(db.Roles.data['code'].astext.cast(TEXT) == 'head').first()
bag_employee['user_id'] = g.user.id
bag_employee['roles_id'] = role
bag_employee['company_id'] = company['id']
bag_employee['head'] = True
entity.add({CRUD: db.Companyemployees, BOBJECT: bag_employee})
bag_prequal = bag['prequal_info']
bag_prequal['company_id'] = company['id']
bag_prequal['type'] = 'Companyqualification'
# bag_prequal['data'] = {}
if 'certificates' in bag_prequal:
bag_prequal['data']['certificates'] = bag_prequal['certificates']
if 'supplies' in bag_prequal:
bag_prequal['data']['supplies'] = bag_prequal['supplies']
if 'experiences' in bag_prequal:
bag_prequal['data']['experiences'] = bag_prequal['experiences']
if 'finances' in bag_prequal:
bag_prequal['data']['finances'] = bag_prequal['finances']
prequal = controller.call(controller_name='data.put', bag=bag_prequal)
return
def dashboard(bag):
query = g.tran.query(db.Journal) \
.filter_by(_deleted='infinity')
if 'status' in bag:
query = query.filter(db.Journal.status == bag['status'])
if 'date_start' in bag:
query = query.filter(db.Journal.date >= bag['date_start'])
if 'date_end' in bag:
query = query.filter(db.Journal.date <= bag['date_end'])
incoming_query = query.filter_by(status='Входящий')
outgoing_query = query.filter_by(status='Исходящий')
spoiled_query = query.filter_by(status='испорчен')
refused_query = query.filter_by(status='Отказано')
incoming = orm_to_json(incoming_query.all())
incoming_sum = 0
incoming_count = incoming.__len__()
for inc in incoming:
incoming_sum += inc['summ']
outgoing = orm_to_json(outgoing_query.all())
outgoing_sum = 0
outgoing_count = outgoing.__len__()
for out in outgoing:
outgoing_sum += out['summ']
spoiled = orm_to_json(spoiled_query.all())
spoiled_sum = 0
spoiled_count = spoiled.__len__()
for inc in spoiled:
spoiled_sum += inc['summ']
refused = orm_to_json(refused_query.all())
refused_sum = 0
refused_count = refused.__len__()
for ref in refused:
refused_sum += ref['summ']
return {
'data': {
'incoming': incoming_sum,
'incoming_count': incoming_count,
'outgoing': outgoing_sum,
'outgoing_count': outgoing_count,
'spoiled': spoiled_sum,
'spoiled_count': spoiled_count,
'refused': refused_sum,
'refused_count': refused_count
}
}
def get(bag):
pur_comp = aliased(db.Companies)
sup_comp = aliased(db.Companies)
cons, pur_company, adv, section, procur, sup_company = g.tran.query(
db.Consignment, pur_comp, db.Advert, db.DirSection, db.DirProcurement, sup_comp) \
.outerjoin(pur_comp, and_(db.Consignment.purchaser_company_id == pur_comp._id,
pur_comp._deleted == INFINITY)) \
.outerjoin(db.Advert, and_(db.Consignment.advert_id == db.Advert._id,
db.Advert._deleted == INFINITY)) \
.outerjoin(db.DirSection, and_(db.Advert.dirsection_id == db.DirSection._id,
db.DirSection._deleted == INFINITY)) \
.outerjoin(sup_comp, and_(db.Consignment.supplier_company_id == sup_comp._id,
sup_comp._deleted == INFINITY)) \
.filter(db.Consignment.id == bag['id']).first()
consignment = orm_to_json(cons)
pur_company_bank = g.tran.query(db.Companybank).filter_by(_deleted='infinity', company_id=pur_company._id).first()
if pur_company_bank:
dirbank = g.tran.query(db.DirBank).filter_by(_deleted='infinity', _id=pur_company_bank.dirbank_id).first()
if dirbank:
pur_company_bank.dirbank = dirbank
pur_company.bank = pur_company_bank
sup_company_bank = g.tran.query(db.Companybank).filter_by(_deleted='infinity', company_id=sup_company._id).first()
if sup_company_bank:
dirbank = g.tran.query(db.DirBank).filter_by(_deleted='infinity', _id=sup_company_bank.dirbank_id).first()
if dirbank:
sup_company_bank.dirbank = dirbank
sup_company.bank = sup_company_bank
consignment['pur_company'] = pur_company if pur_company else ''
consignment['sup_company'] = sup_company if sup_company else ''
ann = orm_to_json(adv)
ann['dirprocurement_name'] = procur.name if procur else ''
consignment['announce'] = ann
cons_lots = g.tran.query(db.ConsignmentLots, db.Advert_lot, db.DirCategory) \
.outerjoin(db.Advert_lot, and_(db.ConsignmentLots.advert_lot_id == db.Advert_lot._id,
db.Advert_lot._deleted == INFINITY)) \
.outerjoin(db.DirCategory, db.Advert_lot.dircategory_id == db.DirCategory.id)\
.filter(db.ConsignmentLots.consignment_id == cons.id).all()
lots = []
for cl, al, cat in cons_lots:
lot = orm_to_json(al)
lot['dircategory_name'] = cat.name if cat else ''
lots.append(lot)
consignment['lots'] = lots
return {'doc': consignment}
def listing(bag):
query = g.tran.query(db.DirCoate)
if bag.get('name'):
if bag.get('lang') == 'ru':
query = query.filter(
db.DirCoate.name.ilike('%' + bag.get('name') + '%'))
del bag['name']
elif bag.get('lang') == 'kg':
query = query.filter(
db.DirCoate.name_kg.ilike('%' + bag.get('name') + '%'))
del bag['name']
elif bag.get('lang') == 'en':
query = query.filter(
db.DirCoate.name_en.ilike('%' + bag.get('name') + '%'))
del bag['name']
if bag.get('center'):
query = query.filter(db.DirCoate.center == bag.get('center'))
if bag.get('code'):
query = query.filter(db.DirCoate.code == bag.get('code'))
if bag.get('parent_id'):
query = query.filter(db.DirCoate.parent_id == bag.get('parent_id'))
questions = query.all()
items = []
for _questions in questions:
item = orm_to_json(_questions)
items.append(item)
return {'docs': items}
def mainlisting(bag):
query = g.tran.query(db.New).filter_by(_deleted='infinity')\
.filter(db.New.is_active == True)
query.section = None
if bag.get('name'):
if bag.get('lang') == 'ru':
query = query.filter(
db.New.name_ru.ilike('%' + bag.get('name') + '%'))
elif bag.get('lang') == 'kg':
query = query.filter(
db.New.name_kg.ilike('%' + bag.get('name') + '%'))
if bag.get('created_from'):
query = query.filter(db.New.created_from >= bag.get('created_from'))
if bag.get('created_to'):
query = query.filter(db.New.created_to <= bag.get('created_to'))
if bag.get('is_active'):
active = bag.get('is_active')
if active == 'yes':
query = query.filter_by(is_active=True)
elif active == 'no':
query = query.filter_by(is_active=False)
section = g.tran.query(db.Sectionsofpublication.name_ru) \
.select_from(db.Sectionsofpublication) \
.filter_by(_deleted='infinity').filter(
db.Sectionsofpublication._id == db.New.sectionsofpublication_id).as_scalar() \
.label('section')
query = query.add_columns(section)
query = query.order_by(db.New.created_from.desc())
query = query.limit(10).all()
return {'docs': orm_to_json(query)}
def userlist(bag):
query = g.tran.query(db.User.id).select_from(db.User)
if "filter" in bag:
if bag['filter'].get('search', ''):
query = query.filter(
or_(
db.User.fullname.ilike(u"%{}%".format(
bag["filter"]["search"])),
db.User.email.ilike(u"%{}%".format(
bag["filter"]["search"]))))
del bag["filter"]["search"]
query = query.filter_by(**bag["filter"])
doc_vars = vars(db.User)
for var in doc_vars:
if var != 'password' and var != 'secure' and isinstance(
doc_vars[var], InstrumentedAttribute):
query = query.add_column(doc_vars[var])
if "limit" in bag:
query = query.limit(bag.get('limit', 10))
if "offset" in bag:
query = query.offset(bag["offset"])
users = []
for u in query.all():
usr = orm_to_json(u)
usr['info'] = u'{} {}'.format(u.fullname, u.email)
users.append(usr)
return {'users': users}
def load(self, idx, rev=None, revs=False, as_dict=True, locked=False):
if not self.contains(idx, rev):
raise self.NotFound(idx)
ti = g.tran.query(db.TableId).filter_by(_id=idx)
if locked:
ti = ti.with_for_update(of=db.TableId)
ti = ti.first()
table = self.__get_object(ti.table_name)
doc = g.tran.query(table).filter_by(_id=idx)
if rev:
doc = doc.filter_by(_rev=rev)
else:
doc = doc.filter_by(_deleted='infinity')
doc = doc.first()
if not doc:
raise self.NotFound(idx)
setattr(doc, 'type', ti.table_name)
d = orm_to_json(doc)
d['type'] = ti.table_name
del d['_created']
del d['_deleted']
if doc._deleted != 'infinity':
d['_deleted'] = True
if revs:
d['_revisions'] = {'ids': []}
sql = g.tran.query(table).filter_by(_id=idx).order_by(
table._created.desc())
for r in sql:
d['_revisions']['ids'] = r._rev.split('-')[1]
if not d['_revisions'].get('start'):
d['_revisions']['start'] = r._rev.split('-')[0]
if as_dict:
return d
return doc
def pur_submit(bag):
con_status = ["Schedule", "Review"]
contract = g.tran.query(db.Contract) \
.filter_by(id=bag['id']) \
.filter(and_(db.Contract.status.in_(con_status),
db.Contract.purchaser_company_id == g.company._id)) \
.first()
if not contract:
raise CbsException(GENERIC_ERROR, u'Не найден договор')
contract.date_pur_submit = datetime.datetime.now()
contract.status = 'Pending'
if bag.get('comment'):
contract.comment.append({
"pur_company": g.company._id,
"comment": bag['comment'],
"date": datetime.datetime.now()
})
# save
entity.add({CRUD: db.Contract, BOBJECT: orm_to_json(contract)})
return
def getsession(id):
user = g.tran.query(db.User).filter_by(id=int(id)).first()
company = None
docs = None
if user.default_company is not None and user.default_company != "":
uc = g.tran.query(db.Companies).filter_by(
_deleted='infinity', _id=user.default_company).first()
if uc:
company = orm_to_json(uc)
company['roles'] = g.tran.query(db.Roles).filter_by(_deleted='infinity') \
.filter(db.Roles._id.in_(company["roles_id"])).first()
user_data = {
'id': user.id,
'username': user.username,
'email': user.email,
'fullname': user.fullname,
'phone': user.phone,
'inn': user.inn,
'role': user.role,
'rec_date': user.rec_date,
'default_company': user.default_company,
'data': user.data
}
token = redis_session.open_session({'user_id': user.id})
session = redis_session.get_session(token)
redis_session.update_session(token, session)
return make_json_response({
'token': token,
'user': user_data,
'company': company,
'docs': docs
})
def listing(bag):
query = g.tran.query(db.User.id).select_from(db.User)
if "filter" in bag:
if 'filter' in bag and 'first_name' in bag['filter']:
query = query.filter(db.User.first_name.ilike(u"%{}%".format(bag["filter"]["first_name"])))
del bag["filter"]["first_name"]
if 'filter' in bag and 'last_name' in bag['filter']:
query = query.filter(db.User.last_name.ilike(u"%{}%".format(bag["filter"]["last_name"])))
del bag["filter"]["last_name"]
if 'filter' in bag and 'middle_name' in bag['filter']:
query = query.filter(db.User.middle_name.ilike(u"%{}%".format(bag["filter"]["middle_name"])))
del bag["filter"]["middle_name"]
query = query.filter_by(**bag["filter"])
doc_vars = vars(db.User)
for var in doc_vars:
if var != 'password' and var != 'secure' and isinstance(doc_vars[var], InstrumentedAttribute):
query = query.add_column(doc_vars[var])
query = query.order_by(asc(db.User.id))
count = query.count()
if "limit" in bag:
query = query.limit(bag["limit"])
if "offset" in bag:
query = query.offset(bag["offset"])
return {'users': orm_to_json(query.all()), 'count': count}
def listing(bag):
# if user is operator
if g.user.role == 1:
notifications = g.tran.query(
db.AdminNotification).filter_by(_deleted='infinity').all()
else:
sequence = ["all"]
# user_company = g.tran.query(db.Companies).filter_by(_id=g.company._id, _deleted='infinity').one()
# if user_company and user_company.company_type:
# role_id = user_company.roles_id[0]
# sequence.append(role_id)
# else:
# raise CbsException(USER_NOT_AUTHORIZED)
notifications = g.tran.query(
db.AdminNotification).filter_by(_deleted='infinity').filter(
db.AdminNotification.role_id.in_(sequence)).all()
notifications = orm_to_json(notifications)
# builds content without styles
for n in notifications:
content = ""
if n.get('content'):
for b in n['content']['blocks']:
content += b['text']
n['content'] = content
return {"docs": notifications}
def get(bag):
label = ""
dirsection = g.tran.query(db.DirSection).filter_by(_deleted='infinity',
_id=bag['_id']).first()
specifications = g.tran.query(db.Specification)\
.filter(db.Specification.id.in_(dirsection.dircategories_id)).all()
specifications = orm_to_json(specifications)
for spec in specifications:
dircategory = g.tran.query(
db.DirCategory).filter_by(id=spec['dircategory_id']).first()
if g.lang == "ru":
label = dircategory.name
elif g.lang == "en":
label = dircategory.name_en if dircategory.name_en and dircategory.name_en != 'null' else dircategory.name
elif g.lang == "kg":
label = dircategory.name_kg if dircategory.name_kg and dircategory.name_kg != 'null' else dircategory.name
dirc = {
"code": dircategory.code,
"data": dircategory.data,
"id": dircategory.id,
"name": label,
"parent_id": dircategory.parent_id
}
spec['dircategory'] = dirc
return {'docs': specifications}
def listing(bag):
query = g.tran.query(db.Advert)
if bag.get('name'):
if bag.get('lang') == 'ru':
query = query.filter(
db.Advert.name_ru.ilike('%' + bag.get('name') + '%'))
elif bag.get('lang') == 'kg':
query = query.filter(
db.Advert.name_kg.ilike('%' + bag.get('name') + '%'))
if bag.get('created_from'):
query = query.filter(db.Advert.created_from >= bag.get('created_from'))
if bag.get('created_to'):
query = query.filter(db.Advert.created_to <= bag.get('created_to'))
if bag.get('is_active'):
active = bag.get('is_active')
if active == 'yes':
query = query.filter_by(is_active=True)
elif active == 'no':
query = query.filter_by(is_active=False)
query = query.order_by(desc(db.Advert.created_from))
adverts = query.all()
items = []
for _adverts in adverts:
item = orm_to_json(_adverts)
items.append(item)
return {'list': items}
def publish(bag):
bag_advert = bag['advert']
result = None
advert = g.tran.query(db.Advert) \
.filter_by(_deleted='infinity', _id=bag_advert['_id'], status='Draft') \
.first()
if not advert:
raise CbsException(GENERIC_ERROR, u'Объявление не найдено')
Force_status_list = [
'ENSURE_SECURITY_KR', 'EARLY_ELECTIONS', 'LOCALIZE_FORCE_MAJEURE',
'THREE_PERCENT_SERVICE'
]
dirprocumenet = g.tran.query(db.DirProcurement) \
.filter_by(_deleted='infinity').filter(db.DirProcurement.code.in_(Force_status_list),
db.DirProcurement._id == advert.dirprocurement_id) \
.first()
if not dirprocumenet:
result = controller.call(controller_name='announce.put',
bag=bag_advert)
advert = orm_to_json(advert)
advert['type'] = 'Advert'
advert['code'] = result.get('orderNumber',
get_code()) if result else get_code()
advert['published_date'] = datetime.datetime.now()
advert['update_date'] = datetime.datetime.now()
advert['status'] = 'Published'
controller.call(controller_name='data.put', bag=advert)
return
def listing(bag):
sql = g.tran.query(db.Companydocument, db.Companies, db.DirDocument) \
.outerjoin(db.Companies, and_(db.Companydocument.company_id == db.Companies._id,
db.Companies._deleted == INFINITY)) \
.outerjoin(db.DirDocument, and_(db.Companydocument.dirdocument_id == db.DirDocument._id,
db.DirDocument._deleted == INFINITY)) \
.filter(db.Companydocument._deleted == INFINITY)
if hasattr(g, 'company'):
sql = sql.filter(db.Companydocument.company_id == g.company._id)
if bag.get('dirdocument_id', ''):
sql = sql.filter(
db.Companydocument.dirdocument_id == bag['dirdocument_id'])
comp_docs = []
sql = sql.order_by(db.Companydocument.date_start.desc(),
db.Companydocument._created.desc())
if 'limit' in bag:
sql = sql.limit(bag['limit'])
for cd, comp, doc in sql.all():
d = orm_to_json(cd)
d['company'] = comp.name
d['inn'] = comp.inn
d['document'] = doc.name
d['debt'] = cd.debt
d['debt_status'] = u'Имеется' if cd.debt else u'Не имеется'
comp_docs.append(d)
return {'docs': comp_docs}
def listing(bag):
invoices = []
pur_comp = aliased(db.Companies)
sup_comp = aliased(db.Companies)
if not bag.get('contract_id'):
raise CbsException(GENERIC_ERROR, u'Укажите id договора')
sql = g.tran.query(db.Invoice, pur_comp.short_name.label('pur_company'), db.DirSection,
sup_comp.short_name.label('sup_company')) \
.outerjoin(pur_comp, and_(db.Invoice.purchaser_company_id == pur_comp._id,
pur_comp._deleted == INFINITY)) \
.outerjoin(db.Advert, and_(db.Invoice.advert_id == db.Advert._id,
db.Advert._deleted == INFINITY)) \
.outerjoin(db.DirSection, and_(db.Advert.dirsection_id == db.DirSection._id,
db.DirSection._deleted == INFINITY)) \
.outerjoin(sup_comp, and_(db.Invoice.supplier_company_id == sup_comp._id,
sup_comp._deleted == INFINITY)) \
.filter(or_(db.Invoice.purchaser_company_id == g.company._id,
db.Invoice.supplier_company_id == g.company._id)) \
.filter(db.Invoice.contract_id == bag['contract_id'])\
.order_by(db.Invoice.date)\
.order_by(db.Invoice.created_date)
for ct, pur_company, section, sup_company in sql.all():
contract = orm_to_json(ct)
contract['pur_company'] = pur_company if pur_company else ''
contract['sup_company'] = sup_company if sup_company else ''
contract['dirsection'] = section.name if section else ''
invoices.append(contract)
return {'docs': invoices}
def get(self, bag):
query = g.tran.query(db.Companies) \
.filter_by(_deleted='infinity', _id=bag['id'])
doc_vars = vars(db.Companies)
for var in doc_vars:
if isinstance(doc_vars[var], InstrumentedAttribute):
query = query.add_column(doc_vars[var])
if 'with_related' in bag and bag['with_related'] is True:
company_status_value = g.tran.query(
func.row_to_json(text('enums.*'))).select_from(db.Enums) \
.filter_by(_deleted='infinity', name='company_status') \
.filter(db.Enums.data['key'].cast(TEXT) == cast(db.Companies.company_status, TEXT)) \
.as_scalar().label('company_status_value')
company_type_value = g.tran.query(
func.row_to_json(text('enums.*'))).select_from(db.Enums) \
.filter_by(_deleted='infinity', name='company_type') \
.filter(db.Enums.data['key'].cast(TEXT) == cast(db.Companies.company_type, TEXT)) \
.as_scalar().label('company_type_value')
entry_user = g.tran.query(func.json_build_object(
"id", db.User.id, "username", db.User.username, "email", db.User.email, "rec_date", db.User.rec_date,
"data", db.User.data, "role", db.User.role)).select_from(db.User).filter_by(
id=db.Companies.entry_user_id) \
.as_scalar().label('entry_user')
typeofownership = g.tran.query(func.row_to_json(text('typeofownership.*'))).select_from(db.Typeofownership) \
.filter_by(_deleted='infinity', _id=db.Companies.typeofownership_id).as_scalar() \
.label('typeofownership')
dircountry = g.tran.query(func.row_to_json(text('dircountry.*'))).select_from(db.DirCountry) \
.filter_by(_deleted='infinity', _id=db.Companies.dircountry_id).as_scalar() \
.label('dircountry')
dircoate = g.tran.query(func.row_to_json(text('dircoate.*'))).select_from(db.DirCoate) \
.filter_by(_deleted='infinity', _id=db.Companies.dircoate_id).as_scalar() \
.label('dircoate')
roles = g.tran.query(func.jsonb_agg(func.row_to_json(text('roles.*')))).select_from(db.Roles) \
.filter_by(_deleted='infinity') \
.filter(type_coerce(db.Companies.roles_id).has_any(array([db.Roles._id]))) \
.as_scalar().label('roles')
company_users = g.tran.query(db.Companyemployees.user_id).filter_by(_deleted='infinity',
company_id=bag['id']).all()
company_users = []
for user_id in company_users:
user = g.tran.query(func.json_build_object(
"id", db.User.id, "username", db.User.username, "email", db.User.email, "rec_date", db.User.rec_date,
"data", db.User.data, "role", db.User.role)).select_from(db.User) \
.filter_by(id=user_id).first()
company_users.append(user)
query = query.add_columns(company_status_value, company_type_value, entry_user, company_users, typeofownership,
dircountry, roles, dircoate)
company = query.one()
return {'doc': orm_to_json(company)}
def update(bag):
company = g.tran.query(db.Companies).filter_by(_deleted='infinity', _id=bag['id']).first()
if company:
company = orm_to_json(company)
company['type'] = 'Companies'
company['short_name'] = bag.get('short_name', '')
controller.call(controller_name='data.put', bag=company)
def regulationsListing():
query = g.tran.query(db.Regulation)
regulations = query.all()
items = []
for _regulations in regulations:
item = orm_to_json(_regulations)
items.append(item)
return make_json_response({'regulations': items})
def activate(bag):
if 'id' in bag:
DirDoc = g.tran.query(db.DirDoc).filter_by(id=bag['id']).first()
DirDoc = orm_to_json(DirDoc)
if 'active' in bag:
DirDoc['type'] = 'DirDoc'
DirDoc['is_active'] = bag['active']
return entity.add({CRUD: db.DirDoc, BOBJECT: DirDoc})
def activate(bag):
if '_id' in bag:
new = g.tran.query(db.New).filter_by(_deleted='infinity', _id=bag['_id']).first()
new = orm_to_json(new)
if 'active' in bag:
new['type'] = 'New'
new['is_active'] = bag['active']
return controller.call(controller_name='data.put', bag=new)
def put_answer(bag):
answer = g.tran.query(db.Question).filter_by(id=bag.get('id')).first()
answer = answer if answer else db.Question()
answer.answer = bag.get('answer')
answer.is_active = bag.get('is_active')
g.tran.add(answer)
return {'answer': orm_to_json(answer)}
def sup_submit(bag):
# check_otp(g.user.phone, bag['otpcode'])
contract = g.tran.query(db.Contract) \
.filter_by(id=bag['id']) \
.filter(and_(db.Contract.status == 'Pending',
db.Contract.supplier_company_id == g.company._id)) \
.first()
if not contract:
raise CbsException(GENERIC_ERROR, u'Не найден договор')
contract.date_sup_submit = datetime.datetime.now()
contract.status = 'Active'
sql = g.tran.query(db.Advert_lot, db.Application) \
.outerjoin(db.Application, and_(db.Advert_lot._id == db.Application.advert_lot_id,
db.Application._deleted == INFINITY)) \
.filter(db.Advert_lot.advert_id == contract.advert_id,
db.Advert_lot._deleted == INFINITY)
for lot, appl in sql.all():
if appl:
appl.lot_id = lot.lot_id
appl.product_id = lot.product_id
g.tran.add(appl)
if bag.get('comment'):
contract.comment.append({
"pur_company": g.company._id,
"comment": bag['comment'],
"date": datetime.datetime.now()
})
advert = g.tran.query(db.Advert).filter_by(_deleted='infinity').filter(
db.Advert._id == contract.advert_id).first()
Force_status_list = [
'ENSURE_SECURITY_KR', 'EARLY_ELECTIONS', 'LOCALIZE_FORCE_MAJEURE',
'THREE_PERCENT_SERVICE'
]
dirprocumenet = g.tran.query(db.DirProcurement)\
.filter_by(_deleted='infinity').filter(and_(db.DirProcurement.code.in_(Force_status_list),
db.DirProcurement._id == advert.dirprocurement_id))\
.first()
if dirprocumenet:
controller.call(controller_name='announce.sendContract',
bag={
'contract': contract,
'code': dirprocumenet.code
})
else:
controller.call(controller_name='announce.sendAnnounce',
bag={
'advert_id': contract.advert_id,
'contract_code': contract.code
})
entity.add({CRUD: db.Contract, BOBJECT: orm_to_json(contract)})
return
def get(bag):
if hasattr(g, 'company'):
roles = g.tran.query(db.Roles).filter_by(_deleted='infinity').filter(
db.Roles.parent_id.in_(g.company.roles_id))
count = roles.count()
roles = orm_to_json(roles.all())
else:
raise CbsException(GENERIC_ERROR, u'У вас не выбрана организация')
return {'docs': roles, 'count': count}
def update_status(bag, status_list, new_status):
company = g.tran.query(db.Companies).filter_by(_deleted='infinity', _id=bag['id']).first()
if company and company.company_status in status_list:
company = orm_to_json(company)
company['type'] = 'Companies'
company['company_status'] = new_status
if new_status == 'rejected':
company['reason'] = bag.get('reason')
controller.call(controller_name='data.put', bag=company)
def test(bag):
advert_lots_ids = g.tran.query(db.Advert_lot._id) \
.filter_by(_deleted='infinity', advert_id='e83b1f46-8c20-413d-a9d2-c71cf7c1f29f').all()
advert_lots_ids = orm_to_json(advert_lots_ids)
items = []
for advert_lot in advert_lots_ids:
application_count = g.tran.query(db.Application) \
.filter_by(_deleted='infinity', advert_lot_id=advert_lot['_id'], status='Published').count()
items.append(application_count)
return {'items': items}
def put(bag):
regulations = g.tran.query(db.Regulation).filter_by(id=bag.get('id')).first()
regulations = regulations if regulations else db.Regulation()
regulations.departmentdocument_id = bag.get('departmentdocument_id')
regulations.name_ru = bag.get('name_ru')
regulations.name_kg = bag.get('name_kg')
regulations.file = bag.get('file')
g.tran.add(regulations)
return {'regulations': orm_to_json(regulations)}
def get(bag):
query = g.tran.query(db.User).filter_by(id=bag['id']).one()
query = orm_to_json(query)
query['citizenship'] = {}
query['nationality'] = {}
query['citizenship'] = g.tran.query(db.Citizenship).filter_by(_deleted='infinity',
_id=query['citizenship_id']).first()
query['nationality'] = g.tran.query(db.Nationality).filter_by(_deleted='infinity',
_id=query['nationality_id']).first()
return {'user': query}
def get(self, bag):
query = g.tran.query(db.Document).filter_by(_deleted='infinity', _id=bag[ID])
query = query.filter(
or_(db.Document.data.contains(type_coerce({"user_id": g.user.id}, JSONB)),
db.Document.data.contains(type_coerce({"executor_id": g.user.id}, JSONB)),
type_coerce(db.Document.approval['roles_id'], JSONB).has_any(array(g.user.roles_id)) if len(
g.user.roles_id) > 0 else None))
doc = query.one()
return {'docs': orm_to_json(doc)}