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
