def create_tenant(email, subscription_id, request):
res = 'Unknown issue'
req_data = request.POST
sub_domain = req_data['sub_domain']
company = req_data['company']
password = req_data['password']
plan_id = req_data['plan_id']
public_tenant = request.tenant
try:
tenant_model = get_tenant_model()
with transaction.atomic():
if not tenant_model.objects.filter(schema_name=sub_domain):
schema_owner = User.objects.create(username='******' +
sub_domain + '.com')
schema_owner.save()
domain_name = sub_domain + '.' + server_domain
company = tenant_model(schema_name=sub_domain,
name=company,
owner_id=schema_owner.id,
domain_name=domain_name)
company.subscription_id = subscription_id
company.plan_id = plan_id
company.save()
create_public_user(company, email, password)
request.tenant = company
connection.set_tenant(request.tenant, False)
ContentType.objects.clear_cache()
try:
tenant_user = AuthUser(username=email,
is_superuser=True,
is_staff=True,
is_active=True)
tenant_user.on_schema_creating = True
tenant_user.email = email
tenant_user.save()
tenant_user.set_password(password)
tenant_user.save()
print('\n\n\n Success while creating user\n\n\n')
except:
print('\n\n\n Error while creating user\n\n\n')
res = 'done'
else:
res = 'Client with name "' + sub_domain + '" already exists'
except:
res = ws_methods.produce_exception()
request.tenant = public_tenant
connection.set_tenant(request.tenant, False)
ContentType.objects.clear_cache()
return res
def get_context_data(self, **kwargs):
res = 'Unknown status'
customer_id = self.request.GET['id']
context = {}
try:
TenantModel = get_tenant_model()
TenantModel.objects.get(pk=customer_id).delete_tenant()
context = {'list': get_customer_list(self.request.user)}
except:
res = ws_methods.produce_exception()
context = {
'error': res,
'list': get_customer_list(self.request.user)
}
context['port'] = SERVER_PORT_STR
return context
def post_subscription(request, payment_token=None):
template_name = 'customers/subscription/form.html'
req_url_postfix = ''
payment_promise_obj = None
try:
req_data = request.POST
if not payment_token:
res = check_schema_name(req_data['sub_domain'])
if res != 'ok':
context = get_response(req_data['plan_id'], res, payment_token)
return render(request, template_name, context)
obj = PaymentInProgress(company=req_data['sub_domain'],
plan_id=req_data['plan_id'])
payment_token = uuid.uuid4().hex[:20]
obj.amount = req_data['amount']
obj.token = payment_token
obj.save()
else:
res = check_schema_name(req_data['sub_domain'], payment_token)
if res != 'ok':
context = get_response(req_data['plan_id'], res, payment_token)
return render(request, template_name, context)
payment_promise_obj = obj
req_url_postfix += '/' + req_data['plan_id'] + '/' + payment_token
res = make_payment(req_data, payment_promise_obj)
if res != 'done':
context = get_response(req_data['plan_id'], res, payment_token)
return render(request, template_name, context)
else:
payment_promise = payment_promise_obj.__dict__
req_url_postfix += '/' + payment_token
with transaction.atomic():
subscription_id = create_related_entries(
req_data, payment_promise)
print('creating tenant')
res = create_tenant(payment_promise['email'], subscription_id,
request)
return redirect('/')
except:
res = produce_exception()
context = get_response(req_data['plan_id'], res, payment_token)
return render(request, template_name, context)
def get_context_data(self, **kwargs):
context = {}
try:
tenant_name = self.request.POST.get('name')
if not tenant_name:
tenant_name = self.request.GET.get('name')
if not tenant_name:
context['error'] = 'No name provided'
return context
res = create_tenant(tenant_name, self.request)
if res != 'done':
context['error'] = res
else:
context['message'] = 'Successfully created ' + tenant_name
except:
context['error'] = ws_methods.produce_exception()
context['list'] = get_customer_list(self.request.user)
context['port'] = SERVER_PORT_STR
return context
def create_tenant(t_name, request):
res = 'Unknown issue'
try:
tenant_model = get_tenant_model()
with transaction.atomic():
if not tenant_model.objects.filter(schema_name=t_name):
owner = User.objects.create(username='******' + t_name,
is_active=True,
is_staff=True)
owner.set_password('123')
owner.save()
domain_name = t_name + '.' + server_domain
company = tenant_model(schema_name=t_name,
name=t_name,
owner_id=owner.id,
domain_name=domain_name)
company.save()
company.users.add(owner)
request.tenant = company
connection.set_tenant(request.tenant, False)
ContentType.objects.clear_cache()
owner = User.objects.create(username='******' + t_name,
is_superuser=True,
is_staff=True,
is_active=True)
owner.set_password('123')
owner.save()
company = tenant_model.objects.get(schema_name='public')
request.tenant = company
connection.set_tenant(request.tenant, False)
ContentType.objects.clear_cache()
res = 'done'
else:
res = 'Client with id' + t_name + ' already exists'
except:
res = ws_methods.produce_exception()
return res
def save(self, *args, **kwargs):
try:
file_changed = False
creating = False
if not self.pk:
file_changed = True
creating = True
self.new_file = True
try:
if self.file_ptr and self.file_ptr.attachment and self.file_ptr.attachment.url:
file_changed = False
creating = False
self.new_file = False
self.pending_tasks = 0
except:
pass
if self.pending_tasks == 3:
if not creating:
if self.attachment != File.objects.get(pk=self.id).attachment:
self.pending_tasks = 2
file_changed = True
else:
self.pending_tasks = 0
elif not self.file_name:
raise Exception('Invalid file name')
file_data = None
if self.cloud_url and (creating or self.file_type == 'esign'):
file_changed = True
cloud_url = self.cloud_url
self.cloud_url = ''
headers = {}
if self.access_token:
headers = {'Authorization': 'Bearer ' + self.access_token}
self.file_name = re.sub('[^0-9a-zA-Z\.]+', '_', self.file_name)
try:
request = urllib.request.Request(cloud_url, headers=headers)
url_opened = None
try:
url_opened = urlopen(request)
except Exception as ex:
try:
my_bytes_value = ws_methods.http(cloud_url, headers)
my_json = ws_methods.bytes_to_json(my_bytes_value)
my_json = my_json['error']
raise Exception(my_json)
except:
raise
file_content = url_opened.read()
file_temp = NamedTemporaryFile(delete=True)
file_temp.write(file_content)
file_temp.flush()
file_data = file_temp
except urllib.error.HTTPError as e:
msg = str(e.code) + e.reason
raise Exception(msg)
if 'https://www.googleapis.com' in cloud_url:
self.access_token = 'Google'
elif 'files.1drv.com' in cloud_url:
self.access_token = 'Onedrive'
elif 'https://dl.dropboxusercontent.com' in cloud_url:
self.access_token = 'Dropbox'
else:
self.access_token = 'Unknown Cloud'
self.pending_tasks = 2
self.attachment.save(self.file_name, file_data)
return
elif file_changed:
if self.access_token != 'Messenger':
self.access_token = 'Local'
if file_data is None:
if not self.attachment:
raise ValidationError('No file provided')
elif file_changed:
self.pending_tasks = 2
if file_changed:
arr = os.path.splitext(self.attachment.url)
self.extention = arr[1]
super(File, self).save(*args, **kwargs)
if self.pending_tasks == 2:
if self.file_type != 'message':
self.pending_tasks = 1
self.get_pdf()
return
if self.pending_tasks == 1:
if self.html:
self.content = self.html
else:
if not self.pdf_doc:
self.file_error = 'File conversion failed 1'
raise
if not self.pdf_doc.url:
self.file_error = 'File conversion failed 2'
raise
try:
self.content = text_extractor(self.pdf_doc)
except:
self.file_error = 'unable to extract file content '
ws_methods.produce_exception(self.file_error + ' '+str(self.pk) + ' '+self.pdf_doc.url)
self.pending_tasks = 0
self.save()
pass
except:
try:
ws_methods.produce_exception(self.file_error)
if self.new_file and self.pk:
self.delete()
except:
pass
res = ws_methods.get_error_message()
raise Exception(res)