def process_payments():
# cycle all unpaid payments
for payment in Payment.objects.filter(
paid=False, provider=settings.PAYMENT_PROVIDER_STRIPE):
# update charging attempt
if payment.last_charging_attempt == None or payment.last_charging_attempt < date.today(
):
payment.last_charging_attempt = date.today()
# try charging
provider, transaction_id = _charge_payment(payment)
if provider:
payment.provider = provider
payment.transaction_id = transaction_id
payment.paid = True
payment.save()
payment_export_util.export_payment(payment)
else:
# notify admin
receiver = payment.user.payment_details.email if payment.user.payment_details.email else None
mailer.send_mail('payment_failed', {
'amount_due': payment.amount_due,
'currency': payment.currency
}, payment.user, receiver)
# save changes
payment.charging_attempts += 1
payment.save()
def jpg_transcode_success(message):
key = message['result']['key']
try:
# update source object
source = Source.objects.get(key=key)
# only send mails if jpg sequence change is new
for v in source.get_attached_videos():
mailer.send_mail('jpg_transcode_succeeded', {'title':v.draft.title}, v.team.owner)
source.jpg_sequence_support = True
source.jpg_sequence_length = message['result']['results']['frames']
source.sprite_support = True
source.sprite_length = message['result']['results']['frames']
source.save()
# reexport all attached video objects
for v in source.get_attached_videos():
v.reexport()
except Source.DoesNotExist:
pass # do nothing..
def _send_six_weeks_follow_up(max_mails):
six_weeks_ago = datetime.now() - timedelta(days=SIX_WEEKS)
two_months_ago = datetime.now() - timedelta(days=TWO_MONTHS)
# all users which have received mail 21 and have not been seen for longer than 6 weeks
users = User.objects.filter(
activity__last_seen__lte=six_weeks_ago,
date_joined__gte=two_months_ago,
automated_mails__mailtype=AutomatedMail.TYPE_FOLLOW_UP_21,
settings__receive_retention_emails=True)
users = users.exclude(
automated_mails__mailtype=AutomatedMail.TYPE_FOLLOW_UP_42)
count = 0
for u in users:
three_weeks_ago = datetime.now() - timedelta(days=TREE_WEEKS)
if u.automated_mails.filter(mailtype=AutomatedMail.TYPE_FOLLOW_UP_21,
created__gte=three_weeks_ago).count():
continue
# send
mailer.send_mail('follow_up_six_weeks', {}, u)
AutomatedMail.objects.create(user=u,
mailtype=AutomatedMail.TYPE_FOLLOW_UP_42)
count += 1
if count > max_mails: break
def send_share_mail(video, recipients, message):
recipients = re.split("[\ ,]", recipients)
# validate emails
recipients_validated = []
try:
for r in recipients:
if len(r.strip()) > 0:
validate_email(r)
recipients_validated.append({'email': r})
except ValidationError:
return False, "Could not parse recipients"
if len(recipients_validated) == 0:
return False, "No valid recipients"
mailer.send_mail(
'share_video', {
'message': message,
'description': video.draft.description,
'title': video.draft.title,
'link': "http://player.videopath.com/" + video.key,
'thumb_url': thumbnails_for_video(video)["large"],
'to': recipients_validated,
}, video.team.owner)
return True, ""
def jpg_transcode_error(message):
key = message['request']['source']['key']
try:
source = Source.objects.get(key=key)
for v in source.get_attached_videos():
mailer.send_mail('jpg_transcode_failed', {'title':v.draft.title}, v.team.owner)
except Source.DoesNotExist:
pass
def process_notification(request, type):
# load body
try:
post = json.loads(request.body)
except BaseException:
return HttpResponse()
# respond to aws subscription request
if post['Type'] == 'SubscriptionConfirmation':
if 'Token' in post and 'TopicArn' in post:
confirm_subscription(post['TopicArn'], post['Token'])
return HttpResponse()
# retrieve video file
message = json.loads(post['Message'])
key = message['input']['key']
state = message["state"]
try:
source = Source.objects.get(key=key)
except Source.DoesNotExist:
return HttpResponse()
# parse status out of type
if state == 'PROGRESSING':
source.status = Source.STATUS_PROCESSING
elif state == 'COMPLETED':
thumbs_no = '00001' #'00002' if message['outputs'][0]['duration'] > 65 else '00001'
source.aspect = float(message['outputs'][0]['width']) / float(
message['outputs'][0]['height'])
source.duration = message['outputs'][0]['duration']
source.status = Source.STATUS_OK
source.file_mp4 = key + '.mp4'
source.file_webm = key + '.webm'
source.thumbnail_small = key + '/' + thumbs_no + '.jpg'
source.thumbnail_large = key + '/' + thumbs_no + '-hd.jpg'
revision = source.revisions.first()
send_mail('transcode_complete', {
'title': revision.title,
'video_id': revision.video.id
}, revision.video.team.owner)
elif state == 'ERROR':
source.status = Source.STATUS_ERROR
source.description = message['outputs'][0]['statusDetail']
revision = source.revisions.first()
send_mail('transcode_error', {
'title': revision.title,
'video_id': revision.video.id
}, revision.video.team.owner)
source.save()
# respond with empty json
return HttpResponse()
def password_reset(request):
name = request.data.get("username", None).lower()
try:
user = User.objects.get(Q(username=name) | Q(email=name))
except User.DoesNotExist or User.MultipleObjectsReturned:
raise ValidationError(detail="Could not find user.")
# create new pw
password = user.create_new_password()
send_mail('forgot_password', {'password':password}, user)
return Response(status=201)
def _send_email(user, action=None):
if action == "plan_changed":
plan = settings.PLANS.get(user.subscription.plan,
settings.DEFAULT_PLAN)
mailer.send_mail(
'subscribe_change', {
'plan': plan['name'],
'interval': plan["payment_interval"],
'is_free': plan.get("default", False)
}, user)
elif action == "plan_will_change":
try:
plan = settings.PLANS.get(user.pending_subscription.plan,
settings.DEFAULT_PLAN)
mailer.send_mail(
'subscribe_will_change', {
'plan': plan["name"],
'switch_date': user.subscription.current_period_end
}, user)
except PendingSubscription.DoesNotExist:
pass
def create_payment(user, lines, currency):
amount_due = 0
percent_vat = 19
# get correct vat
try:
country = user.payment_details.country
if country in settings.VAT_RATES:
percent_vat = settings.VAT_RATES[country]
else:
percent_vat = 0
except PaymentDetails.DoesNotExist:
pass
# sum up
for line in lines:
amount_due += line["amount"]
# if nothing is due, leave
if amount_due <= 0:
return
payment = Payment.objects.create(user=user,
date=date.today(),
amount_due=amount_due,
percent_vat=percent_vat,
currency=currency,
details=json.dumps(lines),
provider=user.settings.payment_provider)
url = payment_export_util.url_for_payment(payment)
receiver = user.payment_details.email if user.payment_details.email else None
mailer.send_mail('invoice_created', {
'amount_due': amount_due,
'link': url,
'currency': currency
}, payment.user, receiver)
return payment
def create(self, request, *args, **kwargs):
# get and validate user data
user_dict = request.data.copy()
profile_dict = request.data.copy()
del user_dict['first_name']
del user_dict['last_name']
serializer = self.get_serializer(data=user_dict)
serializer.is_valid(raise_exception=True)
username = serializer.validated_data.get("username").lower()
email = serializer.validated_data.get("email").lower()
password = serializer.validated_data.get("password")
# confirm password match
password2 = request.data.get('password2','')
if password != password2:
return Response({'password':"******"}, status=status.HTTP_400_BAD_REQUEST)
# get and validate profile data
profile_serializer = FullProfileSerializer(data=request.data)
profile_serializer.is_valid(raise_exception=True)
first_name = profile_serializer.validated_data.get("first_name").title()
last_name = profile_serializer.validated_data.get("last_name").title()
gender = profile_serializer.validated_data.get("gender")
phone = profile_serializer.validated_data.get("phone")
occupation = profile_serializer.validated_data.get("occupation")
birthdate = profile_serializer.validated_data.get("birthdate")
industry = profile_serializer.validated_data.get("industry")
industry_other = profile_serializer.validated_data.get("industry_other")
with transaction.atomic():
user = User.objects.validate_and_create_user(username, email,password)
key8 = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(8))
profile = UserProfile(ref=key8, user=user, first_name=first_name, last_name=last_name, gender=gender, occupation=occupation, phone=phone, birthdate=birthdate, industry=industry, industry_other=industry_other)
profile.save()
# send a signup email
send_mail('signup', {}, user)
# users geo record
geo_service = service_provider.get_service("geo_ip")
geo_record = geo_service.record_from_request(request)
# create campaign information if available
campaign_data = UserCampaignData.objects.create(user=user)
campaign_data.country = geo_record['country_full'][:500]
if request.data:
try:
campaign_data.referrer = request.data.get('referrer', '')[:500]
except: pass
campaign = request.data.get('campaign', {})
if campaign:
try:
campaign_data.source = campaign.get('source', '')[:500]
campaign_data.medium = campaign.get('medium', '')[:500]
campaign_data.name = campaign.get('name', '')[:500]
campaign_data.content = campaign.get('content', '')[:500]
campaign_data.term = campaign.get('term', '')[:500]
except: pass
campaign_data.save()
# subscribe to mailchimp if they want to
if serializer.validated_data.get("newsletter", False):
try:
service = service_provider.get_service("mailchimp")
service.subscribe_email(user.email)
except: pass
# greate britain
if geo_record["country"] in ["UK", "GB"]:
user.settings.currency = settings.CURRENCY_GBP
# rest of europe
elif geo_record["continent"] == "EU":
user.settings.currency = settings.CURRENCY_EUR
# rest of world
else:
user.settings.currency = settings.CURRENCY_USD
try:
user.settings.phone_number = request.data.get('phone', '')
except: pass
user.settings.save()
# create tokens
token = AuthenticationToken.objects.create(user=user)
ottoken = OneTimeAuthenticationToken.objects.create(token=token)
# create response
result = UserSerializer(user, context={'request': request}).data
result["api_token"] = token.key
result["api_token_once"] = ottoken.key
# notify on slack
slack = service_provider.get_service("slack")
slack.notify("User " + user.email + " just signed up from " + geo_record["country_full"] + ".")
# possibly return some tokens and shit
return Response(result, status=status.HTTP_201_CREATED)
def _handle_user_exceeded(user):
if user.quota_info.quota_exceeded:
return
user.quota_info.quota_exceeded = True
user.quota_info.save()
mailer.send_mail('quota_exceeded', {}, user)
def _handle_user_warning(user):
if user.quota_info.warning_sent:
return
user.quota_info.warning_sent = True
user.quota_info.save()
mailer.send_mail('quota_warning', {}, user)
def _send_welcome_mail(user):
mailer.send_mail('welcome', {}, user)
AutomatedMail.objects.create(mailtype=AutomatedMail.TYPE_WELCOME,
user=user)
