def copy_snapshot(request, domain):
user = request.couch_user
if not user.is_eula_signed():
messages.error(request,
'You must agree to our eula to download an app')
return project_info(request, domain)
dom = Domain.get(domain)
if request.method == "POST" and dom.is_snapshot:
from corehq.apps.registration.forms import DomainRegistrationForm
args = {
'domain_name': request.POST['new_project_name'],
'eula_confirmed': True
}
form = DomainRegistrationForm(args)
if request.POST.get('new_project_name', ""):
if not dom.published:
messages.error(
request,
"This project is not published and can't be downloaded")
return project_info(request, domain)
if form.is_valid():
new_domain = dom.save_copy(form.cleaned_data['domain_name'],
user=user)
else:
messages.error(request, form.errors)
return project_info(request, domain)
if new_domain is None:
messages.error(request,
_("A project by that name already exists"))
return project_info(request, domain)
def inc_downloads(d):
d.downloads += 1
apply_update(dom, inc_downloads)
# sign project up for trial
create_30_day_trial(new_domain)
messages.success(request,
render_to_string(
"appstore/partials/view_wiki.html",
{"pre": _("Project copied successfully!")}),
extra_tags="html")
return HttpResponseRedirect(
reverse('view_app',
args=[
new_domain.name,
new_domain.full_applications()[0].get_id
]))
else:
messages.error(request,
_("You must specify a name for the new project"))
return project_info(request, domain)
else:
return HttpResponseRedirect(reverse('project_info', args=[domain]))
def import_app(request, snapshot):
user = request.couch_user
if not user.is_eula_signed():
messages.error(request, 'You must agree to our eula to download an app')
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
from_project = Domain.get(snapshot)
if request.method == 'POST' and from_project.is_snapshot:
if not from_project.published:
messages.error(request, "This project is not published and can't be downloaded")
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
to_project_name = request.POST['project']
if not user.is_member_of(to_project_name):
messages.error(request, _("You don't belong to that project"))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
full_apps = from_project.full_applications(include_builds=False)
assert full_apps, 'Bad attempt to copy apps from a project without any!'
for app in full_apps:
new_doc = from_project.copy_component(app['doc_type'], app.get_id, to_project_name, user)
clear_app_cache(request, to_project_name)
from_project.downloads += 1
from_project.save()
messages.success(request, render_to_string("appstore/partials/view_wiki.html",
{"pre": _("Application successfully imported!")}),
extra_tags="html")
return HttpResponseRedirect(reverse('view_app', args=[to_project_name, new_doc.id]))
else:
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
def setUp(self):
super(XMLTest, self).setUp()
self.domain = util.bootstrap_domain(util.TEST_DOMAIN)
util.bootstrap_location_types(self.domain.name)
util.bootstrap_products(self.domain.name)
self.products = sorted(Product.by_domain(self.domain.name),
key=lambda p: p._id)
self.ct_settings = SQLCommtrackConfig.for_domain(self.domain.name)
self.ct_settings.sqlconsumptionconfig = SQLConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
)
self.ct_settings.save()
self.ct_settings.sqlconsumptionconfig.commtrack_settings = self.ct_settings
self.ct_settings.sqlconsumptionconfig.save()
self.domain = Domain.get(self.domain._id)
self.loc = make_loc('loc1')
self.sp = self.loc.linked_supply_point()
self.users = [
util.bootstrap_user(self, **user_def)
for user_def in self.user_definitions
]
self.user = self.users[0]
def catch_signal(app, **kwargs):
app_name = app.__name__.rsplit('.', 1)[0]
if app_name == _module:
def _log(msg):
if not settings.DEBUG:
logging.exception(msg)
else:
print(msg, file=sys.stderr)
try:
q = {'fields': ['name']}
result = es_query(params={
'internal.using_call_center': True,
'is_active': True,
'is_snapshot': False
}, q=q)
hits = result.get('hits', {}).get('hits', {})
for hit in hits:
try:
domain = Domain.get(hit['_id'])
print(' callcenter bootstap `{0}`'.format(domain.name))
bootstrap_callcenter(domain)
except ResourceNotFound:
_log("Couldn't find domain {dom} during call center sync".format(dom=hit['_id']))
except (RequestException, ESError):
_log('Unable to query ES for call-center domains during syncdb')
def project_image(request, snapshot):
project = Domain.get(snapshot)
if project.image_path:
image = project.fetch_attachment(project.image_path)
return HttpResponse(image, content_type=project.image_type)
else:
raise Http404()
def import_app(request, snapshot):
user = request.couch_user
if not user.is_eula_signed():
messages.error(request, 'You must agree to our eula to download an app')
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
from_project = Domain.get(snapshot)
if request.method == 'POST' and from_project.is_snapshot:
if not from_project.published:
messages.error(request, "This project is not published and can't be downloaded")
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
to_project_name = request.POST['project']
if not user.is_member_of(to_project_name):
messages.error(request, _("You don't belong to that project"))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
full_apps = from_project.full_applications(include_builds=False)
assert full_apps, 'Bad attempt to copy apps from a project without any!'
for app in full_apps:
new_doc = from_project.copy_component(app['doc_type'], app.get_id, to_project_name, user)
clear_app_cache(request, to_project_name)
from_project.downloads += 1
from_project.save()
messages.success(request, render_to_string("appstore/partials/view_wiki.html",
{"pre": _("Application successfully imported!")}),
extra_tags="html")
return HttpResponseRedirect(reverse('view_app', args=[to_project_name, new_doc.id]))
else:
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
def project_documentation_file(request, snapshot):
project = Domain.get(snapshot)
if project.documentation_file_path:
documentation_file = project.fetch_attachment(project.documentation_file_path)
return HttpResponse(documentation_file, content_type=project.documentation_file_type)
else:
raise Http404()
def project_documentation_file(request, snapshot):
project = Domain.get(snapshot)
if project.documentation_file_path:
documentation_file = project.fetch_attachment(project.documentation_file_path)
return HttpResponse(documentation_file, content_type=project.documentation_file_type)
else:
raise Http404()
def catch_signal(app, **kwargs):
app_name = app.__name__.rsplit('.', 1)[0]
if app_name == _module:
def _log(msg):
if not settings.DEBUG:
logging.exception(msg)
else:
print(msg, file=sys.stderr)
try:
q = {'fields': ['name']}
result = es_query(params={
'internal.using_call_center': True,
'is_active': True,
'is_snapshot': False
},
q=q)
hits = result.get('hits', {}).get('hits', {})
for hit in hits:
try:
domain = Domain.get(hit['_id'])
print(' callcenter bootstap `{0}`'.format(domain.name))
bootstrap_callcenter(domain)
except ResourceNotFound:
_log("Couldn't find domain {dom} during call center sync".
format(dom=hit['_id']))
except RequestException:
_log('Unable to query ES for call-center domains during syncdb')
def setUp(self):
super(LoadBalancingAndRateLimitingTestCase, self).setUp()
self.domain = 'load-balance-rate-limit'
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get(self.domain_obj.get_id)
def project_info(request, domain, template="appstore/project_info.html"):
dom = Domain.get(domain)
if not can_view_app(request, dom):
raise Http404()
copies = dom.copies_of_parent()
images = set()
audio = set()
return render(
request, template, {
"project":
dom,
"applications":
dom.full_applications(include_builds=False),
"fixtures":
FixtureDataType.by_domain(dom.name),
"copies":
copies,
"images":
images,
"audio":
audio,
"url_base":
reverse('appstore'),
'display_import':
True if getattr(request, "couch_user", "")
and request.couch_user.get_domains() else False
})
def project_image(request, snapshot):
project = Domain.get(snapshot)
if project.image_path:
image = project.fetch_attachment(project.image_path)
return HttpResponse(image, content_type=project.image_type)
else:
raise Http404()
def setUp(self):
super(BaseReminderTestCase, self).setUp()
self.domain_obj = Domain(name="test")
self.domain_obj.save()
# Prevent resource conflict
self.domain_obj = Domain.get(self.domain_obj._id)
self.account, _ = BillingAccount.get_or_create_account_by_domain(
self.domain_obj.name,
created_by="tests"
)
advanced_plan_version = DefaultProductPlan.get_default_plan_by_domain(
self.domain_obj, edition=SoftwarePlanEdition.ADVANCED)
self.subscription = Subscription.new_domain_subscription(
self.account,
self.domain_obj.name,
advanced_plan_version
)
self.subscription.is_active = True
self.subscription.save()
self.sms_backend = TestSMSBackend(named="MOBILE_BACKEND_TEST", is_global=True)
self.sms_backend.save()
self.sms_backend_mapping = BackendMapping(is_global=True,prefix="*",backend_id=self.sms_backend._id)
self.sms_backend_mapping.save()
def project_info(request, domain, template="appstore/project_info.html"):
dom = Domain.get(domain)
if not can_view_app(request, dom):
raise Http404()
if request.method == "POST" and dom.copied_from.name not in request.couch_user.get_domains():
form = AddReviewForm(request.POST)
if form.is_valid():
title = form.cleaned_data['review_title']
rating = int(request.POST.get('rating'))
if rating < 1:
rating = 1
if rating > 5:
rating = 5
info = form.cleaned_data['review_info']
date_published = datetime.now()
user = request.user.username
old_review = Review.get_by_version_and_user(domain, user)
if len(old_review) > 0: # replace old review
review = old_review[0]
review.title = title
review.rating = rating
review.info = info
review.date_published = date_published
else:
review = Review(title=title, rating=rating, user=user, info=info, date_published = date_published, domain=domain, project_id=dom.copied_from._id)
review.save()
else:
form = AddReviewForm()
else:
form = AddReviewForm()
copies = dom.copies_of_parent()
reviews = Review.get_by_app(dom.copied_from._id)
average_rating = Review.get_average_rating_by_app(dom.copied_from._id)
num_ratings = Review.get_num_ratings_by_app(dom.copied_from._id)
if average_rating:
average_rating = round(average_rating, 1)
images = set()
audio = set()
return render(request, template, {
"project": dom,
"applications": dom.full_applications(include_builds=False),
"form": form,
"copies": copies,
"reviews": reviews,
"average_rating": average_rating,
"num_ratings": num_ratings,
"images": images,
"audio": audio,
"url_base": reverse('appstore'),
'display_import': True if getattr(request, "couch_user", "") and request.couch_user.get_domains() else False
})
def setUp(self):
super(BaseReminderTestCase, self).setUp()
self.domain_obj = Domain(name="test")
self.domain_obj.save()
# Prevent resource conflict
self.domain_obj = Domain.get(self.domain_obj._id)
self.setup_subscription(self.domain_obj.name, SoftwarePlanEdition.ADVANCED)
self.sms_backend, self.sms_backend_mapping = setup_default_sms_test_backend()
def setUp(self):
super(BaseReminderTestCase, self).setUp()
self.domain_obj = Domain(name="test")
self.domain_obj.save()
# Prevent resource conflict
self.domain_obj = Domain.get(self.domain_obj._id)
self.setup_subscription(self.domain_obj.name, SoftwarePlanEdition.ADVANCED)
self.sms_backend, self.sms_backend_mapping = setup_default_sms_test_backend()
def copy_snapshot(request, snapshot):
user = request.couch_user
if not user.is_eula_signed():
messages.error(request, _('You must agree to our terms of service to download an app'))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
domain_obj = Domain.get(snapshot)
if request.method == "POST" and domain_obj.is_snapshot:
assert domain_obj.full_applications(include_builds=False), 'Bad attempt to copy project without any apps!'
from corehq.apps.registration.forms import DomainRegistrationForm
args = {
'domain_name': request.POST['new_project_name'],
'hr_name': request.POST['new_project_name'],
'eula_confirmed': True,
}
form = DomainRegistrationForm(args)
if request.POST.get('new_project_name', ""):
if not domain_obj.published:
messages.error(request, _("This project is not published and can't be downloaded"))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
if not form.is_valid():
messages.error(request, form.errors)
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
new_domain_name = name_to_url(form.cleaned_data['hr_name'], "project")
with CriticalSection(['copy_domain_snapshot_{}_to_{}'.format(domain_obj.name, new_domain_name)]):
try:
new_domain = domain_obj.save_copy(new_domain_name,
new_hr_name=form.cleaned_data['hr_name'],
user=user)
if new_domain.commtrack_enabled:
new_domain.convert_to_commtrack()
ensure_explicit_community_subscription(
new_domain.name, date.today(), SubscriptionAdjustmentMethod.USER,
web_user=user.username,
)
except NameUnavailableException:
messages.error(request, _("A project by that name already exists"))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
def inc_downloads(d):
d.downloads += 1
apply_update(domain_obj, inc_downloads)
messages.success(request, render_to_string("appstore/partials/view_wiki.html",
{"pre": _("Project copied successfully!")}),
extra_tags="html")
return HttpResponseRedirect(reverse('view_app',
args=[new_domain.name, new_domain.full_applications()[0].get_id]))
else:
messages.error(request, _("You must specify a name for the new project"))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
else:
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
def setUp(self):
super(AllBackendTest, self).setUp()
backend_api.TEST = True
self.domain_obj = Domain(name='all-backend-test')
self.domain_obj.save()
self.create_account_and_subscription(self.domain_obj.name)
self.domain_obj = Domain.get(self.domain_obj._id)
self.test_phone_number = '99912345'
self.contact1 = CommCareCase(domain=self.domain_obj.name)
self.contact1.set_case_property('contact_phone_number', self.test_phone_number)
self.contact1.set_case_property('contact_phone_number_is_verified', '1')
self.contact1.save()
self.contact1 = CommConnectCase.wrap(self.contact1.to_json())
# For use with megamobile only
self.contact2 = CommCareCase(domain=self.domain_obj.name)
self.contact2.set_case_property('contact_phone_number', '63%s' % self.test_phone_number)
self.contact2.set_case_property('contact_phone_number_is_verified', '1')
self.contact2.save()
self.contact2 = CommConnectCase.wrap(self.contact2.to_json())
self.unicel_backend = UnicelBackend(name='UNICEL', is_global=True)
self.unicel_backend.save()
self.mach_backend = MachBackend(name='MACH', is_global=True)
self.mach_backend.save()
self.tropo_backend = TropoBackend(name='TROPO', is_global=True)
self.tropo_backend.save()
self.http_backend = HttpBackend(name='HTTP', is_global=True)
self.http_backend.save()
self.telerivet_backend = TelerivetBackend(name='TELERIVET', is_global=True,
webhook_secret='telerivet-webhook-secret')
self.telerivet_backend.save()
self.test_backend = TestSMSBackend(name='TEST', is_global=True)
self.test_backend.save()
self.grapevine_backend = GrapevineBackend(name='GRAPEVINE', is_global=True)
self.grapevine_backend.save()
self.twilio_backend = TwilioBackend(name='TWILIO', is_global=True)
self.twilio_backend.save()
self.megamobile_backend = MegamobileBackend(name='MEGAMOBILE', is_global=True)
self.megamobile_backend.save()
self.smsgh_backend = SMSGHBackend(name='SMSGH', is_global=True)
self.smsgh_backend.save()
if not hasattr(settings, 'SIMPLE_API_KEYS'):
settings.SIMPLE_API_KEYS = {}
settings.SIMPLE_API_KEYS['grapevine-test'] = 'grapevine-api-key'
def setUp(self):
self.domain = "test-domain"
self.domain2 = "test-domain2"
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.domain_obj = Domain.get(self.domain_obj._id) # Prevent resource conflict
self.backend1 = TestCaseBackend(name="BACKEND1",is_global=True)
self.backend1.save()
self.backend2 = TestCaseBackend(name="BACKEND2",is_global=True)
self.backend2.save()
self.backend3 = TestCaseBackend(name="BACKEND3",is_global=True)
self.backend3.save()
self.backend4 = TestCaseBackend(name="BACKEND4",is_global=True)
self.backend4.save()
self.backend5 = TestCaseBackend(name="BACKEND5",domain=self.domain,is_global=False,authorized_domains=[])
self.backend5.save()
self.backend6 = TestCaseBackend(name="BACKEND6",domain=self.domain2,is_global=False,authorized_domains=[self.domain])
self.backend6.save()
self.backend7 = TestCaseBackend(name="BACKEND7",domain=self.domain2,is_global=False,authorized_domains=[])
self.backend7.save()
self.backend8 = TestCaseBackend(name="BACKEND",domain=self.domain,is_global=False,authorized_domains=[])
self.backend8.save()
self.backend9 = TestCaseBackend(name="BACKEND",domain=self.domain2,is_global=False,authorized_domains=[self.domain])
self.backend9.save()
self.backend10 = TestCaseBackend(name="BACKEND",is_global=True)
self.backend10.save()
self.backend_mapping1 = BackendMapping(is_global=True,prefix="*",backend_id=self.backend1._id)
self.backend_mapping1.save()
self.backend_mapping2 = BackendMapping(is_global=True,prefix="1",backend_id=self.backend2._id)
self.backend_mapping2.save()
self.backend_mapping3 = BackendMapping(is_global=True,prefix="91",backend_id=self.backend3._id)
self.backend_mapping3.save()
self.backend_mapping4 = BackendMapping(is_global=True,prefix="265",backend_id=self.backend4._id)
self.backend_mapping4.save()
self.case = CommCareCase(domain=self.domain)
self.case.set_case_property("contact_phone_number","15551234567")
self.case.set_case_property("contact_phone_number_is_verified", "1")
self.case.save()
self.contact = CommConnectCase.wrap(self.case.to_json())
settings.SMS_LOADED_BACKENDS.append("corehq.apps.sms.tests.TestCaseBackend")
def copy_snapshot(request, snapshot):
user = request.couch_user
if not user.is_eula_signed():
messages.error(request, _('You must agree to our terms of service to download an app'))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
domain_obj = Domain.get(snapshot)
if request.method == "POST" and domain_obj.is_snapshot:
assert domain_obj.full_applications(include_builds=False), 'Bad attempt to copy project without any apps!'
from corehq.apps.registration.forms import DomainRegistrationForm
args = {
'domain_name': request.POST['new_project_name'],
'hr_name': request.POST['new_project_name'],
'eula_confirmed': True,
}
form = DomainRegistrationForm(args)
if request.POST.get('new_project_name', ""):
if not domain_obj.published:
messages.error(request, _("This project is not published and can't be downloaded"))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
if not form.is_valid():
messages.error(request, form.errors)
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
new_domain_name = name_to_url(form.cleaned_data['hr_name'], "project")
with CriticalSection(['copy_domain_snapshot_{}_to_{}'.format(domain_obj.name, new_domain_name)]):
try:
new_domain = domain_obj.save_copy(new_domain_name,
new_hr_name=form.cleaned_data['hr_name'],
user=user)
if new_domain.commtrack_enabled:
new_domain.convert_to_commtrack()
ensure_explicit_community_subscription(
new_domain.name, date.today(), SubscriptionAdjustmentMethod.USER,
web_user=user.username,
)
except NameUnavailableException:
messages.error(request, _("A project by that name already exists"))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
def inc_downloads(d):
d.downloads += 1
apply_update(domain_obj, inc_downloads)
messages.success(request, render_to_string("appstore/partials/view_wiki.html",
{"pre": _("Project copied successfully!")}),
extra_tags="html")
return HttpResponseRedirect(reverse('view_app',
args=[new_domain.name, new_domain.full_applications()[0].get_id]))
else:
messages.error(request, _("You must specify a name for the new project"))
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
else:
return HttpResponseRedirect(reverse(ProjectInformationView.urlname, args=[snapshot]))
def enable_usercase(domain_name):
with CriticalSection(['enable_usercase_' + domain_name]):
domain = Domain.get_by_name(domain_name, strict=True)
if not domain: # copying domains passes in an id before name is saved
domain = Domain.get(domain_name)
if not domain.usercase_enabled:
domain.usercase_enabled = True
domain.save()
create_user_cases.delay(domain_name)
def enable_usercase(domain_name):
with CriticalSection(['enable_usercase_' + domain_name]):
domain = Domain.get_by_name(domain_name, strict=True)
if not domain: # copying domains passes in an id before name is saved
domain = Domain.get(domain_name)
if not domain.usercase_enabled:
domain.usercase_enabled = True
domain.save()
create_user_cases.delay(domain_name)
def media_files(request, domain, template="appstore/media_files.html"):
dom = Domain.get(domain)
if not can_view_app(request, dom):
raise Http404()
return render(request, template, {
"project": dom,
"url_base": reverse('appstore')
})
def approve_app(request, snapshot):
domain = Domain.get(snapshot)
if request.GET.get('approve') == 'true':
domain.is_approved = True
domain.save()
elif request.GET.get('approve') == 'false':
domain.is_approved = False
domain.save()
return HttpResponseRedirect(request.META.get('HTTP_REFERER') or reverse('appstore'))
def approve_app(request, snapshot):
domain = Domain.get(snapshot)
if request.GET.get('approve') == 'true':
domain.is_approved = True
domain.save()
elif request.GET.get('approve') == 'false':
domain.is_approved = False
domain.save()
return HttpResponseRedirect(request.META.get('HTTP_REFERER') or reverse('appstore'))
def media_files(request, domain, template="appstore/media_files.html"):
dom = Domain.get(domain)
if not can_view_app(request, dom):
raise Http404()
return render(request, template, {
"project": dom,
"url_base": reverse('appstore')
})
def copy_snapshot(request, domain):
user = request.couch_user
if not user.is_eula_signed():
messages.error(request, 'You must agree to our eula to download an app')
return project_info(request, domain)
dom = Domain.get(domain)
if request.method == "POST" and dom.is_snapshot:
assert dom.full_applications(include_builds=False), 'Bad attempt to copy project without any apps!'
from corehq.apps.registration.forms import DomainRegistrationForm
args = {
'domain_name': request.POST['new_project_name'],
'hr_name': request.POST['new_project_name'],
'eula_confirmed': True,
}
form = DomainRegistrationForm(args)
if request.POST.get('new_project_name', ""):
if not dom.published:
messages.error(request, _("This project is not published and can't be downloaded"))
return project_info(request, domain)
if not form.is_valid():
messages.error(request, form.errors)
return project_info(request, domain)
new_domain_name = name_to_url(form.cleaned_data['hr_name'], "project")
with CriticalSection(['copy_domain_snapshot_{}_to_{}'.format(dom.name, new_domain_name)]):
try:
new_domain = dom.save_copy(new_domain_name,
new_hr_name=form.cleaned_data['hr_name'],
user=user)
except NameUnavailableException:
messages.error(request, _("A project by that name already exists"))
return project_info(request, domain)
# sign new project up for trial
create_30_day_trial(new_domain)
def inc_downloads(d):
d.downloads += 1
apply_update(dom, inc_downloads)
messages.success(request, render_to_string("appstore/partials/view_wiki.html",
{"pre": _("Project copied successfully!")}),
extra_tags="html")
return HttpResponseRedirect(reverse('view_app',
args=[new_domain.name, new_domain.full_applications()[0].get_id]))
else:
messages.error(request, _("You must specify a name for the new project"))
return project_info(request, domain)
else:
return HttpResponseRedirect(reverse('project_info', args=[domain]))
def setUp(self):
self.domain_obj = Domain(name="test")
self.domain_obj.save()
# Prevent resource conflict
self.domain_obj = Domain.get(self.domain_obj._id)
self.sms_backend = TestSMSBackend(named="MOBILE_BACKEND_TEST", is_global=True)
self.sms_backend.save()
self.sms_backend_mapping = BackendMapping(is_global=True,prefix="*",backend_id=self.sms_backend._id)
self.sms_backend_mapping.save()
def setup_domain(cls, name):
domain_obj = Domain(name=name, sms_mobile_worker_registration_enabled=True)
domain_obj.save()
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
account = BillingAccount.get_or_create_account_by_domain(
name, created_by="automated-test-" + cls.__name__
)[0]
subscription = Subscription.new_domain_subscription(account, name, plan)
subscription.is_active = True
subscription.save()
domain_obj = Domain.get(domain_obj.get_id)
return (domain_obj, account, subscription)
def setUp(self):
super(QueueingTestCase, self).setUp()
self.domain = 'test-sms-queueing'
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get(self.domain_obj._id)
self.backend, self.backend_mapping = setup_default_sms_test_backend()
self.contact = CommCareUser.create(self.domain, 'user1', 'abc', phone_number='999123')
self.contact.save_verified_number(self.domain, '999123', True)
SmsBillable.objects.filter(domain=self.domain).delete()
QueuedSMS.objects.all().delete()
SMS.objects.filter(domain=self.domain).delete()
def setup_domain(cls, name):
domain_obj = Domain(name=name, sms_mobile_worker_registration_enabled=True)
domain_obj.save()
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
account = BillingAccount.get_or_create_account_by_domain(
name, created_by="automated-test-" + cls.__name__
)[0]
subscription = Subscription.new_domain_subscription(account, name, plan)
subscription.is_active = True
subscription.save()
domain_obj = Domain.get(domain_obj.get_id)
return (domain_obj, account, subscription)
def setUp(self):
# might as well clean house before doing anything
delete_all_xforms()
delete_all_cases()
StockReport.objects.all().delete()
StockTransaction.objects.all().delete()
self.backend = test.bootstrap(TEST_BACKEND, to_console=True)
self.domain = bootstrap_domain()
self.ct_settings = CommtrackConfig.for_domain(self.domain.name)
self.ct_settings.consumption_config = ConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
min_periods=0,
)
if self.requisitions_enabled:
self.ct_settings.requisition_config = get_default_requisition_config(
)
self.ct_settings.save()
self.domain = Domain.get(self.domain._id)
self.loc = make_loc('loc1')
self.sp = make_supply_point(self.domain.name, self.loc)
self.users = [
bootstrap_user(self, **user_def)
for user_def in self.user_definitions
]
if False:
# bootstrap additional users for requisitions
# needs to get reinserted for requisition stuff later
self.approver = bootstrap_user(self, **APPROVER_USER)
self.packer = bootstrap_user(self, **PACKER_USER)
self.users += [self.approver, self.packer]
# everyone should be in a group.
self.group = Group(domain=TEST_DOMAIN,
name='commtrack-folks',
users=[u._id for u in self.users],
case_sharing=True)
self.group.save()
self.sp.owner_id = self.group._id
self.sp.save()
self.products = sorted(Product.by_domain(self.domain.name),
key=lambda p: p._id)
self.assertEqual(3, len(self.products))
def test_exchange_snapshot_view(self):
"""
Tests creating a new exchange snapshot and then creating another snapshot
"""
toggles.DOCUMENTATION_FILE.set(self.user.username, True)
self.client.login(username=self.username, password=self.password)
app_publish = "{}-publish".format(self.app._id)
filename = 'file.txt'
data = {
'title': 'Title',
'short_description': 'Description',
'description': 'Description',
'project_type': 'MCH',
'license': 'cc',
'documentation_file': SimpleUploadedFile(filename, b'contents'),
'publish_on_submit': 'yes',
'cda_confirmed': True,
app_publish: True,
}
response = self.client.post(
reverse(CreateNewExchangeSnapshotView.urlname, args=[self.domain.name]),
data,
follow=True
)
self.assertEqual(response.status_code, 200)
published = self.domain.published_snapshot()
self.assertIsNotNone(published)
self.assertEqual(published.title, data['title'])
self.assertEqual(published.documentation_file_path, filename)
# Should keep documentation file when old_documentation_file is specified
del data['documentation_file']
data['old_documentation_file'] = True
response = self.client.post(
reverse(CreateNewExchangeSnapshotView.urlname, args=[self.domain.name]),
data,
follow=True
)
self.domain = Domain.get(self.domain._id)
self.assertEqual(response.status_code, 200)
snapshots = list(self.domain.snapshots())
self.assertEqual(len(snapshots), 2)
self.assertEqual(snapshots[0].documentation_file_path, filename)
self.assertEqual(snapshots[1].documentation_file_path, filename)
def setUpClass(cls):
Role.get_cache().clear()
generator.instantiate_accounting_for_tests()
cls.domain = Domain.get_or_create_with_name("qwerty", is_active=True)
cls.list_endpoint = reverse(
"api_dispatch_list",
kwargs=dict(domain=cls.domain.name, api_name=cls.api_name, resource_name=cls.resource.Meta.resource_name),
)
cls.username = "******"
cls.password = "******"
cls.user = WebUser.create(cls.domain.name, cls.username, cls.password)
cls.user.set_role(cls.domain.name, "admin")
cls.user.save()
set_up_subscription(cls)
cls.domain = Domain.get(cls.domain._id)
def setUpClass(cls):
Role.get_cache().clear()
generator.instantiate_accounting_for_tests()
cls.domain = Domain.get_or_create_with_name("qwerty", is_active=True)
cls.username = "******"
cls.password = "******"
cls.admin_user = WebUser.create(cls.domain.name, cls.username, cls.password)
cls.admin_user.set_role(cls.domain.name, "admin")
cls.admin_user.save()
cls.fake_user_es = FakeUserES()
v0_5.MOCK_BULK_USER_ES = cls.mock_es_wrapper
cls.make_users()
set_up_subscription(cls)
cls.domain = Domain.get(cls.domain._id)
def setUp(self):
super(CommTrackTest, self).setUp()
# might as well clean house before doing anything
delete_all_xforms()
delete_all_cases()
delete_all_sync_logs()
StockReport.objects.all().delete()
StockTransaction.objects.all().delete()
self.backend, self.backend_mapping = setup_default_sms_test_backend()
self.domain = bootstrap_domain(TEST_DOMAIN)
bootstrap_location_types(self.domain.name)
bootstrap_products(self.domain.name)
self.ct_settings = CommtrackConfig.for_domain(self.domain.name)
self.ct_settings.consumption_config = ConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
min_periods=0,
)
# todo: remove?
if self.requisitions_enabled:
self.ct_settings.requisition_config = get_default_requisition_config(
)
self.ct_settings.save()
self.domain = Domain.get(self.domain._id)
self.loc = make_loc('loc1')
self.sp = self.loc.linked_supply_point()
self.users = [
bootstrap_user(self, **user_def)
for user_def in self.user_definitions
]
# everyone should be in a group.
self.group = Group(domain=TEST_DOMAIN,
name='commtrack-folks',
users=[u._id for u in self.users],
case_sharing=True)
self.group._id = self.sp.owner_id
self.group.save()
self.products = sorted(Product.by_domain(self.domain.name),
key=lambda p: p._id)
self.assertEqual(3, len(self.products))
def test_exchange_snapshot_view(self):
"""
Tests creating a new exchange snapshot and then creating another snapshot
"""
self.client.login(username=self.username, password=self.password)
app_publish = "{}-publish".format(self.app._id)
filename = 'file.txt'
data = {
'title': 'Title',
'short_description': 'Description',
'description': 'Description',
'project_type': 'MCH',
'license': 'cc',
'documentation_file': SimpleUploadedFile(filename, b'contents'),
'publish_on_submit': 'yes',
'cda_confirmed': True,
app_publish: True,
}
response = self.client.post(
reverse(CreateNewExchangeSnapshotView.urlname, args=[self.domain.name]),
data,
follow=True
)
self.assertEqual(response.status_code, 200)
published = self.domain.published_snapshot()
self.assertIsNotNone(published)
self.assertEqual(published.title, data['title'])
self.assertEqual(published.documentation_file_path, filename)
# Should keep documentation file when old_documentation_file is specified
del data['documentation_file']
data['old_documentation_file'] = True
response = self.client.post(
reverse(CreateNewExchangeSnapshotView.urlname, args=[self.domain.name]),
data,
follow=True
)
self.domain = Domain.get(self.domain._id)
self.assertEqual(response.status_code, 200)
snapshots = list(self.domain.snapshots())
self.assertEqual(len(snapshots), 2)
self.assertEqual(snapshots[0].documentation_file_path, filename)
self.assertEqual(snapshots[1].documentation_file_path, filename)
def setUp(self):
# might as well clean house before doing anything
delete_all_xforms()
delete_all_cases()
delete_all_sync_logs()
StockReport.objects.all().delete()
StockTransaction.objects.all().delete()
self.backend = test.bootstrap(TEST_BACKEND, to_console=True)
self.domain = bootstrap_domain()
bootstrap_location_types(self.domain.name)
bootstrap_products(self.domain.name)
self.ct_settings = CommtrackConfig.for_domain(self.domain.name)
self.ct_settings.consumption_config = ConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
min_periods=0,
)
if self.requisitions_enabled:
self.ct_settings.requisition_config = get_default_requisition_config()
self.ct_settings.save()
self.domain = Domain.get(self.domain._id)
self.loc = make_loc('loc1')
self.sp = make_supply_point(self.domain.name, self.loc)
self.users = [bootstrap_user(self, **user_def) for user_def in self.user_definitions]
if False:
# bootstrap additional users for requisitions
# needs to get reinserted for requisition stuff later
self.approver = bootstrap_user(self, **APPROVER_USER)
self.packer = bootstrap_user(self, **PACKER_USER)
self.users += [self.approver, self.packer]
# everyone should be in a group.
self.group = Group(domain=TEST_DOMAIN, name='commtrack-folks',
users=[u._id for u in self.users],
case_sharing=True)
self.group.save()
self.sp.owner_id = self.group._id
self.sp.save()
self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id)
self.assertEqual(3, len(self.products))
def setUp(self):
super(QueueingTestCase, self).setUp()
self.domain = 'test-sms-queueing'
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get(self.domain_obj._id)
self.backend, self.backend_mapping = setup_default_sms_test_backend()
self.contact = CommCareUser.create(self.domain, 'user1', 'abc', None, None, phone_number='999123')
entry = self.contact.get_or_create_phone_entry('999123')
entry.set_two_way()
entry.set_verified()
entry.save()
SmsBillable.objects.filter(domain=self.domain).delete()
QueuedSMS.objects.all().delete()
SMS.objects.filter(domain=self.domain).delete()
def catch_signal(app, **kwargs):
app_name = app.__name__.rsplit(".", 1)[0]
if app_name == _module:
from corehq.apps.appstore.views import es_query
try:
q = {"fields": ["name"]}
result = es_query(params={"internal.using_call_center": True, "is_active": True, "is_snapshot": False}, q=q)
hits = result.get("hits", {}).get("hits", {})
for hit in hits:
domain = Domain.get(hit["_id"])
print(" callcenter bootstap `{}`".format(domain.name))
bootstrap_callcenter(domain)
except RequestException:
if not settings.DEBUG:
logging.exception("Unable to query ES for call-center domains during syncdb")
else:
print("WARNING: unable to query ES for call-center domains", file=sys.stderr)
def project_info(request, domain, template="appstore/project_info.html"):
dom = Domain.get(domain)
if not can_view_app(request, dom):
raise Http404()
copies = dom.copies_of_parent()
images = set()
audio = set()
return render(request, template, {
"project": dom,
"applications": dom.full_applications(include_builds=False),
"fixtures": FixtureDataType.by_domain(dom.name),
"copies": copies,
"images": images,
"audio": audio,
"url_base": reverse('appstore'),
'display_import': True if getattr(request, "couch_user",
"") and request.couch_user.get_domains() else False
})
def setUp(self):
super(RegistrationTestCase, self).setUp()
self.domain = 'sms-reg-test-domain'
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get(self.domain_obj.get_id)
self.backend = SQLTestSMSBackend.objects.create(
name='BACKEND',
is_global=False,
domain=self.domain,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend)
def copy_snapshot(request, domain):
user = request.couch_user
if not user.is_eula_signed():
messages.error(request, 'You must agree to our eula to download an app')
return project_info(request, domain)
dom = Domain.get(domain)
if request.method == "POST" and dom.is_snapshot:
from corehq.apps.registration.forms import DomainRegistrationForm
args = {'domain_name': request.POST['new_project_name'], 'eula_confirmed': True}
form = DomainRegistrationForm(args)
if request.POST.get('new_project_name', ""):
if not dom.published:
messages.error(request, "This project is not published and can't be downloaded")
return project_info(request, domain)
if form.is_valid():
new_domain = dom.save_copy(form.cleaned_data['domain_name'], user=user)
else:
messages.error(request, form.errors)
return project_info(request, domain)
if new_domain is None:
messages.error(request, _("A project by that name already exists"))
return project_info(request, domain)
def inc_downloads(d):
d.downloads += 1
apply_update(dom, inc_downloads)
# sign project up for trial
create_30_day_trial(new_domain)
messages.success(request, render_to_string("appstore/partials/view_wiki.html", {"pre": _("Project copied successfully!")}), extra_tags="html")
return HttpResponseRedirect(reverse('view_app',
args=[new_domain.name, new_domain.full_applications()[0].get_id]))
else:
messages.error(request, _("You must specify a name for the new project"))
return project_info(request, domain)
else:
return HttpResponseRedirect(reverse('project_info', args=[domain]))
def setUp(self):
super(CommTrackTest, self).setUp()
# might as well clean house before doing anything
delete_all_xforms()
delete_all_cases()
delete_all_sync_logs()
StockReport.objects.all().delete()
StockTransaction.objects.all().delete()
self.backend, self.backend_mapping = setup_default_sms_test_backend()
self.domain = bootstrap_domain(TEST_DOMAIN)
bootstrap_location_types(self.domain.name)
bootstrap_products(self.domain.name)
self.ct_settings = CommtrackConfig.for_domain(self.domain.name)
self.ct_settings.consumption_config = ConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
min_periods=0,
)
# todo: remove?
if self.requisitions_enabled:
self.ct_settings.requisition_config = get_default_requisition_config()
self.ct_settings.save()
self.domain = Domain.get(self.domain._id)
self.loc = make_loc('loc1')
self.sp = self.loc.linked_supply_point()
self.users = [bootstrap_user(self, **user_def) for user_def in self.user_definitions]
# everyone should be in a group.
self.group = Group(domain=TEST_DOMAIN, name='commtrack-folks',
users=[u._id for u in self.users],
case_sharing=True)
self.group._id = self.sp.owner_id
self.group.save()
self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id)
self.assertEqual(3, len(self.products))
def setUp(self):
super(RegistrationTestCase, self).setUp()
self.domain = 'sms-reg-test-domain'
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get(self.domain_obj.get_id)
self.backend = SQLTestSMSBackend.objects.create(
name='BACKEND',
is_global=False,
domain=self.domain,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend)
self.app_id = 'app_id'
def setUp(self):
super(XMLTest, self).setUp()
self.domain = util.bootstrap_domain(util.TEST_DOMAIN)
util.bootstrap_location_types(self.domain.name)
util.bootstrap_products(self.domain.name)
self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id)
self.ct_settings = CommtrackConfig.for_domain(self.domain.name)
self.ct_settings.consumption_config = ConsumptionConfig(
min_transactions=0,
min_window=0,
optimal_window=60,
min_periods=0,
)
self.ct_settings.save()
self.domain = Domain.get(self.domain._id)
self.loc = make_loc('loc1')
self.sp = self.loc.linked_supply_point()
self.users = [util.bootstrap_user(self, **user_def) for user_def in self.user_definitions]
self.user = self.users[0]
def project_info(request, domain, template="appstore/project_info.html"):
dom = Domain.get(domain)
if not can_view_app(request, dom):
raise Http404()
if request.method == "POST" and dom.copied_from.name not in request.couch_user.get_domains(
):
form = AddReviewForm(request.POST)
if form.is_valid():
title = form.cleaned_data['review_title']
rating = int(request.POST.get('rating'))
if rating < 1:
rating = 1
if rating > 5:
rating = 5
info = form.cleaned_data['review_info']
date_published = datetime.now()
user = request.user.username
old_review = Review.get_by_version_and_user(domain, user)
if len(old_review) > 0: # replace old review
review = old_review[0]
review.title = title
review.rating = rating
review.info = info
review.date_published = date_published
else:
review = Review(title=title,
rating=rating,
user=user,
info=info,
date_published=date_published,
domain=domain,
project_id=dom.copied_from._id)
review.save()
else:
form = AddReviewForm()
else:
form = AddReviewForm()
copies = dom.copies_of_parent()
reviews = Review.get_by_app(dom.copied_from._id)
average_rating = Review.get_average_rating_by_app(dom.copied_from._id)
num_ratings = Review.get_num_ratings_by_app(dom.copied_from._id)
if average_rating:
average_rating = round(average_rating, 1)
images = set()
audio = set()
return render(
request, template, {
"project":
dom,
"applications":
dom.full_applications(include_builds=False),
"form":
form,
"copies":
copies,
"reviews":
reviews,
"average_rating":
average_rating,
"num_ratings":
num_ratings,
"images":
images,
"audio":
audio,
"url_base":
reverse('appstore'),
'display_import':
True if getattr(request, "couch_user", "")
and request.couch_user.get_domains() else False
})
def copy_snapshot(request, domain):
user = request.couch_user
if not user.is_eula_signed():
messages.error(request,
'You must agree to our eula to download an app')
return project_info(request, domain)
dom = Domain.get(domain)
if request.method == "POST" and dom.is_snapshot:
assert dom.full_applications(
include_builds=False
), 'Bad attempt to copy project without any apps!'
from corehq.apps.registration.forms import DomainRegistrationForm
args = {
'domain_name': request.POST['new_project_name'],
'hr_name': request.POST['new_project_name'],
'eula_confirmed': True,
}
form = DomainRegistrationForm(args)
if request.POST.get('new_project_name', ""):
if not dom.published:
messages.error(
request,
_("This project is not published and can't be downloaded"))
return project_info(request, domain)
if not form.is_valid():
messages.error(request, form.errors)
return project_info(request, domain)
new_domain_name = form.cleaned_data['hr_name']
with CriticalSection([
'copy_domain_snapshot_{}_to_{}'.format(
dom.name, new_domain_name)
]):
try:
new_domain = dom.save_copy(
new_domain_name,
new_hr_name=form.cleaned_data['hr_name'],
user=user)
except NameUnavailableException:
messages.error(request,
_("A project by that name already exists"))
return project_info(request, domain)
# sign new project up for trial
create_30_day_trial(new_domain)
def inc_downloads(d):
d.downloads += 1
apply_update(dom, inc_downloads)
messages.success(request,
render_to_string(
"appstore/partials/view_wiki.html",
{"pre": _("Project copied successfully!")}),
extra_tags="html")
return HttpResponseRedirect(
reverse('view_app',
args=[
new_domain.name,
new_domain.full_applications()[0].get_id
]))
else:
messages.error(request,
_("You must specify a name for the new project"))
return project_info(request, domain)
else:
return HttpResponseRedirect(reverse('project_info', args=[domain]))
def project(self):
return Domain.get(self.snapshot)
def project(self):
try:
return Domain.get(self.snapshot)
except ResourceNotFound:
return Domain.get_by_name(self.snapshot)
def project(self):
return Domain.get(self.snapshot)
def _save_settings_and_clear_cache(self):
# since the commtrack settings object is stored as a memoized property on the domain
# we need to refresh that as well
self.ct_settings.save()
self.domain = Domain.get(self.domain._id)
def fetch_latest_doc(dom1_id, dom2_id):
dom1 = Domain.get(dom1_id)
dom2 = Domain.get(dom2_id)
assert dom1.name == dom2.name
return dom2 if dom1.last_modified < dom2.last_modified else dom1
def testOutbound(self):
# Send an outbound call using self.reminder1 to self.case
# and answer it
CaseReminderHandler.now = datetime(2014, 6, 23, 10, 0)
self.case = CommCareCase.get(
register_sms_contact(
self.domain,
'participant',
'case1',
self.user1._id,
'91000',
owner_id=self.groups[0]._id,
))
CaseReminderHandler.now = datetime(2014, 6, 23, 12, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 12, 30))
call = self.get_last_outbound_call(self.case)
self.assertTrue(call.use_precached_first_response)
kookoo_session_id = call.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call = CallLog.get(call._id)
self.assertTrue(call.answered)
self.assertEqual(call.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "1")
self.assertFormQuestionEquals(form, "take_meds", "2")
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "1")
self.assertCasePropertyEquals(case, "take_meds", "2")
CaseReminderHandler.now = datetime(2014, 6, 23, 12, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 0))
last_call = self.get_last_outbound_call(self.case)
self.assertEqual(call._id, last_call._id)
# Move on to the second event which now uses an all-label form and
# should not precache the first ivr response
CaseReminderHandler.now = datetime(2014, 6, 23, 13, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 30))
call = self.get_last_outbound_call(self.case)
self.assertFalse(call.use_precached_first_response)
kookoo_session_id = call.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s">'
'<playtext>This is just a reminder to take your meds.'
'</playtext><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "5",
})
call = CallLog.get(call._id)
self.assertTrue(call.answered)
self.assertEqual(call.duration, 5)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "label", "ok")
CaseReminderHandler.now = datetime(2014, 6, 23, 13, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0))
last_call = self.get_last_outbound_call(self.case)
self.assertEqual(call._id, last_call._id)
# Now test sending outbound calls to a group of users (the owners
# of the case)
# Allow sending to unverified numbers
self.domain_obj = Domain.get(self.domain_obj._id)
self.domain_obj.send_to_duplicated_case_numbers = True
self.domain_obj.save()
CaseReminderHandler.now = datetime(2014, 6, 24, 10, 0)
self.case = CommCareCase.get(
register_sms_contact(
self.domain,
'participant',
'case2',
self.user1._id,
'91003',
owner_id=self.groups[0]._id,
))
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0))
CaseReminderHandler.now = datetime(2014, 6, 24, 12, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 30))
call1 = self.get_last_outbound_call(self.user1)
self.assertTrue(call1.use_precached_first_response)
self.assertFalse(call1.answered)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertFalse(call2.answered)
old_call1 = call1
old_call2 = call2
CaseReminderHandler.now = datetime(2014, 6, 24, 12, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 13, 0))
call1 = self.get_last_outbound_call(self.user1)
self.assertTrue(call1.use_precached_first_response)
self.assertNotEqual(call1._id, old_call1._id)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertFalse(call2.answered)
self.assertNotEqual(call2._id, old_call2._id)
kookoo_session_id = call1.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call1 = CallLog.get(call1._id)
self.assertTrue(call1.answered)
self.assertEqual(call1.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "2")
self.assertFormQuestionEquals(form, "take_meds", "1")
self.assertEqual(form.form["meta"]["userID"], self.user1._id)
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "2")
self.assertCasePropertyEquals(case, "take_meds", "1")
self.assertEqual(case.user_id, self.user1._id)
old_call1 = call1
old_call2 = call2
CaseReminderHandler.now = datetime(2014, 6, 24, 13, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 25, 12, 0))
call1 = self.get_last_outbound_call(self.user1)
# No new call for user1 since it was already answered
self.assertEqual(call1._id, old_call1._id)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertNotEqual(call2._id, old_call2._id)
kookoo_session_id = call2.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call2 = CallLog.get(call2._id)
self.assertTrue(call2.answered)
self.assertEqual(call2.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "1")
self.assertFormQuestionEquals(form, "take_meds", "2")
self.assertEqual(form.form["meta"]["userID"], self.user2._id)
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "1")
self.assertCasePropertyEquals(case, "take_meds", "2")
self.assertEqual(case.user_id, self.user2._id)
def project(self):
try:
return Domain.get(self.snapshot)
except ResourceNotFound:
return Domain.get_by_name(self.snapshot)
def setUp(self):
self.domain = "test-domain"
self.domain2 = "test-domain2"
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.domain_obj = Domain.get(
self.domain_obj._id) # Prevent resource conflict
self.backend1 = TestCaseBackend(name="BACKEND1", is_global=True)
self.backend1.save()
self.backend2 = TestCaseBackend(name="BACKEND2", is_global=True)
self.backend2.save()
self.backend3 = TestCaseBackend(name="BACKEND3", is_global=True)
self.backend3.save()
self.backend4 = TestCaseBackend(name="BACKEND4", is_global=True)
self.backend4.save()
self.backend5 = TestCaseBackend(name="BACKEND5",
domain=self.domain,
is_global=False,
authorized_domains=[])
self.backend5.save()
self.backend6 = TestCaseBackend(name="BACKEND6",
domain=self.domain2,
is_global=False,
authorized_domains=[self.domain])
self.backend6.save()
self.backend7 = TestCaseBackend(name="BACKEND7",
domain=self.domain2,
is_global=False,
authorized_domains=[])
self.backend7.save()
self.backend8 = TestCaseBackend(name="BACKEND",
domain=self.domain,
is_global=False,
authorized_domains=[])
self.backend8.save()
self.backend9 = TestCaseBackend(name="BACKEND",
domain=self.domain2,
is_global=False,
authorized_domains=[self.domain])
self.backend9.save()
self.backend10 = TestCaseBackend(name="BACKEND", is_global=True)
self.backend10.save()
self.backend_mapping1 = BackendMapping(is_global=True,
prefix="*",
backend_id=self.backend1._id)
self.backend_mapping1.save()
self.backend_mapping2 = BackendMapping(is_global=True,
prefix="1",
backend_id=self.backend2._id)
self.backend_mapping2.save()
self.backend_mapping3 = BackendMapping(is_global=True,
prefix="91",
backend_id=self.backend3._id)
self.backend_mapping3.save()
self.backend_mapping4 = BackendMapping(is_global=True,
prefix="265",
backend_id=self.backend4._id)
self.backend_mapping4.save()
self.case = CommCareCase(domain=self.domain)
self.case.set_case_property("contact_phone_number", "15551234567")
self.case.set_case_property("contact_phone_number_is_verified", "1")
self.case.save()
self.contact = CommConnectCase.wrap(self.case.to_json())
settings.SMS_LOADED_BACKENDS.append(
"corehq.apps.sms.tests.TestCaseBackend")
