Beispiel #1
0
    def __init__(self, gallery, debug=False):
        '''debug: True면 디버그용 문자열 출력'''
        self.debug = debug
        self.gallery = gallery
        self.galleryUrl = 'http://gall.dcinside.com/board/lists/?id=%s&page=%d'

        self.idSet = set()  # db넣기전 1차 id 체크용

        self.s_db = Session()
        if self.s_db.query(Category).filter(Category.name == self.gallery).count() == 0:
            category = Category()
            category.name = self.gallery
            self.s_db.add(category)
            self.s_db.commit()
            self.categoryId = category.id
        else:
            id, = self.s_db.query(Category.id).filter(Category.name == self.gallery)[0]
            self.categoryId = id

        headers = {}
        headers['User-Agent'] = USERAGENT
        headers['Accept-Language'] = 'ko-KR,ko;q=0.8,en-US;q=0.5,en;q=0.3'
        headers['Accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
        headers['Referer'] = REFERER % self.gallery
        self.s_req = requests.Session()
        self.s_req.headers.update(headers)

        r = self.s_req.get(self.galleryUrl % (self.gallery, 1))
        id = getStartArticleId(r.text)
        if id is None:
            raise RuntimeError('[error]wrong gall')
Beispiel #2
0
def assign_category(club_id):
    club = Club.query.filter_by(id=club_id).first()
    if not club:
        return json.dumps({'success': False, 'error': 'Club not found'}), 404
    post_body = json.loads(request.data)
    category = Category.query.filter_by(name=post_body.get('name')).first()
    if not category:
        category = Category(name=post_body.get('name', ''))
    club.categories.append(category)
    db.session.add(category)
    db.session.commit()
    return json.dumps({'success': True, 'data': category.serialize()}), 200
Beispiel #3
0
 def post(self):
     args = parser.parse_args()
     new_category = Category()
     new_category.name = args['name']
     new_category.color = args['color']
     new_category.user_id = current_user.id
     db.session.add(new_category)
     db.session.commit()
     return jsonify(status='success',
                    result={
                        'id': new_category.id,
                        'name': new_category.name,
                        'color': new_category.color
                    })
Beispiel #4
0
def add_category(bot, update):
    """Добавляем новую категорию"""

    session = db.session

    user_id = update.message.chat_id
    name_of_category = update.message.text

    # проверяем наличие такой категории в бд
    user_categories = session.query(Category).filter_by(user_id=user_id)

    for category in user_categories:
        if category.name_of_category.lower() == name_of_category.lower():
            update.message.reply_text('Такая категория уже существует.')

            return 'categories_menu'

        else:
            continue

    # добавляем категорию в бд
    category = Category(name_of_category=name_of_category, user_id=user_id)
    session.add(category)
    session.commit()

    update.message.reply_text('Категория успешно добавлена.')

    return start(bot, update)
Beispiel #5
0
def _get_or_create_category(cat):
    category = Category.query.filter_by(category=cat).first()
    if category is not None:
        return category
    category = Category(category=cat)
    db.session.commit()
    return category
Beispiel #6
0
 def update(self, *args, msg=None, hand=None, **kwargs):
     cat = Category.find_by(msg.text)
     if not cat:
         hand.send_msg(msg, f'Категория {msg.text} не найдена')
         return
     hand.send_msg(msg, f'Категория {msg.text}', reply_markup=hand.keybords.in_line_kb_menu(menu_items=cat.wares))
     hand.send_msg(msg, 'Ok', reply_markup=hand.keybords.list_kb_menu(menu_items=hand.update_from_category()))
Beispiel #7
0
def get_ads_cat_filtered(cat_name, longitude, latitude, total):
    from db import Ad, Category
    cat_id = Category.match(cat_name).id
    ads = Ad.query.filter(Ad.category_id == cat_id).all()
    locations = []
    for ad in ads:
        locations += [ad.location]
    return location_sort((longitude, latitude), locations, total)
 def define_categories(self):
     cats = [
         'Soccer', 'Basketball', 'Baseball', 'Frisbee', 'Snowboarding',
         'Rock Climbing', 'Foosball', 'Skating', 'Hockey'
     ]
     self.categories = dict(
         (cat, Category(name=cat, user=random.choice(self.users)))
         for cat in cats)
Beispiel #9
0
def create_category(budget_id):
    budget = Budget.query.filter_by(id=budget_id).first()
    if budget is not None:
        category_body = json.loads(request.data)
        category_name = category_body.get('name')
        category = Category.query.filter_by(budget_id=budget.id, name=category_name).first()
        if category is None:
            category = Category(
                name = category_name,
                total = 0,
                budget_id = budget.id
            )
            budget.categories.append(category)
            db.session.add(category)
            db.session.commit()
            return json.dumps({'success': True, 'data': category.serialize()}), 201
        return json.dumps({'success': False, 'error': 'Category already exists!'}), 201
    return json.dumps({'success': False, 'error': 'Budget not found!'}), 404
Beispiel #10
0
def show_categories():
    category_text = ["Here are the list of categories the bot knows about:\n"]

    for category in Category.select():
        category_text.append(" - *%s* (_%s_)" %
                             (category.display_name, category.name))

    constants.slack.chat.post_message(OUTPUT_CHANNEL,
                                      "\n".join(category_text),
                                      as_user=True)
Beispiel #11
0
 def update_from_category(self):
     events = []
     cat_cmd = CaregoryCommand()
     for cat in Category.all():
         event = str(cat)
         events.append(event)
         if not self.check_event(event):
             router.reg_command(cat_cmd, event)
     events.append(settings.NAV_MENU)
     return events
Beispiel #12
0
 def fake_category(self, count: int = 10):
     """构造虚拟分类"""
     for i in range(count):
         category_obj = Category(name=self.fake.word())
         session.add(category_obj)
         try:
             session.commit()
             session.refresh(category_obj)
         except Exception as e:
             session.rollback()
Beispiel #13
0
def newCategories():
    categories = session.query(Category).order_by(asc(Category.name))
    if request.method == 'POST':
        newCategory = Category(name=request.form['name'])
        session.add(newCategory)
        flash('New Category \"%s\" Successfuly Created' % newCategory.name)
        session.commit()
        return redirect(url_for('showCategories'))
    else:
        return render_template('newCategory.html',categories=categories)
Beispiel #14
0
def handle_summary_parsing(summary_text, user_profile):
    print("Attempting to parse text...")
    results = parse_summary(summary_text, user_profile)

    if results is not None and len(results) > 0:
        glory_walls = save_glory_walls(results, user_profile)
        render_to_wiki(Category.select(), UTOPIA_AGE)
        send_response(glory_walls, user_profile)
    else:
        response = chatbot.get_response(summary_text)
        constants.slack.chat.post_message(OUTPUT_CHANNEL,
                                          response,
                                          as_user=True)
Beispiel #15
0
def assign_category(user_id, trip_id, event_id):
    user = User.query.filter_by(id=user_id).first()
    if not user:
        return json.dumps({'success': False, 'error': 'User not found!'}), 404
    trip = Trip.query.filter_by(id=trip_id).first()
    if not trip:
        return json.dumps({'success': False, 'error': 'Trip not found!'}), 404
    if ((trip in user.trips) == False):
        return json.dumps({'success': False, 'error': 'Trip not found!'}), 404
    event = Event.query.filter_by(id=event_id).first()
    if not event:
        return json.dumps({'success': False, 'error': 'Event not found!'}), 404
    if ((event in trip.events) == False):
        return json.dumps({'success': False, 'error': 'Event not found!'}), 404
    post_body = json.loads(request.data)
    category = Category.query.filter_by(name=post_body.get('name', '')).first()
    if not category:
        category = Category(name=post_body.get('name', ''))
    event.categories.append(category)
    db.session.add(category)
    db.session.commit()
    return json.dumps({'success': True, 'data': category.serialize()}), 200
Beispiel #16
0
    def add_new_item(self, **arguments):
        category_name = arguments["category"]
        category = self.session.query(Category).filter_by(
            owner=self.current_user, name=category_name).first()
        if not category:
            category = Category(name=category_name, owner=self.current_user)

        new_item = Budget(category=category,
                          date=arguments["date"],
                          title=arguments["title"],
                          amount=arguments["amount"],
                          currency=arguments["currency"])
        self.session.add(new_item)
Beispiel #17
0
def assign_category(task_id):
    task = Task.query.filter_by(id=task_id).first()
    if not task:
        return json.dumps({'success': False, 'error': 'Task not found!'}), 404
    post_body = json.loads(request.data)
    category = Category.query.filter_by(
        description=post_body.get('description', '')).first()
    if not category:
        category = Category(description=post_body.get('description', ''),
                            color=post_body.get('color'))
    task.categories.append(category)
    db.session.commit()
    return json.dumps({'success': True})
Beispiel #18
0
def user_category_post(u_id: int):
    form = request.form
    logging.info('user {} data {}'.format(u_id, form))
    name = form.get('name', '')
    order = form.get('order', '')
    if not name or not order or not order.isdigit():
        return jsonify({'status': -1})
    order = int(order)
    if 1 > order or order > 1000:
        return jsonify({'status': -1})
    cate = Category(name=name, order=order, user=request.user)
    logging.info('user {} add new category {} {}'.format(u_id, cate.id, name))
    commit()
    return jsonify({'status': 1, 'id': cate.id})
Beispiel #19
0
def select_website():
    """查询当前用户的网址"""
    sites = UserSite.select(lambda x: x.user == request.user and x.status ==
                            UserSiteStatus.normal)[:]
    categories = Category.select(
        lambda c: c.user == request.user and not c.delete).order_by(
            Category.order)[:]
    ss = defaultdict(list)
    for s in sites:
        key = s.cate.id if s.cate else ""
        ss[key].append(s)
    categories = list(categories)
    categories.insert(0, {"id": '', 'name': '', 'order': 0})
    return ss, categories
    def get_ads_and_write_to_db(self, link, response):

        try:
            category = Category.get(name=link)

        except DoesNotExist:
            category = Category.create(
                name=link
            )

        ad_blocks = response.html.xpath('//div[@class="offer-wrapper"]')
        for ad in ad_blocks:
            try:
                ad_title = ad.xpath('//h3')[0].text
                ad_date = ad.xpath('//p[@class="lheight16"]/small[2]')[0].text
                ad_price = ad.xpath('//p[@class="price"]')[0].text
                ad_photo = ad.xpath('//img/@src')[0]
                ad_link = ad.xpath('//h3/a/@href')[0]
                ad_city = ad.xpath('//p[@class="lheight16"]/small[1]')[0].text

                ad_data = {
                    'title': ad_title,
                    'date': ad_date,
                    'price': ad_price,
                    'photo': ad_photo,
                    'link': ad_link,
                    'city': ad_city,
                    'category_id': category
                }

            except Exception as e:
                print('Parse error\n', e, type(e))

            try:
                Ad.create(**ad_data)
            except Exception as e:
                print('DB error\n', e, type(e))
Beispiel #21
0
def user_category_delete(u_id: int):
    form = request.form
    logging.info('user {} delete data {}'.format(u_id, form))
    cate_id = form.get('id', '')
    if not cate_id or not cate_id.isdigit():
        return jsonify({'status': -1})
    cate_id = int(cate_id)
    cate = Category.select(lambda x: x.id == cate_id and x.user == request.user
                           and not x.delete).first()
    if not cate:
        return jsonify({'status': -1})
    cate.delete = True
    logging.warning('user {} delete category {}'.format(u_id, cate.id))
    commit()
    return jsonify({'status': 1, 'id': cate.id})
Beispiel #22
0
def assign_category(task_id):
    task = Task.query.filter_by(id=task_id).first()
    if task is None:
        return failure_response("Task not found!")

    body = json.loads(request.data)
    description = body.get('description')
    if description is None:
        return failure_response("No description!")

    category = Category.query.filter_by(description=description).first()
    if category is None:
        category = Category(description=description,
                            color=body.get('color', 'purple'))

    task.categories.append(category)
    db.session.commit()
    return success_response(task.serialize())
Beispiel #23
0
 def test_get_specific_question_category(self):
     # We Will Insert New Category , New Question belong to this category
     # and get them
     category = Category('Test')
     category.insert()
     newQuestion = Question('Test Question ?', "True", category.id, 5)
     newQuestion.insert()
     request = self.client().get(f'/categories/{category.id}/questions')
     # Remove Inserted Data
     category.delete()
     newQuestion.delete()
     data = json.loads(request.data)
     self.assertEqual(data['questions'][0]['answer'], "True")
Beispiel #24
0
def user_category_put(u_id: int):
    form = request.form
    logging.info('user {} update data {}'.format(u_id, form))
    cate_id = form.get('id', '')
    name = form.get('name', '')
    order = form.get('order', '')
    if not cate_id or not cate_id.isdigit(
    ) or not name or not order or not order.isdigit():
        return jsonify({'status': -1})
    order = int(order)
    if 1 > order or order > 1000:
        return jsonify({'status': -1})
    cate = Category.select(lambda x: x.id == cate_id and x.user == request.user
                           and not x.delete).first()
    cate.name = name
    cate.order = order
    commit()
    logging.info('user {} update category {}'.format(u_id, cate.id))
    return jsonify({'status': 1, 'id': cate.id})
Beispiel #25
0
def create_category(topic_url):
    topic = session.query(Topic).filter_by(url=topic_url).one()
    if 'username' not in login_session:
        return redirect('/login')
    if request.method == 'POST':
        is_unique = check_category_uniqueness(topic.id, request.form['cname'])
        if is_unique:
            new_url = url_maker(request.form['cname'])
            new_category = Category(name=request.form['cname'],
                                    url=new_url,
                                    topic_id=topic.id)
            session.add(new_category)
            session.commit()
            return redirect(url_for('show_topic', topic_url=topic_url))
        else:
            return render_template('new_category.html',
                                   topic=topic,
                                   error=True)
    else:
        return render_template('new_category.html', topic=topic)
Beispiel #26
0
def user_website_post(u_id: int):
    form = request.form
    logging.info('user {} post data {}'.format(u_id, form))
    cate_id = form.get('cate_id', '')
    name = form.get('name', '')
    url = form.get('url', '')
    order = form.get('order', '')
    type_ = form.get('type', '')

    if not name or not url or not order or not order.isdigit():
        return jsonify({'status': -1})
    order = int(order)
    if order > 1000 or order < 1:
        return jsonify({'status': -1})
    if not cate_id or not cate_id.isdigit():
        cate_id = None
        cate = None
    else:
        cate_id = int(cate_id)
        cate = Category.select(lambda x: x.user == request.user and x.id ==
                               cate_id and not x.delete).first()
        if not cate:
            return jsonify({'status': -1})
    try:
        icon = query_icon(urlparse(url).netloc)
    except Exception:
        icon = ''
    site = UserSite(name=name,
                    url=url,
                    user=request.user,
                    icon=icon,
                    cate=cate,
                    order=order)
    commit()
    logging.info('user {} post site {}'.format(u_id, site.id))
    if not icon:
        logging.warning("icon not found, send to redis")
        download_icon_job(site.id)
    if type_ == 'index':
        return redirect_home()
    return jsonify({'status': 1, 'id': site.id})
Beispiel #27
0
def batch_insert_website(data, user):
    """批量插入数据
    :type data: dict key -> category, values -> sites
    :type user: User
    """
    with db_session:
        i = 0
        for k, ws in data.items():
            i += 1
            if k:
                c = Category(name=k, user=user, order=10 * i)
            else:
                c = None
            k = 0
            for w in ws:
                k += 1
                UserSite(name=w[0],
                         cate=c,
                         user=user,
                         url=w[1],
                         icon=w[2],
                         order=10 * k)
Beispiel #28
0
def create():
    """
    Creates an ad
    
    Requires the following param:
        * long, lat
        * category(id) , email, title, price, image, description
    """
    # validation
    required_fields = ("long", "lat", "email", "title", "price", "image")
    for field in required_fields:
        if not field in request.form:
            return jsonify({"res": False, "error": "There is an error creating your ad due to missing field(s)."})

    # check for price integer
    try:
        float(request.form.get("price"))
    except ValueError:
        return jsonify({"res": False, "error": "Price needs to be a numerical value."})

    # email format validation
    validate_me = StringValidator(request.form.get("email"))
    if not validate_me.isEmail():
        return jsonify({"res": False, "error": "Not a valid email address."})

    from db import Location, Category, Ad

    location = Location(longitude=request.form.get("long"), latitude=request.form.get("lat"))
    category = Category.get(request.form.get("category"))
    id = Ad.create(
        location,
        request.form.get("email"),
        request.form.get("title"),
        request.form.get("price"),
        save_file(request.form.get("image")),
        category,
        request.form.get("description", ""),
    )
    return jsonify({"res": id})
Beispiel #29
0
def make_budget(owner):
    categories = {
        'Food': [
            'Chicken breast', 'Bread', 'Salad', 'Milk', 'Chocolate', 'Sausage',
            'Apples', 'Cake'
        ],
        'Home': ['Soap', 'Shampoo', 'Flower', 'Dinnerware', 'Trash bags'],
        'Clothes': ['Jacket', 'Skirt', 'Sneakers', 'Hat', 'Blouse', 'Sweater'],
        'Transport': [
            'Bus ticket', 'Gasoline 20 l', 'Car wash', 'Parking 8 h',
            'Train ticket'
        ],
        'Entertainment': ['Restaurant', 'Cafe', 'Cinema', 'Gym membership'],
        'Bills': [
            'Electricity', 'Cold water', 'Hot water', 'Internet', 'Heating',
            'Mobile phone'
        ],
        'Other spendings': ['Gift for friend', 'Haircut', 'Manicure']
    }

    random_cat = fake.random_element(categories.keys())
    random_title = fake.random_element(categories[random_cat])

    category = session.query(Category).filter_by(owner=owner,
                                                 name=random_cat).first()
    if not category:
        category = Category(name=random_cat, owner=owner)
        session.add(category)

    budget = Budget(category=category,
                    date=fake.date_this_year(),
                    title=random_title,
                    amount=fake.random_int(min=1, max=2000),
                    currency="UAH")
    session.add(budget)
    return budget
Beispiel #30
0
# Importing the database classes
from db import Base, Category, Items

# Connect to the database
engine = create_engine('sqlite:///catalog.db')

# Bind engine to Base
Base.metadata.bind = engine

# Creating instance of sessionmaker
DBSession = sessionmaker(bind=engine)

# Instatiate the DBSession Class
session = DBSession()

category1 = Category(name= 'Udacity')
session.add(category1)
session.commit()

category2 = Category(name= 'Google')
session.add(category2)
session.commit()


item1 = Items(name= 'FSND', price= '1000$', desc= 'Full Stack NanoDegree', category= category1)
session.add(item1)
session.commit()

item2 = Items(name= 'Android', price= '2000$', desc= 'Android Nanodegree', category= category1)
session.add(item2)
session.commit()
Beispiel #31
0
from db import Category

print Category.gen_options()
Beispiel #32
0
 def insert_categories_to_database(self):
     with self.app.app_context():
         self.db.session.add(Category('category'))
         self.db.session.add(Category('category2'))
         self.db.session.commit()
Beispiel #33
0
def main():
    sys.path.append(ROOT_PATH)
    import db
    from db import Information, Category, Group, Type

    os.chdir(os.path.dirname(__file__))

    clear_dir('locales')

    sessions = {}
    for lcid, name in LCID.items():
        sessions[lcid] = db.create_session(
            os.path.join('locales', lcid + '.db'))

    categories_yaml = load_yaml(os.path.join('sde', 'fsd', 'categoryIDs.yaml'))
    groups_yaml = load_yaml(os.path.join('sde', 'fsd', 'groupIDs.yaml'))
    types_yaml = load_yaml(os.path.join('sde', 'fsd', 'typeIDs.yaml'))

    category_ids = []
    group_ids = []

    def id_(key):
        try:
            value = items[key]
        except KeyError:
            value = 0
        return value

    def locale(key):
        try:
            value = items[key][lcid]
        except KeyError:
            value = ''
        return value.strip()

    for i, items in categories_yaml.items():
        name = items['name']['en']

        if name not in CATEGORY_NAMES:
            continue

        category_ids.append(i)

        for lcid, session in sessions.items():
            session.add(Category(id=i, name=locale('name')))

    for i, items in groups_yaml.items():
        category_id = id_('categoryID')
        if category_id not in category_ids:
            continue

        group_ids.append(i)

        for lcid, session in sessions.items():
            session.add(
                Group(id=i, categoryID=category_id, name=locale('name')))

    for i, items in types_yaml.items():
        group_id = id_('groupID')
        if group_id not in group_ids:
            continue

        for lcid, session in sessions.items():
            session.add(
                Type(id=i,
                     groupID=group_id,
                     name=locale('name'),
                     description=locale('description')))

    for lcid, session in sessions.items():
        session.add(Information(lcid=lcid, name=LCID[lcid]))
        session.commit()
Beispiel #34
0
from db import Ad, Category, Author

cat = Category.get(Category.id == 4)

for ad in cat.ads:
    print(ad.name, ad.price)