def show_operator(request):
try:
if request.method != 'POST':
form = PhoneForm(request.GET)
else:
form = PhoneForm(request.POST)
if form.is_valid():
phone = form.cleaned_data['phone']
operator = Operator.find(phone)
if not operator:
operator = Operator.find_by_range(phone)
if operator:
response = {
'status': 0,
'message': 'ok',
'phone': phone,
'operator': operator.name,
'region': operator.region,
'region_code': operator.region_code,
'mobile': operator.mobile,
'country': operator.country,
}
else:
raise OperatorNotFoundException
else:
raise InvalidNumberException
except (OperatorNotFoundException, InvalidNumberException), e:
return response_json({'status': 1, 'message': e.msg, 'code':e.code})
def verifyUser(username, password):
user = Operator.verify_auth_token(username) #username_or_token
if not user:
operator = Operator.objects(email=username,
is_active=True) #.get()#.clean_data()
if operator:
return operator.get().check_password(password)
#print(operator)
return False
#g.user = operator
return True
def operator_from_table(table: Match) -> Operator:
operator_name = table.group("operator")
operator = Operator(name=operator_name, rates=dict())
raw_rows = table.group("rows")
if raw_rows:
row_matches = row_re.finditer(raw_rows)
for row_match in row_matches:
prefix = row_match.group("prefix")
price = Decimal(row_match.group("price"))
operator.rates[prefix] = price
return operator
def getOperators(operator_id):
try:
if operator_id:
operator = Operator.objects(id=operator_id).get().clean_data()
return jsonify(operator)
else:
operator = [
v.clean_data() for v in Operator.objects(is_active=True).all()
]
return jsonify({"list": operator})
except Exception as error:
return jsonify({"error": str(error)}), 400
def post(self):
"""create a new user"""
new_Operator = request.json
# TODO: get authenticated operator and assignee to new Operator
# new_Operator["created_by"] = authenticated_oprator
try:
assert len(
new_Operator["password"]
) >= MIN_PASSWORD_LEN, f"Password is to short, min length is {MIN_PASSWORD_LEN}"
new_Operator["password"] = PassHash.hash(new_Operator["password"])
comment = Operator(**new_Operator)
comment.save()
return jsonify({"response": "success"})
except Exception as error:
return jsonify({"error": str(error)}), 400
def show_operator(request):
try:
if request.method != 'POST':
form = PhoneForm(request.GET)
else:
form = PhoneForm(request.POST)
if form.is_valid():
phone = form.cleaned_data['phone']
operator = Operator.find(phone)
if operator:
response = {
'status': 0,
'message': 'ok',
'phone': phone,
'operator': operator.name,
'region': operator.region,
'mobile': operator.mobile,
}
else:
raise OperatorNotFoundException
else:
raise WrongNumberException
except (OperatorNotFoundException, WrongNumberException), e:
return response_json({'status': 1, 'message': e.msg})
def form_valid(self, form):
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
user = form.save()
operator = Operator(user=user)
operator.save()
filter = self.init_filter(operator)
filter.initialize(operator)
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(self.request, user)
return super(RegisterView, self).form_valid(form)
def put(self, operator_id, delete=False):
"""update a single user by id"""
update = {}
if not delete:
for key, value in request.json:
if key == "password":
value = PassHash.hash(value)
update[f"set__{key}"] = value
else:
update["set__is_active"] = False
try:
Operator.objects(id=operator_id).get().update(**update)
return jsonify({"response": "success"})
except Exception as error:
return jsonify({"error": str(error)}), 400
def add_care_home():
form = CareHomeForm(request.form)
if request.method == 'POST':
operator = Operator(name=form.operator_name.data,
phone=form.phone.data,
certification=form.certification.data,
license_expiration=form.license_expiration.data)
address = Address(street=form.address_street.data,
city=form.address_city.data,
region=form.address_region.data,
state='HI',
zip=form.address_zip.data,
email=form.email.data,
operator=operator)
carehome = CareHome(
name=form.carehome_name.data,
type=form.type.data,
open_rooms=form.open_rooms.data,
max_rooms=form.private_rooms.data + form.shared_rooms.data,
patient_gender=form.patient_gender.data,
patient_max_age=form.patient_age.data,
private_patients=form.patient_private.data,
medicaid_patients=form.patient_medicaid.data,
ssi_patients=form.patient_ssi.data,
assistive_walking_devices=str(
form.patient_walking_device.data).replace('[', '').replace(
']', '').replace('\'', ''),
behavioral_issues_patient=form.patient_behavioral.data,
dialysis_patient=form.patient_dialysis.data,
hospice_patient=form.patient_hospice.data,
insulin_patient=form.patient_insulin.data,
tube_feed_patient=form.patient_tube_feed.data,
wounded_patient=form.patient_wounds.data,
max_weight_patient=form.patient_weight.data,
case_management_company=form.case_management_company.data,
previous_experience=form.previous_experience.data,
subs=form.subs.data,
open_year=form.carehome_open_year.data,
notes=form.notes.data,
operator=operator)
private_rooms = Room(min_price=form.min_price_private.data,
max_price=form.max_price_private.data,
amount=form.private_rooms.data,
type=Room.Type.PRIVATE,
carehome=carehome)
shared_rooms = Room(min_price=form.min_price_shared.data,
max_price=form.max_price_shared.data,
amount=form.shared_rooms.data,
type=Room.Type.SHARED,
carehome=carehome)
db.session.add(operator)
db.session.add(address)
db.session.add(carehome)
db.session.add(private_rooms)
db.session.add(shared_rooms)
db.session.commit()
flash('Care Home added', 'success')
return redirect(url_for('care_homes'))
return render_template('addcarehome.html', form=form)
def getToken(username):
operator = Operator.objects(email=username,
is_active=True) #.get()#.clean_data()
if operator:
return operator.get().generate_auth_token(), operator.get().clean_data(
)
#print(operator)
#g.user = operator
return None
def setUp(self):
self.client = HTTPClient()
Operator(name=u"МагаданТелеком",
region_code=560,
number_start_range=2000000,
number_end_range=3999999,
mobile=False,
region=u"Магадан").save()
Operator(name=u"КроссТелеком",
region_code=530,
number_start_range=1000000,
number_end_range=1999999,
mobile=True,
region=u"Владивосток").save()
Operator(name=u"Магаданские Телесистемы",
region_code=560,
number_start_range=4000000,
number_end_range=8999999,
mobile=False,
region=u"Магадан").save()
def registerTag(requestjson, created_by):
"""create a new user"""
new_Tags = requestjson
if len(created_by) > 30:
user = Operator.verify_auth_token(created_by)
created_by = user.get().clean_data()['email']
# TODO: get authenticated operator and assignee to new Tags
# new_Tags["created_by"] = authenticated_oprator
try:
new_Tags['created_by'] = created_by #g.user.get().clean_data()['_id']
comment = Tags(**new_Tags)
comment.save()
return jsonify({"response": "success", 'user': comment.clean_data()})
except Exception as error:
return jsonify({"error": str(error)}), 400
def get_operators_by_filters(filters, pages=0, per_page=10000):
try:
item_per_age = int(per_page)
offset = (int(pages) - 1) * item_per_age
if len(filters) > 0:
flt = {}
for k, v in filters.items():
flt[k] = v
if 'is_active' == k:
flt['is_active'] = True if flt[
'is_active'] == '1' else False
obj = Operator.objects(**flt)
beneficiaries = [
v.clean_data() for v in obj.skip(offset).limit(item_per_age)
]
return jsonify({"list": beneficiaries, 'count': obj.count()})
else:
obj = Operator.objects(is_active=True)
beneficiaries = [
v.clean_data() for v in obj.skip(offset).limit(item_per_age)
]
return jsonify({"list": beneficiaries, 'count': obj.count()})
except Exception as error:
return jsonify({"error": str(error)}), 400
def webshell():
if request.environ.has_key('wsgi.websocket'):
ws = request.environ['wsgi.websocket']
if ws:
cmdbuffer = CommandBuffer('192.168.101.126', 'qdam',
Operator.find(login='******'), current_app,
ws)
bridge = wssh.WSSHBridge(ws, cmdbuffer)
try:
bridge.open(hostname='192.168.101.126',
username='******',
password='******')
except Exception:
ws.send(json.dumps({'message': 'can not connect to server.'}))
else:
bridge.shell()
finally:
return {'message': 'webshell closed.'}
def get_active_operator(days=2):
days_diff = dt.now() - timedelta(days=days)
pipeline_used_fixers = [{
'$match': {
'status': 'done',
'created_at': {
'$gte': days_diff
}
}
}, {
'$sort': {
'created_at': 1
}
}, {
'$group': {
'_id': '$fixer',
'count': {
'$sum': 1
}
}
}]
fixers = []
for f in Beneficiary.objects().aggregate(pipeline_used_fixers):
fixers.append(f)
available_fixers = [
v.clean_data() for v in Operator.objects(
is_active=True, role='fixer', created_at__gte=days_diff)
]
available_fixers = [{'_id': af.get('_id')} for af in available_fixers]
if len(fixers) is not 0 and len(fixers) == len(available_fixers):
return fixers[0].get('_id')
else:
fixers_ids = [val['_id'] for val in fixers]
fixer_id = None
for af in available_fixers:
fixer_id = af.get('_id')
if fixer_id not in fixers_ids:
break
return fixer_id
def registerOperator(requestjson, created_by):
"""create a new user"""
new_operator = requestjson
if len(created_by) > 30:
user = Operator.verify_auth_token(created_by)
created_by = user.get().clean_data()['email']
# TODO: get authenticated operator and assignee to new Operator
# new_operator["created_by"] = authenticated_oprator
try:
assert len(
new_operator["password"]
) >= MIN_PASSWORD_LEN, f"Password is to short, min length is {MIN_PASSWORD_LEN}"
new_operator["password"] = PassHash.hash(new_operator["password"])
new_operator['created_by'] = created_by
assert not Operator.objects(
email=new_operator['email']), "user with this email already exists"
comment = Operator(**new_operator)
comment.save()
return jsonify({"response": "success", 'user': comment.clean_data()})
except Exception as error:
return jsonify({"error": str(error)}), 400
def register_volunteer(request_json, created_by):
"""Creates and persists a new volunteer into database.
Parameters
----------
request_json : dict
A dictionary representing the volunteer profile details.
created_by : str
A string representing either name of user who is going to create a new volunteer, or the token
Returns
-------
200:
If the volunteer was successful created and saved.
400:
If the volunteer wasn't created or saved, and there was raised some exception.
"""
log.debug("Relay offer for req:%s from ", request_json)
try:
if not vu.is_email(created_by):
user = Operator.verify_auth_token(created_by)
created_by = user.get().clean_data()['email']
if created_by == os.getenv("COVID_BACKEND_USER"):
vu.exists_by_telegram_chat_id(request_json["chat_id"])
new_volunteer_data = process_volunteer_data_from_telegram(request_json)
else:
vu.exists_by_email(request_json["email"])
new_volunteer_data = request_json
new_volunteer_data["password"] = PassHash.hash(new_volunteer_data["password"])
new_volunteer_data['created_by'] = created_by
new_volunteer = Volunteer(**new_volunteer_data)
new_volunteer.save()
return jsonify({"response": "success", 'user': new_volunteer.clean_data()})
except Exception as error:
return jsonify({"error": str(error)}), 400
def registerBeneficiary(requestjson, created_by, fixer_id):
"""create a new user"""
new_beneficiary = requestjson
if len(created_by) > 30:
user = Operator.verify_auth_token(created_by)
created_by = user.get().clean_data()['email']
try:
new_beneficiary['password'] = '******'
new_beneficiary['email'] = '*****@*****.**'
assert len(
new_beneficiary["password"]
) >= MIN_PASSWORD_LEN, f"Password is to short, min length is {MIN_PASSWORD_LEN}"
new_beneficiary["password"] = PassHash.hash(
new_beneficiary["password"])
new_beneficiary['created_by'] = created_by
new_beneficiary['fixer'] = str(fixer_id)
comment = Beneficiary(**new_beneficiary)
comment.save()
if 'is_active' in new_beneficiary and new_beneficiary['is_active']:
#sent the request to the volunteer via telegram
telegrambot.send_request(comment)
return jsonify({"response": "success", 'user': comment.clean_data()})
except Exception as error:
return jsonify({"error": str(error)}), 400
