class MuhasebeFisleriView(FlaskView):
"""Bap Bütçe Kodları view classi"""
@staticmethod
@login_required
@route('/liste', methods=['GET'])
@auth.requires(Permission(
*permission_dict["bap"]["butce"]["muhasebe_fisleri_goruntuleme"]),
menu_registry={
"path": ".bap.butce.muhasebe_fisleri",
"title": _("Muhasebe Fişleri")
})
def butce_kodlari_goruntuleme_listele():
# todo: monkey patch !!!
# todo: server side yapilacak
muhasebe_fisleri = DB.session.query(MuhasebeFisi).all()
return render_template("muhasebe_fisleri_listeleme.html",
muhasebe_fisleri=muhasebe_fisleri)
@login_required
@auth.requires(
Permission(
*permission_dict["bap"]["butce"]["muhasebe_fisleri_goruntuleme"]),
Or(RoleReq('BAP Yetkilisi'), RoleReq("BAP Admin")))
@route('/muhasebe-fisi/<int:muhasebe_fis_id>', methods=['GET'])
def get_odeme_emri(self, muhasebe_fis_id):
"""
Odeme emri sablonunu ilgili muhasebe fisi alanlari ile render edip kullaniciya doner
"""
try:
muhasebe_fisi_data = BapQueryHelpers.get_muhasebe_fisi_bilgileri(
muhasebe_fis_id)
# sablon tipi id 49 --> Ödeme Emri Şablonu
odeme_emri_sablonu = DB.session.query(Sablon).filter(
Sablon.sablon_tipi_id == 49,
Sablon.kullanilabilir_mi == True).order_by(
desc(Sablon.updated_at)).first()
muhasebe_fisi = DB.session.query(MuhasebeFisi).filter(
MuhasebeFisi.id == muhasebe_fis_id).first()
muhasebe_fisi.odeme_emri_tamamlandi = True
DB.session.commit()
return render_template_string(odeme_emri_sablonu.sablon_text,
data=muhasebe_fisi_data)
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Muhasebe fişi ödeme emrine çevrilirken bir hata "
"oluştu.Hata: {}, Muhasebe Fisi id: {}".format(
muhasebe_fis_id, exc))
return abort(500)
class SatinalmaBelgelerView(FlaskView):
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["satinalma"]
["satinalma_belgeleri_goruntuleme"]),
Or(Role('BAP Yetkilisi'), Role('BAP Admin')))
@route("<int:satinalma_id>/belgeler",
methods=["GET", "POST"],
endpoint="satinalma_belgeler")
def satinalma_ozet(satinalma_id):
satinalma = get_satinalma_with_related_fields(
satinalma_id=satinalma_id)
states_info = get_satinalma_next_states_info(satinalma_id=satinalma_id)
actions_info = get_satinalma_actions_info(satinalma_id=satinalma_id)
proje = DB.session.query(Proje).filter(
Proje.id == satinalma.proje_id).first()
templates = get_templates_info(satinalma_id=satinalma_id)
return render_template("satinalma_dashboard/satinalma_belgeler.html",
satinalma=satinalma,
satinalma_id=satinalma_id,
proje=proje,
actions_info=actions_info,
states_info=states_info,
templates=templates)
class ProjeNotlariView(FlaskView):
"""
Proje Notlari
"""
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["dashboard"]
["proje_notlari_goruntuleme"]),
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role('BAP Admin')))
@route("<int:proje_id>/dashboard/notlar",
methods=["GET"],
endpoint="proje_notlari")
def proje_notlari(proje_id):
"""
projeye eklenen özel notları görüntüler
Args:
proje_id(int): projenin id si
Returns:
"""
proje = DB.session.query(Proje).options(
joinedload(Proje.proje_yurutucu).load_only("id").joinedload(
OgretimElemani.personel).load_only("id").joinedload(
Personel.person).load_only("ad", "soyad"),
lazyload(Proje.proje_detayi),
lazyload(Proje.kabul_edilen_proje_hakemleri),
lazyload(Proje.proje_hakem_onerileri),
lazyload(Proje.proje_destekleyen_kurulus),
lazyload(Proje.proje_kalemleri),
).filter(
Proje.id == proje_id,
or_(
Proje.proje_basvuru_durumu == ProjeBasvuruDurumu.tamamlandi,
Proje.proje_basvuru_durumu ==
ProjeBasvuruDurumu.revizyon_bekleniyor)).first()
next_states_info = get_next_states_info(proje_id=proje_id)
actions_info = get_actions_info(proje_id=proje_id)
proje_yurutucusu_mu = ProjeYurutucusu().fulfill(user=current_user)
proje_notlari = DB.session.query(
ProjeNot, Person.ad.label("ad"),
Person.soyad.label("soyad")).filter(
ProjeNot.proje_id == proje_id).join(
Person,
Person.user_id == ProjeNot.notu_ekleyen_yetkili).all()
if not proje:
pass
# todo: proje bulunamadı hatası dön
return render_template("dashboard/proje_notlari.html",
proje=proje,
next_states_info=next_states_info,
proje_yurutucusu_mu=proje_yurutucusu_mu,
actions_info=actions_info,
proje_notlari=proje_notlari,
proje_id=proje.id)
class ProjeRevizyon(FlaskView):
"""Proje revizyon view classı"""
@staticmethod
@login_required
@auth.requires(
And(Permission(*permission_dict["bap"]["proje"]["basvuru"]["proje_basvurusu_yapma"]),
And(TamamlanmamisProjeBasvurusu(), ProjeYurutucusu())))
@route('/revizyon/<int:proje_id>', methods=['GET'])
def proje_revizyon_get(proje_id):
"""
Proje yetkilisi tarafindan gerekli gorulup yurutucuden proje revizyonu yapmasi istenirse
bu view methodu kullanilir.
Projenin ilgili state durumunda olup olmadigi(P9 - Başvurunun onaylanması için yürütücü
revizyonu bekleniyor (ilgili state id = 9)) kontrolu yapilir.
:param proje_id: revizyon beklenen projenin id si
:return:
"""
user_id = current_user.id
revizyon_proje = DB.session.query(Proje).filter(
Proje.id == Proje.id,
Proje.proje_basvuru_durumu == ProjeBasvuruDurumu.revizyon_bekleniyor).first()
if not revizyon_proje:
CustomErrorHandler.error_handler(
hata="Revizyon istenmeyen bir proje revize edilmeye "
"calisildi".format(user_id, proje_id))
return abort(404)
proje_turu = get_proje_turu_with_related_field(revizyon_proje.proje_turu, False)
proje_turu_dict = proje_turu_to_dict(proje_turu)
yurutucu_calisan_id = None
yurutucu_calisan = DB.session.query(ProjeCalisanlari).filter_by(
proje_id=proje_id,
personel_id=revizyon_proje.yurutucu).first()
if yurutucu_calisan:
yurutucu_calisan_id = yurutucu_calisan.id
form_data = get_proje_data(proje_turu_dict, revizyon_proje)
proje_formu = basvuru_formu_restriction(proje_turu_dict=proje_turu_dict, **form_data)
return render_template(
'arastirma_projesi_basvuru/arastirma_proje_basvurusu.html',
yeni_basvuru_formu=proje_formu,
proje_tur_dict=proje_turu.to_dict(),
proje_id=proje_id,
proje_hakem_onerileri=revizyon_proje.proje_hakem_onerileri,
proje_calisanlari=[calisan for calisan in revizyon_proje.proje_calisanlari if
not (
revizyon_proje.yurutucu and revizyon_proje.yurutucu == calisan.personel_id)],
yurutucu_calisan_id=yurutucu_calisan_id,
taslak_mi=False,
revizyon_bekleniyor_mu=True,
uyari_mesajlari=proje_turu_dict.get("genel_uyari_mesajlari", None)
)
class ProjeKararlariView(FlaskView):
"""Proje kararları listeleme"""
@staticmethod
@login_required
@auth.requires(
And(
Permission(*permission_dict["bap"]["proje"]["dashboard"]
["proje_kararlari_goruntuleme"]),
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role("BAP Admin"))))
@route('<int:proje_id>/dashboard/karar',
methods=["GET"],
endpoint='proje_kararlari_listele')
def proje_kararlari(proje_id):
"""Yönetim Kurulu Kararları Listesi Ekrani"""
proje_yurutucusu_mu = ProjeYurutucusu().fulfill(user=current_user)
proje = DB.session.query(Proje).options(
joinedload(Proje.proje_yurutucu).load_only("id").joinedload(
OgretimElemani.personel).load_only("id").joinedload(
Personel.person).load_only("ad", "soyad"),
lazyload(Proje.proje_detayi),
lazyload(Proje.kabul_edilen_proje_hakemleri),
lazyload(Proje.proje_hakem_onerileri),
lazyload(Proje.proje_destekleyen_kurulus),
lazyload(Proje.proje_kalemleri),
).filter(
Proje.id == proje_id,
or_(
Proje.proje_basvuru_durumu == ProjeBasvuruDurumu.tamamlandi,
Proje.proje_basvuru_durumu ==
ProjeBasvuruDurumu.revizyon_bekleniyor)).first()
next_states_info = get_next_states_info(proje_id=proje_id)
actions_info = get_actions_info(proje_id=proje_id)
try:
karar_listesi = DB.session.query(BapGundem).filter(
BapGundem.proje_id == proje_id,
BapGundem.karar_durum != KararDurumu.degerlendirilmedi)
except SQLAlchemyError as exc:
CustomErrorHandler.error_handler(
hata="Proje kararları sorgusunda hata oluştu "
"Hata: {}, User id: {}, Proje id: {}".format(
exc, current_user.id, proje_id))
return abort(500)
return render_template("dashboard/proje_kararlari.html",
karar_listesi=karar_listesi,
proje_id=proje_id,
proje=proje,
next_states_info=next_states_info,
actions_info=actions_info,
proje_yurutucusu_mu=proje_yurutucusu_mu)
class SatinalmaIslemGecmisiListesiView(FlaskView):
"""
Satinalma islem gecmisini listeleyen view
"""
@login_required
@auth.requires(
Or(Permission(*permission_dict["bap"]["satinalma"]["satinalma_islem_gecmisi_goruntuleme"]),
RoleReq('BAP Yetkilisi'), RoleReq("BAP Admin")))
@route('/<int:satinalma_id>/islem-gecmisi', methods=['GET'],
endpoint='satinalma_islem_gecmisi_listele')
def satinalma_islem_gecmisi(self, satinalma_id):
"""
Satinalma islem gecmisine ulasmak icin kullanilir
:param satinalma_id: satinalma_id(int)
:return: http response
"""
params = {"satinalma_id": satinalma_id}
try:
satinalma = get_satinalma_with_related_fields(satinalma_id=satinalma_id)
states_info = get_satinalma_next_states_info(satinalma_id=satinalma_id)
actions_info = get_satinalma_actions_info(satinalma_id=satinalma_id)
proje = DB.session.query(Proje).filter(Proje.id == satinalma.proje_id).first()
islem_listesi = DB.session.query(AppStateTracker). \
filter(AppStateTracker.params.contains(params),
or_(AppStateTracker.job_type == JobTypes.satinalma_state_change,
AppStateTracker.job_type == JobTypes.satinalma_action)). \
join(Person, Person.user_id == AppStateTracker.triggered_by). \
join(AppState, AppStateTracker.state_id == AppState.id). \
add_columns(
AppState.state_code.label("state_code"),
Person.ad.label("person_ad"),
Person.soyad.label("person_soyad"),
).all()
except Exception as exc:
CustomErrorHandler.error_handler(
hata="Satinalma işlem geçmişi görüntülenirken hata oluştu."
"Hata: {}, Satinalma id: {}".format(satinalma_id,
exc)
)
return abort(500)
return render_template("satinalma_dashboard/satinalma_yapilan_islemler.html",
islem_listesi=islem_listesi,
satinalma=satinalma,
satinalma_id=satinalma_id,
proje=proje,
actions_info=actions_info,
states_info=states_info)
class YollukView(FlaskView):
"""Toplanti Gundem Viewi"""
@staticmethod
@login_required
@auth.requires(Or(Permission(*permission_dict["bap"]["toplanti"]["toplanti_gundemi_listeleme"]),
Role("BAP Yetkilisi"),
Role("BAP Admin")),
menu_registry={'path': '.bap.yolluk.yolluk_arama',
'title': _("Yolluk")})
@route("/yolluk", methods=['GET'])
def yolluk():
return render_template("yolluk.html")
class AvansVerilenProjelerView(FlaskView):
"""Bap Bütçe Avans verilen Projeler view classi"""
# todo: implemente edilmedigi icin demodan dolayi yoruma alinmisti. permission hatasindan dolayi
# todo: yorumdan kaldirilip menuden silindi.
@staticmethod
@route('/liste', methods=['GET'])
# @auth.requires(Permission(*permission_dict["bap"]["butce"]["avans_verilen_projeler_goruntuleme"]),
# menu_registry={"path": ".bap.butce.avans_verilen_projeler", "title": _("Avans Verilen Projeler")})
@auth.requires(
Permission(*permission_dict["bap"]["butce"]["avans_verilen_projeler_goruntuleme"]))
def avans_verilen_projeler_listele():
return render_template("avans_verilen_projeler_listeleme.html")
class AvansMalzemelerView(FlaskView):
"""Bap Satinalma Avans ile alınan malzemeler view class"""
# todo: implemente edilmedigi icin demodan dolayi yoruma alinmisti. permission hatasindan dolayi
# todo: yorumdan kaldirilip menuden silindi.
@staticmethod
@route('/liste', methods=['GET'])
# @auth.requires(Permission(*permission_dict["bap"]["satinalma"]["avans_ile_alinan_malzemeler_listesi_goruntuleme"]),
# menu_registry={"path": ".bap.satinalma.avans_ile_alinan_malzemeler", "title": _("Avans ile Alınan Malzemeler")})
@auth.requires(
Permission(*permission_dict["bap"]["satinalma"]
["avans_ile_alinan_malzemeler_listesi_goruntuleme"]))
def avans_ile_alinan_malzemeler_listele():
return render_template("avans_malzemeler.html")
class StratejiTeslimView(FlaskView):
"""Bap Strateji Teslim view classi"""
# todo: implemente edilmedigi icin demodan dolayi yoruma alinmisti. permission hatasindan dolayi
# todo: yorumdan kaldirilip menuden silindi.
@staticmethod
@route('/liste', methods=['GET'])
# @auth.requires(Permission(*permission_dict["bap"]["butce"]["strateji_teslim_listesi_goruntuleme"]),
# menu_registry={"path": ".bap.butce.strateji_teslim_listesi", "title": _("Strateji Teslim Listesi")})
@auth.requires(
Permission(*permission_dict["bap"]["butce"]
["strateji_teslim_listesi_goruntuleme"]))
def strateji_teslimleri_listele():
return render_template("strateji_teslimleri_listeleme.html")
class GonderilmisEpostalarView(FlaskView):
"""Gonderilmis epostalar Viewi"""
excluded_methods = ["qry", "user_id"]
@property
def qry(self):
"""ProjeMesaj BaseQuery"""
system_user = SessionHandler.system_user()
sp_id = system_user['person_id']
return DB.session.query(ProjeMesaj).join(
Proje, ProjeMesaj.proje_id == Proje.id).join(
Mesaj, Mesaj.id == ProjeMesaj.mesaj_id).join(
Person, Mesaj.gonderen == Person.id).add_columns(
Proje.proje_basligi, Proje.id.label("proje_id"),
Proje.proje_no, Mesaj.okundu, Mesaj.gonderim_zamani,
Mesaj.baslik, Person.ad.label("gonderen_ad"),
Person.soyad.label("gonderen_soyad")).filter(
Mesaj.gonderen == sp_id)
@login_required
@auth.requires(
Permission(*permission_dict['sistem_takibi']['gonderilmis_epostalar']
['gonderilmis_epostalar_goruntuleme']),
menu_registry={
'path': '.sistem_takibi.gonderilmis_epostalar',
'title': _("Gönderilmiş Epostalar")
})
@route("/liste")
def liste(self):
eposta_listesi = self.qry.all()
return render_template("gonderilmis_epostalar/liste.html",
eposta_listesi=eposta_listesi)
class AkademikPersonelView(FlaskView):
"""Akademik Personel ile ilgili islemler Viewi"""
excluded_methods = ["qry", "user_id"]
def process_data(self, result, form_data, total_record):
data = [
[
index + 1,
"{}".format(r.unvan_ad),
"{} {}".format(r.ad, r.soyad),
# "{}".format(r.fakulte_id),
# "{}".format(r.bolum.id),
"{}".format("Aktif" if r.durumu else "Pasif"),
render_template_string("""
<a href="#preview-personel_durum"
class="btn btn-success m-t-10"
data-toggle="modal"
data-target="#preview-personel_durum"
onclick="personel_bilgisi({{ id }});">
{{ _("Durumunu Belirle") }}
</a>
""",
id=r.user_id)
] for index, r in enumerate(result)
]
return jsonify({
"data": data,
"draw": form_data['draw'],
"recordsFiltered": total_record,
"recordsTotal": total_record
})
@property
def qry(self):
"""AkademikPersonel BaseQuery"""
return DB.session.query(OgretimElemani). \
join(Personel, Personel.id == OgretimElemani.personel_id). \
join(Person, Person.id == Personel.person_id). \
join(User, User.id == Person.user_id). \
join(HitapUnvan, HitapUnvan.id == Personel.unvan). \
filter(Personel.personel_turu == PersonelTuru.akademik). \
add_columns(
User.id.label("user_id"),
User.durumu.label("durumu"),
Person.ad.label("ad"),
Person.soyad.label("soyad"),
HitapUnvan.ad.label("unvan_ad")
)
@login_required
@auth.requires(Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["akademik_personel_listesi_goruntuleme"]),
menu_registry={
'path':
'.yonetim.personel_yonetimi.akademik_personel_listesi',
'title': _("Akademik Personel")
})
@route("/", methods=["GET"])
def liste(self):
"""AkademikPersonel Listesi Ekrani"""
personel_durum_form = PersonelDurumForm()
search_form = AkademikPersonelSearchForm()
return render_template("akademik_liste.html",
search_form=search_form,
personel_durum_form=personel_durum_form)
# todo: Silme islemleri daha sonra dusunulecek
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["akademik_personel_silme"]))
@route("/sil/<int:personel_id>/", methods=["DELETE"], endpoint='sil')
def sil(personel_id):
"""AkademikPersonel Silme"""
personel = DB.session.query(Personel).filter(
Personel.id == personel_id).one_or_none()
if personel:
DB.session.delete(personel)
DB.session.commit()
signal_payload = {
"nesne":
'Personel',
"nesne_id":
personel.id,
"ekstra_mesaj":
"{} adlı kullanıcı {} id'li personeli sildi.".format(
current_user.username, personel.id)
}
signal_sender(**signal_payload)
return jsonify(status='success')
return abort(400)
@login_required
@auth.requires(
Permission(
*permission_dict["bap"]["proje"]["proje_arama"]["projeleri_arama"])
)
@route('/data', methods=["POST"], endpoint="akademik_search")
def personel_arama(self): # pylint: disable=too-many-branches
"""
Bap personel için POST ile gelen parametrelere gore arama yapip, sonuclari dondurur.
Returns:
http response
"""
qry = self.qry
total_record = qry.count()
form_data = request.form.to_dict()
search_form = AkademikPersonelSearchForm(**form_data)
ad = search_form.ad.data.strip()
soyad = search_form.soyad.data.strip()
unvan_id = search_form.unvan_id.data
# fakulte_id = search_form.fakulte_id.data
# bolum_id = search_form.bolum_id.data
durumu = search_form.durumu.data
if durumu != '-1':
if durumu == '1':
qry = qry.filter(User.durumu.is_(True))
else:
qry = qry.filter(User.durumu.is_(False))
if not search_form.validate():
result = qry.offset(form_data['start']).limit(
form_data['length']).all()
total_record = qry.count()
return self.process_data(result, form_data, total_record)
if unvan_id:
qry = qry.filter(HitapUnvan.id == unvan_id)
if ad:
qry = qry.filter(Person.ad.ilike('%' + ad + '%'))
if soyad:
qry = qry.filter(Person.soyad.ilike('%' + soyad + '%'))
result = qry.offset(form_data['start']).limit(
form_data['length']).all()
return self.process_data(result, form_data, total_record)
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["personel_durum_atama"]))
@route("/durum-ata/<int:personel_id>/",
methods=["POST"],
endpoint='durum_ata')
def durum_ata(personel_id):
"""AkademikPersonel Aktif veya Pasif durumu atama"""
personel = DB.session.query(Personel).filter(
Personel.id == personel_id).one_or_none()
personel_durum_form = PersonelDurumForm(request.form)
try:
durum = bool(int(personel_durum_form.durum_listesi.data))
personel.user.durumu = durum
DB.session.add(personel)
DB.session.commit()
if durum:
flash(
f"{personel.person.ad} {personel.person.soyad} adlı personelin durumu aktif olarak değiştirildi."
)
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("yonetim").get(
"personel_durumu_belirle").type_index,
"nesne":
'Personel',
"nesne_id":
personel.id,
"ekstra_mesaj":
"""
{} adlı kullanıcı
{} {} adlı ve {} idsine sahip personelin durumunu Aktif olarak değiştirdi."""
.format(
current_user.username,
personel.person.ad,
personel.person.soyad,
personel.id,
)
}
else:
# Useri logout etmek icin cacheten session keyini siliyoruz.
usid = personel.user.session_id
cache = current_app.extensions['redis']
key = "{prefix}:{usid}".format(
prefix=current_app.config.get('SESSION_CACHE_KEY_PREFIX'),
usid=usid)
cache.delete(key)
flash(
f"{personel.person.ad} {personel.person.soyad} adlı personelin durumu pasif olarak değiştirildi."
)
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("yonetim").get(
"personel_durumu_belirle").type_index,
"nesne":
'Personel',
"nesne_id":
personel.id,
"ekstra_mesaj":
"""
{} adlı kullanıcı
{} {} adlı ve {} idsine sahip personelin durumunu Pasif olarak değiştirdi."""
.format(
current_user.username,
personel.person.ad,
personel.person.soyad,
personel.id,
)
}
signal_sender(**signal_payload)
return redirect(
url_for('personel_yonetimi.AkademikPersonelView:liste'))
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata=
"Akademik personel durumu değiştirilmeye çalışıldı. Hata: {}".
format(exc))
return redirect(
url_for('personel_yonetimi.AkademikPersonelView:liste'))
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["personel_durum_atama"]))
@route("/personel-bilgisi/<int:personel_id>/", methods=["GET"])
def personel_bilgisi(personel_id):
try:
personel = DB.session.query(Personel).filter(
Personel.id == personel_id).options(joinedload(
Personel.user)).first()
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata=
"{} id li personel bilgisine oluşılırken bir hata oluştu. Hata:{}"
.format(personel_id, exc))
return jsonify(status="error"), 400
personel_detay = {
'personel_id': personel_id,
'personel_turu': personel.hitap_unvan.ad,
'personel_adı': personel.person.ad,
'personel_soyadı': personel.person.soyad,
'personel_aktifliği': personel.user.durumu
}
return jsonify(status="success", personel=personel_detay)
class ProjeTuruView(FlaskView):
"""Proje Türü View"""
excluded_methods = ["init_proje_turu_gelir_kodlari_data"]
@staticmethod
def init_proje_turu_gelir_kodlari_data(proje_turu_formu,
butce_kalemleri=None):
"""
proje turu icin secilmis butce kalemlerinin verisini proje turu formu butce_kalemliri
alanina ekler
"""
if butce_kalemleri:
for butce_kalemi in butce_kalemleri:
for butce_kalem_form in proje_turu_formu.butce_kalemleri:
if butce_kalem_form.gider_siniflandirma_id.data == butce_kalemi.gider_siniflandirma_id:
butce_kalem_form.secili_mi.data = True
butce_kalem_form.butce_alt_limiti.data = butce_kalemi.butce_alt_limiti
butce_kalem_form.butce_ust_limiti.data = butce_kalemi.butce_ust_limiti
return proje_turu_formu
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["proje_turu"]
["proje_turu_yaratma_formu_goruntuleme"]))
@route('/', methods=["GET"], endpoint='proje_turu')
def get_proje_turu_view(self):
"""
Proje türü view ini almayı saglarl
Returns:
"""
proje_turu_formu = ProjeTuruFormu()
return render_template("proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
basvuru_yapilmis_mi=False,
guncel_mi=True)
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["proje_turu"]
["proje_turu_yaratma_formu_goruntuleme"]))
@route('/<int:proje_turu_id>',
methods=["GET"],
endpoint='proje_turu_with_id')
def get_proje_turu_view_with_id(self, proje_turu_id):
"""
Proje türünü id si ile birlikte almayı sağlar.
Args:
proje_turu_id: proje türünün id si
Returns:
"""
try:
proje_turu = DB.session.query(ProjeTuru).options(
joinedload(ProjeTuru.butce), joinedload(ProjeTuru.cikti),
joinedload(ProjeTuru.personel_ayarlari),
joinedload(ProjeTuru.ek_dosyalar).joinedload(EkDosya.belge),
joinedload(ProjeTuru.butce_kalemleri).joinedload(
ButceKalemi.gider_siniflandirma_kalemi)).filter_by(
id=proje_turu_id).one()
except NoResultFound:
return redirect(url_for('.proje_turu'))
proje = DB.session.query(
Proje.proje_turu).filter(Proje.proje_turu == proje_turu_id).all()
butce_dict = proje_turu.butce.to_dict()
personel_ayarlari_dict = proje_turu.personel_ayarlari.to_dict()
proje_turu_dict = proje_turu.to_dict()
if butce_dict:
butce_dict.pop("id")
butce_dict.pop("proje_turu_id")
if personel_ayarlari_dict:
personel_ayarlari_dict.pop("id")
personel_ayarlari_dict.pop("proje_turu_id")
ek_dosyalar = []
for ek_dosya in proje_turu.ek_dosyalar:
ek_dosyalar.append({
"ek_dosya_id": ek_dosya.id,
"zorunlu_mu": ek_dosya.zorunlu_mu,
"proje_icerik_dosyasi_mi": ek_dosya.proje_icerik_dosyasi_mi,
"belgenin_ciktisi_alinacak_mi":
ek_dosya.belgenin_ciktisi_alinacak_mi,
"belge": {
"adi": ek_dosya.belge.adi,
"aciklama": ek_dosya.belge.aciklama,
"turler": ek_dosya.belge.turler,
"file_id": ek_dosya.belge.file_id
}
})
ciktilar = []
for cikti in proje_turu.cikti:
ciktilar.append({
"cikti_id":
cikti.id,
"sablon_id":
cikti.sablon_id,
"adi":
cikti.adi,
"gorunurluk":
cikti.gorunurluk,
"belge_ciktisi_alinacak_mi":
cikti.belge_ciktisi_alinacak_mi
})
proje_turu_formu = ProjeTuruFormu(
**proje_turu_dict,
**proje_turu.genel_uyari_mesajlari,
butce_ayarlari=butce_dict,
sablon_ayarlari=proje_turu_dict,
personel_ayarlari=personel_ayarlari_dict,
ek_dosyalar=ek_dosyalar,
ciktilar=ciktilar)
proje_turu_formu = self.init_proje_turu_gelir_kodlari_data(
proje_turu_formu, proje_turu.butce_kalemleri)
return render_template("proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
proje_turu_id=proje_turu.id,
guncel_mi=proje_turu.guncel_mi,
basvuru_yapilmis_mi=True if proje else False)
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["bap"]["proje"]["proje_turu"]
["proje_turlerini_listeme"]),
menu_registry={
'path': '.yonetim.bap.proje_turu',
'title': _("Proje Türleri"),
"order": 0
})
@route('/liste', methods=['GET'])
def proje_turu_listele():
"""Proje Turleri Listesi"""
uyarilar = [
"Proje türünü taslak olarak kaydedip daha sonra işlem yapmaya devam edebilirsiniz",
"Başvuru yapılmış bir proje türünü güncelleyemezsiniz.",
"Başvuru yapılmış bir projeyi güncellemek isterseniz versiyonlama özelliğini kullanabilirsiniz",
"Bir proje türünü versiyonlarsanız eski versiyona artık başvuru yapılamayacaktır. Başvurular yeni versiyona yapılabilir.",
"Eski versiyona yapılmış proje başvuruları o versiyondaki ayarlarla devam eder.",
"Basvuru aktif mi seçeneğini işaretlemezseniz proje türü başvuruya açık olmaz",
]
proje_turleri = DB.session.query(ProjeTuru).order_by(
desc(ProjeTuru.created_at)).all()
proje_turu_taslaklari = DB.session.query(Taslak).filter(
Taslak.taslak_tipi == TaslakTipleri.bap_proje_turu).all()
return render_template('/proje_turu/listeleme.html',
proje_turleri=proje_turleri,
taslak_proje_turleri=proje_turu_taslaklari,
uyarilar=uyarilar)
class TeslimBeklenenFirmalarView(FlaskView):
"""Bap Satinalma Teslim Beklenen Firmalar view class"""
excluded_methods = ["qry"]
def kalan_gun_sayisi(self, teslim_edilmesi_beklenen_tarih):
kalan_gun = (datetime(teslim_edilmesi_beklenen_tarih.year,
teslim_edilmesi_beklenen_tarih.month,
teslim_edilmesi_beklenen_tarih.day) -
datetime.now()).days
if kalan_gun < 0:
return ("{} Gün geçti".format(abs(kalan_gun)), kalan_gun)
return ("{} Gün kaldı".format(kalan_gun), kalan_gun)
@property
def qry(self):
"""
Proje ve ilgili alanlari icin query nesnesi olustur.
Returns:
"""
return DB.session.query(BapFirma). \
join(FirmaSatinalmaTeklif, FirmaSatinalmaTeklif.firma_id == BapFirma.id). \
join(FirmaTeklifKalemi, FirmaTeklifKalemi.teklif_id == FirmaSatinalmaTeklif.id). \
join(ProjeSatinAlmaTalebi, ProjeSatinAlmaTalebi.id == FirmaSatinalmaTeklif.satinalma_id). \
join(TalepKalemleri, TalepKalemleri.satinalma_id == ProjeSatinAlmaTalebi.id). \
join(SiparisTakip, SiparisTakip.satinalma_talep_kalemleri_id == TalepKalemleri.id). \
join(Proje, Proje.id == ProjeSatinAlmaTalebi.proje_id). \
join(OgretimElemani, Proje.yurutucu == OgretimElemani.id). \
join(Personel, OgretimElemani.personel_id == Personel.id). \
join(Person, Person.id == Personel.person_id). \
join(HitapUnvan, Personel.unvan == HitapUnvan.id). \
add_columns(
BapFirma.adi.label("firma_adi"),
Proje.proje_no.label("proje_no"),
SiparisTakip.siparis_numarasi.label("siparis_no"),
SiparisTakip.siparis_tarihi.label("siparis_tarihi"),
SiparisTakip.teslim_edilmesi_beklenen_tarih.label("teslim_edilmesi_beklenen_tarih"),
Person.ad.label("ad"),
Person.ad.label("soyad"),
HitapUnvan.ad.label("unvan"),
ProjeSatinAlmaTalebi.id.label("satinalma_id"),
FirmaTeklifKalemi.teslimat_suresi.label("teslimat_suresi")
). \
filter(SiparisTakip.siparis_durumu == SiparisDurumu.firma_bekleniyor)
def process_data(self, result, form_data, total_record):
data = [[
index + 1, r.firma_adi, r.proje_no if r.proje_no else '-',
r.siparis_no, "{} {} {}".format(r.unvan, r.ad, r.soyad),
'{}'.format(
r.siparis_tarihi.strftime(current_app.config['DATE_FORMAT'])),
'{}'.format(
r.teslim_edilmesi_beklenen_tarih.strftime(
current_app.config['DATE_FORMAT'])),
"{}".format(
self.kalan_gun_sayisi(r.teslim_edilmesi_beklenen_tarih)[0]),
"""
<a class="detail_arrow" href="{}"><span class="fa fa-arrow-circle-right fa-2x "></span>
</a>
""".format(
url_for('satinalma.satinalma_dashboard',
satinalma_id=r.satinalma_id))
] for index, r in enumerate(result)]
return jsonify({
"data": data,
"draw": form_data['draw'],
"recordsFiltered": total_record,
"recordsTotal": total_record
})
@staticmethod
@login_required
@route('/', methods=['GET'])
@auth.requires(
Permission(*permission_dict["bap"]["satinalma"]
["teslimi_beklenen_firmalar_listesi_görüntüleme"]),
menu_registry={
"path": ".bap.satinalma.teslim_beklenen_firmalar",
"title": _("Ürün Teslim Takibi")
})
def teslimi_beklenen_firmalar_listele():
search_form = TeslimiBeklenenFirmalarSearchForm()
return render_template("teslimi_beklenen_firmalar.html",
form=search_form)
@login_required
@auth.requires(
Or(
Permission(*permission_dict["bap"]["satinalma"]
["teslimi_beklenen_firmalar_listesi_görüntüleme"]),
Or(Role("BAP Admin"), Role("BAP Yetkilisi"))))
@route('/data',
methods=["POST"],
endpoint="teslim_beklenen_firmalar_search")
def teslimi_beklenen_firmalar_ara(self): # pylint: disable=too-many-branches
"""
Bap projelerinde POST ile gelen parametrelere gore arama yapip, sonuclari dondurur.
Returns:
http response
"""
qry = self.qry
total_record = qry.count()
form_data = request.form.to_dict()
search_form = TeslimiBeklenenFirmalarSearchForm(**form_data)
if search_form.gun_gecikmesi.data == '1':
qry = qry.filter(
SiparisTakip.teslim_edilmesi_beklenen_tarih > date.today())
elif search_form.gun_gecikmesi.data == '2':
qry = qry.filter(
SiparisTakip.teslim_edilmesi_beklenen_tarih < date.today())
elif search_form.gun_gecikmesi.data == '3':
qry = qry.filter(
SiparisTakip.teslim_edilmesi_beklenen_tarih == date.today())
if not search_form.validate():
result = qry.order_by(desc(SiparisTakip.siparis_tarihi)).offset(
form_data['start']).limit(form_data['length']).all()
total_record = qry.count()
return self.process_data(result, form_data, total_record)
firma_adi = search_form.firma_adi.data
proje_no = search_form.proje_no.data
yurutucu = search_form.yurutucu.data
siparis_no = search_form.siparis_no.data
siparis_tarihi = search_form.date.siparis_tarihi.data
siparis_tarihi_option = search_form.date.siparis_tarihi_option.data
teslim_edilmesi_beklenen_tarih = search_form.date.teslim_edilmesi_beklenen_tarih.data
teslim_edilmesi_beklenen_tarih_option = search_form.date.teslim_edilmesi_beklenen_tarih_option.data
if proje_no:
qry = qry.filter(Proje.proje_no.ilike('%' + proje_no + '%'))
if yurutucu:
qry = qry.filter(Person.ad.ilike('%' + yurutucu + '%'))
if firma_adi:
qry = qry.filter(BapFirma.adi.ilike('%' + firma_adi + '%'))
if siparis_no:
qry = qry.filter(
SiparisTakip.siparis_numarasi.ilike('%' + siparis_no + '%'))
if siparis_tarihi:
if siparis_tarihi_option == '0':
qry = qry.filter(SiparisTakip.siparis_tarihi <= siparis_tarihi)
if siparis_tarihi_option == '1':
qry = qry.filter(SiparisTakip.siparis_tarihi == siparis_tarihi)
if siparis_tarihi_option == '2':
qry = qry.filter(SiparisTakip.siparis_tarihi >= siparis_tarihi)
if teslim_edilmesi_beklenen_tarih:
if teslim_edilmesi_beklenen_tarih_option == '0':
qry = qry.filter(SiparisTakip.teslim_edilmesi_beklenen_tarih <=
teslim_edilmesi_beklenen_tarih)
if teslim_edilmesi_beklenen_tarih_option == '1':
qry = qry.filter(SiparisTakip.teslim_edilmesi_beklenen_tarih ==
teslim_edilmesi_beklenen_tarih)
if teslim_edilmesi_beklenen_tarih_option == '2':
qry = qry.filter(SiparisTakip.teslim_edilmesi_beklenen_tarih >=
teslim_edilmesi_beklenen_tarih)
result = qry.order_by(desc(SiparisTakip.siparis_tarihi)).offset(
form_data['start']).limit(form_data['length']).all()
return self.process_data(result, form_data, total_record)
class FilterView(FlaskView):
"""
Filter View
"""
route_base = "/select"
excluded_methods = [
"query_data",
"initial_val",
"get_paginated_query_data_and_number_of_row",
"check_request_params",
"prepare_response",
]
def __init__(self):
with app.app_context():
current_app.logger.info("asdfasffasfdsa")
@property
def query_data(self):
"""request form query"""
return request.form.get("q")
@property
def initial_val(self):
"""request form initial_val"""
return request.form.get("initial_val")
@login_required
@route('/personel', methods=["POST"], endpoint='select.personel.arama')
@auth.requires(Permission(*permission_dict["common"]["app"]["modal_filter"]["personel_arama"]))
def filter_personel(self):
"""
select2 tarafından query_param olarak gönderilen "q" değişkeni alınıp personel tablosunda
"ad" ve "soyad" fieldlarında arama yapılır. "q" değişkeni ile başlayan "ad" veya "soyad"
varsa gerekli degerler return edilir
Returns:
{
"items": [{ "id":1, "text": "Ad1 Soyad1"},...],
"total_count": number_of_total_row,
}
"""
self.check_request_params()
query = DB.session.query(
Personel
).join(
Person,
Personel.person_id == Person.id
).join(HitapUnvan, HitapUnvan.id == Personel.unvan).add_columns(
Personel.id, Person.ad.label("ad"), Person.soyad.label("soyad"),
HitapUnvan.ad.label("hitap_unvan")
)
if self.query_data:
query = query.filter(or_(Person.ad.ilike(self.query_data + "%"),
Person.soyad.ilike(self.query_data + "%")))
else:
query = query.filter(Person.id == self.initial_val)
return self.prepare_response(query, text_field=["ad", "soyad", "hitap_unvan"],
text_format="{} {} - {}")
@login_required
@route('/universite', methods=["POST"], endpoint="select.universite.arama")
@auth.requires(
Permission(*permission_dict["common"]["app"]["modal_filter"]["universite_arama"]))
def filter_universite(self):
"""
select2 tarafından query_param olarak gönderilen "q" değişkeni alınıp birim tablosunda
universite isimleri arasinda filtre edilir ve seçilen universitenin birim id si doner
varsa gerekli degerler return edilir
:return:
"""
query = DB.session.query(Birim).filter(Birim.birim_tipi == "Üniversite").options(
load_only("id", "uzun_ad"))
if self.query_data:
filter_param = or_(Birim.ad.ilike("%" + self.query_data + "%"),
Birim.uzun_ad.ilike("%" + self.query_data + "%"))
query = query.filter(filter_param)
else:
query = query.filter(Birim.id == self.initial_val)
return self.prepare_response(query)
@login_required
@route('/birim', methods=["POST"], endpoint='select.birim.arama')
@auth.requires(Permission(*permission_dict["common"]["app"]["modal_filter"]["birim_arama"]))
def filter_birim(self):
"""
select2 tarafından query_param olarak gönderilen "q" değişkeni alınıp birim tablosunda
"ad" ve "uzun_ad" fieldlarında arama yapılır. "q" değişkeni içeren "ad" veya "uzun_ad"
varsa gerekli degerler return edilir
Returns:
{
"items": [{ "id":1, "text": "İktisat"},...],
"total_count": number_of_total_row,
}
"""
self.check_request_params()
ust_birim_id = request.form.get("dependant_value")
kurum_ici = request.form.get("kurum_ici")
birim_tipi = request.form.get("birim_tipi")
query = DB.session.query(Birim).options(load_only("id", "uzun_ad"))
if self.query_data:
filter_param = or_(Birim.ad.ilike("%" + self.query_data + "%"),
Birim.uzun_ad.ilike("%" + self.query_data + "%"))
if kurum_ici == 'true':
universite_id = SessionHandler.universite_id()
if birim_tipi == BirimTipiEnum.fakulte.value:
ust_birim_id = universite_id
if ust_birim_id:
filter_param = and_(filter_param, Birim.ust_birim_id == ust_birim_id)
if birim_tipi:
filter_param = and_(filter_param, Birim.birim_tipi == birim_tipi)
query = query.filter(filter_param)
else:
query = query.filter(Birim.id == self.initial_val)
return self.prepare_response(query)
@login_required
@route('/bap_belge', methods=["POST"], endpoint='select.bap_belge.arama')
@auth.requires(Permission(*permission_dict["common"]["app"]["modal_filter"]["belge_arama"]))
def filter_bap_belge(self):
"""
Returns:
"""
self.check_request_params()
query = DB.session.query(BAPBelge).options(load_only("id", "adi", "aciklama"))
if self.query_data:
query = query.filter(BAPBelge.adi.ilike(self.query_data + "%"))
else:
query = query.filter(BAPBelge.id == self.initial_val)
return self.prepare_response(query, text_field=["adi", "aciklama"],
text_format="{}\n{}")
@login_required
@route('/hakem', methods=["POST"], endpoint='select.hakem.arama')
@auth.requires(Permission(*permission_dict["common"]["app"]["modal_filter"]["hakem_arama"]))
def filter_hakem(self):
"""
Hakem Filtrelemek için kullanılır
"""
self.check_request_params()
query = DB.session.query(Hakem).join(
Hakem.person
).options(
load_only('unvan', 'hakem_turu'),
joinedload(Hakem.person).load_only('ad', 'soyad'),
joinedload(Hakem.personel))
if self.query_data:
query = query.filter(or_(Person.ad.ilike('%' + self.query_data.strip() + '%'),
Person.soyad.ilike('%' + self.query_data.strip() + '%')))
else:
query = query.filter(Person.ad.ilike('%' + self.initial_val.strip() + '%'))
return self.prepare_response(query,
text_field=["unvan", "person.ad", "person.soyad",
"universite.ad"])
@login_required
@route('/hitap_unvan', methods=["POST"])
@auth.requires(
Permission(*permission_dict["common"]["app"]["modal_filter"]["hitap_unvan_arama"]))
def filter_hitap_unvan(self):
"""
HitapUnvan Filtrelemek için kullanılır
"""
self.check_request_params()
query = DB.session.query(HitapUnvan).options(load_only("id", "ad", "kod"))
if self.query_data:
query = query.filter(HitapUnvan.ad.ilike("%" + self.query_data.upper() + "%"))
else:
query = query.filter(HitapUnvan.id == self.initial_val)
return self.prepare_response(query, text_field=["ad", "kod"])
@login_required
@route('/ogrenci', methods=["POST"])
@auth.requires(Permission(*permission_dict["common"]["app"]["modal_filter"]["ogrenci_arama"]))
def filter_ogrenci(self):
"""
select2 tarafından query_param olarak gönderilen "q" değişkeni alınıp ogrenci tablosunda
"ad" ve "soyad" fieldlarında arama yapılır. "q" değişkeni ile başlayan "ad" veya "soyad"
varsa gerekli degerler return edilir
Returns:
{
"items": [{ "id":1, "text": "Ad1 Soyad1"},...],
"total_count": number_of_total_row,
}
"""
self.check_request_params()
query = DB.session.query(Ogrenci).join(Person, Ogrenci.person_id == Person.id). \
add_columns(Ogrenci.id, Person.ad, Person.soyad)
if self.query_data:
query = query.filter(or_(Person.ad.ilike("%" + self.query_data + "%"),
Person.soyad.ilike("%" + self.query_data + "%")))
else:
query = query.filter(Person.id == self.initial_val)
return self.prepare_response(query, text_field=["ad", "soyad"], text_format="{} {}")
@login_required
@route('/ogretim-uyesi', methods=["POST"])
@auth.requires(
Permission(*permission_dict["common"]["app"]["modal_filter"]["ogretim_uyesi_arama"]))
def filter_ogretim_uyesi(self):
"""
select2 tarafından query_param olarak gönderilen "q" değişkeni alınıp ogretim elamani
tablosunda üzerinden person tablosunun
"ad" ve "soyad" fieldlarında arama yapılır. "q" değişkeni ile başlayan "ad" veya "soyad"
varsa gerekli degerler return edilir
Returns:
{
"items": [{ "id":1, "text": "Ad1 Soyad1"},...],
"total_count": number_of_total_row,
}
"""
self.check_request_params()
query = DB.session.query(OgretimElemani).join(
Personel, OgretimElemani.personel_id == Personel.id).join(
Person, Personel.person_id == Person.id).add_columns(
OgretimElemani.id, Person.ad, Person.soyad)
if self.query_data:
query = query.filter(or_(Person.ad.ilike("%" + self.query_data + "%"),
Person.soyad.ilike("%" + self.query_data + "%"), ))
else:
query = query.filter(Person.id == self.initial_val)
return self.prepare_response(query, text_field=["ad", "soyad"], text_format="{} {}")
@route('/vergi-dairesi', methods=["POST"], endpoint='select.vergi_dairesi.arama')
@auth.requires(
Or(Permission(*permission_dict["common"]["app"]["modal_filter"]["vergi_dairesi_arama"]),
Role("anonymous")))
def filter_vergi_dairesi(self):
"""
select2 tarafından query_param olarak gönderilen "q" değişkeni alınıp vergi dairesi
tablosunda "kodu", "adi" ve "il" fieldlarında arama yapılır. "q" değişkeni içeren "adi" ve "kodu"
varsa gerekli degerler return edilir
Returns:
{
"items": [{ "id":1, "text": "urla vergi dairesi"},...],
"total_count": number_of_total_row,
}
"""
self.check_request_params()
query = DB.session.query(VergiDairesi)
if self.query_data:
query = query.filter(or_(VergiDairesi.kodu.ilike("%" + self.query_data + "%"),
VergiDairesi.adi.ilike("%" + self.query_data + "%"),
VergiDairesi.il.ilike("%" + self.query_data + "%")))
else:
query = query.filter(VergiDairesi.id == self.initial_val)
return self.prepare_response(query, text_field=["adi", "kodu"], text_format="{} - {}")
@route('/detayli-hesap-kodu', methods=["POST"], endpoint='select.detayli_hesap_plani.arama')
@auth.requires(
Permission(*permission_dict["common"]["app"]["modal_filter"]["detayli_hesap_kodu_arama"]))
def filter_detayli_hesap_plani(self):
"""
detayli hesap plani modelinde "hesap_kodu" ve "ana_hesap_hesap_grubu_yardimci_hesap_adi"
alanlarinda arama yapar
"""
self.check_request_params()
query = DB.session.query(DetayliHesapPlanlari)
if self.query_data:
query = query.filter(
or_(DetayliHesapPlanlari.hesap_kodu.ilike("%" + self.query_data + "%"),
DetayliHesapPlanlari.ana_hesap_hesap_grubu_yardimci_hesap_adi.ilike(
"%" + self.query_data + "%")))
else:
query = query.filter(DetayliHesapPlanlari.id == self.initial_val)
return self.prepare_response(query, text_field=["hesap_kodu",
"ana_hesap_hesap_grubu_yardimci_hesap_adi"],
text_format="{} - {}")
@login_required
@route('/gelir-kasasi', methods=["POST"], endpoint='select.gelir_kasasi.arama')
@auth.requires(
Permission(*permission_dict["common"]["app"]["modal_filter"]["gelir_kasasi_arama"]))
def filter_gelir_kasasi(self):
"""
Güncel gelir kasalari arasinda arama yapar.
"""
self.check_request_params()
query = DB.session.query(GelirKasasi)
if self.query_data:
query = query.filter(GelirKasasi.adi.ilike("%" + self.query_data + "%"),
GelirKasasi.mali_yil == datetime.now().year)
else:
query = query.filter(GelirKasasi.id == self.initial_val)
return self.prepare_response(query, text_field=["adi"], text_format="{}")
# pylint: disable=invalid-name
@staticmethod
def get_paginated_query_data_and_number_of_row(query):
"""
Args:
query: query
Returns: query_result(list_model_instance), number_of_row(int)
"""
page = int(request.form.get("page", 1))
page_size = int(request.form.get("page_size", SELECT2_PAGE_SIZE))
count_query = query.statement.with_only_columns([func.count()])
number_of_row = DB.session.execute(count_query).scalar()
query_result = query.limit(page_size).offset((page - 1) * page_size).all()
return query_result, number_of_row
# pylint: enable=invalid-name
def check_request_params(self): # pylint: disable=inconsistent-return-statements
"""
Check request params and returns empty result if both q and initial_data aren't given.
Returns:
Empty result
"""
if not (self.query_data or self.initial_val):
return jsonify({"results": []})
def prepare_response(self, query, id_field="id", text_field=None, text_format=None):
"""
Args:
query:
id_field:
text_field:
text_format:
Returns:
"""
if not text_field:
text_field = ["ad"]
if isinstance(text_field, str):
text_field = [text_field]
text = operator.attrgetter(*text_field)
text_field_number = len(text_field)
if not text_format:
text_format = "{} - " * text_field_number
def format_text(item):
"""
Args:
item: query result item
Returns:
(str) formatted text
"""
item_vals = text(item)
item_vals = list(item_vals) if isinstance(item_vals, tuple) else [item_vals]
return text_format.format(*item_vals).rstrip('- ')
items, number_of_row = self.get_paginated_query_data_and_number_of_row(query)
data = [
{
"id": getattr(item, id_field),
"text": format_text(item)
} for item in items
]
return jsonify({
"items": data,
"total_count": number_of_row
})
class DigerAyarlariView(FlaskView):
"""
Bap ayarları diger bölümü
"""
@staticmethod
@login_required
@auth.requires(Permission(
*permission_dict["yonetim"]["bap_yonetimi"]["diger_ayarlar"]),
menu_registry={
'path': '.yonetim.bap.diger_ayarlari',
'title': _("Diğer"),
"order": 15
})
@route('/diger', methods=['GET'])
def diger_get():
"""
"Diger" ayarlarinin görüntülendigi view
"""
diger_formu = DigerFormu()
universite_id = SessionHandler.universite_id()
genel_ayarlar = DB.session.query(GenelAyarlar).filter_by(
universite_id=universite_id, aktif_mi=True).first()
if genel_ayarlar and genel_ayarlar.bap_diger:
diger_formu = DigerFormu(**genel_ayarlar.bap_diger)
return render_template('diger.html', diger_formu=diger_formu)
@staticmethod
@login_required
@auth.requires(Permission(
*permission_dict["yonetim"]["bap_yonetimi"]["diger_ayarlar"]),
menu_registry={
'path': '.yonetim.bap.diger_ayarlari',
'title': _("Diğer"),
"order": 15
})
@route('/diger', methods=['POST'])
def diger_post():
"""
"Diger" ayarlarinin kaydedildigi view
"""
diger_formu = DigerFormu(request.form)
if diger_formu.validate():
universite_id = SessionHandler.universite_id()
diger_ayarlar_data = dict(diger_formu.data)
diger_ayarlar_data.pop('csrf_token')
diger_ayarlar_data['yayinlar'].pop('csrf_token')
diger_ayarlar_data['firma'].pop('csrf_token')
diger_ayarlar_data['diger'].pop('csrf_token')
genel_ayarlar = DB.session.query(GenelAyarlar).filter_by(
universite_id=universite_id, aktif_mi=True).first()
if genel_ayarlar:
yeni_ayarlar = genel_ayarlar_guncelle(genel_ayarlar,
"bap_diger",
diger_ayarlar_data)
else:
yeni_ayarlar = GenelAyarlar(universite_id=universite_id,
bap_diger=diger_ayarlar_data)
DB.session.add(yeni_ayarlar)
DB.session.commit()
flash(_("İşlem başarıyla gerçekleşti."))
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("ayarlar").get(
"bap_proje_guncelle").type_index,
"nesne":
'GenelAyarlar',
"nesne_id":
yeni_ayarlar.id,
"ekstra_mesaj":
"{} adlı kullanıcı, bap diger ayarlarını güncelledi.".format(
current_user.username)
}
signal_sender(**signal_payload)
return render_template('diger.html', diger_formu=diger_formu)
class FormlarVeBelgelerAyarlarView(FlaskView):
"""Bap anasyafa view classi"""
@staticmethod
@login_required
@auth.requires(Permission(
*permission_dict["yonetim"]["bap_yonetimi"]["ana_sayfa_ayarlari"]),
menu_registry={
'path': '.yonetim.ana_sayfa.formlar_ve_belgeler',
'title': _("Formlar ve Belgeler Ayarları")
})
@route('/formlar_ve-belgeler-ayarlar', methods=['GET'])
def formlar_ve_belgeler_ayarlar():
form = AnaSayfaDosyaAyarlari()
dosyalar = DB.session.query(BAPBelge).filter(
BAPBelge.tur == BAPBelgeTipi.formlar_ve_belgeler).all()
return render_template("ana_sayfa_dosya_ayarlari.html",
ana_sayfa_dosyalari=form,
dosyalar=dosyalar,
button_name="Form ve Belge Ekle",
route_name="Form ve Belge Ayarları",
route=render_template_string("""
{{url_for("ana_sayfa_yonetimi.FormlarVeBelgelerAyarlarView:formlar_ve_belgeler_ayarlar_kaydet")}}
"""))
@staticmethod
@login_required
@auth.requires(
Permission(
*permission_dict["yonetim"]["bap_yonetimi"]["ana_sayfa_ayarlari"]))
@route('/formlar_ve-belgeler-ayarlar-kaydet', methods=['POST'])
def formlar_ve_belgeler_ayarlar_kaydet():
form = AnaSayfaDosyaAyarlari(request.form)
ana_sayfa_dosya = request.files.get(form.file_id.name, None)
dosya_id = None
if not form.validate():
flash("Lütfen uygun dosya uzantısı olan bir dosya yükleyiniz.")
return redirect(
url_for(
'ana_sayfa_yonetimi.FormlarVeBelgelerAyarlarView:formlar_ve_belgeler_ayarlar'
))
if ana_sayfa_dosya:
bap_belge = BAPBelge()
_ana_sayfa_dosya = File(content=ana_sayfa_dosya)
try:
DB.session.add(_ana_sayfa_dosya)
DB.session.flush()
bap_belge.file_id = _ana_sayfa_dosya.id
dosya_id = _ana_sayfa_dosya.id
bap_belge.adi = ana_sayfa_dosya.filename
bap_belge.tur = BAPBelgeTipi.formlar_ve_belgeler
DB.session.add(bap_belge)
DB.session.commit()
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Formlar ve Belgeler oluşturulurken hata"
"oluştu.Hata: {}".format(exc))
flash("Lütfen uygun dosya uzantısı olan bir dosya yükleyiniz.")
return redirect(
url_for(
'ana_sayfa_yonetimi.FormlarVeBelgelerAyarlarView:formlar_ve_belgeler_ayarlar'
))
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("yonetim").get(
"formlar_ve_belgeler_eklendi").type_index,
"nesne":
'Formlar ve Belgeler Ayarları',
"nesne_id":
dosya_id,
"ekstra_mesaj":
"Formlar ve Belgeler eklendi: {}".format(dosya_id),
}
signal_sender(**signal_payload)
flash("Formlar ve Belgeler başarılı bir şekilde kaydedilmiştir.")
return redirect(
url_for(
'ana_sayfa_yonetimi.FormlarVeBelgelerAyarlarView:formlar_ve_belgeler_ayarlar'
))
class IdariPersonelView(FlaskView):
excluded_methods = ["qry", "user_id"]
def process_data(self, result, form_data, total_record):
data = [[
index + 1, "{}".format(r.unvan_ad), "{} {}".format(r.ad, r.soyad),
"{}".format(r.gorevi.value), "{}".format(r.gorev_aciklamasi),
"{}".format("Aktif" if r.durumu else "Pasif"),
render_template_string("""
<a href="#preview-personel_durum"
class="btn btn-success m-t-10"
data-toggle="modal"
data-target="#preview-personel_durum"
onclick="personel_bilgisi({{ id }});">
{{ _("Durumunu Belirle") }}
</a>
""",
id=r.user_id),
render_template_string(
"""
<button class="btn btn-icon btn-danger" type='button'
onclick="idari_personel_sil('{{id}}', '{{unvan}}', '{{ad}}', '{{soyad}}' );">
<span class="float-left detail_edit fa-in-button fa ft-trash fa-1x m-l-10"></span>
</button>
""",
id=r.idari_personel_id,
unvan=r.unvan_ad,
ad=r.ad,
soyad=r.soyad,
)
] for index, r in enumerate(result)]
return jsonify({
"data": data,
"draw": form_data['draw'],
"recordsFiltered": total_record,
"recordsTotal": total_record
})
@property
def qry(self):
"""AkademikPersonel BaseQuery"""
return DB.session.query(BapIdariPersonel). \
join(Personel, Personel.id == BapIdariPersonel.personel_id). \
join(Person, Person.id == Personel.person_id). \
join(User, User.id == Person.user_id). \
join(HitapUnvan, HitapUnvan.id == Personel.unvan).\
add_columns(
User.id.label("user_id"),
User.durumu.label("durumu"),
Person.ad.label("ad"),
Person.soyad.label("soyad"),
HitapUnvan.ad.label("unvan_ad"),
BapIdariPersonel.gorevi.label("gorevi"),
BapIdariPersonel.id.label("idari_personel_id"),
BapIdariPersonel.gorev_aciklamasi.label("gorev_aciklamasi")
).filter(BapIdariPersonel.gorevde_mi == True)
@login_required
@auth.requires(Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["idari_personel_listesi_goruntuleme"]),
menu_registry={
'path':
'.yonetim.personel_yonetimi.idari_personel_listesi',
'title': _("İdari Personel")
})
@route("/", methods=["GET"])
def liste(self):
personel_durum_form = PersonelDurumForm()
search_form = IdariPersonelSearchForm()
idari_personel_ekle_form = IdariPersonelEkle()
return render_template(
"idari_liste.html",
search_form=search_form,
personel_durum_form=personel_durum_form,
idari_personel_ekle_form=idari_personel_ekle_form)
@login_required
@auth.requires(
Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["idari_personel_listesi_goruntuleme"]))
@route("/idari-personel-kaydet",
methods=["POST"],
endpoint="idari_personel_kaydet")
def idari_personel_kaydet(self):
form_data = request.form.to_dict()
idari_personel_ekle_form = IdariPersonelEkle(**form_data)
if not idari_personel_ekle_form.validate():
flash(
"İdari personel eklenirken bir hata ile karşılaşıldı. Lütfen girdiğiniz bilgileri kontrol ediniz"
)
return redirect(
url_for('personel_yonetimi.IdariPersonelView:liste'))
idari_personel = BapIdariPersonel(
personel_id=idari_personel_ekle_form.personel_id.data,
gorevi=idari_personel_ekle_form.gorevi.data,
gorev_aciklamasi=idari_personel_ekle_form.gorev_aciklamasi.data)
try:
DB.session.add(idari_personel)
DB.session.commit()
flash("İşleminiz başarıyla gerçekleştirildi")
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("yonetim").get(
"idari_personel_ekle").type_index,
"nesne":
'Personel',
"nesne_id":
idari_personel.personel_id,
"ekstra_mesaj":
" {} personel idsine sahip personel idari personel olarak eklendi"
.format(idari_personel.personel_id)
}
signal_sender(**signal_payload)
return redirect(
url_for('personel_yonetimi.IdariPersonelView:liste'))
except Exception as exc:
DB.session.rollback()
flash("İdari personel eklenirken bir hata ile karşılaşıldı")
CustomErrorHandler.error_handler(
hata="İdari personel eklenmeye çalışıldı. Hata: {}".format(
exc))
return redirect(
url_for('personel_yonetimi.IdariPersonelView:liste'))
@login_required
@auth.requires(
Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["idari_personel_silme"]))
@route("/idari-personel-sil",
methods=["POST"],
endpoint="idari_personel_sil")
def idari_personel_sil(self):
idari_personel_id = request.get_json()['idari_personel_id']
idari_personel = DB.session.query(BapIdariPersonel).filter(
BapIdariPersonel.id == idari_personel_id).first()
idari_personel.gorevde_mi = False
try:
DB.session.commit()
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("yonetim").get(
"idari_personel_sil").type_index,
"nesne":
'Personel',
"nesne_id":
idari_personel.personel_id,
"ekstra_mesaj":
" {} idari personel idsine sahip personel idari personel görevi pasifleştirildi "
.format(idari_personel.personel_id)
}
signal_sender(**signal_payload)
return jsonify(status="success")
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="İdari personel silinmeye çalışıldı. Hata: {}".format(
exc))
return jsonify(status="error"), 400
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["personel_durum_atama"]))
@route("/durum-ata/<int:personel_id>/",
methods=["POST"],
endpoint='idari_personel_durum_ata')
def durum_ata(personel_id):
"""İdari Personel Aktif veya Pasif durumu atama"""
personel = DB.session.query(Personel).filter(
Personel.id == personel_id).one_or_none()
personel_durum_form = PersonelDurumForm(request.form)
try:
durum = bool(int(personel_durum_form.durum_listesi.data))
personel.user.durumu = durum
DB.session.add(personel)
DB.session.commit()
if durum:
flash(
f"{personel.person.ad} {personel.person.soyad} adlı personelin durumu aktif olarak değiştirildi."
)
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("yonetim").get(
"personel_durumu_belirle").type_index,
"nesne":
'Personel',
"nesne_id":
personel.id,
"ekstra_mesaj":
"""
{} adlı kullanıcı
{} {} adlı ve {} idsine sahip personelin durumunu Aktif olarak değiştirdi."""
.format(
current_user.username,
personel.person.ad,
personel.person.soyad,
personel.id,
)
}
else:
# Useri logout etmek icin cacheten session keyini siliyoruz.
usid = personel.user.session_id
cache = current_app.extensions['redis']
key = "{prefix}:{usid}".format(
prefix=current_app.config.get('SESSION_CACHE_KEY_PREFIX'),
usid=usid)
cache.delete(key)
flash(
f"{personel.person.ad} {personel.person.soyad} adlı personelin durumu pasif olarak değiştirildi."
)
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("yonetim").get(
"personel_durumu_belirle").type_index,
"nesne":
'Personel',
"nesne_id":
personel.id,
"ekstra_mesaj":
"""
{} adlı kullanıcı
{} {} adlı ve {} idsine sahip personelin durumunu Pasif olarak değiştirdi."""
.format(
current_user.username,
personel.person.ad,
personel.person.soyad,
personel.id,
)
}
signal_sender(**signal_payload)
return redirect(
url_for('personel_yonetimi.IdariPersonelView:liste'))
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="İdari personel durumu değiştirilmeye çalışıldı. Hata: {}"
.format(exc))
return redirect(
url_for('personel_yonetimi.IdariPersonelView:liste'))
@login_required
@auth.requires(
Permission(*permission_dict["yonetim"]["personel_yonetimi"]
["idari_personel_listesi_goruntuleme"]))
@route('/data', methods=["POST"], endpoint="idari_search")
def personel_arama(self): # pylint: disable=too-many-branches
"""
Bap personel için POST ile gelen parametrelere gore arama yapip, sonuclari dondurur.
Returns:
http response
"""
qry = self.qry
total_record = qry.count()
form_data = request.form.to_dict()
search_form = IdariPersonelSearchForm(**form_data)
ad = search_form.ad.data.strip()
soyad = search_form.soyad.data.strip()
unvan_id = search_form.unvan_id.data
durumu = search_form.durumu.data
gorevi = search_form.gorevi.data
if durumu != '-1':
if durumu == '1':
qry = qry.filter(User.durumu.is_(True))
else:
qry = qry.filter(User.durumu.is_(False))
if gorevi != '0':
qry = qry.filter(BapIdariPersonel.gorevi == gorevi)
if not search_form.validate():
result = qry.offset(form_data['start']).limit(
form_data['length']).all()
total_record = qry.count()
return self.process_data(result, form_data, total_record)
if unvan_id:
qry = qry.filter(HitapUnvan.id == unvan_id)
if ad:
qry = qry.filter(Person.ad.ilike('%' + ad + '%'))
if soyad:
qry = qry.filter(Person.soyad.ilike('%' + soyad + '%'))
result = qry.offset(form_data['start']).limit(
form_data['length']).all()
return self.process_data(result, form_data, total_record)
class BasvuruPersonelView(FlaskView):
"""Basvuru Personel Kaydet View Class"""
excluded_methods = ["ozgecmis_kaydet"]
@staticmethod
def ozgecmis_kaydet(ozgecmis_text, ozgecmis_file_id):
"""Proje calisanlarinin ozgecmislerini kaydeder. ozgecmis id doner"""
calisan_ozgecmis = Ozgecmis(tecrube=ozgecmis_text,
file_id=ozgecmis_file_id,
user_id=current_user.id)
DB.session.add(calisan_ozgecmis)
DB.session.flush()
return calisan_ozgecmis.id
@login_required
@auth.requires(
And(
Permission(*permission_dict["bap"]["proje"]["basvuru"]
["proje_basvurusu_yapma"]), ProjeYurutucusu(),
TamamlanmamisProjeBasvurusu()))
@route('/<int:proje_id>/arastirmaci-kaydet/', methods=['POST'])
def arastirmaci_kaydet(self, proje_id):
"""
Proje çalışanlarına araştırmacı kaydetmek için kullanılır
"""
arastirmaci_data = request.get_json()
personel_id = arastirmaci_data.get("personel_id")
try:
proje = DB.session.query(Proje).filter(Proje.id == proje_id).one()
if proje.proje_yurutucu.personel.id == int(personel_id):
return jsonify(
status="error",
error_message=_(
"Proje yürütücüsünü personel olarak ekleyemezsiniz")
), 400
try:
personel = DB.session.query(Personel).options(
load_only("id", "person_id"), lazyload(Personel.birimi),
lazyload(Personel.user),
joinedload(Personel.person).load_only(
"ad", "soyad")).filter_by(id=personel_id).one()
except NoResultFound as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata=
"Var olmayan bir personel id si ile projeye arastirmaci eklenmeye calışıldı. "
"Hata: {}, Proje id: {}".format(exc, proje_id))
return jsonify(status="error"), 400
if personel_proje_calisani_mi(proje_id, personel_id):
return jsonify(
status="error",
error_message=_(
"Eklemeye çalıştığınız personel zaten proje çalışanı.")
), 400
arastirmaci_ozgecmis_id = self.ozgecmis_kaydet(
ozgecmis_text=arastirmaci_data.pop("ozgecmis_text", None),
ozgecmis_file_id=arastirmaci_data.pop("ozgecmis_file_id",
None))
yeni_arastirmaci = ProjeCalisanlari(
proje_id=proje_id,
universite_disindan_mi=False,
ozgecmis_id=arastirmaci_ozgecmis_id,
**arastirmaci_data)
personel_ad = personel.person.ad
personel_soyad = personel.person.soyad
DB.session.add(yeni_arastirmaci)
DB.session.commit()
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"projeye_arastirmaci_eklendi").type_index,
"nesne":
'Proje Calisanlari',
"nesne_id":
yeni_arastirmaci.id,
"etkilenen_nesne":
"Personel",
"etkilenen_nesne_id":
personel.id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} {} adlı personeli {} id'li projeye "
"araştırmacı olarak ekledi.".format(current_user.username,
personel_ad,
personel_soyad, proje_id)
}
signal_sender(**signal_payload)
return jsonify(status="success",
calisan={
"id": yeni_arastirmaci.id,
"ad": personel_ad,
"soyad": personel_soyad,
"gorevi": yeni_arastirmaci.projedeki_gorevi
})
except SQLAlchemyError as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Proje idsi %s olan projeye arastirmaci atamaya"
"çalışılırken bir sorun oluştu. Hata: %s" % (proje_id, exc))
return jsonify(status="error"), 400
@login_required
@auth.requires(
And(
Permission(*permission_dict["bap"]["proje"]["basvuru"]
["proje_basvurusu_yapma"]), ProjeYurutucusu(),
TamamlanmamisProjeBasvurusu()))
@route('/<int:proje_id>/bursiyer-kaydet/', methods=['POST'])
def bursiyer_kaydet(self, proje_id):
"""
Proje çalışanlarına bursiyer kaydetmek için kullanılır
"""
bursiyer_data = request.get_json()
ogrenci_id = bursiyer_data.get("ogrenci_id")
try:
try:
ogrenci = DB.session.query(Ogrenci).options(
load_only("id", "person_id"), lazyload(Ogrenci.user),
joinedload(Ogrenci.person).load_only(
"ad", "soyad")).filter_by(id=ogrenci_id).one()
except NoResultFound as exc:
CustomErrorHandler.error_handler(
hata=
"Var olmayan bir öğrenci id si ile projeye bursiyer eklenmeye calışıldı. "
"Hata: {}, Proje id: {}".format(proje_id, exc))
return jsonify(status="error"), 400
bursiyer_calisan = DB.session.query(ProjeCalisanlari.id).filter(
ProjeCalisanlari.ogrenci_id == ogrenci_id,
ProjeCalisanlari.proje_id == proje_id).scalar()
if bursiyer_calisan:
return jsonify(
status="error",
error_message=_(
"Eklemeye çalıştığınız öğrenci zaten proje çalışanı.")
), 400
bursiyer_ozgecmis_id = self.ozgecmis_kaydet(
ozgecmis_text=bursiyer_data.pop("ozgecmis_text", None),
ozgecmis_file_id=bursiyer_data.pop("ozgecmis_file_id", None))
yeni_bursiyer = ProjeCalisanlari(proje_id=proje_id,
universite_disindan_mi=False,
ozgecmis_id=bursiyer_ozgecmis_id,
**bursiyer_data)
ogrenci_ad = ogrenci.person.ad
ogrenci_soyad = ogrenci.person.soyad
DB.session.add(yeni_bursiyer)
DB.session.commit()
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"projeye_bursiyer_eklendi").type_index,
"nesne":
'Proje Calisanlari',
"nesne_id":
yeni_bursiyer.id,
"etkilenen_nesne":
"Proje",
"etkilenen_nesne_id":
proje_id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} {} adlı öğrenciyi bursiyer olarak "
"ekledi.".format(current_user.username, ogrenci_ad,
ogrenci_soyad)
}
signal_sender(**signal_payload)
return jsonify(status="success",
calisan={
"id": yeni_bursiyer.id,
"ad": ogrenci_ad,
"soyad": ogrenci_soyad,
"gorevi": yeni_bursiyer.projedeki_gorevi
})
except SQLAlchemyError as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Proje idsi %s olan projeye bursiyer atamaya"
"çalışılırken bir sorun oluştu. Hata: %s" % (proje_id, exc))
return jsonify(status="error"), 400
@login_required
@auth.requires(
And(
Permission(*permission_dict["bap"]["proje"]["basvuru"]
["proje_basvurusu_yapma"]), ProjeYurutucusu(),
TamamlanmamisProjeBasvurusu()))
@route('/<int:proje_id>/harici-arastirmaci-kaydet/', methods=['POST'])
def harici_arastirmaci_kaydet(self, proje_id):
"""
Proje çalışanlarına üniversite dışı araştırmacı kaydetmek için kullanılır.
"""
harici_arastirmaci_data = request.get_json()
adi = harici_arastirmaci_data.pop("ad")
soyad = harici_arastirmaci_data.pop("soyad")
email = harici_arastirmaci_data.pop("email")
try:
yeni_person = Person(ad=adi, soyad=soyad, birincil_eposta=email)
DB.session.add(yeni_person)
DB.session.flush()
harici_arastirmaci_ozgecmis_id = self.ozgecmis_kaydet(
ozgecmis_text=harici_arastirmaci_data.pop(
"ozgecmis_text", None),
ozgecmis_file_id=harici_arastirmaci_data.pop(
"ozgecmis_file_id", None))
yeni_harici_arastirmaci = ProjeCalisanlari(
proje_id=proje_id,
ozgecmis_id=harici_arastirmaci_ozgecmis_id,
person_id=yeni_person.id,
**harici_arastirmaci_data)
DB.session.add(yeni_harici_arastirmaci)
DB.session.commit()
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"projeye_harici_arastirmaci_eklendi").type_index,
"nesne":
'Proje Calisanlari',
"nesne_id":
yeni_harici_arastirmaci.id,
"etkilenen_nesne":
"Proje",
"etkilenen_nesne_id":
proje_id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} {} adlı kisiyi üniversite dışı arastırmacı "
"olarak kaydetti.".format(current_user.username, adi, soyad)
}
signal_sender(**signal_payload)
return jsonify(status="success",
calisan={
"id": yeni_harici_arastirmaci.id,
"ad": adi,
"soyad": soyad,
"gorevi":
yeni_harici_arastirmaci.projedeki_gorevi
})
except SQLAlchemyError as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Proje idsi %s olan projeye harici araştırmacı atamaya"
"çalışılırken bir sorun oluştu. Hata: %s" % (proje_id, exc))
return jsonify(status="error"), 400
@staticmethod
@login_required
@auth.requires(
And(
Permission(*permission_dict["bap"]["proje"]["basvuru"]
["proje_basvurusu_yapma"]), ProjeYurutucusu(),
TamamlanmamisProjeBasvurusu()))
@route('/<int:proje_id>/calisan-sil/<int:calisan_id>', methods=['DELETE'])
def proje_calisani_sil(proje_id, calisan_id):
"""
Daha önce projeye kaydedilmiş çalışanı siler.
"""
try:
try:
silinecek_calisan = DB.session.query(
ProjeCalisanlari).filter_by(id=calisan_id,
proje_id=proje_id).one()
except NoResultFound as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Var olmayan bir id ile proje çalışanı silinmeye "
"çalışıldı. Proje id: {}, Hata: {}".format(proje_id, exc))
return jsonify(status="error"), 400
DB.session.delete(silinecek_calisan)
if silinecek_calisan.person:
DB.session.delete(silinecek_calisan.person)
DB.session.commit()
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"proje_calisani_sil").type_index,
"nesne":
'Proje Calisanlari',
"nesne_id":
calisan_id,
"etkilenen_nesne":
"Proje",
"etkilenen_nesne_id":
proje_id,
"ekstra_mesaj":
"{} adlı kullanıcı, proje çalışanını projeden sildi.".format(
current_user.username)
}
signal_sender(**signal_payload)
return jsonify(status="success")
except SQLAlchemyError as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata=
"Proje çalışanı silinmeye çalışırken hata ile karşılaşıldı. "
"Proje id: {}, Calisan id: {}, Hata: {}".format(
proje_id, calisan_id, exc))
return jsonify(status="error"), 400
@staticmethod
@login_required
@auth.requires(
And(
Permission(*permission_dict["bap"]["proje"]["basvuru"]
["proje_basvurusu_yapma"]), ProjeYurutucusu(),
TamamlanmamisProjeBasvurusu()))
@route('/<int:proje_id>/calisan/<int:calisan_id>', methods=['GET'])
def get_proje_calisani(proje_id, calisan_id):
"""
Var olan bir çalışanı almak için kullanılır.
"""
try:
try:
calisan = DB.session.query(ProjeCalisanlari).options(
lazyload(ProjeCalisanlari.ogrenci),
lazyload(ProjeCalisanlari.personel),
joinedload(ProjeCalisanlari.person).load_only(
"ad", "soyad"),
joinedload(ProjeCalisanlari.fakulte).load_only("ad"),
joinedload(ProjeCalisanlari.bolum).load_only("ad"),
joinedload(ProjeCalisanlari.hitap_unvan).load_only(
"ad", "kod")).filter_by(id=calisan_id,
proje_id=proje_id).one()
except NoResultFound as exc:
CustomErrorHandler.error_handler(
hata="Var olmayan bir id ile proje çalışanı alınmaya "
"çalışıldı. Proje id: {}, Hata: {}".format(proje_id, exc))
return abort(404)
except SQLAlchemyError as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata=
"Proje çalışanı silinmeye çalışırken hata ile karşılaşıldı. "
"Proje id: {}, Calisan id: {}, Hata: {}".format(
proje_id, calisan_id, exc))
return abort(400)
data = calisan.to_dict()
data["projeye_katkisi"] = float(
calisan.projeye_katkisi) if calisan.projeye_katkisi else float(0)
data.update({
"ozgecmis_text": calisan.ozgecmis.tecrube,
"ozgecmis_file_id": calisan.ozgecmis.file_id
})
if calisan.person:
hitap_unvan_ad = ""
if calisan.hitap_unvan:
hitap_unvan_ad = "{} {}".format(
calisan.hitap_unvan.kod,
calisan.hitap_unvan.ad if calisan.hitap_unvan else "")
data.update({
"hitap_unvan_ad":
hitap_unvan_ad,
"fakulte_ad":
calisan.fakulte.ad if calisan.fakulte else "",
"bolum_ad":
calisan.bolum.ad if calisan.bolum else "",
"ad":
calisan.person.ad,
"soyad":
calisan.person.soyad,
})
return jsonify(status="success", calisan=data)
@staticmethod
@login_required
@auth.requires(
And(
Permission(*permission_dict["bap"]["proje"]["basvuru"]
["proje_basvurusu_yapma"]), ProjeYurutucusu(),
TamamlanmamisProjeBasvurusu()))
@route('/<int:proje_id>/calisan/<int:calisan_id>', methods=['POST'])
def calisan_guncelle(proje_id, calisan_id):
"""
Çalışan güncellemek için kullanılır.
"""
calisan_data = request.get_json()
try:
try:
calisan = DB.session.query(ProjeCalisanlari).filter_by(
id=calisan_id, proje_id=proje_id).one()
except NoResultFound as exc:
CustomErrorHandler.error_handler(
hata="Var olmayan bir id ile proje çalışanı alınmaya "
"çalışıldı. Proje id: {}, Hata: {}".format(proje_id, exc))
return abort(404)
if calisan.person_id:
calisan.person.ad = calisan_data.get("ad")
calisan.person.soyad = calisan_data.get("soyad")
# todo: calisan guncellenirken ozgecmisinde bir degisklik var ise guncelle.
calisan.ozgecmis.tecrube = calisan_data.pop("ozgecmis_text", None)
calisan.ozgecmis.file_id = calisan_data.pop(
"ozgecmis_file_id", None)
calisan.update_obj_data(calisan_data)
DB.session.commit()
except SQLAlchemyError as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata=
"Proje çalışanı silinmeye çalışırken hata ile karşılaşıldı. "
"Proje id: {}, Calisan id: {}, Hata: {}".format(
proje_id, calisan_id, exc))
return abort(400)
data = {"id": calisan.id, "gorevi": calisan.projedeki_gorevi}
if calisan.person_id:
data.update({
"ad": calisan.person.ad,
"soyad": calisan.person.soyad
})
elif calisan.personel_id:
data.update({
"ad": calisan.personel.person.ad,
"soyad": calisan.personel.person.soyad
})
else:
data.update({
"ad": calisan.ogrenci.person.ad,
"soyad": calisan.ogrenci.person.soyad
})
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"proje_calisan_guncelle").type_index,
"nesne":
'Proje Calisanlari',
"nesne_id":
calisan_id,
"etkilenen_nesne":
"Proje",
"etkilenen_nesne_id":
proje_id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} {} adlı proje çalışanının bilgilerini "
"güncelledi.".format(current_user.username, data["ad"],
data["soyad"])
}
signal_sender(**signal_payload)
return jsonify(status="success", calisan=data)
class BapFirmaIslemleriView(FlaskView):
"""Bap firma islemleri view classi"""
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["bap"]["firma"]["firma_anasayfa_goruntuleme"]),
menu_registry={'path': '.bap.firma_dashboard', 'title': _("Anasayfa"),
"order": 0})
@route('/dashboard', methods=['GET'])
def firma_dashboard():
user_id = current_user.id
firma = DB.session.query(BapFirma).filter(BapFirma.user_id == user_id).one()
firma_satinalma_teklifleri = DB.session.query(FirmaSatinalmaTeklif).filter(
FirmaSatinalmaTeklif.firma_id == firma.id).order_by(
desc(FirmaSatinalmaTeklif.created_at)).all()
firma_teklifleri = []
for satinalama_teklif in firma_satinalma_teklifleri:
toplam_tutar = Decimal("0.00")
for teklif_kalemi in satinalama_teklif.teklif_kalemleri:
toplam_tutar += teklif_kalemi.teklif
data = {
"teklif_id": satinalama_teklif.id,
"teklif_tarihi": satinalama_teklif.updated_at,
"satinalma_durum": satinalama_teklif.satinalma.durumu.description,
"teklif_verilen_kalem_sayisi": len(satinalama_teklif.teklif_kalemleri),
"satinalma_kalem_sayisi": len(satinalama_teklif.satinalma.talep_kalemleri),
"toplam_tutar": toplam_tutar,
"hizmet_kalemi_adi": satinalama_teklif.teklif_kalemleri[
0].satinalma_talep_kalemi.proje_kalemi.proje_turu_butce_kalemi.gider_siniflandirma_kalemi.aciklama,
"teklif_tamamlandimi": satinalama_teklif.teklif_tamamlandi_mi,
"firma_id": firma.id,
"satinalma_id": satinalama_teklif.satinalma_id
}
firma_teklifleri.append(data)
return render_template("firma_dashboard.html", firma_teklifleri=firma_teklifleri)
@staticmethod
@route('/firma-kayit', methods=['GET'])
def get_firma_kayit():
"""Firma Kayit Ekranini Getirir"""
firma_kayit_formu = FirmaKayitFormu()
return render_template("firma_kayit.html", firma_kayit_formu=firma_kayit_formu)
@staticmethod
@route('/firma-kayit', methods=['POST'])
def firma_kaydet():
"""Firma Kaydeder"""
firma_kayit_formu = FirmaKayitFormu(request.form)
file = None
if not firma_kayit_formu.validate():
return render_template("firma_kayit.html", firma_kayit_formu=firma_kayit_formu)
yetkili_kullanici_bilgileri = firma_kayit_formu.yetkili_user_bilgileri.data
kullanici_varmi = DB.session.query(User).filter(or_(
User.username == yetkili_kullanici_bilgileri["yetkili_kullanici_adi"],
User.email == yetkili_kullanici_bilgileri["yetkili_email"]
)).first()
if kullanici_varmi:
DB.session.rollback()
flash("Geçersiz kullanıcı adı veya yetkili email adresi. "
"Lütfen başka bir kullanıcı ismi veya email ile yeniden deneyiniz.")
return render_template("firma_kayit.html", firma_kayit_formu=firma_kayit_formu)
firma_faaliyet_belgesi = request.files.get(firma_kayit_formu.firma_faaliyet_belgesi_id.name)
if firma_faaliyet_belgesi:
file = File(content=firma_faaliyet_belgesi)
DB.session.add(file)
DB.session.flush()
else:
flash("Firma faaliyet belgesi yüklemek zorundasınız")
return render_template("firma_kayit.html", firma_kayit_formu=firma_kayit_formu)
password = sha512(yetkili_kullanici_bilgileri["password"].encode()).hexdigest()
# girilen bilgilerden firma icin yetkili bir kullanici yaratilir
yetkili_kullanici_bilgileri.pop("re_password")
firma_yetkili_kullanici = User(
username=yetkili_kullanici_bilgileri["yetkili_kullanici_adi"],
email=yetkili_kullanici_bilgileri["yetkili_email"],
password=password)
DB.session.add(firma_yetkili_kullanici)
DB.session.flush()
yeni_person = Person(user_id=firma_yetkili_kullanici.id,
ad=firma_kayit_formu.yetkili_adi.data,
soyad=firma_kayit_formu.yetkili_soyadi.data,
birincil_eposta=firma_kayit_formu.yetkili_user_bilgileri.yetkili_email.data)
DB.session.add(yeni_person)
# firma rolunun id si bulunur
firma_rolu = DB.session.query(RoleModel).filter(RoleModel.name == "BAP Firma").first()
# firma rolu ve yetkili kullanici arasinda user_role instance olusturulur
user_role = UserRole(user_id=firma_yetkili_kullanici.id,
role_id=firma_rolu.id,
rol_tipi=RolTipleri.firma,
is_default=True)
DB.session.add(user_role)
# girilen bilgilerle yeni firma olusturulur
yeni_firma = BapFirma(user_id=firma_yetkili_kullanici.id,
firma_faaliyet_belgesi_id=file.id,
vergi_dairesi_id=firma_kayit_formu.vergi_dairesi_id.data,
adres=firma_kayit_formu.adres.data,
adi=firma_kayit_formu.adi.data,
telefon=firma_kayit_formu.telefon.data,
email=firma_kayit_formu.email.data,
vergi_kimlik_numarasi=firma_kayit_formu.vergi_kimlik_numarasi.data,
faaliyet_belgesi_verilis_tarihi=firma_kayit_formu.faaliyet_belgesi_verilis_tarihi.data,
iban=firma_kayit_formu.iban.data,
banka_sube_adi=firma_kayit_formu.banka_sube_adi.data,
yetkili_adi=firma_kayit_formu.yetkili_adi.data,
yetkili_soyadi=firma_kayit_formu.yetkili_soyadi.data,
)
DB.session.add(yeni_firma)
DB.session.commit()
signal_payload = {
"message_type": USER_ACTIVITY_MESSAGES.get("bap").get(
"firma_kaydet").type_index,
"nesne": 'BapFirma',
"nesne_id": yeni_firma.id,
"ekstra_mesaj": "{} adlı kullanıcı, yeni firma kaydı yaptı.".format(
current_user.username)
}
signal_sender(**signal_payload)
flash("Firma kayıt işleminiz başarıyla gerçekleşti. "
"Firma bilgileriniz onaylandıktan sonra sisteme giriş yapabilirsiniz.")
return render_template("firma_kayit.html", firma_kayit_formu=firma_kayit_formu)
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["bap"]["firma"]["satinalma_duyuru_listeleme"]),
menu_registry={'path': '.bap.satinalma_duyurulari',
'title': _("Satınalma Duyuruları"), "order": 1})
@route('/satinalma/duyuru', methods=['GET'])
def satinalma_duyuru_listele():
# duyuru stateindeki satinalmalari getirebilmek icin ilgili(Satınalma duyurusu yapıldı)
# state in id si bulunur
duyuru_state = DB.session.query(AppState).filter(AppState.state_code == "ST5").one()
# bu sayfaya ulasan kisi firma yetkilisi ise daha once teklif yaptigi satinalmalari
# gostermemek icin teklif yaptigi satinalmalarin id si getirilir.
firma = DB.session.query(BapFirma).filter(BapFirma.user_id == current_user.id).first()
teklif_yapilan_satinalmalar = []
if firma:
teklif_yapilan_satinalmalar = [satinalma_teklif.satinalma_id for satinalma_teklif in
firma.firma_teklifleri]
duyuru_asamasindaki_satinalmalar = DB.session.query(
ProjeSatinAlmaTalebi.id.label("satinalma_id"),
Icerik.baslangic_tarihi.label("duyuru_baslangic_tarihi"),
Icerik.bitis_tarihi.label("duyuru_bitis_tarihi"),
Icerik.icerik.label("duyuru_icerigi"),
Icerik.baslik.label("duyuru_baslik"),
Proje.proje_no.label("proje_no")
).join(Icerik, ProjeSatinAlmaTalebi.duyuru_id == Icerik.id).filter(
ProjeSatinAlmaTalebi.durum_id == duyuru_state.id,
Icerik.baslangic_tarihi < datetime.now(),
Icerik.bitis_tarihi > datetime.now(),
Icerik.aktif_mi == True
).join(
Proje, ProjeSatinAlmaTalebi.proje_id == Proje.id
).all()
return render_template("satinalma_duyuru_listesi.html",
satinalma_listesi=duyuru_asamasindaki_satinalmalar,
teklif_yapilan_satinalmalar=teklif_yapilan_satinalmalar,
firma_id=firma.id)
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["bap"]["firma"]["satinalmaya_teklif_yapma"]),
FirmaYetkilisi())
@route('/<int:firma_id>/satinalma/<int:satinalma_id>/basvuru', methods=['GET'])
def get_satinalma_teklif_yap(satinalma_id, firma_id):
satinalma = BapQueryHelpers.get_satinalma_with_related_field(satinalma_id)
teklif_formu = TeklifFormu()
for talep_kalemi in satinalma.talep_kalemleri:
data = {
"talep_kalemi": {
"talep_kalemi_id": talep_kalemi.id,
"kalem_adi": talep_kalemi.proje_kalemi.ad,
"sayi": talep_kalemi.talep_miktari,
"birim": talep_kalemi.proje_kalemi.birim.name,
"teknik_sartname_id": talep_kalemi.teknik_sartname_file_id
}
}
teklif_formu.urunler.append_entry(data)
return render_template("satinalma_teklif.html", teklif_formu=teklif_formu,
firma_id=firma_id)
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["bap"]["firma"]["satinalmaya_teklif_yapma"]),
FirmaYetkilisi())
@route('/<int:firma_id>/satinalma/<int:satinalma_id>/basvuru', methods=['POST'])
def post_satinalma_teklif_yap(satinalma_id, firma_id):
teklif_formu = TeklifFormu(request.form)
kaydedilecek_teklifler = []
hata_mesajlari = []
firma = DB.session.query(BapFirma).filter(BapFirma.user_id == current_user.id).first()
if not firma:
hata_mesajlari.append(_("Teklif verebilmeniz için firma yetkilisi olmanız gerekir"))
return render_template("satinalma_teklif.html", teklif_formu=teklif_formu,
hata_mesajlari=hata_mesajlari)
daha_once_teklif_verildi_mi = DB.session.query(FirmaSatinalmaTeklif).filter(
FirmaSatinalmaTeklif.firma_id == firma.id,
FirmaSatinalmaTeklif.satinalma_id == satinalma_id).all()
if daha_once_teklif_verildi_mi:
hata_mesajlari.append(_("Daha önce teklif verdiginiz için tekrar teklif veremezsiniz."))
return render_template("satinalma_teklif.html", teklif_formu=teklif_formu,
hata_mesajlari=hata_mesajlari)
for teklif in teklif_formu.urunler:
if teklif.birim_fiyati.data:
if not all(
[teklif.kdv_orani.data, teklif.teslimat_suresi.data,
teklif.marka_model.data]):
hata_mesajlari.append(_(
"Teklif vermek istediğiniz ürünün bütün alanlarını doldurmak zorundasınız"))
break
else:
kaydedilecek_teklifler.append(teklif)
if not kaydedilecek_teklifler:
hata_mesajlari.append(_("Kaydı tamamlamak için en az bir ürüne teklif vermelisiniz"))
satinalma = BapQueryHelpers.get_satinalma_with_related_field(satinalma_id)
if hata_mesajlari:
for talep_kalemi in satinalma.talep_kalemleri:
for teklif in teklif_formu.urunler:
if teklif.talep_kalemi.talep_kalemi_id.data == talep_kalemi.id:
teklif.talep_kalemi.kalem_adi.data = talep_kalemi.proje_kalemi.ad
teklif.talep_kalemi.sayi.data = talep_kalemi.talep_miktari
teklif.talep_kalemi.birim.data = talep_kalemi.proje_kalemi.birim.name
teklif.talep_kalemi.teknik_sartname_id.data = talep_kalemi.teknik_sartname_file_id
return render_template("satinalma_teklif.html", teklif_formu=teklif_formu,
hata_mesajlari=hata_mesajlari)
try:
yeni_satinalma_teklif = FirmaSatinalmaTeklif(firma_id=firma.id,
satinalma_id=satinalma_id,
aciklama=teklif_formu.aciklama.data)
DB.session.add(yeni_satinalma_teklif)
DB.session.flush()
for teklif in kaydedilecek_teklifler:
for talep_kalemi in satinalma.talep_kalemleri:
if teklif.talep_kalemi.talep_kalemi_id.data == talep_kalemi.id:
toplam_fiyat = teklif.birim_fiyati.data * talep_kalemi.talep_miktari
yeni_teklif = FirmaTeklifKalemi(teklif_id=yeni_satinalma_teklif.id,
satinalma_talep_kalemi_id=talep_kalemi.id,
marka_model=teklif.marka_model.data,
kdv_orani=teklif.kdv_orani.data,
teklif=toplam_fiyat,
teslimat_suresi=teklif.teslimat_suresi.data)
DB.session.add(yeni_teklif)
DB.session.commit()
flash("Teklifleriniz başarıyla kaydedilmiştir. "
"Teklifi tamamlamak için gerekli dosyaları yükleyiniz")
except Exception as exc:
DB.session.rollback()
hata_mesajlari.append(_("Kayıt işlemi yapılırken bir hata oluştu. "
"Lütfen daha sonra tekrar deneyiniz"))
CustomErrorHandler.error_handler(
hata="Satinalmaya firma teklif verirken bir hata oluştu"
"Satinalma:{}, User:{}, Firma: {}, Hata:{}".format(
satinalma_id, current_user.username, firma.id,
exc))
return render_template("satinalma_teklif.html", teklif_formu=teklif_formu,
hata_mesajlari=hata_mesajlari)
return redirect(url_for("firma.BapFirmaIslemleriView:get_satinalma_teklif_dosya_yukle",
satinalma_id=satinalma_id, firma_id=firma.id))
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["bap"]["firma"]["satinalmaya_teklif_yapma"]),
FirmaYetkilisi())
@route('/<int:firma_id>/satinalma/<int:satinalma_id>/basvuru-tamamla', methods=['GET'])
def get_satinalma_teklif_dosya_yukle(satinalma_id, firma_id):
firma_teklif = DB.session.query(FirmaSatinalmaTeklif).filter(
FirmaSatinalmaTeklif.satinalma_id == satinalma_id,
FirmaSatinalmaTeklif.firma_id == firma_id).first()
guncel_teklif_mektup_sablonu = DB.session.query(Sablon.id.label("sablon_id")).filter(
Sablon.sablon_tipi_id == 48,
Sablon.kullanilabilir_mi == True,
Sablon.query_id != None
).order_by(
desc(Sablon.created_at)
).first()
if not firma_teklif:
return redirect(url_for("firma.BapFirmaIslemleriView:firma_dashboard"))
teklif_dosya_formu = TeklifDosyalari()
teklif_kalemleri_data = get_teklif_kalemleri_data(firma_teklif.teklif_kalemleri)
return render_template("teklif_dosya_kaydet.html",
teklif_dosya_formu=teklif_dosya_formu,
teklif_kalemleri_data=teklif_kalemleri_data,
firma_id=firma_id,
satinalma_id=satinalma_id,
firma_teklif_id=firma_teklif.id,
teklif_mektubu_sablon_id=guncel_teklif_mektup_sablonu.sablon_id)
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["bap"]["firma"]["satinalmaya_teklif_yapma"]),
FirmaYetkilisi())
@route('/satinalma/<int:satinalma_id>/firma/<int:firma_id>/basvuru/tamamla', methods=['POST'])
def post_satinalma_teklif_dosya_yukle(satinalma_id, firma_id):
firma_teklif = DB.session.query(FirmaSatinalmaTeklif).filter(
FirmaSatinalmaTeklif.satinalma_id == satinalma_id,
FirmaSatinalmaTeklif.firma_id == firma_id,
FirmaSatinalmaTeklif.teklif_tamamlandi_mi == False
).first()
if not firma_teklif:
return redirect(url_for("firma.BapFirmaIslemleriView:firma_dashboard"))
teklif_dosya_formu = TeklifDosyalari(request.form)
if not teklif_dosya_formu.validate():
teklif_kalemleri_data = get_teklif_kalemleri_data(firma_teklif.teklif_kalemleri)
return render_template("teklif_dosya_kaydet.html",
teklif_dosya_formu=teklif_dosya_formu,
teklif_kalemleri_data=teklif_kalemleri_data,
firma_id=firma_id,
satinalma_id=satinalma_id)
hata_mesajlari = []
for teklif_dosya in teklif_dosya_formu.dosyalar:
if teklif_dosya.kategori.data == DosyaKategori.teklif_mektubu:
break
else:
hata_mesajlari.append(_("Teklif mektubu dosyası yüklemek zorundasınız"))
if hata_mesajlari:
teklif_kalemleri_data = get_teklif_kalemleri_data(firma_teklif.teklif_kalemleri)
return render_template("teklif_dosya_kaydet.html",
teklif_dosya_formu=teklif_dosya_formu,
teklif_kalemleri_data=teklif_kalemleri_data,
firma_id=firma_id,
satinalma_id=satinalma_id,
hata_mesajlari=hata_mesajlari)
try:
for teklif_dosya in teklif_dosya_formu.dosyalar:
file = request.files.get(teklif_dosya.dosya.name)
yeni_file = File(user_id=current_user.id, content=file)
DB.session.add(yeni_file)
DB.session.flush()
firma_teklif_dosya = FirmaTeklifDosya(teklif_id=firma_teklif.id,
file_id=yeni_file.id,
aciklama=teklif_dosya.aciklama.data,
dosya_kategori=teklif_dosya.kategori.data.name)
DB.session.add(firma_teklif_dosya)
firma_teklif.teklif_tamamlandi_mi = True
payload = {
"message_type": USER_ACTIVITY_MESSAGES.get("bap").get(
"firma_satinalma_teklifi_yapti").type_index,
"ekstra_mesaj": "{} id li satınalmaya {} isimli kullanıcı tarafından teklif yapıldı.".format(
satinalma_id,
current_user.username),
"nesne": "FirmaSatinalmaTeklif",
"nesne_id": firma_teklif.id,
}
signal_sender(**payload)
proje = DB.session.query(Proje.proje_no.label("proje_no")).filter(
Proje.id == firma_teklif.satinalma.proje_id).first()
for bap_admin in bap_yetkili_and_admin_ids():
payload = {
"notification_receiver": bap_admin.person_id,
"notification_title": "Satınalma talebine firma teklif yaptı",
"notification_message": "{} numaralı projenin {} numaralı satınalma talebine {}"
" isimli firmanın yetkilisi tarafından teklif yapıldı.".format(
proje.proje_no,
firma_teklif.satinalma.talep_numarasi,
firma_teklif.firma.adi),
}
signal_sender(log=False, notification=True, **payload)
DB.session.commit()
flash("Satınalma teklifiniz başarıyla kaydedilmiştir.")
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Satınalma firma teklifine dosya eklenirken bir hata meydana geldi."
"Satinalma:{}, User:{}, Firma Teklif: {}, Hata:{}".format(satinalma_id,
current_user.username,
firma_teklif.id,
exc))
flash("Beklenmedik bir hata oluştu. Lütfen daha sonra tekrar deneyiniz.")
return redirect(url_for("firma.BapFirmaIslemleriView:firma_dashboard"))
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["bap"]["firma"]["satinalma_teklif_goruntuleme"]),
FirmaYetkilisi())
@route('/<int:firma_id>/teklif/<int:teklif_id>', methods=['GET'])
def firma_teklif_detay_goruntule(teklif_id, firma_id):
firma_teklif = DB.session.query(FirmaSatinalmaTeklif).filter(
FirmaSatinalmaTeklif.id == teklif_id,
FirmaSatinalmaTeklif.firma_id == firma_id,
FirmaSatinalmaTeklif.teklif_tamamlandi_mi == True).first()
if not firma_teklif:
return redirect(url_for("firma.BapFirmaIslemleriView:firma_dashboard"))
teklif_kalemleri_data = get_teklif_kalemleri_data(firma_teklif.teklif_kalemleri)
return render_template("teklif_detay.html",
teklif_kalemleri_data=teklif_kalemleri_data,
teklif_dosyalari=firma_teklif.teklif_dosyalari)
class SatinAlinanMalzemelerView(FlaskView):
"""Bap Satinalma Satınalınan Malzemeler view class"""
excluded_methods = [
"qry"
]
@property
def qry(self):
"""
ilgili alanlari icin query nesnesi olustur.
Returns:
"""
return DB.session.query(SiparisTakip). \
join(TalepKalemleri, TalepKalemleri.id == SiparisTakip.satinalma_talep_kalemleri_id). \
join(FirmaTeklifKalemi, FirmaTeklifKalemi.id == SiparisTakip.kazanan_firma_teklif_id). \
join(FirmaSatinalmaTeklif, FirmaSatinalmaTeklif.id == FirmaTeklifKalemi.teklif_id). \
join(BapFirma, BapFirma.id == FirmaSatinalmaTeklif.firma_id). \
join(ProjeKalemi, ProjeKalemi.id == TalepKalemleri.proje_kalemi_id). \
join(ProjeSatinAlmaTalebi, TalepKalemleri.satinalma_id == ProjeSatinAlmaTalebi.id). \
join(Proje, Proje.id == ProjeSatinAlmaTalebi.proje_id). \
join(OgretimElemani, Proje.yurutucu == OgretimElemani.id). \
join(Personel, OgretimElemani.personel_id == Personel.id). \
join(Person, Person.id == Personel.person_id). \
join(HitapUnvan, Personel.unvan == HitapUnvan.id). \
add_columns(
ProjeKalemi.ad.label("malzeme_adi"),
SiparisTakip.siparis_numarasi.label("siparis_numarasi"),
Proje.proje_no.label("proje_no"),
Person.ad.label("yurutucu_ad"),
Person.ad.label("yurutucu_soyad"),
HitapUnvan.ad.label("yurutucu_unvan"),
SiparisTakip.kabul_tarihi.label("siparis_kabul_tarihi"),
TalepKalemleri.talep_miktari.label("talep_miktari"),
FirmaTeklifKalemi.teklif.label("toplam_fiyati"),
ProjeKalemi.birim.label("birim"),
TalepKalemleri.satinalma_id.label("satinalma_id"),
BapFirma.adi.label("firma_adi")). \
filter(SiparisTakip.siparis_durumu == SiparisDurumu.siparis_tamamlandi)
def process_data(self, result, form_data, total_record):
data = [[
index + 1,
r.malzeme_adi,
r.siparis_numarasi,
r.firma_adi,
r.proje_no,
"{} {} {}".format(r.yurutucu_unvan, r.yurutucu_ad, r.yurutucu_soyad),
"{}".format(r.siparis_kabul_tarihi.strftime(current_app.config['DATE_FORMAT'])),
"{} {}".format(r.talep_miktari, r.birim),
format_currency(r.toplam_fiyati, 'TL', '#,##0.00 ¤¤¤', locale='tr_TR') if r.toplam_fiyati else "-",
"""
<a class="detail_arrow" href="{}"><span class="fa fa-arrow-circle-right fa-2x "></span>
</a>
""".format(url_for('satinalma.satinalma_dashboard', satinalma_id=r.satinalma_id))
] for index, r in enumerate(result)]
return jsonify({"data": data,
"draw": form_data['draw'],
"recordsFiltered": total_record,
"recordsTotal": total_record})
@login_required
@auth.requires(Permission(*permission_dict["bap"]["satinalma"]["satınalinan_malzemeler_listesi_goruntuleme"]),
menu_registry={"path": ".bap.satinalma.satin_alinan_malzemeler",
"title": _("Malzeme Arama")})
@route('/liste', methods=['GET'])
def satinalinan_malzemeler_listele(self):
search_form = SatinalinanMalzemelerSearchForm()
return render_template("satinalinan_malzemeler.html", form=search_form)
@login_required
@auth.requires(Or(Permission(*permission_dict["bap"]["satinalma"]["satınalinan_malzemeler_listesi_goruntuleme"])),
Or(Role("BAP Admin"), Role("BAP Yetkilisi")))
@route('/data', methods=["POST"], endpoint="satinalinan_malzeme_search")
def satinalinan_malzeme_ara(self): # pylint: disable=too-many-branches
"""
POST ile gelen parametrelere gore arama yapip, sonuclari dondurur.
Returns:
http response
"""
qry = self.qry
total_record = qry.count()
form_data = request.form.to_dict()
search_form = SatinalinanMalzemelerSearchForm(**form_data)
if not search_form.validate():
result = qry.order_by(desc(SiparisTakip.kabul_tarihi)).offset(form_data['start']).limit(
form_data['length']).all()
return self.process_data(result, form_data, total_record)
malzeme_adi = search_form.malzeme_adi.data
siparis_no = search_form.siparis_no.data
proje_no = search_form.proje_no.data
yurutucu = search_form.yurutucu.data
siparis_kabul_tarihi = search_form.date.siparis_kabul_tarihi.data
siparis_kabul_tarihi_option = search_form.date.siparis_kabul_tarihi_option.data
talep_miktari = search_form.talep_miktari.data
toplam_fiyati = search_form.toplam_fiyati.data
toplam_fiyati_option = search_form.toplam_fiyati_option.data
firma_adi = search_form.firma_adi.data
if malzeme_adi:
qry = qry.filter(ProjeKalemi.ad.ilike('%' + malzeme_adi + '%'))
if siparis_no:
qry = qry.filter(SiparisTakip.siparis_numarasi.ilike('%' + siparis_no + '%'))
if proje_no:
qry = qry.filter(Proje.proje_no.ilike('%' + proje_no + '%'))
if yurutucu:
qry = qry.filter(Person.ad.ilike('%' + yurutucu + '%'))
if firma_adi:
qry = qry.filter(BapFirma.adi.ilike('%' + firma_adi + '%'))
if siparis_kabul_tarihi:
if siparis_kabul_tarihi_option == '0':
qry = qry.filter(SiparisTakip.kabul_tarihi >= siparis_kabul_tarihi)
if siparis_kabul_tarihi_option == '1':
qry = qry.filter(SiparisTakip.kabul_tarihi == siparis_kabul_tarihi)
if siparis_kabul_tarihi_option == '2':
qry = qry.filter(SiparisTakip.kabul_tarihi <= siparis_kabul_tarihi)
if talep_miktari:
if toplam_fiyati_option == '0':
qry = qry.filter(TalepKalemleri.talep_miktari <= talep_miktari)
if toplam_fiyati_option == '1':
qry = qry.filter(TalepKalemleri.talep_miktari == talep_miktari)
if toplam_fiyati_option == '2':
qry = qry.filter(TalepKalemleri.talep_miktari >= talep_miktari)
qry = qry.filter(TalepKalemleri.talep_miktari == talep_miktari)
if toplam_fiyati:
if toplam_fiyati_option == '0':
qry = qry.filter(FirmaTeklifKalemi.teklif <= toplam_fiyati)
if toplam_fiyati_option == '1':
qry = qry.filter(FirmaTeklifKalemi.teklif == toplam_fiyati)
if toplam_fiyati_option == '2':
qry = qry.filter(FirmaTeklifKalemi.teklif >= toplam_fiyati)
result = qry.order_by(desc(ProjeSatinAlmaTalebi.id)).offset(form_data['start']).limit(form_data['length']).all()
return self.process_data(result, form_data, total_record)
class HakemDashboard(FlaskView):
"""Hakem Projeleri Degerlendirme"""
@staticmethod
@login_required
@route('/degerlendirmeler/', methods=['GET'])
# todo: permissin durumu kontrol edilecek
@auth.requires(Permission(*permission_dict["bap"]["hakem_dashboard"]
["hakem_proje_degerlendirme"]),
menu_registry={
'path': '.bap.proje_degerlendirmeleri',
'title': _("İstekler")
})
def hakem_proje_degerlendirme_istekleri():
""" Hakem proje degerlendirme liste ekrani."""
hakem = DB.session.query(Hakem.id.label("hakem_id")).options(
lazyload('*')).filter(
Hakem.person_id == current_user.person.id).one()
hakem_id = hakem.hakem_id
# query sonucu tuple list halde gelir.
# proje basligi ve proje id label a sahip oldugu icin attr olarak donen degerden alinabilir
# tuple in 0 indexli elemani ProjeHakemleri instance i icerir
# todo: lib query birlesince oraya tasinacak
hakem_projeleri = DB.session.query(
ProjeHakemleri, Proje.proje_basligi.label("proje_basligi"),
Proje.id.label("proje_id")).options(lazyload("*")).filter(
ProjeHakemleri.hakem_id == hakem_id).join(Proje).all()
tamamlanan_degerlendirmeler = []
degerlendirilmemis_davetler = []
for hakem_proje in hakem_projeleri:
data = {
"proje_basligi": hakem_proje.proje_basligi,
"proje_id": hakem_proje.proje_id,
"davet_durumu": hakem_proje[0].davet_durumu.value,
"proje_hakem_id": hakem_proje[0].id,
"projeyi_inceleyebilir_mi": True
}
if hakem_proje[
0].davet_durumu == ProjeHakemDavetDurumlari.gonderildi:
degerlendirilmemis_davetler.append(data)
else:
if hakem_proje[
0].davet_durumu == ProjeHakemDavetDurumlari.reddedildi:
data["projeyi_inceleyebilir_mi"] = False
tamamlanan_degerlendirmeler.append(data)
return render_template(
"proje_degerlendirme_istekleri.html",
degerlendirilmemis_davetler=degerlendirilmemis_davetler,
tamamlanan_degerlendirmeler=tamamlanan_degerlendirmeler)
@login_required
@route('proje/<int:proje_id>/degerlendirmeler/<int:proje_hakem_id>',
methods=['POST'],
endpoint='post_hakem_proje_degerlendirme_istekleri')
# todo: izin degisecek. yapilan islemi test edebilmek icin bu halde
@auth.requires(
Permission(*permission_dict["bap"]["hakem_dashboard"]
["hakem_proje_degerlendirme"]))
def post_hakem_proje_degerlendirme_istekleri(self, proje_hakem_id,
proje_id): # pylint: disable=R0201
"""
Hakem degerlendirmesi kabul veya reddi icin kullanilir.
"""
proje_hakemi = DB.session.query(ProjeHakemleri).options(
joinedload(ProjeHakemleri.proje).load_only(Proje.proje_no)).filter(
ProjeHakemleri.id == proje_hakem_id,
ProjeHakemleri.davet_durumu ==
ProjeHakemDavetDurumlari.gonderildi).one()
hakem = DB.session.query(Hakem.id.label("hakem_id")).options(
lazyload('*')).filter(
Hakem.person_id == current_user.person.id).one()
if proje_hakemi:
if proje_hakemi.hakem_id != hakem.hakem_id:
return jsonify(status="error"), 500
davet_durumu = request.get_json().get('davet_durumu')
proje_hakemi.davet_durumu = davet_durumu
DB.session.commit()
if proje_hakemi.davet_durumu == ProjeHakemDavetDurumlari.kabul_edildi:
message = "hakemlik davetini kabul etti"
else:
message = "hakemlik davetini reddetti"
extra_message = """{} adlı kullanıcı({} id'li hakem),{} numaralı projenin {}""".format(
current_user.username, hakem.hakem_id,
proje_hakemi.proje.proje_no, message)
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"degerlendirme_teklifi_cevaplandi").type_index,
"nesne":
'Proje Hakemleri',
"nesne_id":
proje_hakemi.id,
"ekstra_mesaj":
extra_message
}
signal_sender(**signal_payload)
for bap_admin in bap_yetkili_and_admin_ids():
payload = {
"notification_receiver":
bap_admin.person_id,
"notification_title":
proje_hakemi.davet_durumu.value,
"notification_message":
"{} adlı kullanıcı {} numaralı projenin {}".format(
current_user.username, proje_hakemi.proje.proje_no,
message),
}
signal_sender(log=False, notification=True, **payload)
return jsonify(status="success")
return abort(400)
@staticmethod
@login_required
# todo: izin kontrolu yap
@auth.requires(Permission(*permission_dict["bap"]["hakem_dashboard"]
["hakem_proje_degerlendirme"]),
menu_registry={
'path': '.bap.atanmis_projeler',
'title': _("Atanmış Projeler")
})
@route('/atanmis-projeler', methods=["GET"])
def proje_listesi():
"""Hakem Proje Listesi"""
hakem_id = DB.session.query(Hakem).filter(
Hakem.person_id == current_user.person.id).one().id
# kabul edilen proje hakemliklerinin id listesini doner
hakem_proje = DB.session.query(ProjeHakemleri.id).filter(
ProjeHakemleri.hakem_id == hakem_id, ProjeHakemleri.davet_durumu ==
ProjeHakemDavetDurumlari.kabul_edildi).all()
degerlendirme_bilgileri = DB.session.query(
ProjeDegerlendirmeleri).options(
joinedload(ProjeDegerlendirmeleri.rapor).joinedload(
ProjeRapor.proje)).filter(
ProjeDegerlendirmeleri.proje_hakem_id.in_(
hakem_proje)).all()
degerlendirilecek_projeler = []
ara_rapor_deg_projeler = []
sonuc_rapor_deg_projeler = []
for degerlendirme in degerlendirme_bilgileri:
if degerlendirme.rapor.durumu == ProjeRaporDurumu.tamamlandi:
if degerlendirme.rapor.rapor_tipi == ProjeRaporTipi.ara_rapor:
ara_rapor_deg_projeler.append(degerlendirme)
elif degerlendirme.rapor.rapor_tipi == ProjeRaporTipi.proje_basvuru:
degerlendirilecek_projeler.append(degerlendirme)
elif degerlendirme.rapor.rapor_tipi == ProjeRaporTipi.sonuc_raporu:
sonuc_rapor_deg_projeler.append(degerlendirme)
# todo bilim kurulu ve komisyon üyesi olduğu projeler eklenecek
return render_template(
'proje_listesi.html',
degerlendirilecek_projeler=degerlendirilecek_projeler,
ara_rapor_deg_projeler=ara_rapor_deg_projeler,
sonuc_rapor_deg_projeler=sonuc_rapor_deg_projeler,
hakem_proje_degerlendirme_formu=HakemProjeDegerlendirmeForm(),
degerlendirme_formu=ProjeDegerlendirmeFormu(),
hakem_id=hakem_id)
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["hakem_dashboard"]
["hakem_proje_degerlendirme"]))
@route('/degerlendirme/<int:degerlendirme_id>/kaydet',
methods=["POST"],
endpoint="degerlendirme_kaydet")
def degerlendirme_kaydet(degerlendirme_id):
degerlendirme_formu = ProjeDegerlendirmeFormu(request.form)
degerlendirme = DB.session.query(ProjeDegerlendirmeleri).options(
joinedload(ProjeDegerlendirmeleri.rapor).joinedload(
ProjeRapor.proje).load_only("proje_no")).filter(
ProjeDegerlendirmeleri.id == degerlendirme_id).one()
degerlendirme.degerlendirme = degerlendirme_formu.degerlendirme_metni.data
degerlendirme.degerlendirme_sonuclandi_mi = degerlendirme_formu.degerlendirme_tamamlandi_mi.data
degerlendirme.degerlendirme_gonderim_tarihi = datetime.now()
degerlendirme.sonuc = degerlendirme_formu.degerlendirme_sonucu.data
DB.session.commit()
if degerlendirme.degerlendirme_sonuclandi_mi:
for bap_admin in bap_yetkili_and_admin_ids():
payload = {
"notification_receiver":
bap_admin.person_id,
"notification_title":
"{} Değerlendirmesi Tamamlandı".format(
degerlendirme.rapor.rapor_tipi.value),
"notification_message":
"{} adlı kullanıcı {} numaralı projenin {} değerlendirmesini tamamladı. Değerlendirme sonucu {}"
.format(current_user.username,
degerlendirme.rapor.proje.proje_no,
degerlendirme.rapor.rapor_tipi.value,
degerlendirme.sonuc.value),
}
signal_sender(log=False, notification=True, **payload)
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"proje_degerlendirdi").type_index,
"nesne":
'ProjeDegerlendirmeleri',
"nesne_id":
degerlendirme.id,
"ekstra_mesaj":
"{} adlı kullanıcı {} numaralı projenin {} değerlendirmesini tamamladı. Değerlendirme sonucu {}"
.format(current_user.username,
degerlendirme.rapor.proje.proje_no,
degerlendirme.rapor.rapor_tipi.value,
degerlendirme.sonuc.value)
}
signal_sender(**signal_payload)
return redirect(
url_for('hakem_dashboard.HakemDashboard:proje_listesi'))
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["hakem_dashboard"]
["hakem_proje_degerlendirme"]))
@route('/degerlendirme/<int:degerlendirme_id>/text',
methods=["GET"],
endpoint="get_degerlendirme_text")
def get_degerlendirme_text(degerlendirme_id):
degerlendirme = DB.session.query(ProjeDegerlendirmeleri).filter(
ProjeDegerlendirmeleri.id == degerlendirme_id).scalar()
return jsonify(status="success",
degerlendirme_metni=degerlendirme.degerlendirme)
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["hakem_dashboard"]
["hakem_proje_degerlendirme"]), AtanmisHakem())
@route('/<int:proje_id>', methods=["GET"], endpoint='proje_degerlendirme')
def proje_degerlendirme(proje_id):
"""Hakem Proje Degerlendirme"""
hakem_id = DB.session.query(Hakem).filter(
Hakem.person_id == current_user.person.id).first().id
proje_degerlendirme = DB.session.query(ProjeDegerlendirmeleri).filter(
ProjeDegerlendirmeleri.proje_id == proje_id,
ProjeDegerlendirmeleri.hakem_id == hakem_id,
ProjeDegerlendirmeleri.davet_durumu ==
ProjeHakemDavetDurumlari.kabul_edildi).first()
if proje_degerlendirme.davet_durumu in [
ProjeHakemDavetDurumlari.suruyor,
ProjeHakemDavetDurumlari.tamamlandi
]:
form = ProjeDegerlendirmeForm(
**proje_degerlendirme.degerlendirme_detaylari)
else:
form = ProjeDegerlendirmeForm()
return render_template('proje_degerlendirme.html',
form=form,
proje_id=proje_id)
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["hakem_dashboard"]
["hakem_proje_degerlendirme"]), AtanmisHakem())
@route('/<int:proje_id>', methods=["POST"])
def post_proje_degerlendirme(proje_id):
"""Hakem Proje Degerlendirme"""
form = ProjeDegerlendirmeForm(request.form)
sess = DB.session
hakem_id = DB.session.query(Hakem).filter(
Hakem.person_id == current_user.person.id).one().id
try:
proje_degerlendirmesi = sess.query(ProjeDegerlendirmeleri).filter(
ProjeDegerlendirmeleri.hakem_id == hakem_id).filter(
ProjeDegerlendirmeleri.proje_id == proje_id).one()
proje_degerlendirmesi.degerlendirme_detaylari = form.data
proje_degerlendirmesi.sonuc = form.degerlendirme_sonucu.data
proje_degerlendirmesi.degerlendirme_tarihi = datetime.now()
if form.degerlendirme_tamamlandi.data:
proje_degerlendirmesi.davet_durumu = ProjeHakemDavetDurumlari.tamamlandi
else:
proje_degerlendirmesi.davet_durumu = ProjeHakemDavetDurumlari.suruyor
sess.commit()
extra_mesaj = """{} adlı kullanıcı({} id'li hakem), proje değerlendirme bilgilerini
{} olarak düzenledi.""".format(current_user.username, hakem_id,
proje_degerlendirmesi.davet_durumu)
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"proje_degerlendirdi").type_index,
"nesne":
'Proje Degerlendirme',
"nesne_id":
proje_degerlendirmesi.id,
"ekstra_mesaj":
extra_mesaj
}
signal_sender(**signal_payload)
except SQLAlchemyError as exc:
sess.rollback()
print(str(exc))
return redirect(
url_for(".HakemDashboard:proje_listesi", proje_id=proje_id))
class ProjeSatinalmaTalepleriView(FlaskView):
"""
Proje Satinalma Talepleri
"""
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["dashboard"]
["proje_satinalma_talepleri_goruntuleme"]),
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role('BAP Admin')))
@route("<int:proje_id>/dashboard/satinalma-talepleri",
methods=["GET"],
endpoint="satinalma_talepleri")
def satinalma_talepleri(self, proje_id):
"""
Satinalma Talpeleri view class
"""
satinalma_form = ProjeSatinAlmaTalepleri()
proje_yurutucusu_mu = ProjeYurutucusu()
proje = DB.session.query(Proje).options(
joinedload(Proje.proje_yurutucu).load_only("id").joinedload(
OgretimElemani.personel).load_only("id").joinedload(
Personel.person).load_only("ad", "soyad"),
joinedload(Proje.satinalma_talepleri),
lazyload(Proje.proje_detayi),
lazyload(Proje.kabul_edilen_proje_hakemleri),
lazyload(Proje.proje_hakem_onerileri),
lazyload(Proje.proje_destekleyen_kurulus),
).filter(
Proje.id == proje_id,
or_(
Proje.proje_basvuru_durumu == ProjeBasvuruDurumu.tamamlandi,
Proje.proje_basvuru_durumu ==
ProjeBasvuruDurumu.revizyon_bekleniyor)).first()
next_states_info = get_next_states_info(proje_id=proje_id)
actions_info = get_actions_info(proje_id=proje_id)
proje_durum = DB.session.query(AppState).filter(
AppState.id == proje.proje_durumu_id).first()
proje_satinalma_talepleri_data = []
# satinalma talepleri uyari mesajlari
sa_talepleri_uyari_mesajlari = []
for satinalma_talebi in proje.satinalma_talepleri:
data = {
"satinalma_id": satinalma_talebi.id,
"talep_numarasi": satinalma_talebi.talep_numarasi,
"created_at": satinalma_talebi.created_at,
"state_code": satinalma_talebi.durumu.state_code,
"state_description": satinalma_talebi.durumu.description,
"duyuru_id": satinalma_talebi.duyuru_id,
"duyuru_duzenlensin_mi":
satinalma_talebi.duyuru_duzenlensin_mi,
"teknik_sartname_duzenlensin_mi": False
}
if satinalma_talebi.duyuru_duzenlensin_mi:
sa_talepleri_uyari_mesajlari.append(
_("{} numaralı satınalma talebi için işlemler bölümünden duyuru düzenmeniz "
"gerekmektedir.".format(
satinalma_talebi.talep_numarasi)))
for talep_kalemi in satinalma_talebi.talep_kalemleri:
if talep_kalemi.teknik_sartname_duzenlensin_mi:
data["teknik_sartname_duzenlensin_mi"] = True
sa_talepleri_uyari_mesajlari.append(
_("{} numaralı satınalma talebi için işlemler bölümünden teknik şartname "
"düzenlemeniz gerekmektedir.".format(
satinalma_talebi.talep_numarasi)))
break
proje_satinalma_talepleri_data.append(data)
"""
proje_kalemleri_data {
"Mal Malzeme Alımı": {
"satinalma_talebi_yapilabilir_mi": True,
"butce_kalemi_id": proje_kalemi.proje_turu_butce_kalemi.id,
"proje_kalemleri": []
}
"Hizmet Alımı": {
"satinalma_talebi_yapilabilir_mi": True,
"butce_kalemi_id": proje_kalemi.proje_turu_butce_kalemi.id,
"proje_kalemleri": []
}
}
butce_kalemi adı: projeyenin harcama yapabilecegi butce kalemlerini temsil eder
satinalma_talebi_yapilabilir_mi degeri kullanilabilir miktari ve kullanilabilir butcesine
gore uretilir. ilgili degerlerden biri 0 ise basvuru yapmasi engellenir.
butce_kalemi_id projenin harcama yapabilecegi butce kaleminin id sini temsil eder
"""
proje_kalemleri_data = {}
for proje_kalemi in proje.proje_kalemleri:
butce_kalemi_adi = "{} {}".format(
proje_kalemi.proje_turu_butce_kalemi.
gider_siniflandirma_kalemi.kodu, proje_kalemi.
proje_turu_butce_kalemi.gider_siniflandirma_kalemi.aciklama)
if not proje_kalemleri_data.get(butce_kalemi_adi):
proje_kalemleri_data[butce_kalemi_adi] = {
"satinalma_talebi_yapilabilir_mi": False,
"butce_kalemi_id": proje_kalemi.proje_turu_butce_kalemi.id,
"proje_kalemleri": []
}
kullanilabilir_miktar = proje_kalemi.toplam_miktar - proje_kalemi.kullanilan_miktar - proje_kalemi.rezerv_edilen_miktar
kullanilabilir_butce = proje_kalemi.toplam_butce - proje_kalemi.rezerv_butce - proje_kalemi.kullanilan_butce
kullanilabilir_butce = kullanilabilir_butce.quantize(
Decimal(".01"))
proje_kalemleri_data[butce_kalemi_adi]["proje_kalemleri"].append({
"proje_kalemi_ad":
proje_kalemi.ad,
"toplam_miktar":
proje_kalemi.toplam_miktar,
"birim":
proje_kalemi.birim.value,
"kullanilan_miktar":
proje_kalemi.kullanilan_miktar,
"rezerv_edilen_miktar":
proje_kalemi.rezerv_edilen_miktar,
"kullanilabilir_miktar":
kullanilabilir_miktar,
"toplam_butce":
proje_kalemi.toplam_butce,
"kullanilan_butce":
proje_kalemi.kullanilan_butce,
"rezerv_edilen_butce":
proje_kalemi.rezerv_butce,
"kullanilabilir_butce":
kullanilabilir_butce
})
if kullanilabilir_miktar > 0 and kullanilabilir_butce > 0:
proje_kalemleri_data[butce_kalemi_adi][
"satinalma_talebi_yapilabilir_mi"] = True
return render_template(
"dashboard/proje_satinalma_talepleri.html",
proje_yurutucusu_mu=proje_yurutucusu_mu,
proje_id=proje_id,
next_states_info=next_states_info,
actions_info=actions_info,
proje=proje,
satinalma_form=satinalma_form,
proje_satinalma_talepleri=proje_satinalma_talepleri_data,
proje_kalemleri_data=proje_kalemleri_data,
proje_durum=proje_durum,
satinalma_talepleri_uyari_mesajlari=sa_talepleri_uyari_mesajlari)
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["dashboard"]
["proje_satinalma_talepleri_goruntuleme"]),
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role('BAP Admin')))
@route(
"<int:proje_id>/dashboard/satinalma-talep/<int:butce_kalemi_id>/talep-olustur",
methods=["GET"])
def satinalma_talep_get(self, proje_id, butce_kalemi_id):
"""
Satinalma Talpeleri view class
"""
proje_kalemleri = DB.session.query(ProjeKalemi).filter(
ProjeKalemi.proje_id == proje_id,
ProjeKalemi.proje_turu_butce_kalem_id == butce_kalemi_id).all()
satinalma_talep_form = ProjeSatinAlmaTalepleri()
satinalma_talebi_yapilabilir_mi = False
for proje_kalemi in proje_kalemleri:
kullanilabilir_miktar = proje_kalemi.toplam_miktar - proje_kalemi.kullanilan_miktar - proje_kalemi.rezerv_edilen_miktar
kullanilabilir_butce = proje_kalemi.toplam_butce - proje_kalemi.rezerv_butce - proje_kalemi.kullanilan_butce
kullanilabilir_butce = kullanilabilir_butce.quantize(
Decimal(".01"))
if kullanilabilir_miktar > 0 and kullanilabilir_butce > 0:
satinalma_talebi_yapilabilir_mi = True
satinalma_talep_form.talepler.append_entry({
"proje_kalemi_id":
proje_kalemi.id,
"proje_kalemi_adi":
proje_kalemi.ad,
"toplam_miktar":
proje_kalemi.toplam_miktar,
"birim":
proje_kalemi.birim.value,
"kullanilan_miktar":
proje_kalemi.kullanilan_miktar,
"rezerv_edilen_miktar":
proje_kalemi.rezerv_edilen_miktar,
"kullanilabilir_miktar":
kullanilabilir_miktar,
# "toplam_butce": proje_kalemi.toplam_butce,
# "kullanilan_butce": proje_kalemi.kullanilan_butce,
# "rezerv_edilen_butce": proje_kalemi.rezerv_butce,
# "kullanilabilir_butce": kullanilabilir_butce
})
return render_template(
"dashboard/proje_satinalma_talep_basvuru.html",
proje_id=proje_id,
butce_kalemi_id=butce_kalemi_id,
satinalma_talep_form=satinalma_talep_form,
satinalma_talebi_yapilabilir_mi=satinalma_talebi_yapilabilir_mi)
@login_required
@auth.requires(
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role('BAP Admin')))
@route(
"<int:proje_id>/dashboard/satinalma-talep/<int:butce_kalemi_id>/talep-olustur",
methods=["POST"])
def satinalma_talebi_kaydet(self, proje_id, butce_kalemi_id):
"""
Talep Oluşturur
"""
try:
satinalma_talep_formu = ProjeSatinAlmaTalepleri(request.form)
if not satinalma_talep_formu.validate():
return render_template(
"dashboard/proje_satinalma_talep_basvuru.html",
proje_id=proje_id,
butce_kalemi_id=butce_kalemi_id,
satinalma_talep_form=satinalma_talep_formu)
# mkk ya eklenen uyelerin aynı kişi olma durumuna bakilir
select_field_list = [
satinalma_talep_formu.baskan, satinalma_talep_formu.yedek_uye,
satinalma_talep_formu.yedek_uye2, satinalma_talep_formu.uye,
satinalma_talep_formu.yedek_baskan, satinalma_talep_formu.uye2
]
seen = set()
for select_field in select_field_list:
if select_field.data not in seen:
seen.add(select_field.data)
else:
select_field.errors.append(
"Komisyon üyesini birden fazla kez dahil ettiniz")
if not satinalma_talep_formu.validate():
return render_template(
"dashboard/proje_satinalma_talep_basvuru.html",
proje_id=proje_id,
butce_kalemi_id=butce_kalemi_id,
satinalma_talep_form=satinalma_talep_formu)
genel_teknik_sartname = request.files.get(
satinalma_talep_formu.genel_teknik_sartname_belge.name, None)
genel_teknik_sartname_file = None
if genel_teknik_sartname:
genel_teknik_sartname_file = File(
content=genel_teknik_sartname, user_id=current_user.id)
DB.session.add(genel_teknik_sartname_file)
proje_kalemleri = DB.session.query(ProjeKalemi).filter(
ProjeKalemi.proje_id == proje_id,
ProjeKalemi.proje_turu_butce_kalem_id ==
butce_kalemi_id).all()
satinalma_talebi = ProjeSatinAlmaTalebi(
proje_id=proje_id,
butce_kalem_id=butce_kalemi_id,
mkk_baskan_id=satinalma_talep_formu.baskan.data,
mkk_uye1_id=satinalma_talep_formu.uye.data,
mkk_uye2_id=satinalma_talep_formu.uye2.data,
mkk_yedek_baskan_id=satinalma_talep_formu.yedek_baskan.data,
mkk_yedek_uye1_id=satinalma_talep_formu.yedek_uye.data,
mkk_yedek_uye2_id=satinalma_talep_formu.yedek_uye2.data,
)
DB.session.add(satinalma_talebi)
DB.session.flush()
talep_kalemi_sayisi = 0
for proje_kalemi in proje_kalemleri:
for talep in satinalma_talep_formu.talepler:
kullanilabilir_miktar = proje_kalemi.toplam_miktar - proje_kalemi.kullanilan_miktar - proje_kalemi.rezerv_edilen_miktar
if proje_kalemi.id == talep.proje_kalemi_id.data and talep.secili_mi.data and (
kullanilabilir_miktar > 0):
if not (0 < talep.talep_edilen_miktar.data <=
kullanilabilir_miktar):
flash(
"Talep edilen miktar sıfırdan büyük ve kullanılabilir miktardan "
"küçük olmak zorunda.", "error")
break
teknik_sartname = request.files.get(
talep.teknik_sartname_belge.name, None)
if teknik_sartname:
teknik_sartname_file = File(
content=teknik_sartname,
user_id=current_user.id)
DB.session.add(teknik_sartname_file)
DB.session.flush()
talep_teknik_sartname_file_id = teknik_sartname_file.id
elif genel_teknik_sartname:
talep_teknik_sartname_file_id = genel_teknik_sartname_file.id
else:
# eger ilgili talebe ozel teknik sartname yuklenmemisse ve genel bir teknik
# şartnamede yuklememis ise hata donulur
flash("Teknik şartname yüklemek zorundasınız",
"error")
break
talep_kalemi_sayisi += 1
# talep edilen miktar proje kaleminden rezerv edilir
proje_kalemi.rezerv_edilen_miktar += talep.talep_edilen_miktar.data
talep_kalemi = TalepKalemleri(
satinalma_id=satinalma_talebi.id,
teknik_sartname_file_id=
talep_teknik_sartname_file_id,
proje_kalemi_id=proje_kalemi.id,
talep_miktari=talep.talep_edilen_miktar.data)
DB.session.add(talep_kalemi)
if not talep_kalemi_sayisi:
flash(
"Satınalma talebini tamamlamak için en az bir kalem seçmelisiniz",
"error")
# eger bir hata var ise db session rollback edilip hatalari kullaniciya gostermek icin
# ilgili sayfa render edilir
if get_flashed_messages(category_filter=["error"]):
DB.session.rollback()
return render_template(
"dashboard/proje_satinalma_talep_basvuru.html",
proje_id=proje_id,
butce_kalemi_id=butce_kalemi_id,
satinalma_talep_form=satinalma_talep_formu)
# satinalma id si talep numarasi olarak atanir
satinalma_talebi.talep_numarasi = str(satinalma_talebi.id)
# st1 state id satinalma durum id olarak atanir
satinalma_talebi.durum_id = 34
proje = DB.session.query(Proje.proje_no.label("proje_no")).filter(
Proje.id == proje_id).first()
for bap_admin in bap_yetkili_and_admin_ids():
payload = {
"notification_receiver":
bap_admin.person_id,
"notification_title":
"Satınalma Talebi Yapıldı",
"notification_message":
"{} adlı kullanıcı {} numaralı projede satınalma talebi yaptı"
.format(current_user.username, proje.proje_no),
}
signal_sender(log=False, notification=True, **payload)
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"satinalma_talebi_olustur").type_index,
"nesne":
'',
"nesne_id":
proje_id,
"ekstra_mesaj":
"{} adlı {} id li kullanici satinalma talebi yaptı .".format(
current_user.id, current_user.username)
}
signal_sender(**signal_payload)
DB.session.commit()
flash("Satınalma talebi başarıyla oluşturuldu.", "success")
except Exception as exc:
flash(
"Satınalma talebi yaparken beklenmedik bir sorunla karşılaşıldı. "
"Lütfen daha sonra tekrar deneyin")
DB.session.rollback()
CustomErrorHandler.error_handler()
return redirect(url_for("proje.satinalma_talepleri",
proje_id=proje_id))
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["dashboard"]
["proje_satinalma_talepleri_goruntuleme"]),
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role('BAP Admin')))
@route("<int:proje_id>/dashboard/satinalma-talepleri/duyuru-goster",
methods=["POST"],
endpoint="duyuru_goster")
def duyuru_goster(self, proje_id):
"""
Butce Kalemleri Ürünlerini Listeler
"""
duyuru_id = request.get_json()['duyuru_id']
duyuru_form = DuyuruForm()
duyuru_icerigi = DB.session.query(
Icerik.icerik.label("icerik"), Icerik.baslik.label("baslik"),
Icerik.id.label("id")).filter(Icerik.id == duyuru_id).first()
duyuru_form.duyuru_metni.data = duyuru_icerigi.icerik
duyuru_form.duyuru_basligi.data = duyuru_icerigi.baslik
duyuru_form.duyuru_id.data = duyuru_icerigi.id
form_text = """
{% from 'macros/_formhelpers.html' import render_text_field %}
<form id="duyuru-duzenle-form">
{{ form.csrf_token }}
{{ form.duyuru_id}}
{{render_text_field(form.duyuru_basligi)}}
<br>
{{ form.duyuru_metni }}
</form>
"""
data = {'duyuru': render_template_string(form_text, form=duyuru_form)}
return jsonify(status="success", data=data)
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["dashboard"]
["proje_satinalma_talepleri_goruntuleme"]),
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role('BAP Admin')))
@route("<int:proje_id>/dashboard/satinalma-talepleri/duyuru-kaydet",
methods=["POST"],
endpoint="duyuru_kaydet")
def duyuru_kaydet(self, proje_id):
"""
Duyuruları Listeler
"""
duyuru_duzenle_form = request.get_json()['duyuru_form']
imd = ImmutableMultiDict([(duyuru['name'], duyuru['value'])
for duyuru in duyuru_duzenle_form])
duyuru_form = DuyuruForm(imd)
if not duyuru_form.validate():
form_text = """
{% from 'macros/form_helpers/text_fields.html' import render_text_field %}
<form id="duyuru-duzenle-form">
{{ form.csrf_token }}
{{ form.duyuru_id}}
{{render_text_field(form.duyuru_basligi)}}
<br>
{{ form.duyuru_metni }}
</form>
"""
data = {
'duyuru_form': render_template_string(form_text,
form=duyuru_form)
}
return jsonify(
status="error",
message=
"Lütfen doldurulması gereken alanları boş bırakmayınız.",
data=data), 400
duyuru_yurutucunun_mu = DB.session.query(ProjeSatinAlmaTalebi).filter(
ProjeSatinAlmaTalebi.proje_id == proje_id,
ProjeSatinAlmaTalebi.duyuru_id ==
duyuru_form.duyuru_id.data).first()
if not duyuru_yurutucunun_mu:
return jsonify(
status="error",
message="Değiştirmeye çalıştığınız duyuru size ait değil. "
"Lütfen yetkili ile iletişime geçiniz."), 400
try:
duyuru_icerigi = DB.session.query(Icerik).filter(
Icerik.id == duyuru_form.duyuru_id.data).first()
duyuru_icerigi.baslik = duyuru_form.duyuru_basligi.data
duyuru_icerigi.icerik = duyuru_form.duyuru_metni.data
duyuru_yurutucunun_mu.duyuru_duzenlensin_mi = False
payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("icerik").get(
"satinalma_duyurusu_duzenlendi").type_index,
"ekstra_mesaj":
"".format(),
"nesne":
'İçerik',
"nesne_id":
duyuru_form.duyuru_id.data,
}
signal_sender(notification=True, **payload)
for yetkili in bap_yetkili_and_admin_ids():
payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("icerik").get(
"satinalma_duyurusu_duzenlendi").type_index,
"ekstra_mesaj":
"{} id'li duyuru içeriği {} isimli kullanıcı tarafından değiştrildi"
.format(duyuru_form.duyuru_id.data, current_user.username),
"notification_receiver":
yetkili.person_id,
"notification_title":
"{} İsimli Kullanıcı Duyuru İçeriği Düzenledi".format(
current_user.username),
"notification_message":
"{} isimli kullanıcı duyuru içeriği düzenledi. Lütfen kontrol ediniz"
.format(current_user.username),
"proje_id":
proje_id
}
signal_sender(log=False, notification=True, **payload)
DB.session.commit()
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Duyuru içeriği değiştirilirken bir hata oluştu. "
"Hata: {}, İçerik id: {}".format(exc,
duyuru_form.duyuru_id.data))
return jsonify(
status="error",
message="Bir hata oluştu. Lütfen daha sonra tekrar deneyiniz.!"
), 400
return jsonify(status="success")
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["dashboard"]
["proje_satinalma_talepleri_goruntuleme"]),
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role('BAP Admin')))
@route(
"<int:proje_id>/dashboard/satinalma/<int:satinalma_id>/teknik-sartname-duzenle",
methods=["GET"])
def satinalma_teknik_sartname_duzenle(self, proje_id, satinalma_id):
"""
Satinalma talep kalemleri teknik sartname duzenleme view methodu
"""
satinalma_talep_kalemleri = DB.session.query(TalepKalemleri).filter(
TalepKalemleri.satinalma_id == satinalma_id,
TalepKalemleri.teknik_sartname_duzenlensin_mi == True).all()
if not satinalma_talep_kalemleri:
flash(_("Teknik şartnamesi düzenlenecek talep kalemi bulunamadı."))
return redirect(
url_for("proje.satinalma_talepleri", proje_id=proje_id))
teknik_sartname_duzenle_form = TeknikSartnameDuzenlemeFormu()
for talep_kalemi in satinalma_talep_kalemleri:
if talep_kalemi.teknik_sartname_duzenlensin_mi:
teknik_sartname_duzenle_form.talep_kalemleri.append_entry({
"talep_kalemi_id":
talep_kalemi.id,
"eski_teknik_sartname_id":
talep_kalemi.teknik_sartname_file_id,
"proje_kalemi_adi":
talep_kalemi.proje_kalemi.ad,
"talep_edilen_miktar":
talep_kalemi.talep_miktari,
"birim":
talep_kalemi.proje_kalemi.birim.value
})
return render_template(
"dashboard/teknik_sarname_duzenle.html",
proje_id=proje_id,
satinalma_id=satinalma_id,
teknik_sartname_duzenle_form=teknik_sartname_duzenle_form)
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["dashboard"]
["proje_satinalma_talepleri_goruntuleme"]),
Or(ProjeYurutucusu(), Role('BAP Yetkilisi'), Role('BAP Admin')))
@route(
"<int:proje_id>/dashboard/satinalma/<int:satinalma_id>/teknik-sartname-kaydet",
methods=["POST"])
def satinalma_teknik_sartname_post(self, proje_id, satinalma_id):
"""
Satinalma talep kalemleri teknik sartname duzenleme kaydetme view,
"""
teknik_sartname_duzenle_form = TeknikSartnameDuzenlemeFormu(
request.form)
if not teknik_sartname_duzenle_form.validate():
return render_template(
"dashboard/teknik_sarname_duzenle.html",
proje_id=proje_id,
satinalma_id=satinalma_id,
teknik_sartname_duzenle_form=teknik_sartname_duzenle_form)
satinalma_talebi = DB.session.query(ProjeSatinAlmaTalebi).filter(
ProjeSatinAlmaTalebi.id == satinalma_id).first()
for talep_kalemi in satinalma_talebi.talep_kalemleri:
for talep_kalemi_form in teknik_sartname_duzenle_form.talep_kalemleri:
if talep_kalemi.id == talep_kalemi_form.talep_kalemi_id.data:
yeni_teknik_sartname = request.files.get(
talep_kalemi_form.yeni_teknik_sartname.name)
yeni_file = File(user_id=current_user.id,
content=yeni_teknik_sartname)
DB.session.add(yeni_file)
DB.session.flush()
talep_kalemi.teknik_sartname_file_id = yeni_file.id
talep_kalemi.teknik_sartname_duzenlensin_mi = False
DB.session.commit()
payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"teknik_sartname_duzenle").type_index,
"ekstra_mesaj":
"{} id li satınalmanin talep kalemleri teknik şartname dosyası bap "
"yetkilisi talebiyle yürütücü tarafından düzenlendi".format(
satinalma_id),
"nesne":
'ProjeSatinAlmaTalebi',
"nesne_id":
satinalma_talebi.id,
}
signal_sender(notification=True, **payload)
for yetkili in bap_yetkili_and_admin_ids():
payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("icerik").get(
"satinalma_duyurusu_duzenlendi").type_index,
"ekstra_mesaj":
"{} id'li satınalmanın teknik şartname dosyaları {} isimli "
"kullanıcı tarafından değiştrildi".format(
satinalma_id, current_user.username),
"notification_receiver":
yetkili.person_id,
"notification_title":
"{} İsimli Kullanıcı Teknik Şartname Düzenledi".format(
current_user.username),
"notification_message":
"{} isimli kullanıcı talep edilen teknik şartname düzenleme "
"işlemini gerçekleştirdi. Lütfen kontrol ediniz".format(
current_user.username),
"proje_id":
proje_id
}
signal_sender(log=False, notification=True, **payload)
flash(_("Teknik şartnameler başarıyla düzenlendi."))
return redirect(url_for("proje.satinalma_talepleri",
proje_id=proje_id))
class ProjeTuruGuncelleView(FlaskView):
"""Proje Türü View"""
excluded_methods = [
"proje_turu_ek_dosya_olustur", "proje_turu_cikti_olustur",
"init_proje_turu_form", "get_forms_with_type"
]
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["proje_turu"]
["proje_turu_yaratma_formu_goruntuleme"]))
@route('/<int:proje_turu_id>/guncelle',
methods=["POST"],
endpoint='proje_turu_guncelle_with_id')
def proje_turu_guncelle(self, proje_turu_id):
"""
Proje türünü güncellemek için kullanılacak method
Args:
proje_turu_id: güncellenecek proje tünün id si
Returns:
"""
proje = DB.session.query(
Proje.proje_turu).filter(Proje.proje_turu == proje_turu_id).all()
proje_turu_formu = ProjeTuruFormu(request.form)
try:
proje_turu = DB.session.query(ProjeTuru).options(
joinedload(ProjeTuru.butce),
joinedload(ProjeTuru.cikti),
joinedload(ProjeTuru.personel_ayarlari),
joinedload(ProjeTuru.ek_dosyalar),
).filter_by(id=proje_turu_id, guncel_mi=True).one()
except NoResultFound:
return redirect(url_for('.proje_turu'))
if proje:
flash(
"Proje türüne proje başvurusu yapılmış. Bu yüzden proje türünü güncelleyemezsiniz.",
"error")
return render_template("proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
proje_turu_id=proje_turu_id,
guncel_mi=proje_turu.guncel_mi,
basvuru_yapilmis_mi=True)
if not proje_turu_formu.validate():
hata_listesi = set()
form_errors_dict_to_set(proje_turu_formu.errors, hata_listesi)
return render_template("proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
proje_turu_id=proje_turu_id,
guncel_mi=proje_turu.guncel_mi,
basvuru_yapilmis_mi=False,
hata_mesajlari=hata_listesi)
if proje_turu.ad != proje_turu_formu.ad.data and DB.session.query(
ProjeTuru).filter(
ProjeTuru.ad == proje_turu_formu.ad.data
and ProjeTuru.tur_kodu != proje_turu.tur_kodu).scalar():
proje_turu_formu.ad.errors.append(
_("Proje Türü Adı Kullanılmaktadır. Lütfen Başka Bir Ad ile Tekrar Deneyiniz"
))
return render_template("proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
proje_turu_id=proje_turu_id,
guncel_mi=proje_turu.guncel_mi,
basvuru_yapilmis_mi=False)
try:
proje_turu.update_obj_data(proje_turu_formu.data)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
genel_uyari_mesajlari = {}
for uyari_mesaji in PROJE_TURU_UYARI_MESAJ_TIPLERI:
mesaj = getattr(proje_turu_formu, uyari_mesaji, None)
if mesaj:
genel_uyari_mesajlari[uyari_mesaji] = mesaj.data
proje_turu.genel_uyari_mesajlari = genel_uyari_mesajlari
try:
proje_turu.personel_ayarlari.update_obj_data(
proje_turu_formu.personel_ayarlari.data)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
try:
proje_turu.butce.update_obj_data(
proje_turu_formu.butce_ayarlari.data)
var_olan_butce_kalemleri = []
if proje_turu.butce_tercihi == ButceTercihleri.proje_yurutucusu_onersin.name:
butce_kalemleri_alt_limit = 0
butce_kalemleri_ust_limit = 0
for butce_kalemi in proje_turu_formu.butce_kalemleri:
butce_kalemleri_alt_limit += butce_kalemi.butce_alt_limiti.data
butce_kalemleri_ust_limit += butce_kalemi.butce_ust_limiti.data
if butce_kalemi.secili_mi.data:
if butce_kalemi.butce_ust_limiti.data > proje_turu.butce.butce_ust_limiti:
hata_mesaji = "{} değeri üst limiti bütçe üst limitinden büyük olamaz".format(
butce_kalemi.butce_kalemi_adi.data)
proje_turu_formu.errors.update({
proje_turu_formu.butce_ayarlari.form.butce_ust_limiti.name:
hata_mesaji
})
butce_kalemi.butce_ust_limiti.errors.append(
hata_mesaji)
for kayitli_kalem in proje_turu.butce_kalemleri:
if kayitli_kalem.gider_siniflandirma_id == \
butce_kalemi.gider_siniflandirma_id.data:
kayitli_kalem.update_obj_data(
butce_kalemi.data)
var_olan_butce_kalemleri.append(
kayitli_kalem.gider_siniflandirma_id)
break
else:
yeni_kalem = ButceKalemi(
proje_turu_id=proje_turu.id,
gider_siniflandirma_id=butce_kalemi.
gider_siniflandirma_id.data,
butce_alt_limiti=butce_kalemi.butce_alt_limiti.
data,
butce_ust_limiti=butce_kalemi.butce_ust_limiti.
data)
DB.session.add(yeni_kalem)
DB.session.flush()
var_olan_butce_kalemleri.append(
yeni_kalem.gider_siniflandirma_id)
for butce_kalemi in proje_turu.butce_kalemleri:
if butce_kalemi.gider_siniflandirma_id not in var_olan_butce_kalemleri:
DB.session.delete(butce_kalemi)
elif proje_turu.butce_tercihi == ButceTercihleri.butce_ile_ilgili_islem_yapmasin.name:
for butce_kalemi in proje_turu.butce_kalemleri:
DB.session.delete(butce_kalemi)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
try:
var_olan_ciktilar = []
for cikti in proje_turu_formu.ciktilar:
if cikti.cikti_id.data:
for kayitli_cikti in proje_turu.cikti:
if cikti.cikti_id.data == kayitli_cikti.id:
var_olan_ciktilar.append(kayitli_cikti.id)
kayitli_cikti.adi = cikti.adi.data
kayitli_cikti.cikti_sablonu_id = cikti.cikti_sablonu_id.data
kayitli_cikti.gorunurluk = cikti.gorunurluk.data
kayitli_cikti.belge_ciktisi_alinacak_mi = cikti. \
belge_ciktisi_alinacak_mi.data
else:
cikti_obj = Cikti(proje_turu_id=proje_turu_id,
adi=cikti.adi.data,
sablon_id=cikti.cikti_sablonu_id.data,
gorunurluk=cikti.gorunurluk.data,
belge_ciktisi_alinacak_mi=cikti.
belge_ciktisi_alinacak_mi.data)
DB.session.add(cikti_obj)
DB.session.flush()
var_olan_ciktilar.append(cikti_obj.id)
for cikti in proje_turu.cikti:
if cikti.id not in var_olan_ciktilar:
DB.session.delete(cikti)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
try:
var_olan_dosyalar = []
for ek_dosya in proje_turu_formu.ek_dosyalar:
if ek_dosya.ek_dosya_id.data:
for kayitli_ek_dosya in proje_turu.ek_dosyalar:
if ek_dosya.ek_dosya_id.data == kayitli_ek_dosya.id:
var_olan_dosyalar.append(kayitli_ek_dosya.id)
request_file = request.files.get(
ek_dosya.belge.file_id.name, None)
if request_file:
file = File(content=request_file,
user_id=current_user.id)
DB.session.add(file)
DB.session.flush()
kayitli_ek_dosya.belge.file_id = file.id
kayitli_ek_dosya.belge.adi = ek_dosya.belge.adi.data
kayitli_ek_dosya.belge.aciklama = ek_dosya.belge.aciklama.data
kayitli_ek_dosya.zorunlu_mu = ek_dosya.zorunlu_mu.data
kayitli_ek_dosya.proje_icerik_dosyasi_mi = ek_dosya. \
proje_icerik_dosyasi_mi.data
kayitli_ek_dosya.belgenin_ciktisi_alinacak_mi = ek_dosya. \
belgenin_ciktisi_alinacak_mi.data
else:
request_file = request.files.get(
ek_dosya.belge.file_id.name, None)
if request_file:
file = File(content=request_file,
user_id=current_user.id)
DB.session.add(file)
DB.session.flush()
bap_belge = BAPBelge(adi=ek_dosya.belge.adi.data,
file_id=file.id,
aciklama=ek_dosya.belge.adi.data)
DB.session.add(bap_belge)
DB.session.flush()
ek_dosya_obj = EkDosya(
proje_turu_id=proje_turu_id,
dosya_id=bap_belge.id,
zorunlu_mu=ek_dosya.zorunlu_mu.data,
proje_icerik_dosyasi_mi=ek_dosya.
proje_icerik_dosyasi_mi.data,
belgenin_ciktisi_alinacak_mi=ek_dosya.
belgenin_ciktisi_alinacak_mi.data)
DB.session.add(ek_dosya_obj)
DB.session.flush()
var_olan_dosyalar.append(ek_dosya_obj.id)
for ek_dosya in proje_turu.ek_dosyalar:
if ek_dosya.id not in var_olan_dosyalar:
DB.session.delete(ek_dosya)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
if proje_turu_formu.errors:
DB.session.rollback()
hata_listesi = set()
form_errors_dict_to_set(proje_turu_formu.errors, hata_listesi)
return render_template("proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
proje_turu_id=proje_turu_id,
guncel_mi=proje_turu.guncel_mi,
basvuru_yapilmis_mi=False,
hata_mesajlari=hata_listesi)
DB.session.commit()
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"proje_turu_guncelle").type_index,
"nesne":
'Proje Turu',
"nesne_id":
proje_turu.id,
"ekstra_mesaj":
"{} adli user, {} kategorili, {} isimli proje türünü "
"guncelledi.".format(current_user.username, proje_turu.kategori,
proje_turu.ad)
}
signal_sender(**signal_payload)
flash(_("İşleminiz başarıyla gerçekleştirildi."))
return redirect(url_for('proje.ProjeTuruView:proje_turu_listele'))
class HataLoglariView(FlaskView):
"""Hata loglarini listeleyip detay olarak goruntuledigimiz view"""
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict['sistem_takibi']['hata_loglari']
['hata_loglari_goruntuleme']),
menu_registry={
"path": ".sistem_takibi.hata_loglari",
"title": _("Hata Logları")
})
@route('listele', methods=['GET'])
def hata_loglari():
"""Hata loglarini listeler"""
# todo: pagination ozelligi eklenmesi gerekiyor.
loglar = DB.session.query(AppLog).filter(
AppLog.level == "ERROR").order_by(desc(AppLog.created_at)).all()
return render_template("hata_loglari/hata_loglari.html",
hata_loglari=loglar)
@staticmethod
@login_required
@auth.requires(Permission("Hata Logları Görüntüleme", "Sistem Takibi", 31))
@route('listele/data', methods=['POST'])
def hata_loglari_datatable():
"""Hata loglarini Datatable'a gonderir"""
loglar = DB.session.query(AppLog).filter(AppLog.level == "ERROR")
dts = DataTableServer(columns={
0: AppLog.id,
1: AppLog.created_at,
2: AppLog.user_id,
3: AppLog.remote_addr,
4: AppLog.url,
5: AppLog.method
},
qry=loglar)
result = dts.query(request)
data = [[
r.id,
time.strftime("%d-%m-%Y %H:%M:%S",
time.localtime(r.created_at)), r.user_id,
r.remote_addr if r.remote_addr else "-", r.url, r.method, f"""
<a class="detail_arrow"
href="{ url_for('sistem_takibi.hata_log_detay', log_id=r.id) }"><span
class="fa fa-arrow-circle-right fa-2x "></span></a>
"""
] for r in result.items]
return jsonify({
"data": data,
"recordsFiltered": result.total,
"recordsTotal": result.filtered_from
})
@staticmethod
@login_required
@auth.requires(
Permission(*permission_dict['sistem_takibi']['hata_loglari']
['hata_loglari_goruntuleme']))
@route('<int:log_id>/detay', methods=['GET'], endpoint='hata_log_detay')
def hata_log_detay(log_id):
"""Hata logunun detayini goruntuler"""
try:
log = DB.session.query(AppLog).filter(AppLog.id == log_id).one()
except NoResultFound:
return abort(404)
request_details = json.loads(log.request_details)
return render_template("hata_loglari/hata_log_detay.html",
traceback=log.msg,
request_details=request_details,
log=log)
class BapFirmaView(FlaskView):
"""Bap anasyafa view classi"""
@staticmethod
@login_required
@auth.requires(Or(
Permission(*permission_dict["yonetim"]["firma_yonetimi"]
["firma_listesi_goruntuleme"]), Role("BAP Yetkilisi")),
menu_registry={
'path': '.yonetim.firma_yonetimi.firma_listesi',
'title': _("Firma Listesi")
})
@route('/firma-liste', methods=['GET'])
def firma_liste():
"""Firma Listesi Ekrani"""
firmalar = DB.session.query(BapFirma).options(joinedload(
BapFirma.user)).all()
onay_bekleyen_firmalar = []
reddedilen_firmalar = []
kabul_edilen_firmalar = []
for firma in firmalar:
if firma.onaylandi:
kabul_edilen_firmalar.append(firma)
elif firma.reddedildi_mi:
reddedilen_firmalar.append(firma)
else:
onay_bekleyen_firmalar.append(firma)
return render_template("firma_liste.html",
kabul_edilen_firmalar=kabul_edilen_firmalar,
reddedilen_firmalar=reddedilen_firmalar,
onay_bekleyen_firmalar=onay_bekleyen_firmalar)
@staticmethod
@login_required
@auth.requires(
Or(
Permission(*permission_dict["yonetim"]["firma_yonetimi"]
["firma_goruntuleme"]), Role("BAP Yetkilisi")))
@route('/firma-detay/<int:firma_id>', methods=['GET'])
def firma_detay(firma_id):
"""Firma Listesi Ekrani"""
firma = DB.session.query(BapFirma).filter(
BapFirma.id == firma_id).one()
form = FirmaKayitFormu(**firma.to_dict())
return render_template("firma_bilgileri.html", firma=firma, form=form)
@staticmethod
@login_required
@auth.requires(
Or(
Permission(*permission_dict["yonetim"]["firma_yonetimi"]
["firma_guncelleme"]), FirmaYetkilisi()))
@route('/firma-detay-guncelle/<int:firma_id>',
methods=['POST'],
endpoint='firma_detay_guncelle')
def firma_detay_guncelle(firma_id):
"""Firma Listesi Ekrani"""
firma = DB.session.query(BapFirma).filter(
BapFirma.id == firma_id).one()
form = FirmaKayitFormu(request.form)
form.yetkili_email.validators = None
form.yetkili_adi.validators = None
form.yetkili_soyadi.validators = None
form.adres.validators = None
form.firma_faaliyet_belgesi_id.validators = None
form.telefon.validators = None
form.email.validators = None
firma.yetkili_adi = form.yetkili_adi.data
firma.yetkili_soyadi = form.yetkili_soyadi.data
firma.yetkili_email = form.yetkili_email.data
firma.adres = form.adres.data
firma_faaliyet_belgesi_id = request.files.get(
form.firma_faaliyet_belgesi_id.name)
if firma_faaliyet_belgesi_id:
firma.firma_faaliyet_belgesi_id = firma_faaliyet_belgesi_id
firma.telefon = form.telefon.data
firma.email = form.email.data
DB.session.commit()
flash("Firma bilgileri başarıyla güncellenmiştir.")
return redirect(url_for('firma.firma_detay', firma_id=firma.id))
@staticmethod
@login_required
@auth.requires(
Or(
Permission(*permission_dict["yonetim"]["firma_yonetimi"]
["firma_goruntuleme"]), Role("BAP Yetkilisi")))
@route('/faaliyet-belgesi-indir/<int:firma_id>',
methods=['GET'],
endpoint="firma_faaliyet_belgesi_indir")
def firma_faaliyet_belgesi_indir(firma_id):
"""Firma Listesi Ekrani"""
firma = DB.session.query(BapFirma).get(firma_id)
try:
belge = DB.session.query(File).filter(
File.id == firma.firma_faaliyet_belgesi_id).one()
return send_file(belge.file_object,
attachment_filename=belge.content.file.filename,
as_attachment=True,
mimetype=belge.content.file.content_type)
except Exception as exc:
CustomErrorHandler.error_handler()
return abort(400)
@login_required
@auth.requires(
Or(
Permission(*permission_dict["yonetim"]["firma_yonetimi"]
["firma_onaylama"]), Role("BAP Yetkilisi"),
Role("BAP Admin")))
@route('/firma-onay/<int:firma_id>', methods=['POST'])
def firma_onay(self, firma_id):
onay = bool(int(request.get_json().get('onay')))
firma = DB.session.query(BapFirma).filter(
BapFirma.id == firma_id).first()
if not onay:
firma.onaylandi = False
firma.reddedildi_mi = True
firma.faaliyet_durumu = False
DB.session.commit()
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get("firma_red").type_index,
"nesne":
'BapFirma',
"nesne_id":
firma.id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} idli firmayı reddetti.".format(
current_user.username, firma.id)
}
signal_sender(**signal_payload)
return jsonify(status="success")
else:
firma.onaylandi = True
firma.faaliyet_durumu = True
firma.reddedildi_mi = False
DB.session.commit()
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get("firma_onay").type_index,
"nesne":
'BapFirma',
"nesne_id":
firma.id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} idli firmayı onayladı.".format(
current_user.username, firma.id)
}
signal_sender(**signal_payload)
flash("Firma başarıyla onaylanmıştır..")
return jsonify(status="success")
class ProjeTuruKaydetView(FlaskView):
"""Proje Türü View"""
excluded_methods = [
"proje_turu_ek_dosya_olustur", "proje_turu_cikti_olustur",
"init_proje_turu_form", "init_sabit_butce_kalemleri",
"get_forms_with_type"
]
@login_required
@auth.requires(
Permission(*permission_dict["bap"]["proje"]["proje_turu"]
["proje_turu_yaratma_formu_goruntuleme"]))
@route('/kaydet', methods=["POST"], endpoint='proje_turu_kaydet')
def kaydet(self):
"""Yeni proje turu kaydet"""
versiyonlanacak_proje_turu_id = request.args.get("id", None)
proje_turu_formu = ProjeTuruFormu(request.form)
eski_proje_turu = None
if not proje_turu_formu.validate():
hata_listesi = set()
form_errors_dict_to_set(proje_turu_formu.errors, hata_listesi)
proje = None
if versiyonlanacak_proje_turu_id:
proje = DB.session.query(Proje.proje_turu).filter(
Proje.proje_turu == versiyonlanacak_proje_turu_id).all()
return render_template(
"proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
guncel_mi=True,
proje_turu_id=versiyonlanacak_proje_turu_id
if versiyonlanacak_proje_turu_id else None,
basvuru_yapilmis_mi=True if proje else False,
hata_mesajlari=hata_listesi)
# Bu kontrol requestin proje_türü oluşturmak için veya var olan bir proje türünü
# versiyonlamak için mi atıldığını kontrol eder
if versiyonlanacak_proje_turu_id:
# url parametresi id değeri varsa versiyonlama işlemi yapılacak demektir.
# gelen id geçerli bir proje_turu id olup olmadığı kontrol edilir.
eski_proje_turu = DB.session.query(ProjeTuru).filter_by(
id=versiyonlanacak_proje_turu_id).first()
if not eski_proje_turu:
return redirect("/bap/proje-turu")
else:
# Proje türü adı kontrolü yapılır.Eğer farklı tür kodlu bir proje_turu bu adı
# kullanıyorsa gerekli hata mesajı dönülür
if proje_turu_formu.ad.data != eski_proje_turu.ad:
mevcut_proje_turu = DB.session.query(ProjeTuru).filter(
ProjeTuru.ad == proje_turu_formu.ad.data
and ProjeTuru.tur_kodu !=
eski_proje_turu.tur_kodu).scalar()
if mevcut_proje_turu:
proje = DB.session.query(Proje.proje_turu).filter(
Proje.proje_turu ==
versiyonlanacak_proje_turu_id).all()
proje_turu_formu.ad.errors.append(
_("Proje Türü Adı Kullanılmaktadır. Lütfen Başka Bir Ad ile "
"Tekrar Deneyiniz"))
return render_template(
"proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
proje_turu_id=versiyonlanacak_proje_turu_id,
guncel_mi=eski_proje_turu.guncel_mi,
basvuru_yapilmis_mi=True if proje else False)
tur_kodu = eski_proje_turu.tur_kodu
else:
# Url ile birlikte bir id değeri gelmediği için
# yeni bir proje türü kaydedilecek demektir.
if DB.session.query(ProjeTuru).filter_by(
ad=proje_turu_formu.ad.data).first():
proje_turu_formu.ad.errors.append(
_("Proje Türü Adı Kullanılmaktadır. Lütfen Başka Bir Ad ile Tekrar Deneyiniz"
))
return render_template("proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
basvuru_yapilmis_mi=False,
aktif_mi=True)
max_tur_kodu = DB.session.query(func.max(
ProjeTuru.tur_kodu)).first()[0]
tur_kodu = max_tur_kodu + 1 if max_tur_kodu else 1
try:
try:
# formun içerisindeki uyarı mesajlarından dict oluşturulur.
genel_uyari_mesajlari = {}
for uyari_mesaji in PROJE_TURU_UYARI_MESAJ_TIPLERI:
mesaj = getattr(proje_turu_formu, uyari_mesaji, None)
if mesaj:
genel_uyari_mesajlari[uyari_mesaji] = mesaj.data
# proje_turu_formu içerisindeki veri ProjeTuru modeli fieldlarına göre filtrelenir.
# Sadece eşleşen fieldlardan oluşmuş bir dict elde edilir
proje_turu_data = ProjeTuru.data_to_dict(proje_turu_formu.data)
# proje_turu modelinden instance oluşturulur.
proje_turu = ProjeTuru(guncel_mi=True,
tur_kodu=tur_kodu,
**proje_turu_data)
proje_turu.genel_uyari_mesajlari = genel_uyari_mesajlari
DB.session.add(proje_turu)
DB.session.flush()
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
DB.session.rollback()
return render_template("proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
basvuru_yapilmis_mi=False,
guncel_mi=True)
try:
# proje_turu_formu içerisindeki veri Butce modeli fieldlarına göre filtrelenir.
# Sadece eşleşen fieldlardan oluşmuş bir dict elde edilir
butce_data = proje_turu_formu.butce_ayarlari.data
butce = Butce(proje_turu_id=proje_turu.id, **butce_data)
DB.session.add(butce)
DB.session.flush()
if proje_turu.butce_tercihi == ButceTercihleri.proje_yurutucusu_onersin.name:
butce_kalemleri_alt_limit = 0
butce_kalemleri_ust_limit = 0
for butce_kalemi in proje_turu_formu.butce_kalemleri:
if butce_kalemi.secili_mi.data:
if butce_kalemi.butce_ust_limiti.data > butce.butce_ust_limiti:
hata_mesaji = "{} değeri üst limiti bütçe üst limitinden büyük olamaz".format(
butce_kalemi.butce_kalemi_adi.data)
proje_turu_formu.errors.update({
proje_turu_formu.butce_ayarlari.form.butce_ust_limiti.name:
hata_mesaji
})
butce_kalemi.butce_ust_limiti.errors.append(
hata_mesaji)
butce_kalemleri_alt_limit += butce_kalemi.butce_alt_limiti.data
butce_kalemleri_ust_limit += butce_kalemi.butce_ust_limiti.data
butce_kalemi_obj = ButceKalemi(
proje_turu_id=proje_turu.id,
gider_siniflandirma_id=butce_kalemi.
gider_siniflandirma_id.data,
butce_alt_limiti=butce_kalemi.butce_alt_limiti.
data,
butce_ust_limiti=butce_kalemi.butce_ust_limiti.
data)
DB.session.add(butce_kalemi_obj)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
try:
# proje_turu_formu içerisindeki veri PersonelAyarlari modeli fieldlarına göre
# filtrelenir. Sadece eşleşen fieldlardan oluşmuş bir dict elde edilir
personel_ayarlari_data = proje_turu_formu.personel_ayarlari.data
personel_ayarlari = PersonelAyarlari(
proje_turu_id=proje_turu.id, **personel_ayarlari_data)
DB.session.add(personel_ayarlari)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
try:
self.proje_turu_cikti_olustur(proje_turu.id,
proje_turu_formu.ciktilar)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
try:
self.proje_turu_ek_dosya_olustur(proje_turu.id,
proje_turu_formu.ek_dosyalar)
except ZopseduModelValueError as exc:
form_field = getattr(proje_turu_formu, exc.field_name, None)
form_field.errors.append(str(exc))
if proje_turu_formu.errors:
DB.session.rollback()
hata_listesi = set()
form_errors_dict_to_set(proje_turu_formu.errors, hata_listesi)
return render_template(
"proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
guncel_mi=True,
proje_turu_id=versiyonlanacak_proje_turu_id
if versiyonlanacak_proje_turu_id else None,
basvuru_yapilmis_mi=False,
hata_mesajlari=hata_listesi)
# Bütün işlemler başarılı bir şekilde gerçekleşirse eski versiyon proje türünün
# güncel_mi field ı false yapılır.
if eski_proje_turu:
eski_proje_turu.guncel_mi = False
eski_proje_turu.basvuru_aktif_mi = False
DB.session.commit()
if versiyonlanacak_proje_turu_id:
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"proje_turu_versiyonla").type_index,
"nesne":
'Proje Turu',
"nesne_id":
proje_turu.id,
"ekstra_mesaj":
"{} adli user, {} id'li proje türünü versiyonladi.".format(
current_user.username, versiyonlanacak_proje_turu_id)
}
signal_sender(**signal_payload)
else:
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"proje_turu_olusturuldu").type_index,
"nesne":
'Proje Turu',
"nesne_id":
proje_turu.id,
"ekstra_mesaj":
"{} adli user, {} kategorili, {} isimli yeni proje türü "
"olusturdu.".format(current_user.username,
proje_turu.kategori, proje_turu.ad)
}
signal_sender(**signal_payload)
except IntegrityError as exc:
CustomErrorHandler.error_handler(
hata="Bir hata oluştur. Hata: {}".format(exc))
DB.session.rollback()
return render_template(
"proje_turu/proje_turu.html",
proje_turu_formu=proje_turu_formu,
errors="Beklenmedik hata") # todo: cem, handle in template
flash(_("İşleminiz başarıyla gerçekleştirildi."))
return redirect(url_for('proje.ProjeTuruView:proje_turu_listele'))
@staticmethod
def proje_turu_ek_dosya_olustur(proje_turu_id, form_ek_dosyalar):
"""
Form_ek_dosyalar argumanındaki verilerden ek_dosyalar modelinden instance oluşturur.
proje_turu_id aracılıgıyla proje türü modeliyle relation kurulur.
Args:
proje_turu_id(Int): ilişkilendirilecek proje türünün id si
form_ek_dosyalar(Form): verilerin bulunduğu formun ek dosyalar bölümü
Returns:
"""
for ek_dosya in form_ek_dosyalar:
request_file = request.files.get(ek_dosya.belge.file_id.name, None)
if request_file:
file = File(content=request_file, user_id=current_user.id)
DB.session.add(file)
DB.session.flush()
bap_belge = BAPBelge(adi=ek_dosya.belge.adi.data,
file_id=file.id,
aciklama=ek_dosya.belge.adi.data)
DB.session.add(bap_belge)
DB.session.flush()
ek_dosya_obj = EkDosya(proje_turu_id=proje_turu_id,
dosya_id=bap_belge.id,
zorunlu_mu=ek_dosya.zorunlu_mu.data,
proje_icerik_dosyasi_mi=ek_dosya.
proje_icerik_dosyasi_mi.data,
belgenin_ciktisi_alinacak_mi=ek_dosya.
belgenin_ciktisi_alinacak_mi.data)
DB.session.add(ek_dosya_obj)
@staticmethod
def proje_turu_cikti_olustur(proje_turu_id, form_ciktilar):
"""
form_ciktilar argumanındaki verilerden cikti modelinden instance oluşturur.
proje_turu_id aracılıgıyla proje türü modeliyle relation kurulur.
Args:
proje_turu_id(Int): ilişkilendirilecek proje türünün id si
form_ciktilar: formun cıktılar bölümü
Returns:
"""
for cikti in form_ciktilar:
cikti_obj = Cikti(
proje_turu_id=proje_turu_id,
adi=cikti.adi.data,
sablon_id=cikti.cikti_sablonu_id.data,
gorunurluk=cikti.gorunurluk.data,
belge_ciktisi_alinacak_mi=cikti.belge_ciktisi_alinacak_mi.data)
DB.session.add(cikti_obj)
class SatinalmaMuhasebeFisleri(FlaskView):
"""
Satinalma muhasebe fisi islemleri
"""
def get_siparis_with_firma_and_talep_kalemleri(self, siparis_id):
"""
id si verilen siparisin faturası teslim alındı ise satınalma talep kalemleri ve firma ile
birlikte getirir
:param siparis_id: siparis id
:return: SiparisTakip instance
"""
siparis = DB.session.query(SiparisTakip).options(
joinedload(SiparisTakip.satinalma_talep_kalemleri),
joinedload(SiparisTakip.kazanan_firma_teklif).joinedload(
FirmaTeklifKalemi.satinalma_teklif).joinedload(
FirmaSatinalmaTeklif.firma)
).filter(
SiparisTakip.siparis_durumu == SiparisDurumu.fatura_teslim_alindi,
SiparisTakip.id == siparis_id
).first()
return siparis
def get_proje_for_muhasebe_fisi(self, proje_id):
"""
"proje_id" li projeyi proje yurutucusu fakultesi ve bolumu join edilmis sekilde getirir
:param proje_id: satinalma proje id
:return: Proje model instance
"""
proje = DB.session.query(Proje).options(
joinedload(Proje.proje_yurutucu),
joinedload(Proje.fakulte),
joinedload(Proje.bolum),
joinedload(Proje.gelir_kasasi)
).filter(Proje.id == proje_id).first()
return proje
@login_required
@auth.requires(
Or(Permission(*permission_dict["bap"]["satinalma"]["satinalma_muhasebe_fisi_goruntule"]),
RoleReq('BAP Yetkilisi'), RoleReq("BAP Admin")))
@route('/<int:satinalma_id>/muhase-fisleri', methods=['GET'])
def muhasebe_fisleri(self, satinalma_id):
"""
muhasebe fislerini listeleyen view methodu
:param satinalma_id: ilgili satinalma id
"""
try:
satinalma = get_satinalma_with_related_fields(satinalma_id=satinalma_id)
states_info = get_satinalma_next_states_info(satinalma_id=satinalma_id)
actions_info = get_satinalma_actions_info(satinalma_id=satinalma_id)
proje = DB.session.query(Proje).filter(Proje.id == satinalma.proje_id).first()
satinalma_talep_kalemleri_ids = [talep_kalemi.id for talep_kalemi in
satinalma.talep_kalemleri]
satinalma_muhasebe_fisleri = DB.session.query(MuhasebeFisi).filter(
MuhasebeFisi.satinalma_talep_id == satinalma_id
).all()
satinalma_siparisleri = DB.session.query(SiparisTakip).options(
joinedload(SiparisTakip.satinalma_talep_kalemleri),
joinedload(SiparisTakip.kazanan_firma_teklif).joinedload(
FirmaTeklifKalemi.satinalma_teklif).joinedload(
FirmaSatinalmaTeklif.firma)
).filter(
SiparisTakip.satinalma_talep_kalemleri_id.in_(satinalma_talep_kalemleri_ids),
SiparisTakip.siparis_durumu == SiparisDurumu.fatura_teslim_alindi
).all()
siparis_data = []
for siparis in satinalma_siparisleri:
kdv_dahil_fiyat = kdv_dahil_fiyat_hesabi(siparis.kazanan_firma_teklif.teklif,
siparis.kazanan_firma_teklif.kdv_orani)
if not siparis.satinalma_talep_kalemleri.muhasebe_fis_id:
siparis_data.append({
"siparis_id": siparis.id,
"proje_kalemi": siparis.satinalma_talep_kalemleri.proje_kalemi.ad,
"miktar": siparis.satinalma_talep_kalemleri.talep_miktari,
"birim": siparis.satinalma_talep_kalemleri.proje_kalemi.birim.value,
"kdv_dahil_tutar": kdv_dahil_fiyat,
"tutar": siparis.kazanan_firma_teklif.teklif,
"siparis_numarasi": siparis.siparis_numarasi,
"firma_adi": siparis.kazanan_firma_teklif.satinalma_teklif.firma.adi,
"kabul_tarihi": siparis.kabul_tarihi
})
muhasebe_information_form = MuhasebeFisiListelemeInformation()
except Exception as exc:
CustomErrorHandler.error_handler(hata="Satinalma muhasebe fişi listesi görüntülenirken "
"hata oluştu.Hata: {}, Satinalma id: {}".format(
satinalma_id,
exc)
)
return abort(500)
return render_template("satinalma_dashboard/muhasebe_fisleri.html",
muhasebe_information_form=muhasebe_information_form,
muhesabe_fisleri=satinalma_muhasebe_fisleri,
satinalma_siparisleri=siparis_data,
satinalma=satinalma,
satinalma_id=satinalma_id,
proje=proje,
actions_info=actions_info,
states_info=states_info)
@login_required
@auth.requires(
Or(Permission(*permission_dict["bap"]["satinalma"]["satinalma_muhasebe_fisi_olustur"]),
RoleReq('BAP Yetkilisi'), RoleReq("BAP Admin")))
@route('/<int:satinalma_id>/siparis/<int:siparis_id>/muhase-fisi-olustur', methods=['GET'])
def muhasebe_fisi_olustur_get(self, satinalma_id, siparis_id):
"""
Muhasebe fisi olusturma ekrani
:param satinalma_id: ilgili satinalma id
:param firma_id: muhasebe fisinin kesilecegi firma id
"""
try:
universite_id = SessionHandler.universite_id()
satinalma = get_satinalma_with_related_fields(satinalma_id=satinalma_id)
proje = self.get_proje_for_muhasebe_fisi(satinalma.proje_id)
siparis = self.get_siparis_with_firma_and_talep_kalemleri(siparis_id)
if not siparis:
flash(_("Böyle bir sipariş bulunamadı"), category="error")
return redirect(url_for("satinalma.SatinalmaMuhasebeFisleri:muhasebe_fisleri",
satinalma_id=satinalma_id))
if siparis.satinalma_talep_kalemleri.muhasebe_fis_id:
flash(_("Bu sipariş için daha önce muhasebe fişi oluşturdunuz."), category="error")
return redirect(url_for("satinalma.SatinalmaMuhasebeFisleri:muhasebe_fisleri",
satinalma_id=satinalma_id))
proje_bilgiler_data = self.get_proje_bilgileri(proje)
genel_ayarlar = DB.session.query(GenelAyarlar).filter_by(universite_id=universite_id,
aktif_mi=True).first()
firma_bilgileri = siparis.kazanan_firma_teklif.satinalma_teklif.firma
kisi_bilgileri = self.get_kisi_bilgiler(firma_bilgileri)
kdv_dahil_alacak = kdv_dahil_fiyat_hesabi(siparis.kazanan_firma_teklif.teklif,
siparis.kazanan_firma_teklif.kdv_orani)
proje_kalemi = siparis.satinalma_talep_kalemleri.proje_kalemi
proje_kalemi_data = self.get_proje_kalemi_data(proje_kalemi, kdv_dahil_alacak)
fatura_bilgisi_data = self.get_fatura_bilgileri(siparis)
muhasebe_fis_formu = self.init_muhasebe_fisi_form(genel_ayarlar,
kisi_bilgileri,
kdv_dahil_alacak,
proje,
fatura_bilgisi_data)
# simdiki yil ve siparis id birlesiminden belge numarasi uretir
belge_numarasi = "{}{}".format(date.today().year, siparis.id)
muhasebe_fis_formu.fis_genel_bilgileri.belge_numarasi.data = belge_numarasi
except Exception as exc:
CustomErrorHandler.error_handler(hata="Satinalma muhasebe fişi listesi görüntülenirken "
"hata oluştu.Hata: {}, Satinalma id: {}".format(
satinalma_id,
exc)
)
return abort(500)
return render_template("satinalma_dashboard/muhasebe_fisi_olustur.html",
muhasebe_fis_formu=muhasebe_fis_formu,
proje_bilgileri=proje_bilgiler_data,
proje_kalemi_data=proje_kalemi_data,
satinalma=satinalma,
satinalma_id=satinalma_id,
siparis_id=siparis_id)
@login_required
@auth.requires(
Or(Permission(*permission_dict["bap"]["satinalma"]["satinalma_muhasebe_fisi_olustur"]),
RoleReq('BAP Yetkilisi'), RoleReq("BAP Admin")))
@route('/<int:satinalma_id>/siparis/<int:siparis_id>/muhase-fisi-olustur', methods=['POST'])
def muhasebe_fisi_olustur_post(self, satinalma_id, siparis_id):
"""
Muhasebe fisi olusturma kaydeden view methodu
:param satinalma_id: ilgili satinalma id
:param siparis_id: muhasebe fisinin kesilecegi siparis id
"""
# todo: kasa bilgileri gosterilecek!
try:
universite_id = SessionHandler.universite_id()
satinalma = get_satinalma_with_related_fields(satinalma_id=satinalma_id)
proje = self.get_proje_for_muhasebe_fisi(satinalma.proje_id)
proje_bilgiler_data = self.get_proje_bilgileri(proje)
genel_ayarlar = DB.session.query(GenelAyarlar).filter_by(universite_id=universite_id,
aktif_mi=True).first()
fonksiyonel_kod_choices = self.get_fonksiyonel_kod_choices(
genel_ayarlar.bap_butce.get("fonksiyonel_kodlar", None)
)
siparis = self.get_siparis_with_firma_and_talep_kalemleri(siparis_id)
kdv_dahil_tutar = kdv_dahil_fiyat_hesabi(siparis.kazanan_firma_teklif.teklif,
siparis.kazanan_firma_teklif.kdv_orani)
proje_kalemi = siparis.satinalma_talep_kalemleri.proje_kalemi
proje_kalemi_data = self.get_proje_kalemi_data(proje_kalemi, kdv_dahil_tutar)
muhasebe_fis_formu = MuhasebeFisiForm(request.form)
for fis_maddesi in muhasebe_fis_formu.fis_maddeleri:
fis_maddesi.fonksiyonel_kod.choices = fonksiyonel_kod_choices
if not muhasebe_fis_formu.validate():
return render_template("satinalma_dashboard/muhasebe_fisi_olustur.html",
muhasebe_fis_formu=muhasebe_fis_formu,
proje_bilgileri=proje_bilgiler_data,
proje_kalemi_data=proje_kalemi_data,
satinalma=satinalma,
satinalma_id=satinalma_id,
siparis_id=siparis_id)
# belge numarasinin daha once atanmis olma durumu kontrol edilir
belge_numarasi_exist = DB.session.query(exists().where(
MuhasebeFisi.muhasebe_fis_no == muhasebe_fis_formu.fis_genel_bilgileri.belge_numarasi.data)).scalar()
if belge_numarasi_exist:
oneri_belge_numarasi = "{}{}".format(date.today().year, siparis_id)
hata_mesaji = "Muhasebe fişi belge numarası kullanılmaktadır. (Öneri belge " \
"numarası {})".format(oneri_belge_numarasi)
muhasebe_fis_formu.fis_genel_bilgileri.belge_numarasi.errors.append(hata_mesaji)
return render_template("satinalma_dashboard/muhasebe_fisi_olustur.html",
muhasebe_fis_formu=muhasebe_fis_formu,
proje_bilgileri=proje_bilgiler_data,
proje_kalemi_data=proje_kalemi_data,
satinalma=satinalma,
satinalma_id=satinalma_id,
siparis_id=siparis_id)
proje_kalemi = siparis.satinalma_talep_kalemleri.proje_kalemi
talep_edilen_miktar = siparis.satinalma_talep_kalemleri.talep_miktari
# firma teklifi kabul edildigi zaman firmanin teklifinin kdv dahil tutari rezerv
# butce olarak proje kalemine eklenmisti. Muhasebe fisi olusturuldugu anda rezerv
# edilen para kullanilan paraya aktarilir
proje_kalemi.rezerv_butce = proje_kalemi.rezerv_butce - kdv_dahil_tutar
proje_kalemi.kullanilan_butce = proje_kalemi.kullanilan_butce + kdv_dahil_tutar
# proje yurutucusu satinalma talebi yaptigi anda talep edilen miktar rezerv edilmisti
# Muhasebe fisi olusturuldugu anda rezerv miktar kullanilan miktara aktarilir
proje_kalemi.rezerv_edilen_miktar = proje_kalemi.rezerv_edilen_miktar - talep_edilen_miktar
proje_kalemi.kullanilan_miktar = proje_kalemi.kullanilan_miktar + talep_edilen_miktar
proje_bilgileri_data = self.get_proje_bilgileri(proje)
yeni_muhasebe_fisi = self.muhasebe_fisi_kaydet(
muhasebe_fis_formu,
proje_bilgileri_data["proje_no"],
proje_bilgileri_data["proje_yurutucu_ad_soyad"],
satinalma_id=satinalma_id,
fis_tutari=kdv_dahil_tutar
)
DB.session.add(yeni_muhasebe_fisi)
DB.session.flush()
self.muhasebe_fis_maddesi_kaydet(muhasebe_fis_formu.fis_maddeleri,
yeni_muhasebe_fisi.id)
siparis.satinalma_talep_kalemleri.muhasebe_fis_id = yeni_muhasebe_fisi.id
siparis.siparis_durumu = SiparisDurumu.siparis_tamamlandi
projenin_bagli_oldugu_kasa = proje.gelir_kasasi
projenin_bagli_oldugu_kasa.rezerv_para -= kdv_dahil_tutar
projenin_bagli_oldugu_kasa.harcanan_para += kdv_dahil_tutar
signal_payload = {
"message_type": USER_ACTIVITY_MESSAGES.get("bap").get("muhasebe_fisi_olusturuldu").type_index,
"nesne": 'Proje',
"nesne_id": proje.id,
"ekstra_mesaj": "{} isimli kullanıcı {} id'li projenin {} id'li proje kaleminde "
"yapilan satınalma sonucu {} id 'li {} TL tutarında muhasebe fişi "
"oluşturdu".format(
current_user.username,
proje.id,
proje_kalemi.id,
yeni_muhasebe_fisi.id,
kdv_dahil_tutar
)
}
signal_sender(**signal_payload)
DB.session.commit()
flash(_("Muhasebe fişi başarıyla oluşturulmuştur."), category="success")
return redirect(url_for("satinalma.SatinalmaMuhasebeFisleri:muhasebe_fisleri",
satinalma_id=satinalma_id))
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(hata="Satinalma muhasebe fişi listesi görüntülenirken "
"hata oluştu.Hata: {}, Satinalma id: {}".format(
satinalma_id,
exc)
)
return abort(500)
@login_required
@auth.requires(
Or(Permission(*permission_dict["bap"]["satinalma"]["satinalma_muhasebe_fisi_olustur"]),
RoleReq('BAP Yetkilisi'), RoleReq("BAP Admin")))
@route('/<int:satinalma_id>/muhasebe-fisi/<int:muhasebe_fis_id>', methods=['GET'])
def get_odeme_emri_sablonu(self, satinalma_id, muhasebe_fis_id):
"""
Odeme emri sablonunu ilgili muhasebe fisi alanlari ile render edip kullaniciya doner
"""
try:
muhasebe_fisi_data = BapQueryHelpers.get_muhasebe_fisi_bilgileri(muhasebe_fis_id)
# sablon tipi id 49 --> Ödeme Emri Şablonu
odeme_emri_sablonu = DB.session.query(Sablon).filter(
Sablon.sablon_tipi_id == 49,
Sablon.kullanilabilir_mi == True
).order_by(desc(Sablon.updated_at)).first()
muhasebe_fisi = DB.session.query(MuhasebeFisi).filter(
MuhasebeFisi.id == muhasebe_fis_id).first()
muhasebe_fisi.odeme_emri_tamamlandi = True
DB.session.commit()
return render_template_string(odeme_emri_sablonu.sablon_text, data=muhasebe_fisi_data)
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(hata="Muhasebe fişi ödeme emrine çevrilirken bir hata "
"oluştu.Hata: {}, Satinalma id: {}, "
"Muhasebe Fisi id: {}".format(
satinalma_id,
muhasebe_fis_id,
exc)
)
return abort(500)
def get_kisi_bilgiler(self, firma_bilgileri):
"""
Firma bilgilerinden muhasebe fisi formu icin uygun formatta kisi bilgileri olusturur
:param firma_bilgileri:
:return:
"""
kisi_bilgileri = {
"adi_soyadi": "{} {} - {}".format(
firma_bilgileri.yetkili_adi,
firma_bilgileri.yetkili_adi,
firma_bilgileri.adi
),
"banka_sube": firma_bilgileri.banka_sube_adi,
"vergi_no": firma_bilgileri.vergi_kimlik_numarasi,
"hesap_no": firma_bilgileri.iban,
"vergi_dairesi_id": firma_bilgileri.vergi_dairesi_id,
}
return kisi_bilgileri
def get_fatura_bilgileri(self, siparis):
"""
Siparis fatura bilgilerinden muhasebe formu icin uygun formatta data olusturur
:param siparis: Siparis model instance
:return:
"""
fatura_bilgileri = {
"fatura_no": siparis.fatura_no,
"fatura_tarihi": siparis.fatura_tarihi,
}
return fatura_bilgileri
def get_proje_bilgileri(self, proje):
"""
proje model instancendan proje bilgileri dict olusturur
:param proje: Proje model instance
:return: dict
"""
proje_bilgiler_data = {
"proje_no": proje.proje_no,
"proje_adi": proje.proje_basligi,
"proje_yurutucu_ad_soyad": "{} {} {}".format(
proje.proje_yurutucu.hitap_unvan.ad,
proje.proje_yurutucu.personel.person.ad,
proje.proje_yurutucu.personel.person.soyad),
"proje_fakulte": proje.fakulte.ad,
"proje_bolum": proje.bolum.ad,
}
return proje_bilgiler_data
def init_muhasebe_fisi_form(self, genel_ayarlar, kisi_bilgileri, kdv_dahil_alacak, proje,
fatura_bilgisi):
"""
:param genel_ayarlar: uygulama genel ayarlari
:param kisi_bilgileri: muhasebe fisinin kesilecegi kisi
:param kdv_dahil_alacak: firmanin teklifi ve kdv oranindan olusan kdv dahil alacak
:return: MuhasebeFisiForm
"""
kurumsal_kod = ""
genel_ayarlar_butce = {}
fonksiyonel_kod_choices = []
if genel_ayarlar:
genel_ayarlar_butce.update(genel_ayarlar.bap_butce)
kurumsal_kod = genel_ayarlar_butce.get("kurum_kodu", "")
fonksiyonel_kod_choices = self.get_fonksiyonel_kod_choices(
genel_ayarlar_butce.get("fonksiyonel_kodlar", None)
)
genel_ayarlar_butce.update(
{"fakulte_bolum": "{}/{}".format(proje.fakulte.ad, proje.bolum.ad)})
muhasebe_fis_formu = MuhasebeFisiForm(fis_genel_bilgileri=genel_ayarlar_butce,
odeme_yapilacak_kisi_bilgileri=kisi_bilgileri,
fatura_bilgileri=fatura_bilgisi)
for index, fis_maddesi in enumerate(muhasebe_fis_formu.fis_maddeleri, start=0):
fis_maddesi.kurumsal_kod.data = kurumsal_kod
fis_maddesi.fonksiyonel_kod.choices = fonksiyonel_kod_choices
fis_maddesi.fonksiyonel_kod.default = fonksiyonel_kod_choices[0]
if index % 2 == 0:
fis_maddesi.borc.data = kdv_dahil_alacak
fis_maddesi.alacak.data = Decimal("0.00")
else:
fis_maddesi.borc.data = Decimal("0.00")
fis_maddesi.alacak.data = kdv_dahil_alacak
return muhasebe_fis_formu
def get_fonksiyonel_kod_choices(self, fonksiyonel_kodlar):
"""
genel ayarlari kaydedilmis fonksiyonel kodlari alip muhasebe fisi maddelerinde kullanmak
üzere list of tuple a cevirir
:param fonksiyonel_kodlar: List of dict
:return: List of tuple
"""
fonksiyonel_kod_choices = []
for fonksiyonel_kod in fonksiyonel_kodlar:
fonksiyonel_kod_choices.append((fonksiyonel_kod.get("kod"),
fonksiyonel_kod.get("kod")))
return fonksiyonel_kod_choices
def muhasebe_fisi_kaydet(self, muhasebe_fisi_formu, proje_no, yurutucu_ad_soyad,
satinalma_id, fis_tutari):
vergi_dairesi = DB.session.query(VergiDairesi).filter(
VergiDairesi.id == muhasebe_fisi_formu.odeme_yapilacak_kisi_bilgileri.vergi_dairesi_id.data).first()
yeni_muhasebe_fisi = MuhasebeFisi(
satinalma_talep_id=satinalma_id,
muhasebe_fis_no=muhasebe_fisi_formu.fis_genel_bilgileri.belge_numarasi.data,
muhasebe_fis_tarihi=muhasebe_fisi_formu.fis_genel_bilgileri.belge_tarihi.data,
butce_yili=muhasebe_fisi_formu.fis_genel_bilgileri.yil.data,
kurum_adi=muhasebe_fisi_formu.fis_genel_bilgileri.kurum_adi.data,
kurum_kodu=muhasebe_fisi_formu.fis_genel_bilgileri.kurum_kodu.data,
birim_adi=muhasebe_fisi_formu.fis_genel_bilgileri.birim_adi.data,
birim_kodu=muhasebe_fisi_formu.fis_genel_bilgileri.birim_kodu.data,
muhasebe_birim_adi=muhasebe_fisi_formu.fis_genel_bilgileri.muhasebe_birimi_adi.data,
muhasebe_birim_kodu=muhasebe_fisi_formu.fis_genel_bilgileri.muhasebe_birimi_kodu.data,
proje_no=proje_no,
proje_yurutucusu=yurutucu_ad_soyad,
fakulte_bolum=muhasebe_fisi_formu.fis_genel_bilgileri.fakulte_bolum.data,
ad_soyad=muhasebe_fisi_formu.odeme_yapilacak_kisi_bilgileri.adi_soyadi.data,
vergi_kimlik_no=muhasebe_fisi_formu.odeme_yapilacak_kisi_bilgileri.vergi_no.data,
banka_sube=muhasebe_fisi_formu.odeme_yapilacak_kisi_bilgileri.banka_sube.data,
banka_iban=muhasebe_fisi_formu.odeme_yapilacak_kisi_bilgileri.hesap_no.data,
bagli_oldugu_vergi_dairesi=vergi_dairesi.adi,
fatura_no=muhasebe_fisi_formu.fatura_bilgileri.fatura_no.data,
fatura_tarihi=muhasebe_fisi_formu.fatura_bilgileri.fatura_tarihi.data,
fatura_aciklama=muhasebe_fisi_formu.fatura_bilgileri.aciklama.data,
fis_tutari=fis_tutari
)
return yeni_muhasebe_fisi
def muhasebe_fis_maddesi_kaydet(self, fis_maddeleri_formu, muhasebe_fisi_id):
for fis_maddesi in fis_maddeleri_formu:
detayli_hesap_kodu = DB.session.query(DetayliHesapPlanlari).filter(
DetayliHesapPlanlari.id == fis_maddesi.hesap_kodu.data).first()
hesap_kod_duzeyleri = self.detayli_hesap_kodu_parser(detayli_hesap_kodu.hesap_kodu)
yeni_fis_maddesi = MuhasebeFisMaddesi(
muhasebe_fis_id=muhasebe_fisi_id,
hesap_kodu=hesap_kod_duzeyleri["hesap_kodu"],
ekonomik_hesap_kodu=hesap_kod_duzeyleri["ekonomik_kod"],
kurumsal_kod=fis_maddesi.kurumsal_kod.data,
fonksiyonel_kod=fis_maddesi.fonksiyonel_kod.data,
finans_kodu=fis_maddesi.finans_kodu.data,
borc=fis_maddesi.borc.data,
alacak=fis_maddesi.alacak.data,
hesap_ayrinti_adi=detayli_hesap_kodu.ana_hesap_hesap_grubu_yardimci_hesap_adi,
)
DB.session.add(yeni_fis_maddesi)
def detayli_hesap_kodu_parser(self, hesap_kodu):
"""
Muhasebe fis maddelerini kaydederken hesap kodunu ve ekonomik kodu ayrı ayrı kaydediyoruz.
630.03.07.00.00 seklinde bir kod geliyor. 630 lu kısım hesap kodu. 03.07.00.00 lı kısım
ekonomik kodu temsil ediyor. Duruma gore sadece "630" seklinde bir kodda gelebiliyor.
:param hesap_kodu: detayli hesap plani tablosunda yer alan kod
:return:
"""
hesap_kod_duzeyleri = {
"hesap_kodu": "",
"ekonomik_kod": "",
}
# genel kodu "." ya gore 1 kere split eder
hesap_kodu_array = hesap_kodu.split(".", 1)
hesap_kod_duzeyleri["hesap_kodu"] = hesap_kodu_array[0]
if len(hesap_kodu_array) > 1:
hesap_kod_duzeyleri["ekonomik_kod"] = hesap_kodu_array[1]
return hesap_kod_duzeyleri
def get_proje_kalemi_data(self, proje_kalemi, kdv_dahil_tutar):
data = {
"proje_kalemi_adi": proje_kalemi.ad,
"butce_kalemi_kodu": proje_kalemi.proje_turu_butce_kalemi.gider_siniflandirma_kalemi.kodu,
"butce_kalemi_adi": proje_kalemi.proje_turu_butce_kalemi.gider_siniflandirma_kalemi.aciklama,
"fis_tutari": kdv_dahil_tutar,
"toplam_butce": proje_kalemi.toplam_butce,
"rezerv_butce": proje_kalemi.rezerv_butce,
"kullanilan_butce": proje_kalemi.kullanilan_butce,
}
return data
class ProjeMesajView(FlaskView):
"""Proje mesajlari"""
@staticmethod
@login_required
@auth.requires(
Or(
And(
Permission(*permission_dict["bap"]["proje"]
["dashboard"]["proje_mesajlari_goruntuleme"]),
ProjeYurutucusu()), Role("BAP Yetkilisi"), Role("BAP Admin")))
@route('<int:proje_id>/dashboard/mesaj',
methods=["GET"],
endpoint='proje_mesajlari')
def proje_mesajlari(proje_id):
"""Proje mesajlarini gosterir"""
proje_yurutucusu_mu = ProjeYurutucusu().fulfill(user=current_user)
proje = DB.session.query(Proje).options(
joinedload(Proje.proje_yurutucu).load_only("id").joinedload(
OgretimElemani.personel).load_only("id").joinedload(
Personel.person).load_only("ad", "soyad"),
lazyload(Proje.proje_detayi),
lazyload(Proje.kabul_edilen_proje_hakemleri),
lazyload(Proje.proje_hakem_onerileri),
lazyload(Proje.proje_destekleyen_kurulus),
lazyload(Proje.proje_kalemleri),
).filter(
Proje.id == proje_id,
or_(
Proje.proje_basvuru_durumu == ProjeBasvuruDurumu.tamamlandi,
Proje.proje_basvuru_durumu ==
ProjeBasvuruDurumu.revizyon_bekleniyor)).first()
next_states_info = get_next_states_info(proje_id=proje_id)
actions_info = get_actions_info(proje_id=proje_id)
proje_mesajlari = DB.session.query(Mesaj).join(
ProjeMesaj, ProjeMesaj.mesaj_id == Mesaj.id).filter(
ProjeMesaj.proje_id == proje_id).all()
return render_template('dashboard/proje_mesajlari.html',
proje_id=proje_id,
next_states_info=next_states_info,
proje_mesajlari=proje_mesajlari,
proje_yurutucusu_mu=proje_yurutucusu_mu,
actions_info=actions_info,
proje=proje)
@staticmethod
@login_required
@auth.requires(
Or(
And(
Permission(*permission_dict["bap"]["proje"]
["dashboard"]["proje_mesajlari_goruntuleme"]),
ProjeYurutucusu()), Role("BAP Yetkilisi"), Role("BAP Admin")))
@route('<int:proje_id>/dashboard/mesaj/<int:mesaj_id>',
methods=["GET"],
endpoint='proje_mesaj_detay')
def proje_mesaj_detay(proje_id, mesaj_id):
""" Gelen kutusuna dusen mesajlarin, icerigini, kimden geldigini vs. gosterir."""
mesaj = DB.session.query(Mesaj).filter_by(id=mesaj_id).options(
joinedload(Mesaj.gonderen_kisi).load_only(
'ad', 'soyad', 'birincil_eposta')).one()
if not mesaj.okundu:
mesaj.okundu = True
mesaj.okunma_zamani = datetime.now()
okunma_tarihi = datetime.now().strftime('%d-%m-%Y')
okunma_ip_adresi = request.remote_addr
mesaj.okunma_ip_adresi = request.remote_addr
DB.session.commit()
else:
okunma_tarihi = mesaj.okunma_zamani.strftime('%d-%m-%Y')
okunma_ip_adresi = mesaj.okunma_ip_adresi
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("common").get(
"mesaj_okundu").type_index,
"nesne":
'Mesaj',
"nesne_id":
mesaj_id,
"ekstra_mesaj":
"{} adlı kullanıcı {} id'li mesajı okudu.".format(
current_user.username, mesaj_id)
}
signal_sender(**signal_payload)
mesaj_detay = {
'gonderim_tarihi':
mesaj.gonderim_zamani.strftime('%d-%m-%Y'),
'okunma_tarihi':
okunma_tarihi,
'okunma_ip_adresi':
okunma_ip_adresi,
'gonderen_kisi_ad_soyad':
mesaj.gonderen_kisi.ad + " " + mesaj.gonderen_kisi.soyad,
'gonderen_kisi_birincil_eposta':
mesaj.gonderen_kisi.birincil_eposta,
'baslik':
mesaj.baslik,
'metin':
mesaj.metin,
'mesaj_ek':
render_template_string("""
<ul class="attached-document clearfix">
{% for ek in mesaj_ek %}
{% if ek.belge_r.content %}
<li>
<div class="document-name">
<form method="post">
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}"/>
<button class="btn btn-link" id="ek_{{ ek.belge }}" name="ek_{{ ek.belge }}"
value="{{ ek.belge }}" style="white-space: normal;"
formaction="{{ url_for('mesaj.mesaj_ek',
mesaj_id=mesaj_id,
belge_id= ek.belge ) }}">
{{ ek.belge_r.content.file.filename }}
</button>
</form>
</div>
</li>
{% endif %}
{% endfor %}
</ul>""",
mesaj_ek=mesaj.mesajek,
mesaj_id=mesaj_id)
}
return jsonify(status="success",
mesaj=mesaj_detay,
mesaj_id=int(mesaj_id))
class GundemSablonlariView(FlaskView):
"""Gundem Sablon ile ilgili islemler Viewi"""
excluded_methods = [
"qry",
"gundem_sablon_ekle_form",
"user_id"
]
@property
def qry(self):
"""GundemSablon BaseQuery"""
return DB.session.query(GundemSablon)
@property
def user_id(self):
"""Kullanici idsi dondurur"""
return current_user.id
@property
def gundem_sablon_ekle_form(self):
"""Gundem Sablonu Ekleme Formu dondurur"""
gundem_sablon_ekle_form = GundemSablonEkleForm(request.form)
return gundem_sablon_ekle_form
@property
def gundem_sablon_duzenle_form(self):
"""Gundem Sablonu Duzenleme Formu dondurur"""
gundem_sablon_duzenle_form = GundemSablonDuzenleForm(request.form)
return gundem_sablon_duzenle_form
@login_required
@auth.requires(Permission(*permission_dict["yonetim"]["bap_yonetimi"]["gundem_sablonu_listeleme"]),
menu_registry={'path': '.yonetim.bap.sablon_listesi',
'title': _("Gündem Şablonları"), "order": 1})
@route("/listesi")
def liste(self):
"""Gundem Sablon Listesi Ekrani"""
sablon_listesi = self.qry.all()
return render_template("gundem_sablonlari.html",
sablon_listesi=sablon_listesi,
gundem_sablon_ekle_form=self.gundem_sablon_ekle_form,
gundem_sablon_duzenle_form=self.gundem_sablon_duzenle_form, )
@login_required
@auth.requires(Permission(*permission_dict["yonetim"]["bap_yonetimi"]["gundem_sablonu_ekleme"]))
@route("/gundem-sablon-ekle", methods=["POST"], endpoint='gundem_sablon_ekle')
def gundem_sablon_ekle(self):
"""Gundem Sablonu Ekleme"""
gundem_sablon_ekle_form = self.gundem_sablon_ekle_form
data = GundemSablon.data_to_dict(gundem_sablon_ekle_form.data)
sablon = GundemSablon(**data)
try:
DB.session.add(sablon)
DB.session.commit()
except IntegrityError:
DB.session.rollback()
flash(_("Aynı şablon tipi sadece bir kere oluşturulabilir!"))
return redirect(url_for('bap_yonetimi.GundemSablonlariView:liste'))
flash(_("Gündem Şablonu başarıyla eklenmiştir."))
signal_payload = {
"message_type": USER_ACTIVITY_MESSAGES.get("bap").get("gundem_sablon_ekle").type_index,
"nesne": 'Gundem Sablon',
"nesne_id": sablon.id,
"ekstra_mesaj": "{} adlı kullanıcı gundem sablonu kaydetti.".format(
current_user.username),
}
signal_sender(**signal_payload)
return redirect(url_for('bap_yonetimi.GundemSablonlariView:liste'))
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["yonetim"]["bap_yonetimi"]["gundem_sablonu_duzenleme"]))
@route("/gundem-sablon-duzenle", methods=["GET"], endpoint='gundem_sablon_duzenle')
def gundem_sablon_duzenle():
"""Gundem Sablonu Duzenleme"""
sablon_id = int(request.args['sablon_id'])
sablon = DB.session.query(
GundemSablon
).filter(
GundemSablon.id == sablon_id
).one_or_none()
data = {
"sablon_tipi": sablon.sablon_tipi.name,
"kategori": sablon.kategori.name,
"aciklama": sablon.aciklama,
"karar": sablon.aciklama
}
return jsonify(data)
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["yonetim"]["bap_yonetimi"]["gundem_sablonu_duzenleme"]))
@route("/gundem-sablon-duzenle-post", methods=["POST"], endpoint='gundem_sablon_duzenle_post')
def gundem_sablon_duzenle_post():
"""Gundem Sablonu Duzenleme Kayit"""
sablon_id = request.args['sablon_id']
sablon = DB.session.query(
GundemSablon
).filter(
GundemSablon.id == sablon_id
).one_or_none()
gundem_sablon_duzenle_form = GundemSablonDuzenleForm(request.form)
sablon.sablon_tipi = gundem_sablon_duzenle_form.duzenle.sablon_tipi.data
sablon.kategori = gundem_sablon_duzenle_form.duzenle.kategori.data
sablon.aciklama = gundem_sablon_duzenle_form.duzenle.aciklama.data
sablon.karar = gundem_sablon_duzenle_form.duzenle.karar.data
DB.session.commit()
signal_payload = {
"message_type": USER_ACTIVITY_MESSAGES.get("bap").get("gundem_sablon_guncelle").type_index,
"nesne": 'Gundem Sablon',
"nesne_id": sablon.id,
"ekstra_mesaj": "{} adlı kullanıcı {} id'li gundem sablonu guncelledi.".format(
current_user.username,
sablon.id
)
}
signal_sender(**signal_payload)
return redirect(url_for('bap_yonetimi.GundemSablonlariView:liste'))
@staticmethod
@login_required
@auth.requires(Permission(*permission_dict["yonetim"]["bap_yonetimi"]["gundem_sablonu_silme"]))
@route("/gundem-sablon-sil/<int:sablon_id>/", methods=["DELETE"], endpoint='gundem_sablon_sil')
def gundem_sablon_sil(sablon_id):
"""Gundem Sablonu Silme"""
sablon = DB.session.query(
GundemSablon
).filter(
GundemSablon.id == sablon_id
).one_or_none()
if sablon:
DB.session.delete(sablon)
DB.session.commit()
signal_payload = {
"message_type": USER_ACTIVITY_MESSAGES.get("bap").get("gundem_sablon_sil").type_index,
"nesne": 'Gundem Sablon',
"nesne_id": sablon.id,
"ekstra_mesaj": "{} adlı kullanıcı {} id'li gundem sablonu sildi.".format(
current_user.username,
sablon.id
)
}
signal_sender(**signal_payload)
return jsonify(status='success')
DB.session.rollback()
CustomErrorHandler.error_handler()
return jsonify(status="error"), 400
