Example #1
0
def users(user_id=None):
    """ Manages return of /users/ pages """

    if user_id is None:
        if request.method == "POST":
            form = request.get_json()
            if form is None:
                return "Not a JSON", 400
            if form.get('email') is None:
                return "Missing email", 400
            if form.get('password') is None:
                return "Missing password", 400
            new_user = User(**form)
            new_user.save()
            return new_user.to_dict(), 201
        if request.method == "GET":
            users = storage.all(User).values()
            users = [user.to_dict() for user in users]
            return jsonify(users)
    user = storage.get(User, user_id)
    if user is None:
        abort(404)
    if request.method == "DELETE":
        user.delete()
        storage.save()
        return {}
    if request.method == "PUT":
        form = request.get_json()
        if form is None:
            return "Not a JSON", 400
        for key, value in form.items():
            if key not in ['id', 'email', 'created_at', 'updated_at']:
                setattr(user, key, value)
        user.save()
    return user.to_dict()
Example #2
0
def spotify_search():
    """Search interface for javascript frontend
    function 'get_spotify_search_results'
    """
    # POST request
    if request.method == 'POST':
        # Get values from post request
        search_text = request.get_json()["search_text"]
        music_type = MusicType[request.get_json()["music_type"]]

        # Initialize response dict
        response_dict = {"music_results": [], "invalid_link": False}

        # Get the corresponding list of music to the search text. If the text
        # is an open spotify link, then attempt to get the music from it.
        # Otherwise, just search for the text in spotify and get a list of results.
        if re.match(r'https*://open.spotify.com/', search_text):
            if spotify_iface.spotify_link_invalid(music_type, search_text):
                response_dict["invalid_link"] = True
            else:
                music = spotify_iface.get_music_from_link(music_type, search_text)
                response_dict["music_results"] = [music.format_for_response_dict()]
        elif search_text:
            music_results = spotify_iface.search_for_music(music_type, search_text, num_results=20)
            response_dict["music_results"] = [music.format_for_response_dict() for music in music_results]

        return response_dict, 200
def amenities(amenity_id=None):
    """ Manages return of /amenities/ pages """

    if amenity_id is None:
        if request.method == "POST":
            form = request.get_json()
            if form is None:
                return "Not a JSON", 400
            if form.get('name') is None:
                return "Missing name", 400
            new_amenity = Amenity(**form)
            new_amenity.save()
            return new_amenity.to_dict(), 201
        if request.method == "GET":
            amenities = storage.all(Amenity).values()
            amenities = [amenity.to_dict() for amenity in amenities]
            return jsonify(amenities)
    amenity = storage.get(Amenity, amenity_id)
    if amenity is None:
        abort(404)
    if request.method == "DELETE":
        amenity.delete()
        storage.save()
        return {}
    if request.method == "PUT":
        form = request.get_json()
        if form is None:
            return "Not a JSON", 400
        for key, value in form.items():
            if key not in ['id', 'created_at', 'updated_at']:
                setattr(amenity, key, value)
        amenity.save()
    return amenity.to_dict()
Example #4
0
def states(state_id=None):
    """ Manages return of /states/ pages """

    # Handle '/states/' cases
    if state_id is None:

        if request.method == "POST":
            form = request.get_json()

            if form is None:
                return "Not a JSON", 400

            if form.get('name') is None:
                return "Missing name", 400

            new_state = State(**form)
            new_state.save()

            return new_state.to_dict(), 201

        if request.method == "GET":
            states = storage.all(State).values()
            states = [state.to_dict() for state in states]
            return jsonify(states)

    # Handle '/states/<state_id>' cases

    # get state
    state = storage.get(State, state_id)

    # abort if state doesn't exist
    if state is None:
        abort(404)

    # if "DELETE", delete state, return empty dict
    if request.method == "DELETE":
        state.delete()
        storage.save()
        return {}

    # if "PUT", update state
    if request.method == "PUT":

        form = request.get_json()

        if form is None:
            return "Not a JSON", 400

        for key, value in form.items():
            if key not in ['id', 'created_at', 'updated_at']:
                setattr(state, key, value)

        state.save()

    # return dict representation of state
    # Flask returns exit code 200 by default-- no need to specify it.
    return state.to_dict()
def signup():
    '''
    Callback for validation of signup
    '''
    # Extracts data from the posted request
    container = request.get_json(False, True, False) if request.mimetype == "application/json" else request.form
    login = container["login"]
    password = container["password"]
    email = container["email"]
    # Checks parameters are filled
    if (not login) or (not password) or (not email): 
        return jsonify(message = "Login, password and email must be filled."), 400
    # Checks if a user with given login already exists in db
    if not user_db_service.get_user_by_login(login) is None:
        return jsonify(message = "This login is already used."), 400
    
    #
    # Here we should check that email is valid and not already registered in db.
    # Then we would send a email to this address with an hyperlink to allow the user to confirm her address.
    # For the sake of simplicity, let's forget all this stuff and let's validate the account
    #
    
    # Registers user in db
    user = User(login, password, email)
    user.signin_count += 1
    user_db_service.create_user(user)
    # Everything is ok, let's finalize the authentication 
    session["uid"] = user.uid
    session["auth"] = True
    # Redirects to user page
    return jsonify(redirect_uri = url_for("user")) 
Example #6
0
def convert_to_text():
    LoggerUtil.getLogger(__name__)
    logging.info("received request for conversion")
    jsonRequestData = request.get_json(force=True)
    reqData = json.dumps(jsonRequestData)
    logging.debug("getting JSON request data")

    converterRequestData = jsonpickle.decode(reqData)

    outputData = ConverterData()
    for fileObj in converterRequestData["files"]:
        fileOutputObj = FileObject()
        fileOutputObj.extn = "txt"
        fileOutputObj.id = fileObj["id"]
        logging.debug("decoding base64 file data")

        decodedData = base64.b64decode(fileObj["data"])

        extnConverter = ConverterFactory.getInstance(fileObj["extn"])
        if extnConverter == None:
            logging.error("unsupported extension %s", fileObj["extn"])
            fileOutputObj.error = "Extension not supported"
        else:
            logging.debug("writing file to disk")
            fileName = FileObject.writeFileToDisk(fileObj["id"],
                                                  fileObj["extn"], decodedData)
            logging.debug("converting file to txt")
            textData = extnConverter.convert(fileName)
            fileOutputObj.data = base64.b64encode(bytes(
                textData, "utf-8")).decode('ascii')
        outputData.files.append(fileOutputObj)
    logging.info("returning response")
    text = jsonpickle.encode(outputData, unpicklable=False)
    logging.info(text)
    return jsonpickle.encode(outputData, unpicklable=False)
Example #7
0
def find():
    try:
        items, totalCount = user_service.find_filtered(request.oauth.user, request.get_json())
        response = [n.to_json() for n in items]
        return jsonify({'response': response, 'totalCount': totalCount})
    except ServiceError:
        raise BadRequest('A service error occurred')
Example #8
0
def query():
    payload = request.get_json(silent=True)
    if payload.get('query') is None:
        return 'Not good'
    query = payload['query']
    data = schema.execute(query)
    return json.dumps({'data': data.data, 'error': data.errors})
Example #9
0
def index():
    try:
        data = request.get_json()
        df = pd.read_csv("./%s.csv" % (data['token']))
        df = df[df['State/UnionTerritory'] == data["State"]]
        df["Confirmed"] = df["Confirmed"].diff()
        df = df.dropna()
        X = df[["Date", "Confirmed"]].values
        clf = algorithms[int(data["Algorithm"])]
        X = X[:, 1].reshape(X.shape[0], 1)
        if int(data["Algorithm"]) == 0:
            Y = clf.fit_predict(X)
        else:
            Y = clf.fit(X).predict(X)
        df["Anomaly"] = Y
        a = df[df["Anomaly"] == -1]
        fig = go.Figure()
        fig.add_trace(
            go.Scatter(x=df["Date"], y=df["Confirmed"], name='Confirmed'))
        fig.add_trace(
            go.Scatter(x=a["Date"],
                       y=a["Confirmed"],
                       mode='markers',
                       name='Anomaly'))
        fig.update_layout(
            showlegend=True,
            title='Detected anomalies(Algorithm:%s, State:%s)' %
            (str(algorithms[int(
                data["Algorithm"])]).split("(")[0], data['State']))
        fig.write_html("./templates/%s.html" % (data['token']))
        return render_template("%s.html" % (data['token']))
    except KeyError:
        return "Algorithm Not Specified"
Example #10
0
def add_id_card():
    data = request.get_json()
    link = data['link']
    session_user = tokenAuth.current_user()
    session_user.id_card = link
    db.session.commit()
    return make_response({"msg":"added id card link", link:link},200)
 def put(self):
     request_data = request.get_json(force=True)
     order_id = int(request_data.get('order_id'))
     order_obj = Order.objects.get(sales_order_id=order_id)
     order_obj.status = str(request_data.get('status'))
     order_obj.save()
     return "Status successfully updated"
Example #12
0
 def post(self):
     data = request.get_json()
     chem_composition = ChemicalComposition(data['commodity_id'],
                                            data['element_id'],
                                            data['percentage'])
     chem_composition.save_to_db()
     return chem_composition.json(), 200
def cleanup_uploads():
    """ Deletes uploaded images (input image and extra input images, if any),
    for each of the given keys in the data to process or list of filenames to process """
    data = request.get_json()['data']

    for file_name in data:
        # Delete the file from uploads/images
        file_path = os.path.join(app.config['IMAGES_DIR'], file_name)

        try:
            os.remove(file_path)
        except OSError as err:
            print('>>> [/cleanup/uploads] Error deleting file:', file_name)
            print('>>>', err)

        # Delete associated extra inputs from uploads/images/extra_inputs
        extra_inputs = [
            file for file in os.listdir(app.config['EXTRA_IMAGES_DIR'])
            if file.startswith(file_name.split('.')[0] + '_')
        ]

        for extra in extra_inputs:
            extra_path = os.path.join(app.config['EXTRA_IMAGES_DIR'], extra)

            try:
                os.remove(extra_path)
            except OSError as err:
                print('>>> [/cleanup/uploads] Error deleting file:', extra)
                print('>>>', err)

    return make_response(jsonify('Server: Uploaded files have been deleted'),
                         200)
def cleanup_tempdata():
    """ Deletes the resulting images (processed images and pickles)
    for each of the given list of processed files """
    filenames = request.get_json()['filenames']

    for filename in filenames:
        # Delete the processed file
        processed_path = os.path.join(app.config['TEMP_DATA'], filename)
        try:
            if os.path.exists(processed_path):
                os.remove(processed_path)
            else:
                print('>>> [/cleanup/tempdata] Requested file does not exist:',
                      filename)
        except OSError as err:
            print('>>> [/cleanup/tempdata] Error deleting file:', filename)
            print('>>>', err)

        # Delete the pickled channels
        unprocessed_filename = filename.rsplit('_', 1)[0]
        for channel in 'rgba':
            pickle_name = unprocessed_filename + '_' + channel + '.pickle'
            pickle_path = os.path.join(app.config['TEMP_DATA'], pickle_name)
            try:
                if os.path.exists(pickle_path):
                    os.remove(pickle_path)
            #    else:
            #        print('>>> [/cleanup/tempdata] Pickle does not exist:', pickle_name)
            except OSError as err:
                print('>>> [/cleanup/tempdata] Error deleting pickle:',
                      pickle_name)
                print('>>>', err)

    return make_response(jsonify('Server: Result files have been deleted'),
                         200)
def reviews_API(place_id=None, reviews_id=None):
    """ Get all reviews based on place ID """
    if place_id is None:
        abort(404)
    the_place = storage.get(Place, place_id)
    if the_place is None:
        abort(404)
    if request.method == "GET":
        review_list = the_place.reviews
        review_list = [review.to_dict() for review in review_list]
        return jsonify(review_list)
    if request.method == "POST":
        form = request.get_json()

        if form is None:
            return "Not a JSON", 400

        user_id = form.get('user_id')

        if user_id is None:
            return "Missing user_id", 400

        if storage.get(User, user_id) is None:
            abort(404)

        if form.get('text') is None:
            return "Missing text", 400

        new_review = Review(**form)
        setattr(new_review, 'place_id', place_id)
        new_review.save()

        return new_review.to_dict(), 201
Example #16
0
        def control(device):
            """Change or check the status of one of the
            machine/interface's controls:
                -caster's pump,
                -caster's motor (using two relays),
                -compressed air supply,
                -cooling water supply,
                -solenoid valves.

            GET checks the device's state,
            DELETE turns the device off, PUT turns it on
            POST turns on (state=True), off (state=False)
            """
            # find a suitable interface method, otherwise it's not implemented
            # handle_request will reply 501
            method_name = '{}_control'.format(device)
            request_data = request.get_json() or {}
            device_state = request_data.get('state')
            try:
                routine = getattr(self, method_name)
            except AttributeError:
                raise NotImplementedError
            # we're sure that we have a method
            if request.method == POST and device_state is not None:
                routine(bool(device_state))
            elif request.method == PUT:
                routine(ON)
            elif request.method == DELETE:
                routine(OFF)
            # always return the current state of the controlled device
            return dict(active=self.status.get(device))
Example #17
0
def Places_API(city_id=None):
    """ Get all cities based on State ID """
    if city_id is None:
        abort(404)
    the_city = storage.get(City, city_id)
    if the_city is None:
        abort(404)
    if request.method == "GET":
        place_list = the_city.places
        place_list = [place.to_dict() for place in place_list]
        return jsonify(place_list)
    if request.method == "POST":
        form = request.get_json()

        if form is None:
            return "Not a JSON", 400
        if form.get('user_id') is None:
            return 'Missing user_id', 400
        the_user = storage.get(User, form.get('user_id'))
        if the_user is None:
            abort(404)
        if form.get('name') is None:
            return "Missing name", 400

        new_place = Place(**form)
        setattr(new_place, 'city_id', city_id)
        new_place.save()

        return new_place.to_dict(), 201
Example #18
0
def simulate():
    simulator = Simulator()
    req_data = request.get_json()
    data = {'price':[req_data['price']],
        'bedrooms':[req_data['bedrooms']],
        'bath':[req_data['bath']],
        'size_sqft':[req_data['size_sqft']],
        'professionally_managed':[req_data['professionally_managed']],
        'no_pet_allowed':[req_data['no_pet_allowed']],
        'suit_laundry':[req_data['suit_laundry']],
        'park_stall':[req_data['park_stall']], 
        'available_now':[req_data['available_now']], 
        'amenities':[req_data['amenities']], 
        'brand_new':[req_data['brand_new']],
        'loc_vancouver':[req_data['loc_vancouver']], 
        'loc_burnaby':[req_data['loc_burnaby']], 
        'loc_richmond':[req_data['loc_richmond']], 
        'loc_surrey':[req_data['loc_surrey']], 
        'loc_newwest':[req_data['loc_newwest']], 
        'loc_abbotsford':[req_data['loc_abbotsford']], 
        'no_basement':[req_data['no_basement']]
        }
    
    # Create DataFrame
    record = pd.DataFrame(data)
    
    record = simulator.simulate(record)
    
    return record.to_json(orient='index')
Example #19
0
def insertStudentDetails():
    #Save the data to database
    student = request.get_json()
    print(student)
    print("Saving the Data to DataBase")
    result = s_util.save_Details_To_DB(student)
    return result
Example #20
0
def compra():
    json_data = request.get_json()
    if not json_data:
        return {"message": "No data provided"}, 400
    # Validate and deserialize input
    try:
        precioIdQuantityList = json_data['precioIdQuantitySelected']
        asientosId = json_data['asientoIdSelected']
        funcionId = json_data['funcionId']
        email = json_data['email']
        nombre = json_data['nombre']
        cont = 0
        ticketIdList = []
        for e in precioIdQuantityList:
            for x in range(e['quantity']):
                asientoId = asientosId[cont]
                ticketId = ticketService.create_ticket(asientoId,
                                                       e['precioId'], email,
                                                       nombre)
                ticketIdList.append(ticketId)
                cont += 1
        compra = compraService.compra(funcionId, ticketIdList, email, nombre)
        sendmail(compraService.get_compra(compra))
    except ValueError as e:
        print(e)
        return Response(mimetype="application/json",
                        status=HTTPStatus.INTERNAL_SERVER_ERROR,
                        response=json.dumps({"message": str(e)}))

    return Response('{"data": "JSON string example"}',
                    headers=dict({"HeaderExample": "HeaderContent"}),
                    mimetype="application/json")
def check_signature(callback_uri):
    # Extracts data from the posted request (from form of from json data according to the method used by the client)
    container = request.get_json(False, True, False) if request.mimetype == "application/json" else request.form
    bitid_uri = container["uri"]
    signature = container["signature"]
    address   = container["address"]
    # Checks the address
    if not bitid.address_valid(address, USE_TESTNET):
        return (False, None, address, "Address is invalid or not legal")
    # Checks the bitid uri
    if not bitid.uri_valid(bitid_uri, callback_uri):
        return (False, None, address, "BitID URI is invalid or not legal")
    # Checks the signature
    if not bitid.signature_valid(address, signature, bitid_uri, callback_uri, USE_TESTNET):
        return (False, None, address, "Signature is incorrect")
    
    # Note that the previous 3 steps could also be done in 1 step with following code:
    # if not bitid.challenge_valid(address, signature, bitid_uri, callback_uri, USE_TESTNET):
    #    return (False, "Sorry but something does not match")
    
    # Checks the nonce
    nid = bitid.extract_nonce(bitid_uri)
    # Tries to retrieve the nonce from db
    nonce = nonce_db_service.get_nonce_by_nid(nid)
    if nonce is None:
        return (False, None, address, "NONCE is illegal")
    elif nonce.has_expired():
        nonce_db_service.delete_nonce(nonce)
        return (False, None, address, "NONCE has expired")
    # Everything is  ok
    return (True, nonce, address, "")
def basic_auth():
    '''
    Checks basic authentication by login/password
    '''
    # Extracts data from the posted request
    container = request.get_json(False, True, False) if request.mimetype == "application/json" else request.form
    login = container["login"]
    password = container["password"]
    # Checks parameters are filled
    if (not login) or (not password): return jsonify(message = "Login, password and email are mandatory"), 400
    # Checks if user with given login exists in db
    user = user_db_service.get_user_by_login(login)
    if user is None: return jsonify(message = "Wrong login and password combination."), 400
    # Checks user password
    if not user.check_password(password): return jsonify(message = "Wrong login and password combination."), 400
    # Registers user id in session
    session["uid"] = user.uid
    # Checks if 2fa is activated
    if user.tfa_activited():
        # 2FA activated - Redirects to tfa_challenge page
        return jsonify(redirect_uri = url_for("tfa_challenge"))
    else:
        # Basic auth only
        # Let's increase the sign_in counter in user object (for demo purpose only)
        user.signin_count += 1
        user_db_service.update_user(user)
        # Everything is ok, let's finalize the authentication 
        session["auth"] = True
        # Redirects to user page
        return jsonify(redirect_uri = url_for("user"))
Example #23
0
def add_order(data, id):
    userID = data["id"]
    body = request.get_json()
    menus = body['menus']
    if not menus:
        return {'success': False, 'message': 'ไม่พบเมนู'}, 400
    have_order = Order.query.filter(
        func.DATE(Order.created_at) == date.today(), Order.shop_id == id,
        Order.customer_id == userID,
        or_(Order.status == 'ordering', Order.status == 'waiting')).count()
    if not have_order:
        new_order = Order(
            customer_id=userID,
            shop_id=id,
            note=body["note"],
            menus=[
                OrderMenu(menu_id=menu['id'],
                          extra=menu['is_extra'],
                          total=menu['total']) for menu in menus
            ],
            queue='A%02d' % Order.query.filter(
                func.DATE(Order.created_at) == date.today()).count())
        db.session.add(new_order)
        db.session.commit()
        return {
            'success': True,
            'order': new_order.getData(),
        }, 201
    return {'success': False, 'message': 'คุณมีออเดอร์ของร้านนี้อยู่แล้ว'}, 400
def check_signature(callback_uri):
    # Extracts data from the posted request (from form of from json data according to the method used by the client)
    container = request.get_json(
        False, True,
        False) if request.mimetype == "application/json" else request.form
    bitid_uri = container["uri"]
    signature = container["signature"]
    address = container["address"]
    # Checks the address
    if not bitid.address_valid(address, USE_TESTNET):
        return (False, None, address, "Address is invalid or not legal")
    # Checks the bitid uri
    if not bitid.uri_valid(bitid_uri, callback_uri):
        return (False, None, address, "BitID URI is invalid or not legal")
    # Checks the signature
    if not bitid.signature_valid(address, signature, bitid_uri, callback_uri,
                                 USE_TESTNET):
        return (False, None, address, "Signature is incorrect")

    # Note that the previous 3 steps could also be done in 1 step with following code:
    # if not bitid.challenge_valid(address, signature, bitid_uri, callback_uri, USE_TESTNET):
    #    return (False, "Sorry but something does not match")

    # Checks the nonce
    nid = bitid.extract_nonce(bitid_uri)
    # Tries to retrieve the nonce from db
    nonce = nonce_db_service.get_nonce_by_nid(nid)
    if nonce is None:
        return (False, None, address, "NONCE is illegal")
    elif nonce.has_expired():
        nonce_db_service.delete_nonce(nonce)
        return (False, None, address, "NONCE has expired")
    # Everything is  ok
    return (True, nonce, address, "")
def signup():
    '''
    Callback for validation of signup
    '''
    # Extracts data from the posted request
    container = request.get_json(
        False, True,
        False) if request.mimetype == "application/json" else request.form
    login = container["login"]
    password = container["password"]
    email = container["email"]
    # Checks parameters are filled
    if (not login) or (not password) or (not email):
        return jsonify(
            message="Login, password and email must be filled."), 400
    # Checks if a user with given login already exists in db
    if not user_db_service.get_user_by_login(login) is None:
        return jsonify(message="This login is already used."), 400

    #
    # Here we should check that email is valid and not already registered in db.
    # Then we would send a email to this address with an hyperlink to allow the user to confirm her address.
    # For the sake of simplicity, let's forget all this stuff and let's validate the account
    #

    # Registers user in db
    user = User(login, password, email)
    user.signin_count += 1
    user_db_service.create_user(user)
    # Everything is ok, let's finalize the authentication
    session["uid"] = user.uid
    session["auth"] = True
    # Redirects to user page
    return jsonify(redirect_uri=url_for("user"))
def basic_auth():
    '''
    Checks basic authentication by login/password
    '''
    # Extracts data from the posted request
    container = request.get_json(
        False, True,
        False) if request.mimetype == "application/json" else request.form
    login = container["login"]
    password = container["password"]
    # Checks parameters are filled
    if (not login) or (not password):
        return jsonify(message="Login, password and email are mandatory"), 400
    # Checks if user with given login exists in db
    user = user_db_service.get_user_by_login(login)
    if user is None:
        return jsonify(message="Wrong login and password combination."), 400
    # Checks user password
    if not user.check_password(password):
        return jsonify(message="Wrong login and password combination."), 400
    # Registers user id in session
    session["uid"] = user.uid
    # Checks if 2fa is activated
    if user.tfa_activited():
        # 2FA activated - Redirects to tfa_challenge page
        return jsonify(redirect_uri=url_for("tfa_challenge"))
    else:
        # Basic auth only
        # Let's increase the sign_in counter in user object (for demo purpose only)
        user.signin_count += 1
        user_db_service.update_user(user)
        # Everything is ok, let's finalize the authentication
        session["auth"] = True
        # Redirects to user page
        return jsonify(redirect_uri=url_for("user"))
Example #27
0
def create_user():
  data = request.get_json()
  login_manager = LoginManager()

  if 'email' not in data:
      return jsonify({"message": 'Campo e-mail é obrigatório'}), 401
  
  regex = '^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,})$'
  match = re.match(regex, data['email'].lower())

  if match is None or not valida_sufixos_hosts_email(data['email']):
      return jsonify({"message": 'Campo e-mail inválido'}), 401

  user = {**data, 'email': data['email'],'password': login_manager.password_to_hash(data['password'])}
  
  try:
    user_exists = db.collection_users.find_one({'email': user['email']})
    there_is_user = user_exists if user_exists else {}

    if 'password' in there_is_user:
      return jsonify({'message': 'Usuário já cadastro'}), 401
    else:
      user_temp = user
      user_temp['_id'] = db.collection_users.insert_one(user).inserted_id

    user_temp['_id'] = str(user_temp['_id'])
    token = login_manager.generate_auth_token(user_temp, 600000).decode('ascii')
    template = render_template('bem-vindo.html', nome=user_temp['email'], token=token, api_url=API)
    mail = SendEmail()
    mail.send_verify_email(template, user_temp['email'])

    return jsonify({"message": 'Usuário cadastrado com sucesso'}), 201
  except Exception as e:
    return not_found(e)
Example #28
0
    def post():
        """
        유저 정보를 받아와 새로운 유저를 생성해 준다.
        """
        print("-------- signup.py --------\n")
        body = request.get_json()
        print('type(body): ', type(body))
        print('body:' , body)

        user = UserDto(**body)
        print(f'[ user Dto ] {user}')

        print('아이디: ', user.user_id)
        print('비밀번호: ', user.password)
        print('이름: ', user.name)
        print('성별: ', user.gender)
        print('나이: ', user.age)
        print('핸드폰 번호: ', user.phone)
        print('이메일: ', user.email)
        
        try:
            UserDao.register(user)
            return "worked.."
        except Exception as e:
            return e
Example #29
0
 def add_configs_byproject(self, project):
     """add config item by project api method."""
     if redis_slave.sismember(CONF_PROJECTS_KEY_FORMAT, project):
         if self._check_conf_permission(project, 'write'):
             data = request.get_json()
             if data.get('name') and data.get('value'):
                 if not self._check_conf_exists(project, data['name']):
                     try:
                         value = json.loads(data.get('value'))
                     except Exception:
                         value = data.get('value')
                     item = ConfItem(project, data.get('name'), value)
                     #---we are going to use rejson to wrap the use custmize config item value into JSON type
                     pipe = redis_master.pipeline()
                     pipe.jsonset(
                         CONF_KEY_FORMAT.format(p=project,
                                                k=data.get('name')), '.',
                         item)
                     pipe.sadd(CONF_PROJECT_KEYSET_FORMAT.format(p=project),
                               data.get('name'))
                     pipe.execute()
                     log.info("Successfully add config {c} for project {p} by {u}".format(c=data.get('name'), \
                                                                                 p=project, u=g.user.username))
                     return jsonify({'message': 'success'})
                 else:
                     return jsonify({'message': 'Key exists'}), 400
             else:
                 return jsonify({'message': 'Wrong parameter data'}), 400
         else:
             return jsonify({'message': 'doesn\'t have permission'}), 403
     else:
         return jsonify({'message': 'project does not exists'}), 400
def initialise():
    files = request.get_json()['files']
    images = files['image']
    videos = files['video']

    for image in images:
        # Initialise the data needed for each image
        file_path = os.path.join(app.config['IMAGES_DIR'], image)
        image_file = cv2.imread(file_path, cv2.IMREAD_UNCHANGED)
        image_name_components = image.split('.')

        if utils.is_grayscale(image_file):
            # Compute the padded image
            image_h, image_w = image_file.shape[:2]
            # padded_h, padded_w = 2 * image_h, 2 * image_w
            # padded_image = np.zeros((padded_h, padded_w), np.uint8)
            # padded_image[0:image_h, 0:image_w] = image_file

            # # Compute the FFT of the padded image
            # padded_image_FFT = np.fft.fftshift(np.fft.fft2(padded_image))

            # # Serialise the FFT of the padded image
            # pickle_name = image_name_components[0] + '_fft.pickle'
            # pickle_path = os.path.join(app.config['TEMP_DATA'], pickle_name)
            # with open(pickle_path, 'wb') as f:
            #     pickle.dump(padded_image_FFT, f)
        else:
            # Compute the R, G, B channels of the image
            image_channels = utils.get_channels(image_file)

            # Serialise the image channels
            channels_string = 'bgra'

            for i in range(len(image_channels)):
                pickle_name = image_name_components[0] + '_' + channels_string[i] + '.pickle'
                pickle_path = os.path.join(app.config['TEMP_DATA'], pickle_name)
                with open(pickle_path, 'wb') as f:
                    pickle.dump(image_channels[i], f)

            # # Compute the padded image
            # image_h, image_w, channels = image_file.shape
            # padded_h, padded_w = 2 * image_h, 2 * image_w
            # padded_image = np.zeros((padded_h, padded_w, channels), np.uint8)
            # padded_image[0:image_h, 0:image_w] = image_file

            # # Compute the R, G, B channels of the padded image
            # padded_image_channels = utils.get_channels(padded_image)

            # # Compute the FFT of the padded image channels
            # padded_image_FFTs = [np.fft.fftshift(np.fft.fft2(channel)) for channel in padded_image_channels]

            # # Serialise the FFTs of the padded image channels
            # for i in range(len(padded_image_FFTs)):
            #     pickle_name = image_name_components[0] + '_' + channels_string[i] + '_fft.pickle'
            #     pickle_path = os.path.join(app.config['TEMP_DATA'], pickle_name)
            #     with open(pickle_path, 'wb') as f:
            #         pickle.dump(padded_image_FFTs[i], f)

    return make_response(jsonify('Server: Initialisations process completed successfully'), 200)
Example #31
0
 def delete(self, id):
     data = request.get_json()
     chem_composition = ChemicalComposition.query.filter_by(
         commodity_id=id).filter_by(element_id=data['element_id']).first()
     if chem_composition:
         chem_composition.delete_from_db()
         return {"message": "data deleted "}
     return {"message": "data not found"}, 400
Example #32
0
def upadteTask(tsk):
    num = 1 
    todo = mongo.db.todo
    if not request.json:
        abort(404)
    content = request.get_json()
    todo.update({'userid':num,'taskid':tsk},{'$set':content})
    return "Successfully Updated"
Example #33
0
def delete(tsk):
    num = 1
    todo = mongo.db.todo
    if not request.json:
        abort(404)
    content = request.get_json()
    todo.delete_one({'userid':num,'taskid':tsk})
    return "Successfully Deleted"
Example #34
0
def set_alerts():
    """ Receive custom alerts

        Status codes:
            400 invalid input
            403 invalid server key
    """
    ssn = g.db

    # Input validation
    data = request.get_json()
    assert isinstance(data, dict), 'Invalid data: should be JSON object'
    assert 'server' in data, 'Data: "server" key is missing'
    assert 'alerts' in data, 'Data: "alerts" key is missing'

    # Input validation: alerts
    assert isinstance(data['alerts'], list), 'Data: "alerts" should be a list'
    assert all(
        isinstance(s, dict) and
        'message' in s and isinstance(s['message'], basestring) and
        ('service' not in s or isinstance(s['service'], basestring)) and
        set(s.keys()) <= {'title', 'message', 'service'}
        for s in data['alerts']
    ), 'Data: "alerts" should be a list of objects with keys "title", "message"?, "service"?'

    # Identify server
    server = _identify_server(ssn, data['server'])
    ssn.add(server)

    # Alerts
    services_cache = {}
    for a in data['alerts']:
        # Identify service (if any)
        service = None
        if 'service' in a:
            try:
                service = services_cache[a['service']]
            except KeyError:
                service = _identify_service(ssn, server, a['service'])
                services_cache[service.name] = service
                ssn.add(service)

        # Raise
        alert = models.Alert(
            server=server,
            service=service,
            ctime=datetime.utcnow(),
            channel='api',
            event='alert',
            message=unicode(a['message'])
        )
        ssn.add(alert)
        logger.debug(u'Alert reported for {server}:`{service}`: {message}'.format(server=server.name, service=service.name if service else '-', message=a['message']))

    # Save
    ssn.commit()

    return {'ok': 1}
Example #35
0
File: ws.py Project: sp4x/osnf
def change_state(node, st, key):
    rpc = request.get_json()
    st_instance = get_network().get_node(node).get_station(st)
    if key == 'switch':
        if rpc['switch'] == 'on':
            st_instance.turn_on()
        elif rpc['switch'] == 'off':
            st_instance.turn_off()
    return ('', 204)
Example #36
0
def mc_api_name():
    data = request.get_json()
    if data is None:
        return "Invalid request", 406
    if len(data) >= 100:
        return "Too many uuids", 406
    if not isinstance(data, list):
        return "Not a list", 406
    return json.dumps(retrieve_names(data))
Example #37
0
 def add_movie2list():
     data = request.get_json()
     temp = json.loads(str(data['listName']))
     conn = mysql.connect()
     cur = conn.cursor()
     cur.callproc('addListPost', (data['title'], temp['name'], 'Movies' , data['description'], data['movieTitle'] ))
     conn.commit()
     conn.close()
     
     return jsonify({})
Example #38
0
def pictograma():
    if request.method == "POST":
        ids = inserir_pictograma(request.get_json(force=True))
        return Response(response=json.dumps({'inseridos': ids}), status=200, mimetype="application/json")
    elif request.method == "GET":
        if len(request.args.getlist('topicos')) is 0:
            picto = buscar_pictogramas(None)
        else:
            lista = ast.literal_eval(str(request.args.getlist('topicos')))
            picto = buscar_pictogramas(lista)
        response = Response(response=get_list_as_json(picto), status=200, mimetype="application/json")
        return response
Example #39
0
def mc_api_uuid():
    data = request.get_json()
    if data is None:
        return "Invalid request: {}".format(request.data), 406
    if len(data) >= 100:
        return "Too many usernames", 406
    if not isinstance(data, list):
        return "Not a list", 406
    data = tuple(str(user) for user in data)
    try:
        return json.dumps(retrieve_uuids(data))
    except MojangError as e:
        return e.message, 500
Example #40
0
def update_node():
    '''
    Update the node text.
    '''
    node = request.get_json()
    node_id = node.get('id')
    node_text = node.get('text')

    structure = Structure.query.filter_by(id=node_id).first()
    structure.title = node_text
    db.session.commit()

    return jsonify(status_text=gettext("Hoorah! Section was updated."))
Example #41
0
def delete_node():
    '''
    Delete the node and associated section text.
    '''
    nodes = request.get_json().get('ids')
    for node_id in nodes:
        section = Section.query.filter_by(structure_id=node_id).first()
        db.session.delete(section)
        structure = Structure.query.filter_by(id=node_id).first()
        db.session.delete(structure)
        db.session.commit()

    return jsonify(status_text=gettext("Hoorah! Section was deleted."))
Example #42
0
def finaliza_jogo_e_mostra_metricas():
    json_dic = request.get_json(force=True)
    assert json_dic is not None
    assert metricas.json_valido(json_dic)
    metricas.salvar_jogo(json_dic)
    partidas = metricas.pegar_metricas_ultimas_partidas()
    return_json = {"partidas": []}
    for i, partida in enumerate(partidas):
        respostas_corretas = 0
        for resposta in partida["respostas"]:
            if resposta["acertou"]:
                respostas_corretas += 1
        return_json["partidas"].append({"x": partidas.count() - i, "y": respostas_corretas})

    return_json["topicos"] = metricas.pegar_metricas_ultimos_topicos()
    return Response(response=json_util.dumps(return_json))
 def update_workspace(workspace, storage=None):
     fields = request.get_json(silent=True) or {}
     for k in request.form.keys():
         fields[k] = request.form.get(k, type=str)
     if not 'code' in fields:
         file = request.files.get('code', None)
         if file:
             fields['code'] = file.read().decode("utf-8")
     if len(request.args) > 0:
         return bad_request('invalid update parameters')
     with workspaces.find_or_404(workspace) as w:
         if storage is None:
             w.update(**fields)
         else:
             s = w.storage[storage]
             with s as s:
                 s.update(**fields)
         return {'status': 200, 'message': 'updated' }
Example #44
0
def convert():
    kwargs = request.get_json(force=True)
    input_tar = kwargs["input"]
    archive_name = kwargs["options"].get("filename", "hepdata-converter-ws-data")
    output_format = kwargs["options"].get("output_format", "")

    output, os_handle = StringIO.StringIO(), None
    if output_format.lower() in SINGLEFILE_FORMATS or "table" in kwargs["options"]:
        os_handle, tmp_output = tempfile.mkstemp()
    else:
        tmp_output = tempfile.mkdtemp()

    tmp_dir = tempfile.mkdtemp()
    try:
        conversion_input = os.path.abspath(tmp_dir)
        conversion_output = os.path.abspath(tmp_output)

        with tarfile.open(mode="r:gz", fileobj=StringIO.StringIO(base64.decodestring(input_tar))) as tar:
            tar.extractall(path=conversion_input)

        # one file - treat it as one file input format
        walked = list(os.walk(tmp_dir))
        if len(walked) == 1 and len(walked[0][2]) == 1:
            path, dirs, files = walked[0]
            conversion_input = os.path.join(path, files[0])
        else:
            conversion_input = conversion_input + "/" + archive_name + "/"

        hepdata_converter.convert(conversion_input, conversion_output, kwargs.get("options", {}))

        if not os.path.isdir(conversion_output):
            archive_name = archive_name + "." + output_format

        with tarfile.open(mode="w:gz", fileobj=output) as tar:
            tar.add(conversion_output, arcname=archive_name)

    finally:
        if os_handle:
            os.fdopen(os_handle).close()
        shutil.rmtree(tmp_dir, ignore_errors=True)
        shutil.rmtree(tmp_output, ignore_errors=True)

    return Response(output.getvalue(), mimetype="application/x-gzip")
Example #45
0
def ping():
    """ Test connection and server credentials

        Status codes:
            400 invalid input
            403 invalid server key
    """
    ssn = g.db

    # Input validation
    data = request.get_json()
    assert isinstance(data, dict), 'Invalid data: should be JSON object'
    assert 'server' in data, 'Data: "server" key is missing'

    # Identify server (will raise exception if not fine)
    server = _identify_server(ssn, data['server'])
    ssn.add(server)
    ssn.commit()

    return {'pong': 1}
Example #46
0
def add_node(project_id):
    '''
    Add a new node to the tree and pass the created data back to the caller so it can add
    it to the tree in the browser.
    '''
    nodes = request.get_json()
    parent_id = nodes.get('parent')
    project = Project.query.filter(id==project_id).first()
    parent = Structure.query.filter(id==parent_id).first()
    # Get the highest display order for this project so we can assign the new node to last place.
    displayorder = db.session.query(db.func.max(Structure.displayorder)).filter(Project.id==project_id).scalar() + 1

    structure = create_node(project=project, parent=parent, displayorder=displayorder)

    db.session.commit()

    return jsonify(id=structure.id,
                   text=structure.title,
                   displayorder=structure.displayorder,
                   status_text=gettext("Hoorah! Section was added."))
def negotiation():
    errors = []  
   
    if session.get('nid', None) is None:
        # Generates a new negotiation if needed
        is_new_nego = True
        session['nid'] = str(uuid.uuid4())
        nego = Negotiation(session['nid'], ROLE_BUYER, TESTNET)
        nego_db_service.create_nego(session['nid'], nego)
    else:
        # Gets the negotiation
        is_new_nego = False
        nego = nego_db_service.get_nego_by_id(session['nid'])
            
    '''
    Prepares the BargainingMessage to be sent (if there's one)
    '''
    if is_new_nego:
        # CASE 1: We start a new negotiation
        # Builds a REQUEST message
        new_msg, errors = negotiator.process(nego)
    elif request.method == 'POST':
        # Case 2: We continue an existing negotiation
        # Gets data sent by the user
        container = request.get_json(False, True, False) if request.mimetype == "application/json" else request.form 
        amount    = int(Decimal(container['amount']) * SATOSHIS_TO_BITCOIN)
        memo      = container['memo']
        # Builds a new message (PROPOSAL or CANCEL) 
        # For this demo, we never send fees (test network)
        new_msg, errors = negotiator.process(nego, memo, amount)
    else:
        new_msg = None
        errors.append('Invalid HTTP method')              
    
    '''
    Sends the BargainingMessage
    '''
    if len(errors) == 0:
        # Appends the new message to the chain
        nego.append(new_msg)
        nego_db_service.update_nego(session['nid'], nego)
        # Sends the message
        next_msg_types = nego.get_next_msg_types()
        uri = SELLER_URI if (new_msg.msg_type == TYPE_BARGAIN_REQUEST) else nego.get_bargain_uri_for_role(ROLE_BUYER)
        response = send_msg(new_msg, uri, next_msg_types)
                
        '''
        Processes the response
        '''
        try:
            if response.code == 200:
                if check_req_format(response): 
                    pbuff = response.read()
                    msg = BargainingMessage.deserialize(pbuff)
                    if not nego.already_received(msg):     
                        if msg.check_msg_fmt(NETWORK): 
                            nego.check_consistency(msg)    
                        nego.append(msg)
                        nego_db_service.update_nego(session['nid'], nego)
            else:
                errors.append('Remote node returned an error')
        except:
            errors.append('A problem occurred while processing the message sent by the remote node')
        
    '''
    Prepares rendering 
    '''
    params_tpl = {}
    params_tpl['errors']     = '' if len(errors) == 0 else '\n'.join(errors)
    params_tpl['wallet_blc'] = get_balance([negotiator.addr1])
    params_tpl['chain']      = nego._msgchain
    params_tpl['completed']  = True if nego.status in {NEGO_STATUS_CANCELLED, NEGO_STATUS_COMPLETED} else False
    return render_template('negotiation.html', params_tpl=params_tpl)
Example #48
0
def set_service_status():
    """ Receive single service status

        Status codes:
            400 invalid input
            403 invalid server key
    """
    ssn = g.db

    # Input validation
    data = request.get_json()
    assert isinstance(data, dict), 'Invalid data: should be JSON object'
    assert 'server' in data, 'Data: "server" key is missing'
    assert 'period' in data, 'Data: "period" key is missing'
    assert 'services' in data, 'Data: "services" key is missing'

    # Input validation: period
    try:
        data['period'] = int(data['period'])
    except ValueError:
        raise AssertionError('Data: "period" should be an integer')

    # Input validation: services
    assert isinstance(data['services'], list), 'Data: "services" should be a list'
    assert all(
        isinstance(s, dict) and
        'name' in s and isinstance(s['name'], basestring) and
        'state' in s and isinstance(s['state'], basestring) and
        ('info' not in s or isinstance(s['info'], basestring))
        for s in data['services']
    ), 'Data: "services" should be a list of objects with keys "name", "state", "info"?, "period"?'

    # Identify server
    server = _identify_server(ssn, data['server'])
    ssn.add(server)

    # Services
    services_cache = {}
    for s in data['services']:
        # Identify service
        try:
            service = services_cache[s['name']]
        except KeyError:
            service = _identify_service(ssn, server, s['name'])
            services_cache[service.name] = service
        ssn.add(service)

        # Update period
        try:
            service_period = int(s['period'])
        except (KeyError, ValueError):
            service_period = data['period']

        service.period = service_period

        # State
        if not models.state_t.is_valid(s['state']):
            s['info'] += u' (sent unsupported state: "{}")'.format(s['state'])
            s['state'] = 'UNK'
        state = models.ServiceState(
            service=service,
            rtime=datetime.utcnow(),
            state=s['state'],
            info=s['info']
        )
        ssn.add(state)
        logger.debug(u'Service {server}:`{name}` state update: {state}: {info}'.format(server=server.name, **s))

    # Save
    ssn.commit()

    return {'ok': 1}
Example #49
0
def callback():
    '''
    This function validates the response sent by the client about the challenge
    This is the route called by the bitcoin wallet when the challenge has been signed
    '''
    # Retrieves the callback uri
    callback_uri = get_callback_uri()
    # Extracts data from the posted request (from form of from json data according to the method used by the client)
    container = request.get_json(False, True, False) if request.mimetype == "application/json" else request.form
    bitid_uri = container["uri"]
    signature = container["signature"]
    address   = container["address"]
        
    #
    # Let's start by a bunch of validations
    #
    
    # Checks the address
    if not bitid.address_valid(address, USE_TESTNET):
        return jsonify(message = "Address is invalid or not legal"), 401
    # Checks the bitid uri
    if not bitid.uri_valid(bitid_uri, callback_uri):
        return jsonify(message = "BitID URI is invalid or not legal"), 401
    # Checks the signature
    if not bitid.signature_valid(address, signature, bitid_uri, callback_uri, USE_TESTNET):
        return jsonify(message = "Signature is incorrect"), 401
    
    # Note that the previous 3 steps could also be done in 1 step with following code:
    # if not bitid.challenge_valid(address, signature, bitid_uri, callback_uri, USE_TESTNET):
    #    return jsonify(message = "Sorry but something does not match"), 401
    
    # Checks the nonce
    nid = bitid.extract_nonce(bitid_uri)
    # Tries to retrieve the nonce from db
    nonce = nonce_db_service.get_nonce_by_nid(nid)
    if nonce is None:
        return jsonify(message = "NONCE is illegal"), 401
    elif nonce.has_expired():
        nonce_db_service.delete_nonce(nonce)
        return jsonify(message = "NONCE has expired"), 401
        
    #
    # So good so far, everything seems ok
    # It's time to check if we have a sign out or a sign in
    #
    
    # Checks if a user with the given address has already been registered in db (sign in)
    user = user_db_service.get_user_by_address(address)
    # If we have a sign out
    if user is None:
        # Here, we have an important check to do in order to avoid flooding of the users db
        # Let's check for a proof of goodwill (@see pybitid_demo.services.fake_tx_db_service) 
        if not tx_db_service.check_proof_of_goodwill(address):
            return jsonify(message = "Address is invalid or not legal"), 401
        else:
            # Creates a new user and stores it in db
            user = User(address)
            if not user_db_service.create_user(user):
                return jsonify(message = "Ooops ! Something went wrong but we work on it"), 500
    
    # To finalize the authentication, let's set the user id in the nonce and update it in db
    nonce.uid = user.uid
    if not nonce_db_service.update_nonce(nonce):
        return jsonify(message = "Ooops ! Something went wrong but we work on it"), 500
    # Everything was ok: user is authenticated
    return jsonify(address = address, nonce = nonce.sid)