def make_request(request):
if request.method == "POST":
form = RequestForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.poster = request.user
post.posted_on = datetime.now()
post.email = request.POST['email']
post.save()
return HttpResponseRedirect('/')
else:
form = RequestForm()
return render(request, 'make_request.html', {'form': form})
def create_request():
form = RequestForm(request.form)
if request.method == 'POST' and form.validate():
geolocation = getGeocodeLocation(form.location_string.data)
newrequest = Request(user_id=login_session['id'],
meal_type=form.meal_type.data,
location_string=form.location_string.data,
latitude=geolocation[0],
longitude=geolocation[1])
session.add(newrequest)
session.commit()
date_request = parse_datetime(year=form.year.data, month=form.month.data, day=form.day.data)
if date_request == None:
flash('Date no valid...')
return redirect(url_for('users.index'))
newrequestdate = DateTimeRequest(
request=newrequest.id,
mealtime=form.meal_time.data,
date=date_request)
session.add(newrequestdate)
session.commit()
flash('Succefully!')
return redirect(url_for('users.index'))
flash_errors(form)
return redirect(url_for('users.index'))
def search():
form = SearchForm()
request_form = RequestForm()
last_objects = list()
if request.method == 'GET':
stuff_key = unicode(request.args.get('stuff')).lower()
address_key = unicode(request.args.get('address')).lower()
last_objects = Stuff.query.join(Address).join(User).filter(
Stuff.owner_id == User.id,
User.approved == True,
Stuff.approved == 1,
Address.id == Stuff.address_id,
Stuff.title.ilike('%' + stuff_key + '%'),
Address.detail.ilike('%' + address_key + '%')
)
return render_template(
"search.html",
user=current_user,
last_objects=last_objects,
form=form,
request_form=request_form
)
def render_request_done():
# Если данные не были отправлены
if request.method != "POST":
abort(404)
# Если данные были отправлены
form = RequestForm()
if not form.validate_on_submit():
# отправляем форму назад
return render_template('request.html', form=form)
# получаем данные
client_name = form.clientName.data
client_phone = form.clientPhone.data
client_goal = form.clientGoal.data
client_time = form.clientTime.data
time = next((t[1] for t in form.clientTime.choices if t[0] == client_time),
-1)
goal = Goal.query.filter(Goal.code == client_goal).scalar()
request_t = Request(name=client_name,
phone=client_phone,
goal=goal.goal,
time=time)
db.session.add(request_t)
db.session.commit()
# переходим на request_done
return render_template('request_done.html',
clientName=client_name,
clientPhone=client_phone,
clientGoal=request_t.goal,
clientTime=request_t.time)
def confirmation_page(request):
form = RequestForm()
session = request.session
csrf_token = session.get_csrf_token()
if 'uc' not in request.session:
request.session.flash('Please login to place request')
return HTTPFound(location=request.route_url('login'))
submitter_email = request.session['uniqueName'] + '@' + \
request.registry.settings['EMAIL_DOMAIN']
name = request.session['firstName'] + ' ' + request.session['lastName']
sender = request.registry.settings['mail.username']
message = Message(subject="Relay account setup",
sender=sender,
recipients=[sender, submitter_email])
message.body = make_msg_text(name, submitter_email,
request.session['requestDetails'], form)
message.html = make_msg_html(name, submitter_email,
request.session['requestDetails'], form)
mailer = get_mailer(request)
mailer.send_immediately(message, fail_silently=False)
return {
'csrf_token': csrf_token,
'name': name,
'form': form,
'requestDetails': request.session['requestDetails']
}
def render_request():
form = RequestForm()
goals = get_goals_for_request_form(GOALS_JSON_PATH)
form.goal.choices = goals
form.goal.default = goals[0][0]
form.process()
return render_template('request.html', form=form)
def home():
form = SearchForm()
request_form = RequestForm()
last_objects_shared = Stuff.query.join(User).filter(
Stuff.approved == 1,
Stuff.is_wanted == False,
Stuff.owner_id == User.id,
User.approved == True
).order_by(Stuff.id.desc()).limit(9)
last_objects_wanted = Stuff.query.join(User).filter(
Stuff.approved == 1,
Stuff.is_wanted == True,
Stuff.owner_id == User.id,
User.approved == True
).order_by(Stuff.id.desc()).limit(9)
return render_template(
"index.html",
user=current_user,
last_objects_wanted=last_objects_wanted,
last_objects_shared=last_objects_shared,
form=form,
request_form=request_form
)
def chat_request():
if current_user.Customer:
flash('You do not have access to post to this resource', 'danger')
abort(401)
elif current_user.ServiceRep:
form = RequestForm()
if form.validate_on_submit:
req = ChatRequest.query.get(form.requests.data)
if req.Accepted:
flash('This request has already been accepted', 'danger')
return redirect(url_for('home'))
else:
req.Accepted = True
chat_session = ChatSession(CustomerId=req.CustomerId,
ServiceRepId=current_user.id,
Topic=req.Topic)
db.session.add(chat_session)
db.session.commit()
chat_session = ChatSession.query.filter_by(
CustomerId=req.CustomerId,
ServiceRepId=current_user.id,
Topic=req.Topic).first()
req.ChatSessionId = chat_session.id
db.session.commit()
return redirect(url_for('chat', id=chat_session.id))
else:
abort(401)
def bid_request(request, template_name="alerts/alert-form.html"):
page_title = 'Product Bid Request'
if request.method == 'POST':
form = RequestForm(request.POST)
if form.is_valid():
req = form.save(commit=False)
req.user = request.user
req.save()
return HttpResponseRedirect('/request-success/')
else:
form = RequestForm()
return render_to_response(template_name,
locals(),
context_instance=RequestContext(request))
def render_request_done():
form = RequestForm()
if not form.phone.data:
return render_template(
'request.html',
form=form,
)
name = form.name.data
phone = form.phone.data
have_hours = form.have_hours.data
goal = form.goal.data
if Student.query.filter(Student.phone == phone).scalar():
student = Student.query.filter(Student.phone == phone).scalar()
else:
student = Student(name=name, phone=phone)
db.session.add(student)
db.session.commit()
current_request = Request(student_id=student.id,
goal=goal,
have_time=have_hours)
db.session.add(current_request)
db.session.commit()
return render_template(
'request_done.html',
form=form,
)
def render_request():
form = RequestForm()
return render_template(
'request.html',
form=form,
)
def index():
form = ContactForm()
request_form = RequestForm()
if form.validate_on_submit():
name = form.name.data
body = form.body.data
email = form.email.data
send_mail(name, email, body)
return redirect(url_for('index'))
if request_form.validate_on_submit():
name = request_form.name.data
email = request_form.email.data
phone = request_form.email.data
option = request_form.select.data
reply_request(name, email, option)
return redirect(url_for('index'))
return render_template('index.html', form=form, request_form=request_form)
def render_booking(id_teach, day_weekly, time):
form = RequestForm()
teacher_info = db.session.query(Teacher).get_or_404(id_teach)
return render_template("booking.html",
name_teacher=teacher_info.name,
day=days[day_weekly],
time=time,
form=form)
def make_request():
form = RequestForm()
if request.method == 'GET':
return render_template('request.html', form=form)
if request.method == 'POST':
form = RequestForm()
if form.validate_on_submit():
tr = TeacherRequest(goal=form.goals.data,
availability=form.availability.data,
clientName=form.clientName.data,
clientPhone=form.clientPhone.data)
db.session.add(tr)
db.session.commit()
return render_template('request_done.html',
goal=tr.goal,
availability=tr.availability,
clientName=tr.clientName,
clientPhone=tr.clientPhone)
return render_template('request.html', form=form)
def request_page():
form_request = RequestForm()
if form_request.validate_on_submit():
request_goal = int(form_request.request_goal.data)
request_client_name = form_request.request_client_name.data
request_client_tel = form_request.request_client_tel.data
request_new = Request(name=request_client_name, phone=request_client_tel, goal_id=request_goal)
db.session.add(request_new)
db.session.commit()
return redirect(url_for('search_result_page'))
return render_template('pick.html', form_request=form_request)
def create_request(request):
form = RequestForm(request.POST or None)
num_req = Exchange.objects.filter(receiver=request.user.id).count()
if num_req >= 1:
messages.error(request, "Looks like you've already created a request")
return redirect('/exchange/participate/dashboard')
else:
if request.POST and form.is_valid():
gift_request = form.gift_request(request)
print "GIFT", gift_request
return HttpResponseRedirect('/exchange/participate/dashboard')
return render(request, 'exchange/participate/create_request.html')
def render_booking_done():
form = RequestForm()
if request.method == 'POST':
booking = Booking(name=form.client_teacher.data,
day=form.client_weekday.data,
time=form.client_time.data,
name_user=form.name.data,
phone_user=form.phone.data)
db.session.add(booking)
db.session.commit()
return render_template("booking_done.html", form=form)
return render_template("request.html", form=form)
def get(self):
args = parser.parse_args()
amount = args.get('amount')
form = RequestForm('1HfMPfrRJVrcPygFRoBgt7WgA9iiefmvC9',
amount,
multiple='on')
if form.errors == {}:
seeder = controller.generate_receiver_for_seeding(amount)
resp = {'address': seeder, 'amount': amount}
return resp, 201
else:
return form.errors, 400
def render_request_done():
goals = get_goals_for_request_form(GOALS_JSON_PATH)
form = RequestForm()
form.goal.choices = goals
if form.validate():
goals = read_json(GOALS_JSON_PATH)
goal = form.goal.data
time = form.time.data
name = form.name.data
phone = form.phone.data
write_request_to_json(goal, time, name, phone, REQUESTS_JSON_PATH)
return render_template('request_done.html', goal=goals[goal], time=time, name=name, phone=phone)
return 'Данные не получены '
def render_done():
form = RequestForm()
if request.method == 'POST':
req = Request(goal=form.goal.data,
name_user=form.name.data,
phone_user=form.phone.data,
free_time=form.free_time.data)
db.session.add(req)
db.session.commit()
return render_template("request_done.html",
form=form,
goals=get_goals_id_dict())
return render_template("request.html", form=form)
def render_request_done():
form = RequestForm()
data = {
"spend_time": form.spend_time.data,
"goal": form.goal.data,
"name": form.name.data,
"phone": form.phone.data
}
DataBase.json_worker('request.json', data)
data['goal'] = goals[form.goal.data]
print(spend_time)
print(form.spend_time.data)
data['spend_time'] = spend_time[int(form.spend_time.data)]
return render_template('request_done.html', data=data)
def recover():
form = RequestForm(request.args)
if form.validate():
email = form.email.data
element = mongo.db.accounts.find_one({'email': email})
if element:
username = element.get('username')
email = element.get('email')
return f"Dear {username}, this functionality is not implemented yet!", 202
else:
return jsonify({"email": 'email not found'}), 400
else:
return jsonify(form.errors), 404
def index():
if not login_session.get('username') :
return redirect(url_for('users.login'))
request_user = session.query(Request, DateTimeRequest). \
filter(Request.user_id==login_session['id']). \
filter(DateTimeRequest.request==Request.id).all()
return render_template('index.html',
user_authenticated=True,
login_session=login_session,
request=RequestForm(request.form),
request_user=request_user,
searchform=searchform(request.form))
def category_stuff_type_view(category_name, type_name):
request_form = RequestForm()
is_wanted = request.args.get('is_wanted')
stuff_type = StuffType.query.\
filter(StuffType.name == type_name).first()
category = Category.query.\
filter(Category.name == category_name).first()
if is_wanted is None:
stuff_list = Stuff.query.join(User).join(Category).join(StuffType).filter(
Category.id == category.id,
StuffType.id == stuff_type.id,
Stuff.approved == 1,
Stuff.owner_id == User.id,
User.approved == True
)
# filter(Category.id == category.id)
else:
stuff_list = Stuff.query.join(User).join(Category).join(StuffType).filter(
Category.id == category.id,
StuffType.id == stuff_type.id,
Stuff.approved == 1,
Stuff.is_wanted == is_wanted,
Stuff.owner_id == User.id,
User.approved == True
)
# filter(Category.id == category.id).\
# filter(Stuff.is_wanted == is_wanted)
params = {
'category': {
'type': 'category',
'value': category.id
},
'stuff_type': {
'type': 'stuff_type',
'value': stuff_type.id
},
'is_wanted': {
'type': 'is_wanted',
'value': is_wanted if is_wanted is not None else 2
}
}
return render_template(
"browse.html",
user=current_user,
stuff_list=stuff_list,
params=params,
request_form=request_form
)
def get():
form = RequestForm(request.args)
if form.validate():
email = form.email.data
current_user = get_jwt_identity()
element = mongo.db.accounts.find_one({'email': email})
if element and current_user == element.get('username'):
username = element.get('username')
email = element.get('email')
return jsonify(username=username, email=email)
else:
return jsonify({"email": 'email not found'}), 400
else:
return jsonify(form.errors), 400
def get(self):
args = parser.parse_args()
destination = args.get('destination')
amount = args.get('amount')
form = RequestForm(destination, amount, multiple="on")
if form.errors == {}:
receiver = controller.generate_receiver(destination=destination,
pending_amt=amount)
resp = {
'address': receiver,
'destination': destination,
'amount': amount
}
return resp, 201
else:
return form.errors, 400
def request_book(id):
session = Session()
trans = session.query(Transaction).filter(Transaction.book == id).first()
if (trans.address_to):
return redirect(url_for("listings"))
form = RequestForm()
if form.validate_on_submit():
address = form.streetNameNum.data + " " + form.city.data + ", " + form.state.data + " " + form.zipcode.data
trans.address_to = address
trans.buyer = current_user.user_id
addressf = trans.address_from
session.commit()
return redirect(url_for("index"))
# Very important, make sure to initialize the field of the OWNER's
# associated user's ID after the post request. To be handled later
return render_template('request_book.html', form=form)
def RequestSwapp():
email1 = globals()['cur_user']
if email1 == '':
flash("Login as user to view schedule.")
return redirect(url_for('login'))
else:
form = RequestForm()
if form.validate_on_submit():
email, examid, date, time, slot = form.email.data, form.examid.data, form.date.data, form.time.data, form.slot.data
if email != email1:
print(email, examid, date, time, slot)
res = RequestSwap(email1, email, examid, date, time, slot)
flash(res)
return redirect(url_for("RequestSwapp"))
elif email == email1:
flash("you can't enter your own email!")
return redirect(url_for("RequestSwapp"))
return render_template('request_swap.html', form=form, ddtext='Request Swap')
def render_request_done():
if request.method != "POST":
return redirect(url_for('render_request'))
goal = request.form.get('goal')
time = request.form.get('time')
form = RequestForm()
name = form.name.data
phone = form.phone.data
data = {'goal': goal, 'time': time, 'name': name, 'phone': phone}
update_data('request.json', data)
return render_template('request_done.html',
goal=goals[goal],
time=time,
name=name,
phone=phone)
def show_stuff(stuff_id):
request_form = RequestForm()
is_wanted = request.args.get('is_wanted')
stuff = Stuff.query.join(User).filter(
Stuff.id == stuff_id,
Stuff.owner_id == User.id,
User.approved == True
).first()
if stuff.approved == 1:
stuff_address = Address.query.filter(Address.id == stuff.address_id).first()
reviews = Review.query.filter(Review.request_id == Request.id, Request.stuff_id == stuff_id)
user_rates = Review.query.filter(Review.reviewed_user_id == stuff.owner_id)
rating_count = user_rates.count()
total_rating = 0
if rating_count > 0:
for rate in user_rates:
if rate.rating:
total_rating += rate.rating
avg_rate = total_rating / rating_count
else:
avg_rate = 0
return render_template(
"show_stuff.html",
stuff_address=stuff_address,
user=current_user,
rating=avg_rate,
request_form=request_form,
is_wanted=is_wanted,
stuff=stuff,
reviews=reviews
)
elif stuff.approved == 0 and stuff.owner == current_user:
return redirect(url_for("edit_stuff", stuff_id=stuff_id))
else:
# flash(u"Eşya kaldırılmış.")
return render_template('/404.html', user=current_user)
