Exemple #1
0
    def orderSuccess(self, pay_order_id=0, params=None):
        try:
            pay_order_info = session.query(PayOrder).filter_by(
                id=pay_order_id).first()
            if not pay_order_info or pay_order_info.status not in [-8, -7]:
                return True

            pay_order_info.pay_sn = params[
                'pay_sn'] if params and 'pay_sn' in params else ''
            pay_order_info.status = 1
            pay_order_info.express_status = -7
            pay_order_info.updated_time = getCurrentDate()
            pay_order_info.pay_time = getCurrentDate()
            session.add(pay_order_info)

            pay_order_items = session.query(PayOrderItem).filter_by(
                pay_order_id=pay_order_id).all()
            for order_item in pay_order_items:
                tmp_model_sale_log = FoodSaleChangeLog()
                tmp_model_sale_log.food_id = order_item.food_id
                tmp_model_sale_log.quantity = order_item.quantity
                tmp_model_sale_log.price = order_item.price
                tmp_model_sale_log.member_id = order_item.member_id
                tmp_model_sale_log.created_time = getCurrentDate()
                session.add(tmp_model_sale_log)

            session.commit()
        except Exception as e:
            session.rollback()
            print(e)
            return False

        return True
Exemple #2
0
    def __commit(self):
        """
        """
        try:
            handles = [i.handle for i in self.motifs]
            if len(handles) != len(set(handles)):
                pdb.set_trace()

            r = session.query(NR_release).filter(NR_release.id == self.release.id).first()
            if not r:
                session.add(self.release)

            session.add_all(self.motifs)
            session.add_all(self.loops)
            session.add_all(self.history)
            session.add_all(self.intersection)
            session.add_all(self.release_diff)

            session.commit()
            logging.info("Successful update")
        except sqlalchemy.exc.SQLAlchemyError, e:
            logging.error("Update failed. SQLAlchemy error. Rolling back.")
            logging.error(str(e))
            session.rollback()
            self.remove_release(self.release.id)
            sys.exit()
Exemple #3
0
    def set_online(cls, jid, show=None):
        """ 设置成员在线
        Arguments:
            `jid`   -   成员jid
            `show`  -   stanza.show
        """
        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()
            status.show = show
        except NoResultFound:
            status = Status(show, jid.resource)
            if m.status:
                m.status.append(status)
            else:
                m.status = [status]
        finally:
            try:
                session.commit()
            except:
                session.rollback()

        return True
Exemple #4
0
    def set_info(cls, jid, key, value):
        """ 设置成员选项
        Arguments:
            `jid`   -   jid
            `key`   -   选项键
            `value` -   选项值
        """
        m = cls.get_one(jid)
        try:
            info = session.query(Info).filter(
                and_(Info.key == key, Info.member == m,
                     Info.is_global == 0)).one()
            info.value = value
        except NoResultFound:
            info = Info(key, value)
            if m.infos:
                m.infos.append(info)
            else:
                m.infos = [info]
        finally:
            try:
                session.commit()
            except:
                session.rollback()

        return info
Exemple #5
0
def create_or_update_existing_account(facebook_account):
    user = session \
        .query(User) \
        .filter_by(social_profile_id=facebook_account.id,
                   social_profile_type='facebook') \
        .first()

    if not user:
        try:
            user = User(social_profile_id=facebook_account.id,
                        social_profile_type='facebook',
                        first_name=facebook_account.first_name,
                        last_name=facebook_account.last_name,
                        profile_image=facebook_account.profile_image)
            session.add(user)
            session.flush()
            session.commit()
        except IntegrityError:
            session.rollback()
            logging.warning('User already exists in the system!')

            user = session \
                .query(User) \
                .filter_by(social_profile_id=facebook_account.id,
                           social_profile_type='facebook') \
                .first()

    return {
        'token': savory_token_client.create_savory_token(user)
    }, HTTP_STATUS_OK
Exemple #6
0
async def subscribe(request):
    schema = SubscribeSchema()
    data, error = schema.load(request.form)  # todo 传入空的字符串不能required不能识别
    if error:
        for key, value in error.items():
            error[key] = key + ':' + ','.join(value)
        return resp_error(';'.join(error.values()))

    subscriber = Subscriber()
    subscriber.nick_name = data['nick_name']
    subscriber.email = data['email']
    subscriber.resources = data['resources']
    session.add(subscriber)
    try:
        session.commit()
        session.close()
    except Exception as e:
        session.rollback()
        session.close()
        return resp_error(e.args)
    email_ = await init_email(data['nick_name'], data['email'],
                              data['resources'])
    if not email_:
        return resp_ok('您已经成功订阅')
    else:
        return resp_error(email_)
Exemple #7
0
 def modify_nick(cls, jid, nick):
     """ 修改成员昵称
     Arguments:
         `jid`   -   jid
         `nick`  -   新昵称
     Return:
         False   // 昵称已存在
         True    // 更改昵称成功
     """
     m = cls.get_one(jid)
     if not m: return False
     if m:
         exists = cls.get_with_nick(nick)
         if exists:
             return False
         m.nick = nick
         m.last_change = now()
         cls.set_info(
             jid, "change_nick_times",
             int(cls.get_info(jid, "change_nick_times", 0).value) + 1)
         try:
             session.commit()
         except:
             session.rollback()
         return True
def guildwars2_filter_cm(comments, array_anet_names):
    for cm in comments:
        logging.info("comment")
        if cm.author.name in array_anet_names:
            logging.info("comment from anet: " + cm.name)
            row = bot_submissions()
            title = cm.link_title
            if (len(title) + len(cm.author.name) + 3) > 300:
                title = title[: 300 - len(cm.author.name) - 3 - 3]
                title += "..."
            row.title = title + " [" + cm.author.name + "]"
            row.type = "link"
            row.subreddit = "gw2devtrack"
            row.submitted = False
            row.content = cm.permalink.replace("//www.reddit.com", "//np.reddit.com") + "?context=1000"
            session.add(row)
        continue  # DISALLOWS COMMENTS TO BE PARSED FPR GW2 LINKS
        if re.search("http.*?:\/\/.*?guildwars2.com\/", cm.body) != None:
            logging.info("comment with gw2 link: " + cm.name)
            all_links = re.findall("http.*?:\/\/.*?guildwars2.com\/[^ \])\s]*", cm.body)
            for link in all_links:
                if link != "":
                    try:
                        prepare_comment(cm.name, False, guildwars2.locate_origin(link))
                    except Exception as e:
                        logging.error(e)
                        session.rollback()
                    else:
                        session.commit()
Exemple #9
0
    def set_info(cls, jid, key, value):
        """ 设置成员选项
        Arguments:
            `jid`   -   jid
            `key`   -   选项键
            `value` -   选项值
        """
        m = cls.get_one(jid)
        try:
            info = session.query(Info).filter(and_(Info.key == key,
                                                   Info.member == m,
                                                   Info.is_global == 0)).one()
            info.value = value
        except NoResultFound:
            info = Info(key, value)
            if m.infos:
                m.infos.append(info)
            else:
                m.infos = [info]
        finally:
            try:
                session.commit()
            except:
                session.rollback()

        return info
def create_or_update_account(updated_account):
    existing_account = session \
        .query(Account) \
        .filter_by(google_id=updated_account.google_id) \
        .first()

    if not existing_account:
        try:
            logging.info("Account does not exist in the system!")
            session.add(updated_account)
            session.flush()
            session.commit()

            existing_account = updated_account
        except IntegrityError:
            session.rollback()
            logging.info('User already exists in the system!')

            existing_account = session \
                .query(Account) \
                .filter_by(google_id=updated_account.google_id) \
                .first()

    return {
        'token': jwt_token_utils.create_jwt_token(existing_account)
    }, HTTPStatus.OK
Exemple #11
0
    def set_online(cls, jid, show=None):
        """ 设置成员在线
        Arguments:
            `jid`   -   成员jid
            `show`  -   stanza.show
        """
        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()
            status.show = show
        except NoResultFound:
            status = Status(show, jid.resource)
            if m.status:
                m.status.append(status)
            else:
                m.status = [status]
        finally:
            try:
                session.commit()
            except:
                session.rollback()

        return True
Exemple #12
0
    def addBasePokemonToUser(self, addRequestDict):
        try:
            userId = addRequestDict.get("userId")
            pokedexId = addRequestDict.get("pokedexId")

            pokemon = self.pokemonService.getPokemonByPokedexId(pokedexId)
            if pokemon is None:
                raise Exception("Pokemon with pokedexId:" + str(pokedexId) +
                                " was not found!")

            userPokemon = UserPokemon()
            userPokemon.userId = userId
            userPokemon.pokedexId = pokedexId
            userPokemon.name = pokemon.name
            userPokemon.nickname = addRequestDict.get("nickname", pokemon.name)
            userPokemon.height = pokemon.height
            userPokemon.sprites = pokemon.sprites
            userPokemon.weight = pokemon.weight
            userPokemon.hunger = sysConst.MAX_HUNGER
            userPokemon.maxHp = pokemon.hp
            userPokemon.currentHp = pokemon.hp
            userPokemon.attack = pokemon.attack
            userPokemon.defense = pokemon.defense
            userPokemon.specialAttack = pokemon.specialAttack
            userPokemon.specialDefense = pokemon.specialDefense
            userPokemon.speed = pokemon.speed
            userPokemon.healthState = sysConst.ALIVE_POKEMON_STATE

            session.add(userPokemon)
            session.flush()
            session.commit()
            return userPokemon.id
        except Exception as e:
            session.rollback()
            raise e
def guildwars2_filter_cm(comments, array_anet_names):
    for cm in comments:
        logging.info("comment")
        if cm.author.name in array_anet_names:
            logging.info("comment from anet: " + cm.name)
            row = bot_submissions()
            title = cm.link_title
            if (len(title) + len(cm.author.name) + 3) > 300:
                title = title[:300 - len(cm.author.name) - 3 - 3]
                title += '...'
            row.title = title + ' [' + cm.author.name + ']'
            row.type = 'link'
            row.subreddit = 'gw2devtrack'
            row.submitted = False
            row.content = cm.permalink.replace('//www.reddit.com','//np.reddit.com') + '?context=1000'
            session.add(row)
        continue # DISALLOWS COMMENTS TO BE PARSED FPR GW2 LINKS
        if re.search('http.*?:\/\/.*?guildwars2.com\/', cm.body) != None:
            logging.info("comment with gw2 link: " + cm.name)
            all_links = re.findall('http.*?:\/\/.*?guildwars2.com\/[^ \])\s]*', cm.body)
            for link in all_links:
                if link != '':
                    try:
                        prepare_comment(cm.name, False, guildwars2.locate_origin(link))
                    except Exception as e:
                        logging.error(e)
                        session.rollback()
                    else:
                        session.commit()
Exemple #14
0
def home(request):

    session.rollback()
    session.commit()

    filter_date = datetime.datetime.utcnow() - datetime.timedelta(seconds=60)
    
    wemo_device_count = session.query(func.count(distinct(WemoTimeSeries.device_name))).first()[0]
    wemo = session.query(WemoTimeSeries).order_by(WemoTimeSeries.datetime.desc()).limit(wemo_device_count).all()

    hue_device_count = session.query(func.count(distinct(HueTimeSeries.device_name))).first()[0]
    hue = session.query(HueTimeSeries).order_by(HueTimeSeries.datetime.desc()).limit(hue_device_count).all()

    nest = session.query(NestTimeSeries).order_by(NestTimeSeries.datetime.desc()).limit(1).first()

    apex = session.query(ApexTimeSeries).filter(ApexTimeSeries.value != None).filter(ApexTimeSeries.datetime>filter_date).all()
   
    roomba_device_count = session.query(func.count(distinct(RoombaTimeSeries.device_name))).first()[0]
    roomba = session.query(RoombaTimeSeries).order_by(RoombaTimeSeries.datetime.desc()).limit(roomba_device_count).all()
    
    f = Flower()
    flower = f.get_data(.001)[-1]
    
    return render(request, template_name='home.html', dictionary={'wemo': wemo, 
                                                                  'hue': hue, 
                                                                  'nest': nest,
                                                                  'apex': apex,
                                                                  'roomba': roomba,
                                                                  'flower': flower,
                                                                 })
Exemple #15
0
def websocket_to_database():
    try:
        websocket = yield from websockets.connect("wss://ws-feed.exchange.coinbase.com")
    except gaierror:
        db_logger.error('socket.gaierror - had a problem connecting to Coinbase feed')
        return
    yield from websocket.send('{"type": "subscribe", "product_id": "BTC-USD"}')
    while True:
        message = yield from websocket.recv()
        if message is None:
            file_logger.error('Websocket message is None!')
            break
        try:
            message = json.loads(message)
        except TypeError:
            db_logger.error('JSON did not load, see ' + str(message))
            continue
        if message['type'] != 'match':
            continue
        new_message = Messages()
        for key in message:
            if hasattr(new_message, key):
                setattr(new_message, key, message[key])
            else:
                db_logger.error(str(key) + ' is missing, see ' + str(message))
                continue
        try:
            session.add(new_message)
            session.commit()
        except IntegrityError:
            session.rollback()
        except DatabaseError:
            file_logger.error('Database Error')
            session.rollback()
Exemple #16
0
def main():
    global r
    logging.config.fileConfig(path_to_cfg)
    # the below only works with re2
    # re.set_fallback_notification(re.FALLBACK_EXCEPTION)

    # which queues to check and the function to call
    queue_funcs = {'report': 'get_reports',
                   'spam': 'get_mod_queue',
                   'submission': 'get_new',
                   'comment': 'get_comments'}

    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, cond_dict = initialize(queue_funcs.keys())
            break
        except Exception as e:
            logging.error('ERROR: {0}'.format(e))
    
    run_counter = 0
    while True:
        run_counter += 1
        try:
            # only check reports every 10 runs
            # sleep afterwards in case ^C is needed
            if run_counter % 10 == 0:
                check_queues(queue_funcs, sr_dict, cond_dict)

                Condition.clear_standard_cache()
                if process_messages():
                    sr_dict, cond_dict = initialize(queue_funcs.keys(),
                                                    reload_mod_subs=False)
                logging.info('Sleeping ({0})'.format(datetime.now()))
                sleep(5)
                run_counter = 0
            else:
                check_queues({q: queue_funcs[q]
                              for q in queue_funcs
                              if q != 'report'},
                             sr_dict, cond_dict)
                if process_messages():
                    sr_dict, cond_dict = initialize(queue_funcs.keys(),
                                                    reload_mod_subs=False)
        except (praw.errors.ModeratorRequired,
                praw.errors.ModeratorOrScopeRequired,
                HTTPError) as e:
            if not isinstance(e, HTTPError) or e.response.status_code == 403:
                logging.info('Re-initializing due to {0}'.format(e))
                sr_dict, cond_dict = initialize(queue_funcs.keys())
        except KeyboardInterrupt:
            raise
        except Exception as e:
            logging.error('ERROR: {0}'.format(e))
            session.rollback()
 def addPokemon(self, newPoke):
     try:
         session.add(newPoke)
         session.commit()
         return newPoke.id
     except Exception as e:
         session.rollback()
         raise e
Exemple #18
0
 def addUser(self, newUser):
     try:
         newUser.salt = randint(0, 10000000)
         session.add(newUser)
         session.commit()
         return newUser.id
     except Exception as e:
         session.rollback()
         raise e
Exemple #19
0
def submit_post():

    new_post_submission = NewPostSubmissionForm()

    #TODO:
    #Add logic to determine user, and post to the appropriate page.
    #If no user is logged in, then it should post the guest page.
    #Limit number of posts by IP if not logged in. (3 posts should be enough for posting.)

    #Do stuff with the form data here:
    if new_post_submission.validate_on_submit():
        print("Form submitted!")

        post_title = new_post_submission.title.data
        post_body = new_post_submission.post_body.data
        post_image_caption = new_post_submission.image_caption.data

        post_image_file_name = new_post_submission.image.data.filename
        #Sanitizing input.
        post_image_file_name = post_image_file_name.replace(" ", "")

        # Adding final new line to file.
        post_body += '\n'

        # TODO:
        # Humans separate paragraphs by 2 new lines.
        # Need to convert this to 1 new line after post has been submitted.

        post_image = new_post_submission.image.data

        post_image_file_name = no_duplicate_files(
            post_image_file_name, './static/images/post_images/')

        post_image.save(f'./static/images/post_images/{post_image_file_name}')

        new_post = Posts(title=post_title,
                         post_body=post_body,
                         image_file_name=post_image_file_name,
                         image_caption=post_image_caption)

        try:
            session.add(new_post)
            session.commit()
            print("A new post has been added to db!")

        except Exception as error:
            print(error)
            session.rollback()

        new_post_id = session.query(Posts).order_by(desc(Posts.id)).first().id

        return redirect(f"/post/{new_post_id}")

    else:
        return render_template('submit.html',
                               new_post_submission=new_post_submission)
Exemple #20
0
    def add_history(cls, jid, to_jid, content):
        m = cls.get_one(jid)
        m.last_say = now()
        if m.history:
            m.history.append(History(to_jid, content))
        else:
            m.history = [History(to_jid, content)]

        try:
            session.commit()
        except:
            session.rollback()
Exemple #21
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()
Exemple #22
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()
Exemple #23
0
    def add_history(cls, jid, to_jid, content):
        m = cls.get_one(jid)
        m.last_say = now()
        if m.history:
            m.history.append(History(to_jid, content))
        else:
            m.history = [History(to_jid, content)]

        try:
            session.commit()
        except:
            session.rollback()
Exemple #24
0
 def _crash(self, msg=None):
     """
     """
     if msg:
         logging.critical(msg)
     try:
         session.rollback()
         logging.critical('Session rolled back')
     except:
         logging.critical('Session rollback failed')
     self.send_report()
     sys.exit(2)
Exemple #25
0
def update_peers():
    peers = session.query(Peer).all()
    for peer in peers:
        try:
            height = get_height(peer.url)
            peer.height = height
            if height is not None:
                peer.updated_at = datetime.utcnow()
            session.add(peer)
            session.commit()
        except:
            print('Error {}'.format(peer.url))
            session.rollback()
Exemple #26
0
 def __release_diff_commit(self):
     """
     """
     try:
         session.add_all(self.release_diff)
         session.query(NR_handle).delete()
         session.commit()
         logging.info("Successful update")
     except sqlalchemy.exc.SQLAlchemyError, e:
         logging.error("Update failed. SQLAlchemy error. Rolling back.")
         logging.error(str(e))
         session.rollback()
         sys.exit()
Exemple #27
0
 async def _retry_error_pan(self):
     while self.fail_pan_info:
         pan_info = self.fail_pan_info.pop()
         location = Location(episode=pan_info[0],
                             url=pan_info[1],
                             resource=pan_info[2])
         session.add(location)
         try:
             session.commit()
         except Exception:
             session.rollback()
             self.fail_pan_info.append(pan_info)
     else:
         session.close()
def update_resource():
    try:
        transform = BaseTransForm()

        for name in transform.methods__():
            args = get_func_args(name, transform)
            instance = session.query(TransformModel).filter_by(
                name=name).first()
            tmp_func = getattr(transform, name)
            for property_name, value in vars(transform).items():
                if property_name.find(name) != -1:  # 方法和方法的属性设置
                    if not instance:
                        function_model = TransformModel(
                            name=name,
                            module_id=value["module_id"],
                            args=str(args),
                            is_primary_key=value["primary_key"],
                            description=tmp_func.__doc__)
                        session.add(function_model)
                    else:
                        session.query(TransformModel).filter_by(
                            name=name).update({
                                "args":
                                str(args),
                                "module_id":
                                value["module_id"],
                                "is_primary_key":
                                value["primary_key"],
                                "description":
                                tmp_func.__doc__
                            })

        # source = '''{"connect": {"database": "db_mid_bigdata", "ip": "192.168.1.100", "password": "******", "port": 3306,
        #     "user": "******"}, "id": 2, "sql": "select * from test_apply where WJID != 'NULL';", "type": 1}'''
        # target = "{'connect': {'database': 'db_mid_bigdata', 'ip': '192.168.1.100', 'password': '******'," \
        #          " 'port': 3306, 'user': '******'}, 'id': 2, 'table': 'wj_answer_copy1', 'type': 1}"
        # methods = "[{'translate': {}}]"
        # primary_key = "{'to_primary_field': 'ID'}"
        # task_instance = session.query(TaskModel).filter_by(name="档案库任务").first()
        # if not task_instance:
        #     task = TaskModel(name="档案库任务",source=source,methods=methods,target=target,primary_key=primary_key)
        #     session.add(task)

        try:
            session.commit()
        except Exception as e:
            session.rollback()
            traceback.print_exc()  # TODO 启动日志记录
    except Exception as e:
        traceback.print_exc()  # TODO 启动日志记录
Exemple #29
0
 def post(self, *args, **kwargs):
     username = self.get_argument('username')
     email = self.get_argument('email')
     password = self.get_argument('password')
     user = User(username=username, email=email, password=password)
     session.rollback()
     session.add(user)
     session.commit()
     token = user.generate_confirmation_token()
     message = Loader('templates').load('mail_template.html').generate(
         title="Tornado-blog", username=username, content=token)
     send_email(msg_to=user.email, message=message)
     self.render('login.html',
                 message='An email has been sent to you email-address!')
Exemple #30
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
Exemple #31
0
 async def _retry_error_page(self):
     while self.fail_page_info:
         page_info = self.fail_page_info.pop()
         resource = Resources(name=page_info[0],
                              owner='电波字幕组',
                              stype='tvshow',
                              original=page_info[1])
         session.add(resource)
         try:
             session.commit()
         except Exception:
             session.rollback()
             self.fail_page_info.append(page_info)
     else:
         session.close()
Exemple #32
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
Exemple #33
0
async def add_user(request):
    try:
        data = await request.json()
        u = User(data['username'],
                 data['firstname'],
                 data['lastname'],
                 int(data['groupusers_id']))
        u.set_password(data['password'])
        session.add(u)
        session.commit()
        response_obj = {'status': 'success'}
        return json_response(response_obj, status=200)
    except Exception as e:
        response_obj = {'status': 'failed', 'reason': str(e)}
        session.rollback()
        return json_response(response_obj, status=500)
Exemple #34
0
    def __store_unit_ids(self, unit_ids):
        """
        """
        logging.info('Importing unit ids')
        for (old_id, new_id) in unit_ids:
            # old id 1EKA_AU_1_B_8_C_
            (pdb_id,au_ba,model,chain,seq_id,comp_id,ins_code) = old_id.split('_')
            pdb_file = 'pdb' if au_ba == 'AU' else 'pdb' + au_ba[2:] # BA1, BA10

            underscores = new_id.count('|')
            if underscores == 8: # all fields present
                (pdb_id,model,chain,comp_id,seq_id,atom,alt_id,ins_code,sym_op) = new_id.split('|')
            elif underscores == 7: # default sym_op
                (pdb_id,model,chain,comp_id,seq_id,atom,alt_id,ins_code) = new_id.split('|')
                sym_op = '1_555'
            elif underscores == 4: # default sym_op, ins_code, alt_id, all atoms
                (pdb_id,model,chain,comp_id,seq_id) = new_id.split('|')
                sym_op   = '1_555'
                ins_code = ''
                alt_id   = ''
                atom     = ''
            else:
                msg = 'Unknown id format %s' % new_id
                logging.critical(msg)
                session.rollback()
                self._crash(msg)

            U = PdbUnitIdCorrespondence(old_id   = old_id,
                                        unit_id  = new_id,
                                        pdb      = pdb_id,
                                        model    = model,
                                        chain    = chain,
                                        seq_id   = seq_id,
                                        atom     = atom,
                                        comp_id  = comp_id,
                                        alt_id   = alt_id,
                                        ins_code = ins_code,
                                        sym_op   = sym_op,
                                        pdb_file = pdb_file)
            try:
                session.add(U)
            except:
                pass
        session.commit()
        logging.info('Ids successfully imported')
def main():
    global r
    logging.config.fileConfig(path_to_cfg, disable_existing_loggers=False)
    bot = Polarbyte(cfg_file)
    forceAuthAgain = False
    while True:
        try:
            bot.check()
            bot.collect()
            bot.process_posts()
            bot.submit()
        except praw.errors.OAuthScopeRequired as e:
            logging.error(e)
            bot.forceAuthenticationAgain = True
        except Exception as e:
            print(vars(e))
            logging.error(e)
            session.rollback()
Exemple #36
0
def main():
    global r
    logging.config.fileConfig(path_to_cfg, disable_existing_loggers=False)
    bot = Polarbyte(cfg_file)
    forceAuthAgain = False
    while (True):
        try:
            bot.check()
            bot.collect()
            bot.process_posts()
            bot.submit()
        except praw.errors.OAuthScopeRequired as e:
            logging.error(e)
            bot.forceAuthenticationAgain = True
        except Exception as e:
            print(vars(e))
            logging.error(e)
            session.rollback()
Exemple #37
0
    def add(cls, jid, nick = None, show = None):
        """ 添加一个成员
        Arguments:
            `jid`   -   成员jid
            `nick`  -   昵称
            `show`  -   stanze.show
        """
        if cls.get_one(jid):
            return
        m = Member(jid, nick)
        m.status = [Status(show, jid.resource)]
        try:
            session.add(m)
            session.commit()
        except:
            session.rollback()

        return m
Exemple #38
0
    def add(cls, jid, nick=None, show=None):
        """ 添加一个成员
        Arguments:
            `jid`   -   成员jid
            `nick`  -   昵称
            `show`  -   stanze.show
        """
        if cls.get_one(jid):
            return
        m = Member(jid, nick)
        m.status = [Status(show, jid.resource)]
        try:
            session.add(m)
            session.commit()
        except:
            session.rollback()

        return m
Exemple #39
0
 def __commit(self):
     try:
         session.add(self.release)
         session.add_all(self.motifs)
         session.add_all(self.loops)
         session.add_all(self.history)
         session.add_all(self.intersection)
         session.add_all(self.release_diff)
         session.add_all(self.loop_order)
         session.add_all(self.loop_positions)
         session.add_all(self.loop_discrepancy)
         session.commit()
         logging.info('Successful update')
     except sqlalchemy.exc.SQLAlchemyError, e:
         logging.error('Update failed. Rolling back.')
         logging.error(str(e))
         session.rollback()
         self.remove_release(self.release.id)
         sys.exit()
Exemple #40
0
def follow_user(follower_user, followed_user):
    follow_relationship = FollowRelationship(follower_user_id=follower_user.id,
                                             followed_user_id=followed_user.id)

    try:
        session.add(follow_relationship)
        session.flush()
        session.commit()
    except IntegrityError:
        logging.info('Follow relationship already exists in the system!')
        session.rollback()
        session.query(FollowRelationship) \
            .filter_by(follower_user_id=follower_user.id,
                       followed_user_id=followed_user.id)\
            .update({'is_deleted': False})

        session.commit()

    return {'following': True}, HTTP_STATUS_OK
Exemple #41
0
    def updateUser(self, updatedUserDict):
        mergedUser = None
        userId = updatedUserDict.pop('id')
        if userId is None:
            raise Exception("Cannot update User without User ID")
        try:

            fromDbUserDict = adapters.as_dict(self.getUser(userId))
            fromDbUserDict.update(updatedUserDict)
            print(fromDbUserDict)

            session.query(User).filter(User.id == userId).update(
                fromDbUserDict, synchronize_session=False)
            session.commit()

            mergedUser = self.getUser(userId)
        except Exception as e:
            session.rollback()
            raise e
        return mergedUser
Exemple #42
0
 def remove_release(self, release):
     """
     """
     try:
         session.query(NR_release).filter(NR_release.id == release).delete(synchronize_session="fetch")
         session.query(NR_class).filter(NR_class.release_id == release).delete(synchronize_session="fetch")
         session.query(NR_pdb).filter(NR_pdb.release_id == release).delete(synchronize_session="fetch")
         session.query(NR_setdiff).filter(NR_setdiff.release_id == release).delete(synchronize_session="fetch")
         session.query(NR_parents).filter(NR_parents.release_id == release).delete(synchronize_session="fetch")
         session.query(NR_release_diff).filter(NR_release_diff.nr_release_id1 == release).delete(
             synchronize_session="fetch"
         )
         session.query(NR_release_diff).filter(NR_release_diff.nr_release_id2 == release).delete(
             synchronize_session="fetch"
         )
         session.commit()
         logging.info("Release %s deleted successfully" % release)
     except:
         logging.error("Removing release %s failed" % release)
         session.rollback()
         sys.exit()
def guildwars2_filter_sm(submissions, array_anet_names):
    for sm in submissions:
        logging.info('submission')
        if sm.author.name in array_anet_names:
            logging.info("submission from anet: " + sm.name )
            row = bot_submissions()
            title = sm.title
            if (len(title) + len(sm.author.name) + 3) > 300:
                title = title[:300 - len(sm.author.name) - 3 - 3]
                title += '...'
            row.title = title + ' [' + sm.author.name + ']'
            row.type = 'link'
            row.subreddit = 'gw2devtrack'
            row.submitted = False
            row.content = sm.permalink.replace('//www.reddit.com','//np.reddit.com') + '?context=1000'
            session.add(row)
        if re.search('http.*?:\/\/.*?guildwars2.com\/', sm.selftext) != None:
            logging.info("submission with gw2 link in selftext: " + sm.name)
            all_links = re.findall('http.*?:\/\/.*?guildwars2.com\/[^ \])\s]*', sm.selftext)
            for link in all_links:
                if link != '':
                    try:
                        prepare_comment(sm.name, False, guildwars2.locate_origin(link)[1])
                    except Exception as e:
                        session.rollback()
                        logging.error(e)
        session.commit()
        if re.search('http.*?:\/\/.*?guildwars2.com\/', sm.url) != None:
            logging.info("submission with gw2 link in url: " +  sm.name)
            all_links = re.findall('http.*?:\/\/.*?guildwars2.com\/[^ \])]*', sm.url)
            for link in all_links:
                if link != '':
                    try:
                        prepare_comment(sm.name, False, guildwars2.locate_origin(link)[1])
                    except Exception as e:
                        logging.error(e)
                        session.rollback()
        session.commit()
def guildwars2_filter_sm(submissions, array_anet_names):
    for sm in submissions:
        logging.info("submission")
        if sm.author.name in array_anet_names:
            logging.info("submission from anet: " + sm.name)
            row = bot_submissions()
            title = sm.title
            if (len(title) + len(sm.author.name) + 3) > 300:
                title = title[: 300 - len(sm.author.name) - 3 - 3]
                title += "..."
            row.title = title + " [" + sm.author.name + "]"
            row.type = "link"
            row.subreddit = "gw2devtrack"
            row.submitted = False
            row.content = sm.permalink.replace("//www.reddit.com", "//np.reddit.com") + "?context=1000"
            session.add(row)
        if re.search("http.*?:\/\/.*?guildwars2.com\/", sm.selftext) != None:
            logging.info("submission with gw2 link in selftext: " + sm.name)
            all_links = re.findall("http.*?:\/\/.*?guildwars2.com\/[^ \])\s]*", sm.selftext)
            for link in all_links:
                if link != "":
                    try:
                        prepare_comment(sm.name, False, guildwars2.locate_origin(link)[1])
                    except Exception as e:
                        session.rollback()
                        logging.error(e)
        session.commit()
        if re.search("http.*?:\/\/.*?guildwars2.com\/", sm.url) != None:
            logging.info("submission with gw2 link in url: " + sm.name)
            all_links = re.findall("http.*?:\/\/.*?guildwars2.com\/[^ \])]*", sm.url)
            for link in all_links:
                if link != "":
                    try:
                        prepare_comment(sm.name, False, guildwars2.locate_origin(link)[1])
                    except Exception as e:
                        logging.error(e)
                        session.rollback()
        session.commit()
Exemple #45
0
    def set_global_info(key, value):
        """ 设置全局选项
        Arguments:
            `key`   -   选项键
            `value` -   选项值
        """
        try:
            info = session.query(Info).filter(and_(Info.key == key,
                                                   Info.is_global == 1)).one()
            info.value = value
        except NoResultFound:
            info = Info(key, value, True)
            try:
                session.add(info)
            except:
                session.rollback()
        finally:
            try:
                session.commit()
            except:
                session.rollback()

        return info
Exemple #46
0
    def set_global_info(key, value):
        """ 设置全局选项
        Arguments:
            `key`   -   选项键
            `value` -   选项值
        """
        try:
            info = session.query(Info).filter(
                and_(Info.key == key, Info.is_global == 1)).one()
            info.value = value
        except NoResultFound:
            info = Info(key, value, True)
            try:
                session.add(info)
            except:
                session.rollback()
        finally:
            try:
                session.commit()
            except:
                session.rollback()

        return info
Exemple #47
0
    async def process_page_info(self, html):
        """ 返回单页上所有的数据列表 """

        soup2 = self.soup(html).find_all('a', attrs={'rel': 'bookmark'})
        info_list = []
        for s in soup2:
            s = self.soup(str(s))
            info_list.append(
                (s.span.string, s.a['href']))  # todo 放进redis数据库后再读取
            resource = Resources(name=s.span.string,
                                 owner='电波字幕组',
                                 stype='tvshow',
                                 original=s.a['href'])
            session.add(resource)
        try:
            session.commit()
            info_list = []
        except Exception as e:
            session.rollback()
            logging.error('插入数据库发生错误--{}'.format(str(e)))
        finally:
            session.close()
            return info_list
Exemple #48
0
def chart(request, device=None, chart_type=None):
    device = urllib.unquote(device)
    chart_type = urllib.unquote(chart_type)

    # print 'device: ', device
    # print 'chart_type: ', chart_type

    session.rollback()
    session.commit()

    if not device:
        raise NoDeviceSpecified()
    if not chart_type:
        raise NoChartTypeSpecified()
    
    filter_date = datetime.datetime.utcnow() - datetime.timedelta(days=1)
 
    if device == 'nest':
        nest = session.query(NestTimeSeries).filter(NestTimeSeries.datetime>filter_date).all()
        df = pd.DataFrame([{'datetime': n.datetime, 'value': getattr(n, chart_type)} for n in nest]).set_index('datetime')['value'].dropna()
    elif device == 'apex':
        apex = session.query(ApexTimeSeries).filter(ApexTimeSeries.device_name==chart_type).filter(ApexTimeSeries.datetime>filter_date).all()
        df = pd.DataFrame([{'datetime': a.datetime, 'value': a.value} for a in apex]).set_index('datetime')['value'].dropna()
    elif device == 'wemo':
        wemo = session.query(WemoTimeSeries).filter(WemoTimeSeries.device_name==chart_type).filter(WemoTimeSeries.datetime>filter_date).all()
        df = pd.DataFrame([{'datetime': w.datetime, 'value': float(w.state)} for w in wemo]).set_index('datetime')['value'].dropna()
    elif device == 'hue':
        hue = session.query(HueTimeSeries).filter(HueTimeSeries.device_name==chart_type).filter(HueTimeSeries.datetime>filter_date).all()
        df = pd.DataFrame([{'datetime': h.datetime, 'value': float(h.state) * float(h.reachable)} for h in hue]).set_index('datetime')['value'].dropna()
    elif device == 'roomba':
        roomba = session.query(RoombaTimeSeries).filter(RoombaTimeSeries.device_name==chart_type).filter(RoombaTimeSeries.datetime>filter_date).all()
        df = pd.DataFrame([{'datetime': r.datetime, 'value': r.current} for r in roomba]).set_index('datetime')['value'].dropna()
    elif device == 'flower':
        f = Flower()
        df = pd.DataFrame(f.get_data(1)).set_index('datetime')[chart_type].dropna()

    return render(request, template_name='chart.html', dictionary={'chart_type': 'device' + '_' + chart_type, 'series': df})
Exemple #49
0
 def modify_nick(cls, jid, nick):
     """ 修改成员昵称
     Arguments:
         `jid`   -   jid
         `nick`  -   新昵称
     Return:
         False   // 昵称已存在
         True    // 更改昵称成功
     """
     m = cls.get_one(jid)
     if not m: return False
     if m:
         exists = cls.get_with_nick(nick)
         if exists:
             return False
         m.nick = nick
         m.last_change = now()
         cls.set_info(jid, "change_nick_times",
                      int(cls.get_info(jid, "change_nick_times", 0).value) + 1)
         try:
             session.commit()
         except:
             session.rollback()
         return True
def main():
    global r
    logging.config.fileConfig(path_to_cfg)

    # which queues to check and the function to call
    queue_funcs = {'report': 'get_reports',
                   'spam': 'get_mod_queue',
                   'submission': 'get_new',
                   'comment': 'get_comments'}

    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()
            Condition.update_standards()
            cond_dict = load_all_conditions(sr_dict, queue_funcs.keys())
            break
        except Exception as e:
            logging.error('ERROR: {0}'.format(e))

    reports_mins = int(cfg_file.get('reddit', 'reports_check_period_mins'))
    reports_check_period = timedelta(minutes=reports_mins)
    last_reports_check = time()

    while True:
        try:
            # if the standard conditions have changed, reinit all conditions
            if Condition.update_standards():
                logging.info('Updating standard conditions from database')
                cond_dict = load_all_conditions(sr_dict, queue_funcs.keys())

            # check reports if past checking period
            if elapsed_since(last_reports_check) > reports_check_period:
                last_reports_check = time()
                check_queues({'report': queue_funcs['report']},
                             sr_dict, cond_dict)
                             
            check_queues({q: queue_funcs[q]
                          for q in queue_funcs
                          if q != 'report'},
                         sr_dict, cond_dict)

            updated_srs = process_messages()
            if updated_srs:
                if any(sr not in sr_dict for sr in updated_srs):
                    sr_dict = get_enabled_subreddits(reload_mod_subs=True)
                else:
                    sr_dict = get_enabled_subreddits(reload_mod_subs=False)
                for sr in updated_srs:
                    update_conditions_for_sr(cond_dict,
                                             queue_funcs.keys(),
                                             sr_dict[sr])
        except (praw.errors.ModeratorRequired,
                praw.errors.ModeratorOrScopeRequired,
                HTTPError) as e:
            if not isinstance(e, 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))
            session.rollback()
Exemple #51
0
def check_items(name, items, sr_dict, cond_dict, stop_time):
    """Checks the items generator for any matching conditions."""
    item_count = 0
    comment_counts = Counter()
    start_time = time()
    seen_subs = set()

    logging.info('Checking new %ss', name)

    try:
        for item in items:
            # skip any items in /new that have been approved
            if name == 'submission' and item.approved_by:
                continue

            item_time = datetime.utcfromtimestamp(item.created_utc)
            if item_time <= stop_time:
                break

            subreddit = sr_dict[item.subreddit.display_name.lower()]
            conditions = cond_dict[item.subreddit.display_name.lower()][name]

            # don't need to check for shadowbanned unless we're in spam
            if name == 'spam':
                for condition in conditions:
                    condition.check_shadowbanned = True
            else:
                for condition in conditions:
                    condition.check_shadowbanned = False

            item_count += 1
            if name == 'comment':
                comment_counts[item.subreddit.display_name.lower()] += 1

            if subreddit.name not in seen_subs:
                setattr(subreddit, 'last_'+name, item_time)
                seen_subs.add(subreddit.name)

            logging.debug('  Checking item %s', get_permalink(item))

            # check removal conditions, stop checking if any matched
            if check_conditions(subreddit, item,
                    [c for c in conditions if c.action == 'remove']):
                continue

            # check set_flair conditions 
            check_conditions(subreddit, item,
                    [c for c in conditions if c.action == 'set_flair'])

            # check approval conditions
            check_conditions(subreddit, item,
                    [c for c in conditions if c.action == 'approve'])

            # check alert conditions
            check_conditions(subreddit, item,
                    [c for c in conditions if c.action == 'alert'])

            # check report conditions
            check_conditions(subreddit, item,
                    [c for c in conditions if c.action == 'report'])

            # if doing reports, check auto-reapproval if enabled
            if (name == 'report' and subreddit.auto_reapprove and
                    item.approved_by is not None):
                try:
                    # see if this item has already been auto-reapproved
                    entry = (session.query(AutoReapproval).filter(
                            AutoReapproval.permalink == get_permalink(item))
                            .one())
                    in_db = True
                except NoResultFound:
                    entry = AutoReapproval()
                    entry.subreddit_id = subreddit.id
                    entry.permalink = get_permalink(item)
                    entry.original_approver = item.approved_by.name
                    entry.total_reports = 0
                    entry.first_approval_time = datetime.utcnow()
                    in_db = False

                if (in_db or item.approved_by.name !=
                        cfg_file.get('reddit', 'username')):
                    item.approve()
                    entry.total_reports += item.num_reports
                    entry.last_approval_time = datetime.utcnow()

                    session.add(entry)
                    session.commit()
                    logging.info('  Re-approved %s', entry.permalink)
                    log_request('reapprove')
                            
        session.commit()
    except Exception as e:
        logging.error('  ERROR: %s', e)
        session.rollback()

    # This isn't really correct, since we don't collect any 0 samples
    # but the difference won't matter much in practice
    for subreddit in comment_counts:
        prev_total = (sr_dict[subreddit].avg_comments * 
                     sr_dict[subreddit].avg_comments_samples)
        new_avg = ((prev_total + comment_counts[subreddit]) /
                   (sr_dict[subreddit].avg_comments_samples + 1))
        sr_dict[subreddit].avg_comments = new_avg
        sr_dict[subreddit].avg_comments_samples += 1
    session.commit()

    logging.info('  Checked %s items in %s',
            item_count, elapsed_since(start_time))
    log_request('listing', item_count / 100 + 1)
def main():
    global r
    global search_comment_id
    global search_submission_id

    logging.config.fileConfig(path_to_cfg)

    r = praw.Reddit(cfg_file["reddit"]["user_agent"])
    enabled_subreddits = ["Guildwars2"]
    while True:
        try:
            authenticate(cfg_file["oauth2"])
        except Exception:
            logging.error("OAuth2 could not authenticate")
            continue
        else:
            logging.info("OAuth2 authenticated")
            break

    while True:
        try:
            subreddit_obj = session.query(subreddit).filter_by(website="reddit").first()
            search_comment_id = subreddit_obj.last_comment
            search_submission_id = subreddit_obj.last_submission
        except:
            logging.warning("search_comment_id and search_submission_id initialized with 0")
            search_comment_id = 0
            search_submission_id = 0

        submission_queue = {}
        comment_queue = {}
        try:
            comment_queue = load_recent_comments(enabled_subreddits)
            submission_queue = load_recent_submissions(enabled_subreddits)
            distribute_queues(comment_queue, submission_queue)
            last_ids = session.query(subreddit).filter_by(website="reddit").first()
            if last_ids == None:
                row = subreddit()
                row.website = "reddit"
                row.last_submission = search_submission_id
                row.last_comment = search_comment_id
                # logging.info('last submission updated: ' + str(search_submission_id) + ' - last comment updated: ' + str(search_comment_id))
                session.add(row)
            else:
                session.query(subreddit).filter_by(website="reddit").update(
                    {"last_submission": search_submission_id, "last_comment": search_comment_id}
                )
                # logging.info('last submission updated: ' + str(search_submission_id) + ' - last comment updated: ' + str(search_comment_id))
            session.commit()
        except KeyboardInterrupt:
            raise
        except Exception as e:
            logging.error(e)
            session.rollback()
        try:
            to_be_commented = session.query(bot_comments).filter_by(submitted=False).all()
            for tbcm in to_be_commented:
                cm_obj = r.get_info(thing_id=tbcm.thing_id)
                if tbcm.thing_id[:2] == "t3":
                    try:
                        reply_obj = cm_obj.add_comment(tbcm.content)
                    except (praw.errors.InvalidSubmission):
                        session.query(bot_comments).filter_by(id=tbcm.id).update(
                            {"submitted": True, "submitted_id": "del-1"}
                        )
                        logging.info(str(tbcm.id) + " in bot_comments not submitted, parent deleted")
                    else:
                        session.query(bot_comments).filter_by(id=tbcm.id).update(
                            {"submitted": True, "submitted_id": reply_obj.name}
                        )
                        logging.info(str(tbcm.id) + " in bot_comments submitted")
                elif tbcm.thing_id[:2] == "t1":
                    try:
                        reply_obj = cm_obj.reply(tbcm.content)
                    except (praw.errors.InvalidComment):
                        session.query(bot_comments).filter_by(id=tbcm.id).update(
                            {"submitted": True, "submitted_id": "del-1"}
                        )
                        logging.info(str(tbcm.id) + " in bot_comments not submitted, parent deleted")
                    else:
                        session.query(bot_comments).filter_by(id=tbcm.id).update(
                            {"submitted": True, "submitted_id": reply_obj.name}
                        )
                        logging.info(str(tbcm.id) + " in bot_comments submitted")
                elif tbcm.thing_id[:1] == "i":
                    new_id = session.query(bot_comments).filter_by(id=tbcm.thing_id[1:]).first().submitted_id
                    if new_id == "del-1":
                        session.query(bot_comments).filter_by(id=tbcm.id).update(
                            {"submitted": True, "submitted_id": "del-1"}
                        )
                    if new_id != None:
                        session.query(bot_comments).filter_by(id=tbcm.id).update({"thing_id": new_id})
                session.commit()
        except Exception as e:
            logging.error(e)
            session.rollback()
        try:
            to_be_submitted = session.query(bot_submissions).filter_by(submitted=False).all()
            for tbsm in to_be_submitted:
                if tbsm.type == "link":
                    r.submit(tbsm.subreddit, tbsm.title, url=tbsm.content)
                elif tbsm.type == "self":
                    r.submit(tbsm.subreddit, tbsm.title, text=tbsm.content)
                session.query(bot_submissions).filter_by(id=tbsm.id).update({"submitted": True})
                logging.info(str(tbsm.id) + " in bot_submissions submitted")
                session.commit()
        except Exception as e:
            logging.error(e)
            session.rollback()
Exemple #53
0
            r = session.query(NR_release).filter(NR_release.id == self.release.id).first()
            if not r:
                session.add(self.release)

            session.add_all(self.motifs)
            session.add_all(self.loops)
            session.add_all(self.history)
            session.add_all(self.intersection)
            session.add_all(self.release_diff)

            session.commit()
            logging.info("Successful update")
        except sqlalchemy.exc.SQLAlchemyError, e:
            logging.error("Update failed. SQLAlchemy error. Rolling back.")
            logging.error(str(e))
            session.rollback()
            self.remove_release(self.release.id)
            sys.exit()
        except sqlalchemy.exc.DBAPIError, e:
            logging.error("Update failed. DBAPI error. Rolling back.")
            logging.error(str(e))
            session.rollback()
            self.remove_release(self.release.id)
            sys.exit()
        except sys.exc_info()[0]:
            logging.error("Update failed. Rolling back.")
            logging.error(sys.exc_info()[0])
            session.rollback()
            self.remove_release(self.release.id)
            sys.exit()