Python locations.Location类代码示例

    def testRemoveLocationByName(self):
        test_location_name = 'test_location'
        db.session.add(Location(name=test_location_name))
        db.session.commit()

        assert Location.getLocationByName(test_location_name) is not None
        Location.removeLocationByName(test_location_name)
        db.session.commit()
        assert Location.getLocationByName(test_location_name) is None

    def migrate_locations(self):
        print cformat("%{white!}migrating locations")
        default_location_name = self.zodb_root["DefaultRoomBookingLocation"]
        custom_attributes_dict = self.rb_root["CustomAttributesList"]

        for old_location in self.zodb_root["RoomBookingLocationList"]:
            # create location
            l = Location(
                name=convert_to_unicode(old_location.friendlyName),
                is_default=(old_location.friendlyName == default_location_name),
            )

            print cformat("- %{cyan}{}").format(l.name)

            # add aspects
            for old_aspect in old_location._aspects.values():
                a = Aspect(
                    name=convert_to_unicode(old_aspect.name),
                    center_latitude=old_aspect.centerLatitude,
                    center_longitude=old_aspect.centerLongitude,
                    zoom_level=old_aspect.zoomLevel,
                    top_left_latitude=old_aspect.topLeftLatitude,
                    top_left_longitude=old_aspect.topLeftLongitude,
                    bottom_right_latitude=old_aspect.bottomRightLatitude,
                    bottom_right_longitude=old_aspect.bottomRightLongitude,
                )

                print cformat("  %{blue!}Aspect:%{reset} {}").format(a.name)

                l.aspects.append(a)
                if old_aspect.defaultOnStartup:
                    l.default_aspect = a

            # add custom attributes
            for ca in custom_attributes_dict.get(l.name, []):
                if ca["type"] != "str":
                    raise RuntimeError("Non-str custom attributes are unsupported: {}".format(ca))
                attr_name = attribute_map.get(ca["name"], ca["name"])
                attr = RoomAttribute(
                    name=attr_name.replace(" ", "-").lower(),
                    title=attr_name,
                    type=ca["type"],
                    is_required=ca["required"],
                    is_hidden=ca["hidden"],
                )
                l.attributes.append(attr)
                print cformat("  %{blue!}Attribute:%{reset} {}").format(attr.title)

            # add new created location
            db.session.add(l)
            print
            print
        db.session.commit()

def migrate_locations(main_root, rb_root):
    print cformat('%{white!}migrating locations')
    default_location_name = main_root['DefaultRoomBookingLocation']
    custom_attributes_dict = rb_root['CustomAttributesList']

    for old_location in main_root['RoomBookingLocationList']:
        # create location
        l = Location(
            name=convert_to_unicode(old_location.friendlyName),
            is_default=(old_location.friendlyName == default_location_name)
        )

        print cformat('- %{cyan}{}').format(l.name)

        # add aspects
        for old_aspect in old_location._aspects.values():
            a = Aspect(
                name=convert_to_unicode(old_aspect.name),
                center_latitude=old_aspect.centerLatitude,
                center_longitude=old_aspect.centerLongitude,
                zoom_level=old_aspect.zoomLevel,
                top_left_latitude=old_aspect.topLeftLatitude,
                top_left_longitude=old_aspect.topLeftLongitude,
                bottom_right_latitude=old_aspect.bottomRightLatitude,
                bottom_right_longitude=old_aspect.bottomRightLongitude
            )

            print cformat('  %{blue!}Aspect:%{reset} {}').format(a.name)

            l.aspects.append(a)
            if old_aspect.defaultOnStartup:
                l.default_aspect = a

        # add custom attributes
        for ca in custom_attributes_dict.get(l.name, []):
            if ca['type'] != 'str':
                raise RuntimeError('Non-str custom attributes are unsupported: {}'.format(ca))
            attr_name = attribute_map.get(ca['name'], ca['name'])
            attr = RoomAttribute(name=attr_name.replace(' ', '-').lower(), title=attr_name, type=ca['type'],
                                 is_required=ca['required'], is_hidden=ca['hidden'])
            l.attributes.append(attr)
            print cformat('  %{blue!}Attribute:%{reset} {}').format(attr.title)

        # add new created location
        db.session.add(l)
        print
        print
    db.session.commit()

 def get_location_data(params):
     location_data = json.loads(params['location_data'])
     if location_data.get('room_id'):
         location_data['room'] = Room.get_one(location_data['room_id'])
     if location_data.get('venue_id'):
         location_data['venue'] = Location.get_one(location_data['venue_id'])
     return location_data

    def testClone(self):
        original = Location.getDefaultLocation()
        cloned = utils.clone(Location, original)

        assert cloned.id != original.id
        assert cloned.name == original.name
        assert cloned.default_aspect.id == original.default_aspect.id

 def wrapper(*args, **kw):
     location_name = getattr(request, request_attribute).get(parameter_name, None)
     location = Location.find_first(name=location_name)
     if not location:
         raise NotFound(_('There is no location named: {0}').format(location_name))
     setattr(args[0], attribute_name, location)
     return f(*args, **kw)

def main(main_uri, rb_uri, sqla_uri, photo_path, drop, merged_avatars):
    update_session_options(db)  # get rid of the zope transaction extension
    main_root, rb_root, app = setup(main_uri, rb_uri, sqla_uri)
    global tz
    try:
        tz = pytz.timezone(main_root['MaKaCInfo']['main'].getTimezone())
    except KeyError:
        tz = pytz.utc

    start = time.clock()
    with app.app_context():
        if drop:
            print cformat('%{yellow!}*** DANGER')
            print cformat('%{yellow!}***%{reset} '
                          '%{red!}ALL DATA%{reset} in your database %{yellow!}{!r}%{reset} will be '
                          '%{red!}PERMANENTLY ERASED%{reset}!').format(db.engine.url)
            if raw_input(cformat('%{yellow!}***%{reset} To confirm this, enter %{yellow!}YES%{reset}: ')) != 'YES':
                print 'Aborting'
                sys.exit(1)
            delete_all_tables(db)
        stamp()
        db.create_all()
        if Location.find().count():
            # Usually there's no good reason to migrate with data in the DB. However, during development one might
            # comment out some migration tasks and run the migration anyway.
            print cformat('%{yellow!}*** WARNING')
            print cformat('%{yellow!}***%{reset} Your database is not empty, migration will most likely fail!')
            if raw_input(cformat('%{yellow!}***%{reset} To confirm this, enter %{yellow!}YES%{reset}: ')) != 'YES':
                print 'Aborting'
                sys.exit(1)
        migrate(main_root, rb_root, photo_path, merged_avatars)
    print 'migration took {} seconds'.format((time.clock() - start))

    def export_reservation(self, aw):
        locations = Location.find_all(Location.name.in_(self._locations))
        if not locations:
            return

        for room_id, reservation in _export_reservations(self, False, True):
            yield reservation

 def _checkParams(self):
     self._with_kpi = request.args.get('withKPI', type=bool)
     self._actionSucceeded = request.args.get('actionSucceeded', default=False, type=bool)
     location_name = request.view_args.get('locationId')
     self._location = Location.find_first(name=location_name)
     if not self._location:
         raise IndicoError('Unknown Location: {0}'.format(location_name))

 def _process_args(self):
     self._locationName = request.form.get('newLocationName').strip()
     if not self._locationName:
         raise BadRequest(_('Location name may not be empty'))
     if '/' in self._locationName:
         raise BadRequest(_('Location name may not contain slashes'))
     if Location.find_first(name=self._locationName):
         raise BadRequest(_('Location "{0}" already exists').format(self._locationName))

    def export_roomName(self, aw):
        loc = Location.find_first(name=self._location)
        if loc is None:
            return

        search_str = '%{}%'.format(self._room_name)
        rooms_data = Room.get_with_data('vc_equipment', 'non_vc_equipment',
                                        filters=[Room.location_id == loc.id, Room.name.ilike(search_str)])
        for result in rooms_data:
            yield _serializable_room(result)

    def wrapper(*args, **kw):
        if not args:
            raise IndicoError(_("Wrong usage of location decorator"))

        location_name = getattr(request, request_attribute).get(parameter_name, None)
        location = Location.find_first(name=location_name)
        if not location:
            raise NotFoundError(_("There is no location named: {0}").format(location_name))
        setattr(args[0], attribute_name, location)
        return f(*args, **kw)

    def _process_args(self):
        name = request.view_args.get('locationId')
        self._location = Location.find_one(name=name)
        self._new_attr = None
        attr_title = request.form.get('newCustomAttributeName', default='').strip()
        if attr_title:
            attr_name = attr_title.replace(' ', '-').lower()
            if RoomAttribute.query.filter_by(name=attr_name).first():
                raise BadRequest(_('There is already an attribute named: {0}').format(attr_name))

            self._new_attr = RoomAttribute(name=attr_name, title=attr_title,
                                           is_hidden=request.form.get('newCustomAttributeIsHidden') == 'on')

    def export_roomName(self, user):
        loc = Location.find_first(name=self._location)
        if loc is None:
            return

        search_str = '%{}%'.format(self._room_name)
        rooms_data = Room.get_with_data(
            filters=[
                Room.location_id == loc.id,
                or_(Room.name.ilike(search_str),
                    Room.verbose_name.ilike(search_str))
            ])

        for result in rooms_data:
            yield _serializable_room(result)

    def export_room(self, user):
        loc = Location.find_first(name=self._location)
        if loc is None:
            return

        # Retrieve rooms
        rooms_data = list(Room.get_with_data(filters=[Room.id.in_(self._ids), Room.location_id == loc.id]))

        # Retrieve reservations
        reservations = None
        if self._detail == 'reservations':
            reservations = OrderedMultiDict(_export_reservations(self, True, False, [
                Reservation.room_id.in_(x['room'].id for x in rooms_data)
            ]))

        for result in rooms_data:
            yield _serializable_room(result, reservations)