def page_category_create(request):
request_data = json.loads(request.body)
validator = Validator()
form = PageCategoryForm(request_data)
if not form.is_valid():
validator.errors.errors = get_form_errors(form, {})
market_id = request_data.get('market_id', None)
if market_id:
market = Market.objects.filter(pk=market_id).first()
if not market:
return JsonResponse({'general': 'Market not found.'}, status=500)
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
is_active = to_boolean(request_data['is_active'])
role_id = request_data.get('role_id')
category = PageCategory()
category.is_active = is_active
category.market = market
category.name = request_data['name']
category.role_id = role_id
category.save()
return JsonResponse({}, status=200)
def item_update(request):
pk = request.POST.get('id', 0)
validator = Validator()
item_form = ItemForm(request.POST)
if not item_form.is_valid():
validator.errors.errors = get_form_errors(item_form, {})
request_file = request.FILES.get('file', None)
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
item = Item.objects.filter(pk=pk).first()
if not item:
return JsonResponse({}, status=400)
if request_file:
item.attachment = request_file
if 'description' in request.POST:
item.description = item_form.cleaned_data['description']
if 'amount' in request.POST:
item.amount = item_form.cleaned_data['amount']
if 'type_id' in request.POST:
item.type_id = item_form.cleaned_data['type_id']
if 'currency_id' in request.POST:
item.currency_id = item_form.cleaned_data['currency_id']
if item.currency_id == 6:
item.exchange_rate = Decimal('1.00')
item.total = item.amount
if 'exchange_rate' in request.POST and item.currency_id != 6:
item.exchange_rate = Decimal(request.POST['exchange_rate'])
if item.amount and item.exchange_rate:
item.total = (item.amount * item.exchange_rate).quantize(
Decimal("0.01"), decimal.ROUND_HALF_DOWN)
if 'date' in request.POST and item_form.cleaned_data['date']:
item.date = item_form.cleaned_data['date']
item.save()
response = {'id': item.id}
item = Item.objects.filter(pk=pk).first()
if request_file:
response['url'] = item.attachment.url
return JsonResponse(response)
def city_edit(request):
request_data = json.loads(request.body)
validator = Validator()
form = CityForm(request_data)
if not form.is_valid():
validator.errors.errors = get_form_errors(form, {})
country_id = request_data.get('country_id', None)
if country_id:
country = Country.objects.filter(pk=country_id).first()
if not country:
return JsonResponse({'general': 'Country not found.'}, status=500)
state_id = request_data.get('state_id', None)
if state_id:
state = State.objects.filter(pk=state_id).first()
if not state:
return JsonResponse({'general': 'State not found.'}, status=500)
else:
if state.country_id != country_id:
validator.errors.add(
'state_id', 'This state do not belong to the country.')
city_id = request_data.get('id', None)
if not city_id:
return JsonResponse({'general': 'City not found.'}, status=500)
city = City.objects.filter(pk=city_id).first()
if not city:
return JsonResponse({'general': 'City not found.'}, status=500)
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
is_active = to_boolean(request_data['is_active'])
city.name = request_data['name']
city.state = state
city.is_active = is_active
city.save()
return JsonResponse({}, status=200)
def reimbursements_review(request):
request_data = json.loads(request.body)
pk = request_data.get('id', 0)
reimbursement = Reimbursement.objects.prefetch_related('items').filter(
pk=pk).first()
if not reimbursement:
return JsonResponse({}, status=400)
items = reimbursement.items.all()
validator = Validator()
reimbursement_form = ReimbursementStrictForm({
'account_id':
reimbursement.account_id,
'location':
reimbursement.location,
'spending_justification':
reimbursement.spending_justification,
'date_from':
reimbursement.date_from,
'date_to':
reimbursement.date_to,
})
if not reimbursement_form.is_valid():
validator.errors.errors = get_form_errors(reimbursement_form, {})
if len(items) == 0:
validator.errors.add('no_field_errors', 'Must be at least one item')
else:
item_errors = []
for item in items:
item_form = ItemStrictForm(item.as_dict())
errors = {'id': item.pk}
if not item_form.is_valid():
errors = get_form_errors(item_form, errors)
if not item.attachment:
errors['file'] = ['File required.']
if len(errors) > 1:
item_errors.append(errors)
if len(item_errors) > 0:
validator.errors.errors['items'] = item_errors
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
main_currency = Currency.objects.filter(main=True).first()
for item in reimbursement.items.all():
if item.currency != main_currency:
exchange = ExchangeRate.objects.filter(
start_date__lte=item.date,
end_date__gte=item.date,
target=item.currency).first()
exchange_rate = exchange.rate if exchange else Decimal('0.00')
item.exchange_rate = exchange_rate
item.total = (item.amount * exchange_rate).quantize(
Decimal("0.01"), decimal.ROUND_HALF_DOWN)
else:
item.exchange_rate = Decimal('1.00')
item.total = item.amount
item.save()
reimbursement.reject_reason = ''
reimbursement.date_sent = dt.now()
reimbursement.status = 3
reimbursement.save()
notification = create_notification_from(reimbursement)
notification.creator = request.user
notification.description = u'New reimbursement to review'
notification.details = u'New reimbursement from {}'.format(
request.user.person.get_full_name())
notification.type = 12
notification.save()
user_ids = get_user_model().objects.filter(
Q(groups__name="corporate admin")
| Q(groups__name="finances")).values_list('id', flat=True)
bulk_receiver_creation(notification, user_ids)
return JsonResponse({})
def reimbursements_status_update(request):
role = get_role(request.user)
if role not in ['corporate', 'finance']:
return JsonResponse({}, status=400)
request_data = json.loads(request.body)
pk = request_data.get('id', 0)
need_exchange = to_boolean(request_data.get('need_exchange', '0'))
reimbursement = Reimbursement.objects.prefetch_related('items').filter(
pk=pk).first()
if not reimbursement:
return JsonResponse({}, status=400)
if ('status' not in request_data
or (request_data['status'] == 2 and 'reason' not in request_data)
or request_data['status'] not in [1, 2]):
return JsonResponse({}, status=400)
if request_data['status'] == 1 and need_exchange:
validator = Validator()
item_errors = []
for item in reimbursement.items.all():
errors = {'id': item.pk}
if item.exchange_rate <= Decimal(0):
errors['exchange_rate'] = ['Must be greater than zero.']
if len(errors) > 1:
item_errors.append(errors)
if len(item_errors) > 0:
validator.errors.errors['items'] = item_errors
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
notification = create_notification_from(reimbursement)
notification.creator = request.user
if request_data['status'] == 2:
notification.type = 13
notification.description = u'Reimbursement rejected'
notification.details = u'Rejected reason: {}'.format(
request_data['reason'])
reimbursement.status = 2
reimbursement.reject_reason = request_data['reason']
else:
notification.type = 14
notification.description = u'Reimbursement approved'
notification.details = u'Reimbursement has been approved'
reimbursement.status = 1
reimbursement.date_approved = dt.now()
reimbursement.save()
notification.save()
notification_receiver = NotificationReceiver()
notification_receiver.receiver_id = reimbursement.creator_id
notification_receiver.notification = notification
notification_receiver.save()
return JsonResponse({})
def reimbursements_update(request):
deposit_account = None
request_data = json.loads(request.body)
new_items = request_data.get('new_items', [])
remove_items = request_data.get('remove_items', [])
update_items = request_data.get('update_items', [])
reimbursement = Reimbursement.objects.prefetch_related(
'account__owner').filter(pk=request_data.get('id', 0)).first()
if not reimbursement:
return JsonResponse({}, status=400)
if request_data['account_id']:
deposit_account = DepositAccount.objects.select_related(
'owner__role').filter(pk=request_data['account_id']).first()
if not deposit_account:
return JsonResponse({}, status=400)
validator = Validator()
reimbursement_form = ReimbursementForm(request_data)
if not reimbursement_form.is_valid():
validator.errors.errors = get_form_errors(reimbursement_form, {})
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
reimbursement.creator = request.user
reimbursement.location = request_data['location']
reimbursement.description = request_data['description']
reimbursement.spending_justification = request_data[
'spending_justification']
if deposit_account:
reimbursement.account_id = deposit_account.id
reimbursement.account_number = deposit_account.account_number
reimbursement.swift = deposit_account.swift
reimbursement.bank = deposit_account.bank
reimbursement.clabe = deposit_account.clabe
reimbursement.position = deposit_account.owner.role.name
else:
reimbursement.account_id = None
reimbursement.account_number = ''
reimbursement.swift = ''
reimbursement.bank = ''
reimbursement.clabe = ''
reimbursement.position = ''
if request_data['date_from']:
reimbursement.date_from = request_data['date_from']
if request_data['date_to']:
reimbursement.date_to = request_data['date_to']
reimbursement.save()
items = []
for new_item in new_items:
item = Item()
item.reimbursement = reimbursement
if new_item['date']:
item.date = new_item['date']
item.type_id = new_item['type_id']
item.description = new_item['description']
item.amount = new_item['amount']
item.currency_id = new_item['currency_id']
item.save()
if 'uid' in new_item:
items.append({'id': item.id, 'uid': new_item['uid']})
# TODO we can make this fastest if ask for all instead for every one
for update_item in update_items:
item = Item.objects.filter(pk=update_item['id'],
reimbursement_id=reimbursement.pk).first()
if not item:
continue
if update_item['date']:
item.date = update_item['date']
item.type_id = update_item['type_id']
item.description = update_item['description']
item.amount = update_item['amount']
item.currency_id = update_item['currency_id']
item.save()
if len(remove_items) > 0:
Item.objects.filter(pk__in=remove_items,
reimbursement_id=reimbursement.pk).delete()
response = {}
if len(items) > 0:
response['items'] = items
return JsonResponse(response)
def page_category_edit(request):
request_data = json.loads(request.body)
validator = Validator()
form = PageCategoryEditForm(request_data)
role_id = request_data.get('role_id', None)
if not form.is_valid():
validator.errors.errors = get_form_errors(form, {})
page_category_id = request_data.get('id', None)
if page_category_id:
page_category = PageCategory.objects.filter(
pk=page_category_id).first()
if not page_category:
return JsonResponse({'general': 'Page Category not found.'},
status=500)
market_id = request_data.get('market_id', None)
if market_id:
market = Market.objects.filter(pk=market_id).first()
if not market:
return JsonResponse({'general': 'Market not found.'}, status=500)
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
to_create = request_data.get('to_create', [])
to_remove = request_data.get('to_remove', [])
to_edit = request_data.get('to_edit', [])
for e_page in to_edit:
id_page = e_page['id']
name_page = e_page['name']
if name_page:
page = Page.objects.filter(pk=id_page).update(title=name_page)
for r_page in to_create:
page = Page()
page.title = r_page['name']
page.type = r_page['type']
if page.type == 2:
for icons in r_page['icons']:
icons_id = icons['id']
if page.type == 3 or page.type == 4:
page.view = r_page['view']
if page.type == 5:
page.view_video = r_page['view_video']
page.category = page_category
page.save()
if r_page['type'] == 2:
for icons in r_page['icons']:
icons_id = icons['id']
attachment_page = AttachmentCategory.objects.get(pk=icons_id)
page.attachment_category.add(attachment_page)
Page.objects.filter(category_id=page_category_id,
id__in=to_remove).delete()
page_category.role_id = role_id
page_category.is_active = to_boolean(request_data['is_active'])
page_category.market = market
page_category.name = request_data['name']
page_category.save()
return JsonResponse({}, status=200)
def api_edit_user(request):
request_data = json.loads(request.POST['data'])
market = None
supervisor = None
markets = []
programs_base = []
validator = Validator()
user_id = request_data.get('id', '')
common_name = request_data.get('common_name', '')
first_name = request_data.get('first_name', '')
last_name = request_data.get('last_name', '')
email = request_data.get('email', '')
username = request_data.get('username', '')
password = request_data.get('password', '')
code = request_data.get('code', '')
title = request_data.get('title', '')
supervisor_id = request_data.get('supervisor_id', 0)
market_id = request_data.get('market_id', 0)
commission_category_id = request_data.get('commission_category', None)
commission_start = request_data.get('commission_start', 0)
want_account = request_data.get('want_account', False)
remove_account = request_data.get('remove_account', False)
is_active = to_boolean(request_data.get('is_active', '0'))
markets_mtm = request_data.get('markets_mtm', [])
programs_mtm = request_data.get('programs_mtm', [])
profile_picture = request.FILES.get('profile_picture', None)
old_mnemonic = ''
# region Validations
user = get_user_model().objects.select_related(
'role', 'person').filter(pk=user_id).first()
if not user:
return JsonResponse({'general': ['Something went wrong. code: 1']},
status=500)
user_name = get_user_model().objects.filter(username=username).first()
if user_name and user_name.pk != user.pk:
validator.errors.add('username', 'Is already in use.')
role = Role.objects.filter(code=request_data['role']).first()
if not role:
return JsonResponse({'general': ['Something went wrong. code: 2']},
status=500)
groups_required = groups_by_role(role.code)
groups = Group.objects.filter(name__in=groups_required)
if len(groups) != len(groups_required):
return JsonResponse({'general': ['Something went wrong. code: 2']},
status=500)
if role.code in [
'consultant', 'free_agent', 'supervisor', 'coordinator', 'info',
'trainee'
]:
consultant_profile = ConsultantProfile.objects.filter(
mnemonic=code).first()
if consultant_profile and consultant_profile.consultant_id != user.pk:
validator.errors.add('code', 'Is already in use.')
if consultant_profile:
old_mnemonic = consultant_profile.mnemonic
if role.code in ['consultant', 'free_agent', 'supervisor', 'trainee']:
supervisor = get_user_model().objects.filter(
groups__name='supervisors', is_active=True,
pk=supervisor_id).first()
if not supervisor:
return JsonResponse({'general': ['Something went wrong. code: 3']},
status=500)
if role.code in ['consultant', 'free_agent', 'supervisor'
] and commission_category_id:
commission_category = CommissionCategory.objects.filter(
pk=commission_category_id).first()
if not commission_category:
validator.errors.add('commission_category',
'Invalid commission category.')
if role.code != 'program':
market = Market.objects.filter(pk=market_id).first()
if not market:
return JsonResponse({'general': ['Something went wrong. code: 4']},
status=500)
if len(markets_mtm) > 0:
markets = Market.objects.filter(pk__in=markets_mtm)
if len(programs_mtm) > 0:
programs_base = ProgramBase.objects.filter(pk__in=programs_mtm)
if role.code != 'program':
parts = email.split('@')
if len(parts) != 2:
validator.errors.add('email', 'Invalid email.')
else:
if parts[1] != 'adastra.ca':
validator.errors.add('email', 'Must finish in @adastra.ca')
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
# endregion
user_role = Role.objects.get(user=user)
role_change = role.code != user_role.code
mailbox_name, domain = email.split('@')
mailbox = Mailbox.objects.filter(user=user).first()
try:
rs_request_data = {}
if mailbox and role.code != 'program' and not remove_account:
if user.is_active != is_active:
rs_request_data[
'enabled'] = 'true' if not user.is_active else 'false'
if user.person.first_name != first_name:
rs_request_data['firstName'] = user.person.first_name
if user.person.last_name != last_name:
rs_request_data['lastName'] = user.person.last_name
if user.person.first_name != first_name or user.person.last_name != last_name:
rs_request_data['displayName'] = user.person.get_full_name()
if password != '':
rs_request_data['password'] = password
if mailbox.name != mailbox_name:
rs_request_data['name'] = mailbox_name
with transaction.atomic():
user.person.first_name = first_name
user.person.last_name = last_name
user.person.email = email
user.person.save()
if password != '':
user.password = make_password(password)
user.common_name = common_name
user.username = username
user.is_active = is_active
user.title = title
user.role = role
user.save()
if role_change:
RoleChange.objects.create(user=user,
before=user_role,
after=role)
user.groups.clear()
for group in groups:
user.groups.add(group)
if not role == 'program':
consultant_profile, created = ConsultantProfile.objects.get_or_create(
consultant=user)
if role.code in [
'consultant', 'free_agent', 'supervisor',
'coordinator', 'info', 'trainee'
]:
if role.code in ['consultant', 'free_agent', 'supervisor']:
consultant_profile.commission_start = commission_start
if commission_category_id:
consultant_profile.commission_category = commission_category
if 'probation_start_date' in request_data and 'probation_end_date' in request_data:
consultant_profile.probation_start_date = request_data[
'probation_start_date']
consultant_profile.probation_end_date = request_data[
'probation_end_date']
consultant_profile.probation = True
else:
consultant_profile.probation = False
consultant_profile.mnemonic = code
consultant_profile.supervisor = supervisor
consultant_profile.save()
consultant_profile.market.clear()
consultant_profile.market.add(market)
if role_change:
if not role.code == 'visa' and user_role.code == 'visa':
VisasProfile.objects.filter(user=user).delete()
if not role.code == 'program' and user_role.code == 'program':
ProgramProfile.objects.filter(user=user).delete()
profile, created = Profile.objects.get_or_create(user=user.person)
if role.code == 'program' and profile_picture:
profile.profile_picture = profile_picture
profile.save()
if role.code == 'visa':
visas_profile, created = VisasProfile.objects.get_or_create(
user=user)
visas_profile.user = user
visas_profile.save()
visas_profile.markets.clear()
visas_profile.markets.add(market)
if role.code == 'program':
program_profile = ProgramProfile.objects.filter(
user=user).first()
if not program_profile:
program_profile = ProgramProfile()
program_profile.user = user
program_profile.program_base = programs_base[0]
program_profile.save()
else:
if not program_profile.program_base:
program_profile.program_base = programs_base[0]
program_profile.save()
program_profile.programs_base.clear()
program_profile.markets.clear()
for program in programs_base:
program_profile.programs_base.add(program)
for market in markets:
program_profile.markets.add(market)
rackspace = None
is_production = settings.APP_ENV == 'production'
if is_production:
rackspace = RackSpace()
if mailbox:
# Remove rackspace account
if remove_account:
mailbox.delete()
if is_production:
rackspace.delete_mailbox(mailbox.name)
# Edit rackspace account
elif len(rs_request_data.keys()) > 0 and role != 'program':
if is_production:
rackspace.edit_mailbox(mailbox.name,
data=rs_request_data)
if 'name' in rs_request_data:
if is_production:
rackspace.delete_alias(mailbox.name)
Mailbox.objects.filter(pk=mailbox.pk).update(
name=rs_request_data['name'])
# Create rackspace account
elif want_account and role.code != 'program':
if is_production:
rackspace.add_mailbox(mailbox_name,
data={
'displayName':
user.person.get_full_name(),
'firstName':
user.person.first_name,
'lastName':
user.person.last_name,
'password':
password,
'customID':
user.pk,
'enabled':
user.is_active
})
Mailbox.objects.create(name=mailbox_name, user=user)
if role.code in [
'consultant', 'free_agent', 'supervisor', 'trainee'
] and not old_mnemonic == consultant_profile.mnemonic:
update_mnemonic_by_consultant_profile(consultant_profile)
except IntegrityError as e:
log.info(repr(e))
return JsonResponse(
{
'general':
['The system could not create the user, please try again.']
},
status=400)
except WebServiceException as e:
log.info(repr(e.errors))
return JsonResponse(
{
'general': [
'It seems that the Rackspace service is busy, please try again.'
]
},
status=400)
except ValidationException as e:
return JsonResponse({'general': [e.errors]}, status=400)
except Exception as e:
log.info(repr(e))
return JsonResponse({}, status=500)
return JsonResponse({}, status=200)
def api_user_create(request):
request_data = json.loads(request.POST['data'])
market = None
supervisor = None
markets = []
programs_base = []
response = {}
validator = Validator()
common_name = request_data.get('common_name', '')
first_name = request_data.get('first_name', '')
last_name = request_data.get('last_name', '')
email = request_data.get('email', '')
username = request_data.get('username', '')
password = request_data.get('password', '')
code = request_data.get('code', '').strip()
title = request_data.get('title', '')
supervisor_id = request_data.get('supervisor_id', 0)
market_id = request_data.get('market_id', 0)
commission_category_id = request_data.get('commission_category', None)
commission_start = request_data.get('commission_start', 0)
want_account = request_data.get('want_account', False)
is_active = to_boolean(request_data.get('is_active', '0'))
markets_mtm = request_data.get('markets_mtm', [])
programs_mtm = request_data.get('programs_mtm', [])
profile_picture = request.FILES.get('profile_picture', None)
# region Validations
user = get_user_model().objects.filter(username=username).first()
if user:
validator.errors.add('username', 'Is already in use.')
role = Role.objects.filter(code=request_data['role']).first()
if not role:
return JsonResponse({'general': ['Something went wrong. code: 2']},
status=500)
groups_required = groups_by_role(role.code)
groups = Group.objects.filter(name__in=groups_required)
if len(groups) != len(groups_required):
return JsonResponse({'general': ['Something went wrong. code: 1']},
status=500)
if role.code in [
'consultant', 'free_agent', 'supervisor', 'coordinator', 'info',
'trainee'
]:
consultant_profile = ConsultantProfile.objects.filter(
mnemonic=code).first()
if consultant_profile:
validator.errors.add('code', 'Is already in use.')
if role.code in ['consultant', 'free_agent', 'supervisor', 'trainee']:
supervisor = get_user_model().objects.filter(
is_active=True, pk=supervisor_id, role__code="supervisor").first()
if not supervisor:
validator.errors.add('supervisor', 'Invalid user.')
if role.code in ['consultant', 'free_agent', 'supervisor'
] and commission_category_id:
commission_category = CommissionCategory.objects.filter(
pk=commission_category_id).first()
if not commission_category:
validator.errors.add('commission_category',
'Invalid commission category.')
if role.code != 'program':
market = Market.objects.filter(pk=market_id).first()
if not market:
validator.errors.add('market', 'This field is required.')
if role.code == 'coordinator':
query_set = get_user_model().objects.filter(
consultantprofile__market=market, role__name='coordinator')
if query_set.exists():
validator.errors.add(
'general', 'The coordinator for this market already exist.')
if len(markets_mtm) > 0:
markets = Market.objects.filter(pk__in=markets_mtm)
if len(programs_mtm) > 0:
programs_base = ProgramBase.objects.filter(pk__in=programs_mtm)
if role.code != 'program':
parts = email.split('@')
if len(parts) != 2:
validator.errors.add('email', 'Invalid email.')
else:
if parts[1] != 'adastra.ca':
validator.errors.add('email', 'Must finish in @adastra.ca')
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
# endregion
try:
with transaction.atomic():
person = Person.objects.create(first_name=first_name,
last_name=last_name,
email=email)
user = get_user_model().objects.create(
common_name=common_name,
password=make_password(password),
username=username,
is_active=is_active,
title=title,
role=role,
person=person)
response['id'] = user.pk
for group in groups:
user.groups.add(group)
if not role == 'program':
consultant_profile = ConsultantProfile()
consultant_profile.consultant = user
if role.code in [
'consultant', 'free_agent', 'supervisor',
'coordinator', 'info', 'trainee'
]:
consultant_profile.mnemonic = code
consultant_profile.supervisor = supervisor
if role.code in ['consultant', 'free_agent', 'supervisor']:
consultant_profile.commission_start = commission_start
if 'probation_start_date' in request_data and 'probation_end_date' in request_data:
consultant_profile.probation_start_date = request_data[
'probation_start_date']
consultant_profile.probation_end_date = request_data[
'probation_end_date']
consultant_profile.probation = True
if commission_category_id:
consultant_profile.commission_category_id = commission_category_id
consultant_profile.save()
consultant_profile.market.add(market)
profile = Profile()
profile.user = person
if role.code == 'program':
profile.profile_picture = profile_picture
profile.save()
if role.code == 'visa':
visas_profile = VisasProfile.objects.create(user=user)
visas_profile.markets.add(market)
if role.code == 'program':
program_profile = ProgramProfile.objects.create(
user=user, program_base=programs_base[0])
for program in programs_base:
program_profile.programs_base.add(program)
for market in markets:
program_profile.markets.add(market)
# TODO: posiblemente agregar el switch para habilitar link
if role.code != 'program' and want_account:
mailbox, domain = email.split('@')
if settings.APP_ENV == 'production':
rackspace = RackSpace()
rackspace.add_mailbox(mailbox,
data={
'displayName':
person.get_full_name(),
'firstName': person.first_name,
'lastName': person.last_name,
'password': password,
'customID': user.pk,
'enabled': user.is_active
})
Mailbox.objects.create(name=mailbox, user=user)
except IntegrityError as e:
log.error('{}'.format(e))
return JsonResponse(
{
'general':
['The system could not create the user, please try again.']
},
status=400)
except WebServiceException as e:
log.error('{}'.format(e))
return JsonResponse(
{
'general': [
'It seems that the Rackspace service is busy, please try again.'
]
},
status=400)
except ValidationException as e:
return JsonResponse({'general': [e.errors]}, status=400)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
log.info('{} at line: {}.'.format(e, exc_tb.tb_lineno))
return JsonResponse({}, status=500)
return JsonResponse(response, status=200)