def post(self, request: Request):
try:
q = request.data
kayitId = q.get("kayit_id")
if kayitId is not None and kayitId > -1:
girisler = MusteriGirisi.objects.filter(id=kayitId)
if girisler.count() > 0:
giris: MusteriGirisi = girisler[0]
sube = iliskiVarMi(request.user, giris.secili_sube.id)
if request.user.is_superuser or sube is not None:
if containsInDictionaryKey(q,
["cikis_tarih", "ucret"]):
cikis_tarih = dateUtilParse(q.get("cikis_tarih"))
giris.cikis_tarih = cikis_tarih
giris.ucret = q.get("ucret")
giris.save()
return createErrorResponse(
200, {"message": "Record updated"})
else:
return createErrorResponse(
403, {"message": "Unauthorized for this branch"})
else:
return createErrorResponse(404,
{"message": "Record not found"})
else:
return createErrorResponse(
400, {"message": "Record not provided correctly"})
except Exception as exception:
traceback.print_exc()
return createErrorResponse(500,
{"error": str(exception.__class__)})
def get(self, request, sube=-1):
if (sube > -1):
if request.user.is_superuser or iliskiVarMi(request.user,
sube) is not None:
iliskiler = SubeTemsilcisi.objects.filter(sube__id=sube)
calisanlar_parsed = [
self.__combineTemsil(iliski) for iliski in iliskiler
]
return createErrorResponse(202, calisanlar_parsed)
else:
return createErrorResponse(403,
{"message": "Unauthorized branch"})
else:
if request.user.is_superuser:
iliskiler = SubeTemsilcisi.objects.filter()
calisanlar_parsed = [
self.__combineTemsil(iliski) for iliski in iliskiler
]
return createErrorResponse(202, calisanlar_parsed)
else:
subeler = iliskiliSubeler(request.user)
iliskiler = SubeTemsilcisi.objects.filter(sube__in=subeler)
calisanlar_parsed = [
self.__combineTemsil(iliski) for iliski in iliskiler
]
return createErrorResponse(202, calisanlar_parsed)
def post(self, request):
flag, error_response = _generic_control(request)
if flag:
copied = request.data.copy()
sube_id = copied["sube"]
sube = Sube.objects.filter(id=sube_id)[0]
copied["sube"] = {
"id": sube_id,
"adres": "asdasd",
"sube_ismi": "sasdas"
}
parsedThing = EkstraGiderSerializer(data=copied)
if parsedThing.is_valid():
copied["sube"] = sube
yeniGider = EkstraGider(**copied)
yeniGider.save()
return createErrorResponse(
201, {
"message": "Expense created successfully",
"object": EkstraGiderSerializer(yeniGider).data
})
else:
return createErrorResponse(
400, {
"errors": parsedThing.errors,
"message": "Required fields are missing"
})
else:
return error_response
def _generic_control(request, subePreprovide=None) -> (bool, Response):
"""Controls is branch provided and is user any privaliges
Return 1: when controlling if has a issue, return false. Else then, it is true
Return 2: If has issue, response will be returned. But there is no issue, nothing returned"""
sube_ = ""
if subePreprovide is None:
sube_: str = request.query_params["sube_id"]
else:
sube_ = subePreprovide
if type(sube_) is int or sube_.isnumeric():
sube = int(sube_)
flag = False
if (request.user.is_superuser):
flag = True
else:
iliski = iliskiVarMi(request.user, sube)
if iliski is not None:
flag = True
if flag:
return True, None
return False, createErrorResponse(200, paginated_expenses)
else:
return False, createErrorResponse(404,
{"message": "Branch not found"})
else:
return False, createErrorResponse(400,
{"message": "Branch is missing"})
def post(self, request):
try:
data: dict = request.data
if containsInDictionaryKey(data, ["musteri_isim",
"musteri_soyisim",
"musteri_tel",
"hizmetTipi",
"subeId",
"randevuTarih"]) or \
containsInDictionaryKey(data, ["musteri_id", "hizmetTipi", "subeId", "randevuTarih"]):
# create RANDEVU(Appointment) instance - RANDEVU örneği yaratma
# find SUBE (Branch) - şube arama
subeler = Sube.objects.filter(id=data.get("subeId"))
email, tel = "", "";
if ("musteri_email" in data.keys()):
email = data.get("musteri_email")
if ("musteri_tel" in data.keys()):
tel = data.get("musteri_tel")
musteri = try_fetch_customer(data.get("musteri_id"), data.get("musteri_isim"),
data.get("musteri_soyisim"),email,tel)
if subeler.count() > 0:
sube = subeler[0]
tarih = dateUtilParse(data.get("randevuTarih"))
# tarih = datetime.strptime(data.get("tarih"),"%Y-%m-%dT%H:%M:%S.%Z")
randevu = Randevu(
secili_sube=sube,
hizmet_turu=data.get("hizmetTipi"),
tarih=tarih,
musteri=musteri
)
randevu.save()
return createErrorResponse(
200, {"message": """Appointment created successfully"""}
)
else:
return createErrorResponse(
400, {"message": """Branch not found"""}
) #
else:
return createErrorResponse(
400,
{
"message": """1 field or more than 1 fields are missing. Needed "isim", "soyisim" (first - last names),"hizmetTipi" (service type),"subeId" (branch identify),"tarih" (date with hours) fields """
},
) #
except Exception as exception:
traceback.print_exc()
return createErrorResponse(500, {"error": str(exception.__class__)})
def post(self, request):
try:
ustDuzeyHak = request.data["highlevelRight"]
subeId = request.data["subeId"] if "subeId" in request.data else -1
arananSube = None
if subeId == -1:
return createErrorResponse(404,
{"message": "Branch not found"})
else:
arananSube = iliskiVarMi(request.user, subeId)
if arananSube is None:
return createErrorResponse(404,
{"message": "Branch not found"})
stFilter = ""
if request.user.is_superuser:
stFilter = SubeTemsilcisi.objects.filter(sube__id=subeId)[0]
elif request.user.is_staff:
kul_id = request.user.id
stFilter = SubeTemsilcisi.objects.filter(
sube__id=subeId, kullanici__id=kul_id)[0]
if stFilter is None or stFilter.ustduzey_hak is False:
ustDuzeyHak = False
serialized = UserSerializer(data=request.data)
# subeAuthorized = iliskiliSubeler(request.user)
if subeId > -1 and iliskiVarMi(request.user, subeId):
if serialized.is_valid():
createdUser = User.objects.create_user(
email=request.data['email'],
username=request.data['username'],
password=request.data['password'],
first_name=request.data['firstname'],
last_name=request.data['lastname'],
is_staff=True)
createdUser.save()
yeniSubeIliskisi = SubeTemsilcisi(sube=stFilter.sube,
kullanici=createdUser,
ustduzey_hak=ustDuzeyHak)
yeniSubeIliskisi.save()
return Response(serialized.data,
status=status.HTTP_201_CREATED)
else:
return createErrorResponse(404, serialized.errors)
else:
return Response(serialized.errors,
status=status.HTTP_400_BAD_REQUEST)
except Exception as exception:
traceback.print_exc()
return createErrorResponse(500,
{"error": str(exception.__class__)})
def post(self, request):
try:
upd = {}
if "id" in request.data.keys() and \
(request.user.is_superuser or SubeTemsilcisi.objects.filter(kullanici=request.user,
sube__id__in=MusteriGirisi.objects.
filter(id=request.data["id"]).
values_list("secili_sube",
flat=True))):
data = request.data
if data.get("cikis_tarih"
) is not None or data.get("cikis_tarih") != "":
upd["cikis_tarih"] = dateUtilParse(data.get("cikis_tarih"))
if data.get("giris_tarih"
) is not None or data.get("giris_tarih") != "":
upd["giris_tarih"] = dateUtilParse(data.get("giris_tarih"))
if data.get("hizmet_turu") is not None:
upd["hizmet_turu"] = data.get("hizmet_turu")
if data.get("ucret") is not None:
upd["ucret"] = data.get("ucret")
if data.get("prim") is not None:
upd["prim"] = data.get("prim")
if data.get("calisan") is not None:
upd["calisan"] = User.objects.filter(
id=int(data.get("calisan")))[0]
recordId = int(request.data["id"])
kayit = MusteriGirisi.objects.filter(id=recordId).all()[0]
for key in upd.keys():
setattr(kayit, key, upd[key])
kayit.save()
return Response({"message": "Record updated"})
else:
return createErrorResponse(404, {"message": "Not found"})
except Exception as exception:
traceback.print_exc()
return createErrorResponse(500,
{"error": str(exception.__class__)})
def get(self, request: Request):
"""@sadeceCikmayanlar çıkış tarihi eklenmemiş kayıtları gösterir
@subeFiltre"""
sadeceCikmayanlar = False
subeFiltre = -1
if request.query_params.get("sadece-cikmayanlar") == "1":
sadeceCikmayanlar = True
subeId: str = request.query_params.get("sube-id")
if (subeId != "" and subeId is not None
and re.match("^([0-9].*)$", subeId) is not None):
subeFiltre = int(subeId)
customersQ = MusteriGirisi.objects
if sadeceCikmayanlar:
customersQ = customersQ.filter(cikis_tarih__isnull=True)
relations = iliskiliSubeler(request.user)
# admin control
if request.user.is_superuser:
customerEntries = None
if subeFiltre == -1:
customerEntries = MusteriGirisi.objects.order_by("-id").all()
else:
customerEntries = MusteriGirisi.objects.filter(
secili_sube__id=subeFiltre).order_by("-id")
paginated = pagination(customerEntries,
request.query_params.get("page"),
request.query_params.get("size"))
return Response(makeArraySerializationsQuery(paginated))
# if not admin but staff
elif request.user.is_staff:
if subeFiltre > -1:
iliskiliSube = iliskiVarMi(request.user, subeFiltre, relations)
if iliskiliSube is not None:
customerEntries = customersQ.filter(
secili_sube=iliskiliSube).order_by("-id")
paginated = pagination(customerEntries,
request.query_params.get("page"),
request.query_params.get("size"))
return Response(makeArraySerializationsQuery(paginated))
else:
return createErrorResponse(
403,
{
"message":
"You aren't related with ŞUBE(Branch)" +
str(subeFiltre)
},
)
else:
customerEntries = customersQ.filter(
secili_sube__in=relations).order_by("-id")
return Response(
makeArraySerializationsQuery(customerEntries.all()))
def get(self, request: Request):
kayit_id = request.query_params.get("kayit_id")
if (kayit_id is not None and kayit_id.isnumeric()):
kayit = MusteriGirisi.objects.filter(id=int(kayit_id))
if (kayit.count() > 0):
kayit_: MusteriGirisi = kayit[0]
temsil = SubeTemsilcisi.objects.filter(kullanici=request.user,
sube=kayit_.secili_sube)
if request.user.is_superuser or temsil.count() > 0:
kayit_.delete()
return createErrorResponse(200,
{"message": "Kayit silindi"})
else:
return createErrorResponse(403,
{"message": "İzin bulunamadı"})
else:
return createErrorResponse(401,
{"message": "Kayit bulunamadı"})
else:
return createErrorResponse(401, {"message": "Kayit bulunamadı"})
def get(self, request: Request):
flag, errorResponse = _generic_control(request)
if flag:
date_ = request.query_params["date"]
sube = int(request.query_params["sube_id"])
expenses = extra_expenses(sube, date_)
paginated_expenses = pagination(expenses,
request.query_params.get("page"),
request.query_params.get("size"))
return createErrorResponse(200, paginated_expenses)
else:
return errorResponse
def get(self, request):
if request.query_params[
"gider_id"] is not None and request.query_params[
"gider_id"].isnumeric():
gider_id = int(request.query_params["gider_id"])
giderler = EkstraGider.objects.filter(id=gider_id)
if giderler.count() > 0:
gider: EkstraGider = giderler[0]
giderSube = gider.sube.id
flag, err_response = _generic_control(request, giderSube)
if flag:
gider.delete()
return createErrorResponse(
200, {"message": "Expense record is removed"})
else:
return err_response
else:
return createErrorResponse(404,
{"message": "Expense not found"})
else:
return createErrorResponse(
400, {"message": "Expense not provided properly"})
def get(self, request : Request):
try:
subeId: str = request.query_params.get("sube-id")
if request.user.is_superuser:
if subeId is not None and subeId.isnumeric():
query = Randevu.objects.filter(secili_sube__id=int(subeId)).order_by("-id")
paginated = pagination(query, request.query_params.get("page"), request.query_params.get("size"));
return Response(self.__convertAppointments(paginated))
else:
paginated = pagination(Randevu.objects.order_by("-id"), request.query_params.get("page"),
request.query_params.get("size")).order_by("-id")
return Response(self.__convertAppointments(paginated))
else:
query = Randevu.objects
if subeId is not None and subeId.isnumeric():
temsil = iliskiVarMi(request.user, int(subeId))
if temsil is not None:
query = query.filter(secili_sube=temsil.sube).order_by("-id")
paginated = pagination(query, request.query_params.get("page"),
request.query_params.get("size"))
return Response(self.__convertAppointments(paginated))
else:
return createErrorResponse(403, {"message": "You aren't authenticated with this branch"})
else:
iliskiliBranchler = iliskiliSubeler(request.user)
query = Randevu.objects.filter(secili_sube__in=iliskiliBranchler).order_by("-id")
paginated = pagination(query, request.query_params.get("page"),
request.query_params.get("size"))
return Response(self.__convertAppointments(paginated))
except Exception as exception:
traceback.print_exc()
return createErrorResponse(500, {"error": str(exception.__class__)})
def get(self, request, randevuId):
if randevuId is None:
return createErrorResponse(400, {"message": "randevu Id not provided"})
else:
randevular = Randevu.objects.filter(id=randevuId)
randevu = randevular[0] if randevular.count() > 0 else None
if randevu is not None:
iliski = iliskiVarMi(request.user, randevu.secili_sube.id)
if iliski is not None or request.user.is_superuser:
randevu.delete()
return Response({"message": "Appointment deleted"}, 200)
else:
return Response({"message": "You are unauthorized for this branch"}, 403)
else:
return Response({"message": "Randevu not found"}, 404)
def get(self, request: Request):
subeFiltre = None
subeId: str = request.query_params.get("sube-id")
if (subeId != "" and subeId is not None
and re.match("^([0-9].*)$", subeId) is not None):
subeFiltre = int(subeId)
temsil = iliskiVarMi(request.user, subeFiltre)
if request.user.is_superuser or temsil is not None:
rd = []
musteriIds = MusteriGirisi.objects.filter(
secili_sube__id=subeFiltre).values_list('musteri',
flat=True)
musteriler = Musteri.objects.filter(id__in=musteriIds)
# sube__id=subeFiltre
# krediler =
for musteri in musteriler:
rd.append(MusteriSerializer(musteri).data)
return Response(rd)
else:
return createErrorResponse(404,
{"message": "Sube is not found"})
else:
return createErrorResponse(400, {"message": "Sube id is invalid"})
def _report(request, daily=False):
subeid_ = request.query_params.get("sube")
if subeid_ and subeid_.isnumeric():
subeid = int(subeid_)
iliskiler = SubeTemsilcisi.objects.filter(sube__id=subeid,
kullanici=request.user)
iliski = iliskiler[0] if iliskiler.count() > 0 else None
if request.user.is_superuser or iliski is not None:
aylik_toplam_gelir = 0
aylik_toplam_prim = 0
bugun = ""
if "refdate" in request.query_params.keys():
bugun = dateUtilParse(request.query_params["refdate"])
else:
bugun = timezone.now()
gidertoplam = extra_expenses_sum(subeid, bugun,
daily)["tutar__sum"]
if gidertoplam is None:
gidertoplam = 0
calisan_primler = None
if request.user.is_superuser or iliski.ustduzey_hak is True:
calisan_primler = {}
filter = {
"secili_sube__id": subeid,
"giris_tarih__month": bugun.month,
"giris_tarih__year": bugun.year
}
if daily is True:
filter["giris_tarih__day"] = str(bugun.day)
aylik_kayitlar = MusteriGirisi.objects.filter(**filter)
card_income = 0
cash_income = 0
other_income = 0
for kayit in aylik_kayitlar:
aylik_toplam_prim += kayit.prim
aylik_toplam_gelir += kayit.ucret
if request.user.is_superuser or iliski.ustduzey_hak is True:
if kayit.calisan.id in calisan_primler.keys():
calisan_primler[kayit.calisan.id] += kayit.prim
else:
calisan_primler[kayit.calisan.id] = kayit.prim
if kayit.odeme_yontemi == "Kart":
card_income += kayit.ucret
elif kayit.odeme_yontemi == "Nakit":
cash_income += kayit.ucret
else:
other_income += kayit.ucret
return Response({
"summary": {
"income": aylik_toplam_gelir,
"income_channels": {
"cash": cash_income,
"card": card_income,
"other": other_income
},
"bonus_grand": aylik_toplam_prim,
"extra_expenses": gidertoplam,
"grand_expenses": aylik_toplam_prim + gidertoplam
},
"bonuses": calisan_primler,
})
else:
return createErrorResponse(
403, {"message": "Not authorized for branch"})
else:
return createErrorResponse(400, {"message": "Branch is not provided"})
def post(self, request):
try:
data: dict = request.data
if containsInDictionaryKey(
data, [
"musteri_isim", "musteri_soyisim", "musteri_email",
"musteri_tel", "hizmet_turu", "giris_tarih",
"secili_sube", "calisan"
]
# optional fields = ucret, cikisTarihi
) or containsInDictionaryKey(data, [
"musteri_id", "hizmet_turu", "giris_tarih", "secili_sube",
"calisan"
]
# optional fields = ucret, cikisTarihi
):
ilgili_calisan_id = data.get("calisan")
bulunanCalisan = SubeTemsilcisi.objects.filter(
kullanici__id=int(ilgili_calisan_id),
sube__id=int(data.get("secili_sube")))
email, tel = "", ""
if ("musteri_email" in data.keys()):
email = data.get("musteri_email")
if ("musteri_tel" in data.keys()):
tel = data.get("musteri_tel")
musteri = try_fetch(data.get("musteri_id"),
data.get("musteri_isim"),
data.get("musteri_soyisim"), email, tel)
if bulunanCalisan.count() > -1:
cikis_tarih = None
giris_tarih = dateUtilParse(data.get("giris_tarih"))
ucret = data.get("ucret")
prim = data.get("prim")
calisan = None
calisanId = data.get("calisan")
if calisanId is not None and calisanId.isnumeric():
calisan = User.objects.filter(id=int(calisanId))
if (calisan is None):
calisan = request.user
if data.get("cikis_tarih") is not None:
cikis_tarih = dateUtilParse(data.get("cikis_tarih"))
iliski = iliskiVarMi(request.user, data.get("secili_sube"))
calisanIliski = SubeTemsilcisi.objects.filter(
kullanici=calisan[0], sube=data.get("secili_sube"))[0]
if request.user.is_superuser or iliski is not None:
if data.get("kredi_ekle") is True or data.get(
"kredi_tuket") is True:
tuketilecek_kredi_turu = data.get(
"kredi_tuketim_turu")
eklenecek_kredi_turu = data.get(
"kredi_eklenme_turu")
eklenecek_kredi, ek_taze = None, None
tuketilecek_kredi, tk_taze = None, None
if data.get("kredi_ekle") and eklenecek_kredi_turu and \
eklenecek_kredi_turu.isspace() is not True:
eklenecek_kredi, ek_taze = MusteriKredi.objects.get_or_create(
musteri=musteri,
sube=iliski.sube,
hizmet_turu=eklenecek_kredi_turu)
if eklenecek_kredi:
# kredi ekleme
kredi_eklenecek_sayi = data.get(
"credit_will_be_added")
if kredi_eklenecek_sayi is not None and kredi_eklenecek_sayi > 0:
eklenecek_kredi.sayi += kredi_eklenecek_sayi
if data.get("kredi_tuket") and tuketilecek_kredi_turu and \
tuketilecek_kredi_turu.isspace() is not True:
if (eklenecek_kredi is not None) and (
eklenecek_kredi_turu
== tuketilecek_kredi_turu):
tuketilecek_kredi = eklenecek_kredi
else:
tuketilecek_kredi, tk_taze = MusteriKredi.objects. \
get_or_create(musteri=musteri,
sube=iliski.sube, hizmet_turu=tuketilecek_kredi_turu)
if tuketilecek_kredi:
if tuketilecek_kredi.sayi > 0:
tuketilecek_kredi.sayi -= 1
else:
return createErrorResponse(
400, {
"message":
"Müşterinin kredi hakkı bulunmamaktadır"
})
if eklenecek_kredi and \
(tuketilecek_kredi is None or tuketilecek_kredi.id != eklenecek_kredi.id):
eklenecek_kredi.save()
if tuketilecek_kredi:
tuketilecek_kredi.save()
musteriKayit = MusteriGirisi(
musteri=musteri,
hizmet_turu=data.get("hizmet_turu"),
secili_sube=iliski.sube,
giris_tarih=giris_tarih,
cikis_tarih=cikis_tarih,
odeme_yontemi=data.get("odeme_yontemi"),
ucret=ucret if ucret is not None else 0,
calisan=calisanIliski.kullanici,
prim=prim)
musteriKayit.save()
return createErrorResponse(
200,
MusteriGirisiSerializer(musteriKayit).data)
else:
return createErrorResponse(
403,
{
"message":
"You aren't related with ŞUBE(Branch)" +
str(request.data.get("sube"))
},
)
else:
createErrorResponse(
404,
{"message": "Corresponding User in branch not found"})
else:
return createErrorResponse(
400,
{
"message":
"""1 field or more than 1 fields are missing.
Needed "isim", "soyisim" (first - last names),"hizmetTipi" (service type),
"subeId" (branch identify),"tarih" (date with hours) fields """
},
) #
except Exception as exception:
traceback.print_exc()
return createErrorResponse(500,
{"error": str(exception.__class__)})
