def test_get_item_pictures__success(self):
        item = Item.create(**TEST_ITEM)
        Picture.create(item=item, **TEST_PICTURE)
        Picture.create(item=item, **TEST_PICTURE2)
        resp = self.app.get(
            '/items/{item_uuid}/pictures/'.format(item_uuid=item.uuid))
        assert resp.status_code == client.OK

        test_utils.assert_valid_response(
            resp.data, EXPECTED_RESULTS['get_item_pictures__success'])
def search(parameters):
    # Préparation des paramètres de la requête
    payload = {
        'client':
        "v8.a.3",
        'price_range':
        "%s,%s" % (parameters['price'][0], parameters['price'][1]),  # Loyer
        'area_range':
        "%s,%s" %
        (parameters['surface'][0], parameters['surface'][1]),  # Surface
        'rooms_range':
        "%s,%s" % (parameters['rooms'][0], parameters['rooms'][1]),  # Pièces
        'bedrooms_range':
        "%s,%s" %
        (parameters['bedrooms'][0], parameters['bedrooms'][1]),  # Chambres
        'localities':
        ','.join(key for key in search_city_code(parameters['cities']))
    }

    # Insertion des paramètres propres à LeBonCoin
    payload.update(parameters['logic-immo'])

    request = requests.post(
        "http://lisemobile.logic-immo.com/li.search_ads.php",
        params=payload,
        headers=header)
    data = request.json()

    for ad in data['items']:

        annonce, created = Annonce.get_or_create(
            id='logic-immo-' + ad['identifiers']['main'],
            site="Logic Immo",
            created=datetime.fromtimestamp(ad['info']['firstOnlineDate']),
            title="%s %s pièces" %
            (ad['info']['propertyType']['name'], ad['properties']['rooms']),
            description=ad['info']['text'],
            telephone=ad['contact'].get('phone'),
            price=ad['pricing']['amount'],
            surface=ad['properties']['area'],
            rooms=ad['properties']['rooms'],
            bedrooms=ad['properties'].get('bedrooms'),
            city=ad['location']['city']['name'],
            link=ad['info']['link'])

        if created:
            pictures = [
                picture.replace("[WIDTH]",
                                "1440").replace("[HEIGHT]", "956").replace(
                                    "[SCALE]", "3.5")
                for picture in ad.get('pictures')
            ]
            for picture in pictures:
                Picture.create(url=picture, annonce=annonce)
            annonce.save()
def picture_creator(num_picture, index, item):
    ALLOWED_EXTENSION = ['jpg', 'jpeg', 'png', 'gif']
    pictures_path = get_random_pictures(num_picture)
    picture_id = fake.uuid4()
    extension = random.choice(ALLOWED_EXTENSION)
    Picture.create(uuid=picture_id, extension=extension, item=item)
    image_folder = utils.get_image_folder()
    if not os.path.exists(image_folder):
        os.makedirs(image_folder)
    shutil.copy2(pictures_path[index],
                 '/{}/{}.{}'.format(image_folder, picture_id, extension))
 def create_photos(self, photo_count = default_photo_count):
     count = 1;
     for photo in self.flickr.walk(text='butteryfly', content_type='1', media='photos', per_page=photo_count):
         farm_id = photo.get('farm')
         server_id = photo.get('server')
         _id = photo.get('id')
         secret = photo.get('secret')
         url = 'http://farm' + farm_id + '.staticflickr.com/' + server_id + '/' + _id + '_' + secret + '.jpg'
         print url
         Picture.create(url)
         count +=1
         if count > photo_count:
             break  
     return self
Exemple #5
0
    def create_item_picture(self, item=None, title="Picture title"):
        if not item:
            item = self.create_item()

        # TODO: Add option for different images and extensions?
        extension = 'jpg'

        picture = Picture.create(uuid=uuid.uuid4(),
                                 title=title,
                                 extension=extension,
                                 item=item)

        config = app.config
        with open(os.path.join('.', 'tests', 'images', 'test_image.jpg'),
                  'rb') as image:
            image = FileStorage(image)

            save_path = os.path.join('.', config['UPLOADS_FOLDER'], 'items',
                                     str(item.uuid))
            new_filename = secure_filename('.'.join(
                [str(picture.uuid), extension]))

            os.makedirs(save_path, exist_ok=True)

            image.save(os.path.join(save_path, new_filename))
        return picture
 def setup_method(self):
     super(TestItemSchema, self).setup_method()
     self.data = {
         'name': 'Test item',
         'price': 10.25,
         'description': 'Test item description',
         'availability': 73,
         'category': 'scarpe',
     }
     self.item1 = Item.create(
         uuid='25da606b-dbd3-45e1-bb23-ff1f84a5622a',
         name='Item 1',
         description='Item 1 description',
         price=5.24,
         availability=5,
         category='scarpe',
     )
     self.item2 = Item.create(
         uuid='08bd8de0-a4ac-459d-956f-cf6d8b8a7507',
         name='Item 2',
         description='Item 2 description',
         price=8,
         availability=10,
         category='accessori',
     )
     self.picture = Picture.create(
         item=self.item1,
         uuid='08bd8de0-a4ac-459d-956f-cf6d8b8a7507',
         extension='png',
     )
Exemple #7
0
    def post(self, item_id):
        try:
            item = Item.get(Item.uuid == item_id)
        except Item.DoesNotExist:
            return None, NOT_FOUND

        parser = reqparse.RequestParser()
        parser.add_argument('title', type=non_empty_string, required=True)
        parser.add_argument('file', type=FileStorage, location='files', required=True)

        args = parser.parse_args(strict=True)

        image = args['file']
        title = args['title']

        extension = image.filename.rsplit('.', 1)[1].lower()
        config = current_app.config
        if '.' in image.filename and extension not in config['ALLOWED_EXTENSIONS']:
            abort(400, message="Extension not supported.")

        picture = Picture.create(
            uuid=uuid.uuid4(),
            title=title,
            extension=extension,
            item=item
        )

        save_path = os.path.join('.', config['UPLOADS_FOLDER'], 'items', str(item_id))
        new_filename = secure_filename('.'.join([str(picture.uuid), extension]))

        os.makedirs(save_path, exist_ok=True)

        image.save(os.path.join(save_path, new_filename))

        return picture.json(), CREATED
    def test_delete_item__pictures_cascade(self):
        """
        delete a selected item and all its binded pictures
        """
        test_utils.setup_images()
        item = Item.create(**TEST_ITEM)
        item2 = Item.create(**TEST_ITEM2)
        picture = Picture.create(item=item, **TEST_PICTURE)
        picture2 = Picture.create(item=item, **TEST_PICTURE2)
        picture3 = Picture.create(item=item2, **TEST_PICTURE3)
        imgfolder = utils.get_image_folder()
        path_pic = os.path.join(imgfolder, "{uuid}.{extension}".format(
            uuid=picture.uuid,
            extension=picture.extension))
        path_pic2 = os.path.join(imgfolder, "{uuid}.{extension}".format(
            uuid=picture2.uuid,
            extension=picture2.extension))
        path_pic3 = os.path.join(imgfolder, "{uuid}.{extension}".format(
            uuid=picture3.uuid,
            extension=picture3.extension))
        open(path_pic, "wb")
        open(path_pic2, "wb")
        open(path_pic3, "wb")

        resp = self.app.delete('/items/{item_uuid}'.format(
            item_uuid=item.uuid))

        assert resp.status_code == client.NO_CONTENT
        assert Picture.select().count() == 1
        assert Item.select().count() == 1
        item2 = Item.get()
        pic = Picture.get()
        assert pic == picture3
        assert os.path.isfile("{path}/{picture_uuid}.{extension}".format(
            path=utils.get_image_folder(),
            picture_uuid=picture3.uuid,
            extension=picture3.extension))
        assert not os.path.isfile("{path}/{picture_uuid}.{extension}".format(
            path=utils.get_image_folder(),
            picture_uuid=picture.uuid,
            extension=picture.extension))
        assert not os.path.isfile("{path}/{picture_uuid}.{extension}".format(
            path=utils.get_image_folder(),
            picture_uuid=picture2.uuid,
            extension=picture2.extension))
        test_utils.clean_images()
    def test_delete_picture__success(self):
        test_utils.setup_images()
        item = Item.create(**TEST_ITEM)
        picture = Picture.create(item=item, **TEST_PICTURE)
        picture2 = Picture.create(item=item, **TEST_PICTURE2)
        open(
            "{path}/{picture_uuid}.{extension}".format(
                path=utils.get_image_folder(),
                picture_uuid=picture.uuid,
                extension=picture.extension), "wb")
        open(
            "{path}/{picture_uuid}.{extension}".format(
                path=utils.get_image_folder(),
                picture_uuid=WRONG_UUID,
                extension='jpg'), "wb")
        open(
            "{path}/{picture_uuid}.{extension}".format(
                path=utils.get_image_folder(),
                picture_uuid=picture2.uuid,
                extension=picture2.extension), "wb")

        resp = self.app.delete(
            '/pictures/{picture_uuid}'.format(picture_uuid=picture.uuid))

        assert resp.status_code == client.NO_CONTENT
        assert Picture.select().count() == 1
        assert Item.select().count() == 1
        item2 = Item.get()
        assert str(item2.uuid) == TEST_ITEM['uuid']
        assert item2.name == TEST_ITEM['name']
        assert float(item2.price) == TEST_ITEM['price']
        assert item2.description == TEST_ITEM['description']
        assert os.path.isfile("{path}/{picture_uuid}.{extension}".format(
            path=utils.get_image_folder(),
            picture_uuid=WRONG_UUID,
            extension='jpg'))
        assert not os.path.isfile("{path}/{picture_uuid}.{extension}".format(
            path=utils.get_image_folder(),
            picture_uuid=picture.uuid,
            extension=picture.extension))
        assert os.path.isfile("{path}/{picture_uuid}.{extension}".format(
            path=utils.get_image_folder(),
            picture_uuid=picture2.uuid,
            extension=picture2.extension))
        test_utils.clean_images()
    def test_delete_pictures__missing_file(self):
        item = Item.create(**TEST_ITEM)
        picture = Picture.create(item=item, **TEST_PICTURE)
        resp = self.app.delete(
            '/pictures/{picture_uuid}'.format(picture_uuid=picture.uuid))

        assert resp.status_code == client.NO_CONTENT
        assert not Picture.select().exists()
        assert Item.select().exists()
 def setup_method(self):
     super(TestPictureSchema, self).setup_method()
     self.item = Item.create(
         uuid='25da606b-dbd3-45e1-bb23-ff1f84a5622a',
         name='Item 1',
         description='Item 1 description',
         price=5.24,
         availability=5,
         category='scarpe',
     )
     self.picture = Picture.create(
         item=self.item,
         uuid='08bd8de0-a4ac-459d-956f-cf6d8b8a7507',
         extension='png',
     )
Exemple #12
0
    def __iter__(self):
        session = requests.Session()
        for thread in self.search():
            for post in chan.Thread(self.board, num=thread).posts:

                for pic in post.pictures:

                    if PictureModel.check_existance(pic.url):
                        continue

                    picture = PictureModel.create(
                        url=pic.url,
                        thread=thread,
                        caption=purify_message(post.message))

                    yield picture
    def test_get_picture__success(self):
        test_utils.setup_images()
        item = Item.create(**TEST_ITEM)
        picture = Picture.create(item=item, **TEST_PICTURE)

        open(
            "{path}/{picture_uuid}.jpg".format(path=utils.get_image_folder(),
                                               picture_uuid=picture.uuid),
            "wb")

        resp = self.app.get(
            '/pictures/{picture_uuid}'.format(picture_uuid=picture.uuid))
        assert resp.status_code == client.OK
        test_picture = TEST_PICTURE.copy()
        test_picture['item_uuid'] = item.uuid
        assert resp.data == b''
        assert resp.headers['Content-Type'] == 'image/jpeg'
        test_utils.clean_images()
Exemple #14
0
    def post(self, item_uuid):
        """Insert a new picture for the specified item"""
        if 'image' not in request.files:
            return {"message": "No image received"},\
                client.BAD_REQUEST

        try:
            item = Item.get(Item.uuid == item_uuid)
        except Item.DoesNotExist:
            return None, client.NOT_FOUND

        file = request.files['image']
        picture_uuid = uuid.uuid4()
        extension = os.path.splitext(file.filename)[1][1:]

        if extension not in ALLOWED_EXTENSION:
            return {"message": "File extension not allowed"},\
                client.BAD_REQUEST

        utils.save_image(file, picture_uuid, extension)

        return Picture.create(uuid=picture_uuid,
                              extension=extension,
                              item=item).json(), client.CREATED
Exemple #15
0
def search(parameters):
    # Préparation des paramètres de la requête
    payload = {
        'recherche[prix][min]': parameters['price'][0],  # Loyer min
        'recherche[prix][max]': parameters['price'][1],  # Loyer max
        'recherche[surface][min]': parameters['surface'][0],  # Surface min
        'recherche[surface][max]': parameters['surface'][1],  # Surface max
        'recherche[nb_pieces][min]': parameters['rooms'][0],  # Pièces min
        'recherche[nb_chambres][min]':
        parameters['bedrooms'][0],  # Chambres min
        'size': 200,
        'page': 1
    }

    # Insertion des paramètres propres à PAP
    payload.update(parameters['pap'])

    params = urlencode(payload)

    # Ajout des villes
    for city in parameters['cities']:
        params += "&recherche[geo][ids][]=%s" % place_search(city[1])

    request = requests.get("https://ws.pap.fr/immobilier/annonces",
                           params=unquote(params),
                           headers=header)
    data = request.json()

    if 'annonce' in data['_embedded']:
        for ad in data['_embedded']['annonce']:
            _request = requests.get(
                "https://ws.pap.fr/immobilier/annonces/%s" % ad['id'],
                headers=header)
            _data = _request.json()

            photos = list()
            if _data.get("nb_photos") > 0:
                for photo in _data["_embedded"]['photo']:
                    photos.append(photo['_links']['self']['href'])

            annonce, created = Annonce.get_or_create(
                id='pap-%s' % _data.get('id'),
                site="PAP",
                title="%s %s pièces" %
                (_data.get("typebien"), _data.get("nb_pieces")),
                description=str(_data.get("texte")),
                telephone=_data.get("telephones")[0].replace('.', '')
                if len(_data.get("telephones")) > 0 else None,
                created=datetime.fromtimestamp(_data.get("date_classement")),
                price=_data.get('prix'),
                surface=_data.get('surface'),
                rooms=_data.get('nb_pieces'),
                bedrooms=_data.get('nb_chambres_max'),
                city=_data["_embedded"]['place'][0]['title'],
                link=_data["_links"]['desktop']['href']
                # pictures=photos,
            )

            if created:
                for photo in photos:
                    Picture.create(url=photo, annonce=annonce)
                annonce.save()
Exemple #16
0
def picture_add(site, host, netloc, csrf, logged_in, user_id_logged_in):
    """
    Add picture post url
    """

    # POST parameters
    site_id = int(request.POST.get('site'))
    user_id = int(request.POST.get('user'))
    portfolio_id = int(request.POST.get('portfolio'))
    title = request.POST.get('title')
    description = request.POST.get('description')

    # Portfolio
    try:
        portfolio = Portfolio.get(Portfolio.id == portfolio_id,
                                  Portfolio.site == site)
    except Portfolio.DoesNotExist:
        return dict(status=False, info='Portfólio não encontrado')

    # Upload picture image
    start_index = 1
    try:
        pictures = site.pictures.order_by(Picture.id.desc())
        last_picture = pictures.get()
        start_index = last_picture.id + 1
    except Picture.DoesNotExist:
        pass
    img_path = site.get_image_path(IMAGE_PATH)
    img_url = '%s/%s/' % (host, IMAGE_DIR)
    upload_response = upload_new_image(request, 'picture', start_index,
                                       img_path, img_url, ORIG_SIZE, NORM_SIZE,
                                       THUMB_SIZE)
    if not upload_response['status']:
        return upload_response

    # Upload data
    original_image = upload_response['original_filename']
    normalized_image = upload_response['normalized_filename']
    thumbnail_image = upload_response['thumbnail_filename']
    original_url = upload_response['original_url']
    normalized_url = upload_response['normalized_url']
    thumbnail_url = upload_response['thumbnail_url']

    # Create Picture
    picture_created = None
    with db.transaction():
        try:
            picture_created = Picture.create(site=site,
                                             portfolio=portfolio,
                                             title=title,
                                             description=description,
                                             original_image=original_image,
                                             normalized_image=normalized_image,
                                             thumbnail_image=thumbnail_image)
        except IntegrityError as exp:
            if picture_created:
                picture_created.delete_instance(IMAGE_PATH)
            else:
                site_img_path = site.get_image_path(IMAGE_PATH)
                if original_image:
                    original_file = os.path.join(site_img_path, original_image)
                    if os.path.exists(original_file):
                        os.remove(original_file)
                if normalized_image:
                    normalized_file = os.path.join(site_img_path,
                                                   normalized_image)
                    if os.path.exists(normalized_file):
                        os.remove(normalized_file)
                if thumbnail_image:
                    thumbnail_file = os.path.join(site_img_path,
                                                  thumbnail_image)
                    if os.path.exists(thumbnail_file):
                        os.remove(thumbnail_file)
            # Return error
            return dict(status=False, info='%s' % exp)

    # Lista de pictures atualizada
    try:
        picture_list = template('pictures_admin_list.html',
                                site=site,
                                host=host,
                                csrf=csrf,
                                portfolio=portfolio,
                                img_url=img_url)
    except Exception as exp:
        return dict(status=False, info='%s' % exp)

    # Return OK
    return dict(status=True,
                info='Adicionada com sucesso',
                picture_id=picture_created.get_id(),
                original=original_url,
                normalized=normalized_url,
                thumbnail=thumbnail_url,
                picture_list=picture_list)
Exemple #17
0
def search(parameters):
    # Préparation des paramètres de la requête
    payload = {
        'px_loyermin':
        parameters['price'][0] if parameters['seloger']['idtt'] == 1 else None,
        'px_loyermax':
        parameters['price'][1] if parameters['seloger']['idtt'] == 1 else None,
        'pxmin':
        parameters['price'][0] if parameters['seloger']['idtt'] == 2 else None,
        'pxmax':
        parameters['price'][1] if parameters['seloger']['idtt'] == 2 else None,
        'surfacemin':
        parameters['surface'][0],
        'surfacemax':
        parameters['surface'][1],
        # Si parameters['rooms'] = (2, 4) => "2,3,4"
        'nbpieces':
        list(range(parameters['rooms'][0], parameters['rooms'][1] + 1)),
        # Si parameters['bedrooms'] = (2, 4) => "2,3,4"
        'nb_chambres':
        list(range(parameters['bedrooms'][0], parameters['bedrooms'][1] + 1)),
        'ci': [int(cp[2]) for cp in parameters['cities']]
    }
    # Insertion des paramètres propres à LeBonCoin
    payload.update(parameters['seloger'])

    headers = {
        'user-agent':
        'Dalvik/2.1.0 (Linux; U; Android 6.0.1; D5803 Build/MOB30M.Z1)'
    }

    request = requests.get("http://ws.seloger.com/search_4.0.xml",
                           params=payload,
                           headers=headers)

    xml_root = ET.fromstring(request.text)

    for annonceNode in xml_root.findall('annonces/annonce'):
        # Seconde requête pour obtenir la description de l'annonce
        _payload = {
            'noAudiotel': 1,
            'idAnnonce': annonceNode.findtext('idAnnonce')
        }
        _request = requests.get("http://ws.seloger.com/annonceDetail_4.0.xml",
                                params=_payload,
                                headers=headers)

        photos = list()
        for photo in annonceNode.find("photos"):
            photos.append(photo.findtext("stdUrl"))

        annonce, created = Annonce.get_or_create(
            id='seloger-' + annonceNode.find('idAnnonce').text,
            site='SeLoger',
            # SeLoger peut ne pas fournir de titre pour une annonce T_T
            title="Appartement " + annonceNode.findtext('nbPiece') +
            " pièces" if annonceNode.findtext('titre') is None else
            annonceNode.findtext('titre'),
            description=ET.fromstring(_request.text).findtext("descriptif"),
            telephone=ET.fromstring(
                _request.text).findtext("contact/telephone"),
            created=datetime.strptime(annonceNode.findtext('dtCreation'),
                                      '%Y-%m-%dT%H:%M:%S'),
            price=annonceNode.find('prix').text,
            charges=annonceNode.find('charges').text,
            surface=annonceNode.find('surface').text,
            rooms=annonceNode.find('nbPiece').text,
            bedrooms=annonceNode.find('nbChambre').text,
            city=annonceNode.findtext('ville'),
            link=annonceNode.findtext('permaLien'))

        if created:
            for photo in photos:
                Picture.create(url=photo, annonce=annonce)
            annonce.save()
Exemple #18
0
def picture_add(site, host, netloc, csrf, logged_in, user_id_logged_in):
    """
    Add picture post url
    """

    # POST parameters
    site_id = int(request.POST.get('site'))
    user_id = int(request.POST.get('user'))
    portfolio_id = int(request.POST.get('portfolio'))
    title = request.POST.get('title')
    description = request.POST.get('description')

    # Portfolio
    try:
        portfolio = Portfolio.get(Portfolio.id == portfolio_id, Portfolio.site == site)
    except Portfolio.DoesNotExist:
        return dict(status=False, info='Portfólio não encontrado')

    # Upload picture image
    start_index = 1
    try:
        pictures = site.pictures.order_by(Picture.id.desc())
        last_picture = pictures.get()
        start_index = last_picture.id + 1
    except Picture.DoesNotExist:
        pass
    img_path = site.get_image_path(IMAGE_PATH)
    img_url = '%s/%s/' % (host, IMAGE_DIR)
    upload_response = upload_new_image(request, 'picture', start_index, img_path, img_url, ORIG_SIZE, NORM_SIZE, THUMB_SIZE)
    if not upload_response['status']:
        return upload_response

    # Upload data
    original_image = upload_response['original_filename']
    normalized_image = upload_response['normalized_filename']
    thumbnail_image = upload_response['thumbnail_filename']
    original_url = upload_response['original_url']
    normalized_url = upload_response['normalized_url']
    thumbnail_url = upload_response['thumbnail_url']

    # Create Picture
    picture_created = None
    with db.transaction():
        try:
            picture_created = Picture.create(site=site,
                                             portfolio=portfolio,
                                             title=title,
                                             description=description,
                                             original_image=original_image,
                                             normalized_image=normalized_image,
                                             thumbnail_image=thumbnail_image)
        except IntegrityError as exp:
            if picture_created:
                picture_created.delete_instance(IMAGE_PATH)
            else:
                site_img_path = site.get_image_path(IMAGE_PATH)
                if original_image:
                    original_file = os.path.join(site_img_path, original_image)
                    if os.path.exists(original_file):
                        os.remove(original_file)
                if normalized_image:
                    normalized_file = os.path.join(site_img_path, normalized_image)
                    if os.path.exists(normalized_file):
                        os.remove(normalized_file)
                if thumbnail_image:
                    thumbnail_file = os.path.join(site_img_path, thumbnail_image)
                    if os.path.exists(thumbnail_file):
                        os.remove(thumbnail_file)
            # Return error
            return dict(status=False, info='%s' % exp)

    # Lista de pictures atualizada
    try:
        picture_list = template('pictures_admin_list.html', site=site, host=host, csrf=csrf,
                                portfolio=portfolio, img_url=img_url)
    except Exception as exp:
        return dict(status=False, info='%s' % exp)

    # Return OK
    return dict(status=True, info='Adicionada com sucesso', picture_id=picture_created.get_id(),
                original=original_url, normalized=normalized_url, thumbnail=thumbnail_url,
                picture_list=picture_list)