def create_jamah_event(request, jamah_id):
jamah = Jamah.objects.get(pk=jamah_id)
name = request.POST['name']
messages.success(request, 'Added a Event for the jamah...')
account = Account(description='Event: ' + name + '\'s account')
account.save()
cost_account = Account(description='Event: ' + name + '\'s cost account')
cost_account.save()
event = Event(name=name,
creator=request.user,
account=account,
jamah=jamah,
cost_account=cost_account)
event.save()
event.members.add(request.user)
event.save()
member_account = Account(description='Event: ' + name + ' ' +
' ,Member: ' + request.user.username)
member_account.mother_account = event.account
member_account.save()
eventMember = EventMember(
member=request.user,
event=event,
status='creator',
accountant_account=member_account,
is_accountant=True,
is_head_accountant=True,
is_cost_observer=True,
).save()
return HttpResponseRedirect(reverse('jamah:detail', args=(jamah_id, )))
def validate(self):
try:
self.username = self.args[0]["username"]
self.password = self.args[0]["password"]
self.email = self.args[0]["email"]
except Exception as e:
return json.dumps({'Status':'Error','Message':'Account Creation Failed'})
if not re.match('^[a-zA-Z0-9_]+$', self.username):
self.errordict['usernameerror'] = 'Username must be an alphanumeric character'
elif Account.objects.filter(username=self.username).exists():
self.errordict['usernameerror'] = 'Username already exists'
if not re.match('^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$', self.email):
self.errordict['emailerror'] = 'Invalid Email format'
elif Account.objects.filter(email=self.email).exists():
self.errordict['emailerror'] = 'Email already registered'
if len(self.password) < 6:
self.errordict['passworderror'] = 'Password must be of atleast 6 characters'
elif not re.match('^.*[0-9]+.*$', self.password):
self.errordict['passworderror'] = 'Password must contain a numeric character'
elif not re.match('^.*[a-zA-Z]+.*$', self.password):
self.errordict['passworderror'] = 'Password must contain an alphabetic character'
if self.errordict['usernameerror']==self.errordict['passworderror']==self.errordict['emailerror']=='':
u = Account(username=self.username, password=make_password(self.password), email=self.email)
u.save()
return self.success("Account Created!")
return self.error()
def register(request):
request_data = json.loads(request.body.decode('utf-8'))
username = request_data['username']
password = request_data['password']
try:
user = User.objects.get(username=username)
except ObjectDoesNotExist as e:
user = User(username=username)
user.set_password(password)
user.is_active = False
user.save()
account = Account(user=user)
account.nickname = username
account.save()
account_confirm_code = AccountConfirmCode(
account=account, code=generate_account_confirm_code())
account_confirm_code.save()
else:
if user.is_active:
return JsonResponse(
get_json_dict(data={}, err_code=-1, message="您已注册过"))
user.set_password(password)
user.save()
account_confirm_code = user.account.account_confirm_code
account_confirm_code.code = generate_account_confirm_code()
account_confirm_code.save()
send_confirm_code_to_fdu_mailbox(username, account_confirm_code.code)
return JsonResponse(get_json_dict(data={}))
def get(self, request):
securities = Security.objects.all()
account_types = ["savings", 'retirement', 'growth', 'account', 'basic']
sponsors = ['MRG', 'MRL', 'UBS', 'XFI', 'WCV', 'SMB']
solutions = ["AssetAlloc", "E1", "E2", "EquityIndex", "FI", "FIDynamic", "FixedIncome", "PRDT-Product2", "Strategy1", "Strategy2", "Strategy3", "Strategy4", "Strategy5", "Strategy6", "Strategy7", "Strategy8", "Strategy9", "Strategy10"]
for i in range(0, 100):
sponsor = sponsors[randrange(0, len(sponsors) - 1)]
account_type = account_types[randrange(0, len(account_types) -1)]
name = "{0}{1}{2}".format(sponsor, account_type, i)
cash = randrange(0, 100000000)
expected_cash = randrange(0, 10000000)
client = randrange(1, 50)
description = "{0} for client {1}".format(account_type, client)
max_pos_drift = randrange(0, 100000)
max_cash_drift = randrange(0, 100000)
max_total_drift = randrange(0, 200000)
manager = randrange(0, 10)
solution = solutions[randrange(0, len(solutions) - 1)]
account = Account(name=name, description=description, inception_date=timezone.now(), total_cash=cash,
expected_cash=expected_cash, max_pos_drift=max_pos_drift, max_cash_drift=max_cash_drift,
max_total_drift=max_total_drift, client_1_id=client, manager=manager, solution_name=solution)
account.save()
number_of_holdings = randrange(0, 15)
for j in range(0, number_of_holdings):
sec = securities[randrange(1, (len(securities) - 1))]
quan = randrange(1, 5000)
exquan = randrange(1, 5000)
exval = randrange(1, 1000000)
holding = Holding(account=account, security=sec,
quantity=quan, expected_quantity=exquan, expected_value=exval)
holding.save()
return HttpResponse("done", status="200 OK", content_type="text/html")
def register(username, password):
code = uuid1()
hashed_password = hash_password(password + code.hex)
account = Account(
active=True,
password=hashed_password,
code=code
)
user = models.AccountUsername(
username=username,
account=account
)
db.session.add(account)
db.session.add(user)
try:
db.session.commit()
except:
db.session.rollback()
pass
return {
'id': account.id,
'active': account.active,
'username': user.username
}
def add_account(request):
account = Account(description=request.user.username + '\'s account')
account.save()
print(account.description)
userinfo = UserInfo(user=request.user, account=account)
userinfo.save()
return HttpResponseRedirect(reverse('home'))
def forwards(self, orm):
# we need to associate each user to an account object
for user in User.objects.all():
a = Account()
a.user = user
a.language = 'en' # default language
a.save()
def cargar_socio(request):
usuario = request.user
if usuario.groups.filter(name='secretaria').exists():
DomicilioFormSet = inlineformset_factory(
Account,
Domicilio,
fields=('codigo_postal', 'calle_numero_apartado_postal', 'colonia',
'municipio_delegacion', 'ciudad', 'estado', 'telefono'),
can_delete=False)
socio = Account()
if request.method == "POST":
form = SocioForm(request.POST, instance=socio)
domicilioFormset = DomicilioFormSet(request.POST, instance=socio)
if form.is_valid() and domicilioFormset.is_valid():
form.save()
domicilioFormset.save()
return redirect(detalle_socio, pk=socio.pk)
else:
form = SocioForm(instance=socio)
domicilioFormset = DomicilioFormSet(instance=socio)
else:
return redirect('sinPermisos')
return render(request, 'sociedad/cargar_socio.html', {
'form': form,
'domicilioFormset': domicilioFormset
})
def save(self):
email = self.validated_data['email'],
print(email[0])
username = self.validated_data['username']
account = Account(email=email[0],
username=self.validated_data['username'])
password1 = self.validated_data['password1']
password2 = self.validated_data['password2']
usernamePattern = '^[a-zA-Z0-9]+$'
emailPattern = '^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$'
passwordPattern = '^[a-z1-9A-Z.*+\-?^${}()|[\]\\@#$%^&*(!@]+$'
if not (re.match(usernamePattern, username)
) or len(username) < 8 or username[0] != username[0].upper():
raise serializers.ValidationError({
'error':
"Nazwa użytkownika musi zawierać co najmniej 8 liter bądź cyfr i pierwsza litera musi być wielka"
})
if password1 != password2 or len(
password1) < 8 or len(password2) < 8 or not (re.match(
passwordPattern, password1)) or not (re.match(
passwordPattern, password2)):
raise serializers.ValidationError({
'error':
"Hasło musi zawierać conajmniej 8 liter bądź cyfr i muszą być jendakowe"
})
if not (re.match(emailPattern, email[0])):
raise serializers.ValidationError(
{'error': "Email jest nieprawidłowy"})
account.set_password(password1)
account.save()
return account
def user_register(request):
request.POST = json.loads(request.body.decode('utf-8'))
username = request.POST['username']
password = request.POST['password']
gender = request.POST['gender']
nickname = request.POST['nickname']
user_form_data = {
'username': username,
'password': password,
}
user_form = UserForm(data=user_form_data)
json_dict = {
'err_code': 0,
'message': "Register success",
'data': {}
}
if user_form.is_valid():
user = user_form.save(commit=False)
user.set_password(user.password)
user.save()
account = Account(
user = user,
gender = gender,
nickname = nickname,
)
account.save()
return JsonResponse(json_dict)
json_dict['err_code'] = -1
json_dict['message'] = "User form is not valid"
return JsonResponse(json_dict)
def join_jamah(request, jamah_id):
jamah = Jamah.objects.get(pk=jamah_id)
# test if he requested already
jamahMember = JamahMember.objects.filter(member=request.user).filter(
jamah=jamah)
if jamahMember.count():
jamahMember = jamahMember[0]
if jamahMember.still_to_be_excepted:
messages.success(request, 'You already requested to join !!!')
return HttpResponseRedirect(reverse('jamah:all_jamah'))
else:
messages.success(request, 'You already are a Member !!!')
return HttpResponseRedirect(reverse('jamah:all_jamah'))
else:
# user didnot requested before so create jamahMember
jamah.requested_to_join.add(request.user)
jamah.save()
account = Account(description='Jamah: ' + jamah.jamahname + ' ' +
' ,Member: ' + request.user.username)
account.save()
jamahMember = JamahMember(member=request.user,
jamah=jamah,
status='member',
account=account).save()
messages.success(request, 'You requested to join the Group')
return HttpResponseRedirect(reverse('jamah:all_jamah'))
def main():
"""Execute import"""
chart_yml = get_yml_file('chart')
for item in yaml.safe_load(chart_yml):
import_chart = Chart(name=item.get('name'))
import_chart.save()
accounts_yml = get_yml_file('account')
for item in yaml.safe_load(accounts_yml):
local_chart = Chart.objects.get(pk=item.get('chart_id'))
local_account = Account(name=item.get('name'),
number=item.get('number'),
chart=local_chart)
local_account.save()
transactions_yml = get_yml_file('transaction')
for item in yaml.safe_load(transactions_yml):
left_account = Account.objects.get(name=item.get('left_account'))
right_account = Account.objects.get(name=item.get('right_account'))
print(left_account)
print(right_account)
local_transaction = Transaction(description=item.get('description'),
left_account=left_account,
right_account=right_account,
amount=item.get('amount'),
date=item.get('date'))
local_transaction.save()
def save(self, commit=True):
user = Account(username=self.cleaned_data['username'],
email=self.cleaned_data['email'])
user.set_password(self.cleaned_data['confirm_password'])
if commit:
user.save()
return user
def setUp(self):
self.account = Account(
**{
'username': '******',
'email': '*****@*****.**',
'password': '******'
})
self.account.save()
def save(self):
account = Account(username=self.validated_data['username'])
password = self.validated_data['password']
account.set_password(password)
account.save()
return account
def create(self, validated_data):
account_data = validated_data.pop('account')
password = validated_data.pop('password')
account = Account(**validated_data)
account.set_password(password)
account.save()
AccountProfile.objects.create(user=account, **account_data)
return account
def form_valid(self, form):
account = Account()
account.user = User.objects.filter(id=self.request.POST.get('user'))
account.active = self.request.POST.get('active')
account.role = self.request.POST.get('role')
account.save()
return redirect('account:account_create')
def save(self, *args, **kwargs):
if self.pk is None:
from account.models import Account
account = Account(name_en=self.name_en, name_ne=self.name_ne)
account.save()
self.account = account
super(Employee, self).save(*args, **kwargs)
def setUp(self):
self.account_data = {
'username': '******',
'email': '*****@*****.**',
'password': '******'
}
self.account = Account(**self.account_data)
self.account.save()
self.serializer = AccountSerializer(data=self.account_data)
def save(self):
account = Account(email=self.validated_data['email'])
password = self.validated_data['password']
password2 = self.validated_data['password2']
if password != password2:
raise serializers.ValidationError({'password': '******'})
account.set_password(password)
account.save()
return account
def create(self, validated_data):
"""Create and return a new user."""
user = Account(email=validated_data['email'],
username=validated_data['username'])
user.set_password(validated_data['password'])
user.save()
return user
def setUp(self):
self.account = Account(email='*****@*****.**', password='******')
self.account.first_name = 'user1'
self.account.last_name = 'mail'
self.account.is_active = True
now = datetime.datetime.now()
self.account.created_at = now
self.account.updated_at = now
self.account.save()
def create(request):
name = request.POST['jamahname']
account = Account(description='Jamah: ' + name + '\'s account')
account.save()
jamah = Jamah(jamahname=name, creator=request.user, account=account)
jamah.save()
jamah.members.add(request.user)
jamah.save()
account2 = Account(description='Jamah: ' + name + ' ' + ' ,Member: ' +
request.user.username)
account2.save()
jamahMember = JamahMember(member=request.user,
jamah=jamah,
status='creator',
still_to_be_excepted=False,
account=account2).save()
# print(jamahMember)
return HttpResponseRedirect(reverse('jamah:all_jamah'))
def test_successful_login(self):
password = "******"
account = Account(username="******", first_name="",
last_name="", email="")
account.set_password(password)
account.save()
response = self.client.post(reverse('account:login'), {'username': "******", 'password': password})
# self.assertEqual(response.status_code, 302)
messages = list(get_messages(response.wsgi_request))
self.assertEqual(str(messages[0]), 'Login successful')
def setUp(self):
user = User(email='*****@*****.**', username='******')
user.set_password("testpass")
user.pk = 1
user.save()
account = Account(user_id=1)
account.pk = 1
account.save()
self.profile = Profile(name='Dare', account_id=1)
self.profile.save()
def customer_create(request):
params = json.loads(request.body.decode("utf-8"))
data = {}
blacklist = Blacklist.objects.all()
for man in blacklist:
nameRatio = fuzz.partial_ratio(man.name, params['name'])
nationRatio = fuzz.partial_ratio(man.nationality, params['nation'])
addrRatio = fuzz.partial_ratio(man.address, params['address'])
print(nameRatio, addrRatio, nationRatio)
if (nameRatio > 70 or addrRatio > 80
or (nameRatio + nationRatio) > 170):
log = AlertLog()
log.name = params['name']
log.operate = '開戶'
log.reason = '疑似為高風險或黑名單人物'
log.save()
return common_response(data, message='黑名單人物')
try:
with transaction.atomic():
distrcit = District.objects.get(id=params['district']['id'])
customer = Customer()
customer.name = params['name']
customer.roc_id = params['roc_id']
customer.gender = params['gender']
customer.birthday = params['birthday']
customer.cell_phone = params['cell_phone']
customer.address = params['address']
customer.district = distrcit
customer.password = get_sha256_value(params['cell_phone'])
customer.email = params['email']
customer.save()
data['id'] = customer.id
# 產生帳戶號碼
code = generate_16_digits_code()
exist_codes = [account.code for account in Account.objects.all()]
while code in exist_codes:
code = generate_16_digits_code()
# 新增帳戶
account = Account()
account.code = code
account.customer = Customer.objects.get(id=customer.id)
# 預設第1筆(新台幣)
currency_list = Currency.objects.filter(id=1)
if len(currency_list) != 0:
account.currency = currency_list[0]
account.save()
return common_response(data)
except Exception as e:
return common_response(data, message=str(e))
def save(self):
account = Account(email=self.validated_data['email'],
username=self.validated_data['username'])
password = self.validated_data['password']
password2 = self.validated_data['password2']
if password != password2:
raise serializers.ValidationError(
{'password': '******'})
account.set_password = password
account.save()
return account
def save(self):
account = Account(
email=self.validated_data['email'],
first_name=self.validated_data['first_name'],
last_name=self.validated_data['last_name'],
)
password = self.validated_data['password']
account.set_password(password)
account.save()
return account
def test_edit_usl(self):
user = Account()
user.save()
test_date = datetime.datetime(2021, 3, 1)
test_usl = UnCertifiedSickLeave(usl_officer_id=user,
usl_date=test_date,
reason_for_usl="User Sick")
test_usl.save()
page = self.client.get("/abscences/{0}/edit_usl/".format(test_usl.id))
self.assertEqual(page.status_code, 200)
self.assertTemplateUsed(page, "edit_usl_application.html")
def test_reject_fm_page(self):
user = Account()
user.save()
test_date = datetime.datetime(2021, 3, 1)
test_fm = ForceMajeure(fm_officer_id=user,
fm_date=test_date,
reason_for_fm="User Sick")
test_fm.save()
page = self.client.get("/abscences/{0}/reject_fm/".format(test_fm.id))
self.assertEqual(page.status_code, 200)
self.assertTemplateUsed(page, "reject_fm.html")
