async def post(self):
data = await self.request.json()
client = Client(
email=data.get('email'),
password=data.get('password')
)
if self.request.app['db']:
client.db = self.request.app['db']
q = {
"email": client.client_email,
"password": client.password
}
client_exit = await client.get(**q)
if client_exit:
client.pk = client_exit.get('_id')
response = {
'client_id': "{}".format(client.pk),
'status': True,
'token': "{}".format(await client.token)
}
else:
response = {
'status': False,
'error': 'client not found'
}
return json_response(response)
async def post(self):
data = await self.request.json()
try:
client = Client(
pk=ObjectId(data.get('id'))
)
if self.request.app['db']:
client.db = self.request.app['db']
if await client.get():
await client.delete()
response = {
'status': True
}
else:
response = {
'status': False,
'error': 'client not found'
}
except(Exception,) as error:
response = {
'status': False,
'error': "{}".format(error)
}
return json_response(response)
async def post(self):
data = await self.request.json()
client = Client(
email=data.get('email'),
password=data.get('password')
)
if self.request.app['db']:
client.db = self.request.app['db']
q = {'email': client.client_email}
search = await client.objects.find_one(q)
if not search:
try:
response = {
'status': True,
'client_id': "{}".format(await client.save()),
}
except(Exception,) as error:
response = {
'status': False,
'error': "{}".format(error)
}
else:
response = {
'status': False,
'error': 'client already exist'
}
return json_response(response)
async def check_client(self):
"""
Метод для проверяет, что данный пользователь авторизован и что он это он.
Ищем пользователя по указанному ID в строке URL
Затем, находтим его token и сравниваем с тем, что указан в заголовке запроса
Если токены не совпадают - произойдет ошибка
"""
token_in_header = self.request.__dict__.get('headers').get('AUTHORIZATION',
'c97868d8-ccd5-43e4-914c-fe87e9438ec0')
if not token_in_header:
raise TokeInHeadersNotFound
else:
client = Client(
pk=self.client_pk
)
if self.db:
client.db = self.db
self.client = await client.get()
if not str(await client.token) == str(token_in_header):
raise TokenIsNotFound
def new_client():
form = NewClientForm(request.form)
if request.method == 'POST' and form.validate():
db_client_name = Client.name_exist(form.name.data)
if not db_client_name:
client = Client.add(form.name.data, form.industry.data)
flash(u'新建客户(%s)成功!' % client.name, 'success')
else:
flash(u'客户%s已存在，不用添加!' % form.name.data, 'danger')
return tpl('client.html', form=form, title=u"新建客户")
return redirect(url_for("client.clients"))
return tpl('client.html', form=form, title=u"新建客户")
async def get(self):
client_obj = Client(
pk=ObjectId(self.request.match_info.get('id'))
)
if self.request.app['db']:
client_obj.db = self.request.app['db']
client = await client_obj.get()
result = {
'id': "{}".format(client.get('_id')),
'email': "{}".format(client.get('email')),
}
return json_response(result)
def index():
if not g.user.is_super_admin():
abort(403)
form = ClientOrderForm(request.form)
mediums = [(m.id, m.name) for m in Medium.all()]
if request.method == 'POST' and form.validate():
if ClientOrder.query.filter_by(contract=request.values.get('contract')).count() > 0:
flash(u'合同号已存在', 'danger')
return redirect(url_for('util_insert_orders.index'))
order = ClientOrder.add(agent=Agent.get(form.agent.data),
client=Client.get(form.client.data),
campaign=form.campaign.data,
money=int("%.0f" % (form.money.data or 0)),
client_start=form.client_start.data,
client_end=form.client_end.data,
reminde_date=form.reminde_date.data,
direct_sales=User.gets(form.direct_sales.data),
agent_sales=User.gets(form.agent_sales.data),
contract_type=form.contract_type.data,
resource_type=form.resource_type.data,
sale_type=form.sale_type.data,
contract=request.values.get('contract', ''),
creator=g.user,
contract_status=2,
create_time=datetime.now())
order.add_comment(g.user,
u"导入了客户订单:%s - %s - %s" % (
order.agent.name,
order.client.name,
order.campaign
))
medium_ids = request.values.getlist('medium')
medium_moneys = request.values.getlist('medium_money')
medium_moneys2 = request.values.getlist('medium_money2')
medium_contracts = request.values.getlist('medium_contract')
if medium_ids and medium_moneys and len(medium_ids) == len(medium_moneys):
for x in range(len(medium_ids)):
medium = Medium.get(medium_ids[x])
mo = Order.add(campaign=order.campaign,
medium=medium,
sale_money=int("%.0f" % (form.money.data or 0)),
medium_money=int(medium_moneys[x] or 0),
medium_money2=int(medium_moneys2[x] or 0),
medium_contract=medium_contracts[x],
medium_start=order.client_start,
medium_end=order.client_end,
creator=g.user)
order.medium_orders = order.medium_orders + [mo]
order.add_comment(g.user, u"导入了媒体订单: %s %s元" %
(medium.name, mo.sale_money))
order.save()
flash(u'导入客户订单成功!', 'success')
insert_executive_report(order, '')
return redirect(order.info_path())
else:
form.client_start.data = datetime.now().date()
form.client_end.data = datetime.now().date()
form.reminde_date.data = datetime.now().date()
return tpl('insert_order.html', form=form, mediums=mediums)
def douban_order_json():
if not (g.user.is_super_leader() or g.user.is_aduit() or g.user.is_finance()):
abort(403)
now_date = datetime.datetime.now()
location = int(request.values.get('location', 0))
start_year = str(request.values.get('start_year', now_date.year))
start_month = str(request.values.get('start_month', now_date.month))
end_year = str(request.values.get('end_year', now_date.year - 1))
end_month = str(request.values.get('end_month', now_date.month))
start_date_month = datetime.datetime.strptime(
start_year + '-' + start_month, '%Y-%m')
end_date_month = datetime.datetime.strptime(
end_year + '-' + end_month, '%Y-%m')
douban_orders = DoubanOrderExecutiveReport.query.filter(
DoubanOrderExecutiveReport.month_day >= start_date_month,
DoubanOrderExecutiveReport.month_day <= end_date_month)
medium_orders = MediumOrderExecutiveReport.query.filter(
MediumOrderExecutiveReport.month_day >= start_date_month,
MediumOrderExecutiveReport.month_day <= end_date_month)
medium_orders = [_format_order(k) for k in medium_orders if k.status == 1]
medium_date = [{'client_name': k['client'].name,
'medium_id': k['medium_id'],
'money':_get_money_by_location(k, location)}
for k in medium_orders if k['medium_id'] in [3, 8]]
douban_orders = [_format_order(k, 'douban')
for k in douban_orders if k.status == 1]
douban_date = [{'client_name': k['client'].name,
'money':_get_money_by_location(k, location)}
for k in douban_orders]
client_params = {}
for k in Client.all():
client_params[k.name] = 0
for k in douban_date + medium_date:
if k['client_name'] in client_params:
client_params[k['client_name']] += k['money']
client_params = sorted(client_params.iteritems(), key=lambda x: x[1])
client_params.reverse()
data = [{
"name": u"占比",
"data": []
}]
sum_saler_money = sum([v for k, v in client_params])
for k, v in client_params:
if v > 0:
if sum_saler_money == 0:
percent = u'0.00%'
else:
percent = v / sum_saler_money * 100
data[0]['data'].append({'name': k,
'y': v,
'percent': percent})
return jsonify({'data': data, 'title': u'直签豆瓣订单（含：优力、无线）客户分析',
'total': float(sum_saler_money)})
async def wrapper(request, *args, **kwargs):
token_in_header = request._request.__dict__.get('headers').get('AUTHORIZATION', None)
if token_in_header:
try:
token = Token()
if request._request.app['db']:
token.db = request._request.app['db']
token_is = await token.objects.find_one({
'token': token_in_header
})
if not token_is:
raise TokenIsNotFound
else:
client = Client(
pk=token_is.get('client')
)
if request._request.app['db']:
client.db = request._request.app['db']
request._request.client = await client.get()
if not client:
raise ClientNotFoundViaToken
else:
return await func(request, *args, **kwargs)
except(Exception,) as error:
return json_response({
'status': False,
'error': '{}'.format(error)
})
else:
return json_response({
'status': False,
'error': 'need token in headers'
})
def douban_order_excle_data():
now_date = datetime.datetime.now()
location = int(request.values.get('location', 0))
start_year = str(request.values.get('start_year', now_date.year))
start_month = str(request.values.get('start_month', now_date.month))
end_year = str(request.values.get('end_year', now_date.year - 1))
end_month = str(request.values.get('end_month', now_date.month))
start_date_month = datetime.datetime.strptime(
start_year + '-' + start_month, '%Y-%m')
end_date_month = datetime.datetime.strptime(
end_year + '-' + end_month, '%Y-%m')
douban_orders = DoubanOrderExecutiveReport.query.filter(
DoubanOrderExecutiveReport.month_day >= start_date_month,
DoubanOrderExecutiveReport.month_day <= end_date_month)
medium_orders = MediumOrderExecutiveReport.query.filter(
MediumOrderExecutiveReport.month_day >= start_date_month,
MediumOrderExecutiveReport.month_day <= end_date_month)
medium_orders = [_format_order(k) for k in medium_orders if k.status == 1]
medium_date = [{'client_name': k['client'].name,
'medium_id': k['medium_id'],
'money':_get_money_by_location(k, location)}
for k in medium_orders if k['medium_id'] in [3, 8]]
douban_orders = [_format_order(k, 'douban')
for k in douban_orders if k.status == 1]
douban_date = [{'client_name': k['client'].name,
'money':_get_money_by_location(k, location)}
for k in douban_orders]
client_params = {}
for k in Client.all():
client_params[k.name] = 0
for k in douban_date + medium_date:
if k['client_name'] in client_params:
client_params[k['client_name']] += k['money']
client_params = sorted(client_params.iteritems(), key=lambda x: x[1])
client_params = [(k, v) for k, v in client_params if v > 0]
client_params.reverse()
headings = ['#', u'客户名称', u'执行额', u'占比']
data = []
data.append([k + 1 for k in range(len(client_params))])
data.append([k for k, v in client_params])
data.append([v for k, v in client_params])
sum_saler_money = sum([v for k, v in client_params])
if sum_saler_money:
data.append(['%.2f%%' % (v / sum_saler_money * 100)
for k, v in client_params])
else:
data.append(['0.00%' for k, v in client_params])
return {'data': data, 'title': u'直签豆瓣订单（含：优力、无线）客户分析',
'total': float(sum_saler_money), 'headings': headings}
async def check_receiver(self, receiver: ObjectId):
"""
Метод проверяет, что получатель существует и находится в чате с отправителем.
:param receiver: индификатор получателя
"""
client = Client(
pk=ObjectId(receiver)
)
if self.db:
client.db = self.db
await client.get()
q = {
'chat': self.chat_pk,
'client': ObjectId(receiver)
}
if not await self.client_in_chat.get(**q):
self.client_in_chat.save(**q)
def client_detail(client_id):
client = Client.get(client_id)
if not client:
abort(404)
form = NewClientForm(request.form)
if request.method == 'POST' and form.validate():
client.name = form.name.data
client.industry = form.industry.data
client.save()
flash(u'保存成功', 'success')
else:
form.name.data = client.name
form.industry.data = client.industry
return tpl('client.html', form=form, title=u"客户-" + client.name)
def post(self):
client_id = int(self.request.headers['Client-Id'] or 0)
if not client_id:
self.abort(400)
client = Client.get(client_id)
if not client_id:
self.abort(400)
code = self.request.get('code')
try:
check_result = platius.check_sms(client.tel, code)
except platius.PlatiusError:
self.render_json({"authorized": False})
else:
platius_client = PlatiusClient.create_or_overwrite(
client, check_result['userId'], check_result['token'])
self.render_json(_get_barcode_info(platius_client))
def create_shop():
user = User()
user.username = '******'
user.passwd = 'test_pass'
user.save()
client = Client()
client.username = '******'
client.email = 'test_phone'
client.phone = 'test_pass'
client.save()
shop = Shop()
shop.user = user.id
shop.client = client.id
shop.save()
return shop
def add(self, *args):
try:
newEntity: Client = Client()
if len(args) > 0 and isinstance(args[0], Client):
newEntity = args[0]
else:
newEntity.fill()
if newEntity.isFull():
self.db.cursor.execute(
f'INSERT INTO db_labs.public."Client" ({newEntity.getKeys()}) '
f'VALUES ({newEntity.getValues()}) RETURNING id')
self.db.connect.commit()
return int(self.db.cursor.fetchone()[0])
except Exception as err:
print("Add error! ", err)
return False
def cancel(self, namespace):
from methods.alfa_bank import reverse
if self.status == self.READY:
legal = LegalInfo.query().get(
) # TODO find solution for multiple legals
reverse(legal.alfa_login, legal.alfa_password, self.payment_id)
share = Share.get_by_id(self.share_id)
share.deactivate()
promo_code = self.promo_code.get()
promo_code.deactivate()
self.status = self.CANCELED
self.put()
sender = Client.get(self.client_id)
text = u'Ваш подарок не был получен. Ссылка более не будет активна, а деньги вернутся в ближайшее время.'
header = u'Отмена подарка'
SimplePush(text, False, text, header, sender, namespace).send()
def post(self):
client_id = int(self.request.headers.get('Client-Id') or 0)
client = Client.get(client_id)
if not client:
self.abort(400)
order_id = self.request.get_range('order_id')
order = Order.get_by_id(order_id)
if order.client_id != client.key.id():
self.abort(409)
meal_rate = float(self.request.get('meal_rate'))
service_rate = float(self.request.get('service_rate'))
comment = self.request.get('comment')
rate = OrderRate(meal_rate=meal_rate,
service_rate=service_rate,
comment=comment)
order.rate = rate
order.put()
is_negative = 0 < meal_rate < 4 or 0 < service_rate < 4
if is_negative or rate.comment:
conf = config.Config.get()
venue = Venue.get(order.venue_id)
emails = conf.SUPPORT_EMAILS
body = u"Клиент: {0} {1}<br>" \
u"Заказ: {2}<br>" \
u"Точка: {3}<br>" \
u"Оценка еды: {4} из 5<br>" \
u"Оценка обслуживания: {5} из 5<br>" \
.format(client.tel, client.name, order.number, venue.title, meal_rate, service_rate)
if comment:
body += u"Комментарий: %s" % comment
logging.info(body)
to = emails
cc = ['*****@*****.**', '*****@*****.**']
subject = u'Негативный отзыв о заказе' if is_negative else u'Отзыв о заказе с комментарием'
postmark.send_email('*****@*****.**',
to,
subject,
body,
cc_email=cc)
self.render_json({})
def get_user(cls, name):
user_id = cls.is_user_registered(name)
if user_id is False:
raise UserNotRegistered()
user = ClientProxy.query(id=user_id)
if user != []:
from models.client import Client
return Client.make_client(user[0])
user = MechanicProxy.query(id=user_id)
if user != []:
from models.mechanic import Mechanic
return Mechanic.make_mechanic(user[0])
raise Exception('Why are you here!')
def authorize():
global grant
global _redirect_url
user = current_user()
if request.method == 'GET':
request_data = request.args
client_id = request_data.get('client_id')
redirect_url = request_data.get('redirect_uri')
raw_redirect_url = redirect_url.split('?')[0]
_token = request_data.get('token')
_state = request_data.get('state')
_redirect_url = redirect_url + '&token=%s&state=%s' % (_token, _state)
response_type = request_data.get('response_type')
grant = Client.select().filter(Client.client_id == client_id).first()
if grant:
if grant.response_type != response_type:
return jsonify(code=1, msg='Not support response_type')
else:
if raw_redirect_url == grant.redirect_uri:
back_uri = settings.HOST + '/oauth/authorize?' \
'redirect_uri=%s&client_id=%s' \
'&response_type=%s&state=%s' % (
redirect_url,
client_id,
response_type,
_state
)
print('\r\n**************back_uri**************\r\n')
print(back_uri)
print('\r\n**************back_uri**************\r\n')
return render_template('authrized.html',
grant=grant,
user=user,
back_uri=back_uri)
else:
return jsonify(code=1, msg='incorrect redirect_uri')
else:
return jsonify(code=1, msg='grant Not such client')
else:
if request.form['confirm'] == 'Submit':
uri = gen_auth_code(grant=grant,
redirect_uri=_redirect_url,
grant_user=user)
return myredirect(uri)
else:
return jsonify(code=1, msg='Client give up')
def dict(self, extra_fields_in_comment=True):
dct = self.history_dict()
client = Client.get(self.client_id)
dct.update({
"total_sum":
self.total_sum,
"actual_delivery_time":
timestamp(self.actual_delivery_time)
if self.actual_delivery_time else None,
"client":
client.dict(with_extra_fields=not extra_fields_in_comment),
"pan":
self.pan,
"comment":
self.get_comment(client, extra_fields=extra_fields_in_comment),
"return_comment":
self.return_comment
})
if not extra_fields_in_comment:
from models.config.config import config
from methods.rendering import latinize
extra = []
if config.ORDER_MODULE and config.ORDER_MODULE.status == STATUS_AVAILABLE:
for field in config.ORDER_MODULE.extra_fields:
key = latinize(field.title)
value = self.extra_data and self.extra_data.get(key)
extra.append({
"field": key,
"title": field.title,
"value": value
})
if config.ORDER_MODULE.enable_number_of_people:
extra.append({
"field": "num_people",
"title": u"Количество персон",
"value": self.extra_data.get('num_people')
})
if config.ORDER_MODULE.enable_change:
extra.append({
"field": "cash_change",
"title": u"Сдача с",
"value": self.extra_data.get('cash_change')
})
dct["extra_data"] = extra
return dct
def verify_auth_code(data):
client = Client.select().filter(
Client.client_id == data.get('client_id')).first()
if client:
if data.get('client_secret') != client.client_secret:
return {'code': 1, 'msg': 'client_secret is error'}
else:
authcode = AuthCode.select().filter(
AuthCode.code == data.get('code')).first()
if authcode:
if authcode.is_expired():
return {'code': 1, 'msg': 'code is_expired'}
else:
return {'code': 0, 'msg': 'code is ok'}
else:
return {'code': 1, 'msg': 'code is error'}
else:
return {'code': 1, 'msg': 'code verify error no such client'}
def index():
print g.user.is_contract()
if not (g.user.is_super_admin() or g.user.is_contract()):
abort(403)
form = DoubanOrderForm(request.form)
if request.method == 'POST' and form.validate():
if DoubanOrder.query.filter_by(contract=request.values.get('contract')).count() > 0:
flash(u'合同号已存在', 'danger')
return redirect(url_for('util_insert_douban_orders.index'))
order = DoubanOrder.add(client=Client.get(form.client.data),
agent=Agent.get(form.agent.data),
campaign=form.campaign.data,
money=int(round(float(form.money.data or 0))),
medium_CPM=form.medium_CPM.data,
sale_CPM=form.sale_CPM.data,
client_start=form.client_start.data,
client_end=form.client_end.data,
reminde_date=form.reminde_date.data,
direct_sales=User.gets(form.direct_sales.data),
agent_sales=User.gets(form.agent_sales.data),
operaters=User.gets(form.operaters.data),
designers=User.gets(form.designers.data),
planers=User.gets(form.planers.data),
contract_type=form.contract_type.data,
resource_type=form.resource_type.data,
sale_type=form.sale_type.data,
creator=g.user,
contract=request.values.get('contract'),
contract_status=2,
create_time=datetime.now())
order.add_comment(g.user,
u"导入了直签豆瓣订单:%s - %s - %s" % (
order.agent.name,
order.client.name,
order.campaign
))
insert_executive_report(order, '')
flash(u'导入订单成功', 'success')
return redirect(order.info_path())
else:
form.client_start.data = datetime.now().date()
form.client_end.data = datetime.now().date()
form.reminde_date.data = datetime.now().date()
return tpl('insert_douban_order.html', form=form)
def index():
print g.user.is_contract()
if not (g.user.is_super_admin() or g.user.is_contract()):
abort(403)
form = DoubanOrderForm(request.form)
if request.method == 'POST' and form.validate():
if DoubanOrder.query.filter_by(
contract=request.values.get('contract')).count() > 0:
flash(u'合同号已存在', 'danger')
return redirect(url_for('util_insert_douban_orders.index'))
order = DoubanOrder.add(client=Client.get(form.client.data),
agent=Agent.get(form.agent.data),
campaign=form.campaign.data,
money=int(round(float(form.money.data or 0))),
medium_CPM=form.medium_CPM.data,
sale_CPM=form.sale_CPM.data,
client_start=form.client_start.data,
client_end=form.client_end.data,
reminde_date=form.reminde_date.data,
direct_sales=User.gets(form.direct_sales.data),
agent_sales=User.gets(form.agent_sales.data),
operaters=User.gets(form.operaters.data),
designers=User.gets(form.designers.data),
planers=User.gets(form.planers.data),
contract_type=form.contract_type.data,
resource_type=form.resource_type.data,
sale_type=form.sale_type.data,
creator=g.user,
contract=request.values.get('contract'),
contract_status=2,
create_time=datetime.now())
order.add_comment(
g.user, u"导入了直签豆瓣订单:%s - %s - %s" %
(order.agent.name, order.client.name, order.campaign))
insert_executive_report(order, '')
flash(u'导入订单成功', 'success')
return redirect(order.info_path())
else:
form.client_start.data = datetime.now().date()
form.client_end.data = datetime.now().date()
form.reminde_date.data = datetime.now().date()
return tpl('insert_douban_order.html', form=form)
def post():
content = request.form
matter_ids = content.get('matters', '')
client = Client()
client.user_id = content.get('userId', None)
if matter_ids:
matters = [
Matter.query.get(int(id)) for id in matter_ids.split(",")
]
client.matters = matters
try:
client.save()
return render_json(200, {'client': client.to_json()})
except:
return render_json(500, {'message': "An error occurred."})
def __init__(self, *args, **kwargs):
super(DoubanOrderForm, self).__init__(*args, **kwargs)
self.agent.choices = [(m.id, m.name) for m in Agent.all()]
self.client.choices = [(c.id, c.name) for c in Client.all()]
self.direct_sales.choices = [(m.id, m.name) for m in User.sales()]
self.agent_sales.choices = [(m.id, m.name) for m in User.sales()]
self.assistant_sales.choices = [(m.id, m.name) for m in User.sales()]
operaters = User.gets_by_team_type(
TEAM_TYPE_OPERATER) + User.gets_by_team_type(
TEAM_TYPE_OPERATER_LEADER)
self.operaters.choices = [(m.id, m.name) for m in operaters]
self.designers.choices = [
(m.id, m.name) for m in User.gets_by_team_type(TEAM_TYPE_DESIGNER)
]
self.planers.choices = [
(m.id, m.name) for m in User.gets_by_team_type(TEAM_TYPE_PLANNER)
]
self.contract_type.choices = CONTRACT_TYPE_CN.items()
self.resource_type.choices = RESOURCE_TYPE_CN.items()
self.sale_type.choices = SALE_TYPE_CN.items()
def create():
post_data = request.get_json()
name = post_data['name']
project_type = post_data['projectType']
client_id = post_data['clientID']
date = post_data['date']
currency = post_data['currency']
total = post_data['total']
project = Project(name=name,
project_type=project_type,
client_id=client_id,
date=date,
currency=currency,
total=total)
if project.save():
client = Client.get_by_id(client_id)
client_data = {
"id": int(client.id),
"name": client.name,
"industry": client.industry,
"country": client.country
}
project_data = {
"id": project.id,
"name": project.name,
"project_type": project.project_type,
"client": client_data,
"date": str(project.date),
"currency": str(project.currency),
"total": project.total
}
return jsonify(status="success",
message=f"Project added: {name}",
project=project_data)
else:
return jsonify(status="failed", message="Failed to save new project.")
def __client_db(self):
print(bcolors.BOLD + '---------- Client DB ----------' + bcolors.ENDC)
if not self.profile:
print(
bcolors.HEADER + 'no profile ?> ' + bcolors.ENDC,
bcolors.OKGREEN + 'OK' if False else bcolors.FAIL +
"Please call __profile_db()", bcolors.ENDC)
return
self.client = Client()
self.client.address = "TEST 1"
self.client.comp_address = "TEST 2"
self.client.zipcode = "TEST 3"
self.client.id_profile = self.profile.id
self.client.name = "TEST 4"
self.client.country = "TEST 5"
self.client.city = "TEST 6"
inscdao = self.cdao.insert(self.client)
print(bcolors.HEADER + 'insert client ?> ' + bcolors.ENDC,
bcolors.OKGREEN + 'OK' if inscdao else bcolors.FAIL + "KO",
bcolors.ENDC)
self.client.zipcode = "13013"
chzipcodecdao = self.cdao.update(self.client)
print(bcolors.HEADER + 'update client ?> ' + bcolors.ENDC,
bcolors.OKGREEN + 'OK' if chzipcodecdao else bcolors.FAIL + "KO",
bcolors.ENDC)
get_client_list = self.cdao.get(
self.cdao.where('name', self.client.name))
print(
bcolors.HEADER + 'get client ?> ' + bcolors.ENDC,
bcolors.OKGREEN + 'OK' if get_client_list else bcolors.FAIL + "KO",
bcolors.ENDC)
if not get_client_list:
return False
self.client = get_client_list[0]
is_change_zipcode = (self.client.zipcode == "13013")
print(
bcolors.HEADER + 'change zip code client ?> ' + bcolors.ENDC,
bcolors.OKGREEN + 'OK' if is_change_zipcode else bcolors.FAIL +
"KO", bcolors.ENDC)
return (inscdao and chzipcodecdao and is_change_zipcode)
def gen_token_return(params):
access_token = generate_token(48)
refresh_token = generate_token(48)
client_id = params.get('client_id')
code = params.get('code')
authcode = AuthCode.select().filter(AuthCode.code == code).first()
if authcode and not authcode.is_expired():
client = Client.select().filter(Client.client_id == client_id).first()
if client:
token_tmp = AuthToken(user_id=authcode.user_id,
client_id=client.client_id,
token_type='public',
access_token=access_token,
refresh_token=refresh_token,
scope=client.scope,
expires_in=172800)
token_tmp.save()
return {'code': 0, 'msg': 'token is ok', 'data': token_tmp}
else:
return {'code': 1, 'msg': 'token general error No such client'}
else:
return {'code': 1, 'msg': 'auth_code is_expired'}
def update_client(id):
data = request.get_json()
client = Client.find_by_id(id)
if not client:
return {
'message':
f'No se encuentra el client con el ID [{id}] especificado'
}, 404
client.description = data.get('description', '')
client.city = data['city']
client.email = data['email']
try:
client.save_to_db()
except Exception:
return {
"message": "ocurrio un error en la actualización del medidor."
}, 500
return client.json(), 201
class ClientDAOTests(unittest.TestCase):
client = Client("Test Client")
def test_01_insert(self):
self.assertEqual(ClientDAO.create_client(ClientDAOTests.client), True)
def test_02_get_all(self):
clients = ClientDAO.get_all_clients()
ClientDAOTests.client = clients.pop()
self.assertTrue(clients)
def test_92_update_client(self):
ClientDAOTests.client.name = "Updated test client"
self.assertTrue(ClientDAO.update_client(ClientDAOTests.client))
def test_03_get_one(self):
self.assertTrue(ClientDAO.get_client(ClientDAOTests.client.id))
def test_94_delete_client(self):
client = ClientDAO.get_all_clients().pop()
self.assertTrue(ClientDAO.delete_client(client.id))
class ClientServiceTest(unittest.TestCase):
client = Client("Test Client")
def test_01_insert(self):
self.assertTrue(ClientService.create_client(ClientServiceTest.client))
def test_02_get_all(self):
clients = ClientService.get_all_clients()
ClientServiceTest.client = Client.deserialize(clients.pop())
self.assertTrue(clients)
def test_03_get_one(self):
self.assertTrue(ClientService.get_client(ClientServiceTest.client.id))
def test_93_update(self):
ClientServiceTest.client.name = "Updated Test Client"
self.assertTrue(ClientService.update_client(ClientServiceTest.client))
def test_94_delete(self):
self.assertTrue(
ClientService.delete_client(ClientServiceTest.client.id))
def create_client():
data = request.get_json()
idclient = data['idclient']
if Client.find_by_idclient(idclient):
return {
'message': f"Existe un cliente con el identificador '{idclient}'."
}, 500
client = Client(idclient, data.get('description', ''), data['city'],
data['email'])
try:
client.save_to_db()
except Exception:
return {"message": "ocurrio un error en la creacion del cliente."}, 500
return client.json(), 201
def put(user_id):
client = Client.find_by_user_id(user_id)
if client:
content = request.form
matter_ids = content.get('matters', '')
if matter_ids:
print matter_ids
matters = [
Matter.query.get(int(id)) for id in matter_ids.split(",")
]
client.matters = matters
try:
client.save()
return render_json(200, {'client': client.to_json()})
except:
return render_json(500, {'message': "An error occurred."})
return render_json(
404,
{'message': 'No client with user ID {} found'.format(user_id)})
def index():
auth_header = request.headers.get('Authorization')
if auth_header:
token = auth_header.split(" ")[1]
else:
return jsonify(status="failed",
message="No authorization header found.")
user_id = decode_auth_token(token)
user = User.get(User.id == int(user_id))
clients = Client.select()
client_data = [{
"id": int(c.id),
"name": c.name,
"industry": c.industry,
"country": c.country
} for c in clients]
if user:
return jsonify(client_data)
else:
return jsonify(status="failed", message="Authentication failed")
def get(self, username):
client = Client.get_by_username(username=username)
if client is None:
return {'message': 'client not found'}, HTTPStatus.NOT_FOUND
current_client = get_jwt_identity()
if current_client == client.id:
data = {
'id': client.id,
'username': client.username,
'email': client.email,
'password': client.password
}
else:
data = {
'id': client.id,
'username': client.username,
}
return data, HTTPStatus.OK
def test_shops(self):
"""
test the @property shop to retrieve a
list of shop correspoding to this user
"""
user = User()
user.username = '******'
user.passwd = 'test_pass'
user.save()
client = Client()
client.username = '******'
client.email = 'test_phone'
client.phone = 'test_pass'
client.save()
user.save()
shop = Shop()
shop.user = user.id
shop.client = client.id
shop.save()
req_shop = user.shops[0]
self.assertIsNotNone(req_shop)
storage.delete(user)
storage.save()
storage.close()
from models.client import Client
if __name__ == '__main__':
matrix_p2 = "0,0,1,9,5,7,0,6,3,0,0,0,8,0,6,0,7,0,7,6,9,1,3,0,8,0,5,0,0,7,2,6,1,3,5,0,3,1,2,4,9,5,7,8,6,0,5,6,3,7,8,0,0,0,1,0,8,6,0,9,5,0,7,0,9,0,7,1,0,6,0,8,6,7,4,5,8,3,0,0,0"
matrix_p = "0,0,4,0,0,6,0,2,0,0,0,7,8,0,0,9,1,0,0,0,0,0,0,0,3,0,8,0,1,8,3,0,0,2,0,0,3,0,0,7,8,9,0,0,1,0,0,9,0,0,1,0,6,0,8,0,3,0,0,0,5,0,0,0,4,5,0,0,3,6,0,0,0,2,6,5,0,0,1,0,0"
client = Client("localhost", 25000)
client.request_solve(matrix_p2, 3)
solv = ""
while not client.flag:
pass
solv = client.response
print("Response: ", solv)
print("Column: ", 18 % 9, " Row: ", 18 / 9)
def clients():
info = request.values.get('info', '')
clients = Client.all()
if info:
clients = [c for c in clients if info in c.name]
return tpl('clients.html', clients=clients, info=info)
def _into_order(param):
group = Group.query.filter_by(name=u'默认集团').first()
if not group:
group = Group.add(name=u'默认集团')
group.save()
agent = Agent.query.filter_by(name=param['agent_name']).first()
if not agent:
agent = Agent.add(
name=param['agent_name'],
group=group,
tax_num='',
address='',
phone_num='',
bank='',
bank_num='',
)
client = Client.query.filter_by(name=param['client_name']).first()
if not client:
client = Client.add(name=param['client_name'], industry=1)
# client.save()
medium = Medium.query.filter_by(name=param['medium_name']).first()
if not medium:
medium = Medium.add(name=param['medium_name'],
abbreviation=param['medium_name'],
tax_num='',
address='',
phone_num='',
bank='',
bank_num='',
owner=Team.query.filter_by(type=8).first())
team_huabei = Team.query.filter_by(name=u'导入渠道销售团队华北').first()
if not team_huabei:
team_huabei = Team.add(
name=u'导入渠道销售团队华北',
type=4,
location=1,
admins=[],
)
team_huanan = Team.query.filter_by(name=u'导入渠道销售团队华南').first()
if not team_huanan:
team_huanan = Team.add(
name=u'导入渠道销售团队华南',
type=4,
location=3,
admins=[],
)
team_huadong = Team.query.filter_by(name=u'导入渠道销售团队华东').first()
if not team_huadong:
team_huadong = Team.add(
name=u'导入渠道销售团队华东',
type=4,
location=2,
admins=[],
)
team_qita = Team.query.filter_by(name=u'导入渠道销售团队其他').first()
if not team_qita:
team_qita = Team.add(
name=u'导入渠道销售团队其他',
type=4,
location=0,
admins=[],
)
if not param['agent_sale_name']:
agents = []
else:
agent_names = param['agent_sale_name'].split(' ')
agents = []
if param['location'] == u'华北':
team = team_huabei
elif param['location'] == u'华东':
team = team_huadong
elif param['location'] == u'华南':
team = team_huanan
else:
team = team_qita
for k in agent_names:
name = k.strip()
p_name = p.get_pinyin(name, '').lower()
email = p_name + '@inad.com'
user = User.query.filter_by(email=email).first()
if not user:
user = User.add(name, email, 'pwd@inad', team, 1)
agents.append(user.id)
if param['contract_type'].find(u'非标') >= 0:
contract_type = 1
else:
contract_type = 0
if param['resource_type'].find(u'硬广') >= 0:
resource_type = 0
elif param['resource_type'].find(u'互动') >= 0:
resource_type = 1
else:
resource_type = 4
if param['sale_type'] == u'代理':
sale_type = 0
else:
sale_type = 1
if ClientOrder.query.filter_by(agent=agent,
client=client,
campaign=param['campaign'],
status=1).first():
return
order = ClientOrder.add(
agent=agent,
client=client,
campaign=param['campaign'],
money=param['money'],
client_start=param['medium_start'],
client_end=param['medium_end'],
reminde_date=param['reminde_date'],
direct_sales=[],
agent_sales=User.gets(agents),
contract_type=contract_type,
resource_type=resource_type,
sale_type=sale_type,
creator=g.user,
create_time=datetime.datetime.now(),
)
order.add_comment(
g.user, u"新建了客户订单:%s - %s - %s" %
(order.agent.name, order.client.name, order.campaign))
mo = Order.add(campaign=order.campaign,
medium=medium,
sale_money=param['money'],
medium_money=param['medium_money'],
medium_money2=param['medium_money2'],
medium_start=param['medium_start'],
medium_end=param['medium_end'],
creator=g.user)
order.add_comment(g.user,
u"新建了媒体订单: %s %s元" % (medium.name, mo.sale_money))
order.medium_orders = [mo]
order.save()
return
def update(oid):
out = Out.get(oid)
joiners_form = JoinersForm(request.form)
joiners_form.joiners.data = [u.id for u in out.joiners]
m_persions = []
if g.user.is_out_saler:
m_persions += [{'key': '1' + '-' +
str(k.id) + '-' + k.name, 'name': k.name} for k in Client.all()]
m_persions += [{'key': '2' + '-' +
str(k.id) + '-' + k.name, 'name': k.name} for k in Agent.all()]
m_persions += [{'key': '3' + '-' +
str(k.id) + '-' + k.name, 'name': k.name} for k in Medium.all()]
m_persions.append({'key': 100, 'name': u'其他'})
if request.method == 'POST':
if g.user.is_out_saler:
creator_type = 1
else:
creator_type = 2
start_time = request.values.get('start_time', '')
end_time = request.values.get('end_time', '')
# m_person有两种类型，一种是其他所以填写，一种是代理+客户+媒体组合而成，例如：1-1，2-1，3-1（具体请查看m_persions）
m_persion = request.values.get('m_persion', '')
m_persion_type = int(request.values.get('m_persion_type', 1))
reason = request.values.get('reason', '')
persions = request.values.get('persions', '')
address = request.values.get('address', '')
joiners = User.gets(request.values.getlist('joiners'))
out.start_time = datetime.datetime.strptime(
start_time, '%Y-%m-%d %H:%M')
out.end_time = datetime.datetime.strptime(end_time, '%Y-%m-%d %H:%M')
out.reason = reason
out.joiners = joiners
out.persions = persions
out.address = address
out.m_persion = m_persion
out.m_persion_type = m_persion_type
out.creator_type = creator_type
out.status = int(request.values.get('action', 0))
out.create_time = datetime.datetime.now()
out.save()
# 先删除外出报表，在从新添加
OutReport.query.filter_by(out_id=oid).delete()
for k in list(set(joiners + [out.creator])):
OutReport.add(
start_time=datetime.datetime.strptime(
start_time, '%Y-%m-%d %H:%M'),
end_time=datetime.datetime.strptime(
end_time, '%Y-%m-%d %H:%M'),
reason=reason,
out=out,
meeting_s='',
persions=persions,
address=address,
m_persion=m_persion,
m_persion_type=m_persion_type,
creator_type=creator_type,
status=int(request.values.get('action', 0)),
creator=k,
create_time=datetime.datetime.now()
)
if int(int(request.values.get('action', 0))) == OUT_STATUS_APPLY:
flash(u'已发送申请', 'success')
account_out_apply_signal.send(
current_app._get_current_object(), out=out, status=1)
else:
flash(u'添加成功，请及时申请外出报备', 'success')
return redirect(url_for('account_out.index'))
return tpl('/account/out/update.html', out=out, m_persions=m_persions, joiners_form=joiners_form)
def first_run():
from models.client import Client
from models.category import Category
from models.orders import Order
from models.product import Product
from models.restaurants import Restaurant
from models.user import User
meta = sqlalchemy.MetaData(engine)
meta.reflect()
#meta.drop_all()
print("First run, please wait while the db is being populated...")
# Create tables
Base.metadata.create_all(engine)
testClient = Client.add("6977988551")
testClient2 = Client.add("8891155521")
restaurant = Restaurant.add(
"Restaurant 1",
"The best food you'll find in the city\nWe make sandwiches, salads and burgers"
)
sandwichesCategory = Category.add("Sandwiches", restaurant)
Product.add("Pulled Pork", "With tangy barbecue sauce on an onion knot",
9.50, restaurant, sandwichesCategory)
Product.add(
"Turkey Club",
"Roasted turkey breast, bacon, lettuce, avocado and tomato on baguette",
8, restaurant, sandwichesCategory)
Product.add(
"Reuben",
"Corned beef, melted swiss, sauerkraut and thousand island on marbled rye",
8, restaurant, sandwichesCategory)
Product.add(
"Shrimp Cilantro Wrap",
"Shrimp, avocado, mixed greens, salsa, cilantro and may on a tomato tortilla",
8.5, restaurant, sandwichesCategory)
burgerCategory = Category.add("Burgers", restaurant)
Product.add(
"Grass-fed Beef Burger",
"With sharp cheddar, heirloom tomatoes and caramelized onions", 9.5,
restaurant, burgerCategory)
Product.add(
"Mushroom Swiss Burger",
"With sautéed mushrooms and melted swiss on a home-baked roll", 10,
restaurant, burgerCategory)
Product.add(
"Hickory Burger",
"Topped with cheddar, hickory smoked bacon and smoked barbecue sauce",
10, restaurant, burgerCategory)
Product.add(
"Chicken Burger",
"Grilled chicken breast with heirloom tomatoes, avocado and sprouts on a home-baked roll",
9, restaurant, burgerCategory)
saladCategory = Category.add("Salads", restaurant)
Product.add(
"Caesar Salad",
"Romaine, fresh parmesan, seasoned croutons and black pepper with garlic anchovy dressing",
6.75, restaurant, saladCategory)
Product.add("Red Iceberg Salad",
"With sweet corn, blackberries, goat cheese and fresh basil",
9.25, restaurant, saladCategory)
Product.add(
"House Salad",
"With green olives, green peppers, onions, cucumbers, and tomato",
6.75, restaurant, saladCategory)
Product.add(
"Blue Chicken Salad",
"Mesclun greens, apple, grilled chicken, gorgonzola, chesse and balsamic vinagrette",
9.25, restaurant, saladCategory)
# Add an user for the restaurant we just created
User.add("restaurant1", "restaurant1", 0, restaurant)
streets = [
"Oak Street", "Madison Avenue", "Bridle Lane", "Jefferson Street",
"Lafayette Avenue", "Grove Street", "Chestnut Avenue"
]
# Simulate some orders on a different client
originalDate = time.time() - 57600000
for i in range(87):
productCount = randint(1, 2)
used = {}
products = []
price = 0
originalDate += randint(376000, 576000)
for y in range(productCount):
id = randint(0, 11)
while (id in used):
id = randint(0, 11)
used[id] = True
amount = randint(1, 2)
products.append({"id": id + 1, "count": amount})
product = Product.get_from_id(id + 1)
price += amount * product.price
order = Order.add(
random.choice(streets) + " " + str(randint(1, 5000)), price, "",
products, [-34.601874, -58.432611], testClient2, restaurant)
order.date = originalDate
order.status = 2
get_session().commit()
Order.add("Bridle Lane 1775", 9.50, "", [{
'id': 1,
'count': 1
}], [-34.601874, -58.432611], testClient, restaurant)
from app import app
from libs.db import db
db.create_all()
from models.user import (User, Team, TEAM_TYPE_SUPER_ADMIN, TEAM_TYPE_MEDIUM,
TEAM_TYPE_LEADER, TEAM_TYPE_DIRECT_SELLER)
from models.medium import Medium, MediumGroup
from models.client import Client, Agent, Group
from models.order import Order
from config import DEFAULT_PASSWORD
admin_team = Team.add(u'管理员', type=TEAM_TYPE_SUPER_ADMIN)
medium_team = Team.add(u'媒体', type=TEAM_TYPE_MEDIUM)
leader_team = Team.add('ledaer', type=TEAM_TYPE_LEADER)
sale_team = Team.add('ledaer', type=TEAM_TYPE_DIRECT_SELLER)
user = User.add(name="admin", email="*****@*****.**", password=DEFAULT_PASSWORD, team=admin_team)
leader = User.add(name="leader", email="*****@*****.**", password=DEFAULT_PASSWORD, team=leader_team)
saler = User.add(name="saler", email="*****@*****.**", password=DEFAULT_PASSWORD, team=sale_team)
medium_group = MediumGroup.add(name='测试媒体供应商', tax_num="", address="",
phone_num="", bank="", bank_num="", level=100)
medium = Medium.add(medium_group, u"测试媒体", owner=medium_team)
client = Client.add(u"测试客户", 0)
group = Group.add(u'测试代理集团')
agent = Agent.add(u"测试代理", group=group)
def add_client(name):
client = Client.add(name, 0)
return client
def __init__(self, fname, lname, address, email=None, phone=None):
Client.__init__(self)
Individual.__init__(self, fname, lname, address, email, phone)
def generate_clients(self, number):
print("Generating clients")
for i in range(number):
self.clients.append(Client(self.faker))
def get_client(id):
client = Client.find_by_id(id)
if client:
return client.json(), 200
return {'message': f'No existe cliente con el ID [{id}] especificado'}, 404
'agent_name':k['agent_name'],
'money':k['medium_money2'],
'medium_id':k['medium_id'],
'medium_name':k['medium_name']}
for k in medium_orders]
douban_date = [{'client_id': k['client_id'],
'client': k['client'],
'agent_id': k['agent_id'],
'agent': k['agent'],
'agent_name':k['agent_name'],
'client_name':k['client_name'],
'money':k['money']}
for k in douban_orders]
client_data = {}
for k in Client.all():
client_data[k.name] = 0
for k in douban_date+youli_data+wuxian_data:
if client_data.has_key(k['client'].name):
client_data[k['client'].name] += k['money']
client_data = sorted(client_data.iteritems(), key=lambda x: x[1])
client_data.reverse()
for k in client_data:
if k[1]:
print k[0], k[1]
'''
medium_data = {}
for k in Medium.all():
if k.id in [52, 51, 46, 14,9,7,6,5,4]:
medium_data[k.name] = 0
for k in medium_date:
def clients():
clients = [{'id': k.id, 'name': k.name} for k in Client.all()]
return jsonify({'data': clients})
