def import_data_sender(self, form_model, organization, registered_emails,
registered_phone_numbers, submission, values):
phone_number = TelephoneNumber().clean(
case_insensitive_lookup(values, MOBILE_NUMBER_FIELD_CODE))
if phone_number in registered_phone_numbers:
raise DataObjectAlreadyExists(_("Data Sender"), _("Mobile Number"),
phone_number)
email = case_insensitive_lookup(values, "email")
if email:
if email in registered_emails:
raise DataObjectAlreadyExists(_("User"), _("email address"),
email)
if not email_re.match(email):
raise InvalidEmailException(message="Invalid email address.")
response = self.submit(form_model, values, submission, [])
user = User.objects.create_user(email, email, 'password')
group = Group.objects.filter(name="Data Senders")[0]
user.groups.add(group)
user.first_name = case_insensitive_lookup(response.processed_data,
NAME_FIELD_CODE)
user.save()
profile = NGOUserProfile(user=user,
org_id=organization.org_id,
title="Mr",
reporter_id=case_insensitive_lookup(
response.processed_data, SHORT_CODE))
profile.save()
send_reset_password_email(user, ugettext_lazy("en"))
else:
response = self.submit(form_model, values, submission, [])
return response
def setUp(self):
self.username = '******'
self.paid_user, _ = User.objects.get_or_create(username=self.username,email=self.username,password='******')
self.paid_user.save()
self.paid_org = Organization(name='test_org_for_correct_active_date', sector='PublicHealth', address='add', city='city', country=Country('MG'),
zipcode='10000', active_date=None)
self.paid_org.save()
self.mobile_number = "1233"
self.paid_user_profile = NGOUserProfile(user=self.paid_user, title='Mr.', org_id=self.paid_org.org_id,mobile_phone=self.mobile_number)
self.paid_user_profile.save()
self.trial_username = '******'
self.trial_user, _ = User.objects.get_or_create(username=self.trial_username,email=self.trial_username,password='******')
self.trial_user.save()
self.trial_org = Organization(name='trial_org', sector='PublicHealth', address='add', city='city', country=Country('MG'),
zipcode='10000', active_date=None, in_trial_mode=True,org_id='test')
self.trial_org.save()
self.trial_mobile_number = "12445"
self.trial_user_profile = NGOUserProfile(user=self.trial_user, title='Mr.', org_id=self.trial_org.org_id,mobile_phone=self.trial_mobile_number)
self.trial_user_profile.save()
self.patcher1 = patch('datawinners.accountmanagement.post_activation_events.get_entity_count_for_type')
self.get_all_entities_mock = self.patcher1.start()
self.patcher2 = patch('datawinners.accountmanagement.post_activation_events.create_entity')
self.create_entity_mock = self.patcher2.start()
self.patcher3 = patch('datawinners.accountmanagement.post_activation_events.get_or_create_data_dict')
self.get_or_create_data_dict_mock = self.patcher3.start()
def __create_web_users(org_id, reporter_details, language_code):
duplicate_email_ids = User.objects.filter(
email__in=[x['email'].lower()
for x in reporter_details]).values('email')
errors = []
dbm = get_database_manager_for_org(Organization.objects.get(org_id=org_id))
if len(duplicate_email_ids) > 0:
for duplicate_email in duplicate_email_ids:
errors.append("User with email %s already exists" %
duplicate_email['email'])
content = json.dumps({'success': False, 'errors': errors})
else:
for reporter in reporter_details:
reporter_entity = get_by_short_code(dbm, reporter['reporter_id'],
[REPORTER])
user = User.objects.create_user(reporter['email'].lower(),
reporter['email'].lower(),
'test123')
group = Group.objects.filter(name="Data Senders")[0]
user.groups.add(group)
user.first_name = reporter_entity.value(NAME_FIELD)
user.save()
profile = NGOUserProfile(user=user,
org_id=org_id,
title="Mr",
reporter_id=reporter['reporter_id'])
profile.save()
send_email_to_data_sender(user, language_code)
content = json.dumps({
'success': True,
'message': "Users has been created"
})
return content
def setUp(self):
set_email_settings()
User.objects.filter(username='******').delete()
User.objects.filter(username='******').delete()
Organization.objects.filter(name='test_org_for_paid_account').delete()
Organization.objects.filter(name='test_org_for_trial_account').delete()
self.user1 = RegistrationProfile.objects.create_inactive_user(
username='******',
email='*****@*****.**',
password='******',
site=Site(),
send_email=False)
self.user2 = RegistrationProfile.objects.create_inactive_user(
username='******',
email='*****@*****.**',
password='******',
site=Site(),
send_email=False)
self.user1.first_name = 'first_name1 last_name1'
self.user2.first_name = 'first_name2 last_name2'
self.user1.save()
self.user2.save()
self.prepare_organization()
NGOUserProfile(user=self.user1,
title='Mr.',
org_id=self.paid_organization.org_id).save()
NGOUserProfile(user=self.user2,
title='Ms.',
org_id=self.trial_organization.org_id).save()
class TestEntityHelper(unittest.TestCase):
def setUp(self):
self.username = '******'
self.datasender_user, _ = User.objects.get_or_create(
username=self.username, email=self.username, password='******')
self.datasender_user.save()
self.mobile_number = '112233'
self.org_id = "test_org"
self.reporter_id = "rptr1"
self.datasender_user_profile = NGOUserProfile(
user=self.datasender_user,
title='Mr.',
org_id=self.org_id,
mobile_phone=self.mobile_number,
reporter_id=self.reporter_id)
self.datasender_user_profile.save()
def test_should_delete_the_datasender_user_if_it_exists(self):
self.assertTrue(User.objects.get(username=self.username))
self.assertTrue(
NGOUserProfile.objects.get(reporter_id=self.reporter_id,
org_id=self.org_id))
entity_ids = [self.reporter_id, 'test_id']
organization = Mock(spec=Organization)
organization.org_id = self.org_id
delete_datasender_users_if_any(entity_ids, organization)
self.assertTrue(is_empty(User.objects.filter(username=self.username)))
self.assertTrue(
is_empty(
NGOUserProfile.objects.filter(reporter_id=self.reporter_id,
org_id=self.org_id)))
def tearDown(self):
User.objects.filter(username=self.username).delete()
def create_web_users(org_id, reporter_details, language_code):
duplicate_entries = {}
[duplicate_entries.update({item[0]: item[1]}) for item in reporter_details.items() if
[val for val in reporter_details.values()].count(item[1]) > 1]
errors = []
if len(duplicate_entries) > 0:
content = json.dumps({'success': False, 'errors': errors, 'duplicate_entries': duplicate_entries})
organization = Organization.objects.get(org_id=org_id)
dbm = get_database_manager_for_org(organization)
existent_email_addresses = User.objects.filter(email__in=reporter_details.values()).values('email')
if len(existent_email_addresses) > 0:
for duplicate_email in existent_email_addresses:
errors.append("User with email %s already exists" % duplicate_email['email'])
content = json.dumps({'success': False, 'errors': errors, 'duplicate_entries': duplicate_entries})
if errors.__len__() == 0 and duplicate_entries.keys().__len__() == 0:
for reporter_id, email in reporter_details.iteritems():
reporter_entity = contact_by_short_code(dbm, reporter_id)
reporter_email = email.lower()
set_email_for_contact(dbm, reporter_entity, email=reporter_email)
user = User.objects.create_user(reporter_email, reporter_email, 'test123')
group = Group.objects.filter(name="Data Senders")[0]
user.groups.add(group)
user.first_name = reporter_entity.value(NAME_FIELD)
user.save()
profile = NGOUserProfile(user=user, org_id=org_id, title="Mr",
reporter_id=reporter_id.lower())
profile.save()
send_email_to_data_sender(user, language_code, organization=organization)
content = json.dumps({'success': True, 'message': "Users has been created"})
return content
def ngo_user_created(sender, user, request, **kwargs):
data = NGOUserProfile()
data.org_id = kwargs['organization_id']
data.title = kwargs['title']
data.office_phone = kwargs['office_phone']
data.mobile_phone = kwargs['mobile_phone']
data.skype = kwargs['skype']
data.user = user
data.save()
def new_user(request):
add_user_success = False
if request.method == 'GET':
profile_form = UserProfileForm()
return render_to_response("accountmanagement/account/add_user.html",
{'profile_form': profile_form},
context_instance=RequestContext(request))
if request.method == 'POST':
manager = get_database_manager(request.user)
org = get_organization(request)
form = UserProfileForm(organization=org, data=request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
if not form.errors:
user = User.objects.create_user(username, username, 'test123')
user.first_name = form.cleaned_data['full_name']
group = Group.objects.filter(name="Project Managers")
user.groups.add(group[0])
user.save()
mobile_number = form.cleaned_data['mobile_phone']
ngo_user_profile = NGOUserProfile(
user=user,
title=form.cleaned_data['title'],
mobile_phone=mobile_number,
org_id=org.org_id)
ngo_user_profile.reporter_id = make_user_as_a_datasender(
manager=manager,
organization=org,
current_user_name=user.get_full_name(),
mobile_number=mobile_number,
email=username)
ngo_user_profile.save()
associate_user_with_existing_project(
manager, ngo_user_profile.reporter_id)
reset_form = PasswordResetForm({"email": username})
if reset_form.is_valid():
send_email_to_data_sender(reset_form.users_cache[0],
request.LANGUAGE_CODE,
request=request,
type="created_user",
organization=org)
name = form.cleaned_data.get("full_name")
form = UserProfileForm()
add_user_success = True
detail_dict = dict({"Name": name})
UserActivityLog().log(request,
action=ADDED_USER,
detail=json.dumps(detail_dict))
return render_to_response("accountmanagement/account/add_user.html", {
'profile_form': form,
'add_user_success': add_user_success
},
context_instance=RequestContext(request))
def _create_user(self, email, organization, response):
user = User.objects.create_user(email, email, 'password')
group = Group.objects.filter(name="Data Senders")[0]
user.groups.add(group)
user.first_name = case_insensitive_lookup(response.processed_data, NAME_FIELD_CODE)
user.save()
profile = NGOUserProfile(user=user, org_id=organization.org_id, title="Mr",
reporter_id=case_insensitive_lookup(response.processed_data, SHORT_CODE))
profile.save()
return user
def setUp(self):
self.new_user = User(first_name="First",
last_name="Last",
username="******")
self.new_user.save()
from datawinners.accountmanagement.models import Organization
org_id = Organization.objects.all()[0].org_id
self.ngouser = NGOUserProfile(user=self.new_user,
org_id=org_id,
reporter_id="ds406")
self.ngouser.save()
def setUp(self):
MangroveTestCase.setUp(self)
self.username = '******'
self.datasender_user, _ = User.objects.get_or_create(username=self.username,email=self.username,password='******')
self.datasender_user.save()
self.mobile_number = '112233'
self.org_id = "test_org"
self.reporter_id = "rptr1"
self.datasender_user_profile = NGOUserProfile(user=self.datasender_user, title='Mr.',
org_id=self.org_id, mobile_phone=self.mobile_number, reporter_id = self.reporter_id)
self.datasender_user_profile.save()
def create_web_users(org_id, reporter_details, language_code):
organization = Organization.objects.get(org_id=org_id)
dbm = get_database_manager_for_org(organization)
for reporter_id, email in reporter_details.iteritems():
reporter_entity = contact_by_short_code(dbm, reporter_id)
reporter_email = email.lower()
set_email_for_contact(dbm, reporter_entity, email=reporter_email)
user = User.objects.create_user(reporter_email, reporter_email, 'test123')
group = Group.objects.filter(name="Data Senders")[0]
user.groups.add(group)
user.first_name = reporter_entity.value(NAME_FIELD)
user.save()
profile = NGOUserProfile(user=user, org_id=org_id, title="Mr",
reporter_id=reporter_id.lower())
profile.save()
send_email_to_data_sender(user, language_code, organization=organization)
return json.dumps({'success': True, 'message': "Users has been created"})
def new_user(request):
if request.method == "GET":
profile_form = UserProfileForm()
return render_to_response(
"accountmanagement/account/add_user.html",
{"profile_form": profile_form},
context_instance=RequestContext(request),
)
if request.method == "POST":
org_id = request.user.get_profile().org_id
form = UserProfileForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get("username")
if not form.errors:
user = User.objects.create_user(username, username, "test123")
user.first_name = form.cleaned_data["first_name"]
user.last_name = form.cleaned_data["last_name"]
group = Group.objects.filter(name="Project Managers")
user.groups.add(group[0])
user.save()
ngo_user_profile = NGOUserProfile(
user=user,
title=form.cleaned_data["title"],
office_phone=form.cleaned_data["office_phone"],
mobile_phone=form.cleaned_data["mobile_phone"],
skype=form.cleaned_data["skype"],
org_id=org_id,
)
ngo_user_profile.save()
reset_form = PasswordResetForm({"email": username})
reset_form.is_valid()
reset_form.save()
return HttpResponseRedirect("/account/users")
return render_to_response(
"accountmanagement/account/add_user.html", {"profile_form": form}, context_instance=RequestContext(request)
)
def setUp(self):
try:
User.objects.get(username='******').delete()
User.objects.get(username='******').delete()
Organization.objects.get(
name='test_org_for_expired_organization_out_of_31_days'
).delete()
Organization.objects.get(name='test_org_for_paid_account').delete()
Organization.objects.get(
name='test_org_for_unexpired_account').delete()
Organization.objects.get(
name='test_org_for_expired_organization_of_30_days').delete()
except:
pass
self.user1 = User(username='******',
email='*****@*****.**',
password='******',
first_name='first_name1',
last_name='last_name1')
self.user2 = User(username='******',
email='*****@*****.**',
password='******',
first_name='first_name2',
last_name='last_name2')
self.user1.set_password('expired')
self.user2.set_password('expired')
self.user1.save()
self.user2.save()
self.prepare_organization()
NGOUserProfile(
user=self.user1,
title='Mr.',
org_id=self.expired_organization_of_30_days.org_id).save()
NGOUserProfile(
user=self.user2,
title='Ms.',
org_id=self.expired_organization_of_30_days.org_id).save()
class TestEntityHelper(MangroveTestCase):
def setUp(self):
MangroveTestCase.setUp(self)
self.username = '******'
self.datasender_user, _ = User.objects.get_or_create(username=self.username,email=self.username,password='******')
self.datasender_user.save()
self.mobile_number = '112233'
self.org_id = "test_org"
self.reporter_id = "rptr1"
self.datasender_user_profile = NGOUserProfile(user=self.datasender_user, title='Mr.',
org_id=self.org_id, mobile_phone=self.mobile_number, reporter_id = self.reporter_id)
self.datasender_user_profile.save()
def test_should_delete_the_datasender_user_if_it_exists(self):
self.assertTrue(User.objects.get(username=self.username))
self.assertTrue(NGOUserProfile.objects.get(reporter_id=self.reporter_id, org_id=self.org_id))
entity_ids = [self.reporter_id, 'test_id']
organization = Mock(spec=Organization)
organization.org_id = self.org_id
delete_datasender_users_if_any(entity_ids, organization)
self.assertTrue(is_empty(User.objects.filter(username=self.username)))
self.assertTrue(is_empty(NGOUserProfile.objects.filter(reporter_id=self.reporter_id, org_id=self.org_id)))
def test_should_add_email_to_datasender(self):
email = "*****@*****.**"
entity = Entity(self.manager, entity_type=REPORTER_ENTITY_TYPE, short_code="short_code")
entity.save()
create_default_reg_form_model(self.manager)
put_email_information_to_entity(self.manager, entity, email=email)
entity_values = entity.data
self.assertEquals(entity_values["email"]["value"], email)
def tearDown(self):
MangroveTestCase.tearDown(self)
User.objects.filter(username=self.username).delete()
class TestLinkUser(unittest.TestCase):
def setUp(self):
self.new_user = User(first_name="First",
last_name="Last",
username="******")
self.new_user.save()
from datawinners.accountmanagement.models import Organization
org_id = Organization.objects.all()[0].org_id
self.ngouser = NGOUserProfile(user=self.new_user,
org_id=org_id,
reporter_id="ds406")
self.ngouser.save()
@patch(
'datawinners.accountmanagement.user_tasks.make_user_data_sender_with_project'
)
@patch('datawinners.accountmanagement.user_tasks.get_all_projects')
@patch('datawinners.accountmanagement.user_tasks.get_database_manager')
def test_should_link_user_as_datasender_to_all_project(
self, get_database_manager_mock, get_all_projects_mock,
make_user_data_sender_with_project_mock):
all_projects = [{
'value': {
'datasenders': ["ds406", "rep011"],
"_id": "27348932184297"
}
}]
get_database_manager_mock.return_value = "dbm"
get_all_projects_mock.return_value = all_projects
link_user_to_all_projects.apply(args=(self.new_user.id, )).get()
get_database_manager_mock.assert_called_with(self.new_user)
make_user_data_sender_with_project_mock.assert_called_with(
"dbm", "ds406", "27348932184297")
def tearDown(self):
self.ngouser.delete()
self.new_user.delete()
def _prepare_test_user(self):
user = User(username='******',
first_name='a',
last_name='a',
email='*****@*****.**',
password='******')
user.save()
(NGOUserProfile(user=user)).save()
digest = PartialDigest(user=user,
login='******',
partial_digest='partial',
confirmed=True)
digest.save()
self.digest = digest
return user
def new_user(request):
if request.method == 'GET':
profile_form = UserProfileForm()
return render_to_response("accountmanagement/account/add_user.html",
{'profile_form': profile_form},
context_instance=RequestContext(request))
if request.method == 'POST':
org_id = request.user.get_profile().org_id
form = UserProfileForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
if not form.errors:
user = User.objects.create_user(username, username, 'test123')
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
group = Group.objects.filter(name="Project Managers")
user.groups.add(group[0])
user.save()
ngo_user_profile = NGOUserProfile(
user=user,
title=form.cleaned_data['title'],
office_phone=form.cleaned_data['office_phone'],
mobile_phone=form.cleaned_data['mobile_phone'],
skype=form.cleaned_data['skype'],
org_id=org_id)
ngo_user_profile.save()
reset_form = PasswordResetForm({"email": username})
reset_form.is_valid()
reset_form.save()
return HttpResponseRedirect('/account/users')
return render_to_response("accountmanagement/account/add_user.html",
{'profile_form': form},
context_instance=RequestContext(request))
def setUpClass(cls):
EntityFormModelDocument.registered_functions = []
EntityDocument.registered_functions = []
cls.manager = get_db_manager('http://localhost:5984/',
uniq('mangrove-test'))
initializer._create_views(cls.manager)
cls.username = '******'
cls.datasender_user, _ = User.objects.get_or_create(
username=cls.username, email=cls.username, password='******')
cls.datasender_user.save()
cls.mobile_number = '112233'
cls.org_id = "test_org"
cls.reporter_id = "rptr1"
cls.datasender_user_profile = NGOUserProfile(
user=cls.datasender_user,
title='Mr.',
org_id=cls.org_id,
mobile_phone=cls.mobile_number,
reporter_id=cls.reporter_id)
cls.datasender_user_profile.save()
def save_model(self, request, obj, form, change):
super(DWUserAdmin, self).save_model(request, obj, form, change)
if change:
if 'email' in form.changed_data or 'username' in form.changed_data:
try:
existing_digests = PartialDigest.objects.filter(user=obj)
if existing_digests:
for existing_digest in existing_digests:
existing_digest.delete()
except PartialDigest.DoesNotExist:
pass
if form.cleaned_data.get('organization_id') is not None:
try:
user_profile = NGOUserProfile.objects.get(user=obj)
user_profile.org_id = form.cleaned_data['organization_id']
user_profile.save()
except NGOUserProfile.DoesNotExist:
user_profile = NGOUserProfile()
user_profile.org_id = form.cleaned_data['organization_id']
user_profile.title = 'Title'
user_profile.user = obj
user_profile.save()
def new_user(request):
org = get_organization(request)
add_user_success = True
manager = get_database_manager(request.user)
if request.method == 'GET':
profile_form = UserProfileForm()
return render_to_response(
"accountmanagement/account/add_new_user.html", {
'profile_form': profile_form,
'is_pro_sms': org.is_pro_sms,
'current_lang': get_language()
},
context_instance=(RequestContext(request)))
if request.method == 'POST':
post_parameters = request.POST
org = get_organization(request)
form = UserProfileForm(organization=org, data=request.POST)
errors = {}
if form.is_valid():
username = post_parameters['username']
role = post_parameters['role']
if not form.errors:
with transaction.commit_manually():
sid = transaction.savepoint()
try:
user = User.objects.create_user(
username, username, 'test123')
user.first_name = post_parameters['full_name']
group = Group.objects.filter(name=role)
user.groups.add(group[0])
user.save()
mobile_number = post_parameters['mobile_phone']
ngo_user_profile = NGOUserProfile(
user=user,
title=post_parameters['title'],
mobile_phone=mobile_number,
org_id=org.org_id)
ngo_user_profile.reporter_id = make_user_as_a_datasender(
manager=manager,
organization=org,
current_user_name=user.get_full_name(),
mobile_number=mobile_number,
email=username)
ngo_user_profile.save()
handle_feature_toggle_impact_for_new_user(
ngo_user_profile)
reset_form = PasswordResetForm({"email": username})
name = post_parameters["full_name"]
if role == 'Extended Users':
associate_user_with_all_projects_of_organisation(
manager, ngo_user_profile.reporter_id)
UserActivityLog().log(request,
action=ADDED_USER,
detail=activity_log_detail(
name,
friendly_name(role)))
elif role == 'Project Managers':
selected_questionnaires = post_parameters.getlist(
'selected_questionnaires[]')
selected_questionnaire_names = post_parameters.getlist(
'selected_questionnaire_names[]')
if selected_questionnaires is None:
selected_questionnaires = []
associate_user_with_projects(
manager, ngo_user_profile.reporter_id, user.id,
selected_questionnaires)
UserActivityLog().log(
request,
action=ADDED_USER,
detail=activity_log_detail(
name, friendly_name(role),
selected_questionnaire_names))
transaction.savepoint_commit(sid)
except Exception as e:
transaction.savepoint_rollback(sid)
datawinners_logger.exception(e.message)
add_user_success = False
transaction.commit(
) #Mandatory for manually managed transaction blocks. Here it won't save anything
if add_user_success and reset_form.is_valid():
send_email_to_data_sender(reset_form.users_cache[0],
request.LANGUAGE_CODE,
request=request,
type="created_user",
organization=org)
form = UserProfileForm()
else:
add_user_success = False
else:
errors = form.errors
add_user_success = False
if len(request.user.groups.filter(name__in=["NGO Admins"])) < 1:
current_user_type = "Administrator"
else:
current_user_type = "Account-Administrator"
data = {
"add_user_success": add_user_success,
"errors": errors,
"current_user": current_user_type
}
return HttpResponse(json.dumps(data),
mimetype="application/json",
status=201)
class TestPostActivationEvents(unittest.TestCase):
def setUp(self):
self.username = '******'
self.paid_user, _ = User.objects.get_or_create(username=self.username,
email=self.username,
password='******')
self.paid_user.save()
self.paid_org = Organization(name='test_org_for_correct_active_date',
sector='PublicHealth',
address='add',
city='city',
country=Country('MG'),
zipcode='10000',
active_date=None)
self.paid_org.save()
self.mobile_number = "1233"
self.paid_user_profile = NGOUserProfile(
user=self.paid_user,
title='Mr.',
org_id=self.paid_org.org_id,
mobile_phone=self.mobile_number)
self.paid_user_profile.save()
self.trial_username = '******'
self.trial_user, _ = User.objects.get_or_create(
username=self.trial_username,
email=self.trial_username,
password='******')
self.trial_user.save()
self.trial_org = Organization(name='trial_org',
sector='PublicHealth',
address='add',
city='city',
country=Country('MG'),
zipcode='10000',
active_date=None,
account_type='Basic',
org_id='test')
self.trial_org.save()
self.trial_mobile_number = "12445"
self.trial_user_profile = NGOUserProfile(
user=self.trial_user,
title='Mr.',
org_id=self.trial_org.org_id,
mobile_phone=self.trial_mobile_number)
self.trial_user_profile.save()
self.patcher1 = patch(
'datawinners.accountmanagement.post_activation_events.get_entity_count_for_type'
)
self.get_all_entities_mock = self.patcher1.start()
self.patcher2 = patch(
'datawinners.accountmanagement.post_activation_events.create_contact'
)
self.create_entity_mock = self.patcher2.start()
def test_active_organization_with_should_active_date_is_none_save_active_date(
self):
active_organization(org=self.paid_org)
self.assertIsNotNone(
Organization.objects.get(org_id=self.paid_org.org_id).active_date)
self.assertEqual(
Organization.objects.get(
org_id=self.paid_org.org_id).active_date.microsecond, 0)
def test_should_make_datasender_entity_for_paid_account(self):
mock_manager = Mock(spec=DatabaseManager)
entity_mock = Mock(spec=Contact)
entity_mock.type_path = [REPORTER]
self.get_all_entities_mock.return_value = 1
self.create_entity_mock = entity_mock
make_user_as_a_datasender(mock_manager, self.paid_org, self.username,
self.mobile_number)
entity_mock.add_data.assert_called_once()
def test_should_make_datasender_entity_and_datasender_on_trial_account_for_trial_account(
self):
mock_manager = Mock(spec=DatabaseManager)
entity_mock = Mock(spec=Entity)
entity_mock.type_path = [REPORTER]
self.get_all_entities_mock.return_value = 1
self.create_entity_mock = entity_mock
make_user_as_a_datasender(mock_manager, self.trial_org,
self.trial_username,
self.trial_mobile_number)
entity_mock.add_data.assert_called_once()
data_senders_on_trial_account = DataSenderOnTrialAccount.objects.filter(
organization=self.trial_org)
self.assertEqual(1, len(data_senders_on_trial_account))
self.assertEqual(self.trial_mobile_number,
data_senders_on_trial_account[0].mobile_number)
self.assertEqual(self.trial_org,
data_senders_on_trial_account[0].organization)
def tearDown(self):
self.paid_user_profile.delete()
self.paid_org.delete()
self.paid_user.delete()
self.trial_user_profile.delete()
self.trial_org.delete()
self.trial_user.delete()
DataSenderOnTrialAccount.objects.filter(
organization=self.trial_org).delete()
self.patcher1.stop()
self.patcher2.stop()
def get_profile(self):
profile = NGOUserProfile()
profile.org_id = self.org_id
return profile
