python类commit()的实例源码

def test_delete_entity_method_is_working_properly(self):
        """testing if the delete_entity() method is working properly
        """
        from stalker import db, Entity
        test_entity = Entity(
            name='Test Entity'
        )
        db.DBSession.add(test_entity)
        db.DBSession.commit()

        test_entity_db = Entity.query\
            .filter(Entity.name == test_entity.name).first()

        self.assertIsNotNone(test_entity_db)

        from stalker_pyramid.testing import DummyRequest
        request = DummyRequest()
        request.matchdict['id'] = test_entity_db.id

        entity_view = entity.EntityViews(request)
        entity_view.delete_entity()

        test_entity_db = Entity.query\
            .filter(Entity.name == test_entity.name).first()
        self.assertIsNone(test_entity_db)

def test_delete_entity_method_is_working_properly(self):
        """testing if DELETE /api/entities/{id} is working properly
        """
        from stalker import db, Entity
        test_entity = Entity(
            name='Test Entity'
        )
        db.DBSession.add(test_entity)
        db.DBSession.commit()

        test_entity_db = Entity.query\
            .filter(Entity.name == test_entity.name).first()

        self.assertIsNotNone(test_entity_db)

        self.test_app.delete(
            '/api/entities/%s' % test_entity_db.id,
            status=200
        )

        test_entity_db = Entity.query\
            .filter(Entity.name == test_entity.name).first()
        self.assertIsNone(test_entity_db)

def tearDown(self):
        """clean up the test
        """
        import datetime
        import transaction
        from stalker import defaults
        from stalker.db.session import DBSession
        from stalker.db.declarative import Base
        from pyramid import testing

        testing.tearDown()

        # clean up test database
        connection = DBSession.connection()
        engine = connection.engine
        connection.close()
        Base.metadata.drop_all(engine)
        transaction.commit()
        DBSession.remove()

        defaults.timing_resolution = datetime.timedelta(hours=1)

def update_links(self):
        """updates the ticket.links attribute
        """
        link_ids = self.get_multi_integer(self.request, 'link_id')

        from stalker import SimpleEntity
        links = SimpleEntity.query.filter(SimpleEntity.id.in_(link_ids)).all()

        if self.request.method == 'PATCH':
            for link in links:
                if link not in self.entity.links:
                    self.entity.links.append(link)
        elif self.request.method == 'POST':
            self.entity.links = links

        import transaction
        transaction.commit()

        from pyramid.response import Response
        return Response('Updated links of ticket %s' % self.entity_id)

def delete_links(self):
        """removes items from the ticket.links attribute
        """
        link_ids = self.get_multi_integer(self.request, 'link_id')

        from stalker import SimpleEntity
        links = SimpleEntity.query.filter(SimpleEntity.id.in_(link_ids)).all()

        successfully_deleted_item_ids = []
        for link in links:
            if link in self.entity.links:
                self.entity.links.remove(link)
                successfully_deleted_item_ids.append(link.id)

        import transaction
        transaction.commit()

        from pyramid.response import Response
        return Response(
            'Deleted links [%s] from ticket %s' % (
                ', '.join(map(str, successfully_deleted_item_ids)),
                self.entity_id
            )
        )

def update_related_tickets(self):
        """updates the ticket.related_tickets attribute
        """
        related_ticket_ids = \
            self.get_multi_integer(self.request, 'related_ticket_id')
        related_tickets = \
            Ticket.query.filter(Ticket.id.in_(related_ticket_ids)).all()

        if self.request.method == 'PATCH':
            for rt in related_tickets:
                if rt not in self.entity.related_tickets:
                    self.entity.related_tickets.append(rt)
        elif self.request.method == 'POST':
            self.entity.related_tickets = related_tickets

        import transaction
        transaction.commit()

def delete_good(request):
    """deletes the good with data from request
    """

    logger.debug('***delete good method starts ***')

    good_id = request.params.get('id')
    good = Good.query.filter_by(id=good_id).first()

    if not good:
        transaction.abort()
        return Response('There is no good with id: %s' % good_id, 500)

    good_name = good.name
    try:
        DBSession.delete(good)
        transaction.commit()
    except Exception as e:
        transaction.abort()
        c = StdErrToHTMLConverter(e)
        transaction.abort()
        return Response(c.html(), 500)

    return Response('Successfully deleted good with name %s' % good_name)

def entity_creator(self, entity_class, param_resolution):
        """Creates SOM class instances by using param_resolution.

        :param entity_class: A SOM Class
        :param param_resolution: A list of dictionaries. See
          :method:``.resolve_param_resolution`` for details.
        """
        args = self.resolve_param_resolution(param_resolution)

        # fix created_by value if skipped
        # and use the logged in user as the creator
        if 'created_by' not in args:
            logged_in_user = self.get_logged_in_user(self.request)
            args['created_by'] = logged_in_user

        from stalker.db.session import DBSession
        new_entity = entity_class(**args)
        DBSession.add(new_entity)
        DBSession.flush()
        transaction.commit()

        return new_entity

def main():
    session = make_session()
    with transaction.manager:
        old_friends = session.query(OldFriend).all()
        for old in old_friends:
            username = old.user
            friend_username = old.friend
            user_id = session.query(User.id).filter(User.username == username).first()[0]
            try:
            friend_id = session.query(User.id).filter(User.username == friend_username).first()[0]
            except:
                print "friend was missing"
                continue
        new_friend = Friend(user_id, friend_id)
            session.add(new_friend)
        #transaction.commit()

def add_result_config():
    session = make_session()
    parser = argparse.ArgumentParser()
    parser.add_argument("league", type=int, help="league id")
    parser.add_argument("match", type=int, help="match id")
    args = parser.parse_args()
    results = results_config

    with transaction.manager:
        for team in results:
            for player in team['players']:
                result_string = "%s,%s" % (team["position"], player["kills"])
                hero_id = session.query(Hero).filter(Hero.league == args.league).filter(Hero.name == player['name']).first()
                if not hero_id:
                    print "Name wrong"
                    return
                session.add(Result(args.league, hero_id.id, args.match, result_string,
                                   time.time(), 1, 1))
        transaction.commit()
    return

def add_result():
    session = make_session()

    parser = argparse.ArgumentParser()
    parser.add_argument("league", type=int, help="league id")
    parser.add_argument("match", type=int, help="match")
    parser.add_argument("player", type=str, help="player name")
    parser.add_argument("position", type=int, help="team position")
    parser.add_argument("kills", type=int, help="player kills")

    args = parser.parse_args()
    with transaction.manager:
        result_string = "%s,%s" % (args.position, args.kills)
        hero_id = session.query(Hero).filter(Hero.league == args.league).filter(Hero.name == args.player).first()
        if not hero_id:
            print "Name wrong"
            return
        session.add(Result(args.league, hero_id.id, args.match, result_string,
                           time.time(), 1, 1))
        transaction.commit()
    return

def main():
    """
    Dont want to delete account as soon as indicated. makes battlecupos and stuff awkward.
    so delete it at the end of the day.
    :return:
    """
    session = make_session()
    with transaction.manager:
        delete_accounts = session.query(User.username).filter(User.to_delete == True).all()
        for username in delete_accounts:
            username = username[0]
            # loop over leagues and delete from them
            #session.query(TeamHero).filter(TeamHero.user == username).delete()
            # any others?
            session.query()
        delete(delete_accounts)
        transaction.commit()

def main():
    session = make_session()
    parser = argparse.ArgumentParser()
    parser.add_argument("league", type=int, help="league id")
    args = parser.parse_args()
    league = session.query(League).filter(League.id == args.league).first()
    with transaction.manager:
        print "Updating hero points"
        update_hero_points(session, league)
        transaction.commit()
    with transaction.manager:
        print "Updating league points"
        update_league_points(session, league)
        transaction.commit()
    with transaction.manager:
        print "Updating user rankings"
        update_user_rankings(session, league)
        transaction.commit()

def merge_artists(artists):
    root = getSite()
    new_artists = []
    from lac.utilities.duplicates_utility import (
        find_duplicates_artist)
    for artist in artists:
        old_artists = find_duplicates_artist(artist)
        published_old_artists = [a for a in old_artists
                                 if 'published' in a.state]
        if old_artists:
            old_artist = published_old_artists[0] if \
                published_old_artists else old_artists[0]
            new_artists.append(old_artist)
        else:
            new_artists.append(artist)
            artist.state = PersistentList(['editable'])
            root.addtoproperty('artists', artist)
            artist.reindex()
            import transaction
            transaction.commit()

    return new_artists

def venue_normalize_text(root, registry):
    from lac.views.filter import find_entities
    from lac.views.widget import redirect_links
    from lac.content.interface import IVenue
    import html_diff_wrapper

    contents = find_entities(interfaces=[IVenue])
    len_entities = str(len(contents))
    for index, venue in enumerate(contents):
        if getattr(venue, 'description', None):
            venue.description = html_diff_wrapper.normalize_text(
                venue.description, {redirect_links})
            venue.hash_venue_data()
            venue.reindex()

        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Venues text evolved.')

def artist_normalize_text(root, registry):
    from lac.views.filter import find_entities
    from lac.views.widget import redirect_links
    from lac.content.interface import IArtistInformationSheet
    import html_diff_wrapper

    contents = find_entities(interfaces=[IArtistInformationSheet])
    len_entities = str(len(contents))
    for index, artist in enumerate(contents):
        if getattr(artist, 'biography', None):
            artist.biography = html_diff_wrapper.normalize_text(
                artist.biography, {redirect_links})
            artist.hash_artist_data()
            artist.reindex()

        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Artists text evolved.')

def event_normalize_text(root, registry):
    from lac.views.filter import find_entities
    from lac.views.widget import redirect_links
    from lac.content.interface import ICulturalEvent
    import html_diff_wrapper

    contents = find_entities(interfaces=[ICulturalEvent])
    len_entities = str(len(contents))
    for index, event in enumerate(contents):
        if getattr(event, 'details', None):
            try:
                event.details = html_diff_wrapper.normalize_text(
                    event.details, {redirect_links})
                event.reindex()
            except Exception as error:
                log.warning(error)

        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Event text evolved.')

def reviw_normalize_text(root, registry):
    from lac.views.filter import find_entities
    from lac.views.widget import redirect_links
    from lac.content.interface import IBaseReview
    import html_diff_wrapper

    contents = find_entities(interfaces=[IBaseReview])
    len_entities = str(len(contents))
    for index, review in enumerate(contents):
        if getattr(review, 'article', None):
            review.article = html_diff_wrapper.normalize_text(
                review.article, {redirect_links})
            review.reindex()

        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Review text evolved.')

def filme_schedules_duplicates(root, registry):
    from lac.views.filter import find_entities
    from lac.content.interface import IFilmSchedule

    contents = find_entities(interfaces=[IFilmSchedule])
    len_entities = str(len(contents))
    for index, schedule in enumerate(contents):
        if not schedule.venue:
            root.delfromproperty('schedules', schedule)
        else:    
            root.addtoproperty('film_schedules', schedule)

        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Film schedules evolved.')

def evolve_services(root, registry):
    from lac.views.filter import find_entities
    from lac.content.interface import IService
    from lac.content.site_folder import SiteFolder

    contents = find_entities(interfaces=[IService])
    len_entities = str(len(contents))
    for index, service in enumerate(contents):
        if service.definition.service_id == 'moderation':
            if not isinstance(getattr(service, 'perimeter', None), SiteFolder):
                subscription = service.subscription
                subscription['subscription_type'] = 'per_unit'
                service.subscription = PersistentDict(subscription)
                service.reindex()

        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Services evolved.')

def fix_contributors(root, registry):
    from lac.views.filter import find_entities
    from lac.content.interface import ISearchableEntity

    contents = find_entities(interfaces=[ISearchableEntity])
    len_entities = str(len(contents))
    for index, content in enumerate(contents):
        if hasattr(content, 'contributors'):
            original = getattr(content, 'original', None)
            contributors = content.contributors
            if content.author and content.author not in contributors:
                content.addtoproperty('contributors', content.author)

            contributors = content.contributors
            if original and original.author and \
               original.author not in contributors:
                content.addtoproperty('contributors', original.author)

            if index % 1000 == 0:
                log.info("**** Commit ****")
                transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Contributors evolved.')

def _update_zipcode_venue(contents):
    len_entities = str(len(contents))
    for index, venue in enumerate(contents):
        addresses = getattr(venue, 'addresses', [])
        result = []
        for address in addresses:
            zipcodes = address.get('zipcode', [])
            if zipcodes is not None and isinstance(zipcodes, (set, list)):
                zipcodes = list(zipcodes)
                address['zipcode'] = zipcodes[0] if zipcodes else None

            result.append(address)

        venue.addresses = PersistentList(result)
        venue.hash_venue_data()
        venue.reindex()

        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

def reindex_venues(root, registry):
    from lac.views.filter import find_entities
    from lac.content.interface import IVenue

    contents = find_entities(interfaces=[IVenue])
    len_entities = str(len(contents))
    for index, venue in enumerate(contents):
        venue.reindex()

        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Venues reindexed')

def evolve_alerts(root, registry):
    from lac.views.filter import find_entities
    from lac.content.interface import IAlert
    from substanced.util import get_oid

    contents = find_entities(interfaces=[IAlert])
    len_entities = str(len(contents))
    for index, alert in enumerate(contents):
        alert.users_to_alert = PersistentList(
            [str(get_oid(user, user))
             for user in alert.users_to_alert])
        alert.reindex()
        if index % 1000 == 0:
            log.info("**** Commit ****")
            transaction.commit()

        log.info(str(index) + "/" + len_entities)

    log.info('Alerts reindexed')

def ZODBDatabaseConfigurationFactory(key, dbconfig):
    config = dbconfig.get('configuration', {})
    fs = ZODB.FileStorage.FileStorage(dbconfig['path'])
    db = DB(fs)
    try:
        rootobj = db.open().root()
        if not IDatabase.providedBy(rootobj):
            alsoProvides(rootobj, IDatabase)
        transaction.commit()
        rootobj = None
    except:
        pass
    finally:
        db.close()
    # Set request aware database for app
    db = RequestAwareDB(dbconfig['path'], **config)
    return Database(key, db)

def NewtConfigurationFactory(key, dbconfig):
    if not NEWT:
        raise Exception("You must install the newt.db package before you can use "
                        "it as a dabase adapter.")
    config = dbconfig.get('configuration', {})
    dsn = "dbname={dbname} user={username} host={host} password={password} port={port}".format(**dbconfig['dsn'])  # noqa
    adapter = newt.db.storage(dsn=dsn, **dbconfig['options'])
    db = newt.db.DB(dsn, **dbconfig['options'])
    try:
        conn = db.open()
        rootobj = conn.root()
        if not IDatabase.providedBy(rootobj):
            alsoProvides(rootobj, IDatabase)
        transaction.commit()
    except:
        pass
    finally:
        rootobj = None
        conn.close()
        db.close()
    adapter = newt.db.storage(dsn, **dbconfig['options'])
    db = newt.db._db.NewtDB(RequestAwareDB(adapter, **config))
    return Database(key, db)

def createUser(username, password, fullname, email, role):
    """Create a new L{User}.

    @param username: A C{unicode} username for the user.
    @param password: A C{unicode} password in plain text for the user. The
        password will be hashed before being stored.
    @param fullname: A C{unicode} name for the user.
    @param email: The C{unicode} email address for the user.
    @param role: The L{Role} for the user.
    @return: A C{list} of C{(objectID, username)} 2-tuples for the new
        L{User}s.
    """
    username = username.lower()
    users = UserAPI()
    result = users.create([(username, password, fullname, email)])
    # Set the role with an update to ensure that the 'fluiddb/users/role' tag
    # value is set correctly.
    users.set([(username, None, None, None, role)])
    try:
        transaction.commit()
    except:
        transaction.abort()
        raise
    return result

def updateUser(username, password, fullname, email, role):
    """Updates a L{User}.

    @param username: A C{unicode} username for the user.
    @param password: A C{unicode} password in plain text for the user. The
        password will be hashed before being stored.
    @param fullname: A C{unicode} name for the user.
    @param email: The C{unicode} email address for the user.
    @param role: The L{Role} for the user.
    @return: @return: A C{(objectID, username)} 2-tuple representing the
        L{User} that was updated.
    """
    try:
        result = UserAPI().set([(username, password, fullname, email, role)])
        transaction.commit()
    except:
        transaction.abort()
        raise
    return result

def setVersionTag(version):
    """Updates the fluiddb/version tag.

    @param version: The new version string.
    """
    user = getUser(u'fluiddb')
    objectID = ObjectAPI(user).create(u'fluidinfo')
    releaseDate = datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
    values = {objectID: {
        u'fluiddb/api-version': {
            'mime-type': 'text/plain',
            'contents': version},
        u'fluiddb/release-date': {
            'mime-type': 'text/plain',
            'contents': releaseDate + '\n'}}}
    TagValueAPI(user).set(values)
    PermissionAPI(user).set([
        (u'fluiddb/api-version', Operation.READ_TAG_VALUE, Policy.OPEN, []),
        (u'fluiddb/release-date', Operation.READ_TAG_VALUE, Policy.OPEN, [])])

    try:
        transaction.commit()
    except:
        transaction.abort()
        raise

def _resetIndex(self, baseURL):
        """Reset the Solr index."""
        url = urljoin(baseURL, '/solr/update?wt=json')
        headers = {'User-Agent': 'FluidDB test suite',
                   'Content-Type': 'text/xml'}
        body = '<delete><query>*:*</query></delete>'
        response, content = Http().request(url, 'POST', body, headers)
        if response.status != 200:
            raise RuntimeError(
                "Couldn't clear Solr index!  Got HTTP %s return code and "
                'content: %s', (response.status, content))

        url = urljoin(baseURL, '/solr/update?wt=json')
        headers = {'User-Agent': 'FluidDB test suite',
                   'Content-Type': 'text/xml'}
        body = '<commit></commit>'
        response, content = Http().request(url, 'POST', body, headers)
        if response.status != 200:
            raise RuntimeError(
                "Couldn't commit Solr index!  Got HTTP %s return code and "
                'content: %s', (response.status, content))