Esempio n. 1
0
def send_all():
    lock = FileLock("send_notices")

    logging.debug("acquiring lock...")
    try:
        lock.acquire(LOCK_WAIT_TIMEOUT)
    except AlreadyLocked:
        logging.debug("lock already in place. quitting.")
        return
    except LockTimeout:
        logging.debug("waiting for the lock timed out. quitting.")
        return
    logging.debug("acquired.")

    batches, sent = 0, 0
    start_time = time.time()

    try:
        # nesting the try statement to be Python 2.4
        try:
            for queued_batch in NoticeQueueBatch.objects.all():
                notices = pickle.loads(str(queued_batch.pickled_data).decode("base64"))
                batch_sent = 0
                for user, label, extra_context, on_site, sender in notices:
                    try:
                        user = User.objects.get(pk=user)
                        logging.info("emitting notice to %s" % user)
                        # call this once per user to be atomic and allow for logging to
                        # accurately show how long each takes.
                        notification.send_now([user], label, extra_context, on_site, sender)
                        sent += 1
                        batch_sent += 1
                    except:
                        # get the exception
                        _, e, _ = sys.exc_info()
                        # log it as critical
                        logging.critical("an exception occurred: %r" % e)
                        # update the queued_batch, removing notices that had been sucessfully sent
                        queued_batch.pickled_data = pickle.dumps(notices[batch_sent:]).encode("base64")
                        queued_batch.save()
                queued_batch.delete()
                batches += 1
        except:
            # get the exception
            exc_class, e, t = sys.exc_info()
            # email people
            current_site = Site.objects.get_current()
            subject = "[%s emit_notices] %r" % (current_site.name, e)
            message = "%s" % ("\n".join(traceback.format_exception(*sys.exc_info())),)
            mail_admins(subject, message, fail_silently=True)
            # log it as critical
            logging.critical("an exception occurred: %r" % e)
    finally:
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")
    
    logging.info("")
    logging.info("%s batches, %s sent" % (batches, sent,))
    logging.info("done in %.2f seconds" % (time.time() - start_time))
def image_detail(request, id, template_name="loupe/image_detail.html"):
    """
    Displays the image to be discussed by the project members

    expects an id for the image and the user has access to the parent project
    """
    if not request.user.is_staff:
        image = get_object_or_404(Image, pk=id, corkboard__project__members=request.user)
    else:
        image = get_object_or_404(Image, pk=id)

    notes = Note.objects.filter(image=image)
    notes_count = notes.count()
    form = NoteForm()

    if request.method == "POST":
        form = NoteForm(request.user, request.POST)
        if form.is_valid():
            note = form.save(commit=False)
            note.user = request.user
            note.image = image
            note.save()
            if notification:
                notification.send_now(
                    image.corkboard.project.members.all(),
                    "corkboard_new_image_note",
                    {"user": request.user, "image_url": image.get_absolute_url, "image": image},
                )
            request.user.message_set.create(message=_("Successfully attached note to image '%s'") % image.title)

    return render_to_response(
        template_name,
        {"image": image, "notes": notes, "notes_count": notes_count, "form": form},
        context_instance=RequestContext(request),
    )
def send_all():
    lock = FileLock("send_notices")

    logging.debug("acquiring lock...")
    try:
        lock.acquire(NOTIFICATION_LOCK_WAIT_TIMEOUT)
    except AlreadyLocked:
        logging.debug("lock already in place. quitting.")
        return
    except LockTimeout:
        logging.debug("waiting for the lock timed out. quitting.")
        return
    logging.debug("acquired.")

    batches, sent = 0, 0
    start_time = time.time()

    try:
        # nesting the try statement to be Python 2.4
        try:
            for queued_batch in NoticeQueueBatch.objects.all():
                notices = pickle.loads(
                    str(queued_batch.pickled_data).decode("base64"))
                for user, label, extra_context, on_site in notices:
                    user = User.objects.get(pk=user)
                    logging.info("emitting notice to %s" % user)
                    # call this once per user to be atomic and allow for 
                    # logging to accurately show how long each takes.
                    notification.send_now([user], label, extra_context, on_site)
                    sent += 1
                queued_batch.delete()
                batches += 1
        except:
            # get the exception
            exc_class, e, t = sys.exc_info()
            # email people
            
            if NOTIFICATION_USE_SITE:
                name = Site.objects.get_current().name
            elif NOTIFICATION_DEFAULT_SITE_NAME:
                name = NOTIFICATION_DEFAULT_SITE_NAME
            else:
                # don't display None, display just a space
                name = ""

            subject = "[%s emit_notices] %r" % (name, e)
               
            message = "%s" % ("\n".join(
                    traceback.format_exception(*sys.exc_info())),)
            mail_admins(subject, message, fail_silently=True)
            # log it as critical
            logging.critical("an exception occurred: %r" % e)
    finally:
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")
    
    logging.info("")
    logging.info("%s batches, %s sent" % (batches, sent,))
    logging.info("done in %.2f seconds" % (time.time() - start_time))
Esempio n. 4
0
def expiration_notification(sender, **kwargs):
    """
    FIXME: Migrate it (txcron) to work with the String Level.
    """
    logger.debug("lock-addon: Sending expiration notifications...")
    if not settings.ENABLE_NOTICES:
        logger.debug("lock-addon: ENABLE_NOTICES is not enabled")
        return
    current_site = Site.objects.get_current()
    locks = Lock.objects.expiring()
    nt = 'project_resource_language_lock_expiring'
    for lock in locks:
        context = {
            'resource': lock.rlstats.resource,
            'language': lock.rlstats.language,
            'project': lock.rlstats.resource.project,
            'user': lock.owner,
            'expires': lock.expires,
            'current_site': current_site
        }
        logger.debug("lock-addon: Sending notification about lock: %s" % lock)
        notification.send_now([
            lock.owner,
        ], nt, context)
        lock.notified = True
        lock.save()
Esempio n. 5
0
def register(request):
    invite = request.session['profile-invite']
    if request.method == 'POST':
        userForm = forms.UserForm(request.POST, prefix='user')
        profileForm = ProfileForm(request.POST, prefix='profile')
    else:
        userForm = forms.UserForm(prefix='user')
        profileForm = ProfileForm(prefix='profile')
    if userForm.is_valid() and profileForm.is_valid():
        oldUser = None
        try:
            oldUser = User.objects.get(username__exact=userForm.cleaned_data['username'])
        except ObjectDoesNotExist, e:
            pass
        if not oldUser:
            user = User.objects.create_user(userForm.cleaned_data['username'], userForm.cleaned_data['email'], userForm.cleaned_data['password'])
            user.save()
            invite.claimer = user
            invite.save()
            profile = user.minecraftprofile
            profile.mc_username = profileForm.cleaned_data['mc_username']
            profile.save()
            user = authenticate(username=userForm.cleaned_data['username'], password=userForm.cleaned_data['password'])
            notification.send_now([invite.creator], "invite_accepted", {"new_user": user})
            login(request, user)
            del request.session['profile-invite']
            return HttpResponseRedirect("/")
Esempio n. 6
0
def notify_expired_accounts():
    expired_accounts = Account.objects.filter(status='EXPIRED')
    for account in expired_accounts:
        notification.send_now([account.user], "account_expired", {
            'user': account.user,
            'site': Site.objects.get_current()
        }, True)
Esempio n. 7
0
def emit_batch(queued_batch):
    sent = 0
    try:
        notices = pickle.loads(str(queued_batch.pickled_data).decode("base64"))
        for user, label, extra_context, on_site, sender, kwargs in notices:
            try:
                user = User.objects.get(pk=user)
                logging.info("emitting notice %s to %s" % (label, user))
                # call this once per user to be atomic and allow for logging to
                # accurately show how long each takes.
                notification.send_now([user], label, extra_context,
                        on_site, sender, **kwargs)
            except User.DoesNotExist:
                # Ignore deleted users, just warn about them
                logging.warning("not emitting notice %s to user %s since it "
                        "does not exist" % (label, user))
            sent += 1
        queued_batch.delete()
    except:
        # get the exception
        exc_class, e, t = sys.exc_info()
        # email people
        current_site = Site.objects.get_current()
        subject = "[%s emit_notices] %r" % (current_site.name, e)
        message = "%s" % ("\n".join(traceback.format_exception(
            *sys.exc_info())),)
        mail_admins(subject, message, fail_silently=True)
        # log it as critical
        logging.critical("an exception occurred: %r" % e)
    return sent
Esempio n. 8
0
def send_all():
    lock = FileLock("send_notices")

    logging.debug("acquiring lock...")
    try:
        lock.acquire(LOCK_WAIT_TIMEOUT)
    except AlreadyLocked:
        logging.debug("lock already in place. quitting.")
        return
    except LockTimeout:
        logging.debug("waiting for the lock timed out. quitting.")
        return
    logging.debug("acquired.")

    batches, sent = 0, 0
    start_time = time.time()

    try:
        # nesting the try statement to be Python 2.4
        try:
            for queued_batch in NoticeQueueBatch.objects.all():
                data = str(queued_batch.pickled_data).decode("base64")
                notices = pickle.loads(data)
                for user, label, extra_context, on_site, sender in notices:
                    try:
                        user = User.objects.get(pk=user)
                        logging.info("emitting notice %s to %s" %
                                                                (label, user))
                        # call this once per user to be atomic and allow for
                        # logging to accurately show how long each takes.
                        notification.send_now([user], label, extra_context,
                                              on_site, sender)
                    except User.DoesNotExist:
                        # Ignore deleted users, just warn about them
                        logging.warning("not emitting notice %s to user %s"
                                        " since it does not exist" %
                                                                (label, user))
                    sent += 1
                queued_batch.delete()
                batches += 1
        except:
            # get the exception
            exc_class, e, t = sys.exc_info()
            # email people
            current_site = Site.objects.get_current()
            subject = "[%s emit_notices] %r" % (current_site.name, e)
            message = "%s" % ("\n".join(
                                traceback.format_exception(*sys.exc_info())),)
            mail_admins(subject, message, fail_silently=True)
            # log it as critical
            logging.critical("an exception occurred: %r" % e)
    finally:
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")

    logging.info("")
    logging.info("%s batches, %s sent" % (batches, sent,))
    logging.info("done in %.2f seconds" % (time.time() - start_time))
Esempio n. 9
0
def send_all():
    lock = FileLock("send_notices")

    logging.debug("acquiring lock...")
    try:
        lock.acquire(LOCK_WAIT_TIMEOUT)
    except AlreadyLocked:
        logging.debug("lock already in place. quitting.")
        return
    except LockTimeout:
        logging.debug("waiting for the lock timed out. quitting.")
        return
    logging.debug("acquired.")

    batches, sent = 0, 0
    start_time = time.time()

    try:
        # nesting the try statement to be Python 2.4
        try:
            for queued_batch in NoticeQueueBatch.objects.all():
                notices = pickle.loads(str(queued_batch.pickled_data).decode("base64"))
                try:
                    for user, label, extra_context, on_site, sender in notices:
                        try:
                            user = User.objects.get(pk=user)
                            logging.info("emitting notice %s to %s" % (label, user))
                            # call this once per user to be atomic and allow for logging to
                            # accurately show how long each takes.
                            notification.send_now([user], label, extra_context, on_site, sender)
                        except User.DoesNotExist:
                            # Ignore deleted users, just warn about them
                            logging.warning("not emitting notice %s to user %s since it does not exist" % (label, user))
                        sent += 1
                except :
                    #if we sent half the batch, we don't want to resend notices to the first half next
                    #time we run it, so just throw away this (apparantly faulty) queued_batch
                    queued_batch.delete()
                    raise
                queued_batch.delete()
                batches += 1
        except:
            # get the exception
            exc_class, e, t = sys.exc_info()
            # email people
            current_site = Site.objects.get_current()
            subject = "[%s emit_notices] %r" % (current_site.name, e)
            message = "%s" % ("\n".join(traceback.format_exception(*sys.exc_info())),)
            mail_admins(subject, message, fail_silently=True)
            # log it as critical
            logging.critical("an exception occurred: %r" % e)
    finally:
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")
    
    logging.info("")
    logging.info("%s batches, %s sent" % (batches, sent,))
    logging.info("done in %.2f seconds" % (time.time() - start_time))
Esempio n. 10
0
def notify_expiring_accounts():
    expiring_accounts = Account.objects.filter(status='EXPIRING',
                                               user__isnull=False)
    for account in expiring_accounts:
        notification.send_now([account.user], "account_expiring", {
            'user': account.user,
            'site': Site.objects.get_current()
        }, True)
Esempio n. 11
0
def send_all():
    lock = FileLock('send_notices')

    logging.debug('acquiring lock...')
    try:
        lock.acquire(LOCK_WAIT_TIMEOUT)
    except AlreadyLocked:
        logging.debug('lock already in place. quitting.')
        return
    except LockTimeout:
        logging.debug('waiting for the lock timed out. quitting.')
        return
    logging.debug('acquired.')

    batches, sent = 0, 0
    start_time = time.time()

    try:
        # nesting the try statement to be Python 2.4
        try:
            for queued_batch in NoticeQueueBatch.objects.all():
                notices = pickle.loads(
                    base64.b64decode(queued_batch.pickled_data))
                for user, label, extra_context, on_site in notices:
                    user = User.objects.get(pk=user)
                    # FrankU: commented, because not all users get e-mailed
                    # and to supress useless logging
                    # logging.info('emitting notice to %s' % user)

                    # call this once per user to be atomic and allow for logging to
                    # accurately show how long each takes.
                    notification.send_now([user], label, extra_context,
                                          on_site)
                    sent += 1
                queued_batch.delete()
                batches += 1
        except:
            # get the exception
            exc_class, e, t = sys.exc_info()
            # email people
            current_site = Site.objects.get_current()
            subject = '[%s emit_notices] %r' % (current_site.name, e)
            message = '%s' % ('\n'.join(
                traceback.format_exception(*sys.exc_info())), )
            mail_admins(subject, message, fail_silently=True)
            # log it as critical
            logging.critical('an exception occurred: %r' % e)
    finally:
        logging.debug('releasing lock...')
        lock.release()
        logging.debug('released.')

    logging.info('')
    logging.info('%s batches, %s sent' % (
        batches,
        sent,
    ))
    logging.info('done in %.2f seconds' % (time.time() - start_time))
Esempio n. 12
0
def index(request):
    if request.method == 'POST':
        form = forms.DonationForm(request.POST, prefix='base')
        stripeForm = forms.StripeForm(request.POST, prefix='stripe')
    else:
        form = forms.DonationForm(prefix='base')
        stripeForm = forms.StripeForm(prefix='stripe')
    if form.is_valid():
        if int(form.cleaned_data['method']) == forms.DonationForm.METHOD_DWOLLA:
            data = {}
            order = {}
            item = {}
            item['Description'] = "Caminus Donation"
            item['Name'] = "Caminus Donation"
            item['Price'] = str(form.cleaned_data['quantity'])
            item['Quantity'] = 1
            order['OrderItems'] = [item,]
            order['Test'] = True
            order['Tax'] = 0.00
            order['Total'] = str(form.cleaned_data['quantity'])
            order['DestinationId'] = settings.DWOLLA_API_ID
            data['PurchaseOrder'] = order
            data['Key'] = settings.DWOLLA_API_KEY
            data['Secret'] = settings.DWOLLA_API_SECRET
            data['Callback'] = 'http://camin.us%s'%reverse('donate.views.dwollaCallback')
            donation = models.Donation.objects.create(quantity=form.cleaned_data['quantity'], user=request.user)
            order['OrderId'] = donation.id
            data['Redirect'] = 'http://camin.us%s'%reverse('donate.views.thanks', kwargs={'donation':donation.id})
            req = urllib2.Request("https://www.dwolla.com/payment/request", data=json.dumps(data), headers={'Content-Type': 'application/json'})
            response = json.load(urllib2.urlopen(req))
            return HttpResponseRedirect("https://www.dwolla.com/payment/checkout/%s"%(response['CheckoutId']))
        elif stripeForm.is_valid():
            stripe.api_key = settings.STRIPE_KEY
            cardData = {}
            cardData['number'] = stripeForm.cleaned_data['card']
            cardData['exp_month'] = stripeForm.cleaned_data['month']
            cardData['exp_year'] = stripeForm.cleaned_data['year']
            cardData['cvc'] = stripeForm.cleaned_data['cvc']
            try:
                charge = stripe.Charge.create(
                    amount = str(form.cleaned_data['quantity']*100),
                    currency = 'usd',
                    card = cardData,
                    description = 'Caminus Donation from %s'%(request.user.email)
                )
            except stripe.CardError, e:
                messages.error(request, "There was an error while processing your card: %s"%(e.message))
                return render_to_response('donate/index.html', {'form': form,
                  'stripeForm': stripeForm}, context_instance = RequestContext(request))
            donation = models.Donation.objects.create(quantity=form.cleaned_data['quantity'], user=request.user)
            donation.status = models.Donation.STATUS_PAID
            donation.transactionId = charge.id
            donation.save()
            acct = donation.user.minecraftprofile.currencyaccount
            acct.balance = F('balance')+(donation.quantity*2000)
            acct.save()
            notification.send_now([donation.user], "donation_paid", {"donation":donation, "credit":donation.quantity*2000})
            return HttpResponseRedirect('http://camin.us%s'%reverse('donate.views.thanks', kwargs={'donation':donation.id}))
Esempio n. 13
0
def notify_new_letter(sender, instance, created, **kw):
	if notification and isinstance(instance, Letter) and created:
		user = [instance.recipient,]
		game = instance.recipient_player.game
		extra_context = {'game': game,
						'letter': instance,
						'STATIC_URL': settings.STATIC_URL,}
		if game.fast:
			notification.send_now(user, "condottieri_messages_received", extra_context)
		else:
			notification.send(user, "condottieri_messages_received", extra_context)
Esempio n. 14
0
def dwollaCallback(request):
    if request.method =='POST':
        data = json.loads(request.raw_post_data)
        donation = models.Donation.objects.get(id=data['OrderId'])
        donation.status = models.Donation.STATUS_PAID
        donation.transactionId = data['TransactionId']
        donation.save()
        acct = donation.user.minecraftprofile.currencyaccount
        acct.balance = F('balance')+(donation.quantity*2000)
        acct.save()
        notification.send_now([donation.user], "donation_paid", {"donation":donation, "credit":donation.quantity*2000})
    return HttpResponse(status=204)
Esempio n. 15
0
def notify_unclaimed_gifts():
    unclaimed = Gift.objects.filter(used=None)
    for gift in unclaimed:
        """
        send notice every 7 days
        """
        unclaimed_duration = (now() - gift.acq.created).days
        if unclaimed_duration > 0 and unclaimed_duration % 7 == 0:  # first notice in 7 days
            notification.send_now([gift.acq.user], "purchase_gift_waiting",
                                  {'gift': gift}, True)
            notification.send_now([gift.giver], "purchase_notgot_gift",
                                  {'gift': gift}, True)
Esempio n. 16
0
def report_new_ebooks(created=None):  #created= creation date
    if created:
        period = (created, created + timedelta(days=1))
    else:
        period = (date_today() - timedelta(days=1), date_today())
    works = models.Work.objects.filter(
        editions__ebooks__created__range=period).distinct()
    for work in works:
        # only notify if a new ebooks are active, don't notify person if the book was just wished
        # ebooks() only returns active ebooks
        for ebook in work.ebooks().filter(created__range=period):
            notification.send_now(work.wished_by(excluding=period),
                                  "wishlist_unglued_book_released",
                                  {'work': work}, True)
            break
Esempio n. 17
0
def main(*args, **options):
    help_msg = """Send a test notification to a specified user.\nUsage: python manage.py test_notification <username>"""
    if len(args) == 1:
        username = args[0]
    else:
        username = '******'
        print "Using default recipient, %s" % username
    try:
        u = User.objects.get(username=username)
    except User.DoesNotExist:
        sys.exit("User, %s, does not exist" % username)

    print "Sending test notification to %s ..." % username
    a = Article.objects.get(doi='pone.0012345')
    n.send_now([u], 'new_urgent_web_correction', {"article": a})
Esempio n. 18
0
def _send_batch_part(users, label, extra_context, on_site, sender):
    """Sends part of queued batch"""
    sent = {}
    for user in users:
        # The instance of QuerySet also can be pickled,
        # so, ckecks the instance of user.
        if not isinstance(user, User):
            try:
                logger.info("loading user {0}".format(user))
                user = User.objects.get(pk=user)
            except User.DoesNotExist:
                # Ignore deleted users, just warn about them
                logger.warning("not emitting notice {0} to user {1} since it does not exist".format(label, user))
                continue

        logger.info("emitting notice {0} to {1}".format(label, user))
        # call this once per user to be atomic and allow for logger to
        # accurately show how long each takes.
        try:
            result = notification.send_now([user], label, extra_context, on_site, sender)
        except ObjectDoesNotExist as e:
            logger.warning("Can't to emit notice {0} to user {1} since {2}".format(label, user, e))
        else:
            for k, v in result.items():
                sent.setdefault(k, 0)
                sent[k] += v

    return sent
Esempio n. 19
0
def send_all(*args):
    lock = acquire_lock(*args)
    batches, sent, sent_actual = 0, 0, 0
    start_time = time.time()

    try:
        # nesting the try statement to be Python 2.4
        try:
            for queued_batch in NoticeQueueBatch.objects.all():
                notices = pickle.loads(
                    base64.b64decode(queued_batch.pickled_data))
                for user, label, extra_context, sender in notices:
                    try:
                        user = User.objects.get(pk=user)
                        logging.info("emitting notice {} to {}".format(
                            label, user))
                        # call this once per user to be atomic and allow for logging to
                        # accurately show how long each takes.
                        if notification.send_now([user], label, extra_context,
                                                 sender):
                            sent_actual += 1
                    except User.DoesNotExist:
                        # Ignore deleted users, just warn about them
                        logging.warning(
                            "not emitting notice {} to user {} since it does not exist"
                            .format(label, user))
                    sent += 1
                queued_batch.delete()
                batches += 1
            emitted_notices.send(sender=NoticeQueueBatch,
                                 batches=batches,
                                 sent=sent,
                                 sent_actual=sent_actual,
                                 run_time="%.2f seconds" %
                                 (time.time() - start_time))
        except Exception:  # pylint: disable-msg=W0703
            # get the exception
            _, e, _ = sys.exc_info()
            # email people
            current_site = Site.objects.get_current()
            subject = "[{} emit_notices] {}".format(current_site.name, e)
            message = "\n".join(
                traceback.format_exception(
                    *sys.exc_info())  # pylint: disable-msg=W0142
            )
            mail_admins(subject, message, fail_silently=True)
            # log it as critical
            logging.critical("an exception occurred: {}".format(e))
    finally:
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")

    logging.info("")
    logging.info("{} batches, {} sent".format(
        batches,
        sent,
    ))
    logging.info("done in {:.2f} seconds".format(time.time() - start_time))
Esempio n. 20
0
def corkboard_detail(request,
                     slug,
                     template_name="loupe/corkboard_detail.html"):
    """
    Displays the corkboard and all it's associated images
    to the user

    expects a slug and expects the user has access to the parent project
    """

    if not request.user.is_staff:
        corkboard = get_object_or_404(Corkboard,
                                      slug=slug,
                                      project__members=request.user)
    else:
        corkboard = get_object_or_404(Corkboard, slug=slug)

    images = Image.objects.filter(corkboard=corkboard)

    form = ImageForm()

    if request.method == "POST":
        form = ImageForm(request.user, request.POST, request.FILES)
        if form.is_valid():
            image = form.save(commit=False)
            image.user = request.user
            image.corkboard = corkboard
            image.save()
            if notification:
                notification.send_now(
                    corkboard.project.members.all(), "corkboard_new_image", {
                        "user": request.user,
                        "corkboard": corkboard,
                        "image_url": image.get_absolute_url,
                        "corkboard_url": corkboard.get_absolute_url
                    })

            request.user.message_set.create(
                message=_("Successfully uploaded image '%s'") % image.title)

    return render_to_response(template_name, {
        "corkboard": corkboard,
        "form": form,
        "images": images,
    },
                              context_instance=RequestContext(request))
Esempio n. 21
0
def generate():
    print "Sending 10% of the stored notifications"
    num = NoticeQueueBatch.objects.count()
    users = dict([(str(u.id), u) for u in User.objects.all()])
    print "Unpickling batch data"
    batches = map(
        lambda data: pickle.loads(data.decode("base64"))[0],
        NoticeQueueBatch.objects.order_by('?').values_list('pickled_data',
            flat=True)[:num / 10]
    )
    print "Unpickled batch data"
    NoticeQueueBatch.objects.all().delete()
    i = 0
    for i, args in enumerate(batches):
        arg_list = list(args)
        arg_list[0] = [users[str(arg_list[0])]]
        send_now(*arg_list)
    print "%d notifications sent" % (i,)
Esempio n. 22
0
def generate():
    print "Sending 10% of the stored notifications"
    num = NoticeQueueBatch.objects.count()
    users = dict([(str(u.id), u) for u in User.objects.all()])
    print "Unpickling batch data"
    batches = map(
        lambda data: pickle.loads(data.decode("base64"))[0],
        NoticeQueueBatch.objects.order_by('?').values_list('pickled_data',
                                                           flat=True)[:num /
                                                                      10])
    print "Unpickled batch data"
    NoticeQueueBatch.objects.all().delete()
    i = 0
    for i, args in enumerate(batches):
        arg_list = list(args)
        arg_list[0] = [users[str(arg_list[0])]]
        send_now(*arg_list)
    print "%d notifications sent" % (i, )
Esempio n. 23
0
def project_detail(request, slug, template_name="loupe/project_detail.html"):
    """
    Displays the corkboards for the given porject 'slug'
    to the user

    expects a slug and expects the user has access to the parent project
    """

    if not request.user.is_staff:
        project = get_object_or_404(Project, slug=slug, members=request.user)
    else:
        project = get_object_or_404(Project, slug=slug)

    corkboards = Corkboard.objects.filter(project=project)
    form = CorkboardForm()

    if request.method == "POST":
        form = CorkboardForm(request.user, request.POST)
        if form.is_valid():
            corkboard = form.save(commit=False)
            corkboard.user = request.user
            corkboard.project = project
            corkboard.save()
            request.user.message_set.create(
                message=_("Successfully created corkboard '%s'") %
                corkboard.title)

            if notification:
                notification.send_now(
                    project.members.all(), "corkboard_new_corkboard", {
                        "user": request.user,
                        "corkboard": corkboard,
                        "corkboard_url": corkboard.get_absolute_url
                    })

            return HttpResponseRedirect(
                reverse('corkboard_detail', args=(corkboard.slug, )))

    return render_to_response(template_name, {
        "project": project,
        "form": form,
        "corkboards": corkboards,
    },
                              context_instance=RequestContext(request))
def corkboard_detail(request, slug, template_name="loupe/corkboard_detail.html"):
    """
    Displays the corkboard and all it's associated images
    to the user

    expects a slug and expects the user has access to the parent project
    """

    if not request.user.is_staff:
        corkboard = get_object_or_404(Corkboard, slug=slug, project__members=request.user)
    else:
        corkboard = get_object_or_404(Corkboard, slug=slug)

    images = Image.objects.filter(corkboard=corkboard)

    form = ImageForm()

    if request.method == "POST":
        form = ImageForm(request.user, request.POST, request.FILES)
        if form.is_valid():
            image = form.save(commit=False)
            image.user = request.user
            image.corkboard = corkboard
            image.save()
            if notification:
                notification.send_now(
                    corkboard.project.members.all(),
                    "corkboard_new_image",
                    {
                        "user": request.user,
                        "corkboard": corkboard,
                        "image_url": image.get_absolute_url,
                        "corkboard_url": corkboard.get_absolute_url,
                    },
                )

            request.user.message_set.create(message=_("Successfully uploaded image '%s'") % image.title)

    return render_to_response(
        template_name,
        {"corkboard": corkboard, "form": form, "images": images},
        context_instance=RequestContext(request),
    )
Esempio n. 25
0
def image_detail(request, id, template_name="loupe/image_detail.html"):
    """
    Displays the image to be discussed by the project members

    expects an id for the image and the user has access to the parent project
    """
    if not request.user.is_staff:
        image = get_object_or_404(Image,
                                  pk=id,
                                  corkboard__project__members=request.user)
    else:
        image = get_object_or_404(Image, pk=id)

    notes = Note.objects.filter(image=image)
    notes_count = notes.count()
    form = NoteForm()

    if request.method == "POST":
        form = NoteForm(request.user, request.POST)
        if form.is_valid():
            note = form.save(commit=False)
            note.user = request.user
            note.image = image
            note.save()
            if notification:
                notification.send_now(
                    image.corkboard.project.members.all(),
                    "corkboard_new_image_note", {
                        "user": request.user,
                        "image_url": image.get_absolute_url,
                        "image": image
                    })
            request.user.message_set.create(
                message=_("Successfully attached note to image '%s'") %
                image.title)

    return render_to_response(template_name, {
        "image": image,
        "notes": notes,
        "notes_count": notes_count,
        "form": form,
    },
                              context_instance=RequestContext(request))
Esempio n. 26
0
def send_all(*args):
    lock = acquire_lock(*args)
    batches, sent, sent_actual = 0, 0, 0
    start_time = time.time()

    try:
        # nesting the try statement to be Python 2.4
        try:
            for queued_batch in NoticeQueueBatch.objects.all():
                notices = pickle.loads(base64.b64decode(queued_batch.pickled_data))
                for user, label, extra_context, sender in notices:
                    try:
                        user = User.objects.get(pk=user)
                        logging.info("emitting notice {} to {}".format(label, user))
                        # call this once per user to be atomic and allow for logging to
                        # accurately show how long each takes.
                        if notification.send_now([user], label, extra_context, sender):
                            sent_actual += 1
                    except User.DoesNotExist:
                        # Ignore deleted users, just warn about them
                        logging.warning(
                            "not emitting notice {} to user {} since it does not exist".format(
                                label,
                                user)
                        )
                    sent += 1
                queued_batch.delete()
                batches += 1
            emitted_notices.send(
                sender=NoticeQueueBatch,
                batches=batches,
                sent=sent,
                sent_actual=sent_actual,
                run_time="%.2f seconds" % (time.time() - start_time)
            )
        except Exception:  # pylint: disable-msg=W0703
            # get the exception
            _, e, _ = sys.exc_info()
            # email people
            current_site = Site.objects.get_current()
            subject = "[{} emit_notices] {}".format(current_site.name, e)
            message = "\n".join(
                traceback.format_exception(*sys.exc_info())  # pylint: disable-msg=W0142
            )
            mail_admins(subject, message, fail_silently=True)
            # log it as critical
            logging.critical("an exception occurred: {}".format(e))
    finally:
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")

    logging.info("")
    logging.info("{} batches, {} sent".format(batches, sent,))
    logging.info("done in {:.2f} seconds".format(time.time() - start_time))
Esempio n. 27
0
def give_money(request, slug, player_id):
	game = get_object_or_404(Game, slug=slug)
	if game.phase == 0 or not game.configuration.finances:
		messages.error(request, _("You cannot give money in this game."))
		return redirect(game)
	borrower = get_object_or_404(Player, id=player_id, game=game)
	lender = get_object_or_404(Player, user=request.user, game=game)
	context = base_context(request, game, lender)

	if request.method == 'POST':
		form = forms.LendForm(request.POST)
		if form.is_valid():
			ducats = form.cleaned_data['ducats']
			if ducats > lender.ducats:
				##TODO Move this to form validation
				messages.error(request, _("You cannot give more money than you have"))
				return redirect(game)
			lender.ducats = F('ducats') - ducats
			borrower.ducats = F('ducats') + ducats
			lender.save()
			borrower.save()
			messages.success(request, _("The money has been successfully sent."))
			if notification:
				extra_context = {'game': lender.game,
								'ducats': ducats,
								'country': lender.country,
								'STATIC_URL': settings.STATIC_URL}
				if lender.game.fast:
					notification.send_now([borrower.user,], "received_ducats", extra_context)
				else:
					notification.send([borrower.user,], "received_ducats", extra_context)
			return redirect(game)
	else:
		form = forms.LendForm()
	context['form'] = form
	context['borrower'] = borrower

	return render_to_response('machiavelli/give_money.html',
							context,
							context_instance=RequestContext(request))
Esempio n. 28
0
def expiration_notification(sender, **kwargs):
    """
    FIXME: Migrate it (txcron) to work with the String Level.
    """
    logger.debug("lock-addon: Sending expiration notifications...")
    if not settings.ENABLE_NOTICES:
        logger.debug("lock-addon: ENABLE_NOTICES is not enabled")
        return
    current_site = Site.objects.get_current()
    locks = Lock.objects.expiring()
    nt = 'project_resource_language_lock_expiring'
    for lock in locks:
        context = { 'resource': lock.rlstats.resource,
                    'language': lock.rlstats.language,
                    'project' : lock.rlstats.resource.project,
                    'user': lock.owner,
                    'expires': lock.expires,
                    'current_site' : current_site }
        logger.debug("lock-addon: Sending notification about lock: %s" % lock)
        notification.send_now([lock.owner,], nt, context)
        lock.notified = True
        lock.save()
def project_detail(request, slug, template_name="loupe/project_detail.html"):
    """
    Displays the corkboards for the given porject 'slug'
    to the user

    expects a slug and expects the user has access to the parent project
    """

    if not request.user.is_staff:
        project = get_object_or_404(Project, slug=slug, members=request.user)
    else:
        project = get_object_or_404(Project, slug=slug)

    corkboards = Corkboard.objects.filter(project=project)
    form = CorkboardForm()

    if request.method == "POST":
        form = CorkboardForm(request.user, request.POST)
        if form.is_valid():
            corkboard = form.save(commit=False)
            corkboard.user = request.user
            corkboard.project = project
            corkboard.save()
            request.user.message_set.create(message=_("Successfully created corkboard '%s'") % corkboard.title)

            if notification:
                notification.send_now(
                    project.members.all(),
                    "corkboard_new_corkboard",
                    {"user": request.user, "corkboard": corkboard, "corkboard_url": corkboard.get_absolute_url},
                )

            return HttpResponseRedirect(reverse("corkboard_detail", args=(corkboard.slug,)))

    return render_to_response(
        template_name,
        {"project": project, "form": form, "corkboards": corkboards},
        context_instance=RequestContext(request),
    )
Esempio n. 30
0
def send_all():
    lock = FileLock("send_notices")

    logging.debug("acquiring lock...")
    try:
        lock.acquire(LOCK_WAIT_TIMEOUT)
    except AlreadyLocked:
        logging.debug("lock already in place. quitting.")
        return
    except LockTimeout:
        logging.debug("waiting for the lock timed out. quitting.")
        return
    logging.debug("acquired.")

    batches, sent = 0, 0
    start_time = time.time()

    try:
        for queued_batch in NoticeQueueBatch.objects.all():
            notices = pickle.loads(str(queued_batch.pickled_data).decode("base64"))
            for user, label, extra_context, on_site in notices:
                user = User.objects.get(pk=user)
                logging.info("emitting notice to %s" % user)
                # call this once per user to be atomic and allow for logging to
                # accurately show how long each takes.
                notification.send_now([user], label, extra_context, on_site)
                sent += 1
            queued_batch.delete()
            batches += 1
    finally:
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")

    logging.info("")
    logging.info("%s batches, %s sent" % (batches, sent))
    logging.info("done in %.2f seconds" % (time.time() - start_time))
Esempio n. 31
0
def refresh_acqs():
    in_10_min = now() + timedelta(minutes=10)
    acqs = Acq.objects.filter(refreshed=False, refreshes__lt=in_10_min)
    logger.info('refreshing %s acqs' % acqs.count())
    for acq in acqs:
        for hold in acq.holds:
            # create a 1 day reserve on the acq
            reserve_acq = Acq.objects.create(
                user=hold.user,
                work=hold.work,
                license=RESERVE,
                lib_acq=acq,
            )
            # the post_save handler takes care of pushing expires  vis acq.expires_in

            # notify the user with the hold
            if 'example.org' not in reserve_acq.user.email:
                notification.send_now([reserve_acq.user], "library_reserve",
                                      {'acq': reserve_acq})
            # delete the hold
            hold.delete()
            break
        else:
            acq.refreshed = True
Esempio n. 32
0
def test_announce():
    from notification import models as notification
    a = Announcement.objects.all()[0]
    data = {'content' :a.content, 'get_absolute_url' : a.get_absolute_url()}
    users = [User.objects.get(username = '******'), User.objects.get(username = '******')]
    notification.send_now(users, "announcement", {'announcement' : data})
Esempio n. 33
0
 def notify(self, from_user, q):
     editors = Permission.objects.get(codename='change_question').user_set.all() | User.objects.filter(is_superuser=True)
     notification.send_now(editors, 'question_reported', {"from":from_user, "q":q, "description": self.cleaned_data['description']})
Esempio n. 34
0
def send_all():
    lock = FileLock("send_notices")

    logging.debug("acquiring lock...")
    try:
        lock.acquire(LOCK_WAIT_TIMEOUT)
    except AlreadyLocked:
        logging.debug("lock already in place. quitting.")
        return
    except LockTimeout:
        logging.debug("waiting for the lock timed out. quitting.")
        return
    logging.debug("acquired.")

    batches, sent, tried = 0, 0, 0
    start_time = time.time()

    try:
        # nesting the try statement to be Python 2.4
        try:
            for queued_batch in NoticeQueueBatch.objects.all():
                notices = pickle.loads(str(queued_batch.pickled_data).decode("base64"))
                for user, label, extra_context, on_site, sender in notices:
                    try:
                        user = User.objects.get(pk=user)
                        logging.info("emitting notice %s to %s" % (label, user))
                        # call this once per user to be atomic and allow for logging to
                        # accurately show how long each takes.
                        notification.send_now([user], label, extra_context, on_site, sender)
                        tried = tried + 1
                    except User.DoesNotExist:
                        tried = tried + 1
                        # Ignore deleted users, just warn about them
                        logging.warning("not emitting notice %s to user %s since it does not exist" % (label, user))
                    except Exception as e:
                        logging.critical("Error while sending email to user: %s. Notification: %s" % (user, label))
                        logging.critical("Exception: %s" % e.value)
                        logging.critical("Updating NoticeQueueBatch object to avoid re-sending to same users...")
                        queued_batch.pickled_data = pickle.dumps(notices[tried:]).encode("base64")
                        queued_batch.save()
                        raise e
                    sent += 1
                queued_batch.delete()
                batches += 1
                tried = 0
        except:
            # get the exception
            exc_class, e, t = sys.exc_info()
            # email people
            current_site = Site.objects.get_current()
            subject = "[%s emit_notices] %r" % (current_site.name, e)
            message = "%s" % ("\n".join(traceback.format_exception(*sys.exc_info())),)
            mail_admins(subject, message, fail_silently=True)
            # log it as critical
            logging.critical("an exception occurred: %r" % e)
    finally:
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")

    logging.info("")
    logging.info("%s batches, %s sent" % (batches, sent,))
    logging.info("done in %.2f seconds" % (time.time() - start_time))