def patch(self, req, pk):
if req.user.pk != int(pk) and not req.user.is_superuser:
return Response(status=status.HTTP_401_UNAUTHORIZED,
data={'reason': 'User account is not authorized'})
try:
acc = Account.objects.get(id=pk)
serializer = AccountSerializer(acc, data=req.data, partial=True)
if serializer.is_valid():
serializer.save()
except Account.DoesNotExist:
return Response(
status=status.HTTP_404_NOT_FOUND,
data={'reason': 'User account not found for the requested pk'})
if req.user.is_superuser:
acc_data = serializer.data
else:
acc_data = {
'id': serializer.data['id'],
'username': serializer.data['username'],
'first_name': serializer.data['first_name'],
'last_name': serializer.data['last_name'],
'email': serializer.data['email'],
'profile_pic': serializer.data['profile_pic']
}
return Response(status=status.HTTP_202_ACCEPTED, data=acc_data)
def account_detail(request, pk):
try:
account = Account.objects.get(pk=pk)
except Account.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
account_serializer = AccountSerializer(account)
return Response(account_serializer.data)
elif request.method == 'PUT':
account_serializer = AccountSerializer(account, data=request.data)
if account_serializer.is_valid():
account_serializer.save()
return Response(account_serializer.data)
return Response(account_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'PATCH':
account_serializer = AccountSerializer(account, data=request.data, partial=True)
if account_serializer.is_valid():
account_serializer.save()
return Response(account_serializer.data)
return Response(account_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE)
elif request.method == 'DELETE':
account.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def post(self, request):
serializer = AccountSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
data = request.data
serializer = AccountSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=400)
def put(self, request, pk, format=None):
account = get_object_or_404(Account, pk=pk)
serializer = AccountSerializer(account, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def account_list(request):
if request.method == 'GET':
# faz uma lista com todos os Account
accounts = Account.objects.all()
# faz a serialização (Model -> JSON)
# o many=True serve para serializar uma lista de objetos
# em vez de uma única instância de objeto
accounts_serializer = AccountSerializer(accounts, many=True)
return Response(accounts_serializer.data)
elif request.method == 'POST':
if AccountSerializer(data=request.data).validate_json_creation_date(
request.data):
# faz a deserialização (JSON -> Model) passando os dados necessários
account_serializer = AccountSerializer(data=request.data)
# salva o account caso seja válido, depois
# retorna account_serializer.data e 201
if account_serializer.is_valid():
account_serializer.save()
return Response(account_serializer.data,
status=status.HTTP_201_CREATED)
# account inválido retorna 400
return Response(account_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
account = self.get_object(pk)
account_serializer = AccountSerializer(account, data=request.data)
if account_serializer.verify_balance(account_serializer):
account_serializer.save()
return Response(account_serializer.data)
return Response(account_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
account_serializer = AccountSerializer(data=request.data)
if account_serializer.verify_balance(account_serializer):
account_serializer.save()
return Response(account_serializer.data,
status=status.HTTP_201_CREATED)
return Response(account_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
account = self.get_object(pk)
serializer = AccountSerializer(account,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, req):
account = Account.objects.create()
serializer = AccountSerializer(account, data=req.data)
if serializer.is_valid():
serializer.password = make_password(
serializer.validated_data['password'])
serializer.save()
return Response(status=status.HTTP_201_CREATED)
return Response(
status=status.HTTP_400_BAD_REQUEST,
data={'reason': 'Request data not properly structured'})
def account_detail(request, id):
try:
account = Account.objects.get(pk=id)
except Account.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
account_serializer = AccountSerializer(account)
return Response(account_serializer.data)
elif request.method == 'PUT':
account_serializer = AccountSerializer(account, data=request.data)
if account_serializer.validate_balance(
) and account_serializer.is_valid():
account_serializer.save()
return Response(account_serializer.data)
return Response(account_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
account.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
elif request.method == 'PATCH':
account_serializer = AccountSerializer(account,
data=request.data,
partial=True)
saldo = account.__getattribute__('balance') - request.data['balance']
print(saldo)
print(account.__getattribute__('balance'))
print(request.data['balance'])
if saldo > 0:
if account_serializer.is_valid():
account_serializer.validated_data
account_serializer.data['balance'] = saldo
print(account_serializer.validated_data)
account_serializer.save()
# if account_serializer.is_valid():
# account_serializer.save()
print('entrou')
return Response(status=status.HTTP_202_ACCEPTED)
return Response(account_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif saldo == 0:
raise serializers.ValidationError("O Saldo não pode ser zerado")
elif saldo < 0:
raise serializers.ValidationError("Saldo insuficiente")
def account_list(request):
if request.method == 'GET':
accounts = Account.objects.all()
accounts_serializer = AccountSerializer(accounts, many=True)
return Response(accounts_serializer.data)
elif request.method == 'POST':
account_serializer = AccountSerializer(data=request.data)
if account_serializer.validate_balance(
) and account_serializer.is_valid(
) and account_serializer.validate_data():
account_serializer.save()
return Response(account_serializer.data,
status=status.HTTP_201_CREATED)
return Response(account_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_update_account(self):
"""Order data is updated correctly for users."""
account = AccountFactory(status="ACTIVE")
serializer = AccountSerializer(
account,
data={"status": "APPROVAL_PENDING"},
partial=True,
context={"request": self.request},
)
self.assertTrue(serializer.is_valid())
serializer.save()
account.refresh_from_db()
self.assertEqual(account.status, "APPROVAL_PENDING")
def post(self, request, format='json'):
serializer = AccountSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
json = serializer.data
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def account_detail(request, id):
# tenta pegar o account esse determinado id
try:
account = Account.objects.get(id=id)
# sem achar accounts com o id, retorna 404
except Account.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
# faz a serialização (Model -> JSON)
account_serializer = AccountSerializer(account)
return Response(account_serializer.data)
elif request.method == 'PUT':
# faz a deserialização (JSON -> Model) passando os dados necessários adicionando
# esses dados no objeto que está sendo modificado
account_serializer = AccountSerializer(account, data=request.data)
# salva o account caso seja válido, depois retorna
# game_serializer.data
if account_serializer.is_valid():
account_serializer.save()
return Response(account_serializer.data)
# account inválido retorna 400
return Response(account_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'PATCH':
# faz a deserialização (JSON -> Model) passando os dados necessários
final_account_balance = AccountSerializer(
data=request.data).validate_patch(account.balance, request.data)
if final_account_balance or (final_account_balance == 0):
account.balance = final_account_balance
if account.is_valid():
account.save()
return Response(account)
return Response()
# exclui o account e retorna 204
elif request.method == 'DELETE':
account.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def update(self):
""" Updates using serializer and self.data """
ser = AccountSerializer(self.acc, data=self.data, partial=True)
ser.is_valid(True)
return ser.save()
def post(self, request, format=None):
serializer = AccountSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self):
""" Creates using the serializer and self.data """
ser = AccountSerializer(data=self.data)
ser.is_valid(True)
return ser.save()
def test_create_account(self):
"""Account data is serialized correctly for users own account."""
data = {
"id": "2aa28199-1ff1-4b28-929b-51aaa3d7bdd7",
"user": self.user.pk,
"account_blocked": False,
"account_number": "PA24RIKIGB1U",
"buying_power": 400000.01,
"cash": 100000.01,
"created_at": "2020-10-31T23:40:50.376107Z",
"currency": "USD",
"daytrade_count": 0,
"daytrading_buying_power": 400000.01,
"equity": 100000.01,
"initial_margin": 0,
"last_equity": 100000.01,
"last_maintenance_margin": 0,
"long_market_value": 0,
"maintenance_margin": 0,
"multiplier": 4,
"pattern_day_trader": False,
"portfolio_value": 100000.01,
"regt_buying_power": 200000.01,
"short_market_value": 0,
"shorting_enabled": True,
"sma": 0,
"status": "ACTIVE",
"trade_suspended_by_user": False,
"trading_blocked": False,
"transfers_blocked": False,
}
serializer = AccountSerializer(data=data, context={"request": self.request})
self.assertTrue(serializer.is_valid())
account = serializer.save()
self.assertEqual(data["id"], "2aa28199-1ff1-4b28-929b-51aaa3d7bdd7")
self.assertEqual(self.user, account.user)
self.assertEqual(data["status"], account.status)
self.assertFalse(account.account_blocked)
self.assertEqual(account.account_number, "PA24RIKIGB1U")
self.assertEqual(float(account.buying_power), 400000.01)
self.assertEqual(float(account.cash), 100000.01)
self.assertEqual(account.currency, "USD")
self.assertEqual(account.daytrade_count, 0)
self.assertEqual(float(account.daytrading_buying_power), 400000.01)
self.assertEqual(float(account.equity), 100000.01)
self.assertEqual(account.initial_margin, 0)
self.assertEqual(float(account.last_equity), 100000.01)
self.assertEqual(account.last_maintenance_margin, 0)
self.assertEqual(account.long_market_value, 0)
self.assertEqual(account.maintenance_margin, 0)
self.assertEqual(account.multiplier, 4)
self.assertFalse(account.pattern_day_trader)
self.assertEqual(float(account.portfolio_value), 100000.01)
self.assertEqual(float(account.regt_buying_power), 200000.01)
self.assertTrue(account.shorting_enabled)
self.assertEqual(account.sma, 0)
self.assertEqual(account.status, Account.ACTIVE)
self.assertFalse(account.trade_suspended_by_user)
self.assertFalse(account.trading_blocked)
self.assertFalse(account.transfers_blocked)
