Exemple #1
0
 def test_get_description(self):
     request = Request()
     request.username = "******"
     request.save()
     twitterProfile = GetTwitterProfile(request)
     self.assertEqual(twitterProfile.description,
                      "Jugador de Boca Juniors y Piola Vago frontman")
    def test_requests(self):
        request = Request(path = "/foo")
        request.save()
        django_response = HttpResponse(self.text)

        # No rules, should pass
        self.assertEqual(len(check_request_rules(request, django_response)), 0)

        # Should have one error now that the status is not 200
        django_response.status_code = 442
        self.assertEqual(len(check_request_rules(request, django_response)), 1)
        
        # set it back for the rest of the tests
        django_response.status_code = 200
        self.assertEqual(len(check_request_rules(request, django_response)), 0)

        rule1 = RequestRule(request = request, target = "content", operator = "contains", value = "Teletubbies")
        rule1.save()
        self.assertEqual(len(check_request_rules(request, django_response)), 0)

        # add a rule that fails
        rule2 = RequestRule(request = request, target = "content", operator = "!contains", value = "Teletubbies")
        rule2.save()
        self.assertEqual(len(check_request_rules(request, django_response)), 1)


        # Done testing requests, now test functionality on the models that have been created
        # str the request to test the __unicode__ method
        str(request) 

        # Test the display_operator
        self.assertEqual(rule2.display_operator, "does not contain")
        rule2.operator='foo'
        # Should not fail on unrecognized operator
        self.assertEqual(rule2.display_operator, "foo")
Exemple #3
0
 def test_request_completed(self):
     request = Request()
     request.username = "******"
     request.save()
     twitterProfile = GetTwitterProfile(request)
     request = Request.objects.latest()
     self.assertEqual(request.status, "Completed")
Exemple #4
0
def requestsv2():
    if not request.args or not request.args['key'] or request.args['key'] != IOS_API_KEY:
        abort(401)
    if request.method == "POST":
        if not request.json or not 'google_places_id' in request.json or not 'name' in request.json or not 'vicinity' in request.json:
            abort(400)
        report_request = Request(google_places_id=request.json['google_places_id'],
                                    name=request.json['name'],
                                    vicinity=request.json['vicinity'])
        questions = ''
        more_questions = ''
        if 'ios_device_id' in request.json:
            report_request.populate(ios_device_id=request.json['ios_device_id'])
        if 'questions' in request.json:
            report_request.populate(questions=request.json['questions'])
            questions = request.json['questions']
        if 'more_questions' in request.json:
            report_request.populate(more_questions=request.json['more_questions'])
            more_questions = request.json['more_questions']
        try:
            report_request.put()
            sender_address = "Scout Support <*****@*****.**>"
            user_address = "*****@*****.**"
            subject = "Update requested at %s" % request.json['name']
            body = """Name: %s\nAddress: %s\nQuestions: %s\nMore Questions: %s""" % (request.json['name'], request.json['vicinity'], ', '.join(questions), more_questions)
            logging.info('questions: %s', ', '.join(questions))
            logging.info('more_questions: %s', more_questions)
            mail.send_mail(sender_address, user_address, subject, body)
            return jsonify(report_request.to_dict())
        except CapabilityDisabledError:
            abort(400)
Exemple #5
0
 def test_request_account_not_found(self):
     request = Request()
     request.username = "******"
     request.save()
     twitterProfile = GetTwitterProfile(request)
     request = Request.objects.latest()
     self.assertEqual(request.status, "User not found")
Exemple #6
0
 def test_request_account_suspended(self):
     request = Request()
     request.username = "******"
     request.save()
     twitterProfile = GetTwitterProfile(request)
     request = Request.objects.latest()
     self.assertEqual(request.status, "Account suspended")
def create(request):

    if request.method=='POST':
        name = request.POST['username']
        email = request.POST['email']
        sex = request.POST['sex']
        mobile_number = request.POST['mobile_number']
        exam_city = request.POST['exam_city']
        current_city = request.POST['current_city']
        exam_date = request.POST['exam_date']

        if exam_date == '' or name == '' or email == '' or mobile_number == '' :
            return render_to_response('share/create.html')
        else :
            new_obj = Users(name = name, email = email, sex = sex, mobile_number = mobile_number,exam_city_id = exam_city,exam_date = exam_date, current_city = current_city)
            new_obj.save()
            if "requested_to" in request.session:

                obj = Request(requester = new_obj.id,requested_to = request.session["requested_to"])
                obj.save()
                del request.session["requested_to"]
                return HttpResponseRedirect('/thanks/')
            return HttpResponseRedirect('/thankyou/')
    if "exam_city" in request.session:
        return render_to_response('share/create.html',{'exists':1,'exam_date':request.session["exam_date"]})

    return render_to_response('share/create.html',{'exists':0})
Exemple #8
0
 def test_get_valid_profile1(self):
     request = Request()
     request.username = "******"
     request.save()
     twitterProfile = GetTwitterProfile(request)
     self.assertEqual(twitterProfile.name,
                      "Mauricio Morero (@maurimorero) | Twitter")
Exemple #9
0
  def get(self):
    user = self.user_model
    get_notifications(user)
    current_date = datetime.datetime.now() - datetime.timedelta(hours=8)

    all_requests = Request.query(Request.start_time >= current_date).order(Request.start_time)
    all_requests = [r for r in all_requests if r.sender != user.key]
    pending_requests = Request.query(Request.status == 'pending').order(Request.start_time)
    pending_requests = [r for r in pending_requests if r.start_time < current_date]

    # Sort by food type
    type_sort = sorted(all_requests, key=lambda x:x.food_type)
    types = {}

    for r in type_sort:
      # Get all types
      if r.food_type not in types:
        types[r.food_type] = []

    for r in type_sort:
      for t in types:
        if r.food_type == t:
          types[t].append(r)
          break

    self.response.out.write(template.render('views/feed.html', {'user': user,
      'pending_requests': pending_requests, 'all_requests': all_requests, 'food_type':types}))
Exemple #10
0
 def test_get_valid_profile2(self):
     request = Request()
     request.username = "******"
     request.save()
     twitterProfile = GetTwitterProfile(request)
     self.assertEqual(twitterProfile.name,
                      "Diario Olé (@DiarioOle) | Twitter")
Exemple #11
0
    def get(self, url):
      
      ip = self.request.remote_addr #to prevent abuses, only a request every minute is served
      
      request = Request.gql("where ip='%s'" % ip).get() #Look for request from the same IP address
      if not request is None:
        delta = request.is_allowed()
        
        if delta > 0: #too little time has passed from the previous request
          #self.error(408)   #Timeout Error
          self.response.set_status(408, "Your IP address has issued a request less than 1 min ago. Please wait %d seconds" % delta)
          return
      else:
        request = Request(ip=ip, page_crawled=url)
        request.save()
      
      self.response.headers['Content-Type'] = 'application/json'
      handler = CrawlerHandler()


      site_image = memcache.get(url)

      
      if site_image is None:
        home_page = handler.start_crawling(url, MAX_PAGE_DEPTH, MAX_PAGES_TO_CRAWL, 0.01)  #causes a little delay, but not too big (one 100th of a sec) 

        if home_page is None:
          self.error(400) #Bad Request
          return
        else:
          site_image = handler.page_graph(home_page)
          memcache.set(url, site_image)
      
      self.__responde(site_image) 
    def test_login_as(self):
        user = User.objects.create_user(username = TEST_USER, password = TEST_PASS, email = TEST_USER)

        request = Request(path = "/foo", login_as_user = user)
        request.save()

        response = create_django_response(request)
        self.assertTrue(response.context["user"].is_authenticated())
Exemple #13
0
def requests():
    '''Route to Requests Collection.'''
    if ('past' == request.args.get('date')):
        requests = Request.get_past_reqs()
    else:
        requests = Request.get_open_reqs()
    user = g.user
    return render_template('request/requests.html', requests=requests, user=user)
    def process_request(self, request):

        method = request.method
        path = request.path
        time = datetime.now().strftime('%d/%b/%Y %H:%M:%S')
        if not request.is_ajax() and path != '/requests/':
            request = Request(method=method, path=path, time=time)
            request.save()
Exemple #15
0
 def test_get_imageURI(self):
     request = Request()
     request.username = "******"
     request.save()
     twitterProfile = GetTwitterProfile(request)
     self.assertEqual(
         twitterProfile.imageURI,
         "https://pbs.twimg.com/profile_images/959194538182103041/q6heJEdD_400x400.jpg"
     )
Exemple #16
0
    def test_login_as(self):
        user = User.objects.create_user(username=TEST_USER,
                                        password=TEST_PASS,
                                        email=TEST_USER)

        request = Request(path="/foo", login_as_user=user)
        request.save()

        response = create_django_response(request)
        self.assertTrue(response.context["user"].is_authenticated())
Exemple #17
0
 def process_request(self, request):
     data = {}
     data['Path'] = request.path
     data['Method'] = request.method
     data['Meta'] = str(request.META)
     req = Request(request=data)
     if request.user.is_authenticated():
         req.priority = 1
     req.save()
     return None
Exemple #18
0
def login():
    # first check if this ip should be banned
    r = Request.query.filter_by(request_addr=request.remote_addr).first()
    if r == None:
        r = Request(request_addr=request.remote_addr)
        db.session.add(r)
        db.session.commit()
    else:
        r.attempts += 1
        should_ban = True if r.attempts > 3 else False
        if should_ban:
            r.banned_until = datetime.now() + timedelta(hours=1)

            # remove the  ban after 1 hour
            oneHourInSecond = 1 * 60 * 60
            threading.Timer(oneHourInSecond, remove_ban,
                            (request.remote_addr, )).start()

        db.session.add(r)
        db.session.commit()

        if should_ban:
            abort(403)

    if current_user.is_authenticated:
        return render_template(url_for('index'))

    form = PNOForm()
    if form.validate_on_submit():
        pno = form.pno.data
        user = User.get_by_pno(pno)

        # user has registered before
        if user is not None:
            session['pno'] = pno
            return redirect(url_for('login4'))

        # no such user ever existed
        else:
            user = User(pno)
            db.session.add(user)
            db.session.commit()

            # generate random for verification code
            # not doing anything for now, reserved for future probably
            rand = randint(1000, 9999)
            flash('this is your verification code: {}'.format(rand))

            session['pno'] = pno
            session['verif_code'] = rand
            return redirect(url_for('login2'))

        return render_template('index.html')
    return render_template('login.html', form=form)
Exemple #19
0
 def get(self):
   current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
   max_time = current_time + datetime.timedelta(hours=1)
   dead_accepted_requests = Request.query(Request.start_time > current_time, Request.start_time < max_time).fetch()
   dead_accepted_requests = [x for x in dead_accepted_requests if x.status == "sms" and x.recipient != None]
   for request in dead_accepted_requests:
     request.status = "dead"
   dead_requests = Request.query(Request.start_time < current_time).fetch()
   dead_requests = [x for x in dead_requests if x.status == "waiting for a bid" or x.status =="pending"]
   for request in dead_requests:
     print "Removing request: " + str(request)
     request.key.delete()
Exemple #20
0
 def getallrequests():
     roles = g.jwt_oidc_token_info['realm_access']['roles']
     userid = g.jwt_oidc_token_info['sub']
     userrole = 'user_role'
     approverrole = 'approver_role'
     if userrole in roles:
         requests = Request.get_requests_by_user(userid)
     elif approverrole in roles:
         requests = Request.get_requests_by_role()
     else:
         requests = Request.get_requests()
     jsondata = json.dumps(requests)
     return jsondata, 200       
def starting_page():
  print 'Submitting a task'
  r = Request()
  r.name = 'Some random name'
  db.session.add(r)
  db.session.commit()
  
  context = dict()
  context['id'] = r.id
  db.session.close()
  db.session.remove()
  run_workflow(context)
  return ('Task submitted %r' % context['id']), 201
Exemple #22
0
def TakeRequest(request, url):
    request_url = URL(url)
    robj = Request.objects.filter(target__contains=request_url.host)
    if not robj:
        r = Request(request_type='HttpRequest', storage_type='UrlStorage', 
                    action='mirror', target=request_url.host, flag='requested')
    else:
        r = robj[0]
        r.flag = 'requested'

    r.save()

    return HttpResponseRedirect('http://%s/%s' % (getifip(web_server_interface), request_url.with_www().replace('http://', '')))
def test_request_model_does_not_find_row_if_it_does_not_exist(initialize_db):
    """
    Tests that model does not find row correctly if it does not exist in
    the db.

    Args:
        initialize_db (None): initializes the database and drops tables when
            test function finishes.
    """
    with raises(ClientError) as err:
        Request.find_by_id(1)

    assert err.value.message == 'cannot find specified request'
    assert err.value.status_code == 404
Exemple #24
0
def get_notifications(user):
  #Get Requests for Notifications
  accepted_requests = []
  new_requests = []
  current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
  # Check for last login/update
  check_time = user.last_check
  print "Last Check: " , check_time
  if check_time is None:
    # Pull all results from previous week
    check_time = datetime.datetime.now() - datetime.timedelta(days=7, hours=8)
    print "Updated time: ", check_time

  # New requests
  available_requests = Request.query(Request.sender != user.key).fetch()
  available_requests = [r for r in available_requests if r.creation_time >= check_time]
  available_requests = [r for r in available_requests if r.start_time >= current_time]
  available_requests = [r for r in available_requests if r.recipient == None]

  # Approved requests
  approved_requests = Request.query(Request.recipient == user.key).fetch()
  approved_requests = [r for r in approved_requests if r.accept_time != None]
  approved_requests = [r for r in approved_requests if r.start_time >= current_time]
  approved_requests = [r for r in approved_requests if r.accept_time >= check_time]


  # Pending requests
  pend_requests = Request.query(Request.sender == user.key).fetch()
  pend_requests = [r for r in pend_requests if r.start_time >= current_time]
  pend_requests = [r for r in pend_requests if len(r.bidders) > 0]
  new_bidders = 0
  if len(pend_requests) > 0:
    for r in pend_requests:
      for bid in r.bidders:
        bid = bid.get()
        if bid.bid_time != None:
          if bid.bid_time > check_time:
            print "Bid Time: " , bid.bid_time
            new_bidders += 1
  else:
    pend_requests = [r for r in pend_requests if r.creation_time >= check_time]
    print "No bidders: ", pend_requests

  user.pending_requests = new_bidders
  user.available_requests = len(available_requests)
  print len(available_requests)
  user.approved_requests = len(approved_requests)
  print len(approved_requests)
  user.put()
  print "user updated"
Exemple #25
0
def api_view_request(request_rid):
    check_admin()
    request = Request.find_by('where rid = ?', request_rid)
    response = Response.find_by('where rid = ?', request_rid)
    if request is None or response is None:
        raise notfound()
    return dict(request=content_escape(request), response=html_encode(response))
Exemple #26
0
    def fetch_request(self, username):
        cursor = self.conn.execute(
            """
      SELECT * FROM request where status == 0 AND to_user = (?)""",
            (username, ))

        donations = []
        consumptions = []
        for row in cursor:
            request_id = row[0]
            from_user = row[1]
            # to_user = row[2]
            appointment_date = row[3]
            appointment_time = row[4]
            request_type = row[5]
            beneficiary = row[6]
            frequency = row[7]
            description = row[8]
            status = row[9]
            create_date = row[10]

            new_request = Request(from_user, username, appointment_date,
                                  appointment_time, request_type, beneficiary,
                                  frequency, description, status, create_date,
                                  request_id)
            if request_type == constants.REQUEST_DONATION:
                donations.append(new_request)
            else:
                consumptions.append(new_request)
        return donations, consumptions
Exemple #27
0
def submit_donate_request():
    if session['logged_in'] and request.method == 'POST':
        from_user = session['username']
        to_user = request.form['to_user']
        appointment_date = request.form['date']
        appointment_time = request.form['time']
        request_type = constants.REQUEST_DONATION
        beneficiary = request.form['beneficiary']
        frequency = request.form['frequency']
        description = request.form['description']

        food_item_id = request.form['food_item_id']
        category_id = request.form['category_id']
        quantity = request.form['quantity']
        weight = request.form['weight']
        expiry_date = request.form['expiry_date']

        new_request = Request(from_user, to_user, appointment_date,
                              appointment_time, request_type, beneficiary,
                              frequency, description,
                              constants.REQUEST_PENDING)
        request_id = db.create_request_header(new_request)
        new_request_detail = Request_Detail(request_id, food_item_id,
                                            category_id, quantity, weight,
                                            expiry_date)
        db.create_request_detail_entry(new_request_detail)
        return "succeed"
Exemple #28
0
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)
Exemple #29
0
def update_request(id):
    user = g.user
    req = session.query(Request).filter(
        and_(Request.id == id, user.id != Request.user_id))
    if not req:
        abort(400)

    errors = Request.validate(request.json)
    if len(errors) == 0:
        meal_type = request.json.get('meal_type')
        location_string = request.json.get('location_string')
        latitude = request.json.get('latitude')
        longitude = request.json.get('longitude')
        meal_time = request.json.get('meal_time')
        new_req = {
            'meal_type': meal_type,
            'meal_time': meal_time,
            'latitude': latitude,
            'longitude': longitude,
            'location_string': location_string
        }
        req.update(new_req)
        session.commit()
        return jsonify({'response': True})
    else:
        return jsonify({'errors': errors}), 400
Exemple #30
0
def multiple_valid_request_models(multiple_valid_client_models,
                                  multiple_valid_staff_models):
    """
    A fixture for creating a multiple valid requests.

    Args:
        multiple_valid_client_models (list): a list of valid client models
            created by a fixture.
        multiple_valid_staff_models (list): a list of valid staff models
            created by a fixture.
    """
    requests = [
        Request(
            title='Improve customer care services',
            description='The current customer care services are reported to '
            'be abysmal with representatives dropping calls on customer or '
            'being rather unpleasant.',
            product_area=ProductArea.POLICIES,
            target_date=datetime.utcnow(),
            priority=i,
            staff_id=1,
            client_id=1,
        ).save() for i in range(12)
    ]

    return requests
Exemple #31
0
def addARequest(user_id):
    if request.method == 'POST':
        phone_no = request.json.get('phone_no')
        delivery_state = request.json.get('delivery_state')
        delivery_city = request.json.get('delivery_city')
        item_location_state = request.json.get('item_location_state')
        item_location_city = request.json.get('item_location_city')
        posted_on = request.json.get('posted_on')
        deliver_before = request.json.get('deliver_before')
        picture = request.json.get('picture')
        offer_amount = request.json.get('offer_amount')
        time_updated = request.json.get('time_updated')
        item_name = request.json.get('item_name')
        user = session.query(User).filter_by(id=user_id).first()
        profile_image = user.picture
        user_first_name = user.first_name
        user_last_name = user.last_name
        user_id = user_id
        newRequest = Request(phone_no=phone_no,
                             delivery_state=delivery_state,
                             delivery_city=delivery_city,
                             item_location_state=item_location_state,
                             item_location_city=item_location_city,
                             deliver_before=deliver_before,
                             posted_on=posted_on,
                             time_updated=time_updated,
                             profile_image=profile_image,
                             user_id=user_id,
                             user_first_name=user.first_name,
                             user_last_name=user.last_name,
                             item_name=item_name,
                             offer_amount=offer_amount,
                             picture=picture)
        session.add(newRequest)
        session.commit()
        payload = {}
        payload['profile_image'] = user.picture
        payload['id'] = newRequest.id
        payload['phone_no'] = phone_no
        payload['delivery_state'] = delivery_state
        payload['delivery_city'] = delivery_city
        payload['item_location_state'] = item_location_state
        payload['item_location_city'] = item_location_city
        payload['deliver_before'] = deliver_before
        payload['posted_on'] = posted_on
        payload['offer_amount'] = offer_amount
        payload['item_name'] = item_name
        payload['time_updated'] = time_updated
        payload['picture'] = picture
        payload['user_id'] = user_id
        payload['user_first_name'] = user_first_name
        payload['user_last_name'] = user.last_name

        raw = {"data": payload}
        request_data = json.dumps(raw)
        #result = push_service.notify_single_device(registration_id = reg_id, data_message= payload)
        result = push_service.notify_topic_subscribers(
            topic_name=REQUEST_TOPIC, data_message=payload)
        pprint(result)
        return request_data
def request_from():
    """ request money from a new Mutual Aid """

    user_id = request.args.get('user_id', None)
    situation = request.args.get('situation', None)
    identities = request.args.get('identities', None)
    amount = request.args.get('amount', None)
    venmo_username = request.args.get('venmo_username', None)

    #Keeping this here as a note to how to get the elements of the identity
    #identities_array = re.split(', |,',identities)

    user = User.query.filter_by(id=user_id).first()

    if user is None:
        return "Could not find a mutual aid by that id", 404

    request_obj = Request(situation=situation,
                          identities=identities,
                          amount=amount,
                          user_id=user_id,
                          venmo_username=venmo_username)

    db.session.add(request_obj)
    db.session.commit()

    #return the id so the requestor can search up their 'ticket' and know their progress
    return jsonify(id=request_obj.id), 200
Exemple #33
0
def test_flask_seed_model_cli_seeds_to_db_with_all_option(cli_app):
    """
    Tests that db tables are populated `flask seed model` when passed an `all`
    option.

    Args:
        cli_app (function): a flask app factory function that also manages its
            context.
    """
    # Create a script for running application.
    obj = ScriptInfo(create_app=cli_app)

    # Call command, apply arguments and create app.
    result = CliRunner().invoke(seed_model, ['all'], obj=obj)

    clients = Client.get_all()
    staff = Staff.get_all()
    requests = Request.get_all()
    comments = Comment.get_all()

    assert len(clients) == 3
    assert len(staff) == 3
    assert len(comments) == 14
    assert len(requests) == 12
    assert result.exit_code == 0
Exemple #34
0
 def test_create_django_response(self):
     request = Request(path="/foo")
     response = create_django_response(request)
     self.assertEqual(response.status_code, 404,
                      "status code on create_django_response")
     self.assertTrue("File not found" in response.content,
                     "content on create_django_response")
def add_request():
    if request.method == 'POST':
        data = request.get_json()
        req1 = Request(day=data["daySelect"],
                       requester=data["requester"],
                       startTime=data["startTime"],
                       endTime=data["endTime"],
                       reason=data["reason"],
                       weekly=data["weekly"],
                       status=False)
        db.session.add(req1)
        db.session.commit()
        print(Request.query.all())
    req = Request.query.all()
    newls = []
    for i in range(len(req)):
        newls.append({})
        newls[i]["id"] = req[i].id
        newls[i]["day"] = req[i].day
        newls[i]["requester"] = req[i].requester
        newls[i]["startTime"] = req[i].startTime
        newls[i]["endTime"] = req[i].endTime
        newls[i]["reason"] = req[i].reason
        newls[i]["status"] = req[i].status
        newls[i]["weekly"] = req[i].weekly
    return json.dumps(newls)
Exemple #36
0
def api_view_request(request_rid):
    check_admin()
    request = Request.find_by('where rid = ?', request_rid)
    response = Response.find_by('where rid = ?', request_rid)
    if request is None or response is None:
        raise notfound()
    return dict(request=content_escape(request), response=html_encode(response))
def requestsEliminator(msgBody, reqer):
    text = msgBody['Body'].lower()
    numOfMedia = msgBody['NumMedia']
    if numOfMedia == '0' and len(text) < 10:  # change latter to 150
        Request(requester=reqer, message=str(msgBody), status=99).save()
        return True
    return False
Exemple #38
0
def save_request(request_data):
    """
    Reorders entries for a client if priority already exists and
    saves new request.

    Args:
        request_data (dict): request data to be saved.
    """
    priority = request_data['priority']
    client_id = request_data['client_id']

    # Check for row with similar priority
    request = Request.query.filter_by(client_id=client_id,
                                      priority=priority).all()
    # Update every duplicate we find.
    while request:
        # Increment priority.
        priority += 1

        # Check for row with the newly updated priority value.
        new_request = Request.query.filter_by(client_id=client_id,
                                              priority=priority).all()

        # Update request with previous priority value.
        request[0].update(priority=priority)

        # Update request
        request = new_request

    Request(**request_data).save()
    def registerOptimizationRequest(request, user):
        assert user is not None
        ip = RequestUtils.getIPAddress(request)
        url = request.get_full_path()

        req = Request(ip=ip, url=url, request_user=user)
        req.save()

        optreq = OptimizationRequest(ip=ip,
                                     url=url,
                                     request=req,
                                     request_user=user)
        #req = Request(ip=ip,url=url,request_user = user)
        optreq.save()

        return optreq.id
Exemple #40
0
  def get(self):
    user = self.user_model
    date = cgi.escape(self.request.get("date"))
    time = cgi.escape(self.request.get("time"))
    active_request = cgi.escape(self.request.get("edit_request"))
    if active_request:
      edit_request = ndb.Key(urlsafe=active_request).get()

    # Check for lack of values
    if len(date) < 1:
      if active_request:
        date = edit_request.start_time.strftime("%Y-%m-%d")
      else:
        self.response.out.write('Please choose date')

    # Convert date and time to datetime
    format_date = str(date+ " " +time+":00.0")
    start_time = datetime.datetime.strptime(format_date, "%Y-%m-%d %H:%M:%S.%f")

    # Check for current request within time limit
    ongoing_request = Request.query(Request.sender == user.key).fetch()

    # Remove current request if applicable
    if active_request:
      ongoing_request.remove(edit_request)
    alloted_date = start_time + datetime.timedelta(minutes=20) #Max limit

    create = timeCheck(ongoing_request, alloted_date, start_time)
    if create is True:
      self.response.out.write('Available')
    else:
      self.response.out.write('Time Already Passed/Reserved')
Exemple #41
0
    def get(self, id):
        try:
            currentRequest = Request.get(id = id)
        except peewee.DoesNotExist:
            abort(404, message="Request {} doesn't exist".format(args.request_id))

        return currentRequest
Exemple #42
0
def authentication_request_get(message):
    '''
    This is the url that other system uses to redirect the user in order to authenticate them
    '''
    try:
        message = JWS().verify_compact(message, keys=[public_key])
    except BadSignature:
        return "Signature invalid"
    # todo check whether signed correctly raise BadSignature
    satosa_request = Request(message)
    user = database.get_user(satosa_request.userId)
    if not database.request_exists(satosa_request):
        database.save_request(satosa_request)
    else:
        return "REPLAY ATTACK"
    if not user:
        database.save_user(satosa_request.userId)
        new_user = database.get_user(satosa_request.userId)
        login_user(new_user)
        return render_template('satosa_registration_index.html',
                               username1=satosa_request.userId,
                               redirect_url1=cfg['caller']['callback-url'])
    if len(database.get_credentials(satosa_request.userId)) == 0:
        new_user = database.get_user(satosa_request.userId)
        login_user(new_user)
        return render_template('satosa_registration_index.html',
                               username1=satosa_request.userId,
                               redirect_url1=cfg['caller']['callback-url'])

    if cfg['host']['turn-off'] and database.is_turned_off(user.id):
        database.turn_on(user.id)
        login_user(user)
        satosa_request = Request()
        satosa_request.userId = user.id
        database.make_success(satosa_request)
        username = current_user.id
        credentials_array = database.get_credentials(username)
        return render_template("credentials.html",
                               credentials=credentials_array,
                               username1=username,
                               url=ORIGIN,
                               turn_off=cfg['host']['turn-off'],
                               timeout=int(
                                   cfg['host']['turn-off-timeout-seconds']))
    return render_template('satosa_index.html',
                           username1=satosa_request.userId,
                           redirect_url1=cfg['caller']['callback-url'])
Exemple #43
0
 def post(self):
     data = request.get_json()
     loggedInUser = User.query.filter_by(id=LOGGED_IN_USER).first()
     req = Request(str(loggedInUser.id), str(data['driver']),
                   str(data['rating']))
     db.session.add(req)
     db.session.commit()
     return
Exemple #44
0
    async def take_turn(self, message):
        player = getattr(self.game, f"player_{message.body['player_id']}")
        player.drawing_block()
        await self.pick_block(player=player, index=message.body['block_index'])
        request = await player.ws.recv()
        request = Request.deserialize(value=request)
        guess = Guess(**request.body)

        await self.guess_block(player, guess=guess)
Exemple #45
0
def api_request():
    """Send user's search request"""
    request_text = request.values.get('request')
    result = {
        'ok': 1,
        'request_id': -1
    }

    # create request_id in DB
    try:
        session_key = request.cookies.get('beaker.session.id')
        # session_key = request.cookies.get('sessionid')

        request_obj = Request(
            request=request_text,
            session=session_key
        )
        db.session.add(request_obj)
        db.session.commit()
        print("Created %s" % str(request_obj))
        result['request_id'] = request_obj.id
    except Exception as ex:
        print(ex)

    # associate all found results with this request_id
    results = []
    t = []
    try:
        t = translate(request_text)
    except Exception as ex:
        print("Translation failed: %s" % str(ex))

    pg_conn = psycopg2.connect(
        get_pg_connection_string(
            app.config['DBHOST'],
            app.config['DBNAME'],
            app.config['DBUSER'],
            app.config['DBPASS']))
    cur = pg_conn.cursor()

    if t and isinstance(t, str):
        t = t.strip().replace('\n', ' ').replace('', '').replace('', '').replace('OOV', "'OOV' OR 1 = 1")
        t = t.split(';')

    results_count = float(len(t))
    for i, r in enumerate(t):
        if r:
            results.append(Result(request_obj.id,
                                  r,
                                  results_count - float(i),
                                  resolve_report_type(cur, r)))

    for r in results:
        db.session.add(r)
    db.session.commit()

    return jsonify(result)
Exemple #46
0
 def get(self):
   current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
   # Get all requests in accepted state
   completed_requests = Request.query(Request.status == "foodie").fetch()
   #completed_requests = [x for x in completed_requests if x.start_time + datetime.timedelta(minutes=10) < current_time]
   for request in completed_requests:
     send_fire_notification(request)
     request.status = "attempt_fire"
     request.put()
def update_request(id):
    user = g.user
    if not request.json:
        abort(400)
    errors = Request.validate(request.json)
    if len(errors) == 0:
        return  jsonify( { 'result': True } )

    return jsonify({"message": "The request is invalid."},errors = [error for error in errors])  ,400
Exemple #48
0
def local_search(request, place_type):
    if request.GET.get('coords', ''):
        form = SearchForm(request.GET)
        if form.is_valid():
            (lat,lon) = form.cleaned_data['coords'].split(',')
            search_point = Point(float(lat),float(lon))
            r = Request(point=search_point, place_type=place_type)
            r.save()
            places = Place.objects.distance(search_point).filter(place_type=place_type).filter(point__distance_lte=(search_point, distance(mi=2))).order_by('distance')
            return render_to_response('_local_search.html', {
                    'title': place_type,
                    'places': places
                })

    else:
        form = SearchForm()
        return render_to_response('search.html', {
                'form': form,
                })
Exemple #49
0
def lookup(request):
    if request.GET.get('coords', ''):
        form = SearchForm(request.GET)
        if form.is_valid():
            (lat,lon) = form.cleaned_data['coords'].split(',')
            pnt=Point(float(lat),float(lon))
            n = get_neighborhood_by_point(pnt)
            r = Request(point=pnt, place_type="neighborhood")
            r.save()
            search_response = {'name': n.name.title(), 'polygon': n.gpoly(), 
                               'slug': n.slug, 'wiki': n.wiki,
                               'centroid_x': "%.5f" % n.poly.centroid.x,
                               'centroid_y': "%.5f" % n.poly.centroid.y}
            return HttpResponse(simplejson.dumps(search_response),
                                    mimetype='application/json')

    else:
        form = SearchForm()
        return render_to_response('search.html', {
                'form': form,
                })
Exemple #50
0
    def post(self):
        args = request_parser.parse_args()

        try:
            currentRequest = Request.get(id = args.request_id)
            currentRequest.status = 1 # status: the request is canceled
            currentRequest.save()
        except peewee.DoesNotExist:
            abort(404, message="Request {} doesn't exist".format(args.request_id))


        return args.request_id, 200
Exemple #51
0
    def post(self):
        args = request_parser.parse_args()

        try:
            currentRequest = Request.get(id = args.request_id)
            currentRequest.current_latitude = args.current_latitude
            currentRequest.current_longitude = args.current_longitude
            currentRequest.save()
        except peewee.DoesNotExist:
            abort(404, message="Request {} doesn't exist".format(args.request_id))

        return currentRequest.id, 200
Exemple #52
0
def details(id, page=20):
    actor = Schedule.select().where(Schedule.id == id).get()
    actor_requests = Request.select().where(Request.url_id == id).order_by(Request.insert_date.desc())
    pages = PaginatedQuery(actor_requests, page)
    content = pages.get_list()

    stats = {}
    stats['site_changes'] = actor_requests.select(Request.content_len).distinct().count()
    stats['total_hits'] = actor_requests.count()
    stats['ok_hits'] = actor_requests.select(Request.id).where(Request.status_code == '200').count()
    stats['avg_response_time'] = (sum([row.response_time for row in actor_requests])/stats['total_hits'])

    return render_template('details.html', actor=actor, actor_requests=content, pages=pages, stats=stats)
Exemple #53
0
    def post(self):
        args = request_parser.parse_args()

        try:
            currentRequest = Request.get(id = args.request_id)
            currentRequest.status = 6 # status: the request is closed
            currentRequest.board_price = args.end_price_estimate
            currentRequest.product = args.product_id
            currentRequest.save()
        except peewee.DoesNotExist:
            abort(404, message="Request {} doesn't exist".format(args.request_id))

        return args.request_id, 200
Exemple #54
0
 def get(self):
   current_time = datetime.datetime.now() - datetime.timedelta(hours=8)
   # 5 min before current
   min_time = current_time - datetime.timedelta(minutes=5)
   # 5 min after current
   max_time = current_time + datetime.timedelta(minutes=5)
   # Get all requests in accepted state
   completed_requests = Request.query(Request.status == "accepted").fetch()
   completed_requests = [x for x in completed_requests if x.recipient != None]
   #completed_requests = [x for x in completed_requests if x.start_time >= min_time and x.start_time < max_time]
   for request in completed_requests:
     send_sms(request)
     request.status = "sms"
     request.put()
Exemple #55
0
    def post(self):
        args = request_parser.parse_args()
        currentRequest = Request.create(user = args.user_id,
                              depart_latitude = args.start_latitude,
                              depart_longitude = args.start_longitude,
                              request_time = datetime.datetime.now(),
                              dest_latitude = args.end_latitude,
                              dest_longitude = args.end_longitude,
                              accept_price = args.target_price,
                              depart_price = args.start_price_estimate,
                              current_latitude = args.start_latitude,
                              current_longitude = args.start_longitude,
                              status = 3)

        return currentRequest.id, 200
Exemple #56
0
def services(request):
    r = Request(request_method=request.method,
                request_path=request.path,
                request_accept=request.META['HTTP_ACCEPT'],
                request_body=request.body)
    try:
        action = Action.objects.get(request_method=request.method,
                                    request_path=request.path,
                                    request_accept=request.META['HTTP_ACCEPT'])
    except ObjectDoesNotExist:
        r.response_status_code = 404
        r.save()
        return HttpResponse(status=404)
    else:
        r.response_status_code = action.response_status_code
        r.response_content = action.response_content
        r.response_content_type = action.response_content_type
        r.save()
        return HttpResponse(status=action.response_status_code,
                            content=action.response_content,
                            content_type=action.response_content_type)
def new_request():
    user = g.user
    if not request.json:
        abort(400)
    errors = Request.validate(request.json)
    if len(errors) == 0:
        meal_type = request.json.get('meal_type')
        longitude = request.json.get('longitude')
        latitude = request.json.get('latitude')
        location_string = request.json.get('location_string')
        meal_time = request.json.get('meal_time')
        r = Request(user_id = user.id,meal_type = meal_type, longitude = longitude, latitude = latitude, location_string = location_string, meal_time = meal_time)
        session.add(r)
        session.commit()
        return  jsonify( { 'result': True } ),201
    return jsonify({"message": "The request is invalid."},errors = [error for error in errors])  ,400
Exemple #58
0
def home(request):
    if request.method == 'POST':
            song_req = Request()
            song_req.user = request.POST.get('user', '')
            song_req.song = request.POST.get('song', '')
            song_req.message = request.POST.get('message', '')
            song_req.save()
    else:
        req = get_latest_request()
        listeners = get_listeners()
        title = get_title()
        return render_to_response('home.html', {'latest':req, 'listeners':listeners, 'title':title})
    def process_request(self, request):

        path_info = request.META['PATH_INFO']

        exlude_list = [reverse('request-counter'),
                       reverse('admin:jsi18n'),
                       settings.MEDIA_URL,
                       settings.STATIC_URL]

        if not any(url in path_info for url in exlude_list):
            new_http_request = Request()
            new_http_request.method = request.META['REQUEST_METHOD']
            new_http_request.path_info = path_info
            new_http_request.server_protocol = request.META['SERVER_PROTOCOL']
            new_http_request.viewed = False
            new_http_request.save()