def test_dec30_plus_2(self):
# 2 months after December 30 is February 28
self.assertEqual(Member.add_n_months(date(2014, 12, 30), 2),
date(2015, 2, 28))
# or February 29
self.assertEqual(Member.add_n_months(date(2015, 12, 30), 2),
date(2016, 2, 29))
def _member_link(member: Member) -> str:
if member:
return format_html(
"<a href='{}'>{}</a>", member.get_absolute_url(), member.get_full_name()
)
else:
return "-"
def handle(self, *args, **kwargs):
if len(Member.objects.filter(permission=1)) == 0:
name = input('name :')
account = input('account :')
while '@' not in account:
print('\nemail 형식으로 입력해주세요 ex) [email protected]')
account = input('account :')
count = 0
while count < 3:
password = input('password :'******'pw 확인 :'):
permission = Permission.objects.get(id=1)
member = Member(name=name,
password=password,
account=account,
permission=permission)
member.save()
print('Complete to create master member')
return
else:
print('\npassword가 다릅니다. 다시 입력해주세요.')
count += 1
print('3회 이상 입력 실패')
else:
print('Aleady exists master member')
def test_dec30_plus_2(self):
# 2 months after December 30 is February 28
self.assertEqual(Member.add_n_months(date(2014, 12, 30), 2),
date(2015, 2, 28))
# or February 29
self.assertEqual(Member.add_n_months(date(2015, 12, 30), 2),
date(2016, 2, 29))
def create_or_login(request):
if not request.method == "POST":
return HttpResponseRedirect(reverse(list))
form = EmailForm(request.POST)
if not form.is_valid():
return render(request, "members/login.html", {"form": form})
data = form.cleaned_data
member = get_object_or_None(Member, email=data["email"])
if not member:
member = Member(email=data["email"])
member.save()
member_url = reverse(edit, kwargs={"key": member.key})
token_gen = PasswordResetTokenGenerator()
token = token_gen.make_token(member)
try:
send_mail(
"Your Nick Reid Directory Profile",
"Follow this link to update your profile: %s?token=%s" % (member_url, token),
"*****@*****.**",
[member.email],
fail_silently=False,
)
except:
messages.error(request, "There was an error sending email to %s", member.email)
messages.success(request, "An email has been sent to %s." % (member.email))
return HttpResponseRedirect(reverse(list))
def test_march30_minus_1(self):
# 1 month before March 30 is February 28
self.assertEqual(Member.add_n_months(date(2015, 3, 30), -1),
date(2015, 2, 28))
# or February 29
self.assertEqual(Member.add_n_months(date(2016, 3, 30), -1),
date(2016, 2, 29))
def handle(self, *args, **options):
member_length = options['member_length']
for i in range(member_length):
name = ''.join(
[random.choice(self.last_name_list)] +
[random.choice(self.first_name_list) for _ in range(2)])
account = ''.join(
[random.choice(string.ascii_lowercase) for _ in range(3)] +
[random.choice(string.digits) for _ in range(4)] + ['@'] +
[random.choice(string.ascii_lowercase)
for _ in range(5)] + ['.com'])
password = ''.join(
random.choice(string.ascii_lowercase + string.digits)
for _ in range(8))
permission = Permission.objects.get(id=random.randint(2, 6))
member = Member(name=name,
password=password,
account=account,
permission=permission)
member.save()
print('Complete to make ' + str(i + 1) + 'th ' + 'member : [ ' +
name + ', ' + account + ', ' + password + ' ]')
def test_march30_minus_1(self):
# 1 month before March 30 is February 28
self.assertEqual(Member.add_n_months(date(2015, 3, 30), -1),
date(2015, 2, 28))
# or February 29
self.assertEqual(Member.add_n_months(date(2016, 3, 30), -1),
date(2016, 2, 29))
def test_create_member_method(self):
m = Member(last_name='Bugglesworth', first_name='Paul', title="Dr.", member=True, registered=False)
self.assertEqual(m.last_name, 'Bugglesworth')
member_start_count = Member.objects.count()
m.save()
Member.objects.create(last_name="Lennon", first_name="John", member=True, registered=True)
member_end_count = Member.objects.count()
self.assertEqual(member_end_count, member_start_count+2)
def _home(request, db=None, ctx=None):
t = loader.get_template('home.html')
ctx['summary'] = OrderedDict([
('Waiting', counts(Member.waiters())),
('Elfin', counts(Member.elfins())),
('Woodchip', counts(Member.woodchips())),
('Carer', counts(Member.carers())),
])
ctx['Member'] = Member
return HttpResponse(t.render(RequestContext(request, ctx)))
def create():
if 'app-key' not in request.headers:
response = jsonify({'code': 401, 'message': 'App-Key header is required.'})
response.status_code = 401
return response
application = Application.find_by_key(request.headers['app-key'])
if not application:
response = jsonify({'code': 401, 'message': 'Invalid App-key.'})
response.status_code = 401
return response
g.application = application
form = OrganizationCreateForm(request.form)
if not form.validate():
return form.errors_as_json()
plan = ApplicationPlan.find_by_id(form.application_plan_id.data)
if not plan:
form.errors['application_plan_id'] = ['No application plan found..']
return form.errors_as_json()
check = Organization.query.filter(Organization.name == form.name.data).first()
if check:
form.errors['name'] = ['Name is already taken.']
return form.errors_as_json()
organization = Organization(**{
'name': form.name.data,
'display': form.display.data,
'description': form.description.data,
'website': form.description.data,
'removed': form.removed.data,
'currency': form.currency.data.upper(),
'application_plan_id': form.application_plan_id.data,
'application_id': g.application.id
})
organization.save()
member = Member(**{
'display': Member.display_from_email(form.member_email.data),
'email': form.member_email.data,
'password': bcrypt.hashpw(form.member_password.data, bcrypt.gensalt()),
'organization_id': organization.id,
'status': 'MEMBER',
'admin': True
})
member.save()
return jsonify(organization.to_json()), 201
def member_edit():
"""
"""
form = MemberForm()
if form.validate_on_submit():
member = Member(firstname = form.firstname.data,
lastname = form.lastname.data,
location = form.location.data,
user = users.get_current_user())
member.put()
flash('Member saved on database.')
return redirect(url_for('member_list'))
return render_template('members/edit.html', form=form)
def save_keypair(request):
public_key = request.POST['public-key']
private_key = request.POST['private-key']
try:
member = request.user.member
member.private_key = private_key
member.public_key = public_key
member.save()
except Member.DoesNotExist:
# New user
member = Member(public_key=public_key, private_key=private_key, user=request.user)
member.save()
return JsonResponse({'foo': 'bar'})
def create_chat(is_group, user_id, second_user_id):
chat = Chat(title='aa', is_group_chat=is_group)
chat.save()
first_member = Member(user=User.objects.get(pk=user_id), chat=chat)
second_member = Member(user=User.objects.get(pk=second_user_id), chat=chat)
first_member.save()
second_member.save()
def post(self, request, *args, **kwargs):
self.object = self.get_object()
form_class = self.get_form_class()
form = MemberImportForm(user=self.object)
c_in = request.POST.get('c_in')
c_out = request.POST.get('c_out')
if c_in:
member = Member.objects.get(id=c_in)
elif c_out:
member = Member.objects.get(id=c_out)
else:
member = Member()
member.user = self.object
member.save()
return HttpResponseRedirect(reverse('user_edit'))
def post(self, request, *args, **kwargs):
self.object = self.get_object()
form_class = self.get_form_class()
form = MemberImportForm(user=self.object)
c_in = request.POST.get('c_in')
c_out = request.POST.get('c_out')
if c_in:
member = Member.objects.get(id=c_in)
elif c_out:
member = Member.objects.get(id=c_out)
else:
member = Member()
member.user = self.object
member.save()
return HttpResponseRedirect(reverse('user_edit'));
def save_keypair(request):
public_key = request.POST['public-key']
private_key = request.POST['private-key']
try:
member = request.user.member
member.private_key = private_key
member.public_key = public_key
member.save()
except Member.DoesNotExist:
# New user
member = Member(public_key=public_key,
private_key=private_key,
user=request.user)
member.save()
return JsonResponse({'foo': 'bar'})
def desktop_verify_parking_permit(request):
if request.method == "POST":
owner = request.user
try:
# Process the email address the owner provided.
owner_email = request.session.get("owner_email")
if owner.email == "":
owner.email == owner_email
owner.save()
elif owner.email != owner_email:
pass
# TODO: Save as an alternate email (member app) and log as a WARNING or INFO?
# Create the parking permit in the database
perm = ParkingPermit.objects.create(
owner=request.user.member,
short_desc=request.session.get("short_desc"),
ok_to_move=request.session.get("ok_to_move"),
approving_member=Member.get_local_member(request.session.get("approving_member_username")),
)
_clear_session(request)
return HttpResponse("SUCCESS " + str(perm.pk))
except Exception as e:
return HttpResponse("ERROR " + str(e))
else: # For GET and any other methods:
return render(request, "inventory/desktop-parking-permit-verify.html")
def desktop_verify_parking_permit(request):
if request.method == 'POST':
owner = request.user
try:
# Process the email address the owner provided.
owner_email = request.session.get("owner_email")
if owner.email == "":
owner.email == owner_email
owner.save()
elif owner.email != owner_email:
pass
# TODO: Save as an alternate email (member app) and log as a WARNING or INFO?
# Create the parking permit in the database
perm = ParkingPermit.objects.create(
owner=request.user.member,
short_desc=request.session.get("short_desc"),
ok_to_move=request.session.get("ok_to_move"),
approving_member=Member.get_local_member(
request.session.get("approving_member_username")))
_clear_session(request)
return HttpResponse("SUCCESS " + str(perm.pk))
except Exception as e:
return HttpResponse("ERROR " + str(e))
else: # For GET and any other methods:
return render(request, 'inventory/desktop-parking-permit-verify.html')
def delete(self, request, member_id=None):
member = Member.safe_get(member_id)
if not member:
return HTTPResponse({"No such member found !"})
member.delete()
response = {}
return HTTPResponse(response)
def api_member_details(request, member_card_str, staff_card_str):
""" Respond with corresponding user/member info given the membership card string in the QR code. """
success, info = Member.get_for_staff(member_card_str, staff_card_str)
if not success:
error_msg = info
return JsonResponse({'error': error_msg})
member = info[0] # type: Member
data = {
'pk':
member.pk,
'is_active':
member.is_active,
'username':
member.username,
'first_name':
member.first_name,
'last_name':
member.last_name,
'email':
member.email,
'tags': [
tagging.tag.name
for tagging in member.taggings.filter(tag__active=True,
is_tagged=True).all()
]
}
return JsonResponse(data)
def test_form_valid(self, board_mail, references_mail):
mock_form = Mock(spec=RenewalFormView)
member = Member(
email="*****@*****.**",
first_name="John",
last_name="Doe",
profile=Profile(),
)
renewal = Renewal(pk=0, member=member)
mock_form.save = MagicMock(return_value=renewal)
with self.subTest("No references required"):
renewal.no_references = True
return_value = self.view.form_valid(mock_form)
board_mail.assert_called_once_with(renewal)
self.assertFalse(references_mail.called)
self.assertEqual(return_value.status_code, 302)
self.assertEqual(return_value.url,
reverse("registrations:renew-success"))
board_mail.reset_mock()
with self.subTest("References required"):
renewal.no_references = False
return_value = self.view.form_valid(mock_form)
board_mail.assert_called_once_with(renewal)
references_mail.assert_called_once_with(renewal)
self.assertEqual(return_value.status_code, 302)
self.assertEqual(return_value.url,
reverse("registrations:renew-success"))
def test_send_renewal_accepted_message(self, send_email):
member = Member(
email="*****@*****.**",
first_name="John",
last_name="Doe",
profile=Profile(),
)
renewal = Renewal(pk=0, member=member, contribution=2)
emails.send_renewal_accepted_message(renewal)
with translation.override(renewal.member.profile.language):
send_email.assert_called_once_with(
renewal.member.email,
_("Renewal accepted"),
"registrations/email/renewal_accepted.txt",
{
"name": renewal.member.get_full_name(),
"fees": floatformat(renewal.contribution, 2),
"thalia_pay_enabled":
settings.THALIA_PAY_ENABLED_PAYMENT_METHOD,
"url":
(settings.BASE_URL + reverse("registrations:renew", )),
},
)
def validate_client_id(form, field):
if not field.data:
return
member = Member.find_by_id(field.data)
if not member:
raise ValidationError('Client not found.')
def test_name(self):
renewal = Renewal(member=Member(
first_name="John",
last_name="Doe",
))
self.assertEqual(self.admin.name(renewal),
renewal.member.get_full_name())
def upload_file(request):
"""Creates a view to upload a file and read the contents, if the uploaded file is\
a zip file, file is first extracted and read. the file is read and updates the data\
to database. if the corresponding group is not present, a new group is created and updated."""
x = {}
y = []
s = []
if request.method == "POST":
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
title = form.files["file"]
filename = str(title)
x = request.FILES
front = filename.split(".")[0]
if filename.endswith(".zip"):
zipf = zipfile.ZipFile(x["file"])
zipf.extractall(os.getcwd())
else:
y = x["file"].read()
z = "" + front + ".xlsx"
path = default_storage.save(z, ContentFile(y))
tmp_file = os.path.join(settings.MEDIA_ROOT, path)
if form.is_valid():
workbook = xlrd.open_workbook(z)
sh = workbook.sheet_by_name("Sheet1")
for rownum in range(sh.nrows):
member = Member()
member.firstname = sh.row_values(rownum)[0]
member.lastname = sh.row_values(rownum)[1]
member.dob = sh.row_values(rownum)[2]
member.gender = sh.row_values(rownum)[3]
member.organisation = sh.row_values(rownum)[4]
member.email = sh.row_values(rownum)[5]
code = str(sh.row_values(rownum)[6])
group, status = Group.objects.get_or_create(group_code=code)
member.group = group
member.save()
os.chdir(os.getcwd())
files = glob.glob("*.xlsx")
for filename in files:
os.unlink(filename)
return HttpResponseRedirect(reverse("index"))
else:
form = UploadFileForm()
return render(request, "contacts/read.html", {"form": form})
def clean_person_number(self):
person_number = self.cleaned_data['person_number']
melos_id = MelosClient.get_melos_id(person_number)
if not melos_id or Member.find_by_melos_id(melos_id):
raise forms.ValidationError(_("Incorrect SSN"))
self.instance.melos_id = melos_id
return person_number
def save(self, commit=True):
# We need remove category before save person.
category = self.cleaned_data.pop('category', '')
person = super(SignupPersonForm, self).save(commit=False)
person.comments = (
"Se cargó a través del sitio web. Categoria seleccionada: %s." % category.name)
patron = Patron(
name=f"{person.first_name} {person.last_name}",
email=person.email, comments="Se cargó a través del sitio web")
member = Member(registration_date=now(), category=category)
if commit:
patron.save()
member.patron = patron
member.save()
person.membership = member
person.save()
return person
def member_tags(request, tag_pk=None, member_pk=None, op=None):
staff = request.user.member
member = None if member_pk is None else Member.objects.get(pk=member_pk)
if member is not None and tag_pk is not None and op is not None:
tag = Tag.objects.get(pk=tag_pk)
if op == "+": Tagging.add_if_permitted(staff, member, tag)
if op == "-": Tagging.remove_if_permitted(staff, member, tag)
staff_can_tags = None
staff_addable_tags = None
members_tags = None
if request.method == 'POST': # Process the form data.
form = Desktop_ChooseUserForm(request.POST)
if form.is_valid():
member_id = form.cleaned_data["userid"]
member = Member.get_local_member(member_id)
else:
# We get here if the userid field was blank.
member = None
else: # If a GET (or any other method) we'll create a blank form.
username = None if member is None else member.username
form = Desktop_ChooseUserForm(initial={'userid': username})
if member is not None:
members_tags = [
tagging.tag for tagging in Tagging.objects.filter(
tag__active=True, is_tagged=True, member=member)
]
staff_can_tags = [
tagging.tag for tagging in Tagging.objects.filter(
tag__active=True, can_tag=True, member=staff)
]
staff_addable_tags = list(
staff_can_tags) # copy contents, not pointer.
# staff member can't add tags that member already has, so:
for tagging in member.taggings.filter(tag__active=True,
is_tagged=True).all():
if tagging.tag in staff_addable_tags:
staff_addable_tags.remove(tagging.tag)
today = date.today()
visits = VisitEvent.objects.filter(when__gt=today)
visitors = [visit.who for visit in visits]
return render(
request, 'members/desktop-member-tags.html', {
'form': form,
'staff': staff,
'member': member,
'members_tags': members_tags,
'staff_can_tags': staff_can_tags,
'staff_addable_tags': staff_addable_tags,
'visitors': set(visitors),
})
def create(self, request, **kwargs):
serializer = AddMemberSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
id = request.user
adder = User.objects.get(username=id)
semester = get_semester_of_date(datetime.datetime.now())
lifetime = serializer.data["lifetime"]
try:
user = User.objects.get(email=serializer.data["email"])
except Exception:
user = None
member = Member(
seller=adder,
last_edited_by=adder,
semester=semester,
name=serializer.data["name"],
lifetime=serializer.data["lifetime"],
email=serializer.data["email"],
honorary=False,
)
if "uio_username" in serializer.data:
member.uio_username = serializer.data["uio_username"]
if user is not None:
member.user = user
if lifetime:
member.date_lifetime = timezone.now()
member.save()
return Response(MemberSerializer(member).data, status=status.HTTP_201_CREATED)
def _members(request, db=None, ctx={}):
t = loader.get_template('members.html')
try:
status = request.REQUEST['status']
except StandardError:
status = 'Elfin'
ctx['status'] = status
ctx['members'] = Member.members_with_status(status)
return HttpResponse(t.render(RequestContext(request, ctx)))
def create_member(email, company):
# Create user account for member with random password
user = User(email=email, is_active=False)
password = User.objects.make_random_password()
user.set_password(password)
user.save()
member = Member(user=user, company=company)
member.save()
member.generate_token()
# Finally send an email to member with an invitation to activate account
member.notify_activation()
def verify_default_claims(HOST):
today = datetime.date.today()
claims = Claim.objects.filter(
status=Claim.STAT_CURRENT,
claimed_task__scheduled_date__range=[
today + THREEDAYS, today + FOURDAYS
],
# REVIEW: Is the following 'claiming_member' restriction actually required?
claiming_member=F(
'claimed_task__recurring_task_template__default_claimant'),
date_verified__isnull=True,
claiming_member__worker__should_nag=True,
)
if len(claims) == 0:
# No default claims to process.
return
text_content_template = get_template('tasks/email-verify-claim.txt')
html_content_template = get_template('tasks/email-verify-claim.html')
for claim in claims:
if not claim.claiming_member.worker.should_nag:
continue
b64, md5 = Member.generate_auth_token_str(
lambda token: Nag.objects.filter(auth_token_md5=token).count(
) == 0) # uniqueness test
nag = Nag.objects.create(who=claim.claiming_member,
auth_token_md5=md5)
nag.claims.add(claim)
nag.tasks.add(claim.claimed_task)
dow = claim.claimed_task.scheduled_weekday()
d = {
'claimant': claim.claiming_member,
'claim': claim,
'task': claim.claimed_task,
'dow': dow,
'auth_token': b64,
'host': HOST,
}
# Send email messages:
subject = 'Please verify your availability for this {}'.format(dow)
from_email = EMAIL_VOLUNTEER
bcc_email = EMAIL_ARCHIVE
to = claim.claiming_member.email
text_content = text_content_template.render(d)
html_content = html_content_template.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email,
[to], [bcc_email])
msg.attach_alternative(html_content, "text/html")
msg.send()
def setUpTestData(cls):
# Add 10 members with default membership
members = [Member(id=i, username=i) for i in range(10)]
Member.objects.bulk_create(members)
memberships = [
Membership(user_id=i, type=Membership.MEMBER) for i in range(10)
]
Membership.objects.bulk_create(memberships)
profiles = [Profile(user_id=i) for i in range(10)]
Profile.objects.bulk_create(profiles)
def authenticate(self, username=None, password=None):
identifier = username # Given username is actually a more generic identifier.
user = Member.get_local_user(identifier)
if user is None:
return None
elif user.check_password(password):
return user
else:
return None
def create_chat(request):
form = CreateChatForm(request.POST)
if form.is_valid():
session = boto3.session.Session()
user = User.objects.get(username=request.POST['username'])
opponent = User.objects.get(username=request.POST['opponent'])
user_chats = [elem.chat for elem in Member.objects.filter(user=user)]
s3_client = session.client(
service_name='s3',
endpoint_url='http://hb.bizmrg.com',
aws_access_key_id='6Da62vVLUi6AKbFnnRoeA3',
aws_secret_access_key=
'gDYg4Bu15yUpNYGKmmpiVNGvLRWhUAJ3m1GGRvg8KTbU',
)
avatar = s3_client.generate_presigned_url(
'get_object',
Params={
'Bucket': 'tsyrkov_messanger_bucket',
'Key': opponent.avatar,
},
ExpiresIn=3600)
topic = request.POST['username'] + ' with ' + request.POST['opponent']
for chat in user_chats:
if Member.objects.filter(chat=chat).filter(user=opponent).exists():
return JsonResponse({
'opponent': opponent.username,
'avatar': avatar,
'author': '',
'last_message': '',
'read': False,
'topic': topic,
'date': '',
})
chat = Chat(
topic=topic,
is_group_chat=False,
)
chat.save()
member_1 = Member(chat=chat, user=user)
member_2 = Member(chat=chat, user=opponent)
member_1.save()
member_2.save()
return JsonResponse({
'opponent': opponent.username,
'avatar': avatar,
'author': '',
'last_message': '',
'read': False,
'topic': topic,
'date': '',
})
return JsonResponse({'errors': form.errors}, status=400)
def create(self, row):
first_name = row['Nombre'].strip()
last_name = row['Apellido'].strip()
email = row['EMail'].strip()
patron = Patron(
name="{} {}".format(first_name, last_name),
email=email,
comments='Automatically loaded with PyCamp 2018 script',
)
patron.save()
category = Category.objects.get(name=row["Tipo socio"].strip())
member = Member(
category=category,
patron=patron,
has_student_certificate=row['C.Estud'].strip() == "✓",
has_subscription_letter=row['Firmó'].strip() == "✓"
)
member.save()
street_address, city, zip_code, province, country = split_address(row['Domicilio'].strip())
person = Person(
first_name=first_name,
last_name=last_name,
email=email,
document_number=row['DNI'].strip(),
nickname=row['Nick'].strip(),
nationality=row['Nacionalidad'].strip(),
marital_status=row['Estado Civil'].strip(),
occupation=row['Profesión'].strip(),
birth_date=get_date(row['Fecha Nacimiento'].strip()),
street_address=street_address,
city=city,
zip_code=zip_code,
province=province,
country=country,
membership=member,
comments='Automatically loaded with PyCamp 2018 script',
)
person.save()
return member
def authenticate(self, username=None, password=None):
identifier = username # Given username is actually a more generic identifier.
# Member.get_local_user() is case-insensitive
user = Member.get_local_user(identifier) # type: User
if user is None:
return None
elif user.check_password(password):
return user
else:
return None
def filter_queryset(self, request, queryset, view):
rfidnum = request.query_params.get('rfidnum', None)
if rfidnum is None:
return queryset
else:
m = Member.get_by_card_str(rfidnum)
if m is None:
return queryset.none()
else:
return queryset.filter(
membership_card_md5=m.membership_card_md5)
def form_valid(self, form):
ret = super(RegisterView, self).form_valid(form)
user = form.auth_user()
if user:
login(self.request, user)
if form.is_import():
return HttpResponseRedirect(reverse('retrieve_member'))
else:
Member(user=user).save()
return HttpResponseRedirect(reverse('user_edit'))
return ret
def kiosk_staff_menu(request, member_card_str):
member = Member.get_by_card_str(member_card_str)
if member is None or not member.is_domain_staff():
return render(request, 'members/kiosk-invalid-card.html', {}) # TODO: use kiosk-domain-error template?
params = {
"memb_fname" : member.first_name,
"memb_card_str" : member_card_str
}
return render(request, 'members/kiosk-staff-menu.html', params)
def kiosk_identify_subject(request, staff_card_str, next_url):
member = Member.get_by_card_str(staff_card_str)
if member is None or not member.is_domain_staff():
return render(request, 'members/kiosk-invalid-card.html', {}) # TODO: use kiosk-domain-error template?
params = {
"staff_card_str" : staff_card_str,
"next_url" : next_url
}
return render(request, 'members/kiosk-identify-subject.html', params)
def create_new_member_and_pass( clean_new_member_data ):
### Create the Member Instance ###
# create the dictionary of attributes relevant to the member model
member_dict = {k:v for k,v in clean_new_member_data.items() if k not in ['member_type', 'is_reserved', 'reserved_id']}
#print member_dict
member = Member( **member_dict )
member.save()
### Create the Pass instance ###
# Don't create a pass for Trip-Only Members
current_season = get_current_season()
is_reserved = clean_new_member_data['is_reserved']
# if signed up as reserved, use that reserved id
if ( is_reserved ):
active_id = clean_new_member_data['reserved_id']
# else give them the lowest active id for the season, which is greater than 25
# this should fill in holes if someone gets deleted
else:
pass_set = Pass.objects.filter(season=current_season, active_id__gte=26)
active_set = { p.active_id for p in pass_set}
if ( len(active_set) == 0 ): active_id = 26 # first non-reserved member of the season
else:
active_range = range(26, max(active_set))
active_id = max(active_set) + 1 # set to the max + 1
# unless we find an empty space
for i in active_range:
if i not in active_set: # if we find one in the range, but not in the set
active_id = i # use that empty space
break
if clean_new_member_data['member_type'].member_type == "TRIP": active_id= None
member_pass = Pass( member=member, season=current_season,
active_id=active_id, is_reserved=is_reserved,
member_type=clean_new_member_data['member_type'],
price_paid=get_price_paid(clean_new_member_data['member_type']),
photo=member.photo)
# add them to the database
member_pass.save()
return member.id
def _session(request, db=None, ctx={}):
try:
name = request.REQUEST['name']
except StandardError:
name = None
t = loader.get_template('session.html')
ctx['SessionChoiceForm'] = forms.SessionChoiceForm()
ctx['sessions'] = Session.objects.all()
return HttpResponse(t.render(RequestContext(request, ctx)))
t = loader.get_template('members.html')
ctx['members'] = Member.attendees(name)
return HttpResponse(t.render(RequestContext(request, ctx)))
def validate_member_id(form, field):
from members.models import Member
if request.method == 'POST':
if not form.member_id.data:
raise ValidationError(field.gettext('This field is required.'))
field.member = Member.find_by_id(field.data)
if not member:
raise ValidationError('Member not found.')
else:
field.data = None
def _log_visit_event(member_card_str, event_type):
is_valid_evt = event_type in [x for (x, _) in VisitEvent.VISIT_EVENT_CHOICES]
if not is_valid_evt:
return False, "Invalid event type."
member = Member.get_by_card_str(member_card_str)
if member is None:
return False, "No matching member found."
else:
VisitEvent.objects.create(who=member, event_type=event_type)
_inform_other_systems_of_checkin(member, event_type)
return True, member
def _special_case_0JFN0loJ0kcy8DXCvuDVwwMF(self, sale):
# Verify: This was erroneously entered as a donation but was really a work-trade payment.
mship = Membership()
mship.sale = Sale(id=sale['id'])
mship.member = Member(
id=19
) # Lookup by name would be better but I don't want to have names in the code.
mship.membership_type = Membership.MT_WORKTRADE
mship.ctrlid = "{}:1:1".format(sale['ctrlid'])
mship.start_date = date(2015, 12, 1)
mship.end_date = date(2015, 12, 31)
mship.sale_price = 10.00
self.upsert(mship)
def test_send_references_information_message(self, send_email):
with self.subTest("Registrations"):
registration = Registration(
language="en",
email="*****@*****.**",
first_name="John",
last_name="Doe",
pk=uuid.uuid4(),
)
emails.send_references_information_message(registration)
send_email.assert_called_once_with(
"*****@*****.**",
"Information about references",
"registrations/email/references_information.txt",
{
"name": registration.get_full_name(),
"reference_link": (
"https://thalia.localhost"
+ reverse("registrations:reference", args=[registration.pk])
),
},
)
send_email.reset_mock()
with self.subTest("Renewals"):
member = Member(
email="*****@*****.**",
first_name="John",
last_name="Doe",
profile=Profile(language="en"),
)
renewal = Renewal(pk=uuid.uuid4(), member=member)
emails.send_references_information_message(renewal)
send_email.assert_called_once_with(
"*****@*****.**",
"Information about references",
"registrations/email/references_information.txt",
{
"name": renewal.member.get_full_name(),
"reference_link": (
"https://thalia.localhost"
+ reverse("registrations:reference", args=[renewal.pk])
),
},
)
def kiosk_main_menu(request, member_card_str):
member = Member.get_by_card_str(member_card_str)
if member is None:
return render(request, 'members/kiosk-invalid-card.html', {}) # TODO: use kiosk-domain-error template?
params = {
"memb_fname" : member.first_name,
"memb_card_str" : member_card_str,
"memb_is_staff" : member.is_tagged_with("Staff"),
"evt_arrival" : VisitEvent.EVT_ARRIVAL,
"evt_departure" : VisitEvent.EVT_DEPARTURE,
}
return render(request, 'members/kiosk-main-menu.html', params)
def rfid_entry_granted(request, rfid_cardnum):
member = Member.get_by_card_str(rfid_cardnum)
if member is not None:
VisitEvent.objects.create(
who=member,
# RFID reads are not reliable indicators of arrival.
# Cards are sometimes read when people walk past the reader on the way OUT.
# Therefore, RFID reads will be considered as indicationg *presence*.
event_type=VisitEvent.EVT_PRESENT,
method=VisitEvent.METHOD_RFID,
)
else:
logger.warning("No member found with RFID card# %s", rfid_cardnum)
return JsonResponse({'success': "Information noted."})
def SurvivorRegistration(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/home')
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(username=form.cleaned_data["username"],
email=form.cleaned_data["email"],
password=form.cleaned_data["password"])
user.save()
member = Member(
user=user, ign=form.cleaned_data["ign"], title="Player")
member.save()
return HttpResponseRedirect('/home')
else:
return render_to_response("register.html", {"form": form},
context_instance=RequestContext(request))
else:
# user is not submitting the form, show them a registration form
form = RegistrationForm()
context = {"form": form}
return render_to_response('register.html', context,
context_instance=RequestContext(request))
def api_member_details_pub(request, member_card_str):
""" Respond with corresponding user/member tags given the membership card string. """
subject = Member.get_by_card_str(member_card_str)
if subject is None:
return JsonResponse({'error':"Invalid member card string"})
data = {
'pk': subject.pk,
'is_active': subject.is_active,
'tags': [tag.name for tag in subject.tags.all()]
}
return JsonResponse(data)
def member_tags(request, tag_pk=None, member_pk=None, op=None):
staff = request.user.member
member = None if member_pk is None else Member.objects.get(pk=member_pk)
if member is not None and tag_pk is not None and op is not None:
tag = Tag.objects.get(pk=tag_pk)
if op == "+": Tagging.add_if_permitted(staff, member, tag)
if op == "-": Tagging.remove_if_permitted(staff, member, tag)
staff_can_tags = None
staff_addable_tags = None
members_tags = None
if request.method == 'POST': # Process the form data.
form = Desktop_ChooseUserForm(request.POST)
if form.is_valid():
member_id = form.cleaned_data["userid"]
member = Member.get_local_member(member_id)
else:
# We get here if the userid field was blank.
member = None
else: # If a GET (or any other method) we'll create a blank form.
username = None if member is None else member.username
form = Desktop_ChooseUserForm(initial={'userid': username})
if member is not None:
members_tags = member.tags.all()
staff_can_tags = [tagging.tag for tagging in Tagging.objects.filter(can_tag=True, tagged_member=staff)]
staff_addable_tags = list(staff_can_tags) # copy contents, not pointer.
# staff member can't add tags that member already has, so:
for tag in member.tags.all():
if tag in staff_addable_tags:
staff_addable_tags.remove(tag)
today = date.today()
visits = VisitEvent.objects.filter(when__gt=today)
visitors = [visit.who for visit in visits]
return render(request, 'members/desktop-member-tags.html', {
'form': form,
'staff': staff,
'member': member,
'members_tags': members_tags,
'staff_can_tags': staff_can_tags,
'staff_addable_tags': staff_addable_tags,
'visitors': set(visitors),
})
def import_data(ty,data):
#TODO
error = False
# for line in csv.DictReader(data,delimiter='\t',quoting=csv.QUOTE_NONE):
for l in csv.DictReader(data.read().splitlines(),delimiter=';',quoting=csv.QUOTE_NONE):
# for line in c_data:
# l = findall(r'\"(.+?)\"',str(line))
# for line in c_data:
# l = findall(r'\"(.+?)\"',str(line))
Model = None
try:
if ty == "members":
# Model = Member.objects.get(first_name=l[1],last_name=l[0],email=l[6])
Model = Member.objects.get(first_name=unicode(l['VIRNUMM']),last_name=unicode(l['NUMM']),email=unicode(l['EMAIL']))
if ty == "calendar": Model = Meeting.objects.get(title=unicode(l[0]),when=unicode(l[1]),time=unicode(l[2]))
except:
if ty == "members":
A = Address (
address = unicode(l['ADRESS']),
postal_code = unicode(l['CP']),
location = unicode(l['DUERF']),
country = unicode(l['LAND'])
)
Model = Member (
first_name = unicode(l['VIRNUMM']),
last_name = unicode(l['NUMM']),
address = A,
email = unicode(l['EMAIL'])
)
# create user
user = User.objects.create_user(gen_username(Model.first_name,Model.last_name), Model.email, make_password(gen_random_password()))
Model.user = user
if ty == "calendar":
Model = Meeting (
title = unicode(l[0]),
when = unicode(l[1]),
time = unicode(l[2])
)
# check/create location
location = None
try:
location = Location.objects.get(name=l[3])
except Location.DoesNotExist:
location = Location (name=l[3])
Model.location = location
Model.save()
return error
def verify_default_claims(HOST):
today = datetime.date.today()
claims = Claim.objects.filter(
status=Claim.STAT_CURRENT,
claimed_task__scheduled_date__range=[today+THREEDAYS, today+FOURDAYS],
# REVIEW: Is the following 'claiming_member' restriction actually required?
claiming_member=F('claimed_task__recurring_task_template__default_claimant'),
date_verified__isnull=True)
if len(claims) == 0:
# No default claims to process.
return
text_content_template = get_template('tasks/email-verify-claim.txt')
html_content_template = get_template('tasks/email-verify-claim.html')
for claim in claims:
b64, md5 = Member.generate_auth_token_str(
lambda token: Nag.objects.filter(auth_token_md5=token).count() == 0) # uniqueness test
nag = Nag.objects.create(who=claim.claiming_member, auth_token_md5=md5)
nag.claims.add(claim)
nag.tasks.add(claim.claimed_task)
dow = claim.claimed_task.scheduled_weekday()
d = {
'claimant': claim.claiming_member,
'claim': claim,
'task': claim.claimed_task,
'dow': dow,
'auth_token': b64,
'host': HOST,
}
# Send email messages:
subject = 'Please verify your availability for this {}'.format(dow)
from_email = EMAIL_VOLUNTEER
bcc_email = EMAIL_ARCHIVE
to = claim.claiming_member.email
text_content = text_content_template.render(d)
html_content = html_content_template.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to], [bcc_email])
msg.attach_alternative(html_content, "text/html")
msg.send()
def api_member_details(request, member_card_str, staff_card_str):
""" Respond with corresponding user/member info given the membership card string in the QR code. """
success, info = Member.get_for_staff(member_card_str, staff_card_str)
if not success:
error_msg = info
return JsonResponse({'error': error_msg})
member, _ = info # type: Tuple[Member, Member]
data = {
'pk': member.pk,
'is_active': member.is_active,
'username': member.username,
'first_name': member.first_name,
'last_name': member.last_name,
'email': member.email,
'tags': [tag.name for tag in member.tags.all()]
}
return JsonResponse(data)
def member_calendar(request, token):
# See if token corresponds to a Worker's calendar_token:
try:
worker = Worker.objects.get(calendar_token=token)
member = worker.member
except Worker.DoesNotExist:
member = None
# If token didn't correspond to nag, see if it's a member card string:
if member is None:
member = Member.get_by_card_str(token)
if member is None:
raise Http404("No such calendar")
cal = _new_calendar("My Xerocraft Tasks")
for task in _gen_tasks_for(member):
_add_event(cal, task, request)
#TODO: Add ALARM
return _ical_response(cal)
def verify_default_claims(HOST):
text_content_template = get_template('tasks/email-verify-claim.txt')
html_content_template = get_template('tasks/email-verify-claim.html')
today = datetime.date.today()
for claim in Claim.objects.filter(
status = Claim.STAT_CURRENT,
claimed_task__scheduled_date__range=[today+THREEDAYS, today+FOURDAYS],
claiming_member=F('claimed_task__recurring_task_template__default_claimant'),
date_verified__isnull=True):
b64, md5 = Member.generate_auth_token_str(
lambda token: Nag.objects.filter(auth_token_md5=token).count() == 0) # uniqueness test
nag = Nag.objects.create(who=claim.claiming_member, auth_token_md5=md5)
nag.claims.add(claim)
nag.tasks.add(claim.claimed_task)
dow = claim.claimed_task.scheduled_weekday()
d = Context({
'claimant': claim.claiming_member,
'claim': claim,
'task': claim.claimed_task,
'dow': dow,
'auth_token': b64,
'host': HOST,
})
# Send email messages:
subject = 'Please verify your availability for this {}'.format(dow)
from_email = VC_EMAIL
bcc_email = XIS_EMAIL
to = claim.claiming_member.email
text_content = text_content_template.render(d)
html_content = html_content_template.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to], [bcc_email])
msg.attach_alternative(html_content, "text/html")
msg.send()
def _get_task_and_member(task_pk, member_card_str):
try:
task = Task.objects.get(pk=task_pk)
except Task.DOES_NOT_EXIST:
msg = "Info provided doesn't correspond to a task."
_logger.error(msg)
return None, None, JsonResponse({"error": msg})
if task.work_start_time is None or task.work_duration is None:
msg = "Expected a task with a specific time window."
_logger.error(msg)
return None, None, JsonResponse({"error": msg})
member = Member.get_by_card_str(member_card_str)
if member is None:
# This might legitimately occur if an invalidated card is presented at the kiosk.
msg = "Info provided doesn't correspond to a member."
_logger.warning(msg)
return None, None, JsonResponse({"error": msg})
return task, member, None
