Ejemplo n.º 1
0
def poll_create(request):
    if request.user.is_authenticated():
        if request.method == 'POST':
            poll_form = PollCreateForm(request.POST, prefix="poll")
            if poll_form.is_valid():
                print 'Valid Form'
                unsaved_poll = poll_form.save(commit=False)
                unsaved_poll.member = request.user.members
                unsaved_poll.save()
                history = History(user = request.user.members, item_type = 'POLL', item_id = unsaved_poll.id)
                history.save()
                return HttpResponseRedirect("/polls/"+str(unsaved_poll.id))

        poll_form = PollCreateForm(prefix="poll")
        try:
            polls = Poll.objects.filter(member = request.user.members)
        except:
            polls = []
        template_dict = {
            'error': '',
            'poll_form' : poll_form,
            'polls': polls
        }
        return render_to_response(
            'user_pages/polls/poll_create.html',
            template_dict, 
            context_instance=RequestContext(request)
        )
    else:
        return HttpResponseRedirect("/login/")
Ejemplo n.º 2
0
    def recover(self, request):
        ''' Allows users to ask for password recovery(which needs to be confirmed).
        '''
        if request.user.is_authenticated():
            return Response({
                'error':
                "An already logged in user can't recover a password!"
            })
        email = request.data.get('email', None)

        if email != None:
            email = email.lower()
            try:
                usr = User.objects.get(email=email)

                ur = UserRecovery(user=usr)

                ur.save()

                History.new(event=History.RECOVER,
                            actor=usr,
                            object=ur,
                            authorized=[usr])

                return Response({'success': True})

            except User.DoesNotExist:
                pass

            return Response(
                {'error': "An user with this email does not exist."})
Ejemplo n.º 3
0
    def changePassword(self, request):
        '''
        Allows users to change their own password, after confirming a password recovery.
        '''
        if request.user.is_authenticated():
            return Response(
                {
                    'error':
                    "An already logged in user can't recover a password!"
                },
                status=status.HTTP_400_BAD_REQUEST)

        hash = request.data.get('hash', None)
        new_password = request.data.get('password', None)

        if hash != None and new_password != None:
            try:
                userRecovery = UserRecovery.getUserRecovery(hash=hash)

                userRecovery.setNewPassword(new_password)

                History.new(event=History.EDIT,
                            actor=userRecovery.user,
                            object=userRecovery.user,
                            authorized=[userRecovery.user])

                return Response({'success': True}, status=status.HTTP_200_OK)
            except (UserRecovery.DoesNotExist, AttributeError):
                return Response({
                    'error':
                    "Either the request does not exist, or it has expired."
                })

        return Response({'error': "This request is not valid."})
Ejemplo n.º 4
0
    def retrieve(self, request, *args, **kwargs):
        """
        Retrieve a task details, by id
        """
        History.new(event=History.ACCESS, actor=request.user, object=self.get_object())

        return super(TaskViewSet, self).retrieve(request, args, kwargs)
Ejemplo n.º 5
0
    def create(self, request, *args, **kwargs):
        """
        Insert a new workflow

        """
        request.data[u'owner'] = request.user.id

        d = copy.deepcopy(request.data)

        request.data.pop('tasks')
        # first round without tasks, to get reference to workflow instance
        serializer, headers = create_serializer(self, request)

        # create tasks...
        wf = serializer.save()

        d = self.__linkTasks(d, wf)

        print d

        serializer = WorkflowSerializer(instance=wf, data=d, partial=True)
        serializer.is_valid(raise_exception=True)
        # add tasks dependencies
        serializer.save()

        History.new(event=History.ADD,
                    actor=request.user,
                    object=serializer.instance)

        return Response(serializer.data,
                        status=status.HTTP_201_CREATED,
                        headers=headers)
Ejemplo n.º 6
0
    def invite(self, request):
        '''
            Allows a user to register anothers users. Being then put on a waiting list to be approved.
        '''
        userList = []
        for usr in request.data:
            email = usr.get('email', None)
            password = "******"  #Default password, the user will be notice to change it. This needs to be changed

            if email != None:
                email = email.lower()

                try:
                    usr = User.objects.get(email=email)
                    userList += [usr]
                except User.DoesNotExist:
                    try:
                        usr['first_name'] = usr['firstName']
                        usr['last_name'] = usr['lastName']
                    except:
                        usr['first_name'] = ""
                        usr['last_name'] = ""

                    usr['username'] = email[:30]
                    usr['email'] = email
                    usr['profile'] = {
                        'detail_mode': Profile.get_default_detail_mode()
                    }

                    serializer = UserSerializer(data=usr)
                    valid = serializer.is_valid(raise_exception=True)

                    if valid:
                        new_user = serializer.save()

                        new_user.set_password(password)
                        new_user.is_active = True  #I decide let the userbe active in the first place because this is a invite
                        new_user.save()
                        userList += [new_user]

                        ur = UserRecovery(user=new_user)
                        ur.save()

                        History.new(event=History.INVITE,
                                    actor=request.user,
                                    object=ur,
                                    authorized=[new_user])
            else:
                return Response({
                    'error':
                    "Email are mandatory fields on registering a new user"
                })
        serializer_context = {
            'request': request,
        }
        serializerAll = UserSerializer(userList,
                                       many=True,
                                       context=serializer_context)
        return Response(serializerAll.data)
Ejemplo n.º 7
0
    def register(self, request):
        '''
        Allows users to register themselves. Being then put on a waiting list to be approved.
        '''
        if request.user.is_authenticated():
            return Response(
                {
                    'error':
                    "An already registered user can't register new users!"
                }, status.HTTP_400_BAD_REQUEST)
        dataRequest = request.data.copy()
        password = dataRequest.pop('password', None)
        email = dataRequest.get('email', None)

        if email != None and password != None:
            email = email.lower()

            try:
                user = User.objects.get(email=email)

                return Response(
                    {'error': "An user with this email already exists"},
                    status=status.HTTP_400_BAD_REQUEST)
            except User.DoesNotExist:
                if (not 'username' in dataRequest):
                    dataRequest['username'] = email[:30]
                dataRequest['email'] = email
                serializer = UserSerializer(data=dataRequest,
                                            context={'request': request})

                user_validated = serializer.is_valid(raise_exception=True)

                if user_validated:
                    new_user = serializer.save()

                    new_user.set_password(password)
                    new_user.is_active = False
                    new_user.save()

                    staff = User.objects.filter(is_staff=True)

                    History.new(event=History.ADD,
                                actor=new_user,
                                object=new_user,
                                authorized=staff)

                    return Response(serializer.data,
                                    status=status.HTTP_201_CREATED)
                return Response({'error': "User details invalid"},
                                status=status.HTTP_400_BAD_REQUEST)

        return Response(
            {
                'error':
                "Email and password are mandatory fields on registering a new user"
            },
            status=status.HTTP_400_BAD_REQUEST)
Ejemplo n.º 8
0
Archivo: api.py Proyecto: kotenev/taska
    def retrieve(self, request, *args, **kwargs):
        """
        Retrieve a resource details, by hash
        """
        History.new(event=History.ACCESS,
                    actor=request.user,
                    object=self.get_object())

        return super(ResourceViewSet, self).retrieve(request, args, kwargs)
Ejemplo n.º 9
0
    def defeat(self, event):
        profile = Profile.objects.get(user_id=event['data']['player'])
        profile.defeat = profile.defeat + 1
        profile.save()

        history = History(user_id=event['data']['player'],
                          text="Lose a fight",
                          type="defeat")
        history.save()
Ejemplo n.º 10
0
    def retrieve(self, request, *args, **kwargs):
        """
        Retrieve a result, by id

        """
        instance = self.get_object()
        History.new(event=History.ACCESS, actor=request.user, object=instance, related=[instance.processtaskuser.processtask.process])

        return super(ResultViewSet, self).retrieve(request, args, kwargs)
Ejemplo n.º 11
0
    def victory(self, event):
        profile = Profile.objects.get(user_id=event['data']['player'])
        profile.victory = profile.victory + 1
        profile.save()

        history = History(user_id=event['data']['player'],
                          text="Won a fight",
                          type="victory")
        history.save()
Ejemplo n.º 12
0
    def retrieve(self, request, *args, **kwargs):
        """
        Retrieve a form, by id

        """
        instance = self.get_object()
        History.new(event=History.ACCESS, actor=request.user, object=instance)

        return Response(FormSerializer(instance).data)
Ejemplo n.º 13
0
    def reject(self, comment):
        self.status = ProcessTaskUser.REJECTED
        self.save()
        History.new(event=History.REJECT,
                    actor=self.user,
                    object=self,
                    observations=comment)

        self.processtask.refreshState()
        self.processtask.move()
Ejemplo n.º 14
0
    def create(self, request, *args, **kwargs):
        """
        Add a result as a response to a task

        """
        serializer, headers = create_serializer(self, request)

        History.new(event=History.ADD, actor=request.user, object=serializer.instance)

        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
Ejemplo n.º 15
0
    def retrieve(self, request, *args, **kwargs):
        """
        Retrieve a workflow, by id including related tasks

        """
        History.new(event=History.ACCESS,
                    actor=request.user,
                    object=self.get_object())

        return Response(WorkflowDetailSerializer(self.get_object()).data)
Ejemplo n.º 16
0
def res(request):
    f = Cart.objects.filter(customer=request.user)
    print(f)
    for i in range(0, len(f)):
        h = History()
        h.item = f[i].name
        h.quantity = f[i].quantity
        h.totalcost = f[i].totalcost
        h.customer = f[i].customer
        h.order_date = timezone.datetime.now()
        #h.reserve_time = s
        print(f[i])
        f[i].delete()
        h.save()
        print(h)
    t = Transactions()
    t.customer = request.user
    t.totalcost = (request.POST['cost'])
    t.order_date = timezone.datetime.now()
    t.save()
    #------------------------------------send mail----------------------------------------------
    hi = History.objects.filter(customer=request.user, status="P")
    rec = str(request.user.email)
    html_content = render_to_string('transaction/email.html', {'hi': hi})
    text_content = strip_tags(html_content)
    email = EmailMultiAlternatives("Your Order", text_content,
                                   settings.EMAIL_HOST_USER, [rec])
    email.attach_alternative(html_content, "text/html")
    email.send()
    return redirect('home')
Ejemplo n.º 17
0
def create_trip(request, traveller_id):
    traveller_user = get_object_or_404(Traveller, pk=traveller_id)
    traveller_user_logged_in = get_object_or_404(Traveller, email=request.user)
    guide_user = get_object_or_404(Guide, email=request.user)
    if 'confirm' in request.POST:
        traveller = traveller_user.email
        guide = request.user
        place = Place.objects.filter(name=request.POST['place']).first()
        no_of_people = request.POST['no_of_people']
        no_of_children = request.POST['no_of_children']
        total_hours = request.POST['travel_hours']
        nop = float(no_of_people)
        noc = float(no_of_children)
        noh = float(total_hours)
        if ((nop + noc * 0.75) <= 2):
            tp = 2 * noh * float(guide_user.price)
            tp = int(tp)
        elif ((nop + noc * 0.75) >= 8):
            tp = 8 * noh * float(guide_user.price)
            tp = int(tp)
        else:
            tp = (nop + noc * 0.75) * noh * float(guide_user.price)
            tp = int(tp)
        history = History(traveller=traveller,
                          guide=guide,
                          place=place,
                          no_of_people=no_of_people,
                          no_of_children=no_of_children,
                          total_hours=total_hours,
                          total_price=tp)
        history.save()
        trip_notification = Trip_Notification(
            receiver_email=traveller_user.email,
            sender_email=request.user,
            form=history)
        trip_notification.save()
        traveller_id = request.POST['traveller_id']
        return redirect('/view_profile/' + traveller_id)

    places = guide_user.places.all()
    place_pattern = ''
    for place in places:
        place_pattern = place.name + '|' + place_pattern

    context = {
        'traveller_user': traveller_user,
        'logged_in_user': traveller_user_logged_in,
        'places': places,
        'place_pattern': place_pattern[:-1],
        'guide_user': guide_user,
    }
    # print(guide_user.place)
    return render(request, 'travellers/create_trip.html', context)
Ejemplo n.º 18
0
    def destroy(self, request, *args, **kwargs):
        """
        Delete a form, by id
        """
        instance = self.get_object()

        instance.removed = True
        instance.save()

        History.new(event=History.DELETE, actor=request.user, object=instance)

        return Response(status=status.HTTP_204_NO_CONTENT)
Ejemplo n.º 19
0
def signed(request, pet_id):
    p = get_object_or_404(Petition, pk=pet_id)
    userobject = get_object_or_404(Member, user=request.user)
    print userobject
    print "^^userobject^^"
    already_signed = SignPetition.objects.filter(user=userobject).filter(
        signedpet_id=pet_id)
    print already_signed
    if request.method == 'POST':
        signform = PetitionSignForm(request.POST)
        if already_signed:
            print "user already signed this petition!!!"
        elif signform.is_valid():
            print 'user not signed yet. going to update database'
            instance = signform.save(commit=False)
            instance.user = userobject
            instance.signedpet = p
            instance.save()
            p.current_num = p.current_num + 1
            p.save()
            new_hist = History()
            new_hist.user = userobject
            new_hist.item_type = "SIGN"
            new_hist.timestamp = datetime.datetime.now()
            new_hist.item_id = instance.id
            new_hist.save()
    return HttpResponseRedirect('/petitions/' + pet_id + '/')
Ejemplo n.º 20
0
def index(request):
    userobject = Member.objects.get(user=request.user)
    print userobject
    if request.method == 'POST':
        form = PetitionForm(request.POST)
        if form.is_valid():
            newpetobj = form.save(commit=False)
            newpetobj.user = userobject
            newpetobj.current_num = 0
            newpetobj.timestamp = datetime.datetime.now()
            newpetobj.save()
            new_hist = History()
            new_hist.user = userobject
            new_hist.item_type = "PETITION"
            new_hist.timestamp = newpetobj.timestamp
            new_hist.item_id = newpetobj.id
            new_hist.save()
            return HttpResponseRedirect('/petitions/')
    else:
        form = PetitionForm()

    return render_to_response('user_pages/home/base_home_petitions.html', {
        'form': form,
    },
                              context_instance=RequestContext(request))
Ejemplo n.º 21
0
def index(request):
    userobject = Member.objects.get(user=request.user)
    inv_list = Invited.objects.filter(invited_user=userobject).values_list(
        'debateinvite_id', flat=True)
    debate_list = Debate.objects.filter(id__in=inv_list)
    part_list = Participants.objects.filter(
        participant=userobject).values_list('debateparticipate_id', flat=True)
    part_deb_list = Debate.objects.filter(id__in=part_list)
    if request.method == 'POST':
        #form1=InviteDebateForm()
        form2 = ParticipantDebateForm()
        form = CreateDebateForm(request.POST)
        print 'request method is post(index)'
        if form.is_valid():
            print 'form is valid(index)'
            new_debate = form.save(commit=False)
            new_debate.created_by = userobject
            new_debate.privacy = "none"
            new_debate.timestamp = datetime.datetime.now()
            new_debate.save()
            #
            #	HISTORY TABLE UPDATION>>>
            #
            new_hist = History()
            new_hist.user = userobject
            new_hist.item_type = "DEBATE"
            new_hist.timestamp = new_debate.timestamp
            new_hist.item_id = new_debate.id
            new_hist.save()
            #p=get_object_or_404(Debate,pk=pet_id)
            print new_debate.num_part
            formset1 = formset_factory(InviteDebateForm,
                                       extra=new_debate.num_part)
            form1 = formset1()
            return render_to_response('user_pages/home/base_home_debate.html',
                                      {
                                          'dform1': form1,
                                          'dform2': form2,
                                          'new_debate': new_debate,
                                          'cur_user': request.user
                                      },
                                      context_instance=RequestContext(request))
        else:
            form = CreateDebateForm()
            return render_to_response('user_pages/home/base_home_debate.html',
                                      {
                                          'debate_list': debate_list,
                                          'part_deb_list': part_deb_list,
                                          'dform': form,
                                      },
                                      context_instance=RequestContext(request))
    else:
        form = CreateDebateForm()
        return render_to_response('user_pages/home/base_home_debate.html', {
            'debate_list': debate_list,
            'part_deb_list': part_deb_list,
            'dform': form,
        },
                                  context_instance=RequestContext(request))
Ejemplo n.º 22
0
    def update(self, request, *args, **kwargs):
        """
        Update a task

        """
        partial = kwargs.pop('partial', False)
        instance = self.get_object()

        serializer = instance.init_serializer(instance=instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)

        History.new(event=History.EDIT, actor=request.user, object=instance)

        return Response(serializer.data)
Ejemplo n.º 23
0
    def fork(self, request, hash=None):
        """
        Duplicates a public or owned workflow, returning the duplicate
        """
        workflow = self.get_object()

        if workflow.permissions().forkable:
            new_workflow = workflow.fork(owner=request.user)

            History.new(event=History.ADD,
                        actor=request.user,
                        object=new_workflow)

            return Response(WorkflowSerializer(new_workflow).data)

        return Response({"error": "Workflow isn't forkable"}, 403)
Ejemplo n.º 24
0
    def create(self, request, *args, **kwargs):
        """
        Insert a new Form

        """
        request.data[u'creator'] = request.user.id

        serializer, headers = create_serializer(self, request)

        History.new(event=History.ADD,
                    actor=request.user,
                    object=serializer.instance)

        return Response(serializer.data,
                        status=status.HTTP_201_CREATED,
                        headers=headers)
Ejemplo n.º 25
0
    def register(self, request):
        ''' Allows users to register themselves. Being then put on a waiting list to be approved.
        '''
        if request.user.is_authenticated():
            return Response({
                'error':
                "An already registered user can't register new users!"
            })
        password = request.data.pop('password', None)
        email = request.data.get('email', None)

        if email != None and password != None:
            email = email.lower()

            try:
                usr = User.objects.get(email=email)

                return Response(
                    {'error': "An user with this email already exists"})
            except User.DoesNotExist:
                request.data['username'] = email[:30]
                request.data['email'] = email
                serializer = UserSerializer(data=request.data,
                                            context={'request': request})

                valid = serializer.is_valid(raise_exception=True)

                if valid:
                    new_user = serializer.save()

                    new_user.set_password(password)
                    new_user.is_active = False
                    new_user.save()

                    History.new(event=History.ADD,
                                actor=new_user,
                                object=new_user,
                                authorized=User.objects.filter(is_staff=True))

                    return Response(serializer.data)

                return Response({'error': "User details invalid"})

        return Response({
            'error':
            "Email and password are mandatory fields on registering a new user"
        })
Ejemplo n.º 26
0
def warnBeforeDeadlines():
    allProcess = Process.allWithNotificationBeforeDelay()
    for process in allProcess:
        ptasks = ProcessTask.all(process=process).filter(
            status=ProcessTask.RUNNING)
        for ptask in ptasks:
            if (((ptask.deadline - timezone.now()).days +
                 1) == process.days_before_delay):
                pusers = ptask.users()

                for puser in pusers:
                    if (puser.finished == False):
                        History.new(event=History.REMAINDER,
                                    actor=puser.user,
                                    object=puser,
                                    authorized=[puser.user],
                                    related=[puser.processtask.process])
Ejemplo n.º 27
0
    def resignRejectedUser(self, oldUser, newUser):
        tasks = ProcessTaskUser.all(processtask=self).filter(user=oldUser)
        exists = ProcessTaskUser.all(processtask=self).filter(
            user=newUser).count()
        if exists == 0 or int(oldUser) == int(newUser):
            for task in tasks:
                task.changeUser(newUser)

                History.new(event=History.ADD,
                            actor=task.processtask.process.executioner,
                            object=task.processtask.process,
                            authorized=[newUser],
                            related=[task.processtask.process])
        else:
            for task in tasks:
                task.delete()
        self.save()
Ejemplo n.º 28
0
def warnLateDeadlines():
    allProcess = Process.allWithDelay()
    for process in allProcess:
        ptasks = ProcessTask.all(process=process).filter(
            status=ProcessTask.RUNNING, deadline__lt=timezone.now())
        for ptask in ptasks:
            if ((((ptask.deadline - timezone.now()).days + 1) %
                 process.days_after_delay) == 0):
                pusers = ptask.users()

                for puser in pusers:
                    if (puser.finished == False):
                        History.new(event=History.LATE,
                                    actor=puser.user,
                                    object=puser,
                                    authorized=[puser.user],
                                    related=[puser.processtask.process])
Ejemplo n.º 29
0
    def update(self, request, *args, **kwargs):
        """
        Update an already existing form

        """
        request.data[u'creator'] = request.user.id

        instance = self.get_object()

        serializer = FormSerializer(instance=instance,
                                    data=request.data,
                                    partial=True)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)

        History.new(event=History.EDIT, actor=request.user, object=instance)

        return Response(serializer.data)
Ejemplo n.º 30
0
def buy(request):
    profile = request.user.profile
    package = Package.objects.get(id=request.POST.get('id'))
    if package.price > profile.credits:
        return render(request, 'store/buy.html', {'success': False})

    cards = Card.objects.get_random(package.cards_count)

    profile.cards.add(*cards)
    profile.credits -= package.price
    profile.save()

    history = History(user=request.user,
                      text="Bought a new pack of " + package.cards_count.__str__() + " cards",
                      type='store')
    history.save()

    return render(request, 'store/buy.html', {'success': True, 'package': package, 'cards': cards})
Ejemplo n.º 31
0
def create_history(history_type_dict, source_object=None, data=None):
    history_type = get_object_or_404(HistoryType, namespace=history_type_dict['namespace'], name=history_type_dict['name'])
    new_history = History(history_type=history_type)
    if source_object:
        new_history.content_object = source_object
    if data:
        new_dict = {}
        for key, value in data.items():
            new_dict[key] = {}
            if isinstance(value, models.Model):
                new_dict[key]['value'] = serializers.serialize('json', [value])
            elif isinstance(value, models.query.QuerySet):
                new_dict[key]['value'] = serializers.serialize('json', value)
            else:
                new_dict[key]['value'] = json.dumps(value)
            new_dict[key]['type'] = pickle.dumps(type(value))

        new_history.dictionary = json.dumps(new_dict)
    new_history.save()
Ejemplo n.º 32
0
 def test_convert_its_RST_text_to_HTML(self):
     h = History(text="*NSI* site rulz!")
     h.to_html() |should| contain('<em>NSI</em> site rulz!')
Ejemplo n.º 33
0
def parse_jabong(request):
    website = Website.objects.get(name="Jabong")
    brand = Brand.objects.get(name="Adidas")
    category = Category.objects.get(name="Shoes")
    url = 'http://www.jabong.com/men/shoes/men-sports-shoes/Adidas/?special_price=1&page=4'
    user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
    values = {}
    headers = {
        'User-Agent': user_agent,
        'X-Requested-With': 'XMLHttpRequest'
    }

    data = urllib.urlencode(values)
    req = urllib2.Request(url, data, headers)
    response = urllib2.urlopen(req)
    html = response.read()
    tree = lxml.html.fromstring(html)
    for el in tree.cssselect("li.itm a.itm-link"):
        print el.cssselect(".itm-title")[0].text.strip()
        try:
            search_item = Item.objects.get(name=el.cssselect(".itm-title")[0].text.strip())
        except:
            search_item = None
        print search_item
        if search_item is None:
            print "Item does not exist. Creating new"
            item = Item()
            item.name = el.cssselect(".itm-title")[0].text.strip()
            print item.name
            item.gender_type = "MALE"
            product_url = el.attrib["href"]
            item.url = product_url
            item.category = category
            item.brand = brand
            item.website = website
            item.slug = slugify(item.name + "=" + item.website.slug)
            old_price_text = el.cssselect(".itm-price.old")[0].text
            new_price_text = el.cssselect(".itm-price.special-b")[0].text
            discount_rate_text = el.cssselect(".itm-price.discount")[0].text
            re_float = re.compile(r'.*?(?P<number>\d+\.?\d*).*?')
            old_price = re_float.match(old_price_text).group("number")
            new_price = re_float.match(new_price_text).group("number")
            discount_rate = re_float.match(discount_rate_text).group("number")

            user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
            values = {}
            headers = {
                'User-Agent': user_agent,
            }
            data = urllib.urlencode(values)
            req = urllib2.Request(product_url, data, headers)
            product_response = urllib2.urlopen(req)
            product_html = product_response.read()
            product_tree = lxml.html.fromstring(product_html)
            print product_tree
            print product_tree.cssselect(".prd-image")
            print product_tree.cssselect(".prd-image")[0].attrib["src"]
            item.image_url1 = product_tree.cssselect("#prdImage")[0].attrib["src"]
            item.details = product_tree.cssselect(".prd-description")[0].text
            item.save()
            history = History()
            history.item = item
            history.offer_text = item.brand.name + " " + item.name + " " + old_price_text + " " + new_price_text + " " + discount_rate_text
            history.selling_price = float(new_price)
            history.actual_price = float(old_price)
            history.discount_rate = float(discount_rate)
            history.is_on_sale = True
            history.save()

            print item
        print "#######################################"
    return HttpResponse(html)