def displayDoc(request, id, doc): import trml2pdf # Create the HttpResponse object with the appropriate PDF headers for an invoice or a packing slip order = get_object_or_404(Order, pk=id) shopDetails = Config.objects.get_current() filename_prefix = shopDetails.site.domain if doc == "invoice": filename = "%s-invoice.pdf" % filename_prefix template = "invoice.rml" elif doc == "packingslip": filename = "%s-packingslip.pdf" % filename_prefix template = "packing-slip.rml" elif doc == "shippinglabel": filename = "%s-shippinglabel.pdf" % filename_prefix template = "shipping-label.rml" else: return HttpResponseRedirect('/admin') response = HttpResponse(mimetype='application/pdf') if config_value('SHIPPING','DOWNLOAD_PDFS'): response['Content-Disposition'] = 'attachment; filename=%s' % filename icon_uri = config_value('SHOP', 'LOGO_URI') t = loader.get_template(os.path.join('shop/pdf', template)) c = Context({ 'filename' : filename, 'iconURI' : icon_uri, 'shopDetails' : shopDetails, 'order' : order, 'default_view_tax': config_value('TAX','DEFAULT_VIEW_TAX') }) pdf = trml2pdf.parseString(smart_str(t.render(c))) response.write(pdf) return response
def send_order_notice(order, template='', template_html=''): """Send an order confirmation mail to the owner. """ if config_value("PAYMENT", "ORDER_EMAIL_OWNER"): try: sale = Discount.objects.by_code(order.discount_code, raises=True) except Discount.DoesNotExist: sale = None c = {'order': order, 'sale' : sale} subject = _("New order on %(shop_name)s") eddresses = [] more = config_value("PAYMENT", "ORDER_EMAIL_EXTRA") if more: eddresses = set([m.strip() for m in more.split(',')]) eddresses = [e for e in eddresses if e] try: send_store_mail(subject, c, template, eddresses, template_html=template_html, format_subject=True, send_to_store=True, sender=order_notice_sender) except NoRecipientsException: log.warn("No shop owner email specified, skipping owner_email") return
def activate(request, activation_key, template = 'registration/activate.html'): """ Activates a user's account, if their key is valid and hasn't expired. """ activation_key = activation_key.lower() account = AdminRegistrationProfile.objects.activate_user(activation_key) if account: # ** hack for logging in the user ** # when the login form is posted, user = authenticate(username=data['username'], password=data['password']) # ...but we cannot authenticate without password... so we work-around authentication account.backend = settings.AUTHENTICATION_BACKENDS[0] contact = Contact.objects.get(user=account) #send_welcome_email(contact.email, contact.first_name, contact.last_name) # Send an email to the user if an Administrator has activated his/her account if config_value('SHOP', 'ACCOUNT_VERIFICATION') == "ADMINISTRATOR": site = Site.objects.get_current() profile = AdminRegistrationProfile.objects.get(user=account) profile.send_welcome_email(site) template = 'registration/administrator_activate.html' else: # Otherwise login the user as he/she is the one activating his/her account _login(request, account) request.session[CUSTOMER_ID] = contact.id signals.satchmo_registration_verified.send(contact, contact=contact) context = RequestContext(request, { 'account': account, 'expiration_days': config_value('SHOP', 'ACCOUNT_ACTIVATION_DAYS'), "page_info": _get_page_parameters(), }) return render_to_response(template, context_instance=context)
def add(request, id=0, redirect_to='satchmo_cart'): """Add an item to the cart.""" log.debug('FORM: %s', request.POST) formdata = request.POST.copy() productslug = None cartplaces = config_value('SHOP', 'CART_PRECISION') roundfactor = config_value('SHOP', 'CART_ROUNDING') if formdata.has_key('productname'): productslug = formdata['productname'] try: product, details = product_from_post(productslug, formdata) if not (product and product.active): log.debug("product %s is not active" % productslug) return bad_or_missing(request, _("That product is not available at the moment.")) else: log.debug("product %s is active" % productslug) except (Product.DoesNotExist, MultiValueDictKeyError): log.debug("Could not find product: %s", productslug) return bad_or_missing(request, _('The product you have requested does not exist.')) # First we validate that the number isn't too big. if decimal_too_big(formdata['quantity']): return _product_error(request, product, _("Please enter a smaller number.")) # Then we validate that we can round it appropriately. try: quantity = round_decimal(formdata['quantity'], places=cartplaces, roundfactor=roundfactor) except RoundedDecimalError, P: return _product_error(request, product, _("Invalid quantity."))
def check_with_akismet(comment=None, request=None, **kwargs): if config_value("PRODUCT", "AKISMET_ENABLE"): key = config_value("PRODUCT", "AKISMET_KEY") if key: site = Site.objects.get_current() shop = urlresolvers.reverse('satchmo_shop_home') from akismet import Akismet akismet = Akismet( key=settings.AKISMET_API_KEY, blog_url='http://%s' % url_join(site.domain, shop)) if akismet.verify_key(): akismet_data = { 'comment_type': 'comment', 'referrer': request.META.get('HTTP_REFERER', ""), 'user_ip': comment.ip_address, 'user_agent': '' } if akismet_api.comment_check(smart_str(comment.comment), data=akismet_data, build_data=True): comment.is_public=False comment.save() log.info("Akismet marked comment #%i as spam", comment.id) else: log.debug("Akismet accepted comment #%i", comment.id) else: log.warn("Akismet key '%s' not accepted by akismet service.", key) else: log.info("Akismet enabled, but no key found. Please put in your admin settings.")
def send(self, timestamp = datetime.now(), send = True, headers = {}, extra_context = {}): """Метод для отправки дайджеста. Для всех пользователей вызывается self.get_content, результат отдается в self.render (можно использовать extra_context), после чего письмо отправляется. """ for user in self.users: digest_pref = user.digestpreference_set.get(digest = self.digest) if timestamp - self.digest.get_last(user) < timedelta(hours=digest_pref.interval): continue qs = self.get_content(user, timestamp) if not qs: continue current_site = Site.objects.get_current() subject = _("%(prefix)sEmail digest for %(digest)s") % { 'prefix': config_value('EmailServer', 'EMAIL_SUBJECT_PREFIX'), 'digest': self.digest, } context = { 'user': user, 'from': self.digest.get_last(user), 'till': timestamp, 'site': current_site, } email = EmailMultiAlternatives(subject, self.render_txt(qs, context, extra_context={}), config_value('EmailServer', 'DEFAULT_FROM_EMAIL'), [user.email, ], [], headers=headers,) email.attach_alternative(self.render(qs, context, extra_context={}), "text/html") if send: email.send() journal = DigestJournal(user=user, digest=self.digest) journal.save()
def shipping(self, subtotal=None, with_details=False): if subtotal is None and self.order: subtotal = self.order.shipping_sub_total tax_details = {} if subtotal: full_rate = None taxes = [] if config_value('TAX','TAX_SHIPPING_CANADIAN'): try: # get the tax class used for taxing shipping taxclass = TaxClass.objects.get(title=config_value('TAX', 'TAX_CLASS')) full_rate, taxes = self.get_rate(taxclass=taxclass, get_object=True) except ObjectDoesNotExist: log.error("'Shipping' TaxClass doesn't exist.") if full_rate: ship_tax = full_rate * subtotal else: ship_tax = Decimal("0.00") if with_details: for taxcode, rate in taxes: if taxcode not in tax_details: tax_details[taxcode] = Decimal('0.00') tax_details[taxcode] += rate * subtotal else: ship_tax = Decimal("0.00") if with_details: return ship_tax, tax_details else: return ship_tax
def map(request): return { 'GOOGLE_API_KEY': getattr(settings, 'GOOGLE_API_KEY'), 'newevent_highlight': config_value('EventsMap', 'newevent-highlight'), 'newevent_sound': config_value('EventsMap', 'newevent-sound'), 'wakeup_interval': config_value('EventsMap', 'operator-wake-up-alert-interval') }
def __init__(self, *args, **kwargs): contact = kwargs.pop('contact', None) self._contact = contact shop = kwargs.pop('shop', None) if not shop: shop = Config.objects.get_current() self._shop = shop super(AddressBookForm, self).__init__(*args, **kwargs) self.required_shipping_data = config_value('SHOP', 'REQUIRED_SHIPPING_DATA') self._local_only = shop.in_country_only self.enforce_state = config_value('SHOP','ENFORCE_STATE') self._default_country = shop.sales_country shipping_country = (self._contact and getattr(self._contact.shipping_address, 'country', None)) or self._default_country self.fields['country'] = forms.ModelChoiceField(shop.countries(), required=False, label=_(u'国家'), empty_label=None, initial=shipping_country.pk) if self.enforce_state: # Get areas for the initial country selected. shipping_areas = area_choices_for_country(shipping_country) shipping_state = (self._contact and getattr(self._contact.shipping_address, 'state', None)) or selection self.fields['province'] = forms.ChoiceField(choices=shipping_areas, initial=shipping_state, required=False, label=_(u'地区')) for f in self.fields: fld = self.fields[f] if fld.required: fld.label = (fld.label or f) + '*' log.info('Sending form_init signal: %s', self.__class__) form_init.send(self.__class__, form=self)
def get_common_context(request): c = {} form = OrderForm() if request.method == 'POST': form = OrderForm(request.POST) if form.is_valid(): form.save(request.POST['action']) if request.POST['action'] == 'request': c['order_ok'] = True else: c['feedback_ok'] = True form = OrderForm() c['form'] = form c['request_url'] = request.path c['is_debug'] = settings.DEBUG c['phone'] = config_value('MyApp', 'PHONE') ORDERS_COUNT = int(config_value('MyApp', 'ORDERS_COUNT')) c['oc_3'] = ORDERS_COUNT % 10 ORDERS_COUNT = ORDERS_COUNT / 10 c['oc_2'] = ORDERS_COUNT % 10 c['oc_1'] = ORDERS_COUNT / 10 c.update(csrf(request)) return c
def displayDoc(request, id, doc): import trml2pdf # Create the HttpResponse object with the appropriate PDF headers for an invoice or a packing slip order = get_object_or_404(Order, pk=id) shopDetails = Config.objects.get_current() filename_prefix = shopDetails.site.domain if doc == "invoice": filename = "%s-invoice.pdf" % filename_prefix template = "invoice.rml" elif doc == "packingslip": filename = "%s-packingslip.pdf" % filename_prefix template = "packing-slip.rml" elif doc == "shippinglabel": filename = "%s-shippinglabel.pdf" % filename_prefix template = "shipping-label.rml" else: return HttpResponseRedirect("/admin") response = HttpResponse(mimetype="application/pdf") if config_value("SHIPPING", "DOWNLOAD_PDFS"): response["Content-Disposition"] = "attachment; filename=%s" % filename icon_uri = config_value("SHOP", "LOGO_URI") t = loader.get_template(os.path.join("shop/pdf", template)) c = Context({"filename": filename, "iconURI": icon_uri, "shopDetails": shopDetails, "order": order}) pdf = trml2pdf.parseString(smart_str(t.render(c))) response.write(pdf) return response
def multisuccess_view(request): """ The order has been succesfully processed. This can be used to generate a receipt or some other confirmation """ target_view = None try: order = Order.objects.from_request(request) except Order.DoesNotExist: return bad_or_missing(request, _('Your order has already been processed.')) del request.session['orderID'] payments_completed = order.payments_completed() if payments_completed: payment_completed = payments_completed[0].payment else: payment_completed = '' shop = Config.objects.get_current() postal_code = shop.postal_code city = shop.city phone = shop.phone fax = "" store_email = shop.store_email store_name = shop.store_name street1 = shop.street1 state = shop.state p_iva = config_value('SHOP_CONFIG','VAT') iban = config_value('SHOP_CONFIG','IBAN') # Cablare il campo per il rilevamento della tipologia # di pagamento target_view = [] if payment_completed: target_view.append( "shop/checkout/success_%s.html" % payment_completed.lower() ) target_view.append("shop/checkout/success_generic.html") return render_to_response( target_view, { 'order': order, 'payment': payment_completed, 'p_iva' : p_iva, 'iban' : iban, 'store_postal_code' : postal_code, 'store_phone' : phone, 'store_fax' : fax, 'store_email' : store_email, 'store_name' : store_name, 'store_street1' : street1, 'store_state' : state, 'store_city' : city, }, context_instance=RequestContext(request) )
def confirm_info(request, template="shop/checkout/reward/confirm.html"): checkout_url = reverse('satchmo_checkout-step1') try: order = Order.objects.from_request(request) except Order.DoesNotExist: return HttpResponseRedirect(checkout_url) contact = Contact.objects.from_request(request) reward, created = Reward.objects.get_or_create(contact=contact) point_modifier = config_value('PAYMENT_REWARD', 'POINTS_VALUE') total_point_value = point_modifier * reward.points needs_total = config_value('PAYMENT_REWARD', 'REWARDS_NEED_TOTAL') if total_point_value > order.balance: point_value_used = order.balance points_used = point_value_used / point_modifier else: points_used = reward.points point_value_used = total_point_value controller = RewardConfirmController(request, payment_module) controller.templates['CONFIRM'] = template controller.extra_context={'points_used' : points_used, 'points_balance' : reward.points, 'needs_total':needs_total} controller.confirm() return controller.response
def __call__(self, request, id, doc): order = get_object_or_404(Order, pk=id) shopDetails = Config.objects.get_current() filename_prefix = shopDetails.site.domain converter_ = getattr(self, self.converter) if doc == "invoice": filename = "%s-invoice.pdf" % filename_prefix template = "invoice." + converter_.dd_extension elif doc == "packingslip": filename = "%s-packingslip.pdf" % filename_prefix template = "packing-slip." + converter_.dd_extension elif doc == "shippinglabel": filename = "%s-shippinglabel.pdf" % filename_prefix template = "shipping-label." + converter_.dd_extension else: return HttpResponseRedirect('/admin') icon_uri = config_value('SHOP', 'LOGO_URI') t = loader.get_template(os.path.join('shop/pdf', template)) c = Context({ 'filename' : filename, 'iconURI' : icon_uri, 'shopDetails' : shopDetails, 'order' : order }) data = converter_(t.render(c)) response = HttpResponse(mimetype='application/pdf') if config_value('SHIPPING','DOWNLOAD_PDFS'): response['Content-Disposition'] = 'attachment; filename=%s' % ( filename, ) response.write(data) return response
def process(self, order=None): """ Calculate the tax and return it """ if order: self.order = order else: order = self.order percent = config_value('TAX','PERCENT') sub_total = Decimal("0.00") for item in order.orderitem_set.filter(product__taxable=True): sub_total += item.sub_total itemtax = sub_total * (percent/100) taxrates = {'%i%%' % percent : itemtax} if config_value('TAX','TAX_SHIPPING'): shipping = order.shipping_sub_total sub_total += shipping ship_tax = shipping * (percent/100) taxrates['Shipping'] = ship_tax tax = sub_total * (percent/100) return tax, taxrates
def index(request): """ Page shell for the client-side application. Bootstraps read-once data onto the page. """ serializer = Serializer() cr = CategoryResource() categories = list(Category.objects.annotate(dataset_count=Count('datasets'))) bundles = [cr.build_bundle(obj=c) for c in categories] categories_bootstrap = [cr.full_dehydrate(b) for b in bundles] uncategorized = Category( id=settings.PANDA_UNCATEGORIZED_ID, slug=settings.PANDA_UNCATEGORIZED_SLUG, name=settings.PANDA_UNCATEGORIZED_NAME) uncategorized.__dict__['dataset_count'] = Dataset.objects.filter(categories=None).count() uncategorized_bundle = cr.full_dehydrate(cr.build_bundle(obj=uncategorized)) categories_bootstrap.append(uncategorized_bundle) return render_to_response('index.html', { 'settings': settings, 'max_upload_size': int(config_value('MISC', 'MAX_UPLOAD_SIZE')), 'email_enabled': int(config_value('EMAIL', 'EMAIL_ENABLED')), 'demo_mode_enabled': int(config_value('MISC', 'DEMO_MODE_ENABLED')), 'bootstrap_data': serializer.to_json({ 'categories': categories_bootstrap }), 'moment_lang_code': settings.MOMENT_LANGUAGE_MAPPING.get(settings.LANGUAGE_CODE, None), })
def send_digest(now=datetime.now()): from exmo2010.mail import ExmoEmail users = User.objects.filter( userprofile__notification_type=UserProfile.NOTIFICATION_DIGEST, is_active=True, email__isnull=False) subject = _("%(prefix)s Email digest") % { 'prefix': config_value('EmailServer', 'EMAIL_SUBJECT_PREFIX'), } context = { 'masked_expert_name': config_value('GlobalParameters', 'EXPERT'), 'site': Site.objects.get_current(), } for user in users.exclude(email__exact='').select_related('userprofile'): profile = user.userprofile last_date = profile.digest_date_journal if not last_date: last_date = now - timedelta(days=profile.notification_interval) interval = profile.notification_interval if now - last_date < timedelta(hours=interval): continue if profile.is_expertA: score_pk = Score.objects.all() elif profile.is_expertB: score_pk = Score.objects.filter(task__user=user) elif profile.is_organization: score_pk = Score.objects.filter(task__organization__in=profile.organization.all()) else: score_pk = Score.objects.none() comments = Comment.objects.filter( content_type__model='score', object_pk__in=score_pk.values_list('id', flat=True), ).order_by('submit_date') if last_date: comments = comments.filter(submit_date__gte=last_date) if not user.userprofile.notification_self: comments = comments.exclude(user=user) if not comments: continue context.update({ 'comments': comments, 'from': last_date, 'till': now, 'user': user, }) with translation.override(profile.language or settings.LANGUAGE_CODE): message = ExmoEmail(template_basename='mail/digest', context=context, to=[user.email], subject=subject) send_email.delay(message) profile.digest_date_journal = now profile.save()
def make_urlpatterns(): patterns = [] for key in config_value('PAYMENT', 'MODULES'): cfg = config_get(key, 'MODULE') modulename = cfg.editor_value urlmodule = "%s.urls" % modulename patterns.append(url(config_value(key, 'URL_BASE'), [urlmodule])) return tuple(patterns)
def index(request): image_count = config_value('MyApp','NUM_IMAGES') # Note, the measurement_system will return a list of selected values # in this case, we use the first one measurement_system = config_value('MyApp','MEASUREMENT_SYSTEM') return render_to_response('myapp/index.html', {'image_count': image_count, 'measurement_system': measurement_system[0]})
def get_connection(): return mail.get_connection( host=config_value('EMAIL', 'EMAIL_HOST'), port=config_value('EMAIL', 'EMAIL_PORT'), # See http://bugs.python.org/issue8489 username=str(config_value('EMAIL', 'EMAIL_HOST_USER')), password=str(config_value('EMAIL', 'EMAIL_HOST_PASSWORD')), use_tls=config_value('EMAIL', 'EMAIL_USE_TLS'))
def send_digest(timestamp=datetime.now()): """ Send digest. """ users = User.objects.filter(userprofile__notification_type=UserProfile.NOTIFICATION_DIGEST, is_active=True, email__isnull=False)\ .exclude(email__exact='') current_site = Site.objects.get_current() expert = config_value('GlobalParameters', 'EXPERT') subject = _("%(prefix)s Email digest") % { 'prefix': config_value('EmailServer', 'EMAIL_SUBJECT_PREFIX'), } for user in users: profile = user.userprofile last_date = profile.digest_date_journal if not last_date: last_date = datetime.now() - timedelta(days=profile.notification_interval) interval = profile.notification_interval if timestamp - last_date < timedelta(hours=interval): continue if profile.is_expertA or profile.is_manager_expertB: score_pk = Score.objects.all() elif profile.is_expertB: score_pk = Score.objects.filter(task__user=user) elif profile.is_organization: score_pk = Score.objects.filter(task__organization__in=profile.organization.all()) else: score_pk = Score.objects.none() comments = Comment.objects.filter( content_type__model='score', object_pk__in=score_pk.values_list('id', flat=True), ).order_by('submit_date') if last_date: comments = comments.filter(submit_date__gte=last_date) if not user.userprofile.notification_self: comments = comments.exclude(user=user) if not comments: continue context = { 'comments': comments, 'expert': expert, 'from': last_date, 'site': current_site, 'till': timestamp, 'user': user, } send_email.delay(user.email, subject, 'digest', context=context) profile.digest_date_journal = datetime.now() profile.save()
def add_points_on_order(order=None, **kwargs): log.debug("Caught order, attempting to add customer points pending.") rewards_enabled = config_value('PAYMENT_REWARD', 'REWARD_ENABLE') if order and rewards_enabled: if order.contact.user: if not RewardItem.objects.filter(order=order).filter(status=POINTS_PENDING).exists(): #reward = Reward.objects.get_or_create(contact=order.contact) points = math.floor(order.sub_total * config_value('PAYMENT_REWARD', 'POINTS_EARNT') /100) RewardItem.objects.update_or_create(order.contact,order,points,POINTS_PENDING, _('Points from Order'))
def testLcrLoad(self): """docstring for testLcrLoad""" resp = '<result>\n <row id="1"> <prefix>380</prefix> <carrier_name>ukrtelecom</carrier_name> <rate>0.22800</rate> <codec></codec> <cid></cid> <dialstring>[lcr_carrier=ukrtelecom,lcr_rate=0.22800]sofia/external/380443615162</dialstring> </row></result>' self.assertEquals(config_value("SERVER", "rcphost"), "127.0.0.1") self.assertEquals(config_value("SERVER", "rcpport"), "8080") self.assertEquals(config_value("SERVER", "rcpuser"), "freeswitch") self.assertEquals(config_value("SERVER", "rcppasswd"), "works") xml_resp = Soup(resp) self.assertEquals(xml_resp.row.rate.string, "0.22800")
def claim_notification(sender, **kwargs): """ Оповещение о претензиях. """ claim = kwargs['claim'] request = kwargs['request'] creation = kwargs['creation'] score = claim.score theme = _('New claim') if creation else _('Delete claim') subject = _('%(prefix)s%(monitoring)s - %(org)s: %(code)s - %(theme)s') % { 'prefix': config_value('EmailServer', 'EMAIL_SUBJECT_PREFIX'), 'monitoring': score.task.organization.monitoring, 'org': score.task.organization.name.split(':')[0], 'code': score.parameter.code, 'theme': theme, } url = '%s://%s%s' % (request.is_secure() and 'https' or 'http', request.get_host(), reverse('exmo2010:score_view', args=[score.pk])) t_plain = loader.get_template('score_claim.txt') t_html = loader.get_template('score_claim.html') c = Context({'score': score, 'claim': claim, 'url': url, 'creation': creation, 'current_user': request.user.userprofile.legal_name, }) message_plain = t_plain.render(c) message_html = t_html.render(c) headers = { 'X-iifd-exmo': 'claim_notification' } recipients = list(get_experts().values_list('email', flat=True)) if score.task.user.email and score.task.user.email not in recipients: recipients.append(score.task.user.email) for r in recipients: email = EmailMultiAlternatives(subject, message_plain, config_value('EmailServer', 'DEFAULT_FROM_EMAIL'), [r], [], headers=headers,) email.attach_alternative(message_html, "text/html") email.send()
def __init__(self, *args, **kwargs): super(Charge, self).__init__(*args, **kwargs) import stripe DEBUG = settings.DEBUG STRIPE_TEST_MODE = config_value('laurenmcmanus', 'STRIPE_TEST_MODE') if DEBUG == True or STRIPE_TEST_MODE == True: stripe.api_key = config_value('laurenmcmanus', 'STRIPE_TEST_PUBLIC_KEY') else: stripe.api_key = config_value('laurenmcmanus', 'STRIPE_LIVE_PUBLIC_KEY') self.stripe = stripe
def add(request, id=0, redirect_to='satchmo_cart'): """Add an item to the cart.""" log.debug('FORM: %s', request.POST) formdata = request.POST.copy() productslug = None cartplaces = config_value('SHOP', 'CART_PRECISION') roundfactor = config_value('SHOP', 'CART_ROUNDING') if formdata.has_key('productname'): productslug = formdata['productname'] try: product, details = product_from_post(productslug, formdata) if not (product and product.active): log.debug("product %s is not active" % productslug) return bad_or_missing(request, _("That product is not available at the moment.")) else: log.debug("product %s is active" % productslug) except (Product.DoesNotExist, MultiValueDictKeyError): log.debug("Could not find product: %s", productslug) return bad_or_missing(request, _('The product you have requested does not exist.')) # First we validate that the number isn't too big. if decimal_too_big(formdata['quantity']): return _product_error(request, product, _("Please enter a smaller number.")) # Then we validate that we can round it appropriately. try: quantity = round_decimal(formdata['quantity'], places=cartplaces, roundfactor=roundfactor) except RoundedDecimalError: return _product_error(request, product, _("Invalid quantity.")) if quantity <= Decimal('0'): return _product_error(request, product, _("Please enter a positive number.")) cart = Cart.objects.from_request(request, create=True) # send a signal so that listeners can update product details before we add it to the cart. satchmo_cart_details_query.send( cart, product=product, quantity=quantity, details=details, request=request, form=formdata ) try: added_item = cart.add_item(product, number_added=quantity, details=details) except CartAddProhibited, cap: return _product_error(request, product, cap.message)
def add_dumb_urls(sender, patterns=None, **kwargs): """ Payment in satchmo is unfriendly towards us; it only adds urls for modules with `PAYMENT_PROCESSOR` in their model. (See models.py on why we don't define `PAYMENT_PROCESSOR`.) """ patterns.append( url(r'^checkout/%s/' % config_value(config_group, 'URL_BASE'), include('%s.urls' % config_value(config_group, 'MODULE').__name__),) )
def send_mail(subject, message, recipients): log = logging.getLogger('panda.utils.mail') if not config_value('EMAIL', 'EMAIL_ENABLED'): log.info('Email is disabled, not sending message to %s' % recipients) return try: mail.send_mail('[PANDA] %s' % subject, message, str(config_value('EMAIL', 'DEFAULT_FROM_EMAIL')), recipients, connection=get_connection()) except socket.error: log.error('Failed connecting to email server. (Sending to %s.)' % recipients)
def test_checkout(self): """ Run through a full checkout process """ cache_delete() tax = config_get("TAX", "MODULE") tax.update("tax.modules.percent") pcnt = config_get("TAX", "PERCENT") pcnt.update("10") shp = config_get("TAX", "TAX_SHIPPING") shp.update(False) self.test_cart_adding() response = self.client.post(url("satchmo_checkout-step1"), get_step1_post_data(self.US)) self.assertRedirects(response, url("DUMMY_satchmo_checkout-step2"), status_code=302, target_status_code=200) data = { "credit_type": "Visa", "credit_number": "4485079141095836", "month_expires": "1", "year_expires": "2014", "ccv": "552", "shipping": "FlatRate", } response = self.client.post(url("DUMMY_satchmo_checkout-step2"), data) self.assertRedirects(response, url("DUMMY_satchmo_checkout-step3"), status_code=302, target_status_code=200) response = self.client.get(url("DUMMY_satchmo_checkout-step3")) self.assertContains( response, smart_str("Shipping + %s4.00" % config_value("LANGUAGE", "CURRENCY")), count=1, status_code=200 ) self.assertContains( response, smart_str("Tax + %s4.60" % config_value("LANGUAGE", "CURRENCY")), count=1, status_code=200 ) self.assertContains( response, smart_str("Total = %s54.60" % config_value("LANGUAGE", "CURRENCY")), count=1, status_code=200 ) response = self.client.post(url("DUMMY_satchmo_checkout-step3"), {"process": "True"}) self.assertRedirects(response, url("DUMMY_satchmo_checkout-success"), status_code=302, target_status_code=200) self.assertEqual(len(mail.outbox), 1) # Log in as a superuser user = User.objects.create_user("fredsu", "*****@*****.**", "passwd") user.is_staff = True user.is_superuser = True user.save() self.client.login(username="******", password="******") # Test pdf generation response = self.client.get("/admin/print/invoice/1/") self.assertContains(response, "reportlab", status_code=200) response = self.client.get("/admin/print/packingslip/1/") self.assertContains(response, "reportlab", status_code=200) response = self.client.get("/admin/print/shippinglabel/1/") self.assertContains(response, "reportlab", status_code=200)
def display_featured(): """ Used by the index generic view to choose how the featured products are displayed. Items can be displayed randomly or all in order """ random_display = config_value('PRODUCT','RANDOM_FEATURED') num_to_display = config_value('PRODUCT','NUM_DISPLAY') q = Product.objects.featured_by_site() if not random_display: return q[:num_to_display] else: return q.order_by('?')[:num_to_display]
class OptionGroupOptions(admin.ModelAdmin): inlines = [Option_Inline] if get_l10n_setting('show_admin_translations'): inlines.append(OptionGroupTranslation_Inline) if config_value('SHOP', 'SHOW_SITE'): list_display = ('site', ) else: list_display = () list_display += ('name', )
def discount_price(product, discount): """Returns the product price with the discount applied, including tax if that is the default. Ex: product|discount_price:sale """ if config_value('TAX', 'DEFAULT_VIEW_TAX'): return taxed_discount_price(product, discount) else: return untaxed_discount_price(product, discount)
def make_thumbnail(photo_url, width=None, height=None, root=settings.MEDIA_ROOT, url_root=settings.MEDIA_URL): """ create thumbnail """ # one of width/height is required assert (width is not None) or (height is not None) if not photo_url: return None th_url = _get_thumbnail_path(photo_url, width, height) th_path = _get_path_from_url(th_url, root, url_root) photo_path = _get_path_from_url(photo_url, root, url_root) if _has_thumbnail(photo_url, width, height, root, url_root): # thumbnail already exists if not (os.path.getmtime(photo_path) > os.path.getmtime(th_path)): # if photo mtime is newer than thumbnail recreate thumbnail return th_url # make thumbnail # get original image size orig_w, orig_h = get_image_size(photo_url, root, url_root) if (orig_w is None) and (orig_h) is None: # something is wrong with image return photo_url # make proper size if (width is not None) and (height is not None): if (orig_w == width) and (orig_h == height): # same dimensions return None size = (width, height) elif width is not None: if orig_w == width: # same dimensions return None size = (width, orig_h) elif height is not None: if orig_h == height: # same dimensions return None size = (orig_w, height) try: img = Image.open(photo_path).copy() img.thumbnail(size, Image.ANTIALIAS) img.save(th_path, quality=config_value('THUMBNAIL', 'IMAGE_QUALITY')) except Exception, err: # this goes to webserver error log import sys print >> sys.stderr, '[MAKE THUMBNAIL] error %s for file %r' % ( err, photo_url) return photo_url
def upload_dir(instance, filename): raw = "images/" try: raw = config_value('PRODUCT', 'IMAGE_DIR') except SettingNotSet: pass except ImportError, e: log.warn("Error getting upload_dir, OK if you are in SyncDB.")
def category_view_kamel(request, slug, parent_slugs='', template='product/category.html'): """Display the category, its child categories, and its products. Parameters: - slug: slug of category - parent_slugs: ignored """ if request.method == "GET": currpage = request.GET.get('page', 1) town = request.GET.get('town') else: currpage = 1 town = 'Gdansk' is_paged = False page = None try: category = Category.objects.get_by_site(slug=slug) products = list(category.active_products()) sale = find_best_auto_discount(products) count = config_value('PRODUCT', 'NUM_PAGINATED') paginator = Paginator(products, count) try: paginator.validate_number(currpage) except EmptyPage: return bad_or_missing(request, _("Invalid page number")) is_paged = paginator.num_pages > 1 page = paginator.page(currpage) except Category.DoesNotExist: return bad_or_missing( request, _('The category you have requested does not exist.')) child_categories = category.get_all_children() ctx = { 'category': category, 'child_categories': child_categories, 'sale': sale, 'town': town, 'products': page.object_list, 'is_paginated': is_paged, 'page_obj': page, 'paginator': paginator } index_prerender.send(Product, request=request, context=ctx, category=category, object_list=products) return render_to_response(template, context_instance=RequestContext(request, ctx))
def cost(self): """ Complex calculations can be done here as long as the return value is a dollar figure """ fee = Decimal("0.00") rate = config_value('SHIPPING', 'PER_RATE') for cartitem in self.cart.cartitem_set.all(): if cartitem.product.is_shippable: fee += rate * cartitem.quantity return fee
def mail_comment(request, comment): score = comment.content_object monitoring = score.task.organization.monitoring if not monitoring.status in [MONITORING_INTERACTION, MONITORING_FINALIZING]: return users = User.objects.filter( userprofile__notification_type=UserProfile.NOTIFICATION_ONEBYONE, is_active=True, email__isnull=False) users = users.exclude(pk=comment.user.pk, userprofile__notification_self=False) experts = users.filter(Q(is_superuser=True) | Q(groups__name=UserProfile.expertA_group) | Q(pk=score.task.user.pk)) experts_thread = experts.filter(userprofile__notification_thread=True) experts_one = experts.filter(userprofile__notification_thread=False) orgusers = users.filter(userprofile__organization=score.task.organization) orgusers_thread = orgusers.filter(userprofile__notification_thread=True) orgusers_one = orgusers.filter(userprofile__notification_thread=False) subject = u'%(prefix)s%(monitoring)s - %(org)s: %(code)s' % { 'prefix': config_value('EmailServer', 'EMAIL_SUBJECT_PREFIX'), 'monitoring': monitoring, 'org': score.task.organization.name.split(':')[0], 'code': score.parameter.code} context = { 'title': '%s: %s' % (score.task.organization, score.parameter), 'masked_expert_name': _(config_value('GlobalParameters', 'EXPERT'))} comment_url = request.build_absolute_uri(reverse('exmo2010:score', args=[score.pk])) + '#c%s' % comment.pk recommendation_url = request.build_absolute_uri(reverse('exmo2010:recommendations', args=[score.task.pk])) + \ '#param%s' % score.parameter.pk # Send notifications with single comment. _mail_comment(experts_one, subject, dict(context, comments=[comment], url=comment_url, mask_expert_name=False)) _mail_comment(orgusers_one, subject, dict(context, comments=[comment], url=recommendation_url, mask_expert_name=True)) thread = CommentExmo.objects.filter(object_pk=score.pk) # Send notifications with whole comments thread. _mail_comment(experts_thread, subject, dict(context, comments=thread, url=comment_url, mask_expert_name=False)) _mail_comment(orgusers_thread, subject, dict(context, comments=thread, url=recommendation_url, mask_expert_name=True))
def _decryptCC(self): ccnum = _decrypt_code(self.encrypted_cc) if not config_value('PAYMENT', 'STORE_CREDIT_NUMBERS'): try: key = _encrypt_code(ccnum + '-card') encrypted_ccnum = keyedcache.cache_get(key) ccnum = _decrypt_code(encrypted_ccnum) except keyedcache.NotCachedError: ccnum = "" return ccnum
def Encrypt(self): self.ErrorCode = '0' self.ErrorDescription = '' self.ToBeEncrypt = '' if not self.ShopLogin: self.ErrorCode = '546' self.ErrorDescription = 'IDshop not valid' return None if not self.Currency: self.ErrorCode = '552' self.ErrorDescription = 'Currency not valid' return None if not self.Amount: self.ErrorCode = '553' self.ErrorDescription = 'Amount not valid' return None if not self.ShopTransactionID: self.ErrorCode = '551' self.ErrorDescription = 'Shop Transaction ID not valid' return None self.ToEncrypt(self.CVV, 'PAY1_CVV') self.ToEncrypt(self.Min, 'PAY1_MIN') self.ToEncrypt(self.Currency, 'PAY1_UICCODE') self.ToEncrypt(self.Amount, 'PAY1_AMOUNT') self.ToEncrypt(self.ShopTransactionID, 'PAY1_SHOPTRANSACTIONID') self.ToEncrypt(self.CardNumber, 'PAY1_CARDNUMBER') self.ToEncrypt(self.ExpMonth, 'PAY1_EXPMONTH') self.ToEncrypt(self.ExpYear, 'PAY1_EXPYEAR') self.ToEncrypt(self.BuyerName, 'PAY1_CHNAME') self.ToEncrypt(self.BuyerEmail, 'PAY1_CHEMAIL') self.ToEncrypt(self.Language, 'PAY1_IDLANGUAGE') self.ToEncrypt(self.CustomInfo, '') self.ToBeEncrypt = string.replace(self.ToBeEncrypt, ' ', '§') uri = '%s?a=%s&b=%s' % (self.ScriptEnCrypt, self.ShopLogin, self.ToBeEncrypt[len(self.separator):]) live = config_value('PAYMENT_CREDITCARD', 'LIVE') if live: self.EncryptedString = self.HttpGetResponse( self.DomainName, uri, 1) else: self.EncryptedString = self.HttpGetResponse( self.TestDomainName, uri, 1) if not self.EncryptedString: return None return 1
def process(self, order=None): """ Calculate the tax and return it. Probably need to make a breakout. """ if order: self.order = order else: order = self.order sub_total = Decimal('0.00') taxes = {} rates = {} for item in order.orderitem_set.filter(product__taxable=True): tc = item.product.taxClass if tc: tc_key = tc.title else: tc_key = "Default" if rates.has_key(tc_key): rate = rates[tc_key] else: rate = self.get_rate(tc, get_object=True) rates[tc_key] = rate taxes[tc_key] = Decimal("0.00") # XXX If this setting is true, # Satchmo does it wrong most of the time. # We MUST have tests for this! if config_value('TAX', 'TAX_USE_ITEMPRICE'): # In Europe, if there is a supplier # which applies discounts to products # you have to use full price for taxes. price = item.line_item_price else: # use discounted price before taxing price = item.sub_total if rate: t = price * rate.percentage else: t = Decimal("0.00") sub_total += t taxes[tc_key] += t ship = self.shipping() sub_total += ship taxes['Shipping'] = ship for k in taxes: taxes[k] = taxes[k] return sub_total, taxes
def index(request): """ Page shell for the client-side application. Bootstraps read-once data onto the page. """ serializer = Serializer() cr = CategoryResource() categories = list( Category.objects.annotate(dataset_count=Count('datasets'))) bundles = [cr.build_bundle(obj=c) for c in categories] categories_bootstrap = [cr.full_dehydrate(b) for b in bundles] uncategorized = Category(id=settings.PANDA_UNCATEGORIZED_ID, slug=settings.PANDA_UNCATEGORIZED_SLUG, name=settings.PANDA_UNCATEGORIZED_NAME) uncategorized.__dict__['dataset_count'] = Dataset.objects.filter( categories=None).count() uncategorized_bundle = cr.full_dehydrate( cr.build_bundle(obj=uncategorized)) categories_bootstrap.append(uncategorized_bundle) return render_to_response( 'index.html', { 'settings': settings, 'warn_upload_size': int(config_value('MISC', 'WARN_UPLOAD_SIZE')), 'max_upload_size': int(config_value('MISC', 'MAX_UPLOAD_SIZE')), 'email_enabled': int(config_value('EMAIL', 'EMAIL_ENABLED')), 'demo_mode_enabled': int(config_value('MISC', 'DEMO_MODE_ENABLED')), 'bootstrap_data': serializer.to_json({'categories': categories_bootstrap}), 'moment_lang_code': settings.MOMENT_LANGUAGE_MAPPING.get(settings.LANGUAGE_CODE, None), })
def recentlyviewed(recent, slug=""): """Build a list of recent products, skipping the current one if given.""" if slug: recent = [r for r in recent if slug != r.slug] rmax = config_value('PRODUCT','RECENT_MAX') if len(recent) > rmax: recent = recent[:rmax] return { 'recent_products' : recent, }
def get_shop_config(self): shop_config = Config.objects.get_current() schema = self.schema() config = {} for key in schema.keys(): config_path, config_attribute = schema[key] value = config_value(*config_path) if not value and config_attribute is not None: value = getattr(shop_config, config_attribute, None) config[key] = value return config
def handle(self, *args, **options): # pylint: disable=R0914 verbosity = int(options.get('verbosity', 1)) user = config_value('ReceiveMail', 'USERNAME') password = config_value('ReceiveMail', 'PASSWORD') server = config_value('ReceiveMail', 'SERVER') port = config_value('ReceiveMail', 'PORT') ssl = config_value('ReceiveMail', 'SSL_ENABLED') logger = logging.getLogger('econsensus') try: if ssl == True: mailbox = poplib.POP3_SSL(server, port) else: mailbox = poplib.POP3(server, port) mailbox.user(user) mailbox.pass_(password) except poplib.error_proto, e: logger.error(e) raise
def display_bestsellers(request, count=0, template='product/best_sellers.html'): """Display a list of the products which have sold the most""" if count == 0: count = config_value('PRODUCT', 'NUM_PAGINATED') ctx = RequestContext(request, { 'products': bestsellers(count), }) return render_to_response(template, context_instance=ctx)
def clean(self, value): """ Normalize the field according to cart normalizing rules. """ cartplaces = config_value('SHOP', 'CART_PRECISION') roundfactor = config_value('SHOP', 'CART_ROUNDING') if not value or value == '': value = Decimal(0) try: value = round_decimal(val=value, places=cartplaces, roundfactor=roundfactor, normalize=True) except RoundedDecimalError: raise forms.ValidationError( _('%(value)s is not a valid number') % {'value': value}) return value
def gift_box(context): gift_category = config_value('GIFT_INFO', 'GIFT_CATEGORY') if gift_category: gifts = gift_category.active_products(include_children=True) else: gifts = [] if gifts: gift = gifts[0] else: gift = None return {'gift': gift}
def config_boolean(option): """Looks up the configuration option, returning true or false.""" args = option.split('.') try: val = config_value(*args) except: log.warn('config_boolean tag: Tried to look up config setting "%s", got SettingNotSet, returning False', option) val = False if val: return "true" else: return ""
def gift_certificate_processor(order): """ If an order has gift certificates, then we'll try to send emails to the recipients """ from payment.modules.giftcertificate.models import GiftCertificate email_sent = False send_email = config_value('PAYMENT_GIFTCERTIFICATE', 'EMAIL_RECIPIENT') if send_email: gcs = GiftCertificate.objects.filter(order=order) for gc in gcs: if gc.recipient_email: send_gift_certificate_by_email(gc) email_sent = True return email_sent
def shipping(self, subtotal=None): if subtotal is None and self.order: subtotal = self.order.shipping_sub_total if subtotal: rate = None if config_value('TAX','TAX_SHIPPING'): try: tc = TaxClass.objects.get(title=config_value('TAX', 'TAX_CLASS')) rate = self.get_rate(taxclass=tc) except: log.error("'Shipping' TaxClass doesn't exist.") if rate: t = rate * subtotal else: t = Decimal("0.00") else: t = Decimal("0.00") return t
def __init__(self, *args, **kwargs): template_basename = kwargs.pop('template_basename') context = Context(dict(kwargs.pop('context'), subject=kwargs['subject'])) body_txt = loader.get_template(template_basename + '.txt').render(context) body_html = loader.get_template(template_basename + '.html').render(context) kwargs.update( body=body_txt, alternatives=[(body_html, "text/html")], from_email=kwargs.get('from_email', config_value('EmailServer', 'DEFAULT_FROM_EMAIL'))) super(ExmoEmail, self).__init__(*args, **kwargs)
def confirm_info(request, template="shop/checkout/reward/confirm.html"): checkout_url = reverse('satchmo_checkout-step1') try: order = Order.objects.from_request(request) except Order.DoesNotExist: return HttpResponseRedirect(checkout_url) contact = Contact.objects.from_request(request) reward, created = Reward.objects.get_or_create(contact=contact) if not reward.points: messages.error( request, "You do not have any points. Please select an alternate payment method." ) return HttpResponseRedirect(checkout_url) point_modifier = config_value('PAYMENT_REWARD', 'POINTS_VALUE') total_point_value = point_modifier * reward.points needs_total = config_value('PAYMENT_REWARD', 'REWARDS_NEED_TOTAL') if total_point_value > order.balance: point_value_used = order.balance points_used = point_value_used / point_modifier else: points_used = reward.points point_value_used = total_point_value controller = RewardConfirmController(request, payment_module) controller.templates['CONFIRM'] = template controller.extra_context = { 'points_used': points_used, 'points_balance': reward.points, 'needs_total': needs_total } controller.confirm() return controller.response
def add(request, id=0, redirect_to='satchmo_cart'): """Add an item to the cart.""" log.debug('FORM: %s', request.POST) formdata = request.POST.copy() productslug = None cartplaces = config_value('SHOP', 'CART_PRECISION') roundfactor = config_value('SHOP', 'CART_ROUNDING') if formdata.has_key('productname'): productslug = formdata['productname'] try: product, details = product_from_post(productslug, formdata) if not (product and product.active): log.debug("product %s is not active" % productslug) return bad_or_missing( request, _("That product is not available at the moment.")) else: log.debug("product %s is active" % productslug) except (Product.DoesNotExist, MultiValueDictKeyError): log.debug("Could not find product: %s", productslug) return bad_or_missing( request, _('The product you have requested does not exist.')) # First we validate that the number isn't too big. if decimal_too_big(formdata['quantity']): return _product_error(request, product, _("Please enter a smaller number.")) # Then we validate that we can round it appropriately. try: quantity = round_decimal(formdata['quantity'], places=cartplaces, roundfactor=roundfactor) except RoundedDecimalError, P: return _product_error(request, product, _("Invalid quantity."))
def _get_maillist(listname): try: if not listname: listname = config_value('NEWSLETTER', 'NEWSLETTER_NAME') if listname == "": log.warn("NEWSLETTER_NAME not set in store settings") raise NameError('No NEWSLETTER_NAME in settings') return MailList.MailList(listname, lock=0), listname except Errors.MMUnknownListError: print >> sys.stderr, "Can't find the MailMan newsletter: %s" % listname raise NameError('No such newsletter, "%s"' % listname)
def _get_prev_cart(request): try: contact = Contact.objects.from_request(request) saved_cart = contact.cart_set.latest('date_time_created') # If the latest cart has len == 0, cart is unusable. if len(saved_cart) and 'cart' in request.session: existing_cart = Cart.objects.from_request(request, create=False) if ((len(existing_cart) == 0) or config_value('SHOP', 'PERSISTENT_CART_MERGE')): # Merge the two carts together saved_cart.merge_carts(existing_cart) request.session['cart'] = saved_cart.id except Exception, e: pass
def account_balance(context): """docstring for accaut_balance""" request = context['request'] try: contact = Contact.objects.from_request(request, create=False) balance = Balance.objects.get(accountcode=contact) except Contact.DoesNotExist: contact = None balance = None return { 'contact': contact, 'balance': balance, 'c': config_value('LANGUAGE', 'CURRENCY') }
def add_points_on_complete(order): try: item = RewardItem.objects.get(order=order) except RewardItem.DoesNotExist: points = math.floor( order.total * config_value('PAYMENT_REWARD', 'POINTS_EARNT') / 100) description = _('Points earned from Order #%s' % order.id) item = RewardItem.objects.update_or_create(order.contact, order, points, POINTS_ADDED, description) except Execption, err: log.debug("Can't change status of points") log.debug(traceback.format_exc()) return
def mail_feedback(request, sender_email, body): # Send email back to author send_email.delay(ExmoEmail( template_basename='mail/feedback_creator', context={'comment': body}, subject=_("Feedback"), to=[sender_email])) # Send email to support staff send_email.delay(ExmoEmail( template_basename='mail/feedback_recipient', context=dict(comment=body, email=sender_email, user=request.user), subject=_("Feedback"), to=[config_value('EmailServer', 'DEFAULT_SUPPORT_EMAIL')]))
def mail_contacts_frontpage(formdata): # Send email back to author send_email.delay(ExmoEmail( template_basename='mail/contacts_creator', context=formdata, subject=_("Infometer communication"), to=[formdata["email"]])) # Send email to support staff send_email.delay(ExmoEmail( template_basename='mail/contacts_recipient', context=formdata, subject=_("Infometer communication"), to=[config_value('EmailServer', 'DEFAULT_SUPPORT_EMAIL')]))
def __init__(self, request, payment_module, extra_context={}): self.request = request self.paymentModule = payment_module if payment_module: processor_module = payment_module.MODULE.load_module('processor') self.processor = processor_module.PaymentProcessor(self.paymentModule) else: self.processor = None self.viewTax = config_value('TAX', 'DEFAULT_VIEW_TAX') self.order = None self.cart = None self.extra_context = extra_context self.no_stock_checkout = config_value('PRODUCT','NO_STOCK_CHECKOUT') #to override the form_handler, set this #otherwise it will use the built-in `_onForm` self.onForm = self._onForm #to override the success method, set this #othewise it will use the built-in `_onSuccess` self.onSuccess = self._onSuccess #false on any "can not continue" error self.valid = False #the value to be returned from the view #an HttpResponse or a HttpRedirect self.response = None self.processorMessage = "" self.processorReasonCode = "" self.processorResults = None self.templates = { 'CONFIRM' : 'shop/checkout/confirm.html', 'EMPTY_CART': 'shop/checkout/empty_cart.html', '404': 'shop/404.html', }