Ejemplo n.º 1
0
 def settings_form(self):
     language_choices = langcodes.get_all_langs_for_select()
     api_key_status, api_key_exists = self.get_api_key_status()
     from corehq.apps.users.forms import UpdateMyAccountInfoForm
     try:
         domain = self.request.domain
     except AttributeError:
         domain = ''
     if self.request.method == 'POST':
         form = UpdateMyAccountInfoForm(
             self.request.POST,
             api_key_status=api_key_status,
             api_key_exists=api_key_exists,
             domain=domain,
             existing_user=self.request.couch_user,
         )
     else:
         form = UpdateMyAccountInfoForm(
             api_key_status=api_key_status,
             api_key_exists=api_key_exists,
             domain=domain,
             existing_user=self.request.couch_user,
         )
     form.load_language(language_choices)
     return form
Ejemplo n.º 2
0
class PullResourceForm(forms.Form):
    transifex_project_slug = forms.ChoiceField(
        label=ugettext_lazy("Trasifex project"), choices=())
    target_lang = forms.ChoiceField(
        label=ugettext_lazy("Target Language"),
        choices=langcodes.get_all_langs_for_select(),
        initial="en")
    resource_slug = forms.CharField(
        label=_("Resource Slug"),
        required=False,
        help_text=ugettext_lazy("Leave blank to fetch full project"))

    def __init__(self, domain, *args, **kwargs):
        super(PullResourceForm, self).__init__(*args, **kwargs)
        self.domain = domain
        self.helper = FormHelper()
        self.helper.form_tag = False
        self.helper.label_class = 'col-sm-3 col-md-4 col-lg-2'
        self.helper.field_class = 'col-sm-4 col-md-5 col-lg-3'

        projects = TransifexProject.objects.filter(domain=domain).all()
        if projects:
            self.fields['transifex_project_slug'].choices = (tuple(
                (project.slug, project) for project in projects))
        self.helper.layout = crispy.Layout(
            'transifex_project_slug',
            crispy.Field('target_lang', css_class="ko-select2"),
            'resource_slug',
            hqcrispy.FormActions(
                twbscrispy.StrictButton(
                    ugettext_lazy("Submit"),
                    type="submit",
                    css_class="btn-primary",
                )))
Ejemplo n.º 3
0
class PullResourceForm(forms.Form):
    transifex_project_slug = forms.ChoiceField(
        label=ugettext_lazy("Trasifex project"), choices=(), required=True)
    target_lang = forms.ChoiceField(
        label=ugettext_lazy("Target Language"),
        choices=langcodes.get_all_langs_for_select(),
        initial="en")
    resource_slug = forms.CharField(label=_("Resource Slug"))

    def __init__(self, domain, *args, **kwargs):
        super(PullResourceForm, self).__init__(*args, **kwargs)
        self.domain = domain
        self.helper = FormHelper()
        self.helper.form_tag = False
        self.helper.label_class = 'col-sm-3 col-md-4 col-lg-2'
        self.helper.field_class = 'col-sm-4 col-md-5 col-lg-3'

        if settings.TRANSIFEX_DETAILS:
            self.fields['transifex_project_slug'].choices = (tuple(
                (slug, slug) for slug in settings.TRANSIFEX_DETAILS.get(
                    'project').get(domain)))
        self.helper.layout = crispy.Layout(
            'transifex_project_slug',
            crispy.Field('target_lang', css_class="ko-select2"),
            'resource_slug',
            hqcrispy.FormActions(
                twbscrispy.StrictButton(
                    ugettext_lazy("Submit"),
                    type="submit",
                    css_class="btn-primary",
                )))
Ejemplo n.º 4
0
 def settings_form(self):
     language_choices = langcodes.get_all_langs_for_select()
     from corehq.apps.users.forms import UpdateMyAccountInfoForm
     if self.request.method == 'POST':
         form = UpdateMyAccountInfoForm(self.request.POST)
     else:
         form = UpdateMyAccountInfoForm()
     form.initialize_form(existing_user=self.request.couch_user)
     form.load_language(language_choices)
     return form
Ejemplo n.º 5
0
 def settings_form(self):
     language_choices = langcodes.get_all_langs_for_select()
     from corehq.apps.users.forms import UpdateMyAccountInfoForm
     if self.request.method == 'POST':
         form = UpdateMyAccountInfoForm(self.request.POST)
     else:
         form = UpdateMyAccountInfoForm()
     form.initialize_form(existing_user=self.request.couch_user)
     form.load_language(language_choices)
     return form
Ejemplo n.º 6
0
class CreateAppTranslationsForm(AppTranslationsForm):
    form_action = 'create'
    source_lang = forms.ChoiceField(label=ugettext_lazy("Source Language on Transifex"),
                                    choices=langcodes.get_all_langs_for_select(),
                                    initial="en"
                                    )

    def form_fields(self):
        form_fields = super(CreateAppTranslationsForm, self).form_fields()
        form_fields.append(hqcrispy.Field('source_lang', css_class="ko-select2"))
        return form_fields
Ejemplo n.º 7
0
def get_domain_languages(domain):
    app_languages = get_app_languages(domain)
    translations = SMSTranslations.objects.filter(domain=domain).first()
    sms_languages = translations.langs if translations else []

    domain_languages = []
    for lang_code in app_languages.union(sms_languages):
        name = langcodes.get_name(lang_code)
        label = "{} ({})".format(lang_code, name) if name else lang_code
        domain_languages.append((lang_code, label))

    return sorted(domain_languages) or langcodes.get_all_langs_for_select()
Ejemplo n.º 8
0
def get_domain_languages(domain):
    query = AppES().domain(domain).terms_aggregation("langs", "languages").size(0)
    app_languages = query.run().aggregations.languages.keys

    translation_doc = StandaloneTranslationDoc.get_obj(domain, "sms")
    sms_languages = translation_doc.langs if translation_doc else []

    domain_languages = []
    for lang_code in set(app_languages + sms_languages):
        name = langcodes.get_name(lang_code)
        label = u"{} ({})".format(lang_code, name) if name else lang_code
        domain_languages.append((lang_code, label))

    return sorted(domain_languages) or langcodes.get_all_langs_for_select()
Ejemplo n.º 9
0
def get_domain_languages(domain):
    query = (AppES().domain(domain).terms_aggregation('langs',
                                                      'languages').size(0))
    app_languages = query.run().aggregations.languages.keys

    translation_doc = StandaloneTranslationDoc.get_obj(domain, 'sms')
    sms_languages = translation_doc.langs if translation_doc else []

    domain_languages = []
    for lang_code in set(app_languages + sms_languages):
        name = langcodes.get_name(lang_code)
        label = u"{} ({})".format(lang_code, name) if name else lang_code
        domain_languages.append((lang_code, label))

    return sorted(domain_languages) or langcodes.get_all_langs_for_select()
Ejemplo n.º 10
0
 def language_choices(self):
     language_choices = []
     results = []
     if self.domain:
         results = get_db().view('languages/list', startkey=[self.domain], endkey=[self.domain, {}], group='true').all()
     if results:
         for result in results:
             lang_code = result['key'][1]
             label = result['key'][1]
             long_form = langcodes.get_name(lang_code)
             if long_form:
                 label += " (" + langcodes.get_name(lang_code) + ")"
             language_choices.append((lang_code, label))
     else:
         language_choices = langcodes.get_all_langs_for_select()
     return language_choices
Ejemplo n.º 11
0
 def language_choices(self):
     language_choices = []
     results = []
     if self.domain:
         results = get_db().view('languages/list', startkey=[self.domain], endkey=[self.domain, {}], group='true').all()
     if results:
         for result in results:
             lang_code = result['key'][1]
             label = result['key'][1]
             long_form = langcodes.get_name(lang_code)
             if long_form:
                 label += " (" + langcodes.get_name(lang_code) + ")"
             language_choices.append((lang_code, label))
     else:
         language_choices = langcodes.get_all_langs_for_select()
     return language_choices
Ejemplo n.º 12
0
def get_domain_languages(domain):
    query = (AppES()
             .domain(domain)
             .terms_facet('langs', 'languages')
             .size(0))
    app_languages = query.run().facets.languages.terms

    translation_doc = StandaloneTranslationDoc.get_obj(domain, 'sms')
    sms_languages = translation_doc.langs if translation_doc else []

    domain_languages = []
    for lang_code in set(app_languages + sms_languages):
        name = langcodes.get_name(lang_code)
        label = u"{} ({})".format(lang_code, name) if name else lang_code
        domain_languages.append((lang_code, label))

    return sorted(domain_languages) or langcodes.get_all_langs_for_select()
Ejemplo n.º 13
0
def get_domain_languages(domain):
    app_languages = [
        res["key"][1]
        for res in Application.get_db()
        .view("languages/list", startkey=[domain], endkey=[domain, {}], group="true")
        .all()
    ]

    translation_doc = StandaloneTranslationDoc.get_obj(domain, "sms")
    sms_languages = translation_doc.langs if translation_doc else []

    domain_languages = []
    for lang_code in set(app_languages + sms_languages):
        name = langcodes.get_name(lang_code)
        label = u"{} ({})".format(lang_code, name) if name else lang_code
        domain_languages.append((lang_code, label))

    return sorted(domain_languages) or langcodes.get_all_langs_for_select()
Ejemplo n.º 14
0
def get_domain_languages(domain):
    app_languages = [
        res['key'][1] for res in Application.get_db().view('languages/list',
                                                           startkey=[domain],
                                                           endkey=[domain, {}],
                                                           group='true').all()
    ]

    translation_doc = StandaloneTranslationDoc.get_obj(domain, 'sms')
    sms_languages = translation_doc.langs if translation_doc else []

    domain_languages = []
    for lang_code in set(app_languages + sms_languages):
        name = langcodes.get_name(lang_code)
        label = u"{} ({})".format(lang_code, name) if name else lang_code
        domain_languages.append((lang_code, label))

    return sorted(domain_languages) or langcodes.get_all_langs_for_select()
Ejemplo n.º 15
0
 def settings_form(self):
     language_choices = langcodes.get_all_langs_for_select()
     api_key = self.get_or_create_api_key()
     from corehq.apps.users.forms import UpdateMyAccountInfoForm
     if self.request.method == 'POST':
         form = UpdateMyAccountInfoForm(self.request.POST,
                                        user=self.request.couch_user,
                                        api_key=api_key)
     else:
         form = UpdateMyAccountInfoForm(user=self.request.couch_user,
                                        api_key=api_key)
     try:
         domain = self.request.domain
     except AttributeError:
         domain = ''
     form.initialize_form(domain, existing_user=self.request.couch_user)
     form.load_language(language_choices)
     return form
Ejemplo n.º 16
0
    def settings_form(self):
        language_choices = langcodes.get_all_langs_for_select()
        api_key = self.get_or_create_api_key()
        from corehq.apps.users.forms import UpdateMyAccountInfoForm

        if self.request.method == "POST":
            form = UpdateMyAccountInfoForm(
                self.request.POST, username=self.request.couch_user.username, api_key=api_key
            )
        else:
            form = UpdateMyAccountInfoForm(username=self.request.couch_user.username, api_key=api_key)
        try:
            domain = self.request.domain
        except AttributeError:
            domain = ""
        form.initialize_form(domain, existing_user=self.request.couch_user)
        form.load_language(language_choices)
        return form
Ejemplo n.º 17
0
 def settings_form(self):
     language_choices = langcodes.get_all_langs_for_select()
     api_key = self.get_or_create_api_key()
     from corehq.apps.users.forms import UpdateMyAccountInfoForm
     try:
         domain = self.request.domain
     except AttributeError:
         domain = ''
     if self.request.method == 'POST':
         form = UpdateMyAccountInfoForm(
             self.request.POST,
             api_key=api_key,
             domain=domain,
             existing_user=self.request.couch_user,
         )
     else:
         form = UpdateMyAccountInfoForm(
             api_key=api_key,
             domain=domain,
             existing_user=self.request.couch_user,
         )
     form.load_language(language_choices)
     return form
Ejemplo n.º 18
0
def _handle_user_form(request, domain, couch_user=None):
    context = {}
    if couch_user:
        create_user = False
    else:
        create_user = True
    can_change_admin_status = ((request.user.is_superuser or request.couch_user.can_edit_web_users(domain=domain))
        and request.couch_user.user_id != couch_user.user_id)

    if couch_user.is_commcare_user():
        role_choices = UserRole.commcareuser_role_choices(domain)
    else:
        role_choices = UserRole.role_choices(domain)

    results = get_db().view('languages/list', startkey=[domain], endkey=[domain, {}], group='true').all()
    language_choices = []

    if results:
        for result in results:
            lang_code = result['key'][1]
            label = result['key'][1]
            long_form = langcodes.get_name(lang_code)
            if long_form:
                label += " (" + langcodes.get_name(lang_code) + ")"
            language_choices.append((lang_code, label))
    else:
        language_choices = langcodes.get_all_langs_for_select()

    if request.method == "POST" and request.POST['form_type'] == "basic-info":
        if couch_user.is_commcare_user():
            form = UserForm(request.POST, role_choices=role_choices, language_choices=language_choices)
        else:
            form = WebUserForm(request.POST, role_choices=role_choices, language_choices=language_choices)
        if form.is_valid():
            if create_user:
                django_user = User()
                django_user.username = form.cleaned_data['email']
                django_user.save()
                couch_user = CouchUser.from_django_user(django_user)
            if couch_user.is_current_web_user(request) or couch_user.is_commcare_user():
                couch_user.first_name = form.cleaned_data['first_name']
                couch_user.last_name = form.cleaned_data['last_name']
                couch_user.email = form.cleaned_data['email']
                if not couch_user.is_commcare_user():
                    couch_user.email_opt_in = form.cleaned_data['email_opt_in']
                couch_user.language = form.cleaned_data['language']
            if can_change_admin_status:
                role = form.cleaned_data['role']
                if role:
                    couch_user.set_role(domain, role)
            couch_user.save()
            if request.couch_user.get_id == couch_user.get_id and couch_user.language:
                # update local language in the session
                request.session['django_language'] = couch_user.language

            messages.success(request, 'Changes saved for user "%s"' % couch_user.username)
    else:
        form = UserForm(role_choices=role_choices, language_choices=language_choices)
        if couch_user.is_commcare_user():
            form = UserForm(role_choices=role_choices, language_choices=language_choices)
        else:
            form = WebUserForm(role_choices=role_choices, language_choices=language_choices)

        if not create_user:
            form.initial['first_name'] = couch_user.first_name
            form.initial['last_name'] = couch_user.last_name
            form.initial['email'] = couch_user.email
            form.initial['email_opt_in'] = couch_user.email_opt_in
            form.initial['language'] = couch_user.language
            if can_change_admin_status:
                if couch_user.is_commcare_user():
                    role = couch_user.get_role(domain)
                    if role is None:
                        initial = "none"
                    else:
                        initial = role.get_qualified_id()
                    form.initial['role'] = initial
                else:
                    form.initial['role'] = couch_user.get_role(domain, include_teams=False).get_qualified_id() or ''

    if not can_change_admin_status:
        del form.fields['role']

    context.update({"form": form,
                    "current_users_page": couch_user.is_current_web_user(request)})
    return context
Ejemplo n.º 19
0
class ScheduledReportForm(forms.Form):
    config_ids = forms.MultipleChoiceField(
        label="Saved report(s)",
        validators=[MinLengthValidator(1)],
        help_text='Note: not all built-in reports support email delivery, so'
                  ' some of your saved reports may not appear in this list')

    interval = forms.TypedChoiceField(
        label='Interval',
        choices=[("daily", "Daily"), ("weekly", "Weekly"), ("monthly", "Monthly")])

    day = forms.TypedChoiceField(
        label="Day",
        coerce=int,
        required=False,
        choices=[(i, i) for i in range(0, 32)])

    hour = forms.TypedChoiceField(
        label='Time',
        coerce=int,
        choices=ReportNotification.hour_choices())

    send_to_owner = forms.BooleanField(
        label='Send to me',
        required=False)

    attach_excel = forms.BooleanField(
        label='Attach Excel Report',
        required=False)

    recipient_emails = MultiEmailField(
        label='Other recipients',
        required=False)

    language = forms.ChoiceField(
        label='Language',
        required=False,
        choices=[('', '')] + langcodes.get_all_langs_for_select(),
        widget=LanguageSelect()
    )

    def __init__(self, *args, **kwargs):
        self.helper = FormHelper()
        self.helper.form_class = 'form-horizontal'
        self.helper.form_id = 'id-scheduledReportForm'
        self.helper.add_layout(
            crispy.Layout(
                'config_ids',
                'interval',
                'day',
                'hour',
                'send_to_owner',
                'attach_excel',
                'recipient_emails',
                'language',
                crispy.HTML(
                    render_to_string('reports/partials/privacy_disclaimer.html')
                )
            )
        )
        self.helper.add_input(crispy.Submit('submit_btn', 'Submit'))

        super(ScheduledReportForm, self).__init__(*args, **kwargs)

    def clean(self):
        cleaned_data = super(ScheduledReportForm, self).clean()
        if cleaned_data["interval"] == "daily":
            del cleaned_data["day"]
        _verify_email(cleaned_data)
        return cleaned_data
Ejemplo n.º 20
0
class ScheduledReportForm(forms.Form):
    INTERVAL_CHOICES = [("daily", _("Daily")), ("weekly", _("Weekly")),
                        ("monthly", _("Monthly"))]

    config_ids = forms.MultipleChoiceField(
        label=_("Saved report(s)"),
        validators=[MinLengthValidator(1)],
        help_text='Note: not all built-in reports support email delivery, so'
        ' some of your saved reports may not appear in this list')

    interval = forms.TypedChoiceField(label=_('Interval'),
                                      widget=SelectToggle(
                                          choices=INTERVAL_CHOICES,
                                          apply_bindings=True),
                                      choices=INTERVAL_CHOICES)

    day = forms.TypedChoiceField(label=_("Day"),
                                 coerce=int,
                                 required=False,
                                 choices=[(i, i) for i in range(0, 32)])

    hour = forms.TypedChoiceField(label=_('Time'),
                                  coerce=int,
                                  choices=ReportNotification.hour_choices())

    start_date = forms.DateField(label=_('Report Start Date'), required=False)

    send_to_owner = forms.BooleanField(label=_('Send to owner'),
                                       required=False)

    attach_excel = forms.BooleanField(label=_('Attach Excel Report'),
                                      required=False)

    recipient_emails = MultiEmailField(label=_('Other recipients'),
                                       required=False)
    email_subject = forms.CharField(
        required=False,
        help_text=
        'Translated into recipient\'s language if set to "%(default_subject)s".'
        % {
            'default_subject': DEFAULT_REPORT_NOTIF_SUBJECT,
        },
    )

    language = forms.ChoiceField(label=_('Language'),
                                 required=False,
                                 choices=[('', '')] +
                                 langcodes.get_all_langs_for_select(),
                                 widget=forms.Select())

    def __init__(self, *args, **kwargs):
        super(ScheduledReportForm, self).__init__(*args, **kwargs)

        self.helper = FormHelper()
        self.helper.form_class = 'form-horizontal'
        self.helper.form_id = 'id-scheduledReportForm'
        self.helper.label_class = 'col-sm-3 col-md-2'
        self.helper.field_class = 'col-sm-9 col-md-8 col-lg-6'

        domain = kwargs.get('initial', {}).get('domain', None)
        if domain is not None and HOURLY_SCHEDULED_REPORT.enabled(
                domain, NAMESPACE_DOMAIN):
            self.fields['interval'].choices.insert(
                0, ("hourly", gettext("Hourly")))
            self.fields['interval'].widget.choices.insert(
                0, ("hourly", gettext("Hourly")))

        self.helper.add_layout(
            crispy.Layout(
                crispy.Fieldset(
                    gettext("Configure Scheduled Report"), 'config_ids',
                    'interval', 'day', 'hour', 'start_date',
                    crispy.Field(
                        'email_subject',
                        css_class='input-xlarge',
                    ), crispy.Field('send_to_owner'),
                    crispy.Field('attach_excel'), 'recipient_emails',
                    'language',
                    crispy.HTML(
                        render_to_string(
                            'reports/partials/privacy_disclaimer.html'))),
                FormActions(crispy.Submit('submit_btn', 'Submit'))))

    def clean(self):
        cleaned_data = super(ScheduledReportForm, self).clean()
        if cleaned_data.get("interval") == "daily":
            del cleaned_data["day"]
        if cleaned_data.get("interval") == "hourly":
            del cleaned_data["day"]
            del cleaned_data["hour"]
        _verify_email(cleaned_data)
        return cleaned_data
Ejemplo n.º 21
0
class AppTranslationsForm(forms.Form):
    app_id = forms.ChoiceField(label=ugettext_lazy("Application"),
                               choices=(),
                               required=True)
    version = forms.IntegerField(
        label=ugettext_lazy("Application Version"),
        required=False,
        help_text=ugettext_lazy("Leave blank to use current saved state"))
    use_version_postfix = forms.MultipleChoiceField(
        choices=[
            ('yes', 'Track resources per version'),
        ],
        widget=forms.CheckboxSelectMultiple(),
        required=False,
        initial='no',
        help_text=ugettext_lazy(
            "Check this if you want to maintain different resources separately for different "
            "versions of the application. Leave it unchecked for continuous update to the same"
            " set of resources"))
    transifex_project_slug = forms.ChoiceField(
        label=ugettext_lazy("Trasifex project"), choices=(), required=True)
    target_lang = forms.ChoiceField(
        label=ugettext_lazy("Translated Language"),
        choices=([(None, ugettext_lazy('Select Translated Language'))] +
                 langcodes.get_all_langs_for_select()),
        required=False,
    )
    action = forms.CharField(widget=forms.HiddenInput)
    perform_translated_check = forms.BooleanField(label=ugettext_lazy(
        "Confirm that resources are completely translated before performing request"
    ),
                                                  required=False,
                                                  initial=True)

    def __init__(self, domain, *args, **kwargs):
        super(AppTranslationsForm, self).__init__(*args, **kwargs)
        self.domain = domain
        self.helper = FormHelper()
        self.helper.form_tag = False
        self.helper.label_class = 'col-sm-4 col-md-4 col-lg-3'
        self.helper.field_class = 'col-sm-6 col-md-6 col-lg-5'

        self.fields['app_id'].choices = tuple(
            (app.id, app.name) for app in get_brief_apps_in_domain(domain))
        projects = TransifexProject.objects.filter(domain=domain).all()
        if projects:
            self.fields['transifex_project_slug'].choices = (tuple(
                (project.slug, project) for project in projects))
        form_fields = self.form_fields()
        form_fields.append(
            hqcrispy.Field(
                StrictButton(
                    ugettext_lazy("Submit"),
                    type="submit",
                    css_class="btn btn-primary btn-lg disable-on-submit",
                    onclick="return confirm('%s')" %
                    ugettext_lazy("Please confirm that you want to proceed?")))
        )
        self.helper.layout = crispy.Layout(*form_fields)
        self.fields['action'].initial = self.form_action

    def form_fields(self):
        return [
            hqcrispy.Field('app_id'),
            hqcrispy.Field('version'),
            hqcrispy.Field('use_version_postfix'),
            hqcrispy.Field('transifex_project_slug'),
            hqcrispy.Field('action')
        ]

    def clean(self):
        # ensure target lang when translation check requested during pull
        # to check for translation completion
        cleaned_data = super(AppTranslationsForm, self).clean()
        version = cleaned_data['version']
        if version:
            app_id = cleaned_data['app_id']
            available_versions = get_available_versions_for_app(
                self.domain, app_id)
            if version not in available_versions:
                self.add_error('version',
                               ugettext_lazy('Version not available for app'))
        if (not cleaned_data['target_lang']
                and (cleaned_data['action'] == "pull"
                     and cleaned_data['perform_translated_check'])):
            self.add_error(
                'target_lang',
                ugettext_lazy(
                    'Target lang required to confirm translation completion'))
        return cleaned_data

    @classmethod
    def form_for(cls, form_action):
        if form_action == 'create':
            return CreateAppTranslationsForm
        elif form_action == 'update':
            return UpdateAppTranslationsForm
        elif form_action == 'push':
            return PushAppTranslationsForm
        elif form_action == 'pull':
            return PullAppTranslationsForm
        elif form_action == 'backup':
            return BackUpAppTranslationsForm
        elif form_action == 'delete':
            return DeleteAppTranslationsForm
Ejemplo n.º 22
0
def _handle_user_form(request, domain, couch_user=None):
    context = {}
    if couch_user:
        create_user = False
    else:
        create_user = True
    can_change_admin_status = ((request.user.is_superuser or request.couch_user.can_edit_web_users(domain=domain))
        and request.couch_user.user_id != couch_user.user_id)

    if couch_user.is_commcare_user():
        role_choices = UserRole.commcareuser_role_choices(domain)
    else:
        role_choices = UserRole.role_choices(domain)

    results = get_db().view('languages/list', startkey=[domain], endkey=[domain, {}], group='true').all()
    language_choices = []

    if results:
        for result in results:
            lang_code = result['key'][1]
            label = result['key'][1]
            long_form = langcodes.get_name(lang_code)
            if long_form:
                label += " (" + langcodes.get_name(lang_code) + ")"
            language_choices.append((lang_code, label))
    else:
        language_choices = langcodes.get_all_langs_for_select()

    if request.method == "POST" and request.POST['form_type'] == "basic-info":
        if couch_user.is_commcare_user():
            form = UserForm(request.POST, role_choices=role_choices, language_choices=language_choices)
        else:
            form = WebUserForm(request.POST, role_choices=role_choices, language_choices=language_choices)
        if form.is_valid():
            if create_user:
                django_user = User()
                django_user.username = form.cleaned_data['email']
                django_user.save()
                couch_user = CouchUser.from_django_user(django_user)
            if couch_user.is_current_web_user(request) or couch_user.is_commcare_user():
                couch_user.first_name = form.cleaned_data['first_name']
                couch_user.last_name = form.cleaned_data['last_name']
                couch_user.email = form.cleaned_data['email']
                if not couch_user.is_commcare_user():
                    couch_user.email_opt_out = form.cleaned_data['email_opt_out']
                couch_user.language = form.cleaned_data['language']
            if can_change_admin_status:
                role = form.cleaned_data['role']
                if role:
                    couch_user.set_role(domain, role)
            couch_user.save()
            if request.couch_user.get_id == couch_user.get_id and couch_user.language:
                # update local language in the session
                request.session['django_language'] = couch_user.language

            messages.success(request, 'Changes saved for user "%s"' % couch_user.username)
    else:
        form = UserForm(role_choices=role_choices, language_choices=language_choices)
        if couch_user.is_commcare_user():
            form = UserForm(role_choices=role_choices, language_choices=language_choices)
        else:
            form = WebUserForm(role_choices=role_choices, language_choices=language_choices)

        if not create_user:
            form.initial['first_name'] = couch_user.first_name
            form.initial['last_name'] = couch_user.last_name
            form.initial['email'] = couch_user.email
            form.initial['email_opt_out'] = couch_user.email_opt_out
            form.initial['language'] = couch_user.language
            if can_change_admin_status:
                if couch_user.is_commcare_user():
                    role = couch_user.get_role(domain)
                    if role is None:
                        initial = "none"
                    else:
                        initial = role.get_qualified_id()
                    form.initial['role'] = initial
                else:
                    form.initial['role'] = couch_user.get_role(domain, include_teams=False).get_qualified_id() or ''

    if not can_change_admin_status:
        del form.fields['role']

    context.update({"form": form,
                    "current_users_page": couch_user.is_current_web_user(request)})
    return context
Ejemplo n.º 23
0
class ScheduledReportForm(forms.Form):
    config_ids = forms.MultipleChoiceField(
        label="Saved report(s)",
        validators=[MinLengthValidator(1)],
        help_text='Note: not all built-in reports support email delivery, so'
        ' some of your saved reports may not appear in this list')

    interval = forms.TypedChoiceField(label='Interval',
                                      choices=[("daily", "Daily"),
                                               ("weekly", "Weekly"),
                                               ("monthly", "Monthly")])

    day = forms.TypedChoiceField(label="Day",
                                 coerce=int,
                                 required=False,
                                 choices=[(i, i) for i in range(0, 32)])

    hour = forms.TypedChoiceField(label='Time',
                                  coerce=int,
                                  choices=ReportNotification.hour_choices())

    send_to_owner = forms.BooleanField(label='Send to owner', required=False)

    attach_excel = forms.BooleanField(label='Attach Excel Report',
                                      required=False)

    recipient_emails = MultiEmailField(label='Other recipients',
                                       required=False)
    email_subject = forms.CharField(
        required=False,
        help_text=
        'Translated into recipient\'s language if set to "%(default_subject)s".'
        % {
            'default_subject': DEFAULT_REPORT_NOTIF_SUBJECT,
        },
    )

    language = forms.ChoiceField(label='Language',
                                 required=False,
                                 choices=[('', '')] +
                                 langcodes.get_all_langs_for_select(),
                                 widget=forms.Select())

    def __init__(self, *args, **kwargs):
        self.helper = FormHelper()
        self.helper.form_class = 'form-horizontal'
        self.helper.form_id = 'id-scheduledReportForm'
        self.helper.label_class = 'col-sm-3 col-md-2'
        self.helper.field_class = 'col-sm-9 col-md-8 col-lg-6'
        self.helper.add_layout(
            crispy.Layout(
                crispy.Fieldset(
                    ugettext("Configure Scheduled Report"), 'config_ids',
                    'interval', 'day', 'hour',
                    B3MultiField(ugettext("Send Options"), 'send_to_owner'),
                    B3MultiField(ugettext("Excel Attachment"), 'attach_excel'),
                    crispy.Field(
                        'email_subject',
                        css_class='input-xlarge',
                    ), 'recipient_emails', 'language',
                    crispy.HTML(
                        render_to_string(
                            'reports/partials/privacy_disclaimer.html'))),
                FormActions(crispy.Submit('submit_btn', 'Submit'))))

        super(ScheduledReportForm, self).__init__(*args, **kwargs)

    def clean(self):
        cleaned_data = super(ScheduledReportForm, self).clean()
        if cleaned_data["interval"] == "daily":
            del cleaned_data["day"]
        _verify_email(cleaned_data)
        return cleaned_data
Ejemplo n.º 24
0
class AppTranslationsForm(forms.Form):
    app_id = forms.ChoiceField(label=ugettext_lazy("App"), choices=(), required=True)
    version = forms.IntegerField(label=ugettext_lazy("Version"), required=False,
                                 help_text=ugettext_lazy("Leave blank to use current application state"))
    use_version_postfix = forms.MultipleChoiceField(
        choices=[
            ('yes', 'Use Version Postfix in resources'),
        ],
        widget=forms.CheckboxSelectMultiple(),
        required=False,
        initial='yes',
    )
    update_resource = forms.MultipleChoiceField(
        choices=[
            ('yes', 'Update the resource files'),
        ],
        widget=forms.CheckboxSelectMultiple(),
        required=False,
        initial='no',
    )
    transifex_project_slug = forms.ChoiceField(label=ugettext_lazy("Trasifex project"), choices=(),
                                               required=True)
    source_lang = forms.ChoiceField(label=ugettext_lazy("Source Language"),
                                    choices=langcodes.get_all_langs_for_select(),
                                    initial="en"
                                    )
    # Unfortunately transifex api does not provide a way to pull all possible target languages and
    # allow us to just add a checkbox instead of selecting a single/multiple target languages at once
    target_lang = forms.ChoiceField(label=ugettext_lazy("Target Language"),
                                    choices=([(None, ugettext_lazy('Select Target Language'))] +
                                             langcodes.get_all_langs_for_select()),
                                    help_text=ugettext_lazy("Leave blank to skip"),
                                    required=False,
                                    )
    action = forms.ChoiceField(label=ugettext_lazy("Action"),
                               choices=[('push', ugettext_lazy('Push to transifex')),
                                        ('pull', ugettext_lazy('Pull from transifex')),
                                        ('delete', ugettext_lazy('Delete resources on transifex'))]
                               )
    lock_translations = forms.BooleanField(label=ugettext_lazy("Lock resources"),
                                           help_text=ugettext_lazy(
                                               "Lock translations for resources that are being pulled"),
                                           required=False,
                                           initial=False)
    perform_translated_check = forms.BooleanField(label=ugettext_lazy("Check for completion"),
                                                  help_text=ugettext_lazy(
                                                      "Check for translation completion before pulling files"),
                                                  required=False,
                                                  initial=True)

    def __init__(self, domain, *args, **kwargs):
        super(AppTranslationsForm, self).__init__(*args, **kwargs)
        self.domain = domain
        self.helper = FormHelper()
        self.helper.form_tag = False
        self.helper.label_class = 'col-sm-3 col-md-4 col-lg-2'
        self.helper.field_class = 'col-sm-4 col-md-5 col-lg-3'

        self.fields['app_id'].choices = tuple((app.id, app.name) for app in get_brief_apps_in_domain(domain))
        if settings.TRANSIFEX_DETAILS:
            self.fields['transifex_project_slug'].choices = (
                tuple((slug, slug)
                      for slug in settings.TRANSIFEX_DETAILS.get('project').get(domain))
            )
        self.helper.layout = Layout(
            'app_id',
            'version',
            'use_version_postfix',
            'update_resource',
            'transifex_project_slug',
            hqcrispy.Field('source_lang', css_class="ko-select2"),
            hqcrispy.Field('target_lang', css_class="ko-select2"),
            'action',
            'lock_translations',
            'perform_translated_check',
            hqcrispy.FormActions(
                twbscrispy.StrictButton(
                    ugettext_lazy("Submit"),
                    type="submit",
                    css_class="btn btn-primary btn-lg disable-on-submit",
                )
            )
        )

    def clean(self):
        # ensure target lang when translation check requested during pull
        # to check for translation completion
        cleaned_data = super(AppTranslationsForm, self).clean()
        version = cleaned_data['version']
        if version:
            app_id = cleaned_data['app_id']
            available_versions = get_available_versions_for_app(self.domain, app_id)
            if version not in available_versions:
                self.add_error('version', ugettext_lazy('Version not available for app'))
        if (not cleaned_data['target_lang'] and
                (cleaned_data['action'] == "pull" and cleaned_data['perform_translated_check'])):
            self.add_error('target_lang', ugettext_lazy('Target lang required to confirm translation completion'))
        return cleaned_data