def handle_noargs(self, **options):
tmp = UserProfile.objects.values('user').filter(send_report=1)
ids = [profile['user'] for profile in tmp]
users = User.objects.filter(id__in=ids)
url = getattr(settings, 'QUARANTINE_REPORT_HOSTURL', '')
a_day = datetime.timedelta(days=1)
yesterday = datetime.date.today() - a_day
from_email = getattr(settings, 'DEFAULT_FROM_EMAIL',
'postmaster@localhost')
logo_path = getattr(settings, 'MEDIA_ROOT', '') + '/imgs/css/logo.jpg'
logo = open(logo_path, 'rb').read()
print _("=== Processing quarantine notifications ===")
for user in users:
if email_re.match(user.email) or email_re.match(user.username):
spam_list = Message.quarantine_report.for_user(user).values(
'id', 'timestamp', 'from_address', 'to_address', 'subject'
).exclude(timestamp__lt=yesterday).exclude(
spam=0).order_by('sascore')[:25]
policy_list = Message.quarantine_report.for_user(user).values(
'id', 'timestamp', 'from_address', 'to_address', 'subject'
).exclude(timestamp__lt=yesterday).exclude(Q(spam=1) |
Q(nameinfected=0) | Q(otherinfected=0) | Q(virusinfected=0)
).order_by('sascore')[:25]
subject = _('Baruwa quarantine report for %(user)s') % {
'user': user.username}
if email_re.match(user.username):
to_addr = user.username
if email_re.match(user.email):
to_addr = user.email
if spam_list or policy_list:
for query_list in [spam_list, policy_list]:
add_uuids(query_list)
html_content = render_to_string(
'messages/quarantine_report.html',
{'spam_items': spam_list, 'policy_items': policy_list,
'host_url': url})
text_content = render_to_string(
'messages/quarantine_report_text.html',
{'spam_items': spam_list, 'policy_items': policy_list,
'host_url': url})
msg = EmailMultiAlternatives(subject, text_content,
from_email, [to_addr])
embed_img(msg, 'baruwalogo', logo)
msg.attach_alternative(html_content, "text/html")
try:
msg.send()
for query_list in [spam_list, policy_list]:
generate_release_records(query_list)
print _("sent quarantine report to %(addr)s") % {'addr': to_addr}
except SMTPException:
print _("failed to send to: %(addr)s") % {'addr': to_addr}
else:
print _("skipping report to %(addr)s no messages") % {'addr': to_addr}
print _("=== completed quarantine notifications ===")
def clean(self):
cleaned_data = self.cleaned_data
field_function = cleaned_data.get("field_function")
choices = cleaned_data.get("choices")
field_type = cleaned_data.get("field_type")
required = cleaned_data.get("required")
if field_function == "GroupSubscription":
if field_type != "BooleanField":
raise forms.ValidationError(_("This field's function requires Checkbox as a field type"))
if not choices:
raise forms.ValidationError(_("This field's function requires at least 1 group specified."))
else:
for val in choices.split(','):
try:
Group.objects.get(name=val.strip())
except Group.DoesNotExist:
raise forms.ValidationError(_("The group \"%(val)s\" does not exist" % { 'val' : val }))
if field_function == "Recipients":
if (field_type != "MultipleChoiceField/django.forms.CheckboxSelectMultiple" and
field_type != "MultipleChoiceField" and
field_type != "BooleanField" and
field_type != "ChoiceField"):
raise forms.ValidationError(_("The \"Email to Recipients\" function requires Multi-select - Checkboxes "
+ "or Multi-select - Select Many as field type"))
if field_type == "BooleanField":
if not choices:
raise forms.ValidationError(_("The \"Email to Recipients\" function requires at least 1 email specified."))
else:
for val in choices.split(','):
if not email_re.match(val.strip()):
raise forms.ValidationError(_("\"%(val)s\" is not a valid email address" % {'val':val}))
else:
if not choices:
raise forms.ValidationError(_("The \"Email to Recipients\" function requires at least 1 choice specified."))
else:
for val in choices.split(','):
val = val.split(':')
if len(val) < 2:
raise forms.ValidationError(_("The \"Email to Recipients\" function requires choices to be in the following format: <choice_label>:<email_address>."))
if not email_re.match(val[1].strip()):
raise forms.ValidationError(_("\"%(val)s\" is not a valid email address" % {'val':val[1]}))
if field_function != None and field_function.startswith("Email"):
if field_type != "CharField":
raise forms.ValidationError(_("This field's function requires Text as a field type"))
#unrequire the display only fields
if field_type == "CharField/tendenci.apps.forms_builder.forms.widgets.Description":
cleaned_data['required'] = False
elif field_type == "CharField/tendenci.apps.forms_builder.forms.widgets.Header":
cleaned_data['required'] = False
return cleaned_data
def create_mri_action(request):
name = request.POST['name']
email = request.POST['email']
address = request.POST['address']
address2 = request.POST['address2']
state = request.POST['state']
city = request.POST['city']
try:
phone = long(request.POST['phone'])
zip = int(request.POST['zip'])
except:
messages.error(request, 'Phone and zipcode must be numbers')
return redirect('main.views.quantmd.create_mri_view')
if (not name.strip() or not email.strip() or not address.strip() or not city.strip() or not state.strip()):
messages.error(request, 'Only address line 2 can be empty.')
return redirect('main.views.quantmd.create_mri_view')
if not email_re.match(email):
messages.error(request, 'Email format not correct.')
return redirect('main.views.quantmd.create_mri_view')
if MRICenter.objects.filter(name=name).exists():
messages.error('There is a same name MRI center in quantmd')
return redirect('main.views.quantmd.create_mri_view')
city = city.upper()
mri = MRICenter.objects.create(name=name,address=address,phone=phone,email=email,state=state,city=city,zip=zip)
if len(address2) != 0:
mri.address2 =address2
mri.save()
return render_to_response('quantmd/mri-create-confirm.htm',{'mri':mri}, context_instance=RequestContext(request))
def clean_send_to(self):
value = self.cleaned_data["send_to"]
emails = filter(bool, split_re.split(value))
for email in emails:
if not email_re.match(email):
raise ValidationError("%s is not a valid e-mail address." % (email,))
return ",".join(emails)
def save(self, *args, **kwargs):
if self.nombre == u'':
self.nombre = "(Anonymous)"
if self.correo:
if not email_re.match(self.correo):
raise ValidationError(u'%s no es una dirección de correo válida' % self.correo)
super(User, self).save(*args, **kwargs)
def subscribe(request):
# get and validate email
email = request.POST.get('email', '')
if not email or not email_re.match(email):
error = u'Please, enter valid email address.'
return render_to_response('index.html', {'error': error},
context_instance=RequestContext(request))
# get subscribers list and try to add new subscriber
try:
elist = mailchimp.utils.get_connection().get_list_by_id(
MAILCHIMP_LIST_ID)
except Exception:
error = u'Sorry, there are some issues on the server. Please, try ' \
'again a bit later'
return render_to_response('index.html', {'error': error},
context_instance=RequestContext(request))
# finally try to subscribe
try:
elist.subscribe(email, {'EMAIL': email})
except Exception, e:
# check if already subscribed
if u'is already subscribed' in e.message:
error = u'You are already subscribed to our newsletter.'
elif u'Invalid Email Address' in e.message:
error = u'Please, enter valid email address.'
else:
error = u'Sorry, there are some issues on the server. Please, ' \
'try again a bit later'
return render_to_response('index.html', {'error': error},
context_instance=RequestContext(request))
def verify_email(email, **kwargs):
ip = _try_to_get_ip(kwargs)
yesterday = utils.now() - timedelta(days=1)
five = utils.now() - timedelta(seconds=5)
if db.EmailVerify.objects.filter(email=email, created__gt=five).count():
return []
invalid = False
invalid |= not email_re.match(email)
invalid |= db.User.objects.filter(email=email).count() > 0
invalid |= db.EmailBlacklist.objects.filter(email=email).count() > 0
invalid |= (
db.EmailVerify.objects.filter(email=email, created__gt=yesterday).count() > settings.SPARK_AUTH_MAX_EMAIL_DAY
)
if ip:
invalid |= (
db.EmailVerify.objects.filter(ip=ip, created__gt=yesterday).count() > settings.SPARK_AUTH_MAX_EMAIL_DAY
)
if invalid:
raise utils.APIException("invalid email address")
code = db.base36(4)
db.EmailVerify.objects.create(email=email, code=code, ip=ip)
body = render_to_string("sparkles/email_verify.html", {"code": code})
msg = mail.EmailMessage("Sparkles Email Verification Code", body, "*****@*****.**", [email])
msg.content_subtype = "html"
msg.send()
return []
def clean(self):
cleaned_data = super(UserEditForm, self).clean()
current_password = cleaned_data.get("current_password")
new_password = cleaned_data.get("new_password")
new_password_check = cleaned_data.get("new_password_check")
new_email = cleaned_data.get("new_email")
location = cleaned_data.get("location")
if not current_password:
raise forms.ValidationError(
'You must enter your current password to make any changes.')
if not self.user.check_password(current_password):
raise forms.ValidationError('That password was incorrect.')
if new_password and new_password_check:
if len(new_password) < 5:
raise forms.ValidationError(
'Your new password must be at least 5 characters.')
if new_password != new_password_check:
raise forms.ValidationError('Your new passwords do not match.')
elif new_email:
if not email_re.match(new_email):
raise forms.ValidationError('Not a valid email address')
elif location == 'empty':
raise forms.ValidationError(
'You have not changed any information.')
return cleaned_data
def register(request):
username = request.POST['username']
password = request.POST['password']
email = request.POST['email']
# Check to make sure stuffs is valid
errors = {}
if email:
if not email_re.match(email):
errors['email'] = "Invalid email format."
else:
try:
User.objects.get(email=email)
errors['email'] = "Email is already taken."
except User.DoesNotExist:
pass
if not username:
errors['username'] = "******"
else:
try:
User.objects.get(username=username)
errors['username'] = "******"
except User.DoesNotExist:
pass
if not password:
errors['password'] = "******"
if errors:
return HttpResponse(json.simplejson.dumps(errors), mimetype="application/json")
User.objects.create_user(username, email, password)
return login_user(request)
def send_email(request):
if not request.method == "POST":
raise Http404
p = request.POST
try:
name = p.get('_name','')
email = p.get('_email','')
s = p.get('_subject','')
m = p.get('_message','')
except:
return render_to_response('ajaxresponse.html',{'data':json.dumps( { 'status': { 'no':2 } } ) })
if (not name) or (not s) or (not m):
return render_to_response('ajaxresponse.html',{'data':json.dumps( { 'status': { 'no':2 } } ) })
elif not email_re.match(email):
return render_to_response('ajaxresponse.html',{'data':json.dumps( { 'status': { 'no':2} } ) })
try:
send_mail(s,m,email,['*****@*****.**'])
except BadHeaderError:
return render_to_response('ajaxresponse.html',{'data':json.dumps( { 'status': { 'no':2} } ) })
return render_to_response('ajaxresponse.html',{'data':json.dumps( { 'status': { 'no':1} } ) })
def ajax_change(request):
resp = {
"success": False,
}
if('old_pass' in request.POST and 'new_pass' in request.POST):
#got a change for pass
#check to make sure old_pass matches
user = authenticate(username=request.user.username, password=request.POST['old_pass'])
if(user is not None and user.is_active):
#old pass matches, change pass to new one
if len(request.POST['new_pass']) < MIN_PASS_LENGTH or len(request.POST['new_pass']) > MAX_PASS_LENGTH:
resp['error'] = 'Passwords must be 8-30 characters'
else:
user.set_password(request.POST['new_pass'])
user.save()
resp['success'] = True
else:
#old pass didn't match, pass back an error
resp['error'] = 'The password is incorrect. Did you forget it?'
elif('email' in request.POST):
#got a change for email
if not email_re.match(request.POST['email']):
resp['error'] = 'Please enter a valid email'
else:
request.user.email = request.POST['email']
request.user.save()
resp['success'] = True
else:
resp['error'] = 'Please fill out all the fields. They are all necessary'
return HttpResponse(json.dumps(resp), mimetype="application/json")
def handle_login(request, data):
"""
Login for user
"""
user_id = data.get('username', None)
if user_id:
user_id = user_id.replace(' ', '')
if email_re.match(user_id):
try:
target_user = User.objects.get(email__iexact = user_id)
except ObjectDoesNotExist:
target_user = None
else:
try:
target_user = User.objects.get(username__iexact = user_id)
except ObjectDoesNotExist:
target_user = None
if target_user:
user = authenticate(username = target_user.username,
password = data.get('password', None))
user_object = target_user
else:
user = None
if user is not None:
login(request, user)
return user
def post(self):
session = sessions.Session()
owner = Owner()
project = Project()
owner.first_name = str(self.request.get("first_name"))
owner.last_name = str(self.request.get("last_name"))
owner.company = str(self.request.get("company"))
owner.department = str(self.request.get("department"))
owner.project = str(self.request.get("project"))
if email_re.match(self.request.get("email")):
owner.email = self.request.get("email")
else:
print("Email format is not valid") # Replace by sentence below the input to allow edition
owner.put()
project.name = str(self.request.get("project"))
project.company = str(self.request.get("company"))
project.department = str(self.request.get("department"))
project.owner_name = str(self.request.get("first_name")) + " " + str(self.request.get("last_name"))
project.owner_email = self.request.get("email")
project.owner_key = str(owner.key())
project.put()
owner.project_key = str(project.key())
owner.put()
session["ProjectID"] = project.key() # sets keyname to value
self.redirect("/setup-team")
def is_valid_email(email):
'''
check is the email valid
'''
if email_re.match(email):
return True
return False
def handle(self, *args, **options):
"""Read emails from text file and create accounts. If
options['email'] is set then send out emails to invited users.
"""
if len(args) != 1:
LOGGER.error('Please provide a file with emails.')
sys.exit(-1)
with open(args[0], 'r') as input_file:
for email in input_file:
email = email.strip()
if not email_re.match(email):
LOGGER.warning('Ignoring not valid email: "%s"' % email)
continue
user, created = User.objects.get_or_create(
username=USERNAME_ALGO(email),
email=email)
if not created:
LOGGER.warning('User "%s" already exists' % email)
continue
# Send invitation email if option is True. Default (yes)
if options['email']:
send_mail(self.SUBJECT, self.MESSAGE,
self.FROM_EMAIL, [email])
def sanitize(first, last, email, bio, password):
result = [True, True, True, True, True]
for c in first:
if (c not in string.ascii_letters + '-') and (c.isspace() is False):
result[0] = False
print "invalid first name"
break
if len(first) == 0:
result[0] = False
for c in last:
if (c not in string.ascii_letters + '-') and (c.isspace() is False):
result[1] = False
print "invalid last name"
break
if len(last) == 0:
result[1] = False
if len(bio) > 500:
result[3] = False
print "invalid bio"
if len(password) == 0:
result[4] == False
if email_re.match(email):
return result
else:
result[2] = False
print "invalid email"
return result
def settings(request):
if request.user.is_authenticated():
settings = UserProfile.objects.get(user_id=request.user.id)
user = User.objects.get(pk=request.user.id)
if request.method == "POST": # If the form has been submitted...
if request.POST.get("full_name", ""):
settings.full_name = request.POST["full_name"]
settings.save()
elif request.POST.get("position", ""):
settings.staff_position = request.POST["position"]
settings.save()
elif request.POST.get("bio", ""):
settings.bio = request.POST["bio"]
settings.save()
elif request.POST.get("receive_notifications", ""):
settings.receive_notifications = request.POST["receive_notifications"]
settings.save()
elif request.POST.get("notification_email", ""):
if email_re.match(request.POST["notification_email"]):
settings.notification_email = request.POST["notification_email"]
settings.save()
else:
error = "Please enter a valid email address."
return HttpResponse(json.dumps(error))
return django.http.HttpResponseRedirect("/settings/") # Redirect after POST
return render(
request, "tail/settings/index.html", {"settings": settings}, context_instance=RequestContext(request)
)
else:
return HttpResponseRedirect("/")
def clean_send_to(self):
value = self.cleaned_data['send_to']
emails = filter(bool, split_re.split(value))
for email in emails:
if not email_re.match(email):
raise ValidationError('%s is not a valid e-mail address.' % email)
return ','.join(emails)
def is_valid_email(email):
"""
Is the string a valid email?
(We use the regex Django uses to define an email address)
"""
return True if email_re.match(email) else False
def clean_username_or_email(self):
field = self.cleaned_data['username_or_email']
if not re.match(r'^[\w]+$', field) and not email_re.match(field):
raise forms.ValidationError('That doesn\'t appear to be a username or an email address')
return field
def save_email_list(request):
if request.method == 'POST':
post = request.POST
emails = post.get('emails', None)
if emails is None:
raise Exception('no email list passed in')
email_list_unstripped = emails.split(',')
email_list = []
bad_emails = []
for email in email_list_unstripped:
if email_re.match(email.strip()):
email_list.append(email.strip())
else:
bad_emails.append(email)
response_dict = {}
if not bad_emails:
request.session["email_list"] = email_list
response_dict = { "success":True, "message": "Done" }
else:
response_dict = { "success":False, "message": "Invalid emails found", "bad_emails":bad_emails }
return HttpResponse(simplejson.dumps(response_dict, cls=PDEncoder), mimetype='application/javascript')
def clean(self):
"""
Validates the quarantine form
"""
cleaned_data = self.cleaned_data
use_alt = cleaned_data.get("use_alt")
altrecipients = cleaned_data.get("altrecipients")
learn = cleaned_data.get("learn")
release = cleaned_data.get("release")
todelete = cleaned_data.get("todelete")
if not learn and not release and not todelete:
raise forms.ValidationError(_("Select atleast one action to perform"))
else:
if altrecipients in EMPTY_VALUES and use_alt and release:
raise forms.ValidationError(
_("Provide atleast one alternative recipient"))
else:
if use_alt and release:
emails = altrecipients.split(',')
for email in emails:
if not email_re.match(email.strip()):
raise forms.ValidationError(
_('%(email)s is not a valid e-mail address.')
% {'email': force_escape(email)})
return cleaned_data
def signup(request, username, password, email, **kwargs):
"""Create a new account
- Username must have only letters/numbers and be 3-30 chars
- Password must be 6-128 chars
- Email is optional
"""
raise APIException("disabled")
if request.user.is_authenticated():
raise APIException(_("you're already logged in"))
check_username(username=username)
if len(password) < 6:
raise APIException(_("password must be at least six characters"))
if len(password) > 128:
raise APIException(_("password too long"))
if email:
if not email_re.match(email):
raise APIException(_("invalid email address"))
user = db.User()
user.username = username
user.set_password(password)
user.email = email
user.save()
userinfo = db.UserInfo()
userinfo.user = user
userinfo.attendance = 'maybe'
userinfo.save()
user.userinfo = userinfo
user.save()
res = login(request, username, password)
res[0]['conversion'] = render_to_string('occupywallst/conversion.html')
return res
def adduser(request):
if request.GET['email']!="" and request.GET['uname']!="" and request.GET['pass']!="":
x= bool(email_re.match(request.GET['email']))
if x:
db = MySQLdb.connect(user='******', db='devesh mysite', passwd='', host='')
cursor = db.cursor()
sql="select email from users where email=%s"
ml=request.GET['email']
cursor.execute(sql,[ml])
x = [row[0] for row in cursor.fetchall()]
if x:
msg="already exists"
else:
unm=request.GET['uname']
ps=request.GET['pass']
sql="insert into users(name,email,password) values(%s,%s,%s)"
cursor.execute(sql,[unm,ml,ps])
db.commit()
request.session["umail"] = request.GET['email']
return render_to_response('loggedin.html',{'msg': "added user"})
db.close()
else:
msg="invalid email"
else:
msg = 'You submitted an empty form.'
return HttpResponse(msg)
def sync_atg_user(atg_user_name, profile=None):
from tinla.users.models import Email, Phone
if not atg_user_name:
return
try:
if not profile:
if email_re.match(atg_user_name):
try:
e = Email.objects.get(email=atg_user_name)
profile = e.user
except Email.DoesNotExist:
pass
elif phone_regex.match(atg_user_name):
try:
p = Phone.objects.get(phone=atg_user_name)
profile = p.user
except Phone.DoesNotExist:
pass
if not profile:
# not able to find a matching user in tinla database
# create new profile and user
user, profile = utils.utils.get_or_create_user(atg_user_name)
profile.atg_username = atg_user_name
profile.save()
return profile
except Exception, e:
log.exception("Error syncing atg user %s" % repr(e))
def team_invite(request, organization_slug, team_id ):
organization = get_object_or_404(Organization, slug=organization_slug)
if not organization.hasStaffAccess( request.user ):
raise PermissionDenied()
team = get_object_or_404(Team, id=team_id)
if team.organization != organization:
raise PermissionDenied() # Shenanigans!
userinput = request.POST.get("invitee")
users = User.objects.filter(username__iexact=userinput)
if len(users) == 0:
users = User.objects.filter(email__iexact=userinput)
if len(users) > 0:
new_member = users[0]
team.members.add( new_member )
team.save()
return team_detail(request, organization_slug, team_id)
if email_re.match( userinput ):
key = ''.join(random.choice(string.letters + string.digits) for i in xrange(8))
invite = TeamInvite(email_address=userinput, team=team, key=key)
invite.save()
subject = _("Invtation to ScrumDo team")
message = render_to_string("organizations/team_invite_email.txt", {
"invite": invite,
"inviter": request.user
})
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [userinput])
return team_detail(request, organization_slug, team_id)
def marketplace(request):
submitted = False
error = False
email = ''
if request.method == 'POST':
email = request.POST['email']
format_ = 'T' if request.POST.get('format') == 'text' else 'H'
newsletter = 'app-dev'
if not email_re.match(email):
error = 'email'
if not request.POST.get('privacy', None):
error = 'privacy'
if not error:
basket.subscribe(email, newsletter, format=format_)
submitted = True
return l10n_utils.render(request,
"marketplace/marketplace.html",
{'submitted': submitted,
'error': error,
'email': email})
def submit(request, category):
categories = [x[1].lower() for x in SIGNUP_CATEGORIES]
# Looks like a malicious request - ignore (go back to homepage)
if category not in categories or request.method != 'POST':
return redirect('home')
else:
email = request.POST.get('email', '')
name = request.POST.get('name', '')
title = 'Unable to process submission'
if email == '' or not email_re.match(email):
message = 'Please enter a valid email address and name.'
elif name == '':
message = 'Please enter your name.'
else:
try:
Person.objects.create(email=email, name=name, category=categories.index(category))
title = 'Successful signup'
message = 'Thank you for signing up for our %s listserv.' % category
except IntegrityError:
message = 'That email address has already been used. Perhaps you signed up before and forgot about it?'
# Why is this method so messy. Switch to using forms later?
data = {
'title': title,
'message': message
}
return render(request, 'confirmation.html', data)
def is_valid_email(email_str):
try:
from django.core.validators import email_re
return email_re.match(email_str)
except ImportError:
logging.warning("Django not installed; email validation not performed")
return True
def login (request):
redirect_url = '/'
if('redirect_url' in request.GET.keys()):
redirect_url = urllib.unquote_plus(request.GET['redirect_url'])
if not redirect_url or redirect_url == '':
redirect_url = '/'
if request.method == "POST":
errors = []
login_email = ''
if('redirect_url' in request.POST.keys()):
redirect_url = urllib.unquote_plus(request.POST['redirect_url'])
email = None
try:
login_id = request.POST["login_id"].lower()
login_password = hashlib.sha1(request.POST["login_password"]).hexdigest()
email = email_re.match(login_id.lower().strip())
user = None
if email:
user = User.objects.get(email=login_id, password=login_password)
else:
user = User.objects.get(username=login_id, password=login_password)
clear_session(request)
request.session[kEmail] = user.email
request.session[kUsername] = user.username
redirect_url = redirect_url + urllib.unquote_plus('?auth_user=%s' %(user.username))
return HttpResponseRedirect(redirect_url)
except User.DoesNotExist:
try:
if email:
User.objects.get(email=login_id)
else:
User.objects.get(username=login_id)
errors.append(
'Wrong password. Please try again.<br /><br />'
'<a class="blue bold" href="/account/forgot">Click Here</a> '
'to reset your password.')
except User.DoesNotExist:
errors.append(
'Could not find any account associated with login_id: '
'%s.<br /><br /><a class="blue bold" '
'href="/account/register?redirect_url=%s">Click Here</a> '
'to create an account.' %(login_id,
urllib.quote_plus(redirect_url)))
return login_form(
request, redirect_url = urllib.quote_plus(redirect_url),
errors = errors)
except:
errors.append('Login failed.')
return login_form(
request, redirect_url = urllib.quote_plus(redirect_url),
errors = errors)
else:
return login_form(request, urllib.quote_plus(redirect_url))
def authenticate(self, username=None, password=None):
if not '@' in username:
return None
login_user, domain = username.split('@')
dom = UserAddresses.objects.filter(address=domain, address_type=1)
if not dom:
return None
hosts = MailAuthHost.objects.filter(useraddress=dom)
if not hosts:
return None
for host in hosts:
if not host.split_address:
login_user = username
if self.mail_auth(host.protocol, login_user, password,
host.address, host.port):
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username)
user.set_unusable_password()
user.is_staff = False
user.is_superuser = False
if email_re.match(username):
user.email = username
user.save()
try:
profile = user.get_profile()
except UserProfile.DoesNotExist:
profile = UserProfile(user=user, account_type=3)
profile.save()
return user
return None
def register(request):
import re
from django.core.validators import email_re
context = {}
if 'account' in request.POST:
account = request.POST['account'].lower()
email = request.POST['email'].lower()
password = request.POST['password']
# alphanumeric and underscore symbols allowed, no more than 30
if not re.match(r'^[a-zA-Z0-9_]{1,30}$', account):
context['error_acc_inval'] = True
if not email_re.match(email):
context['error_email'] = True
if request.POST['password2'] != password:
context['error_password'] = True
if context == {}:
try:
user = models.User.objects.create_user(account, email,
password)
user.save()
# Always return an HttpResponseRedirect after successfully
# dealing with POST data. This prevents data from being posted
# twice if a user hits the Back button.
return HttpResponseRedirect(
reverse('sight.views.signin_account', args=[account]))
except IntegrityError: # There is a record of the same user
context['error_acc_registered'] = True
context['account'] = account
context['email'] = email
return render_to_response('sight/register.html',
context,
context_instance=RequestContext(request))
def backwards(self, orm):
# set third_party_identifier
for user in orm.AstakosUser.objects.all():
for auth_provider in user.auth_providers.all():
user.provider = auth_provider.module
user.third_party_identifier = auth_provider.identifier
user.save()
# reset usernames
for u in orm.AstakosUser.objects.all():
u.uuid = None
u.auth_providers.all().delete()
if email_re.match(u.username):
username = None
while not username:
username_val = uuid.uuid4().hex[:30]
try:
orm.AstakosUser.objects.get(username=username_val)
except orm.AstakosUser.DoesNotExist, e:
username = username_val
u.username = username
u.save()
def _doCheckValid():
# check if it is valid username
# - from 2 to 20 characters long
# - word, number, ., _, -
mtch = re.match('^[\w\d\_\.\-]{2,20}$', request.POST.get("username", "").strip())
if not mtch: return 6
# check if it is valid email
if not bool(email_re.match(request.POST["email"].strip())): return 7
if request.POST.get("password", "") != request.POST.get("password2", "").strip(): return 8
if len(request.POST.get("password", "").strip()) < 6: return 9
if len(request.POST.get("fullname", "").strip()) > 30: return 11
# check if this user exists
try:
u = auth.models.User.objects.get(username=request.POST.get("username", ""))
return 10
except auth.models.User.DoesNotExist:
pass
return 0
def authenticate(self, username=None, password=None):
"""
Retorna o usuário atraves do username ou email e password.
se não encontrar retorna None.
"""
# verifica se e um email
if email_re.match(username):
try:
user = User.objects(email=username).first()
except User.DoesNotExist:
return None
# caso nao autentica no modo padrao
else:
try:
user = User.objects(username=username).first()
except User.DoesNotExist:
return None
if user:
if password and user.check_password(password):
return user
return None
def _import_data_sender(self, form_model, organization, values):
try:
mobile_number = case_insensitive_lookup(values, "m")
if not mobile_number:
raise MobileNumberMandatoryException()
if organization.in_trial_mode:
from accountmanagement.helper import is_mobile_number_unique_for_trial_account
if not is_mobile_number_unique_for_trial_account(
organization, mobile_number):
raise MultipleReportersForANumberException(mobile_number)
else:
data_sender = DataSenderOnTrialAccount.objects.model(
mobile_number=mobile_number, organization=organization)
data_sender.save(force_insert=True)
except IntegrityError:
raise MultipleReportersForANumberException(mobile_number)
except Exception as ex:
raise ex
if len(",".join(values["l"])) > 500:
raise MangroveException(
"Location Name cannot exceed 500 characters.")
email = case_insensitive_lookup(values, "email")
if email:
if not email_re.match(email):
raise InvalidEmailException(message="Invalid email address.")
self._validate_duplicate_email_address(email)
response = self.submit(form_model, values, [])
else:
response = self.submit(form_model, values, [])
return response
def clean(self):
"""clean_address"""
if self._errors:
return self.cleaned_data
cleaned_data = self.cleaned_data
address = cleaned_data['address']
user = cleaned_data['user']
if user.is_superuser:
error_msg = _('Super users do not use addresses')
self._errors["address"] = ErrorList([error_msg])
del cleaned_data['address']
account = UserProfile.objects.get(user=user)
if account.account_type == 2:
if not DOM_RE.match(address):
error_msg = _('provide a valid domain address')
self._errors["address"] = ErrorList([error_msg])
del cleaned_data['address']
else:
if not email_re.match(address):
error_msg = _('provide a valid email address')
self._errors["address"] = ErrorList([error_msg])
del cleaned_data['address']
return cleaned_data
def clean_user_identifiers(self):
value = self.cleaned_data["invite_user_identifiers"]
invitees, errors = [], []
for ui in value.split(","):
ui = ui.strip()
if email_re.match(ui):
try:
invitees.append(User.objects.get(email=ui))
except User.DoesNotExist:
invitees.append(ui)
else:
try:
invitees.append(User.objects.get(username=ui))
except User.DoesNotExist:
errors.append(ui)
if errors:
message = ("The following are not valid email addresses or "
"usernames: %s; no invitations sent" % ", ".join(errors))
raise forms.ValidationError(message)
return invitees
def is_valid_email(email):
""" check if a string is a valid email address
django dependant
@param email: - the string to evaluate
@return: boolean, True if valid, False if not
>>> is_valid_email("*****@*****.**")
True
>>> is_valid_email("foobar")
False
"""
try:
from django.core.validators import email_re
return True if email_re.match(email) else False
except ImportError:
from django.core.validators import validate_email
try:
validate_email(email)
except ValidationError:
return False
return True
def email_is_valid(email):
return True if email_re.match(email) else False
def is_valid_email(email):
return True if email_re.match(email) else False
def validate(self, value):
if len(value) == 0:
raise ValidationError('Choose one contact at least.')
for email in value:
if not email_re.match(email):
raise ValidationError('Incorrect choice.')
def is_valid(self):
"""
Checks if this Mail is valid by validating the email address.
"""
return email_re.match(self.person.get_email())
def register (request):
redirect_url = '/'
if('redirect_url' in request.GET.keys()):
redirect_url = urllib.unquote_plus(request.GET['redirect_url'])
if request.method == "POST":
errors = []
email = ''
try:
error = False
if('redirect_url' in request.POST.keys()):
redirect_url = urllib.unquote_plus(request.POST['redirect_url'])
username = request.POST["username"].lower()
email = request.POST["email"].lower()
password = request.POST["password"]
if(email_re.match(email.strip()) == None):
errors.append("Invalid Email.")
error = True
if(not is_valid_username(username)):
errors.append("Invalid Username.")
error = True
if(password == ""):
errors.append("Empty Password.")
error = True
try:
user = User.objects.get(username=username)
errors.append("Username already taken.")
error = True
except User.DoesNotExist:
pass
if not error:
hashed_password = hashlib.sha1(password).hexdigest()
try:
DataHubManager.create_user(username=username, password=hashed_password)
except Exception, e:
pass
try:
DataHubManager.change_password(username=username, password=hashed_password)
except Exception, e:
errors.append(str(e))
error = True
if(error):
return register_form(request, redirect_url = urllib.quote_plus(redirect_url), errors = errors)
user = User(username=username, email=email, password=hashed_password)
user.save()
clear_session(request)
request.session[kEmail] = user.email
request.session[kUsername] = user.username
encrypted_email = encrypt_text(user.email)
subject = "Welcome to DataHub"
msg_body = '''
Dear %s,
Thanks for registering to DataHub.
Please click the link below to start using DataHub:
%s://%s/account/verify/%s
''' % (
user.email,
'https' if request.is_secure() else 'http',
request.get_host(),
encrypted_email)
pool.apply_async(send_email, [user.email, subject, msg_body])
return HttpResponseRedirect(redirect_url)
def testGetValue(self):
"""Tests getValue().
"""
value = self.provider.getValue()
self.assertTrue(value is not None)
self.assertTrue(email_re.match(value))
def api_add_rp(data):
"""Create a recurrring payment account. Accepted format: json
Input fields:
email - required
description - required
payment_amount - required
billing_period - optional, default to 'month'
billing_frequency - optional, default to 1
billing_start_dt - optional, default to today
num_days - optional, default to 0
has_trial_period - optional, default to False
trial_period_start_dt - optional, default to today
trial_period_end_dt - optional, default to today
trial_amount - optional, default to 0
Output:
rp_id - a recurring payment id
result_code
"""
ALLOWED_FIELES = ('email',
'description',
'payment_amount',
'billing_period',
'billing_frequency',
'billing_start_dt',
'num_days',
'has_trial_period',
'trial_period_start_dt',
'trial_period_end_dt',
'trial_amount',
)
from decimal import Decimal
from django.core.validators import email_re
import dateutil.parser as dparser
from tendenci.core.imports.utils import get_unique_username
email = data.get('email', '')
payment_amount = data.get('payment_amount', '')
try:
payment_amount = Decimal(payment_amount)
except:
payment_amount = 0
if not all([email_re.match(email),
data.has_key('description'),
payment_amount>0]):
return False, {}
rp = RecurringPayment()
for key, value in data.items():
if key in ALLOWED_FIELES:
if hasattr(rp, key):
setattr(rp, key, value)
if rp.billing_start_dt:
try:
rp.billing_start_dt = dparser.parse(rp.billing_start_dt)
except:
rp.billing_start_dt = datetime.now()
else:
rp.billing_start_dt = datetime.now()
if rp.trial_period_start_dt:
try:
rp.trial_period_start_dt = dparser.parse(rp.trial_period_start_dt)
except:
rp.trial_period_start_dt = datetime.now()
if rp.trial_period_end_dt:
try:
rp.trial_period_end_dt = dparser.parse(rp.trial_period_end_dt)
except:
rp.trial_period_end_dt = datetime.now()
rp.payment_amount = Decimal(rp.payment_amount)
try:
rp.billing_frequency = int(rp.billing_frequency)
except:
rp.billing_frequency = 1
try:
rp.num_days = int(rp.num_days)
except:
rp.num_days = 1
if rp.has_trial_period in ['True', '1', True, 1] and all([rp.trial_period_start_dt,
rp.trial_period_end_dt]):
rp.has_trial_period = True
else:
rp.has_trial_period = False
# start the real work
# # get or create a user account with this email
# users = User.objects.filter(email=email)
# if users:
# u = users[0]
# else:
# always create a new user account - This is very important!
# it is to prevent hacker from trying to use somebody else's account.
u = User()
u.email=email
u.username = data.get('username', '')
if not u.username:
u.username = email.split('@')[0]
u.username = get_unique_username(u)
raw_password = data.get('password', '')
if not raw_password:
raw_password = User.objects.make_random_password(length=8)
u.set_password(raw_password)
u.first_name = data.get('first_name', '')
u.last_name = data.get('last_name', '')
u.is_staff = False
u.is_superuser = False
u.save()
# profile = Profile.objects.create(
# user=u,
# creator=u,
# creator_username=u.username,
# owner=u,
# owner_username=u.username,
# email=u.email
# )
# add a recurring payment entry for this user
rp.user = u
# activate it when payment info is received
rp.status_detail = 'inactive'
rp.save()
return True, {'rp_id': rp.id}
def email_validate(val):
if email_re.match(val): return True
return False
def clean(self):
cleaned_data = self.cleaned_data
field_function = cleaned_data.get("field_function")
choices = cleaned_data.get("choices")
field_type = cleaned_data.get("field_type")
required = cleaned_data.get("required")
if field_function == "GroupSubscription":
if field_type != "BooleanField":
raise forms.ValidationError(
_("This field's function requires Checkbox as a field type"
))
if not choices:
raise forms.ValidationError(
_("This field's function requires at least 1 group specified."
))
else:
for val in choices.split(','):
try:
Group.objects.get(name=val.strip())
except Group.DoesNotExist:
raise forms.ValidationError(
_("The group \"%(val)s\" does not exist" %
{'val': val}))
if field_function == "Recipients":
if (field_type !=
"MultipleChoiceField/django.forms.CheckboxSelectMultiple"
and field_type != "MultipleChoiceField"
and field_type != "BooleanField"
and field_type != "ChoiceField"):
raise forms.ValidationError(
_("The \"Email to Recipients\" function requires Multi-select - Checkboxes "
+ "or Multi-select - Select Many as field type"))
if field_type == "BooleanField":
if not choices:
raise forms.ValidationError(
_("The \"Email to Recipients\" function requires at least 1 email specified."
))
else:
for val in choices.split(','):
if not email_re.match(val.strip()):
raise forms.ValidationError(
_("\"%(val)s\" is not a valid email address" %
{'val': val}))
else:
if not choices:
raise forms.ValidationError(
_("The \"Email to Recipients\" function requires at least 1 choice specified."
))
else:
for val in choices.split(','):
val = val.split(':')
if len(val) < 2:
raise forms.ValidationError(
_("The \"Email to Recipients\" function requires choices to be in the following format: <choice_label>:<email_address>."
))
if not email_re.match(val[1].strip()):
raise forms.ValidationError(
_("\"%(val)s\" is not a valid email address" %
{'val': val[1]}))
if field_function != None and field_function.startswith("Email"):
if field_type != "CharField":
raise forms.ValidationError(
_("This field's function requires Text as a field type"))
#unrequire the display only fields
if field_type == "CharField/tendenci.apps.forms_builder.forms.widgets.Description":
cleaned_data['required'] = False
elif field_type == "CharField/tendenci.apps.forms_builder.forms.widgets.Header":
cleaned_data['required'] = False
return cleaned_data
def api_rp_setup(data):
"""Create a recurrring payment account. Accepted format: json
Input fields:
email - required
description - required
amount - required
cp_id - customer profile id, required
pp_id - customer payment profile id, required
billing_cycle_start_dt - required
billing_cycle_end_dt - required
response_str - required
login_name
login_password
url
first_name
last_name
billing_period - optional, default to 'month'
billing_frequency - optional, default to 1
billing_start_dt - optional, default to today
num_days - optional, default to 0
has_trial_period - optional, default to False
trial_period_start_dt - optional, default to today
trial_period_end_dt - optional, default to today
trial_amount - optional, default to 0
Output:
rp_id - a recurring payment id
rp_url - url to rp
username
result_code
"""
from decimal import Decimal
from django.core.validators import email_re
import dateutil.parser as dparser
from tendenci.core.imports.utils import get_unique_username
email = data.get('email', '')
description = data.get('description', '')
url = data.get('url')
payment_amount = data.get('amount', '')
taxable = data.get('taxable', 0)
if taxable in ('True', 'true', '1', 1):
taxable = 1
else:
taxable = 0
try:
tax_rate = Decimal(data.get('tax_rate', 0))
if tax_rate > 1: tax_rate = 0
except:
tax_rate = 0
tax_exempt = data.get('tax_exempt', 0)
if tax_exempt in ('True', 'true', '1', 1):
tax_exempt = 1
else:
tax_exempt = 0
try:
payment_amount = Decimal(payment_amount)
except:
payment_amount = 0
cp_id = data.get('cp_id')
pp_id = data.get('pp_id')
billing_cycle_start_dt = data.get('billing_cycle_start_dt')
if billing_cycle_start_dt:
billing_cycle_start_dt = dparser.parse(billing_cycle_start_dt)
billing_cycle_end_dt = data.get('billing_cycle_end_dt')
if billing_cycle_end_dt:
billing_cycle_end_dt = dparser.parse(billing_cycle_end_dt)
direct_response_str = data.get('response_str')
if not all([email_re.match(email),
description,
payment_amount>0,
cp_id,
pp_id,
billing_cycle_start_dt,
billing_cycle_end_dt,
direct_response_str]
):
return False, {}
# 1) get or create user
username = data.get('login_name')
# check if user already exists based on email and username
users = User.objects.filter(email=email, username=username)
if users:
u = users[0]
else:
# create user account
u = User()
u.email=email
u.username = username
if not u.username:
u.username = email.split('@')[0]
u.username = get_unique_username(u)
raw_password = data.get('login_password')
if not raw_password:
raw_password = User.objects.make_random_password(length=8)
u.set_password(raw_password)
u.first_name = data.get('first_name', '')
u.last_name = data.get('last_name', '')
u.is_staff = False
u.is_superuser = False
u.save()
profile = Profile.objects.create(
user=u,
creator=u,
creator_username=u.username,
owner=u,
owner_username=u.username,
email=u.email
)
# 2) create a recurring payment account
rp = RecurringPayment()
rp.user = u
rp.description = description
rp.url = url
rp.payment_amount = payment_amount
rp.taxable = taxable
rp.tax_rate = tax_rate
rp.tax_exempt = tax_exempt
rp.customer_profile_id = cp_id
rp.billing_start_dt = billing_cycle_start_dt
has_trial_period = data.get('has_trial_period')
trial_period_start_dt = data.get('trial_period_start_dt')
trial_period_end_dt = data.get('trial_period_end_dt')
if has_trial_period in ['True', '1', True, 1] and all([trial_period_start_dt,
trial_period_end_dt]):
rp.has_trial_period = True
rp.trial_period_start_dt = dparser.parse(trial_period_start_dt)
rp.trial_period_end_dt = dparser.parse(trial_period_end_dt)
else:
rp.has_trial_period = False
rp.status_detail = 'active'
rp.save()
# 3) create a payment profile account
payment_profile_exists = PaymentProfile.objects.filter(
customer_profile_id=cp_id,
payment_profile_id=pp_id
).exists()
if not payment_profile_exists:
PaymentProfile.objects.create(
customer_profile_id=cp_id,
payment_profile_id=pp_id,
owner=u,
owner_username=u.username
)
# 4) create rp invoice
billing_cycle = {'start': billing_cycle_start_dt,
'end': billing_cycle_end_dt}
rp_invoice = rp.create_invoice(billing_cycle, billing_cycle_start_dt)
rp_invoice.invoice.tender(rp.user)
# 5) create rp transaction
now = datetime.now()
payment = Payment()
payment.payments_pop_by_invoice_user(rp.user,
rp_invoice.invoice,
rp_invoice.invoice.guid)
payment_transaction = PaymentTransaction(
recurring_payment=rp,
recurring_payment_invoice=rp_invoice,
payment_profile_id=pp_id,
trans_type='auth_capture',
amount=rp_invoice.invoice.total,
status=True)
payment = payment_update_from_response(payment, direct_response_str)
payment.mark_as_paid()
payment.save()
rp_invoice.invoice.make_payment(rp.user, Decimal(payment.amount))
rp_invoice.invoice.save()
rp_invoice.payment_received_dt = now
rp_invoice.save()
rp.last_payment_received_dt = now
rp.num_billing_cycle_completed += 1
rp.save()
payment_transaction.payment = payment
payment_transaction.result_code = data.get('result_code')
payment_transaction.message_code = data.get('message_code')
payment_transaction.message_text = data.get('message_text')
payment_transaction.save()
site_url = get_setting('site', 'global', 'siteurl')
return True, {'rp_id': rp.id,
'rp_url': '%s%s' % (site_url,
reverse('recurring_payment.view_account', args=[rp.id])),
'username': rp.user.username}
def is_valid_email(email):
if email_re.match(email):
return True
return False
def _is_valid_email(email):
return email_re.match(email)
def is_valid_email(email):
return bool(email_re.match(email))
def validate_email(value):
"""Validate that a username is email like."""
if not email_re.match(value):
raise ValidationError(_('Enter a valid address.'))
return value
def run(self, legacy_obj):
from alibrary.models import Label, Relation, Distributor, DistributorLabel
status = 1
log = logging.getLogger('util.migrator.run')
log.info('migrate release: %s' % legacy_obj.name)
obj, created = Label.objects.get_or_create(legacy_id=legacy_obj.id)
if created:
log.info('object created: %s' % obj.pk)
else:
log.info('object found by legacy_id: %s' % obj.pk)
if created:
"""
Mapping data
1-to-1 fields
"""
obj.name = legacy_obj.name
obj.created = legacy_obj.created
obj.updated = legacy_obj.updated
if legacy_obj.published:
obj.published = legacy_obj.published
if legacy_obj.label_type:
obj.type = legacy_obj.label_type
if legacy_obj.label_code:
log.debug('label_code: %s' % legacy_obj.label_code)
obj.labelcode = legacy_obj.label_code[:200]
if legacy_obj.profile:
if legacy_obj.notes:
obj.description = "%s\n\n%s" % (legacy_obj.profile,
legacy_obj.notes)
else:
obj.description = legacy_obj.profile
if legacy_obj.address:
obj.address = legacy_obj.address
if legacy_obj.contact:
log.debug('contact: %s' % legacy_obj.contact)
if email_re.match(legacy_obj.contact):
obj.email = legacy_obj.contact
if legacy_obj.country:
log.debug('country: %s' % legacy_obj.country)
country = None
if len(legacy_obj.country) == 2:
try:
country = Country.objects.get(
iso2_code=legacy_obj.country)
except Exception, e:
pass
else:
try:
country = Country.objects.get(
printable_name=legacy_obj.country)
except Exception, e:
pass
if country:
log.debug('got country: %s' % country.name)
obj.country = country
def isValidEmail(email):
if email_re.match(email):
return True
return False
def clean(self):
"validate the form"
cleaned_data = self.cleaned_data
submited_field = cleaned_data.get('filtered_field')
submited_by = int(cleaned_data.get('filtered_by'))
submited_value = cleaned_data.get('filtered_value')
if submited_by != 0:
sbi = (submited_by - 1)
else:
sbi = submited_by
if submited_field in BOOL_FIELDS:
if not submited_by in BOOL_FILTER:
filter_items = dict(FILTER_ITEMS)
error_msg = _("%(field)s does not support the %(filt)s filter") % {
'field': filter_items[submited_field], 'filt': FILTER_BY[sbi][1]}
raise forms.ValidationError(error_msg)
if submited_field in NUM_FIELDS:
if not submited_by in NUM_FILTER:
filter_items = dict(FILTER_ITEMS)
error_msg = _("%(field)s does not support the %(filt)s filter") % {
'field': filter_items[submited_field], 'filt': FILTER_BY[sbi][1]}
raise forms.ValidationError(error_msg)
if submited_value in EMPTY_VALUES:
raise forms.ValidationError(_("Please supply a value to query"))
if not isnumeric(submited_value):
raise forms.ValidationError(_("The value has to be numeric"))
if submited_field in TEXT_FIELDS:
if not submited_by in TEXT_FILTER:
filter_items = dict(FILTER_ITEMS)
error_msg = _("%(field)s does not support the %(filt)s filter") % {
'field': filter_items[submited_field], 'filt': FILTER_BY[sbi][1]}
raise forms.ValidationError(error_msg)
if submited_value in EMPTY_VALUES and submited_by not in [9, 10]:
raise forms.ValidationError(_("Please supply a value to query"))
if ((submited_field == 'from_address' or
submited_field == 'to_address') and
submited_by in [1, 2]):
if not email_re.match(submited_value.strip()):
raise forms.ValidationError(
_('%(email)s is not a valid e-mail address.')
% {'email': force_escape(submited_value)})
else:
if submited_by in [7, 8]:
try:
re.compile(submited_value)
except re.error:
raise forms.ValidationError(
_("Please provide a valid regex")
)
if ((submited_field == 'from_domain' or
submited_field == 'to_domain') and
submited_by in [1, 2]):
if not DOM_RE.match(submited_value.strip()):
raise forms.ValidationError(
_('Please provide a valid domain name'))
else:
if submited_by in [7, 8]:
try:
re.compile(submited_value)
except re.error:
raise forms.ValidationError(
_("Please provide a valid regex")
)
if submited_field == 'clientip':
if not ipv4_re.match(submited_value.strip()):
raise forms.ValidationError(
_('Please provide a valid ipv4 address'))
if submited_field == 'hostname':
if ((not ipv4_re.match(submited_value.strip())) and
(not DOM_RE.match(submited_value.strip()))):
raise forms.ValidationError(
_("Please provide a valid hostname or ipv4 address")
)
if submited_field in TIME_FIELDS:
if not submited_by in TIME_FILTER:
filter_items = dict(FILTER_ITEMS)
error_msg = _("%(field)s does not support the %(filt)s filter") % {
'field': filter_items[submited_field], 'filt': FILTER_BY[sbi][1]}
raise forms.ValidationError(error_msg)
if submited_value in EMPTY_VALUES:
raise forms.ValidationError(_("Please supply a value to query"))
if submited_field == 'date':
try:
datetime.date(
*time.strptime(submited_value, '%Y-%m-%d')[:3])
except ValueError:
raise forms.ValidationError(
_('Please provide a valid date in YYYY-MM-DD format'))
if submited_field == 'time':
try:
datetime.time(*time.strptime(submited_value, '%H:%M')[3:6])
except ValueError:
raise forms.ValidationError(
_('Please provide valid time in HH:MM format'))
return cleaned_data
def migrate():
# Migration plan
# Read user, user address book from atg
# Create one user in tinla per atg user
#ezone_orders_users = FtbOrder.objects.select_related('order').all().values(
# 'order__profile').distinct()
#atg_users = DpsUser.objects.filter(dps_id__in = ezone_orders_users)
atg_users = DpsUser.objects.all()
count = atg_users.count()
log.info('Found %s users in atg.' % count)
index = 0
exists = 0
non_existing = 0
newly_created = 0
migrated = 0
errors = 0
attached = 0
not_attached = 0
atg_users = queryset_iterator(atg_users)
for atg_user in atg_users:
index += 1
db.reset_queries()
# Check if username is already taken in tinla
# Tinla's usernames are phone numbers and email addresses
email = None
phone = None
profile = None
auth_user = None
found = False
username = atg_user.login
try:
email = Email.objects.select_related(
'user', 'user__user').get(email=username)
profile = email.user
auth_user = profile.user
found = True
except Email.DoesNotExist:
try:
phone = Phone.objects.select_related(
'user', 'user__user').get(phone=username[:10])
profile = phone.user
auth_user = profile.user
found = True
except Phone.DoesNotExist:
pass
if found:
exists += 1
if profile.atg_login:
migrated += 1
if profile.atg_login != username:
log.info(
'Skipping user: %s. Check if it matches with: %s' %
(username, profile.atg_login))
else:
try:
profile.atg_login = username
profile.atg_password = atg_user.password
profile.save()
log.info(
'User exists. Just mapping atg_login and atg_password %s'
% username)
attached += 1
except:
log.info('User exists. Duplicate atg_login %s' % username)
not_attached += 1
else:
non_existing += 1
log.info('%s not found in tinla' % username)
# No email and phone taken.
if phone_re.match(username):
phone = Phone(phone=username[:10])
if email_re.match(username):
email = Email(email=username)
try:
profile = new_profile(atg_user, phone, email)
if profile:
newly_created += 1
log.info('Created new profile for %s. id is %s' %
(username, profile.id))
except Exception, e:
errors += 1
log.exception('Error migrating %s. %s' % (username, repr(e)))
if index % 10000 == 0:
log.info('Processed %s/%s' % (index, count))
def register(self, request, **kwargs):
# Allows POST request
self.method_check(request, allowed=['post'])
# Deserialize the JSon response
data = self.deserialize(request,
request.raw_post_data,
format=request.META.get(
'CONTENT_TYPE', 'application/json'))
# Get the needed datas
username = data.get('username', '')
email = data.get('email', '')
password1 = data.get('password1', '')
password2 = data.get('password2', '')
if len(username
) == 0: # If password1 and password2 don't match, return error
return self.create_response(request, {
'success': False,
'reason': 'username is empty',
})
elif len(User.objects.filter(username=username)
) != 0: # the username is already taken, return error
return self.create_response(request, {
'success': False,
'reason': 'user already exist',
})
elif len(email) == 0: # If email is empty, return error
return self.create_response(request, {
'success': False,
'reason': 'email is empty',
})
elif not email_re.match(
email): # If email data is not a good email, return error
return self.create_response(request, {
'success': False,
'reason': 'email not valid',
})
elif len(User.objects.filter(
email=email)) != 0: # If email already exist, return error
return self.create_response(request, {
'success': False,
'reason': 'email already in use',
})
elif len(password1) == 0: # If password is empty, return error
return self.create_response(request, {
'success': False,
'reason': "passwords don't exist",
})
elif password1 != password2: # If password1 and password2 don't match, return error
return self.create_response(request, {
'success': False,
'reason': "passwords don't match",
})
else: # If already is ok, let's go for regisrtation
# create a user and authenticate him (needed for login)
user = User.objects.create_user(username, email, password1)
user = authenticate(username=username, password=password1)
# If user exist and is active, log him
if user:
if user.is_active:
login(request, user)
# Create a member object and link the user to it
member = Member()
member.user = user
member.save()
# Create a dictionnary for json response and delete unuse datas
member = member.__dict__
del member["_state"]
del member["user_id"]
# Add his api_key
api_key = ApiKey.objects.get(user=user).key
member["api_key"] = api_key
# Return success = True and the member object
return self.create_response(request, {
'success': True,
'member': member
})
def is_valid_email(request, email):
encontrado = False
if email_re.match(email):
encontrado = True
return encontrado
class Migration(DataMigration):
def forwards(self, orm):
# valid activation_sent/email_verified
for user in orm.AstakosUser.objects.all():
if user.is_active:
if not user.activation_sent:
user.activation_sent = datetime.datetime.now()
user.email_verified = True
user.save()
while not user.uuid:
uuid_val = str(uuid.uuid4())
try:
orm.AstakosUser.objects.get(uuid=uuid_val)
except orm.AstakosUser.DoesNotExist, e:
user.uuid = uuid_val
user.save()
# migrate to auth providers
for user in orm.AstakosUser.objects.all():
if user.provider and user.provider != 'local':
orm.AstakosUserAuthProvider.objects.create(
user=user,
module=user.provider,
identifier=user.third_party_identifier)
else:
orm.AstakosUserAuthProvider.objects.create(
user=user, module='local', auth_backend='astakos')
user.save()
# migrate duplicate emails
to_remove = getattr(
settings, 'ASTAKOS_MIGRATION_0045_DELETE_DUPLICATE_USER_IDS', [])
for pk in to_remove:
try:
u = orm.AstakosUser.objects.get(pk=int(pk))
print "Removing user: %s (%d)" % (u.email, u.pk)
except Exception:
msg = "You requested user with id %s to be removed but such user doesn't exist in database" % str(
pk)
raise Exception(msg)
if orm.AstakosUser.objects.filter(
email__iexact=u.email).count() == 1:
msg = (
"You requested user with duplicate email %s and id (%d) to"
" be removed, but it seems that only one user exists with this"
" email in the database.") % (u.email, pk)
raise Exception(msg)
else:
orm.AstakosUser.objects.filter(pk=int(pk)).delete()
for u in orm.AstakosUser.objects.all():
if orm.AstakosUser.objects.filter(
email__iexact=u.email).count() > 1:
existing = orm.AstakosUser.objects.filter(
email__iexact=u.email)
print "Duplicate email found in database"
for e in existing:
print "%d: %s (is_active: %s)" % (e.pk, e.email,
e.is_active)
keep = input(
"Select which user id you want to BE PRESERVED in the database: "
)
if keep:
for e in existing.exclude(pk=int(keep)):
e.delete()
else:
raise Exception(
"Email %s is not unique %r. Please resolve conflicts and run migrate again."
% (u.email, existing))
u = orm.AstakosUser.objects.get(email__iexact=u.email)
save = False
if not email_re.match(u.username):
u.username = u.email.lower()
save = True
if save:
u.save()
