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 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 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 questions(name, city, email, url, question):
questions = {}
questions['name'] = name
questions['city'] = city
questions['email'] = email
questions['url'] = url
questions['question'] = question
entity.add({CRUD: db.Question, BOBJECT: questions})
return make_json_response({'questions': questions})
def save(bag):
employee = g.tran.query(db.Companyemployees) \
.filter(and_(db.Companyemployees.company_id == g.company._id,
db.Companyemployees.user_id == bag['user_id'])).first()
if employee:
raise CbsException(GENERIC_ERROR, u'Этот сотрудник уже есть в списке')
entity.add({CRUD: db.Companyemployees, BOBJECT: bag})
user = g.tran.query(db.User).filter(db.User.id == bag['user_id']).first()
if user.default_company == '' or user.default_company is None:
user.default_company = g.company._id
g.tran.add(user)
g.tran.flush()
return
def pur_decline(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 contract:
contract.status = 'Canceled'
contract.update_date = datetime.datetime.now()
contract.reason = bag['reason'] or ''
contract.who_canceled = g.company._id
entity.add({CRUD: db.Contract, BOBJECT: contract})
return
def sup_decline(bag):
contract = g.tran.query(db.Contract) \
.filter_by(id=bag['id']) \
.filter(and_(db.Contract.status == 'Pending',
db.Contract.purchaser_company_id == g.company._id)).first()
if contract:
contract.status = 'Canceled'
contract.date_canceled = datetime.datetime.now()
contract.reason = bag['reason'] or ''
contract.who_canceled = g.company._id
entity.add({CRUD: db.Contract, BOBJECT: contract})
else:
raise CbsException(GENERIC_ERROR, u'Не найден договор')
return
def save(bag):
tab_dict = {}
for dictionary in bag:
if 'id' in dictionary:
tab_dict['name'] = dictionary.name
tab_dict['parent_id'] = dictionary.parent_id
dict_data = entity.add({CRUD: db.Dictionary, BOBJECT: tab_dict})
dict_attr_data = {}
if 'id' in dict_data:
for dict_attr in dictionary.attr:
dict_attr_data['dictionary_id'] = dict_data['id']
dict_attr_data['name'] = dict_attr.name
dict_attr_data = entity.add({CRUD: db.Dicattribute, BOBJECT: dict_attr_data})
return
def register(bag):
if 'data' not in bag:
bag['data'] = {}
bag['secure'] = pyotp.random_base32()
bag[PASSWORD] = sha1(bag[PASSWORD] + bag['secure']).hexdigest()
if not re.match('^[a-zA-Z]+[\w\-_]+$', bag[USERNAME]):
raise CbsException(GENERIC_ERROR,
u'Имя пользователя может содержать только латинские буквы, цифры и знаки "-" и "_"!')
user = g.tran.query(db.User).filter(or_(db.User.username == bag[USERNAME], db.User.email == bag[EMAIL])).first()
if user:
raise CbsException(USER_ALREADY_EXISTS)
user = entity.add({CRUD: db.User, BOBJECT: bag})
user_data = {
ID: user.id,
USERNAME: user.username,
EMAIL: user.email,
'role': user.role,
'roles_id': user.roles_id,
'rec_date': user.rec_date,
'data': user.data
}
token = redis_session.open_session({'user_id': user.id})
return {'token': token, 'user': user_data}
def decline(bag):
contract = g.tran.query(db.Contract).filter_by(id=bag['id']) \
.filter(or_(db.Contract.status == 'Pending', db.Contract.status == 'Schedule')) \
.first()
if not contract:
raise CbsException(GENERIC_ERROR, u'Контракт не найден')
if g.company.company_type != 'supplier':
raise CbsException(GENERIC_ERROR, u'Вы не являетесь поставщиком!')
contract.status = 'Declined'
contract = {
'id': contract.id,
'code': contract.code,
'status': contract.status,
'advert_id': contract.advert_id,
'purchaser_company_id': contract.purchaser_company_id,
'supplier_company_id': contract.supplier_company_id,
'dirsection_id': contract.dirsection_id,
'total': contract.total,
'created_date': contract.created_date
}
contr = entity.add({CRUD: db.Contract, BOBJECT: contract})
return {'doc': contr}
def save_comm_member(bag):
employee = g.tran.query(db.Companyemployees) \
.filter(db.Companyemployees.company_id == g.company._id,
db.Companyemployees.comm_member == True,
db.Companyemployees.user_id == bag['user_id']).first()
if not employee:
employee = entity.add({CRUD: db.Companyemployees, BOBJECT: bag})
return employee
def sup_review(bag):
contract = g.tran.query(db.Contract) \
.filter_by(id=bag['id']) \
.filter(and_(db.Contract.status == 'Pending',
db.Contract.purchaser_company_id == g.company._id)).first()
if contract:
if bag.get('comment'):
contract.comment.append({
"pur_company": g.company._id,
"comment": bag['comment'],
"date": datetime.datetime.now()
})
contract.status = 'Review'
entity.add({CRUD: db.Contract, BOBJECT: contract})
else:
raise CbsException(GENERIC_ERROR, u'Не найден договор')
return
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 send_otp(bag):
if not hasattr(g, 'user'):
raise CbsException(GENERIC_ERROR, u'Пользователь не авторизован')
otp = get_totp(g.user.phone)
msg = u'Код подтверждения: {}'.format(otp)
sms_data = {
'source_addr': bag.get('command', 'recovery'),
'dest_addr': g.user.phone,
'msg': msg
}
so = entity.add({CRUD: db.SmsOutbox, BOBJECT: sms_data})
sms.send(g.user.phone, msg, so.id)
def check(bag):
company = g.tran.query(db.Companies).filter_by(_deleted='infinity', _id=bag['id']).first()
if company:
company = orm_to_json(company)
role = g.tran.query(db.Roles).filter_by(_deleted='infinity').filter(db.Roles._id.in_(bag['roles_id'])).first()
if role and role.code == 'purchaser':
item = {}
emprole = g.tran.query(db.Roles._id).filter_by(_deleted='infinity') \
.filter(db.Roles.data['code'].astext.cast(TEXT) == 'purhead').first()
employee = g.tran.query(db.Companyemployees).filter(db.Companyemployees.company_id == bag['id']).first()
item['company_id'] = company['_id']
item['user_id'] = company['user_id']
item['roles_id'] = emprole
item['head'] = True
item['data'] = employee.data
item['id'] = employee.id
entity.add({CRUD: db.Companyemployees, BOBJECT: item})
company['type'] = 'Companies'
company['company_status'] = bag['company_status']
company['roles_id'] = bag['roles_id']
company['end_date'] = (datetime.date.today() + datetime.timedelta(6 * 365 / 12)).isoformat()
controller.call(controller_name='data.put', bag=company)
def sign(bag):
contract = g.tran.query(db.Contract).filter_by(id=bag['id'],
status='Pending').first()
if g.company.company_type != 'supplier':
raise CbsException(GENERIC_ERROR, u'Вы не являетесь поставщиком!')
check_otp(g.user.phone, bag['otpcode'])
contract.status = 'Signed'
contract = {
'id': contract.id,
'code': contract.code,
'status': contract.status,
'advert_id': contract.advert_id,
'purchaser_company_id': contract.purchaser_company_id,
'supplier_company_id': contract.supplier_company_id,
'dirsection_id': contract.dirsection_id,
'total': contract.total,
'created_date': contract.created_date
}
contr = entity.add({CRUD: db.Contract, BOBJECT: contract})
return {'doc': contr}
def status_check(bag):
advert = bag['advert']
advert['type'] = bag['type']
if advert['status'] in ['Published']:
print advert['_id']
dirprocurement = g.tran.query(db.DirProcurement)\
.filter_by(_deleted='infinity', _id=advert['dirprocurement_id']).first()
dirprocurement = orm_to_json(dirprocurement)
if 'code' in dirprocurement['data'] and dirprocurement['data'][
'code'] == 'Simplified':
reason = 'Не состоялась в связи с отсутствием не менее двух участников'
else:
reason = 'Не состоялась в связи с отсутствием участников'
advert_lots = g.tran.query(db.Advert_lot)\
.filter_by(_deleted='infinity', advert_id=advert['_id']).all()
advert_lots = orm_to_json(advert_lots)
for advert_lot in advert_lots:
application_count = g.tran.query(db.Application)\
.filter_by(_deleted='infinity', advert_lot_id=advert_lot['_id'], status='Published').count()
if dirprocurement['count'] > application_count:
advert_lot['type'] = 'Advert_lot'
advert_lot['status'] = 'Canceled'
advert_lot['reason'] = reason
protocol = {
'advert_lot_id': advert_lot['_id'],
'title': 'Операция отмены',
'description': advert_lot['reason'],
}
pr = entity.add({CRUD: db.Protocol, BOBJECT: protocol})
advert_lot_res = controller.call(controller_name='data.put',
bag=advert_lot)
advert['status'] = 'Evaluation'
advert_res = controller.call(controller_name='data.put', bag=advert)
def register(bag):
if 'data' not in bag:
bag['data'] = {}
bag['secure'] = pyotp.random_base32()
bag[PASSWORD] = sha1(bag[PASSWORD] + bag['secure']).hexdigest()
if not re.match('^[a-zA-Z]+[\w\-_]+$', bag[USERNAME]):
raise CbsException(GENERIC_ERROR,
u'Имя пользователя может содержать только латинские буквы, цифры и знаки "-" и "_"!')
user = g.tran.query(db.User).filter(db.User.email == bag[EMAIL]).first()
if user:
raise CbsException(USER_ALREADY_EXISTS)
requests.post('https://www.google.com/recaptcha/api/siteverify',
data={'secret': '6Ld_ymMUAAAAAD5k8n1rKpzLT0QWBqLrqVq7DLTi',
'response': bag.get('g-recaptcha-response')
})
user = entity.add({CRUD: db.User, BOBJECT: bag})
user_data = {
ID: user.id,
EMAIL: user.email,
'role': user.role,
'roles_id': user.roles_id,
'rec_date': user.rec_date,
'data': user.data
}
token = redis_session.open_session({'user_id': user.id})
email_token = secret.dumps(bag[EMAIL], salt=SECURITY_PASSWORD_SALT)
recepient = bag[EMAIL]
send_email(email_token, recepient)
return {'token': token, 'user': user_data}
def put(bag):
notification = entity.add({CRUD: db.NotificationCompany, BOBJECT: bag})
return {'notification': notification}
def update_apps(bag):
advert = g.tran.query(db.Advert).filter_by(_deleted='infinity',
_id=bag['announce_id']).first()
if advert.status != 'Evaluation':
raise CbsException(
GENERIC_ERROR,
u'Ваше объявление не в статусе "Оценка предложении"')
if hasattr(g, 'company') and g.company._id != advert.company_id:
raise CbsException(
GENERIC_ERROR,
u'Ваша организация не является создателем этого объявления!')
for bag_lot in bag['lots']:
lot = g.tran.query(db.Advert_lot).filter_by(
_deleted='infinity', _id=bag_lot['_id']).first()
if lot.advert_id != advert._id:
raise CbsException(GENERIC_ERROR, u'Указан неверный id позиции!')
lot_applications = g.tran.query(db.Application) \
.filter(and_(db.Application.advert_lot_id == lot._id,
db.Application._deleted == INFINITY)) \
.order_by(db.Application.total, db.Application._created).all()
for appl in lot_applications:
next_appls = [
ap for ap in bag_lot['applications'] if appl._id == ap['_id']
] # find
if len(next_appls) == 0:
continue
next_appl = next_appls[0]
appl.reason = next_appl['reason']
appl.selected = next_appl['selected']
g.tran.add(appl)
if appl.selected == True:
dircategory = g.tran.query(db.DirCategory).filter(
db.DirCategory.id == lot.dircategory_id).first()
label = dircategory.name or ''
text = {
"company_id":
appl.company_id,
"type":
"Announce",
"title":
advert.code,
"description":
u"Вы являетесь победителем в позиции {}".format(label),
"description_kg":
u"Сиз {} өңүттө жеңүүчү деп табылдыңыз".format(label),
"description_en":
u"Вы являетесь победителем в позиции {}".format(label),
"notification_status":
"active",
"data": {
"announce_lot_id": appl.advert_lot_id,
"announce_id": advert._id
}
}
res = entity.add({CRUD: db.NotificationCompany, BOBJECT: text})
else:
dircategory = g.tran.query(db.DirCategory).filter(
db.DirCategory.id == lot.dircategory_id).first()
label = dircategory.name or ''
text = {
"company_id":
appl.company_id,
"type":
"Announce",
"title":
advert.code,
"description":
u"Уважаемый исполнитель, ваша заявка была отклонена по позиции {}"
.format(label),
"description_kg":
u"Урматтуу Аткаруучу, Сиздин {} өңүттөгү "
u"табыштамаңыз четке кагылган” ".format(label),
"description_en":
u"Уважаемый исполнитель, ваша заявка была отклонена по позиции {}"
.format(label),
"notification_status":
"active",
"data": {
"announce_lot_id": appl.advert_lot_id,
"announce_id": advert._id
}
}
res = entity.add({CRUD: db.NotificationCompany, BOBJECT: text})
return
def update(bag):
try:
curr_advert = g.tran.query(db.Advert) \
.filter_by(_deleted='infinity', _id=bag['id']) \
.filter(db.Advert.status.in_(['Evaluation', 'Published'])).one()
advert = orm_to_json(curr_advert)
advert['type'] = 'Advert'
if bag.get('reason', ''):
advert['status'] = 'Canceled'
advert['reason'] = bag['reason']
else:
advert['status'] = 'Results'
lots = g.tran.query(db.Advert_lot).filter_by(_deleted='infinity') \
.filter(and_(db.Advert_lot.advert_id == advert['_id'],
or_(db.Advert_lot.status != 'Canceled',
db.Advert_lot.status == None))) \
.order_by(db.Advert_lot._created.desc()).all()
for lot in lots:
appl = g.tran.query(db.Application) \
.filter(db.Application.advert_lot_id == lot._id,
db.Application._deleted == INFINITY, db.Application.selected == True) \
.first()
if appl:
contr = g.tran.query(db.Contract) \
.outerjoin(db.ContractLots, db.Contract.id == db.ContractLots.contract_id) \
.filter(and_(db.Contract.advert_id == bag['id'],
db.Contract.supplier_company_id == appl.company_id)).first()
if not contr:
sum_total = 0
for l in lots:
application = g.tran.query(db.Application) \
.filter(and_(db.Application.advert_lot_id == l._id,
db.Application._deleted == INFINITY, db.Application.selected == True,
db.Application.company_id == appl.company_id)) \
.first()
if application:
sum_total += application.total
contract = {
'code': get_code(),
'status': 'Schedule',
'advert_id': advert['_id'],
'purchaser_company_id': advert['company_id'],
'supplier_company_id': appl.company_id,
'dirsection_id': advert['dirsection_id'],
'total': sum_total,
'created_date': func.now(),
}
contr = entity.add({
CRUD: db.Contract,
BOBJECT: contract
})
if contr:
text = {
"company_id": appl.company_id,
"type": "Announce",
"title": u"Вам отправили договор",
"title_kg": u"Сизге келишим жиберилди",
"title_en": u"You sent the contract",
"description":
u"Вы получили договор, пожалуйста дайте ответ по договору",
"description_kg":
u"Сизге келишим жөнөтүлдү, келишим боюнча жооп бергиле",
"description_en":
u"You have received a contract, please give a response to the contract.",
"notification_status": "active",
"data": {
'contract_id': contr.id,
'application_id': appl._id,
'advert_lot_id': appl.advert_lot_id
}
}
entity.add({
CRUD: db.NotificationCompany,
BOBJECT: text
})
con_lot = {
'contract_id': contr.id,
'status': 'Draft',
'application_id': appl._id,
'advert_lot_id': appl.advert_lot_id,
}
con_lot = entity.add({
CRUD: db.ContractLots,
BOBJECT: con_lot
})
else:
break
advert = controller.call(controller_name='data.put', bag=advert)
except NoResultFound:
raise CbsException(GENERIC_ERROR, u'Объявление не найден')
def save(bag):
for specifations in bag:
tab_spec = {}
ds = {}
if 'id' not in specifations:
tab_spec['dircategory_id'] = specifations['dircategory_id']
spec_data = entity.add({CRUD: db.Specification, BOBJECT: tab_spec})
dirsection = g.tran.query(db.DirSection).filter_by(
_deleted='infinity', _id=specifations['section']).first()
dirsection = orm_to_json(dirsection)
if spec_data.id not in dirsection['dircategories_id']:
dirsection['type'] = "DirSection"
dirsection['dircategories_id'].append(spec_data.id)
dirsec_save = controller.call(controller_name='data.put',
bag=dirsection)
if 'dictionaries' in specifations:
for dictionary in specifations['dictionaries']:
dict = {}
dict['specification_id'] = spec_data.id
dict['dirname'] = dictionary['table']
dict['name'] = dictionary['name']
dict['role_id'] = dictionary['roles_id']
if 'id' in dictionary:
dict['id'] = dictionary['id']
entity.add({
CRUD: db.SpecificationDictionary,
BOBJECT: dict
})
if 'attr' in specifations:
for spec_attr in specifations['attr']:
spec_attr_data = {}
if 'id' in spec_attr:
spec_attr_data['id'] = spec_attr['id']
spec_attr_data['specification_id'] = spec_data.id
spec_attr_data['order'] = int(spec_attr['order'])
spec_attr_data['name'] = spec_attr['name']
spec_attr_data['name_kg'] = spec_attr['name_kg'] or None
spec_attr_data['name_en'] = spec_attr['name_en'] or None
spec_attr_data['roles_id'] = spec_attr['roles_id']
res_spec_attr_data = entity.add({
CRUD: db.SpecificationProperty,
BOBJECT: spec_attr_data
})
if 'values' in spec_attr:
for spec_attr_val in spec_attr['values']:
spec_attr_val_data = {}
if 'id' in spec_attr:
spec_attr_val_data['id'] = spec_attr_val['id']
spec_attr_val_data[
'specificationproperty_id'] = res_spec_attr_data.id
spec_attr_val_data['name'] = spec_attr_val['name']
spec_attr_val_data[
'name_kg'] = spec_attr_val['name_kg'] or None
spec_attr_val_data[
'name_en'] = spec_attr_val['name_en'] or None
entity.add({
CRUD: db.SpecificationPropertyValue,
BOBJECT: spec_attr_val_data
})
else:
tab_spec['id'] = specifations['id']
tab_spec['dircategory_id'] = specifations['dircategory_id']
spec_data = entity.add({CRUD: db.Specification, BOBJECT: tab_spec})
dirsection = g.tran.query(db.DirSection).filter_by(
_deleted='infinity', _id=specifations['section']).first()
dirsection = orm_to_json(dirsection)
if spec_data.id not in dirsection['dircategories_id']:
dirsection['type'] = "DirSection"
dirsection['dircategories_id'].append(spec_data.id)
dirsec_save = controller.call(controller_name='data.put',
bag=dirsection)
if 'dictionaries' in specifations:
spec_disc_ts_id = []
dict_Spec_id = []
spec_dict_lists = g.tran.query(db.SpecificationDictionary)\
.filter(db.SpecificationDictionary.specification_id == spec_data.id).all()
for dict_Spec in spec_dict_lists:
dict_Spec_id.append(dict_Spec.id)
for dict_s in specifations['dictionaries']:
if 'id' in dict_s:
spec_disc_ts_id.append(dict_s['id'])
sd = Set(dict_Spec_id)
td = Set(spec_disc_ts_id)
dfd = sd.symmetric_difference(td)
if len(dfd) > 0:
for d_id in dfd:
entity.remove({
CRUD: db.SpecificationDictionary,
ID: d_id
})
for dictionary in specifations['dictionaries']:
dict = {}
dict['specification_id'] = spec_data.id
dict['dirname'] = dictionary['table']
dict['name'] = dictionary['name']
dict['roles_id'] = dictionary['roles_id']
if 'id' in dictionary:
dict['id'] = dictionary['id']
entity.add({
CRUD: db.SpecificationDictionary,
BOBJECT: dict
})
if 'attr' in specifations:
for attr_s in specifations['attr']:
if 'id' in attr_s:
spec_list_values_ids = []
spec_values_ids = []
spec_attr_val_lists = g.tran.query(db.SpecificationPropertyValue)\
.filter(db.SpecificationPropertyValue.specificationproperty_id == attr_s['id']).all()
if spec_attr_val_lists:
for spec_prop_value in spec_attr_val_lists:
spec_list_values_ids.append(spec_prop_value.id)
for value in attr_s['values']:
if 'id' in value:
spec_values_ids.append(value['id'])
sd = Set(spec_list_values_ids)
td = Set(spec_values_ids)
dfd = sd.symmetric_difference(td)
if len(dfd) > 0:
for d_id in dfd:
entity.remove({
CRUD: db.SpecificationPropertyValue,
ID: d_id
})
spec_list_ids = []
spec_attr_ids = []
spec_attr_lists = g.tran.query(db.SpecificationProperty) \
.filter(db.SpecificationProperty.specification_id == spec_data.id).all()
if spec_attr_lists:
for property_Spec in spec_attr_lists:
spec_list_ids.append(property_Spec.id)
for attr in specifations['attr']:
if 'id' in attr:
spec_attr_ids.append(attr['id'])
sd = Set(spec_list_ids)
td = Set(spec_attr_ids)
dfd = sd.symmetric_difference(td)
if len(dfd) > 0:
for d_id in dfd:
spec_attr_val_list = g.tran.query(db.SpecificationPropertyValue)\
.filter(db.SpecificationPropertyValue.specificationproperty_id == d_id).all()
if spec_attr_val_list:
for val in spec_attr_val_list:
entity.remove({
CRUD:
db.SpecificationPropertyValue,
ID: val.id
})
entity.remove({
CRUD: db.SpecificationProperty,
ID: d_id
})
for spec_attr in specifations['attr']:
spec_attr_data = {}
if 'id' in spec_attr:
spec_attr_data['id'] = spec_attr['id']
spec_attr_data['specification_id'] = spec_data.id
spec_attr_data['order'] = int(spec_attr['order'])
spec_attr_data['name'] = spec_attr['name']
spec_attr_data['name_kg'] = spec_attr['name_kg'] or None
spec_attr_data['name_en'] = spec_attr['name_en'] or None
spec_attr_data['roles_id'] = spec_attr['roles_id']
res_spec_attr_data = entity.add({
CRUD: db.SpecificationProperty,
BOBJECT: spec_attr_data
})
if 'values' in spec_attr:
for spec_attr_val in spec_attr['values']:
spec_attr_val_data = {}
if 'id' in spec_attr_val:
spec_attr_val_data['id'] = spec_attr_val['id']
spec_attr_val_data[
'specificationproperty_id'] = res_spec_attr_data.id
spec_attr_val_data['name'] = spec_attr_val['name']
spec_attr_val_data[
'name_kg'] = spec_attr_val['name_kg'] or None
spec_attr_val_data[
'name_en'] = spec_attr_val['name_en'] or None
entity.add({
CRUD: db.SpecificationPropertyValue,
BOBJECT: spec_attr_val_data
})
return {'message': u'Успешно сохранили'}
def date_doct(bag):
all_docs = g.tran.query(
db.DirDocument).filter_by(_deleted='infinity').all()
status = ['confirmed']
companies = g.tran.query(db.Companies).filter_by(_deleted='infinity') \
.filter(db.Companies.company_status.in_(status)).all()
for company in companies:
for doc in all_docs:
label = doc.name
document = g.tran.query(db.Companydocument)\
.filter_by(_deleted='infinity', dirdocument_id=doc._id, company_id=company._id)\
.order_by(db.Companydocument._created.desc()).first()
date = document.date_end - datetime.now()
day = date.days
if day <= 6:
text = {
"company_id":
document.company_id,
"type":
"CompanyDocs",
"title":
u"Требуется обновления {}".format(label),
"title_kg":
u"Жаңылоо талап кылынат {}".format(doc.name_kg),
"title_en":
u"Update required {}".format(doc.name_en),
"description":
u"Срок действия справки {0} истекает через {1} дней, "
u"просим Вас обновить".format(label, day),
"description_kg":
u"{0} - Маалымат кагазынын жарактуу мөөнөтү {1} "
u"күндөн кийин аяктайт".format(doc.name_kg, day),
"description_en":
u"{0} - Reference expires in {1} days".format(
doc.name_en, day),
"notification_status":
"active",
"data": {}
}
entity.add({CRUD: db.NotificationCompany, BOBJECT: text})
elif day == 0:
text = {
"company_id":
document.company_id,
"type":
"CompanyDocs",
"title_kg":
u"Жаңылоо талап кылынат {}".format(doc.name_kg),
"title_en":
u"Update required {}".format(doc.name_en),
"description":
u"Срок действия справки {} истек, просим Вас обновить".
format(label),
"description_kg":
u"{} - Маалымат кагазынын жарактуу мөөнөтү аяктады, "
u"жаңылатууңузду суранабыз".format(doc.name_kg),
"description_en":
u"Help expired {}, please update".format(doc.name_en),
"notification_status":
"active",
"data": {}
}
res = entity.add({CRUD: db.NotificationCompany, BOBJECT: text})
elif day < 0:
break
def pur_update(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'Не найден договор')
cons_bag = bag['consignments']
invs_bag = bag['invoices']
for con_bag in cons_bag:
if 'id' in con_bag:
cons_lot_list_values_ids = []
con_bag_lot_values_ids = []
cons_list = g.tran.query(db.ConsignmentLots) \
.filter(db.ConsignmentLots.consignment_id == con_bag['id']).all()
if cons_list:
for con_value in cons_list:
cons_lot_list_values_ids.append(con_value.id)
for lot in con_bag['lots']:
con_bag_lot_values_ids.append(lot['id'])
clv_ids = Set(cons_lot_list_values_ids)
cbv_ids = Set(con_bag_lot_values_ids)
dfd = clv_ids.symmetric_difference(cbv_ids)
if len(dfd) > 0:
for d_id in dfd:
entity.remove({CRUD: db.ConsignmentLots, ID: d_id})
cons_list_values_ids = []
con_bag_values_ids = []
cons_list_values = g.tran.query(db.Consignment) \
.filter(db.Consignment.contract_id == contract.id).all()
if cons_list_values:
for con_val in cons_list_values:
cons_list_values_ids.append(con_val.id)
for con_bag_tmp in cons_bag:
if 'id' in con_bag_tmp:
con_bag_values_ids.append(con_bag_tmp['id'])
sd = Set(cons_list_values_ids)
td = Set(con_bag_values_ids)
dfd = sd.symmetric_difference(td)
if len(dfd) > 0:
for d_id in dfd:
con_lot_val_list = g.tran.query(db.ConsignmentLots) \
.filter(db.ConsignmentLots.consignment_id == d_id).all()
if con_lot_val_list:
for val in con_lot_val_list:
entity.remove({
CRUD: db.ConsignmentLots,
ID: val.id
})
entity.remove({CRUD: db.Consignment, ID: d_id})
for con_bag in cons_bag:
consigment = {}
if 'id' in con_bag:
con = g.tran.query(db.Consignment).filter(
and_(
db.Consignment.id == con_bag['id'],
db.Consignment.contract_id == contract.id,
)).first()
if not con:
raise CbsException(GENERIC_ERROR, u'Неверный consignment.id')
consigment['id'] = con_bag['id']
consigment['advert_id'] = contract.advert_id
consigment['contract_id'] = contract.id
consigment['purchaser_company_id'] = contract.purchaser_company_id
consigment['supplier_company_id'] = contract.supplier_company_id
consigment['date_to'] = con_bag['date_to'] or None
consigment['date_from'] = con_bag['date_from'] or None
consigment['address'] = con_bag['address'] or None
consigment['conditions'] = con_bag['conditions'] or None
res_con = entity.add({CRUD: db.Consignment, BOBJECT: consigment})
for lot_bag in con_bag['lots']:
lot = {}
if 'id' in lot_bag:
lot_db = g.tran.query(db.ConsignmentLots).filter(
and_(
db.ConsignmentLots.id == lot_bag['id'],
db.ConsignmentLots.consignment_id == res_con.id,
)).first()
if not lot_db:
raise CbsException(GENERIC_ERROR, u'Неверный lot.id')
lot['id'] = lot_bag['id']
contract_lot = g.tran.query(db.ContractLots).filter(
and_(
db.ContractLots.advert_lot_id == lot_bag['advert_lot_id'],
db.ContractLots.contract_id == contract.id,
)).first()
if not contract_lot:
raise CbsException(GENERIC_ERROR, u'Неверный advert_lot_id')
lot['advert_lot_id'] = lot_bag['advert_lot_id']
lot['consignment_id'] = res_con.id
lot['quantity'] = lot_bag['quantity']
# lot['unit_price'] = item['unit_price']
# lot['total'] = item['total']
res_con_lot = entity.add({CRUD: db.ConsignmentLots, BOBJECT: lot})
sum_percent = sum([d['percent'] for d in invs_bag])
if sum_percent != 100:
raise CbsException(GENERIC_ERROR,
u'Сумма платежей должна быть не менее 100%')
invoice_list_values_ids = []
invoice_bag_values_ids = []
inv_list = g.tran.query(db.Invoice) \
.filter(db.Invoice.contract_id == contract.id).all()
if inv_list:
for inv_value in inv_list:
invoice_list_values_ids.append(inv_value.id)
for lot_bag in invs_bag:
if 'id' in lot_bag:
invoice_bag_values_ids.append(lot_bag['id'])
clv_ids = Set(invoice_list_values_ids)
cbv_ids = Set(invoice_bag_values_ids)
dfd = clv_ids.symmetric_difference(cbv_ids)
if len(dfd) > 0:
for d_id in dfd:
entity.remove({CRUD: db.Invoice, ID: d_id})
for inv in invs_bag:
invoice = {}
if 'id' in inv:
invoice_db = g.tran.query(db.Invoice).filter(
and_(
db.Invoice.id == inv['id'],
db.Invoice.contract_id == contract.id,
)).first()
if not invoice_db:
raise CbsException(GENERIC_ERROR, u'Неверный Invoice.id')
invoice['id'] = inv['id']
invoice['contract_id'] = contract.id
invoice['advert_id'] = contract.advert_id
invoice['purchaser_company_id'] = contract.purchaser_company_id
invoice['supplier_company_id'] = contract.supplier_company_id
invoice['date'] = inv['date']
invoice['type'] = inv['type']
invoice['editable'] = inv['editable']
invoice['percent'] = inv['percent']
invoice['amount'] = (contract.total * inv['percent']) / 100
invoice['created_date'] = datetime.datetime.now()
invoice['updated_date'] = datetime.datetime.now()
invoice['conditions'] = inv['conditions']
# invoice['data'] = inv['data'] or {}
# invoice['status'] = inv['status']
result_invoice = entity.add({CRUD: db.Invoice, BOBJECT: invoice})
if bag.get('comment'):
contract.comment.append({
"pur_company": g.company._id,
"comment": bag['comment'],
"date": datetime.datetime.now()
})
# contract.date_pur_submit = datetime.datetime.now()
# contract.status = 'Pending'
entity.add({CRUD: db.Contract, BOBJECT: contract})
return
def update_status(bag):
companyproducts = g.tran.query(db.Company_product).filter_by(
_deleted='infinity', status='active').all()
for product in companyproducts:
dictprod = g.tran.query(db.Product).filter_by(
_deleted='infinity', _id=product.product_id).first()
dircategory = g.tran.query(db.DirCategory).filter(
db.DirCategory.id == dictprod.dircategory_id).first()
prod, dirbrand = g.tran.query(db.ProductDict, db.DirBrand).filter_by(_deleted='infinity') \
.outerjoin(db.DirBrand, db.ProductDict.dictionary_id == db.DirBrand._id)\
.filter(and_(db.ProductDict.product_id == dictprod._id, db.ProductDict.dirname == "DirBrand")).first()
label = dircategory.name + ' ' + dirbrand.name
date = product.date_end - datetime.now()
day = date.days
if day <= 6:
text = {
"company_id":
product.company_id,
"type":
"Products",
"title":
u"Требуется обновления срока истечения цены продукта",
"title_kg":
u"Продукттун баасынын мөөнөтүн жаңылоо талап кылынат",
"title_en":
u"Update of the expiration price of the product is required",
"description":
u"Срок истечения цены продукта {0} истекает через {1} дней, "
u"просим Вас обновить".format(label, day),
"description_kg":
u"{0} Продукттун баасынын жарактуу мөөнөтү {1}"
u" күндөн кийин аяктайт жана жаңылатууңузду суранабыз".format(
label, day),
"description_en":
u"Product price {0} expires in {1} days” and please update".
format(label, day),
"notification_status":
"active",
"data": {
"product_id": product._id
}
}
res = entity.add({CRUD: db.NotificationCompany, BOBJECT: text})
elif day == 0:
text = {
"company_id":
product.company_id,
"type":
"Products",
"title":
u"Требуется обновления срока истечения цены продукта",
"title_kg":
u"Продукттун баасынын мөөнөтүн жаңылоо талап кылынат",
"title_en":
u"Update of the expiration price of the product is required",
"description":
u"Срок истечения цены продукта {} истек, просим Вас обновить".
format(label),
"description_kg":
u"{} - продукттун баасынын мөөнөтү аягына чыкты, "
u"жаңылатууңузду суранабыз".format(label),
"description_en":
u"The expiry price of the product {} has expired, please update"
.format(label),
"notification_status":
"active",
"data": {
"product_id": product._id
}
}
res = entity.add({CRUD: db.NotificationCompany, BOBJECT: text})
elif day < 0:
break
def update(bag):
reg = entity.add({CRUD: db.DirCoate, BOBJECT: bag})
return {BOBJECT: orm_to_json(reg)}
def save_draft(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']
# TODO: check company.id, company owner
company = g.tran.query(db.Companies) \
.filter_by(_deleted='infinity', inn=bag_company['inn'])
if bag_company.get('_id'):
company = company.filter(db.Companies._id != bag_company['_id'])
company = company.first()
if company:
company.type = bag['Companies']
company.name = bag['name']
company.short_name = bag['short_name']
company.user_id = bag['user_id']
company.inn = bag['inn']
company.typeofownership_id = bag['typeofownership_id']
company.dircountry_id = bag['dircountry_id']
company.dircoate_id = bag['dircoate_id']
company.resident_state = bag['resident_state']
company.typeofownership = bag['typeofownership']
company.main_doc_img = bag['main_doc_img']
company.main_doc_regulations = bag['main_doc_regulations']
company.coate = bag['coate']
company.reason = bag['reason']
company.coate_name = bag['coate_name']
company.owner_data = bag['owner_data']
company.data = bag['data']
company.company_status = 'draft'
company = controller.call(controller_name='data.put', bag=company)
else:
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"] = 'draft'
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 'supplies' in bag_prequal:
bag_prequal['data']['supplies'] = bag_prequal['supplies']
if 'experiences' in bag_prequal:
bag_prequal['data']['experiences'] = bag_prequal['experiences']
prequal = controller.call(controller_name='data.put', bag=bag_prequal)
return
def save(bag):
bag['parent_id'] = str(bag['parent_id'])
result = entity.add({CRUD: db.DirCategory, BOBJECT: bag})
return {'doc': result}
def save(bag):
reg = entity.add({CRUD: db.DirDoc, BOBJECT: bag})
return {BOBJECT: orm_to_json(reg)}
