def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=self.request.data)
serializer.is_valid(raise_exception=True)
user = self.get_user()
token = default_token_generator.make_token(user)
uid = urlsafe_base64_encode(force_bytes(user.pk))
context = {
'user': user,
'token': token,
'uid': uid,
'reset_link': ForgotPasswordView.generate_reset_link(uid, token),
}
email_data = {
'subject': 'Password Reset',
'to': user.email,
'context': context,
'template_name': 'password_reset_email',
'template_path': 'authentication/emails/'
}
email = BaseEmail(**email_data)
email.send()
return Response('OK')
def post(self, request, *args, **kwargs):
owner = self.request.user
vm = self.get_object()
opennebula_vm_id = self.kwargs.get('pk')
manager = OpenNebulaManager(email=owner.email, password=owner.password)
terminated = manager.delete_vm(vm.id)
if not terminated:
messages.error(request,
'Error terminating VM %s' % (opennebula_vm_id))
return HttpResponseRedirect(self.get_success_url())
context = {
'vm':
vm,
'base_url':
"{0}://{1}".format(self.request.scheme, self.request.get_host())
}
email_data = {
'subject': 'Virtual machine plan canceled',
'to': self.request.user.email,
'context': context,
'template_name': 'vm_status_changed',
'template_path': 'hosting/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.error(request,
'VM %s terminated successfully' % (opennebula_vm_id))
return HttpResponseRedirect(self.get_success_url())
def post(self, request, *args, **kwargs):
data = request.POST
vms = BetaAccessVM.create(data)
context = {
'base_url':
"{0}://{1}".format(self.request.scheme, self.request.get_host()),
'email':
data.get('email'),
'name':
data.get('name'),
'vms':
vms
}
email_data = {
'subject': 'DatacenterLight Beta Access Request',
'from_address':
'(datacenterlight) datacenterlight Support <*****@*****.**>',
'to': '*****@*****.**',
'context': context,
'template_name': 'request_beta_access_notification',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.add_message(self.request, messages.SUCCESS,
self.success_message)
return HttpResponseRedirect(self.get_success_url())
def register(cls,
name,
password,
email,
app='digital_glarus',
base_url=None,
send_email=True,
account_details=None):
user = cls.objects.filter(email=email).first()
if not user:
user = cls.objects.create_user(name=name,
email=email,
password=password)
if user:
if app == 'digital_glarus':
dg = DigitalGlarusRegistrationMailer(user.validation_slug)
dg.send_mail(to=user.email)
elif app == 'dcl':
dcl_text = settings.DCL_TEXT
user.is_active = False
if send_email is True:
email_data = {
'subject':
'{dcl_text} {account_activation}'.format(
dcl_text=dcl_text,
account_activation=_('Account Activation')),
'from_address':
settings.DCL_SUPPORT_FROM_ADDRESS,
'to':
user.email,
'context': {
'base_url':
base_url,
'activation_link':
reverse('hosting:validate',
kwargs={
'validate_slug':
user.validation_slug
}),
'dcl_text':
dcl_text
},
'template_name':
'user_activation',
'template_path':
'datacenterlight/emails/'
}
if account_details:
email_data['context'][
'account_details'] = account_details
email = BaseEmail(**email_data)
email.send()
return user
else:
return None
else:
return None
def post(self, *args, **kwargs):
vm = self.get_object()
vm.cancel_plan()
context = {
'vm': vm,
'base_url': "{0}://{1}".format(self.request.scheme, self.request.get_host())
}
email_data = {
'subject': 'Virtual machine plan canceled',
'to': self.request.user.email,
'context': context,
'template_name': 'vm_status_changed',
'template_path': 'hosting/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(self.get_success_url())
def post(self, request, *args, **kwargs):
owner = self.request.user
vm = self.get_object()
opennebula_vm_id = self.kwargs.get('pk')
manager = OpenNebulaManager(
email=owner.email,
password=owner.password
)
terminated = manager.delete_vm(
vm.id
)
if not terminated:
messages.error(
request,
'Error terminating VM %s' % (opennebula_vm_id)
)
return HttpResponseRedirect(self.get_success_url())
context = {
'vm': vm,
'base_url': "{0}://{1}".format(self.request.scheme, self.request.get_host())
}
email_data = {
'subject': 'Virtual machine plan canceled',
'to': self.request.user.email,
'context': context,
'template_name': 'vm_status_changed',
'template_path': 'hosting/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.error(
request,
'VM %s terminated successfully' % (opennebula_vm_id)
)
return HttpResponseRedirect(self.get_success_url())
def register(cls,
name,
password,
email,
app='digital_glarus',
base_url=None):
user = cls.objects.filter(email=email).first()
if not user:
user = cls.objects.create_user(name=name,
email=email,
password=password)
if user:
if app == 'digital_glarus':
dg = DigitalGlarusRegistrationMailer(user.validation_slug)
dg.send_mail(to=user.email)
elif app == 'dcl':
user.is_active = False
email_data = {
'subject':
_('Activate your Data Center Light account'),
'from_address':
'(Data Center Light) Data Center Light Support <*****@*****.**>',
'to': user.email,
'context': {
'base_url':
base_url,
'activation_link':
reverse(
'hosting:validate',
kwargs={'validate_slug': user.validation_slug})
},
'template_name': 'user_activation',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
return user
else:
return None
else:
return None
def form_valid(self, form):
context = {
'base_url': "{0}://{1}".format(self.request.scheme, self.request.get_host())
}
email_data = {
'subject': 'DatacenterLight Beta Access Request',
'to': form.cleaned_data.get('email'),
'context': context,
'template_name': 'request_access_confirmation',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
context.update({
'email': form.cleaned_data.get('email')
})
email_data = {
'subject': 'DatacenterLight Beta Access Request',
'to': '*****@*****.**',
'context': context,
'template_name': 'request_access_notification',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.add_message(self.request, messages.SUCCESS, self.success_message)
return render(self.request, 'datacenterlight/beta_success.html', {})
def form_valid(self, form):
context = {
'base_url': "{0}://{1}".format(self.request.scheme, self.request.get_host())
}
email_data = {
'subject': 'DatacenterLight Beta Access Request',
'from_address': '(datacenterlight) datacenterlight Support <*****@*****.**>',
'to': form.cleaned_data.get('email'),
'from': '(datacenterlight) DatacenterLight Support [email protected]',
'context': context,
'template_name': 'request_access_confirmation',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
context.update({
'email': form.cleaned_data.get('email')
})
email_data = {
'subject': 'DatacenterLight Beta Access Request',
'from_address': '(datacenterlight) datacenterlight Support <*****@*****.**>',
'to': '*****@*****.**',
'context': context,
'template_name': 'request_access_notification',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.add_message(self.request, messages.SUCCESS, self.success_message)
return super(IndexView, self).form_valid(form)
def post(self, request, *args, **kwargs):
data = request.POST
vms = BetaAccessVM.create(data)
context = {
'base_url': "{0}://{1}".format(self.request.scheme, self.request.get_host()),
'email': data.get('email'),
'name': data.get('name'),
'vms': vms
}
email_data = {
'subject': 'DatacenterLight Beta Access Request',
'to': '*****@*****.**',
'context': context,
'template_name': 'request_beta_access_notification',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.add_message(self.request, messages.SUCCESS, self.success_message)
return HttpResponseRedirect(self.get_success_url())
def form_valid(self, form):
booking_order = self.get_object()
booking_order.cancel()
request = self.request
BookingCancellation.create(booking_order)
context = {
'order': booking_order,
'booking': booking_order.booking,
'base_url': "{0}://{1}".format(request.scheme, request.get_host()),
'user': request.user
}
email_data = {
'subject': 'A cancellation has been requested',
'to': '*****@*****.**',
'context': context,
'template_name': 'booking_cancellation_notification',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
context = {
'order': booking_order,
'booking': booking_order.booking,
'base_url': "{0}://{1}".format(request.scheme, request.get_host())
}
email_data = {
'subject': 'Your booking has been cancelled',
'to': request.user.email,
'context': context,
'template_name': 'booking_cancellation',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.add_message(self.request, messages.SUCCESS,
self.success_message)
return HttpResponseRedirect(self.get_success_url())
def form_valid(self, form):
context = {
'base_url':
"{0}://{1}".format(self.request.scheme, self.request.get_host())
}
email_data = {
'subject': 'DatacenterLight Beta Access Request',
'from_address':
'(datacenterlight) datacenterlight Support <*****@*****.**>',
'to': form.cleaned_data.get('email'),
'from':
'(datacenterlight) DatacenterLight Support [email protected]',
'context': context,
'template_name': 'request_access_confirmation',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
context.update({'email': form.cleaned_data.get('email')})
email_data = {
'subject': 'DatacenterLight Beta Access Request',
'from_address':
'(datacenterlight) datacenterlight Support <*****@*****.**>',
'to': '*****@*****.**',
'context': context,
'template_name': 'request_access_notification',
'template_path': 'datacenterlight/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.add_message(self.request, messages.SUCCESS,
self.success_message)
return super(IndexView, self).form_valid(form)
def form_valid(self, form):
booking_order = self.get_object()
booking_order.cancel()
request = self.request
BookingCancellation.create(booking_order)
context = {
'order': booking_order,
'booking': booking_order.booking,
'base_url': "{0}://{1}".format(request.scheme, request.get_host()),
'user': request.user
}
email_data = {
'subject': 'A cancellation has been requested',
'to': '*****@*****.**',
'context': context,
'template_name': 'booking_cancellation_notification',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
context = {
'order': booking_order,
'booking': booking_order.booking,
'base_url': "{0}://{1}".format(request.scheme, request.get_host())
}
email_data = {
'subject': 'Your booking has been cancelled',
'to': request.user.email,
'context': context,
'template_name': 'booking_cancellation',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
messages.add_message(self.request, messages.SUCCESS, self.success_message)
return HttpResponseRedirect(self.get_success_url())
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
context = self.get_context_data()
token = form.cleaned_data.get('token')
donation_amount = form.cleaned_data.get('donation_amount')
# Get or create stripe customer
customer = StripeCustomer.get_or_create(email=self.request.user.email,
token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(self.get_context_data(form=form))
# Create Billing Address
billing_address = form.save()
# Make stripe charge to a customer
stripe_utils = StripeUtils()
stripe_utils.CURRENCY = 'usd'
charge_response = stripe_utils.make_charge(amount=donation_amount,
customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
return render(request, self.template_name, context)
# Create a donation
charge = charge_response.get('response_object')
donation_data = request.POST.copy()
donation_data.update({
'cc_brand': charge.source.brand,
'stripe_charge_id': charge.id,
'last4': charge.source.last4,
'billing_address': billing_address.id,
'donator': customer.id,
'donation': donation_amount
})
donation_form = DonationForm(donation_data)
if donation_form.is_valid():
# reactivate donation status
donation = donation_form.save()
try:
donator_status = DonatorStatus.objects.get(user=self.request.user)
donator_status.set_active()
except DonatorStatus.DoesNotExist:
pass
donation = donation_form.save()
context = {
'donation': donation,
'base_url': "{0}://{1}".format(request.scheme, request.get_host())
}
email_data = {
'subject': 'Your donation have been charged',
'to': request.user.email,
'context': context,
'template_name': 'donation_charge',
'template_path': 'nosystemd/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(reverse('nosystemd:donations',
kwargs={'pk': donation.id}))
else:
self.form_invalid(donation_form)
else:
return self.form_invalid(form)
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
# Get billing address data
billing_address_data = form.cleaned_data
context = self.get_context_data()
template = request.session.get('template')
specs = request.session.get('specs')
vm_template_id = template.get('id', 1)
final_price = specs.get('price')
token = form.cleaned_data.get('token')
owner = self.request.user
# Get or create stripe customer
customer = StripeCustomer.get_or_create(email=owner.email,
token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(self.get_context_data(form=form))
# Create Billing Address
billing_address = form.save()
# Make stripe charge to a customer
stripe_utils = StripeUtils()
charge_response = stripe_utils.make_charge(amount=final_price,
customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
return render(request, self.template_name, context)
charge = charge_response.get('response_object')
# Create OpenNebulaManager
manager = OpenNebulaManager(email=owner.email,
password=owner.password)
# Get user ssh key
if not UserHostingKey.objects.filter( user=self.request.user).exists():
context.update({
'sshError': 'error',
'form': form
})
return render(request, self.template_name, context)
# For now just get first one
user_key = UserHostingKey.objects.filter(
user=self.request.user).first()
# Create a vm using logged user
vm_id = manager.create_vm(
template_id=vm_template_id,
# XXX: Confi
specs=specs,
ssh_key=user_key.public_key,
)
# Create a Hosting Order
order = HostingOrder.create(
price=final_price,
vm_id=vm_id,
customer=customer,
billing_address=billing_address
)
# Create a Hosting Bill
bill = HostingBill.create(
customer=customer, billing_address=billing_address)
# Create Billing Address for User if he does not have one
if not customer.user.billing_addresses.count():
billing_address_data.update({
'user': customer.user.id
})
billing_address_user_form = UserBillingAddressForm(
billing_address_data)
billing_address_user_form.is_valid()
billing_address_user_form.save()
# Associate an order with a stripe payment
order.set_stripe_charge(charge)
# If the Stripe payment was successed, set order status approved
order.set_approved()
vm = VirtualMachineSerializer(manager.get_vm(vm_id)).data
# Send notification to ungleich as soon as VM has been booked
context = {
'vm': vm,
'order': order,
'base_url': "{0}://{1}".format(request.scheme, request.get_host())
}
email_data = {
'subject': 'New VM request',
'to': request.user.email,
'context': context,
'template_name': 'new_booked_vm',
'template_path': 'hosting/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(reverse('hosting:orders', kwargs={'pk': order.id}))
else:
return self.form_invalid(form)
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
data = form.cleaned_data
context = self.get_context_data()
token = data.get('token')
membership_type = data.get('membership_type')
# Get or create stripe customer
customer = StripeCustomer.get_or_create(email=self.request.user.email,
token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(self.get_context_data(form=form))
# Make stripe charge to a customer
stripe_utils = StripeUtils()
charge_response = stripe_utils.make_charge(amount=membership_type.first_month_price,
customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
return render(request, self.template_name, context)
charge = charge_response.get('response_object')
# Create Billing Address
billing_address = form.save()
# Create Billing Address for User if he does not have one
if not customer.user.billing_addresses.count():
data.update({
'user': customer.user.id
})
billing_address_user_form = UserBillingAddressForm(data)
billing_address_user_form.is_valid()
billing_address_user_form.save()
# Get membership dates
membership_start_date, membership_end_date = membership_type.first_month_range
# Create membership plan
membership_data = {
'type': membership_type,
'start_date': membership_start_date,
'end_date': membership_end_date
}
membership = Membership.create(membership_data)
# Create membership order
order_data = {
'membership': membership,
'customer': customer,
'billing_address': billing_address,
'stripe_charge': charge,
'amount': membership_type.first_month_price,
'start_date': membership_start_date,
'end_date': membership_end_date
}
membership_order = MembershipOrder.create(order_data)
request.session.update({
'membership_price': membership.type.first_month_price,
'membership_dates': membership.type.first_month_formated_range
})
context = {
'membership': membership,
'order': membership_order,
'membership_start_date': membership_start_date,
'membership_end_date': membership_end_date,
'base_url': "{0}://{1}".format(request.scheme, request.get_host())
}
email_data = {
'subject': 'Your membership has been charged',
'to': request.user.email,
'context': context,
'template_name': 'membership_charge',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(reverse('digitalglarus:membership_activated'))
else:
return self.form_invalid(form)
def handle(self, *args, **options):
translation.activate('en-us')
memberships_orders = MembershipOrder.objects.filter(membership__active=True)
current_month = datetime.now().month
current_year = datetime.now().year
print("--------- STARTING MEMBERSHIP CHARGING SCRIPT ---------")
print("Memberhips date: %s-%s" % (current_month, current_year))
for membership_order in memberships_orders:
member = membership_order.customer
try:
MembershipOrder.objects.get(created_at__month=current_month,
created_at__year=current_year,
customer=member)
except MembershipOrder.DoesNotExist:
try:
current_membership_price = membership_order.membership.type.price
last_membership_order = MembershipOrder.objects.filter(customer=member).last()
# Make stripe charge to a customer
stripe_utils = StripeUtils()
stripe_utils.CURRENCY = self.CURRENCY
charge_response = stripe_utils.make_charge(amount=current_membership_price,
customer=member.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
# There is an error trying to creating the stripe charge
context = {
'paymentError': charge_response.get('error'),
}
print("--------- STRIPE PAYMENT ERROR ---------")
print(context)
print("-------------------------")
continue
# Create a donation
charge = charge_response.get('response_object')
membership_order_data = {
'cc_brand': charge.source.brand,
'stripe_charge_id': charge.id,
'last4': charge.source.last4,
'membership': last_membership_order.membership.id,
'billing_address': last_membership_order.billing_address.id,
'customer': member.id,
'amount': current_membership_price
}
membership_order_form = MembershipOrderForm(membership_order_data)
if membership_order_form.is_valid():
membership_order = membership_order_form.save()
context = {
'order': membership_order,
'base_url': "{0}://{1}".format('https', 'dynamicweb.ungleich.ch')
}
email_data = {
'subject': 'Your monthly membership has been charged',
'to': member.user.email,
'context': context,
'template_name': 'membership_monthly_charge',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
print("--------- PAYMENT DONATION SUCCESSFULL ---------")
print("Member: %s" % member.user.email)
print("Amount: %s %s" % (current_membership_price, self.CURRENCY))
print("-----------------------------------------------")
except Exception as e:
print("--------- ERROR ---------")
print(e)
print("-------------------------")
continue
def create_vm_task(self, vm_template_id, user, specs, template, order_id):
logger.debug("Running create_vm_task on {}".format(
current_task.request.hostname))
vm_id = None
try:
final_price = (specs.get('total_price')
if 'total_price' in specs else specs.get('price'))
if 'pass' in user:
on_user = user.get('email')
on_pass = user.get('pass')
logger.debug("Using user {user} to create VM".format(user=on_user))
vm_name = None
else:
on_user = settings.OPENNEBULA_USERNAME
on_pass = settings.OPENNEBULA_PASSWORD
logger.debug("Using OpenNebula admin user to create VM")
vm_name = "{email}-{template_name}-{date}".format(
email=user.get('email'),
template_name=template.get('name'),
date=int(datetime.now().strftime("%s")))
# Create OpenNebulaManager
manager = OpenNebulaManager(email=on_user, password=on_pass)
vm_id = manager.create_vm(
template_id=vm_template_id,
specs=specs,
ssh_key=settings.ONEADMIN_USER_SSH_PUBLIC_KEY,
vm_name=vm_name)
if vm_id is None:
raise Exception("Could not create VM")
# Update HostingOrder with the created vm_id
hosting_order = HostingOrder.objects.filter(id=order_id).first()
error_msg = None
try:
hosting_order.vm_id = vm_id
hosting_order.save()
logger.debug("Updated hosting_order {} with vm_id={}".format(
hosting_order.id, vm_id))
except Exception as ex:
error_msg = (
"HostingOrder with id {order_id} not found. This means that "
"the hosting order was not created and/or it is/was not "
"associated with VM with id {vm_id}. Details {details}".format(
order_id=order_id, vm_id=vm_id, details=str(ex)))
logger.error(error_msg)
stripe_utils = StripeUtils()
result = stripe_utils.set_subscription_metadata(
subscription_id=hosting_order.subscription_id,
metadata={"VM_ID": str(vm_id)})
if result.get('error') is not None:
emsg = "Could not update subscription metadata for {sub}".format(
sub=hosting_order.subscription_id)
logger.error(emsg)
if error_msg:
error_msg += ". " + emsg
else:
error_msg = emsg
vm = VirtualMachineSerializer(manager.get_vm(vm_id)).data
context = {
'name': user.get('name'),
'email': user.get('email'),
'cores': specs.get('cpu'),
'memory': specs.get('memory'),
'storage': specs.get('disk_size'),
'price': final_price,
'template': template.get('name'),
'vm_name': vm.get('name'),
'vm_id': vm['vm_id'],
'order_id': order_id
}
if error_msg:
context['errors'] = error_msg
if 'pricing_name' in specs:
context['pricing'] = str(
VMPricing.get_vm_pricing_by_name(name=specs['pricing_name']))
email_data = {
'subject': settings.DCL_TEXT + " Order from %s" % context['email'],
'from_email': settings.DCL_SUPPORT_FROM_ADDRESS,
'to': ['*****@*****.**'],
'body':
"\n".join(["%s=%s" % (k, v) for (k, v) in context.items()]),
'reply_to': [context['email']],
}
email = EmailMessage(**email_data)
email.send()
if 'pass' in user:
lang = 'en-us'
if user.get('language') is not None:
logger.debug("Language is set to {}".format(
user.get('language')))
lang = user.get('language')
translation.activate(lang)
# Send notification to the user as soon as VM has been booked
context = {
'base_url':
"{0}://{1}".format(user.get('request_scheme'),
user.get('request_host')),
'order_url':
reverse('hosting:orders', kwargs={'pk': order_id}),
'page_header':
_('Your New VM %(vm_name)s at Data Center Light') % {
'vm_name': vm.get('name')
},
'vm_name':
vm.get('name')
}
email_data = {
'subject': context.get('page_header'),
'to': user.get('email'),
'context': context,
'template_name': 'new_booked_vm',
'template_path': 'hosting/emails/',
'from_address': settings.DCL_SUPPORT_FROM_ADDRESS,
}
email = BaseEmail(**email_data)
email.send()
# try to see if we have the IPv6 of the new vm and that if the ssh
# keys can be configured
vm_ipv6 = manager.get_ipv6(vm_id)
logger.debug("New VM ID is {vm_id}".format(vm_id=vm_id))
if vm_ipv6 is not None:
custom_user = CustomUser.objects.get(email=user.get('email'))
get_or_create_vm_detail(custom_user, manager, vm_id)
if custom_user is not None:
public_keys = get_all_public_keys(custom_user)
keys = [{
'value': key,
'state': True
} for key in public_keys]
if len(keys) > 0:
logger.debug("Calling configure on {host} for "
"{num_keys} keys".format(
host=vm_ipv6, num_keys=len(keys)))
# Let's wait until the IP responds to ping before we
# run the cdist configure on the host
did_manage_public_key = False
for i in range(0, 15):
if ping_ok(vm_ipv6):
logger.debug(
"{} is pingable. Doing a "
"manage_public_key".format(vm_ipv6))
sleep(10)
manager.manage_public_key(keys,
hosts=[vm_ipv6])
did_manage_public_key = True
break
else:
logger.debug(
"Can't ping {}. Wait 5 secs".format(
vm_ipv6))
sleep(5)
if not did_manage_public_key:
emsg = ("Waited for over 75 seconds for {} to be "
"pingable. But the VM was not reachable. "
"So, gave up manage_public_key. Please do "
"this manually".format(vm_ipv6))
logger.error(emsg)
email_data = {
'subject':
'{} CELERY TASK INCOMPLETE: {} not '
'pingable for 75 seconds'.format(
settings.DCL_TEXT, vm_ipv6),
'from_email':
current_task.request.hostname,
'to':
settings.DCL_ERROR_EMAILS_TO_LIST,
'body':
emsg
}
email = EmailMessage(**email_data)
email.send()
except Exception as e:
logger.error(str(e))
try:
retry_task(self)
except MaxRetriesExceededError:
msg_text = 'Finished {} retries for create_vm_task'.format(
self.request.retries)
logger.error(msg_text)
# Try sending email and stop
email_data = {
'subject':
'{} CELERY TASK ERROR: {}'.format(settings.DCL_TEXT, msg_text),
'from_email':
current_task.request.hostname,
'to':
settings.DCL_ERROR_EMAILS_TO_LIST,
'body':
',\n'.join(str(i) for i in self.request.args)
}
email = EmailMessage(**email_data)
email.send()
return
return vm_id
def form_valid(self, form):
data = form.cleaned_data
context = self.get_context_data()
token = data.get('token')
start_date = data.get('start_date')
end_date = data.get('end_date')
is_free = context.get('is_free')
normal_price, final_price, free_days = Booking.\
booking_price(self.request.user, start_date, end_date)
charge = None
# if not credit_card_needed:
# Get or create stripe customer
customer = StripeCustomer.get_or_create(email=self.request.user.email,
token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(self.get_context_data(form=form))
# If booking is not free, make the stripe charge
if not is_free:
# Make stripe charge to a customer
stripe_utils = StripeUtils()
charge_response = stripe_utils.make_charge(amount=final_price,
customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
return render(self.request, self.template_name, context)
charge = charge_response.get('response_object')
# Create Billing Address for Membership Order
billing_address = form.save()
# Create Billing Address for User if he does not have one
if not customer.user.billing_addresses.count():
data.update({
'user': customer.user.id
})
billing_address_user_form = UserBillingAddressForm(data)
billing_address_user_form.is_valid()
billing_address_user_form.save()
# Create Booking
booking_data = {
'start_date': start_date,
'end_date': end_date,
'start_date': start_date,
'free_days': free_days,
'price': normal_price,
'final_price': final_price,
}
booking = Booking.create(booking_data)
# Create Booking order
order_data = {
'booking': booking,
'customer': customer,
'billing_address': billing_address,
'stripe_charge': charge,
'amount': final_price,
'original_price': normal_price,
'special_month_price': BookingPrice.objects.last().special_month_price,
}
order = BookingOrder.create(order_data)
context = {
'booking': booking,
'order': order,
'base_url': "{0}://{1}".format(self.request.scheme, self.request.get_host())
}
email_data = {
'subject': 'Your booking order has been placed',
'to': self.request.user.email,
'context': context,
'template_name': 'booking_order_email',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(self.get_success_url(order.id))
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
# Get billing address data
billing_address_data = form.cleaned_data
context = self.get_context_data()
template = request.session.get('template')
specs = request.session.get('specs')
vm_template_id = template.get('id', 1)
final_price = specs.get('price')
token = form.cleaned_data.get('token')
owner = self.request.user
# Get or create stripe customer
customer = StripeCustomer.get_or_create(email=owner.email,
token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(
self.get_context_data(form=form))
# Create Billing Address
billing_address = form.save()
# Make stripe charge to a customer
stripe_utils = StripeUtils()
charge_response = stripe_utils.make_charge(
amount=final_price, customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
return render(request, self.template_name, context)
charge = charge_response.get('response_object')
# Create OpenNebulaManager
manager = OpenNebulaManager(email=owner.email,
password=owner.password)
# Get user ssh key
if not UserHostingKey.objects.filter(
user=self.request.user).exists():
context.update({'sshError': 'error', 'form': form})
return render(request, self.template_name, context)
# For now just get first one
user_key = UserHostingKey.objects.filter(
user=self.request.user).first()
# Create a vm using logged user
vm_id = manager.create_vm(
template_id=vm_template_id,
# XXX: Confi
specs=specs,
ssh_key=user_key.public_key,
)
# Create a Hosting Order
order = HostingOrder.create(price=final_price,
vm_id=vm_id,
customer=customer,
billing_address=billing_address)
# Create a Hosting Bill
bill = HostingBill.create(customer=customer,
billing_address=billing_address)
# Create Billing Address for User if he does not have one
if not customer.user.billing_addresses.count():
billing_address_data.update({'user': customer.user.id})
billing_address_user_form = UserBillingAddressForm(
billing_address_data)
billing_address_user_form.is_valid()
billing_address_user_form.save()
# Associate an order with a stripe payment
order.set_stripe_charge(charge)
# If the Stripe payment was successed, set order status approved
order.set_approved()
vm = VirtualMachineSerializer(manager.get_vm(vm_id)).data
# Send notification to ungleich as soon as VM has been booked
context = {
'vm': vm,
'order': order,
'base_url': "{0}://{1}".format(request.scheme,
request.get_host())
}
email_data = {
'subject': 'New VM request',
'to': request.user.email,
'context': context,
'template_name': 'new_booked_vm',
'template_path': 'hosting/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(
reverse('hosting:orders', kwargs={'pk': order.id}))
else:
return self.form_invalid(form)
def form_valid(self, form):
data = form.cleaned_data
context = self.get_context_data()
token = data.get('token')
start_date = data.get('start_date')
end_date = data.get('end_date')
is_free = context.get('is_free')
normal_price, final_price, free_days = Booking.\
booking_price(self.request.user, start_date, end_date)
charge = None
# if not credit_card_needed:
# Get or create stripe customer
customer = StripeCustomer.get_or_create(email=self.request.user.email,
token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(self.get_context_data(form=form))
# If booking is not free, make the stripe charge
if not is_free:
# Make stripe charge to a customer
stripe_utils = StripeUtils()
charge_response = stripe_utils.make_charge(
amount=final_price, customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
return render(self.request, self.template_name, context)
charge = charge_response.get('response_object')
# Create Billing Address for Membership Order
billing_address = form.save()
# Create Billing Address for User if he does not have one
if not customer.user.billing_addresses.count():
data.update({'user': customer.user.id})
billing_address_user_form = UserBillingAddressForm(data)
billing_address_user_form.is_valid()
billing_address_user_form.save()
# Create Booking
booking_data = {
'start_date': start_date,
'end_date': end_date,
'start_date': start_date,
'free_days': free_days,
'price': normal_price,
'final_price': final_price,
}
booking = Booking.create(booking_data)
# Create Booking order
order_data = {
'booking': booking,
'customer': customer,
'billing_address': billing_address,
'stripe_charge': charge,
'amount': final_price,
'original_price': normal_price,
'special_month_price':
BookingPrice.objects.last().special_month_price,
}
order = BookingOrder.create(order_data)
context = {
'booking':
booking,
'order':
order,
'base_url':
"{0}://{1}".format(self.request.scheme, self.request.get_host())
}
email_data = {
'subject': 'Your booking order has been placed',
'to': self.request.user.email,
'context': context,
'template_name': 'booking_order_email',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(self.get_success_url(order.id))
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
context = self.get_context_data()
specifications = request.session.get('vm_specs')
vm_type = specifications.get('hosting_company')
vm = VirtualMachineType.objects.get(hosting_company=vm_type)
final_price = vm.calculate_price(specifications)
plan_data = {
'vm_type': vm,
'cores': specifications.get('cores'),
'memory': specifications.get('memory'),
'disk_size': specifications.get('disk_size'),
'configuration': specifications.get('configuration'),
'price': final_price
}
token = form.cleaned_data.get('token')
# Get or create stripe customer
customer = StripeCustomer.get_or_create(email=self.request.user.email,
token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(self.get_context_data(form=form))
# Create Virtual Machine Plan
plan = VirtualMachinePlan.create(plan_data, request.user)
# Create Billing Address
billing_address = form.save()
# Create a Hosting Order
order = HostingOrder.create(vm_plan=plan, customer=customer,
billing_address=billing_address)
# Make stripe charge to a customer
stripe_utils = StripeUtils()
charge_response = stripe_utils.make_charge(amount=final_price,
customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
return render(request, self.template_name, context)
charge = charge_response.get('response_object')
# Associate an order with a stripe payment
order.set_stripe_charge(charge)
# If the Stripe payment was successed, set order status approved
order.set_approved()
# Send notification to ungleich as soon as VM has been booked
context = {
'vm': plan,
'order': order,
'base_url': "{0}://{1}".format(request.scheme, request.get_host())
}
email_data = {
'subject': 'New VM request',
'to': request.user.email,
'context': context,
'template_name': 'new_booked_vm',
'template_path': 'hosting/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(reverse('hosting:orders', kwargs={'pk': order.id}))
else:
return self.form_invalid(form)
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
data = form.cleaned_data
context = self.get_context_data()
token = data.get('token')
membership_type = data.get('membership_type')
# Get or create stripe customer
customer = StripeCustomer.get_or_create(
email=self.request.user.email, token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(
self.get_context_data(form=form))
# Make stripe charge to a customer
stripe_utils = StripeUtils()
charge_response = stripe_utils.make_charge(
amount=membership_type.first_month_price,
customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
email_to_admin_data = {
'subject':
"Could not create charge for Digital Glarus "
"user: {user}".format(user=self.request.user.email),
'from_email':
'*****@*****.**',
'to': ['*****@*****.**'],
'body':
"\n".join([
"%s=%s" % (k, v) for (k, v) in charge_response.items()
]),
}
send_plain_email_task.delay(email_to_admin_data)
return render(request, self.template_name, context)
# Subscribe the customer to dg plan from the next month onwards
stripe_plan = stripe_utils.get_or_create_stripe_plan(
amount=membership_type.price,
name='Digital Glarus {sub_type_name} Subscription'.format(
sub_type_name=membership_type.name),
stripe_plan_id='dg-{sub_type_name}'.format(
sub_type_name=membership_type.name))
subscription_result = stripe_utils.subscribe_customer_to_plan(
customer.stripe_id,
[{
"plan": stripe_plan.get('response_object').stripe_plan_id
}],
trial_end=membership_type.next_month_in_sec_since_epoch)
stripe_subscription_obj = subscription_result.get(
'response_object')
# Check if call to create subscription was ok
if (stripe_subscription_obj is None
or (stripe_subscription_obj.status != 'active'
and stripe_subscription_obj.status != 'trialing')):
context.update({
'paymentError': subscription_result.get('error'),
'form': form
})
email_to_admin_data = {
'subject':
"Could not create Stripe subscription for "
"Digital Glarus user: {user}".format(
user=self.request.user.email),
'from_email':
'*****@*****.**',
'to': ['*****@*****.**'],
'body':
"\n".join([
"%s=%s" % (k, v)
for (k, v) in subscription_result.items()
]),
}
send_plain_email_task.delay(email_to_admin_data)
return render(request, self.template_name, context)
charge = charge_response.get('response_object')
if 'source' in charge:
cardholder_name = charge['source']['name']
else:
cardholder_name = customer.user.name
# Create Billing Address
billing_address = form.save()
# Create Billing Address for User if he does not have one
if not customer.user.billing_addresses.count():
data.update({
'user': customer.user.id,
'cardholder_name': cardholder_name
})
billing_address_user_form = UserBillingAddressForm(data)
billing_address_user_form.is_valid()
billing_address_user_form.save()
# Get membership dates
membership_start_date, membership_end_date = membership_type.first_month_range
# Create or update membership plan
membership_data = {
'type': membership_type,
'active': True,
'start_date': membership_start_date,
'end_date': membership_end_date
}
membership = Membership.activate_or_crete(membership_data,
self.request.user)
# Create membership order
order_data = {
'membership': membership,
'customer': customer,
'billing_address': billing_address,
'stripe_charge': charge,
'stripe_subscription_id': stripe_subscription_obj.id,
'amount': membership_type.first_month_price,
'start_date': membership_start_date,
'end_date': membership_end_date
}
membership_order = MembershipOrder.create(order_data)
request.session.update({
'membership_price':
membership.type.first_month_price,
'membership_dates':
membership.type.first_month_formated_range
})
email_to_admin_data = {
'subject':
"New Digital Glarus subscription: {user}".format(
user=self.request.user.email),
'from_email':
'*****@*****.**',
'to': ['*****@*****.**'],
'body':
"\n".join(["%s=%s" % (k, v) for (k, v) in order_data.items()]),
}
send_plain_email_task.delay(email_to_admin_data)
context = {
'membership': membership,
'order': membership_order,
'membership_start_date': membership_start_date,
'membership_end_date': membership_end_date,
'base_url': "{0}://{1}".format(request.scheme,
request.get_host())
}
email_data = {
'subject': 'Your membership has been charged',
'to': request.user.email,
'context': context,
'template_name': 'membership_charge',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(
reverse('digitalglarus:membership_activated'))
else:
return self.form_invalid(form)
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
data = form.cleaned_data
context = self.get_context_data()
token = data.get('token')
membership_type = data.get('membership_type')
# Get or create stripe customer
customer = StripeCustomer.get_or_create(
email=self.request.user.email, token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(
self.get_context_data(form=form))
# Make stripe charge to a customer
stripe_utils = StripeUtils()
charge_response = stripe_utils.make_charge(
amount=membership_type.first_month_price,
customer=customer.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
context.update({
'paymentError': charge_response.get('error'),
'form': form
})
return render(request, self.template_name, context)
charge = charge_response.get('response_object')
# Create Billing Address
billing_address = form.save()
# Create Billing Address for User if he does not have one
if not customer.user.billing_addresses.count():
data.update({'user': customer.user.id})
billing_address_user_form = UserBillingAddressForm(data)
billing_address_user_form.is_valid()
billing_address_user_form.save()
# Get membership dates
membership_start_date, membership_end_date = membership_type.first_month_range
# Create or update membership plan
membership_data = {
'type': membership_type,
'active': True,
'start_date': membership_start_date,
'end_date': membership_end_date
}
membership = Membership.activate_or_crete(membership_data,
self.request.user)
# Create membership order
order_data = {
'membership': membership,
'customer': customer,
'billing_address': billing_address,
'stripe_charge': charge,
'amount': membership_type.first_month_price,
'start_date': membership_start_date,
'end_date': membership_end_date
}
membership_order = MembershipOrder.create(order_data)
request.session.update({
'membership_price':
membership.type.first_month_price,
'membership_dates':
membership.type.first_month_formated_range
})
context = {
'membership': membership,
'order': membership_order,
'membership_start_date': membership_start_date,
'membership_end_date': membership_end_date,
'base_url': "{0}://{1}".format(request.scheme,
request.get_host())
}
email_data = {
'subject': 'Your membership has been charged',
'to': request.user.email,
'context': context,
'template_name': 'membership_charge',
'template_path': 'digitalglarus/emails/'
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(
reverse('digitalglarus:membership_activated'))
else:
return self.form_invalid(form)
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
context = self.get_context_data()
token = form.cleaned_data.get("token")
donation_amount = form.cleaned_data.get("donation_amount")
# Get or create stripe customer
customer = StripeCustomer.get_or_create(email=self.request.user.email, token=token)
if not customer:
form.add_error("__all__", "Invalid credit card")
return self.render_to_response(self.get_context_data(form=form))
# Create Billing Address
billing_address = form.save()
# Make stripe charge to a customer
stripe_utils = StripeUtils()
stripe_utils.CURRENCY = "usd"
charge_response = stripe_utils.make_charge(amount=donation_amount, customer=customer.stripe_id)
charge = charge_response.get("response_object")
# Check if the payment was approved
if not charge:
context.update({"paymentError": charge_response.get("error"), "form": form})
return render(request, self.template_name, context)
# Create a donation
charge = charge_response.get("response_object")
donation_data = request.POST.copy()
donation_data.update(
{
"cc_brand": charge.source.brand,
"stripe_charge_id": charge.id,
"last4": charge.source.last4,
"billing_address": billing_address.id,
"donator": customer.id,
"donation": donation_amount,
}
)
donation_form = DonationForm(donation_data)
if donation_form.is_valid():
# reactivate donation status
donation = donation_form.save()
try:
donator_status = DonatorStatus.objects.get(user=self.request.user)
donator_status.set_active()
except DonatorStatus.DoesNotExist:
pass
donation = donation_form.save()
context = {"donation": donation, "base_url": "{0}://{1}".format(request.scheme, request.get_host())}
email_data = {
"subject": "Your donation have been charged",
"to": request.user.email,
"context": context,
"template_name": "donation_charge",
"template_path": "nosystemd/emails/",
}
email = BaseEmail(**email_data)
email.send()
return HttpResponseRedirect(reverse("nosystemd:donations", kwargs={"pk": donation.id}))
else:
self.form_invalid(donation_form)
else:
return self.form_invalid(form)
def handle(self, *args, **options):
donators = DonatorStatus.objects.filter(status=DonatorStatus.ACTIVE)
current_month = datetime.now().month
current_year = datetime.now().year
print("--------- STARTING DONATIONS SCRIPT ---------")
print("Donations date: %s-%s" % (current_month, current_year))
for donator_status in donators:
donator = donator_status.user.stripecustomer
try:
Donation.objects.get(created_at__month=current_month,
created_at__year=current_year,
donator=donator)
except Donation.DoesNotExist:
try:
# Get donator last donation amount
last_donation = Donation.objects.filter(
donator=donator).last()
donation_amount = last_donation.donation
# Make stripe charge to a customer
stripe_utils = StripeUtils()
stripe_utils.CURRENCY = self.CURRENCY
charge_response = stripe_utils.make_charge(
amount=donation_amount, customer=donator.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
# There is an error trying to creating the stripe charge
context = {
'paymentError': charge_response.get('error'),
}
print("--------- STRIPE PAYMENT ERROR ---------")
print(context)
print("-------------------------")
continue
# Create a donation
charge = charge_response.get('response_object')
donation_data = {
'cc_brand': charge.source.brand,
'stripe_charge_id': charge.id,
'last4': charge.source.last4,
'billing_address': last_donation.billing_address.id,
'donator': donator.id,
'donation': donation_amount
}
donation_form = DonationForm(donation_data)
if donation_form.is_valid():
donation = donation_form.save()
context = {
'donation':
donation,
'base_url':
"{0}://{1}".format('https',
'dynamicweb.ungleich.ch')
}
email_data = {
'subject': 'Your donation have been charged',
'to': donation.donator.user.email,
'context': context,
'template_name': 'donation_charge',
'template_path': 'nosystemd/emails/'
}
email = BaseEmail(**email_data)
email.send()
print(
"--------- PAYMENT DONATION SUCCESSFULL ---------")
print("Donator: %s" % donation.donator.user.email)
print("Amount: %s %s" %
(donation.donation, self.CURRENCY))
print(
"-----------------------------------------------")
except Exception as e:
print("--------- ERROR ---------")
print(e)
print("-------------------------")
continue
def handle(self, *args, **options):
donators = DonatorStatus.objects.filter(status=DonatorStatus.ACTIVE)
current_month = datetime.now().month
current_year = datetime.now().year
print("--------- STARTING DONATIONS SCRIPT ---------")
print("Donations date: %s-%s" % (current_month, current_year))
for donator_status in donators:
donator = donator_status.user.stripecustomer
try:
Donation.objects.get(created_at__month=current_month,
created_at__year=current_year,
donator=donator)
except Donation.DoesNotExist:
try:
# Get donator last donation amount
last_donation = Donation.objects.filter(donator=donator).last()
donation_amount = last_donation.donation
# Make stripe charge to a customer
stripe_utils = StripeUtils()
stripe_utils.CURRENCY = self.CURRENCY
charge_response = stripe_utils.make_charge(amount=donation_amount,
customer=donator.stripe_id)
charge = charge_response.get('response_object')
# Check if the payment was approved
if not charge:
# There is an error trying to creating the stripe charge
context = {
'paymentError': charge_response.get('error'),
}
print("--------- STRIPE PAYMENT ERROR ---------")
print(context)
print("-------------------------")
continue
# Create a donation
charge = charge_response.get('response_object')
donation_data = {
'cc_brand': charge.source.brand,
'stripe_charge_id': charge.id,
'last4': charge.source.last4,
'billing_address': last_donation.billing_address.id,
'donator': donator.id,
'donation': donation_amount
}
donation_form = DonationForm(donation_data)
if donation_form.is_valid():
donation = donation_form.save()
context = {
'donation': donation,
'base_url': "{0}://{1}".format('https', 'dynamicweb.ungleich.ch')
}
email_data = {
'subject': 'Your donation have been charged',
'to': donation.donator.user.email,
'context': context,
'template_name': 'donation_charge',
'template_path': 'nosystemd/emails/'
}
email = BaseEmail(**email_data)
email.send()
print("--------- PAYMENT DONATION SUCCESSFULL ---------")
print("Donator: %s" % donation.donator.user.email)
print("Amount: %s %s" % (donation.donation, self.CURRENCY))
print("-----------------------------------------------")
except Exception as e:
print("--------- ERROR ---------")
print(e)
print("-------------------------")
continue
