def update_token():
print 'update access token'
params = {
'grant_type': 'client_credential',
'appid': APPID,
'secret': APPSECRET
}
host = 'api.weixin.qq.com'
path = '/cgi-bin/token'
method = 'GET'
res = send_request(host, path, method, params=params)
if not res[0]:
return False
if res[1].get('errcode'):
return False
token = res[1].get('access_token')
starttime = timezone.now()
expires_in = timedelta(seconds=int(res[1].get('expires_in')))
endtime = starttime + expires_in
token_record = Ticket.objects.filter(ticket_type=1).order_by('-start_time')
if len(token_record) > 0:
token_record = token_record[0]
else:
token_record = Ticket()
token_record.content = token
token_record.end_time = endtime
token_record.save()
return token_record
def create_ticket():
ticket_details = request.get_json()['ticket']
date_due = parser.parse(ticket_details['dateDue'])
user = User.query.filter_by(address=ticket_details['userAddress'])
ticket = Ticket(user[0].address, None,
'requested', ticket_details['price'], date_due,
datetime.now(), ticket_details['text'],
ticket_details['subject'])
fox_ticket = add_ticket(ticket, user[0])
ticket.happy_fox_id = fox_ticket['id']
user.update(dict(happy_fox_id=fox_ticket['user']['id']))
ticket_data = {}
if fox_ticket:
db.session.add(ticket)
db.session.commit()
# db.session.add(ticket)
# db.session.commit()
ticket_data = {
'id': ticket.id,
'subject': ticket.subject,
'text': ticket.text,
'price': ticket.price,
'requestedPrice': ticket.requested_price,
'status': ticket.status,
'dateDue': ticket.date_due,
'dateCreated': ticket.date_created,
'userAddress': ticket.user_address
}
response = jsonify({'ticket': ticket_data})
response.headers.add('Access-Control-Allow-Origin', '*')
return response
def testReSellCancelledTicket(self):
"""
TODO
"""
ticket = Ticket(night=self.night, sector=self.sector, row=1,
sit=5, public_type=self.pt)
ticket.save()
sell = Sell(sell_point=self.sell_point)
sell.save()
ticket_sell = TicketSell(sell=sell, ticket=ticket)
ticket_sell.save()
self.assertEquals(True, ticket.was_selled)
cancellation = Cancellation(ticket=ticket)
cancellation.save()
self.assertEquals(False, ticket.was_selled)
sell = Sell(sell_point=self.sell_point)
sell.save()
ticket_sell = TicketSell(sell=sell, ticket=ticket)
ticket_sell.save()
self.assertEquals(True, ticket.was_selled)
def new_contact_ticket(request):
ticket_created = False
if request.POST:
form = __get_contact_form(request)
if form.is_valid():
ticket = Ticket()
ticket.title = form.cleaned_data['title']
ticket.source = TICKET_SOURCE_CONTACT_FORM
ticket.status = TICKET_STATUS_NEW
ticket.queue = Queue.objects.get(name=QUEUE_SUPPORT_REQUESTS)
tc = TicketComment()
if request.user.is_authenticated():
ticket.sender = request.user
tc.sender = request.user
else:
ticket.sender_email = form.cleaned_data['email']
tc.text = form.cleaned_data['message']
ticket.save()
tc.ticket = ticket
tc.save()
ticket_created = True
# TODO: send email
else:
form = __get_contact_form(request, False)
return render_to_response('tickets/contact.html',
locals(),
context_instance=RequestContext(request))
def api_load_ticket_data():
fd = dict(request.form)
if not fd:
return jsonify({'outcome': 'Missing parameters!'}), 422
ticket = Ticket(tid=fd['id'])
return ticket.getTicketData(), 200
def getTicketForUser(userRequestingTicket):
currentTickets = Ticket.objects.filter(user=userRequestingTicket)
if currentTickets:
for ticket in currentTickets:
ticket.delete()
toReturn = Ticket(user=userRequestingTicket, ticket_hash=getUniqueRandHash())
toReturn.save()
return toReturn
def create_node(request, parent_id, title):
try:
parent_node = Ticket.objects.get(id=parent_id)
except Exception as e:
return HttpResponse(str(e), status = 400)
node = Ticket(parent = parent_node, title = title)
node.save()
return HttpResponse('{"id":'+str(node.id)+'}', content_type="application/json")
def setUp(self):
"""
TODO
"""
stadium = Stadium(name="test stadium")
stadium.save()
self.sector = Sector(stadium=stadium, letter="A", color="#00ff00",
rows=10, sits=10, price=Decimal("10.00"))
self.sector.save()
self.festival = Festival(stadium=stadium, name="test festival",
base_price=Decimal("10.00"))
self.festival.save()
start_night = datetime.now() + timedelta(days=50)
self.night = Night(festival=self.festival, datetime=start_night)
self.night.save()
for i in range(2):
band = Band(name="Test band %d" % i)
band.save()
self.bbn = BandByNight(band=band, night=self.night,
price=Decimal("5.00"))
self.bbn.save()
self.pt = PublicType(name="maxor", price=Decimal("10.00"))
self.pt.save()
self.discount = Discount(festival=self.festival, limit_days=30,
porcent=Decimal("10.00"))
self.discount.save()
self.ticket1 = Ticket(night=self.night, sector=self.sector, row=1,
sit=1, public_type=self.pt)
self.ticket1.save()
self.ticket2 = Ticket(night=self.night, sector=self.sector, row=1,
sit=2, public_type=self.pt)
self.ticket2.save()
self.sell_center = SellCenter(name="Test sell center")
self.sell_center.save()
self.sell_point = SellPoint(sell_center=self.sell_center)
self.sell_point.save()
self.sell = Sell(sell_point=self.sell_point)
self.sell.save()
ticket_sell = TicketSell(sell=self.sell, ticket=self.ticket1)
ticket_sell.save()
ticket_sell = TicketSell(sell=self.sell, ticket=self.ticket2)
ticket_sell.save()
def create_db():
db = SqliteDatabase(':memory:')
Promoter.bind(db)
Event.bind(db)
Ticket.bind(db)
Order.bind(db)
db.create_tables([Promoter, Event, Ticket, Order])
def setUp(self):
# set up the test DB
self.db = tested_db
self.db.create_all()
self.db.session.add(Ticket(ticket_id=1, movie_name="A star is born", ticket_number=50))
self.db.session.add(Ticket(ticket_id=2, movie_name="Escape Room", ticket_number=30))
self.db.session.commit()
self.app = tested_app.test_client()
def make_some_db():
"""Create fake data for test"""
day = 27
date = datetime.datetime(year=2017, month=1, day=10,
hour=0, minute=0, second=0)
td = datetime.timedelta
# type = ['standard', 'save', 'flex']
# type_bu = ['standard', 'flex']
# carry = ['Ppew', 'UFO', 'Aiur', 'Navi', 'Medin', 'Lotha', 'Sinvo',
# 'Valve', 'Volvo', 'Skys']
carry = ['vna', 'vja', 'jsa']
# sit_class = ['economy', 'business', 'first', 'save']
ap = Airport.objects.get
rc = random.choice
rr = random.randrange
for x in xrange(1, 2):
print 'make_tk', x
in1 = 11 # rr(1, 21)
in2 = 14 # rr(1, 21)
while in2 == in1:
in2 = rr(1, 21)
td1 = td(hours=16, minutes=35)
td2 = td1 + td(hours=17, minutes=35)
# sit = rc(sit_class)
# typ = rc(type)
# if sit == 'first' or sit == 'save':
# typ = None
# elif sit == 'business' and typ == 'save':
# typ = 'standard'
pr1 = rr(1, 300)
# pr2 = pr1 - 100 * rr(3, 5) if pr1 > 600 else pr1 - 100 * rr(1, 2)
# pr3 = 0 if typ == 'save' else 100*rr(1,2)
# ft1 = pr1*38/100
# ft2 = pr2*29/100
# ft3 = 100*rr(0, 1) + pr3*1/10
carrier = rc(carry)
f_code_num = rr(12, 89)*10
if carrier == 'vja':
f_code = 'VJ' + str(f_code_num)
if carrier == 'jsa':
f_code = 'JS' + str(f_code_num)
if carrier == 'vna':
f_code = 'VN' + str(f_code_num)
t = Ticket(departure_port=ap(pk=in1),
arrival_port=ap(pk=in2),
departure_time=date + td1,
arrival_time=date + td2,
ticket=pr1,
carrier=carrier,
flight_code=f_code,
date_created=timezone.now()
)
t.save()
def api_load_tickets():
fd = dict(request.form)
if not fd:
return jsonify({'outcome': 'Missing parameters!'}), 422
ticket = Ticket(eid=fd['event'])
tickets = ticket.get()
return tickets, 200
def get(self, request):
service = request.GET.get(SERVICE_PARAM)
renew = request.GET.get(RENEW_PARAM) is not None
gateway = request.GET.get(GATEWAY_PARAM) is not None
if not service:
return self.failure(request, '', 'no service field')
model = Service.objects.for_service(service)
if not model:
return self.failure(request, service, 'service unknown')
if renew and gateway:
return self.failure(request, service, 'renew and gateway cannot be requested '
'at the same time')
st = Ticket()
st.service = model
st.service_url = service
st.renew = renew
self.logger.debug('login request from %r renew: %s gateway: %s',
service, renew, gateway)
if self.must_authenticate(request, renew, gateway):
st.save()
return self.authenticate(request, st)
self.validate_ticket(request, st)
if st.valid():
st.save()
return redirect(request, service, params={'ticket': st.ticket_id})
self.logger.debug('gateway requested but no session is open')
return redirect(request, service)
def new_contact_ticket(request):
ticket_created = False
if request.POST:
form = __get_contact_form(request)
if form.is_valid():
ticket = Ticket()
ticket.title = form.cleaned_data['title']
ticket.source = TICKET_SOURCE_CONTACT_FORM
ticket.status = TICKET_STATUS_NEW
ticket.queue = Queue.objects.get(name=QUEUE_SUPPORT_REQUESTS)
tc = TicketComment()
if request.user.is_authenticated():
ticket.sender = request.user
tc.sender = request.user
else:
ticket.sender_email = form.cleaned_data['email']
tc.text = form.cleaned_data['message']
ticket.save()
tc.ticket = ticket
tc.save()
ticket_created = True
# TODO: send email
else:
form = __get_contact_form(request, False)
return render_to_response('tickets/contact.html', locals(), context_instance=RequestContext(request))
def make_test_user(self):
try:
user = User.query.filter(User.email == "*****@*****.**").one()
except NoResultFound:
user = User('*****@*****.**', 'testuser')
user.set_password('happycamper')
db.session.add(user)
types = {"full": TicketType.query.get('full')}
#
# FIXME: this is a complete mess
#
# TODO: needs to cover:
#
# single full ticket
# multiple full tickets
#
# kids & campervans?
#
# full
for full in ([1], [0], [3], [0], [2]):
for pt in (BankPayment, GoCardlessPayment):
for curr in ['GBP', 'EUR']:
total = (full * amounts['full'].get_price(curr))
payment = pt(curr, total)
payment.state = "inprogress"
if payment.provider == "gocardless":
payment.gcid = "%3dSDJADG" % (int(
random.random() * 1000))
sess.add(payment)
for i in range(full):
t = Ticket(code='full')
t.payment = payment
if payment.currency == 'GBP':
t.expires = datetime.utcnow() + timedelta(
days=app.config['EXPIRY_DAYS_TRANSFER'])
elif payment.currency == 'EUR':
t.expires = datetime.utcnow() + timedelta(
days=app.
config['EXPIRY_DAYS_TRANSFER_EURO'])
user.tickets.append(t)
user.payments.append(payment)
db.session.commit()
self.user = user
print user.name
for p in user.payments.all():
print p.provider, p.amount
print p.tickets.all()
def setUp(self):
self.group, created = Group.objects.get_or_create(name='test')
self.user, created = DjangoUser.objects.get_or_create(
username=self.username)
self.user.set_password(self.password)
self.user.save()
perspective, created = Perspective.objects.get_or_create(
name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.status = TicketStatus(name='TestStatus')
self.status.set_default_user()
self.status.save()
self.queue = TicketQueue(name='TestQueue',
default_ticket_status=self.status)
self.queue.set_default_user()
self.queue.save()
self.ticket = Ticket(name='TestTicket',
status=self.status,
queue=self.queue)
self.ticket.set_default_user()
self.ticket.save()
self.agent = ServiceAgent(related_user=self.user.profile,
available_from=datetime.time(9),
available_to=datetime.time(17))
self.agent.set_default_user()
self.agent.save()
self.service = Service(name='test')
self.service.set_default_user()
self.service.save()
self.sla = ServiceLevelAgreement(name='test',
service=self.service,
client=self.contact,
provider=self.contact)
self.sla.set_default_user()
self.sla.save()
def make_test_user(self):
try:
user = User.query.filter(User.email == "*****@*****.**").one()
except NoResultFound:
user = User('*****@*****.**', 'testuser')
user.set_password('happycamper')
db.session.add(user)
types = {
"full" : TicketType.query.get('full')
}
#
# FIXME: this is a complete mess
#
# TODO: needs to cover:
#
# single full ticket
# multiple full tickets
#
# kids & campervans?
#
# full
for full in ([1], [0], [3], [0], [2]):
for pt in (BankPayment, GoCardlessPayment):
for curr in ['GBP', 'EUR']:
total = (full * amounts['full'].get_price(curr))
payment = pt(curr, total)
payment.state = "inprogress"
if payment.provider == "gocardless":
payment.gcid = "%3dSDJADG" % (int(random.random() * 1000 ))
sess.add(payment)
for i in range(full):
t = Ticket(code='full')
t.payment = payment
if payment.currency == 'GBP':
t.expires = datetime.utcnow() + timedelta(days=app.config['EXPIRY_DAYS_TRANSFER'])
elif payment.currency == 'EUR':
t.expires = datetime.utcnow() + timedelta(days=app.config['EXPIRY_DAYS_TRANSFER_EURO'])
user.tickets.append(t)
user.payments.append(payment)
db.session.commit()
self.user = user
print user.name
for p in user.payments.all():
print p.provider, p.amount
print p.tickets.all()
def test_new_ticket_linked_sound(self):
test_user = User.objects.get(username='******')
ticket = Ticket()
ticket.status = 'new'
ticket.sender = User.objects.get(username='******')
ticket.assignee = User.objects.get(username='******')
ticket.queue = Queue.objects.get(name=QUEUE_SOUND_MODERATION)
ticket.save()
# just to test, this would be a sound object for example
s = Sound(description='test sound', license_id=1, user=test_user)
s.save()
ticket.sound = s
ticket.save()
self.assertEqual(s.id, ticket.sound.id)
def new_item(request):
ret = check_auth(request)
if ret:
return ret
if request.method == 'POST':
print request.POST
if request.GET["new"] == "ticket":
form = TicketForm(request.POST)
print "valid", form.errors
if form.is_valid():
a = Ticket()
a.title = form.cleaned_data["title"]
a.text = form.cleaned_data["text"]
a.priority = form.cleaned_data["priority"]
a.author = request.user
a.save()
send_mail_ticket(a.group, "new_ticket")
return show_item(request, a.id)
form = {"ticket": TicketForm(),
"comment": CommentForm()}
return render_to_response('ticket_new.html',
{'forms': form, },
context_instance=RequestContext(request))
def run(self):
tt = TicketType.query.filter_by(fixed_id=24).one()
for i in range(1, 50 + 1):
email = '*****@*****.**' % i
if not User.query.filter_by(email=email).first():
u = User(email, 'Parking ticket %s' % i)
db.session.add(u)
db.session.commit()
t = Ticket(u.id, tt)
t.paid = True
t.emailed = True
db.session.commit()
def test_new_ticket(self):
ticket = Ticket()
ticket.source = 'contact_form'
ticket.status = 'new'
ticket.sender = User.objects.get(username='******')
ticket.queue = Queue.objects.get(name=QUEUE_SUPPORT_REQUESTS)
ticket.save()
self.assertEqual(ticket.assignee, None)
def ticket_list(cls, request):
try:
token = jwt.decode(request.tokenint, 'secret') #CHECA EL TOKEN
user = Usuarios.get_by_id(
token['user_id']) #obtiene usuario dado el token
lista = [] #crea lista para guardar contenido de la BD
lstMessage = TicketList(code=1) #CREA el mensaje de salida
lstBd = Ticket.query().fetch() #obtiene de la base de datos
for i in lstBd: #recorre la base de datos
#inserta a la lista creada con los elementos que se necesiten de la base de datos
#i.empresa_key.urlsafe() obtiene el entityKey
lista.append(
TicketUpdate(
token='',
entityKey=i.entityKey,
#empresa_key=i.empresa_key.urlsafe(),
folio=i.folio,
fecha=i.fecha,
total=i.total,
items=i.items,
qty=i.qty,
facturado=i.facturado))
lstMessage.data = lista #ASIGNA a la salida la lista
message = lstMessage
except jwt.DecodeError:
message = TicketList(code=-1, data=[])
except jwt.ExpiredSignatureError:
message = TicketList(code=-2, data=[])
return message
def on_post(req, resp):
request_payload = json.loads(req.stream.read().decode('utf-8'))
ticket_type = request_payload.get('ticket_type')
message = request_payload.get('message')
try:
ticket = Ticket.create_new(ticket_type, message)
with session() as db:
repo = Repo(db)
ticket.ticket_id = repo.save_new_ticket(ticket)
db.commit()
resp.body = json.dumps(
{
'id': ticket.ticket_id,
'status': ticket.status
},
sort_keys=True,
indent=4)
except ValueError as error:
resp.body = json.dumps({
'status': 'failed',
'reason': str(error)
},
sort_keys=True,
indent=4)
def book_ticket():
if 'user_id' not in session:
return login_in_please()
user_id = session['user_id']
req = request.get_json()
if 'type' not in req:
return bad_request()
ticket_type = req['type']
if ticket_type not in app.config['TYPE_IDS'].values():
return bad_request()
seat_num = None
if ticket_type == app.config['TYPE_IDS']['pc']:
if 'seat' not in req:
return bad_request()
seat_num = req['seat']
tickets_max = app.config['TICKETS_MAX']
price = app.config['PRICING'][ticket_type]
r = Ticket.book_temp(user_id, ticket_type, price, tickets_max, seat_num)
if r[0]:
ticket = Ticket.query.filter(Ticket.owner_id == user_id) \
.filter(or_(Ticket.paid, Ticket.reserved_until >= datetime.now())) \
.one()
return jsonify({'ticket': ticket.as_pub_dict()}), 201
# Conflict while booking ticket
return jsonify({'error': str(r[1])}), 409
def newrequest():
"""Create and show only request fields."""
if request.method == 'GET':
return render_template('new_request.html', title="New Ticket")
if request.method == 'POST':
item = request.form['item']
deliverer = ''
requester = request.form['requester']
dropoff_address = request.form['dropoff_address']
dropoff_time = request.form['dropoff_time']
dropoff_date = request.form['dropoff_date']
gyfter = ''
pickup_address = ''
pickup_time = ''
pickup_date = ''
ticket = Ticket(item, deliverer, gyfter, pickup_address,
pickup_time, pickup_date, requester,
dropoff_address, dropoff_time, dropoff_date)
db.session.add(ticket)
db.session.commit()
return render_template('show_request.html', ticket=ticket)
def book_ticket():
if 'user_id' not in session:
return login_in_please()
user_id = session['user_id']
req = request.get_json()
if 'type' not in req:
return bad_request()
ticket_type = req['type']
if ticket_type not in app.config['TYPE_IDS'].values():
return bad_request()
seat_num = None
if ticket_type == app.config['TYPE_IDS']['pc']:
if 'seat' not in req:
return bad_request()
seat_num = req['seat']
tickets_max = app.config['TICKETS_MAX']
price = app.config['PRICING'][ticket_type]
r = Ticket.book_temp(user_id, ticket_type, price, tickets_max, seat_num)
if r[0]:
ticket = Ticket.query.filter(Ticket.owner_id == user_id) \
.filter(or_(Ticket.paid, Ticket.reserved_until >= datetime.now())) \
.one()
return jsonify({'ticket': ticket.as_pub_dict()}), 201
# Conflict while booking ticket
return jsonify({'error': str(r[1])}), 409
def create_ticket():
""" Function creates new ticket
takes the ticket values
checks if ticket with 'name' parameter already exists in database
and flashes the message back to frontend if True
saves new ticket in database
redirects to url served by 'project_show_update_delete' function
"""
name = request.form.get('name')
description = request.form.get('description')
author_id = request.form.get('author_id')
project_id = request.form.get('project_id')
ticket_priority = request.form.get('ticket_priority')
ticket_status = request.form.get('ticket_status')
time = request.form.get('due_date')
due_date = datetime.strptime(time, '%Y-%m-%d')
new_ticket = Ticket(name=name,
description=description,
author_id=author_id,
project_id=project_id,
ticket_priority=ticket_priority,
ticket_status=ticket_status,
due_date=due_date)
db.session.add(new_ticket)
db.session.commit()
return redirect(url_for('project_show_update_delete', id=project_id))
def newticket():
user = g.user
form = TicketForm()
if form.validate_on_submit():
import datetime
t = Ticket()
form.populate_obj(t)
t.timestamp = datetime.datetime.utcnow()
t.created = datetime.datetime.utcnow()
t.user_id = user.id
db.session.add(t);
db.session.commit()
flash('New ticket submitted: ' + form.subject.data)
return redirect('/dashboard')
return render_template('newticket.html', form=form, user=user)
def test_add_ticket_note(self):
# Add users and a ticket so that we can add some notes.
self.add_users_to_db()
ticket = Ticket(id=9,
status=1,
createdAt=datetime.date.today(),
updatedAt=datetime.date.today())
self.session.add(ticket)
self.session.commit()
# Create the note.
result = self.app.post('/portal/ticket/note/9',
data=dict(poster="oompa",
message="my message to the world",
status=1,
type=2),
follow_redirects=True)
assert result.status == "200 OK"
# Verify the note is actually in the db.
note = self.session.query(Note).filter_by(
ticket_id=9, message="my message to the world", status=1,
type=2).first()
assert note is not None
ticket = self.session.query(Ticket).first()
def continue_scenario(self, text, state):
steps = settings.TICKET_SCENARIOS[state.scenario_name]['steps']
step = steps[state.step_name]
handler = getattr(handlers, step['handler'])
if handler(text=text, context=state.context, state=state):
if type(handler(text=text, context=state.context,
state=state)) is str:
next_step = steps[handler(text=text,
context=state.context,
state=state)]
else:
next_step = steps[step['next_step']]
text_to_send = next_step['text'].format(**state.context)
if next_step['next_step']:
state.step_name = step['next_step']
else:
if next_step == steps['step8']:
log.info(
'Оформлен билет {point_1}-{point_2} на рейс {flight_number}'
' {out_date}.'.format(**state.context))
Ticket(city_out=state.context['point_1'],
city_in=state.context['point_2'],
flight_date=state.context['out_date'],
flight_number=state.context['flight_number'])
else:
log.info('Билет не оформлен.'.format(**state.context))
# finish scenario
state.delete()
else:
text_to_send = step['failure_text'].format(**state.context)
return text_to_send
def test_delete_ticket_note(self):
# Create our two users and make them owners of the same ticket.
self.add_users_to_db()
ticket = Ticket(id=3,
status=0,
createdAt=datetime.date.today(),
updatedAt=datetime.date.today())
self.session.add(ticket)
users = self.session.query(User).all()
for user in users:
owner = Ownership(owner_id=user.id,
ticket_id=3,
createdAt=datetime.date.today(),
updatedAt=datetime.date.today())
self.session.add(owner)
note = Note(id=6,
poster_id=users[0].id,
ticket_id=3,
message="My message to the world",
status=2,
type=3,
createdAt=datetime.date.today(),
updatedAt=datetime.date.today())
self.session.add(note)
self.session.commit()
# Now delete the note and verify it is gone.
response = self.app.delete('/portal/ticket/note/6')
response.status == "200 OK"
result = self.session.query(Note).first()
assert result is None
def test_new_ticket_linked_content(self):
ticket = Ticket()
ticket.source = 'new_sound'
ticket.status = 'new'
ticket.sender = User.objects.get(username='******')
ticket.assignee = User.objects.get(username='******')
ticket.queue = Queue.objects.get(name=QUEUE_SOUND_MODERATION)
ticket.save()
lc = LinkedContent()
# just to test, this would be a sound object for example
lc.content_object = User.objects.get(username='******')
lc.save()
ticket.content = lc
ticket.content.save()
self.assertEqual(User.objects.get(username='******').id,
ticket.content.object_id)
def post(self, code):
session = get_current_session()
code = helper.parse_post_id(
helper.sanitizeHtml(self.request.get('code')))
password = helper.sanitizeHtml(self.request.get('password'))
password_confirm = helper.sanitizeHtml(
self.request.get('password_confirm'))
if password != password_confirm:
session['error'] = "Ocurrió un error al confirmar el password"
self.redirect('/recovery/' + code)
return
ticket = Ticket.all().filter('code', code).filter('is_active',
True).fetch(1)
if len(ticket) == 1:
ticket = ticket[0]
user = ticket.user
user.password = User.slow_hash(password)
user.put()
ticket.is_active = False
ticket.put()
session[
'success'] = "Se ha cambiado el password correctamente, ya puedes iniciar sesión con tus nuevas credenciales"
self.redirect('/login')
else:
self.redirect('/')
def test_model(self):
"""Test Services models"""
status = TicketStatus(name='TestStatus')
status.save()
self.assertNotEquals(status.id, None)
queue = TicketQueue(name='TestQueue', default_ticket_status=status)
queue.save()
self.assertNotEquals(status.id, None)
ticket = Ticket(name='TestTicket', status=status, queue=queue)
ticket.save()
self.assertNotEquals(ticket.id, None)
ticket.delete()
queue.delete()
status.delete()
def testUniqueTicket(self):
"""
TODO
"""
with self.assertRaises(IntegrityError):
self.ticket = Ticket(night=self.night, sector=self.sector, row=1,
sit=1, public_type=self.pt)
self.ticket.save()
def generate_random_data():
from models import Area, User, Ticket, Note, TicketCloseReason
import random
import loremipsum
db.drop_all()
db.create_all()
areas = [
Area(name=u'CTO'),
Area(name=u'Network'),
Area(name=u'Infrastructure'),
Area(name=u'Devops'),
Area(name=u'Helpdesk'),
]
db.session.add_all(areas)
db.session.commit()
users = [
User(user='******', name=u'Bruno Bonagura', areas=areas, access_admin=True, access_reports=False),
]
users[0].set_password('ax886dds')
db.session.add_all(users)
reasons = [
TicketCloseReason(reason=u'Solved'),
TicketCloseReason(reason=u'False Alarm'),
TicketCloseReason(reason=u'Network failure'),
TicketCloseReason(reason=u'Misconfiguration'),
TicketCloseReason(reason=u'Remission')
]
db.session.add_all(reasons)
db.session.commit()
random.seed('oi')
for i in range(1, 100):
t = Ticket(
title = unicode(loremipsum.get_sentence()),
text = unicode(loremipsum.get_paragraph()),
current_area = random.choice(areas),
created_at = datetime.now() - timedelta(random.randint(1,100)),
created_by = random.choice(users),
)
t.add_note(random.choice(users), unicode(loremipsum.get_sentence()))
db.session.add(t)
db.session.commit()
def testChangeWasSelled(self):
"""
TODO
"""
ticket = Ticket(night=self.night, sector=self.sector, row=1,
sit=3, public_type=self.pt)
ticket.save()
self.assertEquals(False, ticket.was_selled)
self.sell = Sell(sell_point=self.sell_point)
self.sell.save()
ticket_sell = TicketSell(sell=self.sell, ticket=ticket)
ticket_sell.save()
self.assertEquals(True, ticket.was_selled)
def post_tickets():
ticket_form = request.form.to_dict()
new_ticket = Ticket.create(ticket_form)
if not new_ticket:
return json.dumps({'error': "couldn't add ticket"}), 422
return json.dumps({'ticket': new_ticket}), 200
def post(self):
session = get_current_session()
email = helper.sanitizeHtml(self.request.get('email'))
if len(email) > 1:
users = User.all().filter("email =", email).fetch(1)
if len(users) == 1:
if session.is_active():
session.terminate()
user = users[0]
Ticket.deactivate_others(user)
ticket = Ticket(user=user,code=Ticket.create_code(user.password + user.nickname + str(random.random())))
ticket.put()
code = ticket.code
host = self.request.url.replace(self.request.path,'',1)
mail.send_mail(sender="NoticiasHacker <*****@*****.**>",
to=user.nickname + "<"+user.email+">",
subject="Liga para restablecer password",
html=template.render('templates/mail/forgotten-password-email.html', locals()),
body=template.render('templates/mail/forgotten-password-email-plain.html', locals()))
session['forgotten_password_ok'] = "Se ha enviado un correo electrónico a tu bandeja de entrada con las instrucciones"
else:
session['forgotten_password_error'] = "El correo electronico <strong>"+ email +"</strong> no existe en nuestra base de datos"
else:
session['forgotten_password_error'] = "Debes especificar tu correo electrónico"
self.redirect('/olvide-el-password')
def verify(ticket_id):
try:
ticket = Ticket.get(id = ticket_id)
if ticket.has_won():
return ticket
else:
return None
except Ticket.DoesNotExist:
return None
def on_pay_clicked(self,widget,data=None):
id = self.serial_number.get_text()
ticket = Ticket.get(id=id)
ticket.paid = True
ticket.paidDate = datetime.now()
ticket.save()
self.serial_number.set_text("")
self.validity_label.set_text("")
self.pay.set_sensitive(False)
def test_new_ticket(self):
"""New tickets shouldn't have an assignee"""
ticket = Ticket()
ticket.status = 'new'
ticket.sender = User.objects.get(username='******')
ticket.queue = Queue.objects.get(name=QUEUE_SUPPORT_REQUESTS)
ticket.save()
self.assertEqual(ticket.assignee, None)
def test_new_ticket(self):
ticket = Ticket()
ticket.source = 'contact_form'
ticket.status = 'new'
ticket.sender = User.objects.get(username='******')
ticket.queue = Queue.objects.get(name=QUEUE_SUPPORT_REQUESTS)
ticket.save()
self.assertEqual(ticket.assignee, None)
def newticket(item='', deliverer='',
gyfter='', pickup_address='', pickup_time='', pickup_date='',
requester='', dropoff_address='', dropoff_time='',
dropoff_date=''):
"""Render ticket form."""
if request.method == 'GET':
return render_template('new_ticket.html', title="New Ticket")
if request.method == 'POST':
# alternative store form fields in varibles & create new ticket object
item = request.form['item']
deliverer = request.form['deliverer']
gyfter = request.form['gyfter']
pickup_address = request.form['pickup_address']
pickup_time = request.form['pickup_time']
pickup_date = request.form['pickup_date']
requester = request.form['requester']
dropoff_address = request.form['dropoff_address']
dropoff_time = request.form['dropoff_time']
dropoff_date = request.form['dropoff_date']
ticket = Ticket(item, deliverer, gyfter, pickup_address,
pickup_time, pickup_date, requester,
dropoff_address, dropoff_time, dropoff_date)
db.session.add(ticket)
db.session.commit()
# map2 show
pickup_ll = geocoder.google(pickup_address)
dropoff_ll = geocoder.google(dropoff_address)
pickup_geoj = pickup_ll.geojson
dropoff_geoj = dropoff_ll.geojson
# complete address
pickup_address = pickup_geoj['properties']['address']
dropoff_address = dropoff_geoj['properties']['address']
p_lat, p_lng = pickup_ll.lat, pickup_ll.lng
d_lat, d_lng = dropoff_ll.lat, dropoff_ll.lng
coords_1 = (p_lat, p_lng)
coords_2 = (d_lat, d_lng)
dist = geopy.distance.vincenty(coords_1, coords_2).mi
dist = round(dist, 2)
dist = str(dist) + ' mi'
return render_template('map2.html',
ticket=ticket,
p_lat=p_lat, p_lng=p_lng,
d_lat=d_lat, d_lng=d_lng,
pickup_geoj=pickup_geoj,
dropoff_geoj=dropoff_geoj, dist=dist)
def test_get_ticket_notes_where_note_does_not_exist(self):
ticket = Ticket(id=2,
status=2,
createdAt=datetime.date.today(),
updatedAt=datetime.date.today())
self.session.add(ticket)
self.session.commit()
result = self.app.get('/portal/ticket/note/2')
assert result.status == "204 NO CONTENT"
def save_ticket(ticket):
''' Save the ticket to the database '''
# Get relevant chunks of ticket
ticket_chunks = ticket.split()
ticket_id = ticket_chunks[1]
team = ticket_chunks[2].title()
priority = ticket_chunks[3].title()
# Check for existing ticket
existing_ticket = Ticket.objects.filter(ticket_id=ticket_id)
if existing_ticket:
return False
# Create and save ticket if it doesn't exist
new_ticket = Ticket(ticket_id=ticket_id, team=team, priority=priority)
new_ticket.save()
return True
def increase_growth_backlog(column: Column):
while True:
from app import app
with app.app_context():
ticket_complexity = np.random.choice(Complexity.query.all(), 1, p=[0.1, 0.3, 0.4, 0.15, 0.05])[0]
ticket_type = np.random.choice(TicketType.query.all(), 1, p=[0.47, 0.43, 0.05, 0.05])[0]
ticket_priority = np.random.choice(Priority.query.all(), 1, p=[0.15, 0.41, 0.38, 0.06])[0]
status = Status.query.filter_by(name=column.name).first()
ticket_components = np.random.choice(Component.query.all(), np.random.randint(1, 3), p=[0.5, 0.25, 0.25])
Ticket(complexity=ticket_complexity.id,
type=ticket_type.id,
priority=ticket_priority.id,
status=status.id,
column_id=column.id,
components=[component for component in ticket_components])
yield g.env.timeout(1)
return
# def development(self):
# while True:
# """START TO WORK"""
# yield g.env.timeout(0.25)
# """START TO WORK: SEARCH TICKET"""
# ticket_selected = self._search_ticket()
# return
# def _search_ticket(self):
# for ticket in
# for ticket in self.board.board.tickets['SELECTED FOR DEVELOPMENT']:
# for ticket_component in ticket.components:
# if ticket_component in self.components:
# if ticket.type == g.subtask_types:
#
# """TAKE COMPLETION BLOCKER"""
# self.start_to_work(ticket, 'IN DEV')
# return True
# elif ticket.type in g.subtask_types:
#
# """TAKE SUB-TASK"""
# self.start_to_work(ticket, 'IN DEV')
# return True
# elif ticket.type == 'Feature':
#
# """TAKE FEATURE"""
# self.start_to_work(ticket, 'IN ANALYSIS')
# ticket.move_on('IN ANALYSIS', self.board.board)
# return True
# else:
#
# """TAKE TASK, DECHNICAL DEBT AND OTHER PARENT CARD"""
# self.start_to_work(ticket, 'IN DEV')
# return True
# return False
def post_tickets():
ticket_form = request.form.to_dict()
new_ticket = Ticket.create(ticket_form)
if not new_ticket:
return json.dumps({
'error': "couldn't add ticket"
}), 422
return json.dumps({
'ticket': new_ticket
}), 200
def on_serial_number_changed(self,widget,data=None):
id = self.serial_number.get_text()
if id != "":
try:
ticket = Ticket.get(id=id,branch=1)
self.validity_label.set_text("Available")
self.verify_serial.set_sensitive(True)
except Ticket.DoesNotExist:
self.validity_label.set_text("Invalid")
self.verify_serial.set_sensitive(False)
else:
self.verify_serial.set_sensitive(False)
def get(self,code):
session = get_current_session()
code = helper.parse_post_id(code)
if session.has_key('error'):
error = session['error']
ticket = Ticket.all().filter('code',code).filter('is_active',True).fetch(1)
if len(ticket) == 1:
ticket = ticket[0]
self.response.out.write(template.render('templates/new-password.html', locals()))
else:
self.redirect('/')
def post(self):
session = get_current_session()
email = helper.sanitizeHtml(self.request.get('email'))
if len(email) > 1:
users = User.all().filter("email =", email).fetch(1)
if len(users) == 1:
if session.is_active():
session.terminate()
user = users[0]
Ticket.deactivate_others(user)
ticket = Ticket(user=user,code=Ticket.create_code(user.password + user.nickname + str(random.random())))
ticket.put()
code = ticket.code
host = self.request.url.replace(self.request.path,'',1)
sender = "Santiago Zavala - Fogata.co <*****@*****.**>"
logging.info("sender = " + sender )
mail.send_mail(sender=sender,
to=user.nickname + "<"+user.email+">",
subject="Liga para restablecer password",
html=template.render('templates/mail/forgotten-password-email.html', locals()),
body=template.render('templates/mail/forgotten-password-email-plain.html', locals()))
session['forgotten_password_ok'] = "Se ha enviado un correo electrónico a tu bandeja de entrada con las instrucciones"
else:
session['forgotten_password_error'] = "El correo electronico <strong>"+ email +"</strong> no existe en nuestra base de datos"
else:
session['forgotten_password_error'] = "Debes especificar tu correo electrónico"
self.redirect('/olvide-el-password')
def update_jsapi():
print 'update jsapi'
params = {
'access_token': get_ticket(1).content,
'type': 'jsapi',
}
host = 'api.weixin.qq.com'
path = '/cgi-bin/ticket/getticket'
method = 'GET'
res = send_request(host, path, method, params=params)
if not res[0]:
return False
if res[1].get('errcode'):
return False
token = res[1].get('ticket')
starttime = timezone.now()
expires_in = timedelta(seconds=int(res[1].get('expires_in')))
endtime = starttime + expires_in
token_record = Ticket.objects.filter(ticket_type=2).order_by('-start_time')
if len(token_record) > 0:
token_record = token_record[0]
else:
token_record = Ticket()
token_record.content = token
token_record.end_time = endtime
token_record.ticket_type = 2
token_record.save()
return token_record
def testReSellSelledTicket(self):
"""
TODO
"""
ticket = Ticket(night=self.night, sector=self.sector, row=1,
sit=5, public_type=self.pt)
ticket.save()
sell = Sell(sell_point=self.sell_point)
sell.save()
ticket_sell = TicketSell(sell=sell, ticket=ticket)
ticket_sell.save()
self.assertEquals(True, ticket.was_selled)
sell = Sell(sell_point=self.sell_point)
sell.save()
with self.assertRaises(ValidationError):
ticket_sell = TicketSell(sell=sell, ticket=ticket)
ticket_sell.save()
def test_new_ticket(self):
"""New tickets shouldn't have an assignee"""
ticket = Ticket()
ticket.status = 'new'
ticket.sender = User.objects.get(username='******')
ticket.queue = Queue.objects.get(name=QUEUE_SUPPORT_REQUESTS)
ticket.save()
self.assertEqual(ticket.assignee, None)
def index(request, action=None):
if request.method == 'POST':
ticketForm = myForms.TicketForm(request.POST)
if ticketForm.is_valid():
newTicket = Ticket(
issuer = request.user.username,
victim = ticketForm.cleaned_data['victim'],
ship = ticketForm.cleaned_data['ship'],
kbLink = ticketForm.cleaned_data['kbLink'],
notes = ticketForm.cleaned_data['notes'],
statusOpen = True,
#date_entry = datetime.datetime.now(),
date_closed = None,
)
#print newTicket
newTicket.save()
return HttpResponseRedirect('.')
else:
print 'ticket error'
return HttpResponseRedirect('.')
else:
ticketForm = myForms.TicketForm()
rList = ShipPrice.objects.all()
tList = Ticket.objects.all()
loginForm = None
if request.user and request.user.is_authenticated() and not request.user.is_anonymous():
user = request.user
else:
user = None
loginForm = myForms.LoginForm()
return render_to_response('index.html', {
'current_user':user,
'loginForm':loginForm,
'ticketForm':ticketForm,
'rList':rList,
'tList':tList,
},
context_instance=RequestContext(request))
def syncTicketTable(self):
data = {}
objects = []
for ticket in Ticket.filter(synced = False):
obj = {'ticket':ticket.id,'branch':1,'amount':str(ticket.amount),'betOn':str(ticket.betOn)}
ticket.synced = True
ticket.save()
objects.append(obj)
data['name'] = objects
request = Request(url='http://'+self.URL+'/sync/ticket',data=json.dumps(data))
try:
urlopen(request).read()
except HTTPError, err:
pass
def make_test_user(self):
try:
user = User.query.filter(User.email == "*****@*****.**").one()
except NoResultFound:
user = User('*****@*****.**', 'testuser')
user.set_password('happycamper')
db.session.add(user)
amounts = {
"prepayfull" : TicketType.query.filter(TicketType.name == 'Full Camp Ticket (prepay)').one().cost,
"full" : TicketType.query.filter(TicketType.name == 'Full Camp Ticket').one().cost
}
#
# TODO: needs to cover:
#
# single full ticket, no prepay
# single full ticket with prepay
# multiple full tickets, no prepay
# multiple full tickets, with prepay
# multiple full tickets, some prepay
#
# kids & campervans?
#
# full, prepay
for full, pp in ((1,0), (0,1), (3,0), (0,3), (2,1)):
for pt in (BankPayment, GoCardlessPayment, GoogleCheckoutPayment):
total = (full * amounts['full']) + (pp * amounts['prepayfull'])
payment = pt(total)
payment.state = "inprogress"
if payment.provider == "gocardless":
payment.gcid = "%3dSDJADG" % (int(random.random() * 1000 ))
sess.add(payment)
tt = 'Full Camp Ticket'
for i in range(full):
t = Ticket(type_id = TicketType.query.filter(TicketType.name == tt).one().id)
t.payment = payment
t.expires = datetime.utcnow() + timedelta(days=app.config.get('EXPIRY_DAYS'))
user.tickets.append(t)
tt = 'Full Camp Ticket (prepay)'
for i in range(pp):
t = Ticket(type_id = TicketType.query.filter(TicketType.name == tt).one().id)
t.payment = payment
t.expires = datetime.utcnow() + timedelta(days=app.config.get('EXPIRY_DAYS'))
user.tickets.append(t)
user.payments.append(payment)
db.session.commit()
self.user = user
print user.name
for p in user.payments.all():
print p.provider, p.amount
print p.tickets.all()
