Exemple #1
0
 def validate(self, data):
     """
     Check that start is before finish.
     """
     room = Room()
     room_value = room.get_value_by_id(
         data.get('room'),
         nested_id=data.get('hotel', {}).get("public_id")
     )
     if not room_value:
         raise serializers.ValidationError(
             {
                 'room': "room don't not exists"
             }
         )
     filter_rate = Rate.objects.filter(
         inventory__date=data.get('date'),
         room__public_id=data.get('room')
     )
     if filter_rate.exists():
         raise serializers.ValidationError(
             {
                 'date': (
                     'It already exists in the inventory in the room '
                     'on this date'
                 )
             }
         )
     data['room'] = room_value
     return data
Exemple #2
0
    def get_queryset(self):
        """
        Get the list of items for this view.
        This must be an iterable, and may be a queryset.
        Defaults to using `self.queryset`.

        This method should always be used rather than accessing `self.queryset`
        directly, as `self.queryset` gets evaluated only once, and those results
        are cached for all subsequent requests.

        You may want to override this if you need to provide different
        querysets depending on the incoming request.

        (Eg. return a list of items that is specific to the user)
        """  # NOQA
        assert self.queryset is not None, (
            "'%s' should either include a `queryset` attribute, "
            "or override the `get_queryset()` method."
            % self.__class__.__name__
        )
        hotel_id = self.kwargs.get('public_id')
        self.valid_hotel(hotel_id)
        rooms = Room()
        values = rooms.get_many_values(
            self.kwargs.get('public_id')
        )
        return values
Exemple #3
0
 def get_queryset(self) -> QueryType[User]:
     room_title = self.kwargs['room_title']
     room = get_object_or_404(Room, room_title=room_title)
     room_users = room.users.annotate(
         texts_count=Count('texts', filter=Q(texts__room=room)))
     Room.calculate_current_turn_user(room_title,
                                      self.request.user)  # recalculate
     return room_users.all().order_by('membership__id')
Exemple #4
0
def resetRoomCount():
    try:
        room = Room.objects.get(pk=1)
        room.count = 0
        room.save()
    except Room.DoesNotExist:
        room = Room(id=1, name="sample room", count=1)
        room.save()
def create_room(number, capacity=0, commit=True, **override):
    defaults = {'name': str(number), 'beds_single': capacity, 'available_beds_single': capacity}
    defaults.update(**override)
    room = Room(**defaults)

    if commit:
        room.save()

    return room
Exemple #6
0
 def _create_room(self, room):
     r = Room(code=room['code'],
              name=room['name'],
              floor=1,
              type=room['type'],
              access=room['access'],
              reservable=True)
     r.save()
     return r
    def test_filter(self):
        Room.create(325, 100, False)
        Room.create(314, 20, True)

        response = self.client.get(self.FILTER_PATH,
                                   data={'is_computer_room': 'true'})
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        for dict_ in response_data:
            self.assertTrue(dict_['is_computer_room'])
    def test_filter_min_capacity(self):
        Room.create(326, 100, False)
        Room.create(315, 20, True)

        response = self.client.get(self.FILTER_PATH,
                                   data={'min_capacity': 50})
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        for dict_ in response_data:
            self.assertGreaterEqual(dict_['capacity'], 50)
Exemple #9
0
    def setUp(self):
        self.su = User.objects.create_user(username="******", password="******")

        self.su.is_staff, self.su.is_superuser = True, True
        self.su.first_name = "Super"
        self.su.last_name = "User"
        self.su.save()

        self.r = Room(title="2E")
        self.r.save()

        self.client.login(username="******", password="******")
Exemple #10
0
    def test_no_duplicate(self):
        r = Room(title="1A")
        r.save()

        url = reverse("rooms:add")
        response = self.client.post(url, {
            "title": r.title,
            "unofficial_name": "",
            "description": "",
            "occupancy": 1,
        })
        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "A room with this title already exists.",
            )
Exemple #11
0
    def test_no_duplicate(self):
        r = Room(title="1A")
        r.save()

        url = reverse("rooms:add")
        response = self.client.post(
            url, {
                "title": r.title,
                "unofficial_name": "",
                "description": "",
                "occupancy": 1,
            })
        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "A room with this title already exists.",
        )
Exemple #12
0
def handle_uploaded_file(csvfile):
    rooms = []
    for row in csv.reader(csvfile, delimiter=','):
        name, desc, cap, hidden = row
        if name != "Name":
            rooms.append(
                Room(name=name, description=desc, capacity=cap, hidden=hidden))
    Room.objects.bulk_create(rooms)
    def post(self, request):
        name = request.POST.get('name')
        capacity = request.POST.get('capacity')
        projector = request.POST.get('projector')

        try:
            capacity = int(capacity)
        except:
            messages.info(request, f'Check capacity')
            return redirect(reverse('room_add'))
        if name and len(name) > 0:
            tmp_name = Room.objects.filter(name=name)
            if not tmp_name and capacity > 0:
                room = Room()
                room.name = name
                room.capacity = capacity
                room.projector = projector == 'on'
                room.save()
                return redirect(reverse('rooms'))
            else:
                messages.info(request, f'Check room name and capacity')
                return redirect(reverse('room_add'))
        else:
            messages.info(request, f'Check room name')
            return redirect(reverse('room_add'))
Exemple #14
0
    def get_object(self):
        """
        Returns the object the view is displaying.

        You may want to override this if you need to provide non-standard
        queryset lookups.  Eg if objects are referenced using multiple
        keyword arguments in the url conf.
        """
        hotel_id = self.kwargs.get('public_id')
        self.valid_hotel(hotel_id)
        room = Room()
        room_value = room.get_value_by_id(
            self.kwargs.get('room_id'),
            nested_id=hotel_id
        )
        if not room_value:
            self.base_value_not_found('room')
        return room_value
Exemple #15
0
def house_add_room(request, pk):
    house = House.objects.filter(pk=pk).get()
    if house.user != request.user:
        raise Http404
    if request.method == 'POST':
        room = Room()
        room.user = request.user
        room.house = house
        if 'name' not in request.POST:
            return render(
                request, 'houses/room_add.html', {
                    'house': house,
                    'error': 'Please make sure to fill in all required details'
                })
        else:
            room.name = request.POST['name']

        if 'price' not in request.POST:
            return render(
                request, 'houses/room_add.html', {
                    'house': house,
                    'error': 'Please make sure to fill in all required details'
                })
        else:
            room.price = request.POST['price']

        if 'description' not in request.POST:
            return render(
                request, 'houses/room_add.html', {
                    'house': house,
                    'error': 'Please make sure to fill in all required details'
                })
        else:
            room.description = request.POST['description']
        room.save()
        try:
            for file in request.FILES.getlist('images'):
                image = RoomImage()
                image.room = room
                image.user = request.user
                image.image = file
                image.save()
        except Exception:
            pass

        return redirect('room_detail', pk=room.id)

    return render(request, 'houses/room_add.html', {'house': house})
Exemple #16
0
    def handle(self, *args, **options):
        for file in args:
            f = open(file, "r")
            for line in f:
                l = line.split()
                room = Room()
                room.number = l[0]
                room.capacity = int(l[1])
                room.description = " ".join(l[2:])
                room.short_unlock_time = datetime.now()
                room.save()

            self.stdout.write('Successfully imported\n')
Exemple #17
0
def uploadphoto(request):
    if request.method == "POST":
        uploaded_image = request.FILES['image']
        fssobj = FileSystemStorage()
        filename = fssobj.save(uploaded_image.name, uploaded_image)
        uploaded_image_url = fssobj.url(filename)

        room = Room(file=uploaded_image_url,
                    Room_owner=request.POST['owner_name'],
                    Room_location=request.POST['location'],
                    Room_phnumber=request.POST['phone_number'],
                    Room_price=request.POST['price'],
                    pub_date=request.POST['pub_date'],
                    Room_desc=request.POST['desc'])
        room.save()
        return HttpResponse(
            'You have successfully uploaded the room photo with its detail<br><br><a href="/">Go to homepage</a>'
        )
    else:
        return render(request, 'upload.html')
Exemple #18
0
    def setUp(self):
        self.su = User.objects.create_user(username="******", password="******")

        self.su.is_staff, self.su.is_superuser = True, True
        self.su.first_name = "Super"
        self.su.last_name = "User"
        self.su.save()

        self.r = Room(title="2E")
        self.r.save()

        self.client.login(username="******", password="******")
Exemple #19
0
    def perform_create(self, serializer: TextsFullSerializer):
        room = self.room
        if room.is_finished:
            raise PermissionDenied(detail='Story is finished')
        request_user = self.request.user
        request_membership = get_user_room_membership(request_user, room)
        if request_membership.status == Membership.STOPPED:
            raise PermissionDenied(detail='User has finished')

        current_turn_user: User = Room.calculate_current_turn_user(self.room_title, request_user)
        request_membership.refresh_from_db()
        if request_membership.status != Membership.CAN_WRITE:
            raise PermissionDenied(detail=self._wrong_turn_error_detail(current_turn_user))

        serializer.save(author=request_user, room=room)
        room.save()  # to update the modification timestamp
        _ = Room.calculate_current_turn_user(self.room_title, self.request.user)  # recalculate
        send_channel_message(self.room_title, {
            'type': WEBSOCKET_MSG_ADD_TEXT,
            'room_title': self.room_title,
            'username': request_user.username,
        })
Exemple #20
0
    def handle(self, *args, **options):
        for file in args:
            f = open(file, "r")
            for line in f:
                l = line.split()
                room = Room()
                room.number = l[0]
                room.capacity = int(l[1])
                room.description = " ".join(l[2:])
                room.short_unlock_time = timezone.now()
                room.save()

            self.stdout.write("Successfully imported\n")
Exemple #21
0
 def post(self):
     data = request.json
     parser.parse_args(strict=True)
     for room in json_data:
         if room.get("number") == data["number"]:
             return "Room exist"
     else:
         rooms_data.append(
             Room(
                 data["number"],
                 data["level"],
                 data["status"],
                 data["price"],
             ).to_dict())
         write_data(rooms_data, json_file)
         return "Room added"
Exemple #22
0
 def get_queryset(self) -> QueryType[Text]:
     """Returns a queryset with a single record: the last, most recent text."""
     room = self.room
     if room.is_finished:
         raise PermissionDenied(detail='Story is finished')
     is_new_user: bool = self.request.user not in room.users.all()
     queryset_with_last_text = Text.objects.filter(room=room).reverse()[:1]
     if is_new_user:  # new users & guests can view anything
         return queryset_with_last_text
     user_membership = get_user_room_membership(self.request.user, room)
     if user_membership.status == Membership.STOPPED:
         raise PermissionDenied(detail='Left room')
     current_turn_user = Room.calculate_current_turn_user(self.room_title, self.request.user)
     user_membership.refresh_from_db()
     if user_membership.status != Membership.CAN_WRITE:
         raise PermissionDenied(detail=self._wrong_turn_error_detail(current_turn_user))
     return queryset_with_last_text
Exemple #23
0
def handle_uploaded_file(csvfile):
    rooms = []

    for line, row in enumerate(csv.reader(csvfile, delimiter=','), start=1):
        try:
            name, desc, hidden, av_single, av_double, b_single, b_double = row
        except ValueError as e:
            raise ValidationError("Line %(line)s - %(error)s", code="invalid",
                                  params={"line": line, "error": e})

        if name != "Name":
            rooms.append(
                Room(name=name, description=desc, hidden=hidden,
                     available_beds_single=av_single,
                     available_beds_double=av_double, beds_single=b_single,
                     beds_double=b_double))

    try:
        Room.objects.bulk_create(rooms)
    except ValueError:
        raise ValidationError(
            "Could not add rooms, check whether the file is properly formed and all values are correct.",
            code="invalid")
Exemple #24
0
class TestEditRoom(TestCase):
    def setUp(self):
        self.su = User.objects.create_user(username="******", password="******")

        self.su.is_staff, self.su.is_superuser = True, True
        self.su.first_name = "Super"
        self.su.last_name = "User"
        self.su.save()

        self.r = Room(title="2E")
        self.r.save()

        self.client.login(username="******", password="******")

    def test_edit_room(self):
        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(url, {
            "room-title": self.r.title,
            "room-unofficial_name": "Starry Night Surprise",
            "room-description": "Previous home to the best person on earth.",
            "room-occupancy": 5,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
        },
                                    follow=True)

        url = reverse("rooms:view", kwargs={"room_title": self.r.title})
        self.assertRedirects(response, url)
        self.assertContains(response, "2E")
        self.assertContains(response, "<dd>{0}</dd>".format(5), html=True)
        self.assertContains(response, "Starry Night Surprise")
        self.assertContains(
            response,
            "Previous home to the best person on earth.",
        )
        self.assertNotContains(response, self.su.get_full_name())

    def test_no_duplicate(self):
        r = Room.objects.create(title="1A")

        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(
            url, {
                "room-title": r.title,
                "room-unofficial_name": "",
                "room-description": "",
                "room-occupancy": 1,
                "residents-TOTAL_FORMS": 0,
                "residents-INITIAL_FORMS": 0,
                "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "A room with this title already exists.",
        )

    def test_edit_room_minimal(self):
        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(url, {
            "room-title": self.r.title,
            "room-unofficial_name": "",
            "room-description": "",
            "room-occupancy": 5,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
        },
                                    follow=True)

        url = reverse("rooms:view", kwargs={"room_title": self.r.title})
        self.assertRedirects(response, url)
        self.assertContains(response, "<dd>{0}</dd>".format(5), html=True)
        self.assertNotContains(response, "Starry Night Surprise")
        self.assertNotContains(response, self.su.get_full_name())

    def test_bad_occupancy(self):
        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(
            url, {
                "room-title": self.r.title,
                "room-unofficial_name": "Starry Night",
                "room-description": "Home to the best person on earth.",
                "room-occupancy": -1,
                "residents-TOTAL_FORMS": 0,
                "residents-INITIAL_FORMS": 0,
                "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "Ensure this value is greater than or equal to 0.",
        )

        response = self.client.post(
            url, {
                "title": self.r.title,
                "unofficial_name": "Starry Night",
                "description": "Home to the best person on earth.",
                "occupancy": "",
                "residents-TOTAL_FORMS": 0,
                "residents-INITIAL_FORMS": 0,
                "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "This field is required.")

    def test_bad_title(self):
        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(
            url, {
                "room-title": "",
                "room-unofficial_name": "",
                "room-description": "",
                "room-occupancy": 1,
                "residents-TOTAL_FORMS": 0,
                "residents-INITIAL_FORMS": 0,
                "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "This field is required.")

        response = self.client.post(
            url, {
                "room-title": "2a.",
                "room-unofficial_name": "",
                "room-description": "",
                "room-occupancy": 1,
                "residents-TOTAL_FORMS": 0,
                "residents-INITIAL_FORMS": 0,
                "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "Only alphanumeric characters are allowed.",
        )

        response = self.client.post(
            url, {
                "room-title": "3_",
                "room-unofficial_name": "",
                "room-description": "",
                "room-occupancy": 1,
                "residents-TOTAL_FORMS": 0,
                "residents-INITIAL_FORMS": 0,
                "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "Only alphanumeric characters are allowed.",
        )
Exemple #25
0
def store(request):
    if request.method == 'POST':
        r = Room()
        r.name = request.POST['name']
        r.save()
    return redirect('/rooms')
Exemple #26
0
def add_room(request):
    if (request.method == 'POST'):
        # print request.POST
        r = Room()
        r.name = request.POST['Name']
        r.capacity = request.POST['capacity']
        temp = request.POST.get('hasAC')
        if (temp != None):
            r.hasAC = True
        else:
            r.hasAC = False
        temp = request.POST.get('hasMic')
        if (temp != None):
            r.hasMic = True
        else:
            r.hasMic = False
        temp = request.POST.get('hasProjector')
        if (temp != None):
            r.hasProjector = True
        else:
            r.hasProjector = False
        r.save()
        return redirect('/')

    return render(request, 'add_room.html', {'user': request.user})
Exemple #27
0
def add_room(request):
    form = RoomImageForm()
    if request.method == "POST":
        form = RoomImageForm(request.POST)
        room = Room()
        room.name = request.POST.get('name')
        room.description = request.POST.get('description')
        room.square = request.POST.get('square')
        room.price_per_m2 = request.POST.get('price_per_m2')
        room.price = request.POST.get('price')
        room.comments = request.POST.get('comments')
        room.status = get_object_or_404(Status, pk=2)
        room.save()
        roomImage = RoomImage()
        roomImage.room = get_object_or_404(Room, pk=room.pk)
        roomImage.image = request.POST.get('image')
        roomImage.save()
        return redirect('/')
    return render(request, 'add_room.html', {
        "form": form,
        "username": auth.get_user(request).username
    })
Exemple #28
0
class TestEditRoom(TestCase):
    def setUp(self):
        self.su = User.objects.create_user(username="******", password="******")

        self.su.is_staff, self.su.is_superuser = True, True
        self.su.first_name = "Super"
        self.su.last_name = "User"
        self.su.save()

        self.r = Room(title="2E")
        self.r.save()

        self.client.login(username="******", password="******")

    def test_edit_room(self):
        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(url, {
            "room-title": self.r.title,
            "room-unofficial_name": "Starry Night Surprise",
            "room-description": "Previous home to the best person on earth.",
            "room-occupancy": 5,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
            }, follow=True)

        url = reverse("rooms:view", kwargs={"room_title": self.r.title})
        self.assertRedirects(response, url)
        self.assertContains(response, "2E")
        self.assertContains(response, "<dd>{0}</dd>".format(5), html=True)
        self.assertContains(response, "Starry Night Surprise")
        self.assertContains(
            response,
            "Previous home to the best person on earth.",
            )
        self.assertNotContains(response, self.su.get_full_name())

    def test_no_duplicate(self):
        r = Room.objects.create(title="1A")

        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(url, {
            "room-title": r.title,
            "room-unofficial_name": "",
            "room-description": "",
            "room-occupancy": 1,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "A room with this title already exists.",
            )

    def test_edit_room_minimal(self):
        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(url, {
            "room-title": self.r.title,
            "room-unofficial_name": "",
            "room-description": "",
            "room-occupancy": 5,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
            }, follow=True)

        url = reverse("rooms:view", kwargs={"room_title": self.r.title})
        self.assertRedirects(response, url)
        self.assertContains(response, "<dd>{0}</dd>".format(5), html=True)
        self.assertNotContains(response, "Starry Night Surprise")
        self.assertNotContains(response, self.su.get_full_name())

    def test_bad_occupancy(self):
        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(url, {
            "room-title": self.r.title,
            "room-unofficial_name": "Starry Night",
            "room-description": "Home to the best person on earth.",
            "room-occupancy": -1,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "Ensure this value is greater than or equal to 0.",
            )

        response = self.client.post(url, {
            "title": self.r.title,
            "unofficial_name": "Starry Night",
            "description": "Home to the best person on earth.",
            "occupancy": "",
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "This field is required.")

    def test_bad_title(self):
        url = reverse("rooms:edit", kwargs={"room_title": self.r.title})
        response = self.client.post(url, {
            "room-title": "",
            "room-unofficial_name": "",
            "room-description": "",
            "room-occupancy": 1,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "This field is required.")

        response = self.client.post(url, {
            "room-title": "2a.",
            "room-unofficial_name": "",
            "room-description": "",
            "room-occupancy": 1,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "Only alphanumeric characters are allowed.",
            )

        response = self.client.post(url, {
            "room-title": "3_",
            "room-unofficial_name": "",
            "room-description": "",
            "room-occupancy": 1,
            "residents-TOTAL_FORMS": 0,
            "residents-INITIAL_FORMS": 0,
            "residents-MAX_NUM_FORMS": 50,
            })

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            "Only alphanumeric characters are allowed.",
            )
Exemple #29
0
for room in rooms:
    try:
        building = Building.objects.get(pk= reversemap[room['buildingname']])
        continue
    except:
        print room['buildingname']
        continue
    # Check that we aren't doubling
    if building.name not in ['Main', 'Bogle', 'North B', 'North C']:
        continue
    roomobj = Room(number = room['number'],
                   sqft = room['sqft'],
                   occ = room['occ'],
                   subfree = room['subfree'],
                   numrooms = room['numrooms'],
                   floor = room['floor'],
                   gender = room['gender'],
                   avail = room['avail'],
                   adjacent = room['adjacent'],
                   ada = room['ada'],
                   bi = room['bi'],
                   con = room['con'],
                   bathroom = room['bathroom'],
                   building = building)
    roomobj.save()
    print room['number'], building




    def setUp(self):
        self.user = User.objects.get(username='******')
        self.client.force_authenticate(user=self.user)

        Room.create(self.ROOM_NUMBER, self.ROOM_CAPACITY, True)
Exemple #31
0
from rooms.models import Track, Artist, Room, Playlist_entry
from django.db import transaction
''' execute via ./manage.py shell < name_of_this_script.py '''

start = time()
t = start

artists_query_set = Artist.objects.all()
tracks_query_set = Track.objects.all()
tracks_count = tracks_query_set.count()
rooms_list = []
#track_artist_list = []
playlist_entries_list = []

for i in range(0, 10000):
    rooms_list.append(Room(name='room' + str(i)))

#for i in range(0, 100000):
#    artists_list.append(Artist(name='artist'+str(i)))

#print('Created 10 000 rooms, 100 000 artists models... ' + str(time()-t) )
#t = time()

# create room, artists BEFORE using
# foreign key to them while creating tracks and rooms

Room.objects.bulk_create(rooms_list)
#Artist.objects.bulk_create(artists_list)

#print('Created db rows for rooms, artists... ' + str(time()-t) )
#t = time()
Exemple #32
0
mapfile = open('reversemap.dat')
reversemap = pickle.load(mapfile)

for room in rooms:
    try:
        building = Building.objects.get(pk=reversemap[room['buildingname']])
        continue
    except:
        print room['buildingname']
        continue
    # Check that we aren't doubling
    if building.name not in ['Main', 'Bogle', 'North B', 'North C']:
        continue
    roomobj = Room(number=room['number'],
                   sqft=room['sqft'],
                   occ=room['occ'],
                   subfree=room['subfree'],
                   numrooms=room['numrooms'],
                   floor=room['floor'],
                   gender=room['gender'],
                   avail=room['avail'],
                   adjacent=room['adjacent'],
                   ada=room['ada'],
                   bi=room['bi'],
                   con=room['con'],
                   bathroom=room['bathroom'],
                   building=building)
    roomobj.save()
    print room['number'], building