예제 #1
0
def load_items(n=50):
    """
    :param n: number of items to insert into database
    :return: None
    """
    conditions = ['clean', 'okay', 'torn', 'incomplete']
    description = ["A test description\nThis sheet is cool"]

    sheets = db_session.query(Sheetmusic).all()
    users = db_session.query(User).all()

    random.seed(0)
    for i in range(n):
        sm = random.choice(sheets)
        user = random.choice(users)
        item = Item()
        item.user = user
        item.sheetmusic = sm
        item.condition = random.choice(conditions)
        item.description = random.choice(description)

        # add 4 images to each item
        item.images = [ItemImage("{}_{}".format(user.username, uuid.uuid4())) for _ in range(4)]

        db_session.add(item)
        # print(item)
        db_session.commit()
예제 #2
0
def renders_list():
    if request.method == 'GET':
        renders = Render.query.order_by(desc(Render.id)).all()
        # for render in renders:
        #     if render.streamable_short == None:
        #         result = tasks.render.AsyncResult(render.celery_id)
        #         if result.successful():
        #             render.streamable_short = result.get()
        db_session.commit()
        return render_template('renders.html', renders=renders)
    if request.method == 'POST':
        form = RenderForm(request.form)
        cut_form = CutForm(request.form)
        mp = None
        if cut_form.data['gtv_match_id']!='' and cut_form.data['client_num']!='':
            mp = MatchPlayer.query.filter(MatchPlayer.gtv_match_id == int(cut_form.data['gtv_match_id']),MatchPlayer.client_num == int(cut_form.data['client_num'])).first()
        if mp != None:
            db_player = Player.query.filter(Player.id == mp.player_id).first()
        else:
            db_player=None
        try:
            render_id = render_new('upload/' + cut_form.data['filename'], str(int(cut_form.data['start'])),
                               cut_form.data['end'],
                               cut_form.data['cut_type'], cut_form.data['client_num'], form.data['title'],
                               cut_form.data['gtv_match_id'], cut_form.data['map_number'],db_player)
        except Exception as e:
            flash(str(e))
            #return redirect(url_for('export'))
            return redirect(url_for('export',_anchor='render-form'), code=307)
        return redirect(url_for('render_get', render_id=render_id))
예제 #3
0
파일: manage.py 프로젝트: planset/templa
def init():
    """initialize database and directories"""
    try:
        remakedir(settings.DATA_DIR_PATH)
        remakedir(settings.DEMO_DIR_PATH)
        remakedir(settings.THUMBNAIL_DIR_PATH)
    except:
        print sys.exc_info()

    try:
        if os.path.exists(settings.DB_PATH):
            os.remove(settings.DB_PATH)
        init_db()
        if getpwuid(os.getuid())[0] == "root":
            os.chown(settings.DB_PATH, apache_uid, apache_gid)
    except:
        print sys.exc_info()

    try:
        role_admin = UserRole("admin", "for administrators")
        db_session.add(role_admin)

        user_admin = User("admin", role=role_admin)
        db_session.add(user_admin)

        db_session.commit()
        db_session.remove()

    except:
        print sys.exc_info()
예제 #4
0
def init():
    """initialize database and directories"""
    try:
        remakedir(settings.DATA_DIR_PATH)
        remakedir(settings.DEMO_DIR_PATH)
        remakedir(settings.THUMBNAIL_DIR_PATH)
    except:
        print sys.exc_info()
        
    try:
        if os.path.exists(settings.DB_PATH):
            os.remove(settings.DB_PATH)
        init_db()
        if getpwuid(os.getuid())[0] == 'root':
            os.chown(settings.DB_PATH, apache_uid, apache_gid)
    except:
        print sys.exc_info()

    try:
        role_admin = UserRole('admin', 'for administrators')
        db_session.add(role_admin)

        user_admin = User('admin', role=role_admin)
        db_session.add(user_admin)

        db_session.commit()
        db_session.remove()

    except:
        print sys.exc_info()
예제 #5
0
파일: models.py 프로젝트: planset/templa
    def update(self, template, form, user):
        filename = secure_filename(form.archive.file.filename)

        template.subject = form.subject.data
        template.description = form.description.data
        template.tags = []
        for tag_name in form.tags.data:
            tag = Tag.query.filter(
                Tag.name == tag_name).first() or Tag(tag_name)
            template.tags.append(tag)
        template.modified_date = datetime.datetime.now()

        if len(filename) > 0:
            delete_template_files(template.id)

            template.filename = filename
            fileinfo = save_template_file(template.id, form.archive.file,
                                          filename)
            template.compressed_filelist = fileinfo.compressed_filelist
            template.index_filename = fileinfo.index_filename

            uncompress_template(template.id, filename)
            make_thumbnail(template.id, template.index_filename)

        db_session.add(template)
        db_session.commit()
예제 #6
0
파일: items.py 프로젝트: theanht1/nd-004
def edit_item(item_id, item):
    """Route to item edit form + update item"""
    catalogs = Catalog.get_all()
    # GET request
    if request.method == 'GET':
        return render_template('items/edit.html', item=item, catalogs=catalogs,
                               name=item.name, catalog_id=item.catalog_id,
                               description=item.description)

    # POST request
    name, description, catalog_id = convert_item_fields(request.form.get('name'),
                                                        request.form.get('description'),
                                                        request.form.get('catalog_id'))
    if name and description and catalog_id:
        item.name = name
        item.description = description
        item.catalog_id = catalog_id
        db_session.add(item)
        db_session.commit()
        flash('Item %s is updated' % item.name, 'info')
        return redirect(url_for('item.get_item', item_id=item.id))

    else:
        flash('Name, description and catalog are required', 'warning')
        return render_template('items/edit.html', catalogs=catalogs, item=item, name=name,
                               catalog_id=catalog_id, description=description)
예제 #7
0
def inviteMany(room, users):
    for user in users:
        room.users.append(user)
    for ot in room.oto:
        room.oto.remove(ot)
        db_session.delete(ot)
    db_session.commit()
예제 #8
0
파일: models.py 프로젝트: planset/templa
    def new(self, form, user):
        filename = secure_filename(form.archive.file.filename)

        # add Template to db
        newtemp = Template(form.subject.data, 
                           user,
                           filename,
                           len(form.archive.file.stream.getvalue())/1024,
                           description=form.description.data,
                           tags=form.tags.data
                           )
        if not newtemp:
            flash("db error")
            abort(401)
        
        db_session.add(newtemp)
        db_session.commit()

        fileinfo = save_template_file(newtemp.id, form.archive.file, filename)
        newtemp.compressed_filelist = fileinfo.compressed_filelist
        newtemp.index_filename = fileinfo.index_filename
        db_session.commit()
    
        uncompress_template(newtemp.id, filename)
        make_thumbnail(newtemp.id, newtemp.index_filename)
예제 #9
0
    def validate_and_save(self, update=False, pdf=None):
        """
        Valida que el centro creado/modificado tenga formato válido.
        Si es válido lo actualiza en la base de datos, caso contrario
        devuelve los errores que existieron en las validaciones.
        """
        errors = ""

        self.web = sql_and_tag_escape(self.web)
        self.name = sql_and_tag_escape(self.name)
        self.address = sql_and_tag_escape(self.address)
        self.municipio = sql_and_tag_escape(self.municipio)
        errors += self.validate_name()
        errors += self.validate_address()
        errors += self.validate_email()
        errors += self.validate_phone()
        errors += self.validate_url()
        errors += self.validate_opens_closes()
        errors += self.validate_coordinates()
        errors += self.validate_municipio()
        errors += self.validate_protocol(pdf)

        if not update:
            db_session.add(self)
        if errors:
            raise AssertionError(errors)
        db_session.commit()
예제 #10
0
def destroy(id):
    """
    Elimina un turno especifico de la base de datos
    """
    turno = Turno.query.filter_by(id=sql_and_tag_escape(str(id))).first()
    if not turno:
        abort(404)
    db_session.delete(turno)
    db_session.commit()
    return redirect(url_for('turns.index'))
예제 #11
0
def create(name, host, users=None):
    room = Room(name, host.id)
    room.users.append(host)
    if users:
        for user in users:
            room.users.append(user)
    db_session.add(room)
    db_session.commit()

    return room
예제 #12
0
    def wrapper_register(*args, **kwargs):
        message = args[0]
        if message is not None:
            chat = message.chat
            if Chat.query.filter(Chat.id == chat.id).first() is None:
                name = chat.first_name if chat.type == 'private' else chat.title
                new_chat = Chat(id=chat.id, name=name)
                db_session.add(new_chat)
                db_session.commit()

        func(*args, **kwargs)
예제 #13
0
def registerAsOneToOne(room, first, second):
    if first.id > second.id:
        first, second = second, first

    otor = OneToOneRoom(room.id, first.id, second.id)
    room.users.append(first)
    room.users.append(second)
    db_session.add(otor)
    db_session.commit()

    return otor
예제 #14
0
def despublicar(id):
    """
    Metodo para cambiar el estado de publicacion de un metodo a
    'Despublicado'
    """
    center = Center.query.filter_by(id=id).first()
    if not center:
        abort(404)
    center.publication_state = False
    db_session.commit()
    return redirect(url_for('centers.show', id=id))
예제 #15
0
파일: items.py 프로젝트: theanht1/nd-004
def delete_item(item_id, item):
    """Route to item's delete page + delete item"""
    # GET request
    if request.method == 'GET':
        return render_template('items/delete.html', item=item)

    # POST request
    item_name = item.name
    db_session.delete(item)
    db_session.commit()
    flash('Item %s is removed' % item_name, 'info')
    return redirect(url_for('catalog.home_page'))
예제 #16
0
def destroy(id):
    """
    Eliminar un centro de la base de datos
    """
    centers = Center.query.filter_by(id=id).first()
    if not centers:
        abort(404)
    centers.state = 4
    centers.delete_date = datetime.now()
    centers.publication_state = False
    db_session.commit()
    return redirect(url_for('centers.index'))
예제 #17
0
def some_todo_tasks():
    tasks = [
        TODOTask(str(uuid.uuid4()), 'Task 1'),
        TODOTask(str(uuid.uuid4()), 'Task 2'),
        TODOTask(str(uuid.uuid4()), 'Task 3'),
    ]

    for t in tasks:
        db_session.add(t)
        db_session.commit()

    return tasks
예제 #18
0
def render_get(render_id):
    render = Render.query.filter(Render.id == render_id).first()
    if render.streamable_short != None:
        return render_template('render.html', render=render)
    result = tasks.render.AsyncResult(render.celery_id)
    if request_wants_json():
        data = result.result or result.state
        # print(data)
        return jsonify(data)
    if result.successful():
        render.streamable_short = result.get()
        db_session.commit()
    return render_template('render.html', render=render)
예제 #19
0
파일: sessions.py 프로젝트: theanht1/nd-004
def gconnect():
    """Use google one time token to validate user"""
    code = request.data

    try:
        # Upgrade the authorization code into a credentials object
        oauth_flow = flow_from_clientsecrets('client_secrets.json', scope='')
        oauth_flow.redirect_uri = 'postmessage'
        credentials = oauth_flow.step2_exchange(code)
    except FlowExchangeError:
        return render_json_error('Failed to upgrade the authorization code.',
                                 401)

    # Check that the access token is valid.
    access_token = credentials.access_token
    url = ('https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=%s' %
           access_token)
    result = json.loads(httplib2.Http().request(url, 'GET')[1])
    # If there was an error in the access token info, abort.
    if result.get('error') is not None:
        return render_json_error(result.get('error'), 500)

    # Verify that the access token is valid for this app.
    if result['issued_to'] != CLIENT_ID:
        return render_json_error("Token's client ID does not match app's.",
                                 401)

    # Get user info
    userinfo_url = "https://www.googleapis.com/oauth2/v1/userinfo"
    params = {'access_token': credentials.access_token, 'alt': 'json'}
    answer = requests.get(userinfo_url, params=params)

    data = answer.json()

    # Try to find user in our db
    user = db_session.query(User).filter(User.email == data['email']).first()
    # If user not in db, create new
    if not user:
        user = User(name=data['name'],
                    email=data['email'],
                    picture=data['picture'])
        db_session.add(user)
        db_session.commit()

    # Store the access token in the session for later use.
    session['access_token'] = credentials.access_token
    # Store user id for user authentication in next request
    session['user_id'] = user.id

    flash('Successfully login', 'info')
    return render_json({'message': 'Successfully login'})
예제 #20
0
def destroy(username):
    """
    Eliminar un usuario de la base de datos
    """
    users = User.query.filter_by(username=username).first()
    if not users:
        abort(404)
    # Si llega hasta aca para eliminarse, chequea que no se elimine a si mismo
    if users.username == session.get("username"):
        flash("No se puede eliminarse a si mismo.", "error")
        return redirect(url_for('users.index'))
    db_session.delete(users)
    db_session.commit()
    return redirect(url_for('users.index'))
예제 #21
0
def client(app):
    client = app.test_client()

    with app.app_context():
        if not db_session.query(User)\
                    .filter(User.username == 'test').one_or_none():
            init_db()
            db_session.add(User(
                username='******',
                password='******',
            ))
            db_session.commit()

    yield client
예제 #22
0
def add_task(message):
    chat = Chat.query.filter(Chat.id==message.chat.id).first()

    text = message.text.split(' ', 1)
    if len(text) <= 1:
        bot.send_message(message.chat.id, "Gimme something to work with, man.")
        return

    task = Task(description=text[1], chat_id=chat.id)

    db_session.add(task)
    db_session.commit()

    bot.send_message(message.chat.id, f'Added task "{task}"')
예제 #23
0
def get_task(message):
    tasks = Task.query.filter(Task.chat_id==message.chat.id).all()

    if len(tasks) == 0:
        bot.send_message(message.chat.id, "There's nothing for you to do.")
        return

    task = tasks[int(random()*len(tasks))]
    db_session.delete(task)
    db_session.commit()

    bot.send_message(
        message.chat.id,
        "Your next mission, should you choose to accept it, is:\n\n" + \
            task.description)
예제 #24
0
def load_sheet_music():
    with open(path.join(DATA_DIRECTORY, 'sheet_music.json'), 'r') as fh:
        data = json.load(fh)

        for sheet_music in data['sheet_music']:
            if not db_session.query(Sheetmusic).filter_by(title=sheet_music['title']).first():
                instrumentation = sheet_music.pop('instrumentation', None)
                genres = sheet_music.pop('genre_tags', None)
                new_obj = Sheetmusic(**sheet_music)

                new_obj.parse_tags(instrumentation, Instrument, 'instrumentation')
                new_obj.parse_tags(genres, Genre, 'genre_tags')

                db_session.add(new_obj)
                # print("added", new_obj)
                db_session.commit()
예제 #25
0
def load_users():
    with open(path.join(DATA_DIRECTORY, 'auth.json')) as fh:
        data = json.load(fh)

        for user in data['users']:
            if db_session.query(User).filter_by(email=user['email']).one_or_none() is None:
                addresses = user.pop('addresses')

                new_user_obj = User(**user)

                new_address_objs = [Address(**address) for address in addresses]
                new_user_obj.addresses = new_address_objs

                db_session.add(new_user_obj)
                # print("added", new_user_obj, new_address_objs)
                db_session.commit()
예제 #26
0
 def validate_and_save(self, update=False):
     """
     Valida y guarda un turno, si falla levanta AssertionError
     con los errores encontrados
     """
     errors = ""
     errors += validate_turno_tomado(self)
     errors += validate_email(self)
     errors += validate_phone_number(self)
     errors += validate_hora_correcta(self)
     errors += validate_centro_disponible(self)
     if errors:
         raise AssertionError(errors)
     if not update:
         db_session.add(self)
     db_session.commit()
예제 #27
0
def update():
    """
    Actualiza la configuracion a partir de los campos rellenados en el
    formulario de configuracion o flashea un mensaje de error si falla
    alguna validacion
    """
    if(check_token(request.form["csrf_token"])):
        CSRF_TOKEN = request.form["csrf_token"]
        form = request.form.copy()
        if "home.habilitado" in request.form.keys():
            form["home.habilitado"] = "TRUE"
        else:
            form["home.habilitado"] = "FALSE"
        errors = ""
        del form["csrf_token"]
        for element in form:
            original = Configuration.query.filter_by(name=element).first()
            original.value = sql_and_tag_escape(form[element])
            error = validate(original)
            if error:
                errors += error
        if not errors:
            flash("Configuración guardada correctamente", "success")
            db_session.commit()
            return redirect(url_for("configuration.index"))
        else:
            flash_messages(errors)
            configurations = Configuration.query.order_by(
                Configuration.name
            ).all()
            configs = {}
            first_name = ''
            for element in configurations:
                name = element.name.split('.')
                if first_name != name[0]:
                    first_name = name[0]
                    configs_content = []
                    configs[name[0]] = configs_content
                content_elements = [element.name, form[element.name]]
                configs[name[0]].append(content_elements)
            return(render_template(
                "configuration/configuration.html",
                configs=configs,
                CSRF_TOKEN_STRING=CSRF_TOKEN
            ))
    else:
        return render_template("configuration/configuration.html")
예제 #28
0
def getOneToOneRoom(first, second):
    current_user = first

    if first.id > second.id:
        first, second = second, first

    otor = db_session.query(OneToOneRoom).filter(OneToOneRoom.firstId == first.id)\
      .filter(OneToOneRoom.secondId == second.id).first()
    if not otor:
        room = create(None, first)
        registerAsOneToOne(room, first, second)
    else:
        room = get(otor.roomId)
        if current_user not in room.users:
            room.users.append(current_user)
            db_session.commit()
    return room
예제 #29
0
def create_view():
    json_data = request.get_json()
    if not json_data:
        return return_non_success_json(400, {'message': 'No input data provided'})

    # Validate and deserialize input
    message_schema = MessageSchema(only=('recipient_address', 'sender_address', 'subject', 'body'))
    try:
        data = message_schema.load(json_data)
    except ValidationError as err:
        return return_non_success_json(422, err.messages)

    message = Message(**data.data)
    db_session.add(message)
    db_session.flush()
    db_session.commit()

    return jsonify({'messages': 'ok'})
예제 #30
0
def load_trades(n=10):
    """ Create and store several trade items.
    :param n: number of trades to insert into database
    :return: None
    """
    random.seed(0)
    users = db_session.query(User).all()

    for i in range(n):
        from_user, to_user = random.sample(users, 2)
        from_item, to_item = random.choice(from_user.items), random.choice(to_user.items)

        trade = Trade(user_from_id=from_user.id,
                      user_to_id=to_user.id,
                      item_from=from_item,
                      item_to=to_item)
        db_session.add(trade)
        db_session.commit()
예제 #31
0
def cut():
    print(request.form.get("longUrl"))
    longUrl = utils.convert(str(request.form.get("longUrl")))
    req = u.query.filter(u.longUrl == longUrl).first()
    print(req)
    if (req != None):
        shortUrl = req.shortUrl
    else:
        shortUrl = utils.random_string(size=4)
        db_session.add(Urls(shortUrl, longUrl))
        db_session.commit()
    response = {"status": True, "shortUrl": shortUrl, "longUrl": longUrl}
    print(longUrl)
    try:
        requests.get(response["longUrl"])
    except:
        response["status"] = False
    return render_template('cut.html', response=response)
예제 #32
0
def reject(id):
    """
    Método para rechazar un centro de ayuda.
    """
    center = Center.query.filter_by(id=id).first()
    if not center:
        abort(404)
    center.publication_state = False
    estado = State.query.filter_by(name="Pendiente").first()
    estado.centers.remove(center)
    estado = State.query.filter_by(name="Rechazado").first()
    estado.centers.append(center)
    db_session.commit()
    from_page = request.form["from_page"]
    if from_page == "pending":
        return redirect(url_for('centers.pending_index'))
    elif from_page == "center_show":
        return redirect(url_for('centers.show', id=id))
예제 #33
0
def render_new(filename, start, end, cut_type, client_num, title, gtv_match_id, map_number, player):
    if gtv_match_id == '':
        filename_orig = filename
    else:
        filename_orig = 'upload/' + str(gtv_match_id) + '_' + str(map_number) + '.tv_84'
    filename_cut = 'download/' + str(gtv_match_id) + '_' + str(map_number) + '_' + str(client_num) + '_' + str(
        start) + '_' + str(end) + '.dm_84'
    if gtv_match_id != '' and not os.path.exists(filename_orig):
        demo_url = app.gamestv.getDemosLinks(app.gamestv.getMatchDemosId(gtv_match_id))[int(map_number)]
        urllib.request.urlretrieve(demo_url, filename_orig)
    app.Libtech3.cut(flask_app.config['PARSERPATH'], filename_orig, filename_cut, int(start) - 2000, end, cut_type,
                     client_num)
    result = tasks.render.delay(flask_app.config['APPHOST'] + '/' + filename_cut, start,end, title, player.name if (player!=None) else None, player.country if (player!=None) else None,etl=False)
    r = Render(result.id, title, gtv_match_id, map_number, client_num, player.id if (player!=None) else None )
    db_session.add(r)
    db_session.flush()
    db_session.commit()
    return r.id
예제 #34
0
def update_view():
    json_data = request.json
    if not json_data:
        return return_non_success_json(400,
                                       {'message': 'No input data provided'})

    # Validate and deserialize input
    summary_schema = ExerciseSummarySchema(only=('created_at', 'subject'))
    try:
        data = summary_schema.load(json_data)
    except ValidationError as err:
        return return_non_success_json(422, err.messages)

    summary = ExerciseSummary(**data.data)
    db_session.add(summary)
    db_session.flush()
    db_session.commit()

    return jsonify({'messages': 'ok'})
예제 #35
0
def seed_db():
    user1 = User(name='user1', email='*****@*****.**')
    user2 = User(name='user2', email='*****@*****.**')
    db_session.add(user1)
    db_session.add(user2)
    db_session.commit()

    catalog_datas = [
        {
            'name': 'Skating'
        },
        {
            'name': 'Hockey'
        },
    ]

    for catalog in catalog_datas:
        new_catalog = Catalog(name=catalog['name'])
        db_session.add(new_catalog)

    db_session.commit()
예제 #36
0
def adminpassword():
    """set admin password"""
    admin_username = "******"

    password = getpass.getpass()
    if len(password)<8:
        print "dame"
        return

    admin = User.query.get(1)

    if not admin:
        userrole = UserRole.query.get('admin')
        admin = User(admin_username, userrole)
        db_session.add(admin)
    
    admin.set_password(password)

    db_session.commit()
    db_session.remove()

    print "update successfully"
def reset_all_tasks():
    today = dt.datetime.today()
    weekday = today.weekday()
    month = today.month
    hour = today.hour
    for task in db_session.query(Task).all():
        if not task.hours:
            continue
        schedule = json.loads(task.hours.replace("\'", "\""))
        if not (schedule['month_of_year'] == '*' or month in set(
            [int(mnt) for mnt in schedule['month_of_year'].split(',')])):
            continue
        if not (schedule['day_of_week'] == '*' or weekday in set(
            [int(week) for week in schedule['day_of_week'].split(',')])):
            continue
        hours = set([int(hr) for hr in schedule['hour'].split(',')])
        if not hour in hours:
            continue
        print(task)
        task.completed = False
    db_session.flush()
    db_session.commit()
예제 #38
0
파일: manage.py 프로젝트: planset/templa
def adminpassword():
    """set admin password"""
    admin_username = "******"

    password = getpass.getpass()
    if len(password) < 8:
        print "dame"
        return

    admin = User.query.get(1)

    if not admin:
        userrole = UserRole.query.get("admin")
        admin = User(admin_username, userrole)
        db_session.add(admin)

    admin.set_password(password)

    db_session.commit()
    db_session.remove()

    print "update successfully"
예제 #39
0
    def validate_and_save(self, update=False, password_change=False):
        """
        Valida que el usuario creado/modificado tenga formato válido.
        Si es válido lo actualiza en la base de datos, caso contrario
        devuelve los errores que existieron en las validaciones.
        """
        errors = ""
        errors += validate_first_name(self)
        errors += validate_last_name(self)

        if not update:
            errors += validate_username(self)
            errors += validate_email(self)
            errors += validate_password(self)
            self.password = generate_password_hash(self.password)
            db_session.add(self)
        elif password_change:
            errors += validate_password(self)
            self.password = generate_password_hash(self.password)
        if errors:
            raise AssertionError(errors)

        db_session.commit()
예제 #40
0
파일: items.py 프로젝트: theanht1/nd-004
def add_new_item():
    """Route to new item page + create item"""
    catalogs = Catalog.get_all()

    # GET request
    if request.method == 'GET':
        return render_template('items/new.html', catalogs=catalogs)

    # POST request
    name, description, catalog_id = convert_item_fields(request.form.get('name'),
                                                        request.form.get('description'),
                                                        request.form.get('catalog_id'))
    if name and description and catalog_id:
        item = CatalogItem(name=name, description=description,
                           catalog_id=catalog_id, user_id=g.current_user.id)
        db_session.add(item)
        db_session.commit()
        flash('Item %s is created' % item.name, 'info')
        return redirect(url_for('item.get_item', item_id=item.id))

    else:
        flash('Name, description and catalog are required', 'warning')
        return render_template('items/new.html', name=name, catalog_id=catalog_id,
                               description=description, catalogs=catalogs)
예제 #41
0
파일: models.py 프로젝트: planset/templa
    def update(self, template, form, user):
        filename = secure_filename(form.archive.file.filename)
    
        template.subject = form.subject.data
        template.description = form.description.data
        template.tags = []
        for tag_name in form.tags.data:
            tag = Tag.query.filter(Tag.name==tag_name).first() or Tag(tag_name)
            template.tags.append(tag)
        template.modified_date = datetime.datetime.now()

        if len(filename) > 0:
            delete_template_files(template.id)
            
            template.filename = filename
            fileinfo = save_template_file(template.id, form.archive.file, filename)
            template.compressed_filelist = fileinfo.compressed_filelist
            template.index_filename = fileinfo.index_filename

            uncompress_template(template.id, filename)
            make_thumbnail(template.id, template.index_filename)

        db_session.add(template)
        db_session.commit()
예제 #42
0
파일: user.py 프로젝트: yukatou/boardapp
 def save(self, username, password):
     user = UserTable(username=username, password=password)
     db_session.add(user)
     db_session.commit()
예제 #43
0
파일: models.py 프로젝트: planset/templa
 def delete_having_no_template(self):
     items = Tag.query.all()
     for item in items:
         if len(item.templates)==0:
             db_session.delete(item)
     db_session.commit()
예제 #44
0
# coding=utf-8
from app.db.project import ProjectTable
from app.db import db_engine, db_session

try:
    ProjectTable.__table__.create(bind=db_engine)
    db_session.add(ProjectTable('Hello World!'))
    db_session.add(ProjectTable(u'こんにちは、世界!'))
    db_session.commit()
except:
    pass
예제 #45
0
파일: models.py 프로젝트: planset/templa
 def delete(self, template):
     db_session.delete(template)
     db_session.commit()
     delete_template_files(template.id)
     TagModel().delete_having_no_template()
예제 #46
0
파일: entry.py 프로젝트: yukatou/boardapp
 def save(self, title, text, username):
   entry = EntryTable(title, text, username)
   db_session.add(entry)
   db_session.commit()