Ejemplo n.º 1
0
 def delete(self, account_id, joke_id):
     logger.log(auth.username(), request.date, request.remote_addr,
                request.url)
     authorizer.authorize_user(auth.username(), account_id)
     joke = self.get_joke_or_404(joke_id, account_id)
     session.delete(joke)
     session.commit()
    def delete(self, rfq_id):

        deliverables = session.query(Deliverable).filter_by(
            document_id=rfq_id).all()
        for d in deliverables:
            session.delete(d)

        content_components = session.query(ContentComponent).filter_by(
            document_id=rfq_id).all()
        for c in content_components:
            session.delete(c)

        custom_components = session.query(CustomComponent).filter_by(
            document_id=rfq_id).all()
        for c in custom_components:
            session.delete(c)

        additional_clins = session.query(AdditionalClin).filter_by(
            document_id=rfq_id).all()
        for a in additional_clins:
            session.delete(a)

        rfq = session.query(RFQ).filter_by(id=int(rfq_id)).first()

        session.delete(rfq)
        session.commit()
        message = "RFQ #" + str(rfq_id) + " deleted."

        return jsonify({'message': message})
Ejemplo n.º 3
0
def deleta_usuario(id):
    try:
        usuario = Usuarios.query.filter_by(id=id).first()
        session.delete(usuario)
        session.commit()
    except Exception as erro:
        print('O id {} não foi encontrado.'.format(id))
def delete_category_by_id(category_id):
    """
    HTML endpoint providing a form to delete a category
    """
    if not UserUtils.is_authenticated():
        UserUtils.set_preauthentication_url()
        flash('sign in to delete categories')
        return redirect('/login')

    category = session.query(Category).filter_by(id=category_id).one()

    if not Permissions.get_user_permissions_for_category(category).delete:
        flash('you may delete only empty categories you created')
        return redirect(url_for(
            'get_categories'))

    if request.method == 'POST':
        session.delete(category)
        session.commit()

        flash('category deleted')

        return redirect(url_for(
            'get_categories'))
    else:
        return UserUtils.render_user_template(
            'category_delete.html',
            category=category,
            page_title="%s %s Category" % ("Delete", category.name))
Ejemplo n.º 5
0
 def mutate(root, info, id):
     note = session.query(NotesModel).filter_by(id=id).first()
     session.delete(note)
     ok = True
     note = note
     session.commit()
     return deleteNote(ok=ok, note=note)
Ejemplo n.º 6
0
	def fetchGamelogs(self, player):

		# Delete all gamelogs for player
		for gamelog in player.gamelogs:
			session.delete(gamelog)

		scraper = Scraper()
		logs = scraper.getGamelogs(player.id)
		gamelogs = []
		for log in logs:
			gamelog = Gamelog()
			gamelog.player = player
			gamelog.game_id = log['game_id']
			gamelog.MIN = log['MIN']
			gamelog.FGM = log['FGM']
			gamelog.FGA = log['FGA']
			gamelog.FG_PCT = log['FG_PCT']
			gamelog.FG3M = log['FG3M']
			gamelog.FG3A = log['FG3A']
			gamelog.FG3_PCT = log['FG3_PCT'] 
			gamelog.FG3M = log['FTM']
			gamelog.FG3A = log['FTA']
			gamelog.FG3_PCT = log['FT_PCT'] 
			gamelog.OREB = log['OREB']
			gamelog.DREB = log['DREB']
			gamelog.REB = log['REB'] 
			gamelog.AST = log['AST']
			gamelog.STL = log['STL']
			gamelog.BLK = log['BLK']
			gamelog.TOV = log['TOV']
			gamelog.PTS = log['PTS'] 
			gamelog.DK = self.calcDK(log)
			gamelogs.append(gamelog)
		session.add_all(gamelogs)
		session.commit()
Ejemplo n.º 7
0
def deleta_pessoa(id):
    try:
        pessoa = Pessoas.query.filter_by(id=id).first()
        session.delete(pessoa)
        session.commit()
    except Exception as erro:
        print('O id {} não foi encontrado.'.format(id))
Ejemplo n.º 8
0
async def contact_delete(request):
    contact = session.query(Contact).filter_by(
        id=request.match_info.get('id')).first()
    session.delete(contact)
    session.commit()

    return web.json_response({'success': True})
Ejemplo n.º 9
0
    def delete(self, **kwargs):

        booking_id = int(kwargs.get('booking_id'))
        booking_obj = session.query(Booking).filter(
            Booking.id == booking_id).all()
        if len(booking_obj) == 0:
            return Response(json.dumps({'message': 'please check booking id'}),
                            mimetype='application/json')

        parking_spot_id = booking_obj[0].to_dict()['parking_spot_id']
        booking_obj_id = booking_obj[0].to_dict()['id']
        parking_obj = session.query(ParkingSpot).filter(
            ParkingSpot.id == parking_spot_id).all()
        parking_obj = parking_obj[0].to_dict()
        if booking_id == booking_obj_id and parking_obj['reserved'] == 1:
            obj = Booking.query.filter_by(id=booking_id).one()
            session.delete(obj)
            session.commit()
            parking_obj['reserved'] = 0
            parking_data = parking_obj
            parking = ParkingSpot(**parking_data)
            session.merge(parking)
            session.commit()
            return Response(json.dumps({
                'message': 'booking deleted successfully ',
                'id': booking_id
            }),
                            mimetype='application/json')
        else:
            return Response(json.dumps({'message': 'please check booking id'}),
                            mimetype='application/json')
Ejemplo n.º 10
0
def deleta_atividade(id):
    try:
        atividade = Atividades.query.filter_by(id=id).first()
        session.delete(atividade)
        session.commit()
    except Exception as erro:
        print('O id {} não foi encontrado.'.format(id))
Ejemplo n.º 11
0
 async def delete(self, instance_id):
     note = session.query(Note).filter(Note.id == instance_id).first()
     if not note:
         abort(404, message="Note {} doesn't exist".format(id))
     session.delete(note)
     session.commit()
     return Response(status=204)
Ejemplo n.º 12
0
 def mutate(root, info, task_id):
     task = Task(task_id=task_id)
     row = session.query(TaskModel).filter(
         TaskModel.task_id == task_id).one()
     session.delete(row)
     session.commit()
     return DeleteTask(task=task)
Ejemplo n.º 13
0
 async def delete(self, instance_id):
     instance = session.query(self.factory).filter(self.factory.id == instance_id).first()
     if not instance:
         abort(404, message="{0} {1} doesn't exist".format(self.collection_name, id))
     session.delete(instance)
     session.commit()
     return Response(status=204)
Ejemplo n.º 14
0
def category_delete(category=None):
    """ Delete a category.

    If the value of action is all, every item associated to the category will also be deleted.
    """
    if 'username' not in login_session:
        return Page(
            title="Unauthorized",
            contentmain="You are not authorized to see this page.").render()
    category = session.query(models.Category).get(category)
    if request.method == 'GET':
        return Page(title="Delete category " + category.name,
                    description="Deletion page for category " + category.name,
                    contentmain=flask.render_template(
                        'category_delete.html', category=category)).render()
    if request.method == 'POST':
        deleted = []
        if request.form['action'] == 'all':
            for i in category.load_items():
                deleted.append(i.name)
                session.delete(i)
        session.delete(category)
        session.commit()
        return Page(
            title="Category "+category.name+" was deleted",
            contentmain="The category was completely removed, including the following items: "+\
            ", ".join([i for i in deleted])+".").render()
Ejemplo n.º 15
0
    async def on_member_ban(self, guild, user):

        async for entry in guild.audit_logs(action=discord.AuditLogAction.ban,
                                            limit=1):
            latest = entry

        user = session.query(Ban).filter_by(userId=latest.user.id).first()
        if user is None:
            d = Ban(userId=latest.user.id,
                    savedTime=(time.time() + 120),
                    deleted=0)
            session.add(d)
            session.commit()
            user = session.query(Ban).filter_by(userId=latest.user.id).first()
        elif (user.savedTime - time.time()) <= 0:
            user.savedTime = (time.time() + 60)
            user.deleted = 0
            session.commit()
            user = session.query(Ban).filter_by(userId=latest.user.id).first()

        if (user.savedTime - time.time()) > 0:
            user.deleted = user.deleted + 1
            session.commit()
            user = session.query(Ban).filter_by(userId=latest.user.id).first()

        if user.deleted == 3:
            d = Raiders(userId=latest.user.id, offense='Ban')
            session.add(d)
            session.delete(user)
            session.commit()
            member = guild.get_member(user.userId)
            for role in member.roles[1:]:
                await member.remove_roles(role)
            role = discord.utils.get(guild.roles, name="Under Investigation")
            await member.add_roles(role)
Ejemplo n.º 16
0
 def show_delete_project_dialog(self, project_id):
     project = session.query(Project).filter_by(id=project_id).first()
     result = messagebox.askquestion('Delete project "%s"' % project.name, 'Are You Sure?', icon='warning')
     if result == 'yes':
         session.delete(project)
         session.commit()
         self.update_projects_list()
         self.back_to_main_screen()
Ejemplo n.º 17
0
 async def disable(self, ctx):
     """Disable Correios messages on the current channel."""
     result = session.query(correios_model).filter_by(guild_id=ctx.guild.id).first()
     if result:
         session.delete(result)
         session.commit()
         return await ctx.reply(f"Correios notification disabled.")
     return await ctx.reply(f"Correios isn't enabled.")
Ejemplo n.º 18
0
 async def disable(self, ctx):
     """Disable birthday messages on the current channel."""
     result = session.query(BDay).filter_by(guild_id=ctx.guild.id).first()
     if result:
         session.delete(result)
         session.commit()
         return await ctx.reply(f"Birthday notification disabled.")
     return await ctx.reply(f"Birthday isn't enabled.")
Ejemplo n.º 19
0
 def show_delete_task_dialog(self, task_id):
     task = session.query(Task).filter_by(id=task_id).first()
     project_id = task.project_id
     result = messagebox.askquestion('Delete task "%s"' % task.name, 'Are You Sure?', icon='warning')
     if result == 'yes':
         session.delete(task)
         session.commit()
         self.popup.destroy()
         self.refresh_project_screen(project_id)
Ejemplo n.º 20
0
def delete_test():
    tom = session.query(Teacher).get(1)
    print tom.students
    session.delete(tom)
    # lucy = session.query(Student).get(1)
    # session.delete(lucy)
    session.commit()
    print session.query(Teacher).all()
    print session.query(Student).all()
Ejemplo n.º 21
0
 def delete(self, page_id):
     page_model = session.query(Page).get(page_id)
     if page_model is not None and page_id != -1:
         #print(page_model.as_dictionary())
         session.delete(page_model)
         session.commit()
         return "success"
     else:
         return None
Ejemplo n.º 22
0
def main():
    global r
    logging.config.fileConfig(path_to_cfg)
    
    while True:
        try:
            r = praw.Reddit(user_agent=cfg_file.get('reddit', 'user_agent'))
            logging.info('Logging in as {0}'
                         .format(cfg_file.get('reddit', 'username')))
            r.login(cfg_file.get('reddit', 'username'),
                    cfg_file.get('reddit', 'password'))
            sr_dict = get_enabled_subreddits()            
            settings_dict = {subreddit: update_from_wiki(sr, cfg_file.get('reddit', 'owner_username')) for subreddit, sr in sr_dict.iteritems()}
            break
        except Exception as e:
            logging.error('ERROR: {0}'.format(e))
            traceback.print_exc(file=sys.stdout)

    while True:
        try:
            bans_to_remove = session.query(Ban).filter(Ban.unban_after <= datetime.utcnow()).all()
            logging.debug("\nChecking due bans")
            
            for ban in bans_to_remove:
                logging.debug("  Unbanning /u/{0} from /r/{1}".format(ban.user, ban.subreddit))
                sr = sr_dict[ban.subreddit]
                sr.remove_ban(ban.user)
                session.add(Log(ban.user, ban.subreddit, 'unban'))
                session.delete(ban)
            
            sleep(5)
            logging.info("\nLOOP\n")

            updated_srs = process_messages(sr_dict, settings_dict)
            if updated_srs:
                if any(subreddit not in sr_dict.keys() for subreddit in updated_srs):
                    # settings and mod subs out of sync, reload everything
                    settings_dict = sr_dict.copy()
                    sr_dict = get_enabled_subreddits(reload_mod_subs=True)
                else:
                    sr_dict = get_enabled_subreddits(reload_mod_subs=False)
                    
                settings_dict.update(updated_srs)
            
        except (praw.errors.ModeratorRequired,
                praw.errors.ModeratorOrScopeRequired,
                praw.requests.HTTPError) as e:
            if not isinstance(e, praw.requests.HTTPError) or e.response.status_code == 403:
                logging.info('Re-initializing due to {0}'.format(e))
                sr_dict = get_enabled_subreddits()
        except KeyboardInterrupt:
            raise
        except Exception as e:
            logging.error('ERROR: {0}'.format(e))
            import traceback
            traceback.print_exc()
Ejemplo n.º 23
0
def remove_user(uid):
    """
    Remove user by user id

    :param uid:
    :return void:
    """
    user = session.query(User).filter_by(id=uid).first()
    session.delete(user)
    session.commit()
Ejemplo n.º 24
0
def remove_request(request_id):
    """
    Remove the request by id, and return list of requests

    :param request_id: integer
    :return list:
    """
    session.delete(session.query(Request).filter_by(id=request_id).first())
    session.commit()
    return get_requests()
Ejemplo n.º 25
0
def del_user(client_id):
    found_client = session.query(Client).filter(
        Client.id == client_id).one_or_none()
    if found_client is None:
        return 'invalid id', 400
    if found_client.id != current_identity.id:
        return 'Access denied', 401
    session.delete(found_client)
    session.commit()
    return ''
Ejemplo n.º 26
0
    def drop(cls, jid):
        """ 删除一个成员
        Arguments:
            `jid`   -   成员jid
        """
        m = cls.get_one(jid)
        if m:
            session.delete(m)

        return
Ejemplo n.º 27
0
    def drop(cls, jid):
        """ 删除一个成员
        Arguments:
            `jid`   -   成员jid
        """
        m = cls.get_one(jid)
        if m:
            session.delete(m)

        return
Ejemplo n.º 28
0
 def show_delete_project_dialog(self, project_id):
     project = session.query(Project).filter_by(id=project_id).first()
     result = messagebox.askquestion('Delete project "%s"' % project.name,
                                     'Are You Sure?',
                                     icon='warning')
     if result == 'yes':
         session.delete(project)
         session.commit()
         self.update_projects_list()
         self.back_to_main_screen()
Ejemplo n.º 29
0
 async def delete(self, request):
     id = request.rel_url.query.get('id', '')
     part = session.query(Part).filter(Part.id == id).first()
     if not part:
         return Response(status=404,
                         body=json.dumps({'not found': 404}),
                         content_type='application/json')
     session.delete(part)
     session.commit()
     return Response(status=204)
Ejemplo n.º 30
0
 def delete(self):
     if not self.item:
         return
     self.item.button.setVisible(False)
     self.parent.items.remove(self.item)
     # 刷新显示
     self.parent.flush()
     # 更新数据库
     session.delete(self.item)
     session.commit()
     self.accept()
Ejemplo n.º 31
0
def remove_product_area(area_id):
    """
    Remove product area by id

    :param area_id: integer
    :return void:
    """
    product_area = session.query(ProductArea).filter_by(id=area_id).first()
    session.delete(product_area)
    session.commit()
    return get_product_areas()
Ejemplo n.º 32
0
def broadcast(bot, update, args):
    text = " ".join(args).replace("\\n", "\n")
    chats = session.query(Chat).all()
    for chat in chats:
        try:
            bot.send_message(chat_id=chat.id,
                             text=text,
                             parse_mode=ParseMode.MARKDOWN)
        except error.Unauthorized:  # User blocked the bot
            session.delete(chat)
    session.commit()
Ejemplo n.º 33
0
 def show_delete_task_dialog(self, task_id):
     task = session.query(Task).filter_by(id=task_id).first()
     project_id = task.project_id
     result = messagebox.askquestion('Delete task "%s"' % task.name,
                                     'Are You Sure?',
                                     icon='warning')
     if result == 'yes':
         session.delete(task)
         session.commit()
         self.popup.destroy()
         self.refresh_project_screen(project_id)
Ejemplo n.º 34
0
def remove_client(client_id):
    """
    Remove client by client id and return list of clients

    :param client_id: integer
    :return void:
    """
    client = query(Client).filter_by(id=client_id).first()
    session.delete(client)
    session.commit()
    return get_clients()
Ejemplo n.º 35
0
    def empty_status():
        all_status = session.query(Status).all()
        for status in all_status:
            try:
                session.delete(status)
            except:
                session.rollback()

        try:
            session.commit()
        except:
            session.rollback()
Ejemplo n.º 36
0
def callback_handler(callback_query):
    '''Handles user keystrokes'''
    message = callback_query.message
    text = callback_query.data

    # User presses "Cancel" button
    if text == 'Отмена':

        # Remove the buttons
        bot.edit_message_reply_markup(chat_id=message.chat.id,
                                      message_id=message.message_id,
                                      reply_markup=None)
        bot.send_message(message.chat.id,
                         text='Добавление нового места отменено.')
        reset_place(message)
        update_state(message, START)

    # User presses "Skip" button to skip adding image
    elif text == 'Пропустить':
        bot.edit_message_reply_markup(chat_id=message.chat.id,
                                      message_id=message.message_id,
                                      reply_markup=None)
        bot.send_message(message.chat.id, text='Хорошо, давай без фото.')
        update_state(message, CONFIRMATION)
        time.sleep(1)
        confirmation(message)

    # User presses "Confirm" button to save new place into database
    elif text == 'Да':
        bot.edit_message_reply_markup(chat_id=message.chat.id,
                                      message_id=message.message_id,
                                      reply_markup=None)

        # Check if user already have 10 saved places.
        # If he has delete one place, the first one that he saved
        places = session.query(Place).filter_by(user=message.chat.id).order_by(
            Place.id).all()
        if len(places) == 10:
            session.delete(places[0])

        # Save place from "PLACE ditionary" to database
        place_dict = get_place(message)
        place = Place(user=message.chat.id,
                      address=place_dict.get('address'),
                      latitude=place_dict.get('latitude'),
                      longitude=place_dict.get('longitude'),
                      image=place_dict.get('image'))
        session.add(place)
        session.commit()

        bot.send_message(message.chat.id, text="Новое место добалено!")
        reset_place(message)
        update_state(message, START)
Ejemplo n.º 37
0
    def empty_status():
        all_status = session.query(Status).all()
        for status in all_status:
            try:
                session.delete(status)
            except:
                session.rollback()

        try:
            session.commit()
        except:
            session.rollback()
Ejemplo n.º 38
0
 def set_offline(cls, jid):
     m = cls.get_one(jid)
     if not m: return False
     try:
         status = session.query(Status)\
                 .filter(and_(Status.resource == jid.resource,
                              Status.member == m)).one()
         m.status.pop(m.status.index(status))
         try:
             session.delete(status)
             session.commit()
         except:
             session.rollback()
     except NoResultFound:
         pass
Ejemplo n.º 39
0
def item_delete(item_title):
    item = session.query(Item).filter_by(
        title=item_title).one()
    user = session.query(User).filter_by(
        id=login_session.get('user_id')).one()
    if item.user is not None and item.user.id != user.id:
        return redirect(url_for('home'))
    if request.method == 'POST':
        img_filepath = vh.get_item_image_filepath(item.id)
        if os.path.isfile(img_filepath):
            os.remove(img_filepath)
        session.delete(item)
        session.commit()
        return redirect(url_for('home'))
    else:
        return render_template('item_delete.html',
                               item=item)
Ejemplo n.º 40
0
    def exec_command(self, request):
        """
        Execute a studio-related command.
        """

        studio = Studio.find_by(slug=request['studio'])

        try:
            command = request['command']
            flag = request['flag']

            if studio is None:
                return

            if command == "live":
                if flag == "on":
                    studio.jukebox.state = u"stopped"
                    liq.set_var("%s.jukebox.switch" % studio.slug, False)
                    liq.set_var("%s.plateau.volume" % studio.slug, 1.0)

                elif flag == "off":
                    liq.set_var("%s.plateau.volume" % studio.slug, 0.0)
                    liq.set_var("%s.jukebox.volume" % studio.slug, 1.0)

                else:
                    self.send_feedback(request, "error", 'flag should be on or off')

                self.send_feedback(request)

            elif command == "start jukebox":
                studio.jukebox.state = u"playing"
                liq.set_var("%s.jukebox.switch" % studio.slug, True)

                self.send_feedback(request)

                # TODO: Create here a fade-in

                #if stack.lastSentStatus and stack.lastSentStatus["mode"] == "live":
                #    liq.set_var("%s.jukebox.volume" % studio.slug, 0.3)
                if studio.jukebox.current_element is not None and \
                   studio.jukebox.current_element.action is not None and \
                   studio.jukebox.current_element.action.command == "end show":
                    # TODO: ORLY ?
                    self.exec_command({"command": "end show", "studio": studio.slug})
                    studio.jukebox.current_element.mark_as_done()
                    studio.jukebox.curpos += 1
                    studio.mark_as_changed()
                    self.exec_command({"command": "live", "flag": "off", "studio": studio.slug})

            elif command == "start jukebox and live off":
                self.exec_command({"command": "start jukebox", "studio": studio.slug})
                self.exec_command({"command": "live", "flag": "off", "studio": studio.slug})

                self.send_feedback(request)

            elif command == "enable recorder":
                # TODO Enable a recorder
                pass

            elif command == "disable recorder":
                # TODO Disable a recorder
                pass

            elif command == "start recorder":
                # TODO Start a recorder
                pass

            elif command == "start recorder":
                # TODO Stop a recorder
                pass

            elif command == "start recording":
                # TODO Start all enabled recoders
                pass

            elif command == "stop recording":
                # TODO Stop all enabled recorders
                pass

            elif command == "start show":
                studio.jukebox.state = u"playing"
                self.exec_command({"command": "start recording", "studio": studio.slug})
                self.exec_global({"command": "select", "studio": studio.slug})
                self.exec_command({"command": "start jukebox", "studio": studio.slug})

                self.send_feedback(request)

            elif command == "end show":
                studio.jukebox.state = u"stopped"
                liq.set_var("%s.running" % studio.slug, False)
                liq.set_var("%s.jukebox.switch" % studio.slug, False)
                self.exec_command({"command": "stop recording", "studio": studio.slug})

                if studio.selected:
                    studio.selected = False
                    self.exec_command({"command": "go back to perm"})

                self.send_feedback(request)

            elif command == "bed" and flag == "on":
                liq.set_var("%s.bed.switch" % studio.slug, True)
                liq.send_command("%s-bed-switch.skip" % studio.slug)

                self.send_feedback(request)

            elif command == "bed" and flag == "off":
                liq.set_var("%s.bed.switch" % studio.slug, False)

                self.send_feedback(request)

            elif command == "skip":
                liq.send_command("%s-jukebox-stereo.skip" % studio.slug)
                studio.jukebox.current_element.mark_as_done()
                studio.jukebox.curpos += 1

                self.send_feedback(request)

            elif command == "set var":
                liq.set_var(request["key"], request["value"])

            elif command == "push":
                element = PlaylistElement.forge(request["element_type"], int(request["element_id"]))
                element.status = u"ready"

                studio.jukebox.add_element(element)

                self.send_feedback(request)

            elif command == "insert":
                if "action_id" in request:
                    element = session.query(Action).get(int(request["action_id"]))
                elif "media_id" in request:
                    element = session.query(Media).get(int(request["media_id"]))
                else:
                    # ERROR
                    return

                element.status = u"ready"

                studio.jukebox.insert_element(element, int(request["position"]))

                self.send_feedback(request)

            elif command == "remove":
                element = PlaylistElement.find_by(uid=int(request["element_id"]))

                studio.jukebox.remove_element(element)

                session.delete(element)

                self.send_feedback(request)

            elif command == "move":
                element = PlaylistElement.find_by(uid=int(request["element_id"]))

                studio.jukebox.move_element(element, int(request["position"]))

                self.send_feedback(request)

            elif command == "debug":
                if "action" in request:
                    if request["action"] == "set position":
                        studio.jukebox.curpos = int(request["position"])

                    elif request["action"] == "reload current":
                        if studio.jukebox.current_element is not None and \
                           studio.jukebox.current_element.status == "loaded":
                            studio.jukebox.current_element.status = "ready"
                            studio.mark_as_changed()

                    elif request["action"] == "force unselect":
                        studio.selected = False

                    else:
                        self.send_feedback(request, "error", "unknown action %s for debug" % request["action"])
                        return
                else:
                    self.send_feedback(request, "error", "action is required")
                    return

                self.send_feedback(request)

            else:
                self.send_feedback(request, "error", "Unknown command '%s', ignored." % command)

                sylog("Commande %s inconnue ; ignorée." % command)

        except SyCantMove as details:

            self.send_feedback(request, "error", details.message)

        if studio:
            studio.mark_as_changed()

        session.add(studio)
        session.commit()
Ejemplo n.º 41
0
# notice that we flush here, but we don't commit. The change won't actually
# make it to the db so when we rerun this script, it'll still report 200/201
session.flush()

ct = Actor.query.count()
plog("Inserted Rick, New Count: {0} ".format(ct))


"""
Homework

Now that the new actor 'Rick' is added, remove him and verify that you get back
200 actors in the database
"""

session.delete(rick)
ct = Actor.query.count()
plog("Actor Count via .count(): {0} ".format(ct))

assert(ct == 200)


"""
Homework:

Tweak the actor class and add some helpful methods for:

a. Display the actors full name via a single method

"""
Ejemplo n.º 42
0
 def delete(self, pk):
     endereco = session.query(Endereco).filter(Endereco.cep == pk)[0]
     session.delete(endereco)
     session.commit()
Ejemplo n.º 43
0
def deleteExistingItem(item):
    session.delete(item)
    return session.commit()
Ejemplo n.º 44
0
def process_messages(sr_dict, settings_dict):
    """Processes the bot's messages looking for invites/commands."""
    global r
    stop_time = int(cfg_file.get('reddit', 'last_message'))
    owner_username = cfg_file.get('reddit', 'owner_username')
    new_last_message = None
    update_srs = set()
    invite_srs = set()
    sleep_after = False

    logging.debug('Checking messages')

    try:
        for message in r.get_inbox():
            logging.debug("Reading message from {0}".format(message.author))
            # use exceptions to send error message reply to user
            try:
                if int(message.created_utc) <= stop_time:
                    logging.debug("  Message too old")
                    break
    
                if message.was_comment:
                    logging.debug("  Message was comment")
                    continue

                # don't get stuck in conversation loops with other bots
                if message.author.name.lower() in ['reddit', 'ban_timer', 'mod_mailer', 'f7u12_hampton', 'botwatchman']:
                    continue

                if not new_last_message:
                    new_last_message = int(message.created_utc)
    
                # if it's a subreddit invite
                if (message.subreddit and
                        message.subject.startswith('invitation to moderate /r/')):
                    message.mark_as_read()
                    raise UserspaceError("/u/ban_timer is currently in closed beta. Message the mods of /r/ban_timer for access.")
                    try:
                        subreddit = message.subreddit.display_name.lower()
                        # workaround for praw clearing mod sub list on accept
                        mod_subs = r.user._mod_subs
                        r.accept_moderator_invite(subreddit)
                        r.user._mod_subs = mod_subs
                        r.user._mod_subs[subreddit] = r.get_subreddit(subreddit)
                        logging.info('Accepted mod invite in /r/{0}'
                                     .format(subreddit))
                    except praw.errors.InvalidInvite:
                        pass
                # if it's a control message
                elif '/' in message.subject:
                    logging.debug("  Control Message")
                    sr_name = message.subject[message.subject.rindex('/')+1:].lower()
                    logging.debug("  /r/{0}".format(sr_name))
    
                    if sr_name in sr_dict:
                        sr = sr_dict[sr_name]
                    else:
                        logging.debug("  unknown subreddit /r/{0}".format(sr_name))
                        message.mark_as_read()
                        raise UserspaceError("/r/{0} is not registered with /u/ban_timer. "
                                        "Please invite /u/ban_timer to moderate /r/{0} "
                                        "with at least the `access` permission.".format(subreddit))
    
                    if (message.author in sr.get_moderators() or
                        message.author.name == owner_username):
                        pass
                    else:
                        logging.debug("  unauthorized user /u/{0}".format(message.author.name))
                        message.mark_as_read()
                        raise UserspaceError("You do not moderate /r/{0}".format(sr_name))
    
                    if message.body.strip().lower() == 'update':
                        if (message.author.name == owner_username or
                                message.author in sr.get_moderators()):
                            logging.debug("  update message")
                            update_srs.add((sr_name.lower(), message.author.name))
                    else:
                        logging.debug("  ban message")
                        
                        # add or remove a ban
                        args = message.body.strip().split("\n")
                        args = filter(lambda arg: arg.strip() != '', args)
                        user = args[1]
        
        #                 for mod in permissions:
        #                     print mod.permissions
        
                        if args[0].lower() == 'ban':
                            duration = args[2].lower() if 2 < len(args) else None
                            duration = duration if duration != 'forever' else None
                            note = args[3] if 3 < len(args) else None
                                                        
                            logging.debug("  Banning /u/{0}".format(user))
                            ban = Ban(sr_name, user, message.author.name, duration, note)
                            sr.add_ban(ban.user, note="<{0}> {1} | /u/ban_timer for /u/{2}".format(ban.duration, ban.note, ban.banned_by))
#                             sr.add_ban(ban.user)
                            session.add(ban)
                            message.mark_as_read()
                            raise UserspaceReply("Successfully banned /u/{0} from /r/{1} for {2}.".format(user, sr_name, duration))
                        elif args[0].lower() == 'unban':
                            logging.debug("  Unbanning /u/{0}".format(user))
                            ban = session.query(Ban).filter(Ban.user==user, Ban.subreddit==sr_name).one()
                            sr.remove_ban(ban.user)
                            session.delete(ban)
                            message.mark_as_read()
                            raise UserspaceReply("Successfully unbanned /u/{0} from /r/{1}".format(user, sr_name))
                        else:
                            message.reply('Unrecognized command syntax. Please check the command syntax documentation.')
                elif (message.subject.strip().lower() == 'sleep' and
                      message.author.name == owner_username):
                    logging.debug("  Sleep Message")
                    sleep_after = True
                    message.mark_as_read()
                else:
                    logging.debug("  Unknown Message")
            except UserspaceReply as e:
                message.reply("{0}".format(e))
            except UserspaceError as e:
                message.reply("Error: {0}".format(e))
        
        # do requested updates from wiki pages
        updated_srs = {}
        for subreddit, sender in update_srs:
            new_settings = update_from_wiki(r.get_subreddit(subreddit), r.get_redditor(sender))
            if new_settings:
                updated_srs[subreddit] = new_settings
                logging.info('Updated from wiki in /r/{0}'.format(subreddit))
            else:
                logging.info('Error updating from wiki in /r/{0}'
                             .format(subreddit))

        if sleep_after:
            logging.info('Sleeping for 10 seconds')
            sleep(10)
            logging.info('Sleep ended, resuming')

    except Exception as e:
        logging.error('ERROR: {0}'.format(e))
        raise
    finally:
        # update cfg with new last_message value
        if new_last_message:
            cfg_file.set('reddit', 'last_message', str(new_last_message))
            cfg_file.write(open(path_to_cfg, 'w'))
        # push bans to the database
        session.commit()


    return updated_srs
Ejemplo n.º 45
0
def delete_todo(request, todoid):
    todo = session.query(ToDo).filter_by(todoid=todoid).first()
    if session.delete(todo):
        session.commit()
        return redirect("/")