def get_term(service, code, default): if isinstance(service, User): term = get_object_or_None( ServiceTerm, service=service.service, code=code ) else: term = get_object_or_None(ServiceTerm, service=service, code=code) return getattr(term, 'term') if hasattr(term, 'term') else default
def clean_username(self): username = self.cleaned_data["username"] user = get_object_or_None(User, username__iexact=username) if user: if user != self.request.user: raise forms.ValidationError(_("You can not choose this username")) return username
def invite_register(request, sid): invite = get_object_or_None(Invite, sid=sid) offset = datetime.now() + timedelta(hours=settings.INVITE_EXPIRES_HOURS) if invite.expire_date > offset: invite.is_expired = True invite.save() return {'redirect': 'core:ufo'} if not invite: return {'redirect': 'core:ufo'} form = InviteRegisterForm(request.POST or None, invite=invite ) if request.method == 'POST': if form.is_valid(): invite.is_verified = True user = form.save(commit=False) # user.email = invite.email user.set_password(form.cleaned_data['password']) user.save() invite.reciever = user invite.save() return {'redirect': 'accounts:invite-register-success'} days = xrange(1, 32) months = xrange(1, 13) years = xrange(1930, 2012) return {'form': form, 'sid': sid, 'days': days, 'months': months, 'years': years}
def get_addons(request, pk): container = get_object_or_None(Container, pk=pk) addon_list = AddonList.objects.filter(container=container) addons = Addon.objects.filter(list__in=addon_list) return { 'addons': addons }
def save(self, commit=True): types = self.data.getlist("contact_phone_type") phones = self.data.getlist("contact_phone") for (tp, phone) in zip(types, phones): instance = ContactPhone.objects.filter(phone=phone, user=self.instance) typ = get_object_or_None(ContactPhoneType, pk=tp) if not typ: continue # ignore phone with invalid type if not phone.isdigit(): continue # skip phones with alphas if instance: instance[0].type = typ instance[0].save() else: phone = phone[0:10] if len(phone) > 11 else phone instance = ContactPhone.objects.create(user=self.instance, phone=phone, type=typ) emails = self.data.getlist("contact_email") for email in emails: instance = ContactEmail.objects.filter(email=email, user=self.instance) if instance: instance[0].save() else: instance = ContactEmail.objects.create(user=self.instance, email=email) if commit: self.instance.save() return self.instance
def order_repeat(request, pk): order = get_object_or_404(Order, pk=pk) containers = order.order_container_order_set.all() cart = Cart(request) if cart.cart.item_set.count() != 0: messages.error( request, _("You can not repeat order if there's something " "in the cart, please cleanse it") ) # return redirect(request.META.get('HTTP_REFERER', '/')) return redirect(reverse('catalog:service-page', args=(order.container.owner.pk,))) for container in containers: model_class = container.content_type.model_class() item = get_object_or_None( model_class.whole_objects, pk=container.object_id ) if item.is_deleted: messages.warning( request, _("Item '%s' does not exist anymore, sorry") % \ item.title ) else: cart.add(item, item.get_cost(), container.quantity) # return redirect(request.META.get('HTTP_REFERER', '/')) return redirect(reverse('catalog:service-page', args=(order.container.owner.pk,)))
def save(self, commit=True): lats = self.data.getlist("lat") lngs = self.data.getlist("lng") ids = self.data.getlist("id") descriptions = self.data.getlist("description") from itertools import chain if not all(chain(*(lats, lngs))): return self.instance # saving instances for (pk, lat, lng, description) in zip(ids, lats, lngs, descriptions): position = get_object_or_None(GPos, pk=pk) position.lat = lat position.lng = lng position.description = description position.user = self.instance position.save() # new coords for (lat, lng, description) in zip(lats[len(ids) :], lngs[len(ids) :], descriptions[len(ids) :]): user = self.instance if any((lat, lng)): position = GPos.objects.create(lat=lat, lng=lng, description=description, user=user) if commit: self.instance.save() return self.instance
def clean_username(self): username = self.cleaned_data['username'] user = get_object_or_None(User, username__iexact=username) if user: raise forms.ValidationError( _("Sorry but such username already taken, \ please choose another or login")) return username
def wrapper(request, *args, **kwargs): from apps.core.models import Comment comment_id = kwargs[field] comment = get_object_or_None(Comment, id=comment_id) user = comment.author if comment else None if user == request.user: return func(request, *args, **kwargs) return HttpResponseRedirect(reverse('url_permission_denied'))
def subways(request, city_pk): city = get_object_or_None(City, pk=city_pk) subways = Subway.objects.filter( city=city) return { 'subways': subways }
def wrapper(request, *args, **kwargs): now = datetime.now() secure_id = kwargs[sid] invite = get_object_or_None( Invite, sid__iexact=secure_id, expire_date__gte=now ) if not invite: return redirect('core:ufo') return func(request, *args, **kwargs)
def wrapper(request, sid, **kwargs): session = get_object_or_None(XHRSession, pk=sid) if not session: return func(request, sid, **kwargs) if not session.is_secure or (session.is_secure and session.owner == request.user): return func(request, sid, **kwargs) response = HttpResponse() response['Content-Type'] = 'text/javascript' response.write('[]') return response
def wrapper(request, *args, **kwargs): if not field in kwargs: return redirect('core:blockage') pk = kwargs[field] ban = get_object_or_None(ServerBanList, pk=pk) if not ban: return redirect('core:does-not-exists') if ban.owner == request.user: return func(request, *args, **kwargs) return redirect('core:blockage')
def wrapper(request, *args, **kwargs): cart = Cart(request) pk = kwargs[field] if type == 'item': item = get_object_or_None(Item, pk=pk) elif type == 'addon': item = get_object_or_None(Addon, pk=pk) else: return func(request, *args, **kwargs) if not item: return func(request, *args, **kwargs) # always proceed if cart is clean if not cart.cart.item_set.count(): return func(request, *args, **kwargs) item_ct = get_model_content_type(Item) addon_ct = get_model_content_type(Addon) if type == 'item': source_item = cart.cart.item_set.filter( content_type=item_ct)[0] source_owner = source_item.product.container.owner dst_owner = item.container.owner elif type == 'addon': source_item = cart.cart.item_set.filter( content_type=item_ct)[0] source_owner = source_item.product.container.owner dst_owner = item.list.container.owner else: source_owner = True dst_owner = False # some sort of trick #validate source and dst owners if source_owner != dst_owner: messages.info( request, _("You can not order stuff with \ another services or providers") ) return redirect(request.META.get('HTTP_REFERER', '/')) return func(request, *args, **kwargs)
def create(self, **kwargs): model_class = self.model if 'user' in kwargs: if isinstance(kwargs['user'], User): user = get_object_or_None(self.model, pk=kwargs['user'].pk) if user: return user sid = uuid1().hex kwargs.update({'sid': sid}) instance = super(VerificationManager, self).create(**kwargs) return instance
def save(self, commit=True): quantities, containers = map(self.data.getlist, ['quantity', 'container']) for quantity, container in zip(quantities, containers): order_container = get_object_or_None(OrderContainer, pk=container) if order_container and quantity.isdigit(): order_container.quantity = int(quantity) order_container.save() if commit: self.instance.save() return self.instance
def add(request, pk=None): instance = get_object_or_None(ServerBanList, pk=pk) form = AddServerBanForm(request.POST or None, instance=instance) if request.method == 'POST': if form.is_valid(): ban = form.save(commit=False) ban.owner = request.user ban.save() return {'redirect': 'banlist:index'} return { 'form': form }
def order_price(request, pk): user = get_object_or_None(User, pk=pk) if not user: return {'status': 'failed', 'success': False} form = CoordinatesForm(request.POST or None) if request.method == 'POST': if form.is_valid(): lat = form.cleaned_data['lat'] lng = form.cleaned_data['lng'] data = user.get_deliver_price(lat, lng) return data return {'form': form, 'success': not bool(form.errors)}
def invite_register(request, sid): invite = get_object_or_None(Invite, sid=sid) if not invite: return {'redirect': 'core:ufo'} form = InviteRegisterForm(request.POST or None) if request.method == 'POST': if form.is_valid(): invite.is_verified = True invite.save() user = form.save(commit=False) user.email = invite.email user.set_password(form.cleaned_data['password']) user.save() return {'redirect': 'accounts:invite-register-success'} return {'form': form, 'sid': sid}
def wrapper(request, *args, **kwargs): pk = kwargs[field] Obj = get_model(*kw['model'].lower().split('.')) item = get_object_or_None(Obj, pk=pk) if not item and allow_create: return func(request, *args, **kwargs) mapper = [item, ] + kw['check_path'].split('.') user = reduce( lambda x, y: getattr(x, y) if hasattr(x, y) else None, mapper ) if user == request.user: return func(request, *args, **kwargs) return redirect('core:blockage')
def password_restore(request, sid): instance = get_object_or_None(UserSID, sid=sid, expired=False) if not instance: request.session['brute_force_iter'] \ = request.session.get('brute_force_iter', 0) + 1 raise Http404("not found") form = PasswordRestoreForm( request.POST or None, instance=instance, request=request ) if request.method == 'POST': if form.is_valid(): form.save() return {'redirect': 'core:password-restored'} return {'form': form}
def save(self, commit=True): super(PartnerEditOrgForm, self).save(commit) deliver_min, deliver_max, deliver_cost = map(self.data.getlist, ["deliver_min", "deliver_max", "deliver_cost"]) for (mn, mx, cost) in zip(deliver_min, deliver_max, deliver_cost): dc = DeliverCost.objects.filter(min=mn, max=mx, cost=cost, user=self.instance) if not dc: DeliverCost.objects.create(min=mn, max=mx, cost=cost, user=self.instance) # proceeding time user = self.instance schedule = self.instance.schedule if not schedule: schedule = Schedule.objects.create(user=user) for day in xrange(1, 8): day_enabled = self.data.get("day-%s" % day) since = self.data.get("day-%s-since" % day) until = self.data.get("day-%s-until" % day) # disabling day if not found it if day_enabled is None: timeday = get_object_or_None(schedule.days, weekday=day) if timeday: timeday.is_active = False timeday.save() if all((day, since, until)): timeday = get_object_or_None(schedule.days, weekday=day) if not timeday: if day_enabled: timeday = TimeNDay.objects.create( weekday=day, since=since, until=until, schedule=schedule, is_active=True ) else: timeday.since = since timeday.until = until if day_enabled: timeday.is_active = True timeday.save() return self.instance
def container(request, pk): container = get_object_or_None(Container, pk=pk) options = Container.objects.filter( owner=container.owner, container=None).values('pk', 'title') options = [{'value': i['pk'], 'title': i['title']} for i in options] fields = [ 'id', 'title', 'description', 'service_id', 'pk', 'owner_id', 'mean_rating', 'category_id', 'weight', ] container = copy_fields(container, fields) return { 'container': container, 'options': options }
def wrapper(request, *args, **kwargs): appid = request.POST.get('appid', request.GET.get('appid', None)) if not appid: return func(request, *args, **kwargs) app = get_object_or_None(WebApp, id=appid) if not app: return func(request, *args, **kwargs) response = func(request, *args, **kwargs) proto = request.META.get('HTTP_ORIGIN', '') m = re.match(re.compile('http[s]'), proto) proto = m.group() if m else 'http' response['Access-Control-Allow-Origin'] = '%(proto)s://%(domain)s' % { 'domain': app.domain, 'proto': proto } return response
def set_areas(city, areas): for area in areas: # print area[0] # print city.title subway = get_object_or_None(Subway, title__iexact=area[0], city=city) if not subway: print "there is no such subway: %s" % area[0] continue if not subway.yalinks.all(): coord = ",".join([str(i) for i in area[1]]) type_id = None create = dict(subway=subway, coords=coord) if len(area[1]) > 4: typ_id = YaType.objects.get(title="poly") create.update({"type": typ_id}) YaLink.objects.create(**create)
def special_add(request, pk=None): instance = get_object_or_None(Special, pk=pk) if instance and instance.owner != request.user: raise Http404("not allowed") form = AddSpecialForm( request.POST or None, request.FILES or None, instance=instance ) if request.method == 'POST': if form.is_valid(): instance = form.save(commit=False) instance.owner = request.user instance.save() return { 'redirect': 'catalog:service-partner-specials', 'redirect-args': (request.user.pk,) } return {'form': form}
def addon_add(request, pk=None): container = get_object_or_None(Container, pk=pk) if container.owner != request.user: raise Http404("not allowed") form = AddAddonForm( request.POST or None, request=request, initial={ 'container': container } ) if request.method == 'POST': if form.is_valid(): form.save() return { 'redirect': 'catalog:addon-list', 'redirect-args': (form.cleaned_data['container'].pk,) } return {'form': form}
def __init__(self, *args, **kwargs): if "request" in kwargs: self.request = kwargs["request"] del kwargs["request"] super(UserRegisterForm, self).__init__(*args, **kwargs) if "username" in self.base_fields: del self.base_fields["username"] del self.fields["username"] if hasattr(self, "request"): from django.contrib.gis.utils import GeoIP geoip = GeoIP() iso_city = (geoip.city(self.request.META.get("REMOTE_ADDR", "127.0.0.1")) or {}).get("city") city = get_object_or_None(City, iso__iexact=iso_city or "") if city: self.fields["city"].initial = city.pk
def register_user(request): form = UserRegisterForm(request.POST or None, request=request) if request.method == 'POST': if form.is_valid(): user = form.save(commit=False) sms = SMSLogger(provider='disms', text=settings.USER_REGISTER_SMS % { 'login': form.cleaned_data['email'], 'password': form.cleaned_data['password'] }, phone=form.cleaned_data['phone'] ) sms.send_message() user.set_password(form.cleaned_data['password']) user.is_active = True user.is_verified = True user.save() auth_user = auth.authenticate(username=user.email, password=form.cleaned_data['password']) auth.login(request, auth_user) # auth.login(request, auth_user) # process invite expired = datetime.now() + \ timedelta(hours=settings.INVITE_EXPIRES_HOURS) invite = get_object_or_None( Invite, email=form.cleaned_data['email'], expire_date__lte=expired ) if invite: invite.is_verified = True invite.receiver = user invite.save() return {'redirect': 'accounts:register-success', 'user': user} else: return {'redirect': 'catalog:index'} days = xrange(1, 32) months = xrange(1, 13) years = xrange(1930, 2012) return {'form': form, 'days': days, 'months': months, 'years': years}
def clean(self): cd = self.cleaned_data item = self.cleaned_data.get('item') or None item_instance = get_object_or_None(Item, pk=item) if item_instance: cart = Cart(self.request) item_ct = get_model_content_type(Item) items = cart.cart.item_set.filter(content_type=item_ct) if items: cart_item = items[0].product if cart_item.container.owner != item_instance.container.owner: dst = item_instance.container.owner.service_name or "-" src = cart_item.container.owner.service_name or "-" msg = _("You can not add multiply service items") if settings.PARTNER_ORDER_ITEM_MESSAGES_WARNING: messages.warning( self.request, _('You\'re trying to stock items from "%(dst)s" delivery. ' 'Do you want to cleanse "%(src)s" items?') % { 'dst': dst, 'src': src }, extra_tags='cleanse_cart' ) self._errors['item'] = ErrorList([msg, 400]) if 'item' in cd: del cd['item'] else: msg = _("No item was found with such id") self._errors['item'] = ErrorList([msg]) if 'item' in cd: del cd['item'] return cd