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 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 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 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 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 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 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_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 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 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 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 _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 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 test_clean_ok(self):
unit = ResourceUnit(name="heure")
resource = Resource(name="Laser",
slug="laser",
unit=unit,
price_not_member=2,
price_member=1)
member = Member(name="Name", surname="Surname")
usage = Usage(member=member, resource=resource, qty=5)
project = Project(name="Project", member=member)
usage.project = project
usage.clean()
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 test_clean_error(self):
unit = ResourceUnit(name="heure")
resource = Resource(name="Laser",
slug="laser",
unit=unit,
price_not_member=2,
price_member=1)
member = Member(name="Name", surname="Surname")
usage = Usage(member=member, resource=resource, qty=5)
project = Project(name="Project")
usage.project = project
with self.assertRaises(ValidationError):
usage.clean()
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 create(self, val_data):
password = val_data.pop('password', None)
username = val_data.pop('username', None)
email = val_data.pop('email', None)
twitch = val_data.pop('twitch', None)
twitter = val_data.pop('twitter', None)
# Check if user exists
does_exist = Member.objects.filter(username__iexact=username)
if len(does_exist) > 0:
return # TODO: This is f*****g retarded
user_instance = Member(email=email, username=username, twitch=twitch, twitter=twitter)
if password is not None: user_instance.set_password(password)
user_instance.save()
return user_instance
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 setUpTestData(cls):
# Add 10 members with default membership
members = [Member(id=i, username=i) for i in range(7)]
Member.objects.bulk_create(members)
profiles = [Profile(user_id=i) for i in range(7)]
Profile.objects.bulk_create(profiles)
Membership(user_id=0,
type=Membership.HONORARY,
until=date.today() + timedelta(days=1)).save()
Membership(
user_id=1,
type=Membership.BENEFACTOR,
until=date.today() + timedelta(days=1),
).save()
Membership(user_id=2,
type=Membership.MEMBER,
until=date.today() + timedelta(days=1)).save()
Membership(user_id=3,
type=Membership.MEMBER,
until=date.today() + timedelta(days=1)).save()
Membership(
user_id=3,
type=Membership.MEMBER,
until=date.today() - timedelta(days=365 * 10),
).save()
Membership(
user_id=4,
type=Membership.BENEFACTOR,
until=date.today() + timedelta(days=1),
).save()
Membership(
user_id=4,
type=Membership.MEMBER,
until=date.today() - timedelta(days=365 * 10),
).save()
Membership(
user_id=5,
type=Membership.MEMBER,
until=date.today() - timedelta(days=365 * 10),
).save()
def create(self, request, *args, **kwargs):
data = dict(request.data)
user = request.user
level = Level.safe_get(data.get('level_id'))
group = Group.safe_get(data.get('group_id'))
member = Member()
name = Name(first=data.get('first_name'),
middle=data.get('middle_name'),
last=data.get('last_name'))
member.name = name
member.dob = data.get("dob", None)
member.mobile_no = data.get("mobile_no", None)
member.level_id = level.to_dbref() if level else None
member.group_id = group.to_dbref() if group else None
member.created_at = datetime.utcnow()
member.created_by = user.to_dbref() if user.id else None
member.save()
response = {"id": str(member.id), "name": member.get_full_name()}
return HTTPResponse(response)
def member(request):
'''Creates a view to add members to database, if the group code exists,\
add the user to that group or else create a new group and save.'''
members = Member.objects.all()
groups = Group.objects.all()
if request.method == 'POST':
form = MemberForm(request.POST)
if form.is_valid():
firstname = form.cleaned_data['firstname']
lastname = form.cleaned_data['lastname']
dob = form.cleaned_data['dob']
gender = form.cleaned_data['gender']
organisation = form.cleaned_data['organisation']
email = form.cleaned_data['email']
options = request.POST.getlist('group')
new_code = request.POST['new_group']
name = request.POST['name']
description = request.POST['description']
try:
member = Member()
member.firstname = firstname
member.lastname = lastname
member.dob = dob
member.gender = gender
member.organisation = organisation
member.email = request.POST['email']
grp_codes = [str(x) for x in options]
for cd in grp_codes:
if cd:
gr = Group.objects.get(group_code=cd)
member.group = gr
g, status = Group.objects.get_or_create(group_code=new_code)
g.name = name
g.description = description
member.group = g
member.save()
except:
pass
return HttpResponseRedirect(reverse('index'))
else:
form = MemberForm()
context = {'members': members, 'groups': groups, 'form': form}
return render(request, 'members/member.html', context)
def test_send_renewal_complete_message(self, send_email):
member = Member(
email="*****@*****.**",
first_name="John",
last_name="Doe",
profile=Profile(),
)
renewal = Renewal(pk=0, member=member)
emails.send_renewal_complete_message(renewal)
with translation.override(renewal.member.profile.language):
send_email.assert_called_once_with(
renewal.member.email,
_("Renewal successful"),
"registrations/email/renewal_complete.txt",
{"name": renewal.member.get_full_name()},
)
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 validate(self, data):
# here data has all the fields which have validated values
# so we can create a User instance out of it
user = Member(**data)
# get the password from the data
password = data.get('password')
errors = dict()
try:
# validate the password and catch the exception
validators.validate_password(password=password, user=Member)
# the exception raised here is different than serializers.ValidationError
except exceptions.ValidationError as e:
errors['password'] = list(e.messages)
if errors:
raise serializers.ValidationError(errors)
return super(RegisterSerializer, self).validate(data)
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 test_send_new_renewal_board_message(self, send_email):
member = Member(
email="*****@*****.**",
first_name="John",
last_name="Doe",
profile=Profile(),
)
renewal = Renewal(pk=0, member=member)
emails.send_new_renewal_board_message(renewal)
send_email.assert_called_once_with(
settings.BOARD_NOTIFICATION_ADDRESS,
"New renewal",
"registrations/email/renewal_board.txt",
{
"name":
renewal.member.get_full_name(),
"url": ("https://thalia.localhost" + reverse(
"admin:registrations_renewal_change", args=[renewal.pk])),
},
)
def test_send_renewal_accepted_message(self, send_email):
member = Member(
email="*****@*****.**",
first_name="John",
last_name="Doe",
profile=Profile(language="en"),
)
renewal = Renewal(pk=0, member=member)
payment = Payment(amount=2,)
emails.send_renewal_accepted_message(renewal, payment)
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(payment.amount, 2),
},
)
from members.models import Member, MemberType
print("done.")
#Do we have any member types
total_types = len(MemberType.objects.all())
if total_types == 0:
print("No types found. Creating \"Member\".")
mtype = MemberType(name="Member")
mtype.save()
print("done.")
mtype = MemberType.objects.get(name__iexact="Member")
total_mem = len(Member.objects.all())
m1 = Member(number=total_mem + 1,
type=mtype,
first_name="Corey",
last_name="Clayton",
birth_date="1961-10-30",
first_seen_date=datetime.date.today(),
last_seen_date=datetime.date.today(),
address="206 Comber",
city="Dorval",
postal_code="H9S 2Y4",
phone_number="5142611046",
email="*****@*****.**",
emergency_contact="Meaghan Mueller",
emergency_phone_number="5146181390")
m1.save()
