Esempio n. 1
0
def _add_share_context(context, request, photos):
    if len(photos) > 0:
        photo_url = photos[0].thumbnail.url
    elif context.get('has_tree'):
        photo_url = settings.STATIC_URL + "img/tree.png"
    else:
        photo_url = settings.STATIC_URL + "img/otmLogo126.png"
    photo_url = request.build_absolute_uri(photo_url)

    title = trans("%s on %s") % (context['title'], request.instance.name)

    if context.get('benefits_total_currency', 0) > 0:
        description = trans("This %s saves %s%s per year.") % (
            context['title'],
            context['currency_symbol'],
            number_format(context['benefits_total_currency'], decimal_pos=0)
        )
    else:
        description = trans("This %s is mapped on %s.") % (
            context['title'],
            request.instance.name,
        )

    context['share'] = {
        'url': request.build_absolute_uri(),
        'title': title,
        'description': description,
        'image': photo_url,
    }
class SendCredentialProposalForm(AgentNameForm):
    connection_id = forms.CharField(widget=forms.HiddenInput())
    partner_name = forms.CharField(label=trans('Partner Name'), max_length=60)
    cred_def = forms.CharField(max_length=80, widget=forms.HiddenInput())
    credential_name = forms.CharField(widget=forms.HiddenInput())
    schema_attrs = forms.CharField(label=trans('Credential Attributes'),
                                   max_length=500,
                                   widget=forms.Textarea)

    def __init__(self, *args, **kwargs):
        super(SendCredentialProposalForm, self).__init__(*args, **kwargs)
        self.fields['agent_name'].widget.attrs['readonly'] = True
        self.fields['agent_name'].widget.attrs['hidden'] = True
        self.fields['connection_id'].widget.attrs['readonly'] = True
        self.fields['partner_name'].widget.attrs['readonly'] = True
        self.fields['cred_def'].widget.attrs['readonly'] = True

        # build a list of attributes for the given schema
        initial = kwargs.get('initial')
        if initial:
            schema_attrs = initial.get('schema_attrs', '{}')
            schema_attrs = json.loads(schema_attrs)
            self.fields['schema_attrs'].widget.attrs['hidden'] = True
            for attr in schema_attrs:
                field_name = 'schema_attr_' + attr
                self.fields[field_name] = forms.CharField(label=attr,
                                                          max_length=500)
class SendCredentialResponseFormProposal(SendConversationResponseForm):
    # a bunch of fields that are read-only to present to the user
    agent_name = forms.CharField(widget=forms.HiddenInput())
    libindy_offer_schema_id = forms.CharField(widget=forms.HiddenInput())
    conversation_id = forms.CharField(label=trans('conversation_id'),
                                      max_length=500)
    from_partner_name = forms.CharField(widget=forms.HiddenInput())
    claim_name = forms.CharField(widget=forms.HiddenInput())
    credential_attrs = forms.CharField(label=trans('Credential Attributs'),
                                       max_length=500)

    def __init__(self, *args, **kwargs):
        super(SendCredentialResponseFormProposal,
              self).__init__(*args, **kwargs)
        self.fields['agent_name'].widget.attrs['readonly'] = True
        self.fields['agent_name'].widget.attrs['hidden'] = True
        self.fields['libindy_offer_schema_id'].widget.attrs['readonly'] = True
        self.fields['libindy_offer_schema_id'].widget.attrs['hidden'] = True
        self.fields['conversation_id'].widget.attrs['readonly'] = True
        self.fields['claim_name'].widget.attrs['readonly'] = True
        self.fields['claim_name'].widget.attrs['hidden'] = True
        self.fields['from_partner_name'].widget.attrs['hidden'] = True
        self.fields['from_partner_name'].widget.attrs['hidden'] = True
        #       self.fields['credential_attrs'].widget.attrs['readonly'] = False

        # build a list of attributes for the current schema
        initial = kwargs.get('initial')
        if initial:
            credential_attrs = initial.get('credential_attrs', {})
            self.fields['credential_attrs'].widget.attrs['hidden'] = True
            for attr in credential_attrs:
                field_name = 'credential_attr_' + attr
                self.fields[field_name] = forms.CharField(
                    label=attr, initial=credential_attrs[attr])
                self.fields[field_name].widget.attrs['readonly'] = True
Esempio n. 4
0
class BlogPostForm(forms.ModelForm):
    helper = FormHelper()
    # helper.form_tag = False

    helper.layout = Layout(
        _('Create a blog post'),
        Field('published'),
        Field('title'),
        Field('description'),
        Field('post_date'),
        Field('language'),
        Field('content'),
        Div(HTML("""
                <div class="btn-group" role="group" aria-label="...">
                  <button type="button" id="italics-btn" title="{0}" class="btn btn-inverse"> <span class="glyphicon glyphicon-italic"></span> </button>
                  <button type="button" id="bold-btn" title="{1}" class="btn btn-inverse"> <span class="glyphicon glyphicon-bold"></span> </button>
                  <button type="button" id="list-btn" title="{2}" class="btn btn-inverse"> <span class="glyphicon glyphicon-list"></span> </button>
                  <button type="button" id="link-btn" title="{3}" class="btn btn-inverse"> <span class="glyphicon glyphicon-link"></span> </button>
                  <button type="button" id="picture-btn" title="{4}" class="btn btn-inverse" data-toggle="modal" data-target="#upload-img-modal"> <span class="glyphicon glyphicon-picture"></span> </button>
                </div>
            """.format(trans("Insert italics code"),
                       trans("Insert bold text code"),
                       trans("Insert a list item"), trans("Insert a link"),
                       trans("Upload picture"))),
            css_class="pull-left"),
        Div(FormActions(Submit('save', _('Save')), ), css_class="pull-right"),
    )

    class Meta:
        model = Post
        fields = '__all__'
Esempio n. 5
0
def user(request, username):
    user = get_object_or_404(User, username=username)
    instance_id = request.GET.get("instance_id", None)

    instance = get_instance_or_404(pk=instance_id) if instance_id else None

    query_vars = {"instance_id": instance_id} if instance_id else {}

    audit_dict = _get_audits(request.user, instance, query_vars, user, ["Plot", "Tree"], 0)

    reputation = user.get_reputation(instance) if instance else None

    public_fields = [(trans("First Name"), "user.first_name"), (trans("Last Name"), "user.last_name")]

    private_fields = [(trans("Email"), "user.email")]

    return {
        "user": user,
        "reputation": reputation,
        "instance_id": instance_id,
        "audits": audit_dict["audits"],
        "next_page": audit_dict["next_page"],
        "public_fields": public_fields,
        "private_fields": private_fields,
    }
Esempio n. 6
0
def user(request, username):
    user = get_object_or_404(User, username=username)
    instance_id = request.GET.get('instance_id', None)

    instance = (get_instance_or_404(pk=instance_id)
                if instance_id else None)

    query_vars = {'instance_id': instance_id} if instance_id else {}

    audit_dict = _get_audits(request.user, instance, query_vars,
                             user, ['Plot', 'Tree'], 0)

    reputation = user.get_reputation(instance) if instance else None

    public_fields = [
        (trans('First Name'), 'user.first_name'),
        (trans('Last Name'), 'user.last_name')
    ]

    private_fields = [
        (trans('Email'), 'user.email')
    ]

    return {'user': user,
            'reputation': reputation,
            'instance_id': instance_id,
            'audits': audit_dict['audits'],
            'next_page': audit_dict['next_page'],
            'public_fields': public_fields,
            'private_fields': private_fields}
Esempio n. 7
0
File: udf.py Progetto: heath/OTM2
    def clean_udfs(self):
        errors = {}

        scalar_fields = {field.name: field for field in self.get_user_defined_fields() if not field.iscollection}

        collection_fields = {field.name: field for field in self.get_user_defined_fields() if field.iscollection}

        # Clean scalar udfs
        for (key, val) in self.udfs.iteritems():
            field = scalar_fields.get(key, None)
            if field:
                try:
                    field.clean_value(val)
                except ValidationError as e:
                    errors["udf:%s" % key] = e.messages
            else:
                errors["udf:%s" % key] = trans("Invalid user defined field name")

        # Clean collection values, but only if they were loaded
        if self.udfs.collection_data_loaded:
            collection_data = self.udfs.collection_fields
            for collection_field_name, data in collection_data.iteritems():
                collection_field = collection_fields.get(collection_field_name, None)

                if collection_field:
                    try:
                        collection_field.clean_collection(data)
                    except ValidationError as e:
                        errors.update(e.message_dict)
                else:
                    errors["udf:%s" % collection_field_name] = trans("Invalid user defined field name")

        if errors:
            raise ValidationError(errors)
Esempio n. 8
0
def _get_status_panel_specs(ie):
    verified_panel = {
        'name': 'verified',
        'status': GenericImportRow.VERIFIED,
        'title': trans('Ready to Add')
    }
    error_panel = {
        'name': 'error',
        'status': GenericImportRow.ERROR,
        'title': trans('Errors')
    }
    success_panel = {
        'name': 'success',
        'status': GenericImportRow.SUCCESS,
        'title': trans('Successfully Added')
    }

    if isinstance(ie, TreeImportEvent):
        warning_panel = {
            'name': 'warning',
            'status': TreeImportRow.WARNING,
            'title': trans('Warnings')
        }
        panels = [verified_panel, error_panel, warning_panel, success_panel]
    else:
        merge_required_panel = {
            'name': 'merge_required',
            'status': None,
            'title': trans('Merge Required')
        }
        panels = [
            verified_panel, merge_required_panel, error_panel, success_panel]
    return panels
Esempio n. 9
0
    def clean(self):
        errors = {}

        if len(self.currency_symbol) > 4:
            errors['currency_symbol'] = trans(
                'Symbol is too long')

        positive_fields = ['electricity_kwh_to_currency',
                           'natural_gas_kbtu_to_currency',
                           'h20_gal_to_currency',
                           'co2_lb_to_currency',
                           'o3_lb_to_currency',
                           'nox_lb_to_currency',
                           'pm10_lb_to_currency',
                           'sox_lb_to_currency',
                           'voc_lb_to_currency']

        for field in positive_fields:
            value = getattr(self, field)
            try:
                value = float(value or '')
                if value < 0:
                    errors[field] = [trans('Values must be not be negative')]
            except ValueError:
                pass

        if errors:
            raise ValidationError(errors)
Esempio n. 10
0
 def action_format_string_for_audit(clz, audit):
     if audit.field == 'id' or audit.field is None:
         lang = {
             Audit.Type.Insert:
             trans('created a %(model)s'),
             Audit.Type.Update:
             trans('updated the %(model)s'),
             Audit.Type.Delete:
             trans('deleted the %(model)s'),
             Audit.Type.PendingApprove:
             trans('approved an '
                   'edit to the %(model)s'),
             Audit.Type.PendingReject:
             trans('rejected an '
                   'edit to the %(model)s')
         }
     else:
         lang = {
             Audit.Type.Insert:
             trans('set %(field)s to %(value)s'),
             Audit.Type.Update:
             trans('set %(field)s to %(value)s'),
             Audit.Type.Delete:
             trans('deleted %(field)s'),
             Audit.Type.PendingApprove:
             trans('approved setting '
                   '%(field)s to %(value)s'),
             Audit.Type.PendingReject:
             trans('rejecting setting '
                   '%(field)s to %(value)s')
         }
     return lang[audit.action]
Esempio n. 11
0
File: user.py Progetto: PyBulls/OTM2
def create_user(request):
    data = json.loads(request.body)

    errors = {}
    for field in REQ_FIELDS:
        if field not in data:
            errors[field] = [trans('This field is required')]

    for inputfield in data:
        if inputfield not in ALL_FIELDS:
            errors[inputfield] = [trans('Unrecognized field')]

    if errors:
        raise ValidationError(errors)

    dup_username = User.objects.filter(username=data['username'])
    dup_email = User.objects.filter(email=data['email'])

    if dup_username.exists():
        return _conflict_response(trans('Username is already in use'))
    if dup_email.exists():
        # BE WARNED - The iOS application relies on this error message string.
        # If you change this you WILL NEED TO ALTER CODE THERE AS WELL.
        return _conflict_response(trans('Email is already in use'))

    user = User(**data)

    # Needed to properly hash the password
    user.set_password(data['password'])
    user.active = True
    user.save()

    RegistrationProfile.objects.create_profile(user)

    return {'status': 'success', 'id': user.pk}
Esempio n. 12
0
def _context_dict_for_map_feature(request, feature):
    instance = request.instance
    if instance.pk != feature.instance_id:
        raise Exception("Invalid instance, does not match map feature")

    feature.instance = instance  # save a DB lookup

    user = request.user
    if user and user.is_authenticated():
        feature.mask_unauthorized_fields(user)

    feature.convert_to_display_units()

    if feature.is_plot:
        tree = feature.current_tree()
        if tree:
            if tree.species:
                title = tree.species.common_name
            else:
                title = trans("Missing Species")
        else:
            title = trans("Empty Planting Site")
    else:
        title = feature.display_name

    context = {
        'feature': feature,
        'feature_type': feature.feature_type,
        'title': title,
    }

    _add_eco_benefits_to_context_dict(instance, feature, context)

    return context
Esempio n. 13
0
def _get_status_panel_specs(ie):
    verified_panel = {
        'name': 'verified',
        'status': GenericImportRow.VERIFIED,
        'title': trans('Ready to Add')
    }
    error_panel = {
        'name': 'error',
        'status': GenericImportRow.ERROR,
        'title': trans('Errors')
    }
    success_panel = {
        'name': 'success',
        'status': GenericImportRow.SUCCESS,
        'title': trans('Successfully Added')
    }

    if isinstance(ie, TreeImportEvent):
        warning_panel = {
            'name': 'warning',
            'status': TreeImportRow.WARNING,
            'title': trans('Warnings')
        }
        panels = [verified_panel, error_panel, warning_panel, success_panel]
    else:
        merge_required_panel = {
            'name': 'merge_required',
            'status': None,
            'title': trans('Merge Required')
        }
        panels = [
            verified_panel, merge_required_panel, error_panel, success_panel
        ]
    return panels
Esempio n. 14
0
class Plot(MapFeature):
    width = models.FloatField(null=True, blank=True,
                              help_text=trans("Plot Width"))
    length = models.FloatField(null=True, blank=True,
                               help_text=trans("Plot Length"))

    owner_orig_id = models.CharField(max_length=255, null=True, blank=True)

    objects = GeoHStoreUDFManager()

    @classproperty
    def benefits(cls):
        from treemap.ecobenefits import TreeBenefitsCalculator
        return TreeBenefitsCalculator()

    def nearby_plots(self, distance_in_meters=None):
        if distance_in_meters is None:
            distance_in_meters = settings.NEARBY_TREE_DISTANCE

        distance_filter = Plot.objects.filter(
            geom__distance_lte=(self.geom, D(m=distance_in_meters)))

        return distance_filter\
            .filter(instance=self.instance)\
            .exclude(pk=self.pk)

    def get_tree_history(self):
        """
        Get a list of all tree ids that were ever assigned
        to this plot
        """
        return Audit.objects.filter(instance=self.instance)\
                            .filter(model='Tree')\
                            .filter(field='plot')\
                            .filter(current_value=self.pk)\
                            .order_by('-model_id', '-updated')\
                            .distinct('model_id')\
                            .values_list('model_id', flat=True)

    def current_tree(self):
        """
        This is a compatibility method that is used by the API to
        select the 'current tree'. Right now OTM only supports one
        tree per plot, so this method returns the 'first' tree
        """
        trees = list(self.tree_set.all())
        if trees:
            return trees[0]
        else:
            return None

    def delete_with_user(self, user, cascade=False, *args, **kwargs):
        if self.current_tree() and cascade is False:
            raise ValidationError(trans(
                "Cannot delete plot with existing trees."))
        super(Plot, self).delete_with_user(user, *args, **kwargs)

    @classproperty
    def display_name(cls):
        return trans('Planting Site')
Esempio n. 15
0
def create_user(request):
    data = json.loads(request.body)

    errors = {}
    for field in REQ_FIELDS:
        if field not in data:
            errors[field] = [trans('This field is required')]

    for inputfield in data:
        if inputfield not in ALL_FIELDS:
            errors[inputfield] = [trans('Unrecognized field')]

    if errors:
        raise ValidationError(errors)

    dup_username = User.objects.filter(username=data['username'])
    dup_email = User.objects.filter(email=data['email'])

    if dup_username.exists():
        return _conflict_response(trans('Username is already in use'))
    if dup_email.exists():
        # BE WARNED - The iOS application relies on this error message string.
        # If you change this you WILL NEED TO ALTER CODE THERE AS WELL.
        return _conflict_response(trans('Email is already in use'))

    user = User(**data)

    # Needed to properly hash the password
    user.set_password(data['password'])
    user.active = True
    user.save()

    RegistrationProfile.objects.create_profile(user)

    return {'status': 'success', 'id': user.pk}
Esempio n. 16
0
File: views.py Progetto: heath/OTM2
def _context_dict_for_map_feature(instance, feature):
    if instance.pk != feature.instance_id:
        raise Exception("Invalid instance, does not match map feature")

    feature.instance = instance  # save a DB lookup

    if feature.is_plot:
        tree = feature.current_tree()
        if tree:
            if tree.species:
                title = tree.species.common_name
            else:
                title = trans("Missing Species")
        else:
            title = trans("Empty Planting Site")
    else:
        title = feature.display_name

    context = {
        'feature': feature,
        'feature_type': feature.feature_type,
        'title': title,
    }

    _add_eco_benefits_to_context_dict(instance, feature, context)

    return context
Esempio n. 17
0
    def _validate_and_update_choice(self, datatype, old_choice_value,
                                    new_choice_value):
        if datatype['type'] != 'choice':
            raise ValidationError({
                'datatype':
                [trans("can't change choices "
                       "on a non-choice field")]
            })

        if old_choice_value not in datatype['choices']:
            raise ValidationError({
                'datatype': [
                    trans("choice '%(choice)s' not found") % {
                        'choice': old_choice_value
                    }
                ]
            })

        choices = datatype['choices']
        if new_choice_value:
            choices = [
                c if c != old_choice_value else new_choice_value
                for c in choices
            ]
        else:
            choices = [c for c in choices if c != old_choice_value]

        datatype['choices'] = choices
        return datatype
Esempio n. 18
0
def Save(request, event_id):
    event = Event.objects.get(pk=event_id)
    form = SignUpForm()
    SignUpFormSet = formset_factory(SignUpForm, )
    if request.method == 'POST':
        formset = SignUpFormSet(request.POST, request.FILES)
        for idx, extraform in enumerate(formset.forms):
            if idx != 0:
                extraform.empty_permitted = True
        if formset.is_valid():
            counter = 0
            for form in formset.forms:

                signup = form.save(commit=False)
                if (signup.name == ''):
                    counter = counter + 1
                    continue
                signup.event = event
                signup.member = get_user(request)
                if counter != 0:
                    signup.avec = True
                signup.save()
                counter = counter + 1
                save_user_checkboxes(request, event, signup, counter)
                save_user_text_fields(request, event, signup, counter)

            messages.add_message(request, messages.SUCCESS,
                                 trans(u'Anmälan sparad'))
            return HttpResponseRedirect(
                reverse('event:view', args=(event_id, )))

    c = {'form': form, 'event': event}
    messages.add_message(request, messages.ERROR,
                         trans(u'Anmälan misslyckades'))
    return render(request, 'events/view.html', c)
Esempio n. 19
0
    def clean(self):
        errors = {}

        if len(self.currency_symbol) > 4:
            errors['currency_symbol'] = trans(
                'Symbol is too long')

        positive_fields = ['electricity_kwh_to_currency',
                           'natural_gas_kbtu_to_currency',
                           'h20_gal_to_currency',
                           'co2_lb_to_currency',
                           'o3_lb_to_currency',
                           'nox_lb_to_currency',
                           'pm10_lb_to_currency',
                           'sox_lb_to_currency',
                           'voc_lb_to_currency']

        for field in positive_fields:
            value = getattr(self, field)
            try:
                value = float(value or '')
                if value < 0:
                    errors[field] = [trans('Values must be not be negative')]
            except ValueError:
                pass

        if errors:
            raise ValidationError(errors)
Esempio n. 20
0
    def create(self, validated_data):
        """Crear pago de especialista."""
        match = validated_data.pop('match')
        instance = Payment(**validated_data)
        instance.save()
        match.status = 5
        if 'test' not in sys.argv:
            client_id = match.client_id
            specialist_id = match.specialist_id
            qset_client = Client.objects.filter(pk=client_id)
            qset_spec = Specialist.objects.filter(pk=specialist_id)
            dict_pending = NotificationClientSerializer(qset_client).data
            dict_pending_sp = NotificationSpecialistSerializer(qset_spec).data
            badge_count = dict_pending["queries_pending"] + dict_pending[
                "match_pending"]
            badge_count_sp = dict_pending_sp[
                "queries_pending"] + dict_pending_sp["match_pending"]
            disp_name = display_specialist_name(match)
            disp_name_to_specialist = display_client_name(match.client)
            data_notif_push = {
                "title": disp_name,
                "body": match.subject,
                "sub_text": "",
                "ticker": trans("successful hiring"),
                "badge": badge_count,
                "icon": match.category.image,
                "type": Params.TYPE_NOTIF["match_success"],
                "queries_pending": dict_pending["queries_pending"],
                "match_pending": dict_pending["match_pending"],
                "match_id": match.id
            }
            data_specialist = {
                "title": disp_name_to_specialist,
                "body": match.subject,
                "sub_text": "",
                "ticker": trans("successful hiring"),
                "badge": badge_count_sp,
                "icon": match.category.image,
                "type": Params.TYPE_NOTIF["match_success"],
                "queries_pending": dict_pending_sp["queries_pending"],
                "match_pending": dict_pending_sp["match_pending"],
                "match_id": match.id
            }
            # envio de notificacion push
            Notification.fcm_send_data(user_id=client_id, data=data_notif_push)

            Notification.fcm_send_data(user_id=specialist_id,
                                       data=data_specialist)
        match.save()

        sellercontact = match.client.sellercontact_set.get()
        sellercontact.type_contact = 3
        sellercontact.save()

        sale = match.sale_detail.sale
        sale.status = 3
        sale.save()

        return instance
Esempio n. 21
0
 def __init__(self, *args, **kwargs):
     super(FormContato, self).__init__(*args, **kwargs)
     self.fields['email'].error_messages['required']                 = trans(u'O campo E-mail é obrigatório')
     self.fields['nome'].error_messages['required']                  = trans(u'O campo Nome é obrigatório')
     self.fields['mensagem'].error_messages['required']              = trans(u'O campo Mensagem é obrigatório')     
     self.fields['email'].widget.attrs['required']                   = "required"
     self.fields['nome'].widget.attrs['required']                    = "required"
     self.fields['mensagem'].widget.attrs['required']                = "required"
class RemoveConnectionForm(AgentNameForm):
    partner_name = forms.CharField(label=trans('Partner Name'), max_length=60)
    connection_id = forms.CharField(label=trans('connection_id'),
                                    max_length=60)

    def __init__(self, *args, **kwargs):
        super(RemoveConnectionForm, self).__init__(*args, **kwargs)
        self.fields['partner_name'].widget.attrs['readonly'] = True
        self.fields['agent_name'].widget.attrs['readonly'] = True
        self.fields['agent_name'].widget.attrs['hidden'] = True
Esempio n. 23
0
def save_uploaded_image(image_data,
                        name_prefix,
                        thumb_size=None,
                        degrees_to_rotate=None):
    # We support passing data directly in here but we
    # have to treat it as a file-like object
    if type(image_data) is str:
        image_data = StringIO(image_data)

    image_data.seek(0, os.SEEK_END)
    file_size = image_data.tell()

    if file_size > settings.MAXIMUM_IMAGE_SIZE:
        raise ValidationError(trans('The uploaded image is too large'))

    image_data.seek(0)

    try:
        image = Image.open(image_data)
        image.verify()
    except IOError:
        raise ValidationError(trans('Invalid image'))

    try:
        # http://pillow.readthedocs.org/en/latest/_modules/PIL/Image.html#Image.verify  # NOQA
        # ...if you need to load the image after using verify,
        # you must reopen the image file.
        image_data.seek(0)
        image = Image.open(image_data)
        format = image.format

        image_data.seek(0)
        hash = hashlib.md5(image_data.read()).hexdigest()
        name = "%s-%s.%s" % (name_prefix, hash, format.lower())

        if degrees_to_rotate is None:
            image = _rotate_image_based_on_exif(image)
        else:
            image = image.rotate(degrees_to_rotate)

        image_file = _get_file_for_image(image, name, format)
        thumb_file = None

        if thumb_size is not None:
            thumb_image = image.copy()
            thumb_image.thumbnail(thumb_size, Image.ANTIALIAS)
            thumb_file = _get_file_for_image(thumb_image, 'thumb-%s' % name,
                                             format)

        # Reset image position
        image_data.seek(0)

        return image_file, thumb_file
    except:
        raise ValidationError(trans('Image upload issue'))
Esempio n. 24
0
    def __init__(self, *args, **kwargs):
        super(SelectProofReqClaimsForm, self).__init__(*args, **kwargs)

        # list requested attributes and the available claims, for the user to select
        initial = kwargs.get('initial')
        if initial:
            available_claims = initial.get('selected_claims', '{}')
            proof_request = initial.get('proof_request', '{}')
            print("available_claims:", available_claims)
            print("proof_request:", proof_request)

            for attr in proof_request['presentation_request'][
                    'requested_attributes']:
                field_name = 'proof_req_attr_' + attr
                choices = []
                claim_no = 0
                for claim in available_claims:
                    if attr in claim['presentation_referents']:
                        choices.append(
                            ('ref::' + claim['cred_info']['referent'],
                             json.dumps(claim['cred_info']['attrs'])))
                        claim_no = claim_no + 1
                if 0 < len(choices):
                    self.fields[field_name] = forms.ChoiceField(
                        label=trans('Select claim for') + attr,
                        choices=tuple(choices),
                        widget=forms.RadioSelect())
                else:
                    self.fields[field_name] = forms.CharField(
                        label=trans('No claims available for') + attr +
                        ', enter value:',
                        max_length=80)

            for attr in proof_request['presentation_request'][
                    'requested_predicates']:
                field_name = 'proof_req_attr_' + attr
                choices = []
                claim_no = 0
                for claim in available_claims:
                    if attr in claim['presentation_referents']:
                        choices.append(
                            ('ref::' + claim['cred_info']['referent'],
                             json.dumps(claim['cred_info']['attrs'])))
                        claim_no = claim_no + 1
                if 0 < len(choices):
                    self.fields[field_name] = forms.ChoiceField(
                        label=trans('Select claim for') + attr,
                        choices=tuple(choices),
                        widget=forms.RadioSelect())
                else:
                    self.fields[field_name] = forms.CharField(
                        label=trans('No claims available for') + attr +
                        ', enter value:',
                        max_length=80)
class SendProofReqResponseForm(SendConversationResponseForm):
    # a bunch of fields that are read-only to present to the user
    from_partner_name = forms.CharField(label=trans('Partner Name'),
                                        max_length=60)
    proof_req_name = forms.CharField(label=trans('Proof Request Name'),
                                     max_length=500)

    def __init__(self, *args, **kwargs):
        super(SendProofReqResponseForm, self).__init__(*args, **kwargs)
        self.fields['from_partner_name'].widget.attrs['readonly'] = True
        self.fields['proof_req_name'].widget.attrs['readonly'] = True
Esempio n. 26
0
class AbstractUniqueEmailUser(AbstractBaseUser, PermissionsMixin):
    """
    An abstract base class implementing a fully featured User model with
    admin-compliant permissions.

    Username, password and email are required. Other fields are optional.
    """
    username = models.CharField(
        trans('username'),
        max_length=30,
        unique=True,
        help_text=trans(
            'Required. 30 characters or fewer. Letters, numbers and '
            '@/./+/-/_ characters'),
        validators=[
            validators.RegexValidator(re.compile('^[\w.@+-]+$'),
                                      trans('Enter a valid username.'),
                                      'invalid')
        ])
    email = models.EmailField(trans('email address'), blank=True, unique=True)
    is_staff = models.BooleanField(
        trans('staff status'),
        default=False,
        help_text=trans('Designates whether the user can log into this admin '
                        'site.'))
    is_active = models.BooleanField(
        trans('active'),
        default=True,
        help_text=trans('Designates whether this user should be treated as '
                        'active. Unselect this instead of deleting accounts.'))
    date_joined = models.DateTimeField(trans('date joined'),
                                       default=timezone.now)

    objects = UserManager()

    USERNAME_FIELD = 'username'
    REQUIRED_FIELDS = ['email']

    class Meta:
        verbose_name = trans('user')
        verbose_name_plural = trans('users')
        abstract = True

    def get_full_name(self):
        """
        Returns the first_name plus the last_name, with a space in between.
        """
        full_name = '%s %s' % (self.first_name, self.last_name)
        return full_name.strip()

    def get_short_name(self):
        "Returns the short name for the user."
        return self.first_name

    def email_user(self, subject, message, from_email=None, **kwargs):
        """
        Sends an email to this User.
        """
        send_mail(subject, message, from_email, [self.email], **kwargs)
Esempio n. 27
0
File: udf.py Progetto: heath/OTM2
 def action_format_string_for_audit(cls, audit):
     if audit.field == "id" or audit.field is None:
         lang = {
             Audit.Type.Insert: trans("created a %(model)s entry"),
             Audit.Type.Update: trans("updated the %(model)s entry"),
             Audit.Type.Delete: trans("deleted the %(model)s entry"),
             Audit.Type.PendingApprove: trans("approved an edit " "to the %(model)s entry"),
             Audit.Type.PendingReject: trans("rejected an " "edit to the %(model)s entry"),
         }
         return lang[audit.action]
     return Auditable.action_format_string_for_audit(audit)
Esempio n. 28
0
 def __init__(self, *args, **kwargs):
     super(FormCadastroDeTemplate, self).__init__(*args, **kwargs)
     self.fields['descricao'].error_messages['required']     = trans(u'O campo Descrição é obrigatório')
     self.fields['assunto'].error_messages['required']       = trans(u'O campo Assunto é obrigatório')
     self.fields['texto'].error_messages['required']         = trans(u'O campo Texto é obrigatório') 
     self.fields['descricao'].widget.attrs['placeholder']    = 'Ex.: Agendamento de entrevista.'
     self.fields['assunto'].widget.attrs['placeholder']      = 'Assunto do Email'
     self.fields['texto'].widget.attrs['placeholder']        = 'Digite a texto do Email'
     self.fields['descricao'].widget.attrs['required']       = "required"
     self.fields['assunto'].widget.attrs['required']         = "required"
     self.fields['texto'].auto_id                            = False
Esempio n. 29
0
def save_uploaded_image(image_data, name_prefix, thumb_size=None,
                        degrees_to_rotate=None):
    # We support passing data directly in here but we
    # have to treat it as a file-like object
    if type(image_data) is str:
        image_data = StringIO(image_data)

    image_data.seek(0, os.SEEK_END)
    file_size = image_data.tell()

    if file_size > settings.MAXIMUM_IMAGE_SIZE:
        raise ValidationError(trans('The uploaded image is too large'))

    image_data.seek(0)

    try:
        image = Image.open(image_data)
        image.verify()
    except IOError:
        raise ValidationError(trans('Invalid image'))

    try:
        # http://pillow.readthedocs.org/en/latest/_modules/PIL/Image.html#Image.verify  # NOQA
        # ...if you need to load the image after using verify,
        # you must reopen the image file.
        image_data.seek(0)
        image = Image.open(image_data)
        format = image.format

        image_data.seek(0)
        hash = hashlib.md5(image_data.read()).hexdigest()
        name = "%s-%s.%s" % (name_prefix, hash, format.lower())

        if degrees_to_rotate is None:
            image = _rotate_image_based_on_exif(image)
        else:
            image = image.rotate(degrees_to_rotate)

        image_file = _get_file_for_image(image, name, format)
        thumb_file = None

        if thumb_size is not None:
            thumb_image = image.copy()
            thumb_image.thumbnail(thumb_size, Image.ANTIALIAS)
            thumb_file = _get_file_for_image(thumb_image, 'thumb-%s' % name,
                                             format)

        # Reset image position
        image_data.seek(0)

        return image_file, thumb_file
    except:
        raise ValidationError(trans('Image upload issue'))
class SendMessageForm(AgentNameForm):
    connection_id = forms.CharField(label=trans('connection_id'),
                                    max_length=50)
    message = forms.CharField(label=trans('Message'),
                              max_length=500,
                              widget=forms.Textarea())

    def __init__(self, *args, **kwargs):
        super(SendMessageForm, self).__init__(*args, **kwargs)
        self.fields['message'].widget.attrs['readonly'] = False
        self.fields['connection_id'].widget.attrs['readonly'] = True
        self.fields['agent_name'].widget.attrs['readonly'] = True
Esempio n. 31
0
class EmailForm(forms.Form):
    helper = FormHelper()
    helper.form_tag = False

    sender = forms.EmailField(
        label=_("Email"),
        required=True,
        widget=forms.TextInput(
            attrs={'placeholder': _("Enter your email address")}))

    subject = forms.CharField(
        label=_("Subject"),
        max_length=100,
        required=False,
        widget=forms.TextInput(attrs={'placeholder': _("What's this about?")}))

    message = forms.CharField(
        label=_("Message"),
        required=True,
        widget=forms.Textarea(attrs={'placeholder': _("Your message here")}))

    cc_myself = forms.BooleanField(label=_("Send myself a copy"),
                                   required=False,
                                   widget=forms.CheckboxInput())

    helper.layout = Layout(
        HTML("""<!-- Modal form -->
                <div class="modal fade" id="emailForm" tabindex="-1" role="dialog" aria-labelledby="emailForm" aria-hidden="false">
                    <div class="modal-dialog">
                        <div class="modal-content">

                            <div class="modal-header">
                                <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>
                                <h4 class="modal-title" id="emailForm">{0}</h4>
                            </div>

                            <form action="{{% url 'mapApp:contact' %}}" method="post" role="form">
                                {{% csrf_token %}}
                                <div class="modal-body">
        """.format(trans("Contact"))), Field('sender'), Field('subject'),
        Field('message'), Field('cc_myself'),
        HTML("""                </div>

                                <div class="modal-footer">
                                    <button type="reset" class="btn btn-default" onclick="$('#emailForm').modal('hide');$('.modal-backdrop').hide();">{0}</button>
                                    <button type="submit" class="btn btn-primary">{1} <span class="glyphicon glyphicon-send"></span></button>
                                </div>

                            </form>
                        </div>
                    </div>
                </div>
        """.format(trans("Cancel"), trans("Send"))))
Esempio n. 32
0
def resolve_object_type(obj: Object, *_):
    if obj.type == "directory":
        return trans("Directory")

    file_type = {
        "xlsx": "Excel file",
        "md": "Markdown document",
        "ipynb": "Jupyter Notebook",
        "csv": "CSV file",
    }.get(obj.extension, "File")

    return trans(file_type)
Esempio n. 33
0
def approve_or_reject_photo(
        request, instance, feature_id, photo_id, action):

    approved = action == 'approve'

    if approved:
        msg = trans('Approved')
    else:
        msg = trans('Rejected')

    resp = HttpResponse(msg)

    try:
        photo = (MapFeaturePhoto.objects
                 .select_related('treephoto')
                 .get(pk=photo_id))
        try:
            photo = photo.treephoto
        except MapFeaturePhoto.DoesNotExist:
            pass  # There is no tree photo, so use the superclass
    except MapFeaturePhoto.DoesNotExist:
        # This may be a pending tree. Let's see if there
        # are pending audits
        pending_audits = Audit.objects\
            .filter(instance=instance)\
            .filter(model__in=['TreePhoto', 'MapFeaturePhoto'])\
            .filter(model_id=photo_id)\
            .filter(requires_auth=True)

        if len(pending_audits) > 0:
            # Process as pending and quit
            approve_or_reject_audits_and_apply(
                pending_audits, request.user, approved)

            return resp
        else:
            # Error - no pending or regular
            raise Http404('Photo Not Found')

    # Handle the id audit first
    all_audits = []
    for audit in photo.audits():
        if audit.field == 'id':
            all_audits = [audit] + all_audits
        else:
            all_audits.append(audit)

    for audit in all_audits:
        approve_or_reject_existing_edit(
            audit, request.user, approved)

    return resp
class SelectProofRequestForm(AgentNameForm):
    connection_id = forms.CharField(widget=forms.HiddenInput())
    partner_name = forms.CharField(label=trans('Partner Name'), max_length=60)
    proof_request = forms.ModelChoiceField(
        label=trans('Proof Request Type'),
        queryset=IndyProofRequest.objects.all())

    def __init__(self, *args, **kwargs):
        super(SelectProofRequestForm, self).__init__(*args, **kwargs)
        self.fields['agent_name'].widget.attrs['readonly'] = True
        self.fields['agent_name'].widget.attrs['hidden'] = True
        self.fields['connection_id'].widget.attrs['readonly'] = True
        self.fields['partner_name'].widget.attrs['readonly'] = True
Esempio n. 35
0
 def action_format_string_for_audit(cls, audit):
     if audit.field == 'id' or audit.field is None:
         lang = {
             Audit.Type.Insert: trans('created a %(model)s entry'),
             Audit.Type.Update: trans('updated the %(model)s entry'),
             Audit.Type.Delete: trans('deleted the %(model)s entry'),
             Audit.Type.PendingApprove: trans('approved an edit '
                                              'to the %(model)s entry'),
             Audit.Type.PendingReject: trans('rejected an '
                                             'edit to the %(model)s entry')
         }
         return lang[audit.action]
     return Auditable.action_format_string_for_audit(audit)
Esempio n. 36
0
File: udf.py Progetto: PyBulls/OTM2
 def action_format_string_for_audit(cls, audit):
     if audit.field == 'id' or audit.field is None:
         lang = {
             Audit.Type.Insert: trans('created a %(model)s entry'),
             Audit.Type.Update: trans('updated the %(model)s entry'),
             Audit.Type.Delete: trans('deleted the %(model)s entry'),
             Audit.Type.PendingApprove: trans('approved an edit '
                                              'to the %(model)s entry'),
             Audit.Type.PendingReject: trans('rejected an '
                                             'edit to the %(model)s entry')
         }
         return lang[audit.action]
     return Auditable.action_format_string_for_audit(audit)
Esempio n. 37
0
def Edit(request, signup_id):
    u = request.user
    signup = SignUp.objects.get(pk=signup_id)
    event = signup.event
    if request.method == 'POST':
        if (u.title and u.title.styrelsePost) or u.is_superuser or (
                u == signup.member and
                event.deadline > datetime.utcnow().replace(tzinfo=pytz.utc)):

            form = SignUpForm(request.POST, instance=signup)
            signup = form.save(commit=False)
            signup.save()
            event = signup.event
            delete_extra_fields(signup)
            save_user_checkboxes(request, event, signup, 0)
            save_user_text_fields(request, event, signup, 0)
            messages.add_message(request, messages.SUCCESS,
                                 trans(u'Anmälan uppdaterad'))
            return HttpResponseRedirect(
                reverse('event:view', args=(signup.event_id, )))
        else:
            messages.add_message(
                request, messages.ERROR,
                trans(
                    u'Du har tyvärr inte rättigheter att ta ändra denna anmälan,\
             vänligen kontakta styrelsen'))
            return HttpResponseRedirect(
                reverse('event:view', args=(event.id, )))
    form = SignUpForm(instance=signup)
    event = signup.event
    event_text_fields = TextFieldXEvent.objects.filter(
        event_id__exact=event.id)
    event_check_boxes = CheckboxXEvent.objects.filter(event_id__exact=event.id)
    text_fields = []
    check_boxes = []
    for textfield in event_text_fields:
        tmp, _ = TextFieldXSignup.objects.get_or_create(
            textfield_id=textfield.id, signUp_id=signup_id)
        text_fields.append(tmp)
    for checkbox in event_check_boxes:
        tmp, _ = CheckboxXSignUp.objects.get_or_create(checkbox_id=checkbox.id,
                                                       signUp_id=signup_id)
        check_boxes.append(tmp)

    c = {
        'form': form,
        'signup': signup,
        'check_boxes': check_boxes,
        'text_fields': text_fields,
    }
    return render(request, 'signup/edit.html', c)
Esempio n. 38
0
    def __init__(self, *args, **kwargs):
        super(RegistrationForm, self).__init__(*args, **kwargs)

        self.fields['email'].label = trans('Email')
        self.fields['password2'].label = trans('Confirm Password')

        for field_name, field in self.fields.items():
            if not isinstance(field, forms.BooleanField):
                field.widget.attrs['class'] = 'form-control'

        self.fields['password1'].widget.attrs['outer_class'] = 'field-left'
        self.fields['password2'].widget.attrs['outer_class'] = 'field-right'
        self.fields['first_name'].widget.attrs['outer_class'] = 'field-left'
        self.fields['last_name'].widget.attrs['outer_class'] = 'field-right'
Esempio n. 39
0
def _action_format_string_for_location(action):
    """A helper that allows multiple auditable models to return the
    same action format string for a field value that should be displayed
    as a location"""
    lang = {
        Audit.Type.Insert: trans('set the location'),
        Audit.Type.Update: trans('updated the location'),
        Audit.Type.Delete: trans('deleted the location'),
        Audit.Type.PendingApprove: trans('approved an '
                                         'edit of the location'),
        Audit.Type.PendingReject: trans('rejected an '
                                        'edit of the location')
    }
    return lang[action]
Esempio n. 40
0
    def __init__(self, *args, **kwargs):
        super(RegistrationForm, self).__init__(*args, **kwargs)

        self.fields['email'].label = trans('Email')
        self.fields['password2'].label = trans('Confirm Password')

        for field_name, field in self.fields.items():
            if not isinstance(field, forms.BooleanField):
                field.widget.attrs['class'] = 'form-control'

        self.fields['password1'].widget.attrs['outer_class'] = 'field-left'
        self.fields['password2'].widget.attrs['outer_class'] = 'field-right'
        self.fields['first_name'].widget.attrs['outer_class'] = 'field-left'
        self.fields['last_name'].widget.attrs['outer_class'] = 'field-right'
Esempio n. 41
0
File: udf.py Progetto: atogle/OTM2
    def update_choice(
            self, old_choice_value, new_choice_value, name=None):
        datatype = self.datatype_dict

        if self.iscollection:
            if name is None:
                raise ValidationError({
                    'name': trans('Name is required for collection fields')})

            datatypes = {info['name']: info for info in datatype}
            datatype = self._validate_and_update_choice(
                datatypes[name], old_choice_value, new_choice_value)

            datatypes[name] = datatype
            self.datatype = json.dumps(datatypes.values())
            self.save()

            vals = UserDefinedCollectionValue\
                .objects\
                .filter(field_definition=self)\
                .extra(where=["data ? %s AND data->%s = %s"],
                       params=[name, name, old_choice_value])

            if new_choice_value is None:
                vals.hremove('data', name)
            else:
                vals.hupdate('data', {name: new_choice_value})

            audits = Audit.objects.filter(
                model='udf:%s' % self.pk,
                field='udf:%s' % name)

            # If the string is empty we want to delete the audits
            # _update_choices_on_audits only does nf new_choice_value
            # is none
            if new_choice_value == '':
                new_choice_value = None

            self._update_choices_on_audits(
                audits, old_choice_value, new_choice_value)
        else:
            if name is not None:
                raise ValidationError({
                    'name': trans(
                        'Name is allowed only for collection fields')})

            self._update_choice_scalar(old_choice_value, new_choice_value)

        # indicate success to transaction manager
        return True
class SendConnectionResponseForm(SendConnectionInvitationForm):
    invitation_id = forms.IntegerField(widget=forms.HiddenInput())
    invitation_details = forms.CharField(label=trans('Invitation'),
                                         max_length=4000,
                                         widget=forms.Textarea)
    invitation_url = forms.CharField(label=trans('Invitation URL'),
                                     max_length=4000,
                                     widget=forms.Textarea)

    def __init__(self, *args, **kwargs):
        super(SendConnectionResponseForm, self).__init__(*args, **kwargs)
        self.fields['invitation_id'].widget.attrs['readonly'] = True
        self.fields['invitation_details'].widget.attrs['readonly'] = True
        self.fields['invitation_url'].widget.attrs['readonly'] = True
class SendCredentialRevokeForm(SendConversationResponseForm):
    # a bunch of fields that are read-only to present to the user
    agent_name = forms.CharField(widget=forms.HiddenInput())
    cred_rev_id = forms.CharField(label=trans('Cred_rev_id'), max_length=10)
    rev_reg_id = forms.CharField(widget=forms.HiddenInput())
    conversation_id = forms.CharField(label=trans('conversation_id'),
                                      max_length=120)

    def __init__(self, *args, **kwargs):
        super(SendCredentialRevokeForm, self).__init__(*args, **kwargs)
        self.fields['agent_name'].widget.attrs['readonly'] = True
        self.fields['cred_rev_id'].widget.attrs['readonly'] = True
        self.fields['conversation_id'].widget.attrs['readonly'] = True
        self.fields['rev_reg_id'].widget.attrs['hidden'] = True
Esempio n. 44
0
def _action_format_string_for_location(action):
    """A helper that allows multiple auditable models to return the
    same action format string for a field value that should be displayed
    as a location"""
    lang = {
        Audit.Type.Insert: trans('set the location'),
        Audit.Type.Update: trans('updated the location'),
        Audit.Type.Delete: trans('deleted the location'),
        Audit.Type.PendingApprove: trans('approved an '
                                         'edit of the location'),
        Audit.Type.PendingReject: trans('rejected an '
                                        'edit of the location')
    }
    return lang[action]
Esempio n. 45
0
class BaseSignUpForm(UserCreationForm):
    first_name = forms.CharField(max_length=80,
                                 label=trans('First Name'),
                                 required=False,
                                 help_text='Optional.')
    last_name = forms.CharField(max_length=150,
                                label=trans('Last Name'),
                                required=False,
                                help_text='Optional.')
    email = forms.EmailField(
        max_length=254,
        label=trans('Email Address'),
        required=True,
        help_text=trans('Required. Provide a valid email address.'))
Esempio n. 46
0
File: views.py Progetto: heath/OTM2
def approve_or_reject_photo(
        request, instance, feature_id, tree_id, photo_id, action):

    approved = action == 'approve'

    if approved:
        msg = trans('Approved')
    else:
        msg = trans('Rejected')

    resp = HttpResponse(msg)

    tree = get_object_or_404(
        Tree, plot_id=feature_id, instance=instance, pk=tree_id)

    try:
        photo = TreePhoto.objects.get(pk=photo_id, tree=tree)
    except TreePhoto.DoesNotExist:
        # This may be a pending tree. Let's see if there
        # are pending audits
        pending_audits = Audit.objects\
                              .filter(instance=instance)\
                              .filter(model='TreePhoto')\
                              .filter(model_id=photo_id)\
                              .filter(requires_auth=True)

        if len(pending_audits) > 0:
            # Process as pending and quit
            approve_or_reject_audits_and_apply(
                pending_audits, request.user, approved)

            return resp
        else:
            # Error - no pending or regular
            raise Http404('Tree Photo Not Found')

    # Handle the id audit first
    all_audits = []
    for audit in photo.audits():
        if audit.field == 'id':
            all_audits = [audit] + all_audits
        else:
            all_audits.append(audit)

    for audit in all_audits:
        approve_or_reject_existing_edit(
            audit, request.user, approved)

    return resp
Esempio n. 47
0
def approve_or_reject_photo(request, instance, feature_id, photo_id, action):

    approved = action == 'approve'

    if approved:
        msg = trans('Approved')
    else:
        msg = trans('Rejected')

    resp = HttpResponse(msg)

    try:
        photo = (MapFeaturePhoto.objects.select_related('treephoto').get(
            pk=photo_id))
        try:
            photo = photo.treephoto
        except MapFeaturePhoto.DoesNotExist:
            pass  # There is no tree photo, so use the superclass
    except MapFeaturePhoto.DoesNotExist:
        # This may be a pending tree. Let's see if there
        # are pending audits
        pending_audits = Audit.objects\
            .filter(instance=instance)\
            .filter(model__in=['TreePhoto', 'MapFeaturePhoto'])\
            .filter(model_id=photo_id)\
            .filter(requires_auth=True)

        if len(pending_audits) > 0:
            # Process as pending and quit
            approve_or_reject_audits_and_apply(pending_audits, request.user,
                                               approved)

            return resp
        else:
            # Error - no pending or regular
            raise Http404('Photo Not Found')

    # Handle the id audit first
    all_audits = []
    for audit in photo.audits():
        if audit.field == 'id':
            all_audits = [audit] + all_audits
        else:
            all_audits.append(audit)

    for audit in all_audits:
        approve_or_reject_existing_edit(audit, request.user, approved)

    return resp
Esempio n. 48
0
    def update_choice(self, old_choice_value, new_choice_value, name=None):
        datatype = self.datatype_dict

        if self.iscollection:
            if name is None:
                raise ValidationError(
                    {'name': trans('Name is required for collection fields')})

            datatypes = {info['name']: info for info in datatype}
            datatype = self._validate_and_update_choice(
                datatypes[name], old_choice_value, new_choice_value)

            datatypes[name] = datatype
            self.datatype = json.dumps(datatypes.values())
            self.save()

            vals = UserDefinedCollectionValue\
                .objects\
                .filter(field_definition=self)\
                .extra(where=["data ? %s AND data->%s = %s"],
                       params=[name, name, old_choice_value])

            if new_choice_value is None:
                vals.hremove('data', name)
            else:
                vals.hupdate('data', {name: new_choice_value})

            audits = Audit.objects.filter(model='udf:%s' % self.pk,
                                          field='udf:%s' % name)

            # If the string is empty we want to delete the audits
            # _update_choices_on_audits only does nf new_choice_value
            # is none
            if new_choice_value == '':
                new_choice_value = None

            self._update_choices_on_audits(audits, old_choice_value,
                                           new_choice_value)
        else:
            if name is not None:
                raise ValidationError({
                    'name':
                    trans('Name is allowed only for collection fields')
                })

            self._update_choice_scalar(old_choice_value, new_choice_value)

        # indicate success to transaction manager
        return True
Esempio n. 49
0
def _no_results_response(address, inregion=False):
    response = HttpResponse()
    response.status_code = 404

    if inregion:
        err = trans("No results found in the area for %(address)s")
    else:
        err = trans("No results found for %(address)s")

    content = {'error': err % {'address': address}}

    response.write(json.dumps(content))
    response['Content-length'] = str(len(response.content))
    response['Content-Type'] = "application/json"
    return response
Esempio n. 50
0
def update_user(request, user_id):
    user = get_object_or_404(User, pk=user_id)

    if user.pk != request.user.pk:
        return HttpResponseForbidden()

    data = json.loads(request.body)

    errors = {}
    for field in ALL_FIELDS:
        if field in data:
            if field in REQ_FIELDS and not field:
                errors[field] = [trans('This field cannot be empty')]
            else:
                if field == 'password':
                    user.set_password(data[field])
                else:
                    setattr(user, field, data[field])

    if errors:
        raise ValidationError(errors)
    else:
        user.save()

    return _context_dict_for_user(user)
Esempio n. 51
0
def context_dict_for_resource(request, resource):
    context = context_dict_for_map_feature(request, resource)
    instance = request.instance

    # Give them 2 for adding the resource and answering its questions
    total_progress_items = 3
    completed_progress_items = 2

    photos = resource.photos()
    context['photos'] = map(context_dict_for_photo, photos)

    has_photos = len(photos) > 0

    if has_photos:
        completed_progress_items += 1

    context['upload_photo_endpoint'] = reverse(
        'add_photo_to_map_feature',
        kwargs={'instance_url_name': instance.url_name,
                'feature_id': resource.pk})

    context['progress_percent'] = int(100 * (
        completed_progress_items / total_progress_items) + .5)

    context['progress_messages'] = []
    if not has_photos:
        context['progress_messages'].append(trans('Add a photo'))

    audits = _map_feature_audits(request.user, request.instance, resource)

    _add_audits_to_context(audits, context)

    return context
Esempio n. 52
0
    def short_descr(self):
        cls = _get_auditable_class(self.model)
        format_string = cls.action_format_string_for_audit(self)

        return format_string % {'field': self.field_display_name,
                                'model': trans(self.model).lower(),
                                'value': self.current_display_value}
Esempio n. 53
0
    def short_descr(self):
        cls = _lookup_model(self.model)
        format_string = cls.action_format_string_for_audit(self)

        return format_string % {'field': self.field.replace('_', ' '),
                                'model': trans(self.model).lower(),
                                'value': self.current_display_value}
Esempio n. 54
0
File: udf.py Progetto: atogle/OTM2
    def _validate_single_datatype(self, datatype):
        if 'type' not in datatype:
            raise ValidationError(trans('type required data type definition'))

        if datatype['type'] not in ['float', 'int', 'string',
                                    'user', 'choice', 'date']:
            raise ValidationError(trans('invalid datatype'))

        if datatype['type'] == 'choice':
            choices = datatype.get('choices', None)

            if choices is None:
                raise ValidationError(trans('missing choices key for key'))

            for choice in choices:
                if not isinstance(choice, basestring):
                    raise ValidationError(trans('Choice must be a string'))
                if choice is None or choice == '':
                    raise ValidationError(trans('empty choice not allowed'))

            if len(choices) == 0:
                raise ValidationError(trans('empty choice list'))

            if len(choices) != len(set(choices)):
                raise ValidationError(trans('duplicate choices'))
Esempio n. 55
0
File: udf.py Progetto: PyBulls/OTM2
    def _validate_single_datatype(self, datatype):
        if 'type' not in datatype:
            raise ValidationError(trans('type required data type definition'))

        if datatype['type'] not in ['float', 'int', 'string',
                                    'user', 'choice', 'date']:
            raise ValidationError(trans('invalid datatype'))

        if datatype['type'] == 'choice':
            choices = datatype.get('choices', None)

            if choices is None:
                raise ValidationError(trans('missing choices key for key'))

            for choice in choices:
                if not isinstance(choice, basestring):
                    raise ValidationError(trans('Choice must be a string'))
                if choice is None or choice == '':
                    raise ValidationError(trans('empty choice not allowed'))

            if len(choices) == 0:
                raise ValidationError(trans('empty choice list'))

            if len(choices) != len(set(choices)):
                raise ValidationError(trans('duplicate choices'))

        if 'default' in datatype:
            try:
                self.clean_value(datatype['default'], datatype)
            except ValidationError as e:
                raise ValidationError(
                    'Default must be valid for field: %(underlying_error)s' %
                    {'underlying_error': e.message})
Esempio n. 56
0
def title_for_map_feature(feature):
    # Cast allows the map feature subclass to handle generating
    # the display name
    feature = feature.cast_to_subtype()

    if feature.is_plot:
        tree = feature.current_tree()
        if tree:
            if tree.species:
                title = tree.species.common_name
            else:
                title = trans("Missing Species")
        else:
            title = trans("Empty Planting Site")
    else:
        title = feature.display_name

    return title
Esempio n. 57
0
def get_map_view_context(request, instance):
    resource_classes = [MapFeature.get_subclass(type)
                        for type in instance.map_feature_types]
    return {
        'fields_for_add_tree': [
            (trans('Tree Height'), 'Tree.height')
        ],
        'resource_classes': resource_classes[1:]
    }
Esempio n. 58
0
def udf_create(params, instance):
    data = _parse_params(params)
    name, model_type, datatype = (data['name'], data['model_type'],
                                  data['datatype'])

    udfs = UserDefinedFieldDefinition.objects.filter(
        instance=instance,
        # TODO: why isn't this also checking model name
        # is there some reason the same name can't appear
        # on more than one model?
        # Too scared to change this.
        name=name)

    if udfs.exists():
        raise ValidationError(
            {'udf.name':
             [trans("A user defined field with name "
                    "'%(udf_name)s' already exists") % {'udf_name': name}]})

    if model_type not in ['Tree', 'Plot']:
        raise ValidationError(
            {'udf.model': [trans('Invalid model')]})

    udf = UserDefinedFieldDefinition(
        name=name,
        model_type=model_type,
        iscollection=False,
        instance=instance,
        datatype=datatype)
    udf.save()

    field_name = udf.canonical_name

    # Add a restrictive permission for this UDF to all roles in the
    # instance
    for role in Role.objects.filter(instance=instance):
        FieldPermission.objects.get_or_create(
            model_name=model_type,
            field_name=field_name,
            permission_level=FieldPermission.NONE,
            role=role,
            instance=role.instance)

    return udf
Esempio n. 59
0
    def clean(self):
        super(MapFeature, self).clean()

        if not self.instance.bounds.contains(self.geom):
            raise ValidationError({
                "geom": [
                    trans(
                        "%(model)ss must be created inside the map boundaries")
                    % {'model': self.display_name}]
            })