class Unit(Model):
"""Unit modeli
Kullanıcılara rol tanımlarken kullanılan, kullanıcının hangı birimde
olduğunu taşıyan modeldir.
Akademik ve idari birimlerin özelliklerini taşır.
"""
name = field.String(_(u"İsim"), index=True)
long_name = field.String(_(u"Uzun İsim"), index=True)
yoksis_no = field.Integer(_(u"Yoksis ID"), index=True)
unit_type = field.String(_(u"Birim Tipi"), index=True)
parent_unit_no = field.Integer(_(u"Üst Birim ID"), index=True)
current_situation = field.String(_(u"Guncel Durum"), index=True)
language = field.String(_(u"Öğrenim Dili"), index=True)
learning_type = field.String(_(u"Öğrenme Tipi"), index=True)
osym_code = field.String(_(u"ÖSYM Kodu"), index=True)
opening_date = field.Date(_(u"Açılış Tarihi"), index=True)
learning_duration = field.Integer(_(u"Öğrenme Süresi"), index=True)
english_name = field.String(_(u"İngilizce Birim Adı."), index=True)
quota = field.Integer(_(u"Birim Kontenjan"), index=True)
city_code = field.Integer(_(u"Şehir Kodu"), index=True)
district_code = field.Integer(_(u"Semt Kodu"), index=True)
unit_group = field.Integer(_(u"Birim Grup"), index=True)
foet_code = field.Integer(_(u"FOET Kodu"), index=True) # yoksis KILAVUZ_KODU mu?
is_academic = field.Boolean(_(u"Akademik"))
is_active = field.Boolean(_(u"Aktif"))
uid = field.Integer(index=True)
parent = LinkProxy('Unit', verbose_name=_(u'Üst Birim'), reverse_name='alt_birimler')
# parent = field.String(verbose_name='Üst Birim') # fake
@classmethod
def get_role_keys(cls, unit_key):
"""recursively gets all roles (keys) under given unit"""
return cls.get_role_keys_by_yoksis(Unit.objects.get(unit_key).yoksis_no)
# stack = Role.objects.filter(unit_id=unit_key).values_list('user_id', flatten=True)
# for unit_key in cls.objects.filter(parent_id=unit_key).values_list('key', flatten=True):
# stack.extend(cls.get_role_keys(unit_key))
# return stack
@classmethod
def get_role_keys_by_yoksis(cls, yoksis_no):
# because we don't refactor our data to use Unit.parent, yet!
stack = Role.objects.filter(unit_id=Unit.objects.get(yoksis_no=yoksis_no).key).values_list(
'key', flatten=True)
for yoksis_no in cls.objects.filter(parent_unit_no=yoksis_no).values_list('yoksis_no',
flatten=True):
stack.extend(cls.get_role_keys_by_yoksis(yoksis_no))
return stack
class Meta:
app = 'Sistem'
verbose_name = _(u"Unit")
verbose_name_plural = _(u"Units")
search_fields = ['name', 'yoksis_no']
list_fields = ['name', 'unit_type']
def __unicode__(self):
return '%s - %s - %s' % (self.name, self.english_name, self.yoksis_no)
class Formlar(ListNode):
class Meta:
title = __(u"Projede Kullanılacak Formlar")
proje_formu = Form()
gereklilik = field.Boolean(__(u"Formun Gerekliliği"), default=False)
secili = field.Boolean(__(u"Projeye Dahil Et"), default=False)
class BAPSatinAlma(Model):
class Meta:
verbose_name = __(u"Bütçe Kalemi Satın Alma")
verbose_name_plural = __(u"Bütçe Kalemi Satın Almaları")
list_fields = ['ad', 'teklife_acilma_tarihi', 'teklife_kapanma_tarihi']
ad = field.String(__(u"Satın Alma Duyuru Adı"))
teklife_acilma_tarihi = field.DateTime(__(u"Teklife Açılma Tarihi"))
teklife_kapanma_tarihi = field.DateTime(__(u"Teklife Kapanma Tarihi"))
sonuclanma_tarihi = field.Date(__(u"Teklifin Sonuçlanma Tarihi"))
onay_tarih_sayi = field.String(__(u"Onay Tarih/Sayı"))
ekleyen = Personel()
aciklama = field.Text(__(u"Açıklama"))
teklif_durum = field.Integer(__(u"Teklif Durum"),
choices='bap_satin_alma_durum')
ilgili_proje = BAPProje()
tek_firma = BAPFirma()
tur = field.Integer(_(u"Satın Alma Türü"),
choices='bap_satin_alma_turleri')
duyuruda = field.Boolean(_(u"Duyuru Durumu"), default=False)
sorumlu = Role()
duyuruda = field.Boolean(__(u"Duyurulma Durumu"), default=False)
class ButceKalemleri(ListNode):
butce = BAPButcePlani()
def __unicode__(self):
return "%s" % self.ad
class WFInstance(Model):
"""
Running workflow instance
"""
wf = BPMNWorkflow()
task = Task()
name = field.String(__(u"WF Name"))
subject = field.String(__(u"Subject ID"))
current_actor = RoleModel(__(u"Current Actor"))
wf_object = field.String(__(u"Subject ID"))
wf_object_type = field.String(__(u"Object type"),
null=True,
choices=get_model_choices)
last_activation = field.DateTime(__(u"Last activation"))
finished = field.Boolean(default=False)
started = field.Boolean(default=False)
in_external = field.Boolean(default=False)
start_date = field.DateTime(__(u"Start time"))
finish_date = field.DateTime(__(u"Finish time"))
step = field.String(__(u"Last executed WF Step"))
data = field.String(__(u"Task Data"))
pool = field.String(__(u"Pool Data"))
class Meta:
verbose_name = "Workflow Instance"
verbose_name_plural = "Workflows Instances"
search_fields = ['name']
list_fields = ['name', 'current_actor']
def get_object(self):
if self.wf_object_type:
model = model_registry.get_model(self.wf_object_type)
return model.objects.get(self.wf_object)
else:
return ''
def actor(self):
return self.current_actor.user.full_name if self.current_actor.exist else '-'
actor.title = 'Current Actor'
# class Pool(ListNode):
# order = field.Integer("Lane order")
# role = RoleModel()
def pre_save(self):
if not self.wf and self.name:
self.wf = BPMNWorkflow.objects.get(name=self.name)
def __unicode__(self):
return '%s instance (%s)' % (self.wf.name, self.key)
class Takvim(Model):
"""
olay, bir zaman araliginda gerceklesiyorsa(ayni gunun saat araliklari dahil),
baslangic ve bitis zamanlari ayri ayri verilir,
olay, bir gun icinde ancak kesin zaman bagimsiz/belirsiz gerceklesiyorsa,
baslangic ve bitis zamanlari ayni verilir,
olay, belirsiz bir baslangic yani son gun belirtilmisse, sadece bitis tarihi verilir,
olay, belirsiz bir son yani baslama gun belirtilmisse, sadece baslangic tarihi verilir,
"""
etkinlik = field.Integer(_(u"Etkinlik"), index=True, choices=AKADEMIK_TAKVIM_ETKINLIKLERI)
baslangic = field.DateTime(_(u"Başlangıç"), index=True, format="%d.%m.%Y", required=False)
bitis = field.DateTime(_(u"Bitiş"), index=True, format="%d.%m.%Y", required=False)
akademik_takvim = AkademikTakvim(_(u"Akademik Takvim"))
resmi_tatil = field.Boolean(_(u"Resmi Tatil"), index=True)
def pre_save(self):
if not self.baslangic and not self.bitis:
raise Exception("Tarihlerden en az bir tanesi dolu olmalidir.")
class Meta:
app = 'Ogrenci'
verbose_name = _(u"Takvim")
verbose_name_plural = _(u"Takvimler")
list_filters = ["etkinlik", "baslangic", "bitis", 'resmi_tatil']
def __unicode__(self):
return '%s %s %s' % (
self.akademik_takvim.birim, self.akademik_takvim.ogretim_yili, self.etkinlik)
class Sinav(Model):
"""Sınav Modeli
Derse ait sınav(ara sınav, genel sınav, bütünleme, tek ders, muafiyet)
bilgilerinin saklandığı modeldir.
Sınavlar şubeler için ders dolayısı ile otomatik açılırlar. Bu sebeple temel bağ Şube
modelidir.
Ders arama kolaylığı için eklenmiştir.
"""
tarih = field.Date(_(u"Sınav Tarihi"), index=True)
yapilacagi_yer = field.String(_(u"Yapılacağı Yer"), index=True)
tur = field.Integer(_(u"Sınav Türü"), index=True, choices="sinav_turleri")
aciklama = field.String(_(u"Açıklama"), index=True)
sube = Sube()
degerlendirme = field.Boolean(_(u"Değerlendirme Durumu"),
index=True,
default=False)
# arama amacli
ders = Ders()
puan = field.Integer(_(u"Puan"), index=True)
class Meta:
app = 'Ogrenci'
verbose_name = _(u"Sınav")
verbose_name_plural = _(u"Sınavlar")
list_fields = ['tarih', 'yapilacagi_yer']
search_fields = ['aciklama', 'tarih']
def __unicode__(self):
return '%s %s' % (self.get_tur_display(), self.sube)
class User(Model):
username = field.String("Username", index=True)
password = field.String("Password")
superuser = field.Boolean("Super user", default=False)
class Meta:
list_fields = ['username', 'superuser']
def __unicode__(self):
return "User %s" % self.username
def __repr__(self):
return "User_%s" % self.key
def set_password(self, raw_password):
self.password = pbkdf2_sha512.encrypt(raw_password,
rounds=10000,
salt_size=10)
def check_password(self, raw_password):
return pbkdf2_sha512.verify(raw_password, self.password)
def get_permissions(self):
return (p.permission.code for p in self.Permissions)
def get_role(self, role_id):
return self.role_set.node_dict[role_id]
class ZatoServiceChannel(Model):
cluster_id = field.Integer(__(u'Zato cluster'))
channel_id = field.Integer(__(u"Channel id"))
channel_name = field.String(__(u"Channel name"))
channel_connection = field.String(__(u"channel or outgoing connection"))
channel_transport = field.String(__(u"plain_http or soap"))
channel_url_path = field.String(__(u"Example: /test/zato-url-path"))
channel_data_format = field.String(__(u"xml or json"))
channel_is_internal = field.Boolean(default=False)
channel_is_active = field.Boolean(default=True)
service_id = field.Integer(__(u"Service Id"))
service_name = field.String(__(u"Service name"))
deploy = field.Boolean(__(u"Deploy Channel"), default=False)
def __unicode__(self):
return self.channel_name
class LimitedPermissions(Model):
"""LimitedPermissions modeli
Bu modelde tutulan bilgilerle mevcut yetkilere sınırlandırmalar
getirilir.
- Başlangıç ve bitiş tarihine göre sınırlandırma uygulanan yetkiler
o tarih aralığında geçerli olur.
- Verilen IPList özelliğine göre bu IPList listesi içindeki
ip'lerden gelen requestlere cevap verecek şekilde kısıtlanır.
"""
restrictive = field.Boolean("Sınırlandırıcı", default=False)
time_start = field.String("Başlama Tarihi", index=True)
time_end = field.String("Bitiş Tarihi", index=True)
class Meta:
app = 'Sistem'
verbose_name = "Sınırlandırılmış Yetki"
verbose_name_plural = "Sınırlandırılmış Yetkiler"
def __unicode__(self):
return "%s - %s" % (self.time_start, self.time_end)
class IPList(ListNode):
ip = field.String()
class Permissions(ListNode):
permission = Permission()
class AbstractRoles(ListNode):
abstract_role = AbstractRole()
class Roles(ListNode):
role = Role()
class Room(Model):
"""Oda modeli
Üniversitenin sahip olduğu odalara (sınıf, lab, amfi) ait data modelidir. Her odanın
bir kodu bulunur.
Odalar, binalara ve binalar aracılığıyla kampüslere bağlanır.
"""
code = field.String(_(u"Kod"), index=True)
name = field.String(_(u"İsim"), index=True)
room_type = RoomType(_(u"Oda Tipi"), index=True)
unit = Unit(_(u"Bölüm"))
#: Bina içerisindeki kat bilgisi
floor = field.String(_(u"Kat"), index=True)
capacity = field.Integer(_(u"Kapasite"), index=True)
building = Building()
exam_capacity = field.Integer(_(u"Sınav Kapasitesi"))
is_active = field.Boolean(_(u"Aktif"), index=True)
unitime_key = field.String(
) # Ders/Sınav programları hazırlanırken id'leri eşleştirmek için
class Meta:
verbose_name = _(u"Oda")
verbose_name_plural = _(u"Odalar")
search_fields = ['code', 'name']
list_fields = ['code', 'name']
def __unicode__(self):
return '%s %s %s' % (self.code, self.name, self.capacity)
class BAPDuyuru(Model):
class Meta:
verbose_name = __(u"BAP Duyuru")
verbose_name_plural = __(u"BAP Duyurular")
list_fields = [
'duyuru_baslik', 'eklenme_tarihi', 'son_gecerlilik_tarihi'
]
ekleyen = User()
eklenme_tarihi = field.Date(__(u"Eklenme Tarihi"))
son_gecerlilik_tarihi = field.Date(__(u"Son Geçerlilik Tarihi"))
duyuru_baslik = field.String(__(u"Duyuru Başlığı"))
duyuru_icerik = field.Text(__(u"Duyuru İçeriği"))
yayinlanmis_mi = field.Boolean(__(u"Yayınlanmış mı?"), default=False)
class EkDosyalar(ListNode):
class Meta:
verbose_name = __(u"Ek Dosya")
verbose_name_plural = __(u"Ek Dosyalar")
list_fields = ['dosya_aciklamasi']
ek_dosya = field.File(__(u"Ek Dosya Seç"), random_name=True)
dosya_aciklamasi = field.String(__(u"Dosya Açıklaması"))
def __unicode__(self):
return "%s" % self.duyuru_baslik
class OgrenciDersi(Model):
"""Öğrenci Dersi Modeli
Öğrencilerin ders seçimlerinin saklandığı modeldir.
Ders alanı Şube modeli ile ilişkilendirilmiştir. Bunun sebebi öğrencilerin ders seçiminin,
ders ve okutmanın birleştiği şube seçimi olmasıdır. Detaylı bilgiler Şube modelinde bulunabilir.
Bir öğrencinin devamsızlıktan kalıp kalmadığı devamsizliktan_kalma alanı ile kontrol edilir.
Bu alan False olduğu zaman öğrenci devamsızlıktan kalır.
"""
alis_bicimi = field.Integer(_(u"Dersi Alış Biçimi"), index=True)
sube = Sube(unique=True)
ogrenci_program = OgrenciProgram()
ogrenci = Ogrenci(unique=True)
basari_ortalamasi = field.Float(_(u"Ortalama"), index=True)
harflendirilmis_not = field.String(_(u"Harf"), index=True)
katilim_durumu = field.Boolean(_(u"Devamsızlıktan Kalma"), default=False, index=True)
# arama amaçlı alanlar
ders = Ders()
donem = Donem()
class Meta:
app = 'Ogrenci'
verbose_name = _(u"Ögrenci Dersi")
verbose_name_plural = _(u"Öğrenci Dersleri")
list_fields = ['ders', 'alis_bicimi']
search_fields = ['alis_bicimi', ]
unique_together = [('ogrenci', 'sube')]
def post_creation(self):
"""
Yeni bir ``OgrenciDers``'i ilk defa yaratılınca ``donem`` ve ``ders`` alanları,
bağlı şubeden atanır.
"""
self.donem = self.sube.donem
self.ders = self.sube.ders
self.save()
def ders_adi(self):
"""
Şubenin bağlı olduğu ders adı.
Returns:
Şubenin bağlı olduğu ders örneğinin adını döndürür.
"""
return six.text_type(self.ders.ad)
ders_adi.title = 'Ders'
def __unicode__(self):
return '%s %s %s' % (self.ders.kod, self.ders.ad, self.alis_bicimi)
class ZatoServiceFile(Model):
cluster_id = field.Integer(__(u'Zato cluster'))
service_payload_name = field.String(__(u"Module’s file name"))
service_payload = field.String(__(u"BASE64-encoded"))
deploy = field.Boolean(__(u"Deploy Service"), default=False)
def __unicode__(self):
return self.service_payload_name
class Belgeler(ListNode):
tip = field.Integer(_(u"Belge Tipi"), choices="belge_tip", index=True)
aciklama = field.String(_(u"Ek Açıklama"),
index=True,
default="-",
required=False)
tamam = field.Boolean(_(u"Belge kontrol edildi"),
index=True,
required=True)
class Unit(Model):
"""Unit modeli
Kullanıcılara rol tanımlarken kullanılan, kullanıcının hangı birimde
olduğunu taşıyan modeldir.
Akademik ve idari birimlerin özelliklerini taşır.
"""
name = field.String("İsim", index=True)
long_name = field.String("Uzun İsim", index=True)
yoksis_no = field.Integer("Yoksis ID", index=True)
unit_type = field.String("Birim Tipi", index=True)
parent_unit_no = field.Integer("Üst Birim ID", index=True)
current_situation = field.String("Guncel Durum", index=True)
language = field.String("Öğrenim Dili", index=True)
learning_type = field.String("Öğrenme Tipi", index=True)
osym_code = field.String("ÖSYM Kodu", index=True)
opening_date = field.Date("Açılış Tarihi", index=True)
learning_duration = field.Integer("Öğrenme Süresi", index=True)
english_name = field.String("İngilizce Birim Adı.", index=True)
quota = field.Integer("Birim Kontenjan", index=True)
city_code = field.Integer("Şehir Kodu", index=True)
district_code = field.Integer("Semt Kodu", index=True)
unit_group = field.Integer("Birim Grup", index=True)
foet_code = field.Integer("FOET Kodu",
index=True) # yoksis KILAVUZ_KODU mu?
is_academic = field.Boolean("Akademik")
is_active = field.Boolean("Aktif")
uid = field.Integer(index=True)
parent = LinkProxy('Unit',
verbose_name='Üst Birim',
reverse_name='alt_birimler')
class Meta:
app = 'Sistem'
verbose_name = "Unit"
verbose_name_plural = "Units"
search_fields = ['name']
list_fields = ['name', 'unit_type']
def __unicode__(self):
return '%s - %s - %s' % (self.name, self.english_name, self.yoksis_no)
class BAPSSS(Model):
class Meta:
verbose_name = __(u"Sıkça Sorulan Soru")
verbose_name_plural = __(u"Sıkça Sorulan Sorular")
list_fields = ['soru', 'cevap']
soru = field.Text(__(u"Sıkça Sorulan Soru"))
cevap = field.Text(__(u"Cevap"))
yayinlanmis_mi = field.Boolean(__(u"Yayınlanmış mı?"), default=False)
def __unicode__(self):
return "%s" % self.soru
class NufusKayitlari(Model):
tckn = field.String(_(u"Sigortalının TC Kimlik No"),
index=True,
hidden=True)
kayit_no = field.String(_(u"Bildirge Kayıt No"), index=True, hidden=True)
ad = field.String(_(u"Adı"), index=True)
soyad = field.String(_(u"Soyadı"), index=True)
ilk_soy_ad = field.String(_(u"Memuriyete Girişteki İlk Soyadı"),
index=True)
dogum_tarihi = field.Date(_(u"Doğum Tarihi"),
index=True,
format="%d.%m.%Y")
cinsiyet = field.String(_(u"Cinsiyet"), index=True)
emekli_sicil_no = field.Integer(_(u"Emekli Sicil No"), index=True)
memuriyet_baslama_tarihi = field.Date(_(u"Memuriyete İlk Başlama Tarihi"),
index=True,
format="%d.%m.%Y")
kurum_sicil = field.String(_(u"Kurum Sicili"), index=True)
maluliyet_kod = field.Integer(_(u"Malul Kod"),
index=True,
choices="maluliyet_kod")
yetki_seviyesi = field.String(_(u"Yetki Seviyesi"), index=True)
aciklama = field.String(_(u"Açıklama"), index=True)
kuruma_baslama_tarihi = field.Date(_(u"Kuruma Başlama Tarihi"),
index=True,
format="%d.%m.%Y")
gorev_tarihi_6495 = field.Date(
_(u"Emeklilik Sonrası Göreve Başlama Tarihi"),
index=True,
format="%d.%m.%Y")
emekli_sicil_6495 = field.Integer(_(u"2. Emekli Sicil No"), index=True)
durum = field.Boolean(_(u"Durum"), index=True)
sebep = field.Integer(_(u"Sebep"), index=True)
sync = field.Integer(_(u"Senkronize"), index=True, hidden=True)
personel = Personel(one_to_one=True)
# TODO: Personele gore unique olmali
class Meta:
app = 'Personel'
verbose_name = _(u"Nüfus Bilgisi")
verbose_name_plural = _(u"Nüfus Bilgileri")
hitap_service_prefix = "HitapNufus"
def __unicode__(self):
return gettext(u'%(ad)s %(soyad)s %(sicil_no)s') % {
'ad': self.ad,
'soyad': self.soyad,
'sicil_no': self.emekli_sicil_no
}
class User(Model, BaseUser):
"""
Basic User model
"""
username = field.String(_(u"Username"), index=True)
password = field.String(_(u"Password"))
superuser = field.Boolean(_(u"Super user"), default=False)
avatar = field.File(_(u"Avatar"), random_name=True, required=False)
locale_language = field.String(_(u"Preferred Language"),
index=False,
default=settings.DEFAULT_LANG)
locale_datetime = field.String(
_(u"Preferred Date and Time Format"),
index=False,
default=settings.DEFAULT_LOCALIZATION_FORMAT)
locale_number = field.String(_(u"Preferred Number Format"),
index=False,
default=settings.DEFAULT_LOCALIZATION_FORMAT)
last_login_role_key = field.String(_(u"Last Login Role Key"))
unit = Unit()
class Meta:
""" meta class
"""
verbose_name = _(u"User")
verbose_name_plural = _(u"Users")
list_fields = ['username', 'superuser']
def pre_save(self):
self.encrypt_password()
def post_creation(self):
self.prepare_channels()
def last_login_role(self):
last_key = self.last_login_role_key
return Role.objects.get(
last_key) if last_key else self.role_set[0].role
def get_permissions(self):
"""
Permissions of the user.
Returns:
List of Permission objects.
"""
user_role = self.last_login_role(
) if self.last_login_role_key else self.role_set[0].role
return user_role.get_permissions()
class BAPGundem(Model):
class Meta:
verbose_name = __(u"Gündem")
verbose_name_plural = __(u"Gündemler")
list_fields = [
'_proje_adi', '_proje_yurutucusu', 'gundem_tipi',
'oturum_numarasi', 'oturum_tarihi', 'karar_no'
]
proje = BAPProje()
etkinlik = BAPEtkinlikProje()
gundem_tipi = field.Integer(__(u"Gündem Tipi"),
choices='bap_komisyon_gundemleri',
default=1)
gundem_aciklama = field.Text(__(u"Gündem Açıklaması"), required=False)
oturum_numarasi = field.String(__(u"Oturum Numarası"),
default="",
required=False)
oturum_tarihi = field.Date(__(u"Oturum Tarihi"), required=False)
karar_no = field.String(__(u"Karar No"), default="", required=False)
karar = field.String(__(u"Karar"), default="", required=False)
sonuclandi = field.Boolean(__(u"Kararın Sonuçlandırılması"), default=False)
karar_metni = field.Text(__(u"Karar Metni"), required=False)
karar_gerekcesi = field.Text(__(
u"Karar Gerekçesi (Reddetme ve revizyon kararlarında gerekçe belirtilmelidir.)"
),
required=False)
gundem_ekstra_bilgiler = field.String(__(u"Gündem Ekstra Bilgileri"),
hidden=True)
def _proje_adi(self):
return "Diğer" if self.gundem_tipi == 10 else "%s" % self.proje.ad if self.proje.key else \
self.etkinlik.bildiri_basligi
_proje_adi.title = __(u"Projenin Adı")
def _proje_yurutucusu(self):
return "Diğer" if self.gundem_tipi == 10 else "%s %s" % (
(self.proje.yurutucu.ad,
self.proje.yurutucu.soyad) if self.proje.key else
(self.etkinlik.basvuru_yapan.ad,
self.etkinlik.basvuru_yapan.soyad))
_proje_yurutucusu.title = __(u"Proje Yürütücüsü")
def __unicode__(self):
return "Bap Gündem"
class Program(Model):
"""Program Modeli
Bir bölümün öğrenim programı (ders ve uygulamalardan oluşan) bilgilerinin
saklandığı modeldir.
"""
yoksis_no = field.String(_(u"YOKSIS ID"), index=True)
bolum_adi = field.String(_(u"Bölüm"), index=True)
ucret = field.Integer(_(u"Ücret"), index=True)
yil = field.String(_(u"Yıl"), index=True)
adi = field.String(_(u"Adı"), index=True)
tanim = field.String(_(u"Tanım"), index=True)
yeterlilik_kosullari_aciklamasi = field.String(
_(u"Yeterlilik Koşulları Açıklaması"), index=True)
program_ciktilari = field.String(_(u"Program Çıktıları"), index=True)
mezuniyet_kosullari = field.String(_(u"Mezuniyet Koşulları"), index=True)
kabul_kosullari = field.String(_(u"Kabul Koşulları"), index=True)
donem_sayisi = field.Integer(_(u"Sürdüğü Dönem Sayısı"), index=True)
farkli_programdan_ders_secebilme = field.Boolean(
_(u"Farklı Bir Programdan Ders Seçebilme"), default=False, index=True)
bolum_baskani = Role(verbose_name=_(u'Bölüm Başkanı'),
reverse_name='bolum_baskani_program')
ects_bolum_kordinator = Role(verbose_name=_(u'ECTS Bölüm Koordinator'),
reverse_name='ects_koordinator_program')
akademik_kordinator = Role(verbose_name=_(u'Akademik Koordinator'),
reverse_name='akademik_koordinator_program')
birim = Unit(reverse_name="yoksis_program_program",
verbose_name=_(u"YÖKSİS Program"))
bolum = Unit(reverse_name="bolum_program", verbose_name=_(u"Bölüm"))
# todo: to be removed
# class Donemler(ListNode):
# donem = Donem()
class Meta:
app = 'Ogrenci'
verbose_name = _(u"Program")
verbose_name_plural = _(u"Programlar")
list_fields = ['adi', 'yil']
search_fields = ['adi', 'yil', 'tanim']
def __unicode__(self):
return '%s %s' % (self.adi, self.yil)
class BAPTeklif(Model):
class Meta:
verbose_name = __(u"Firma Teklif")
verbose_name_plural = __(u"Firma Teklifleri")
firma = BAPFirma()
satin_alma = BAPSatinAlma()
durum = field.Integer(__(u"Durum"), choices='bap_teklif_durum')
ilk_teklif_tarihi = field.DateTime(_(u"İlk Teklif Tarihi"))
son_degisiklik_tarihi = field.DateTime(_(u"Son Değişiklik Tarihi"))
sonuclanma_tarihi = field.Date(__(u"Firma Teklifinin Sonuçlanma Tarihi"))
fiyat_islemesi = field.Boolean(__(u"Fiyat İşlemesi Yapıldı mı?"),
default=False)
class Belgeler(ListNode):
belge = field.File(_(u"Firma Teklif Belgesi"),
random_name=False,
required=True)
aciklama = field.String(__(u"Belge Açıklaması"), required=True)
def __unicode__(self):
return "%s-%s" % (self.firma.ad, self.satin_alma.ad)
class NufusKayitlari(Model):
tckn = field.String("Sigortalının TC Kimlik No", index=True)
ad = field.String("Adı", index=True)
soyad = field.String("Soyadı", index=True)
ilk_soy_ad = field.String("Memuriyete Girişteki İlk Soyadı", index=True)
dogum_tarihi = field.Date("Doğum Tarihi", index=True, format="%d.%m.%Y")
cinsiyet = field.String("Cinsiyet", index=True)
emekli_sicil_no = field.Integer("Emekli Sicil No", index=True)
memuriyet_baslama_tarihi = field.Date("Memuriyete İlk Başlama Tarihi",
index=True,
format="%d.%m.%Y")
kurum_sicil = field.String("Kurum Sicili", index=True)
maluliyet_kod = field.Integer("Malul Kod",
index=True,
choices="maluliyet_kod")
yetki_seviyesi = field.String("Yetki Seviyesi", index=True)
aciklama = field.String("Açıklama", index=True)
kuruma_baslama_tarihi = field.Date("Kuruma Başlama Tarihi",
index=True,
format="%d.%m.%Y")
gorev_tarihi_6495 = field.Date("Emeklilik Sonrası Göreve Başlama Tarihi",
index=True,
format="%d.%m.%Y")
emekli_sicil_6495 = field.Integer("2. Emekli Sicil No", index=True)
durum = field.Boolean("Durum", index=True)
sebep = field.Integer("Sebep", index=True)
sync = field.Integer("Senkronize", index=True)
personel = Personel(one_to_one=True)
# TODO: Personele gore unique olmali
class Meta:
app = 'Personel'
verbose_name = "Nüfus Bilgisi"
verbose_name_plural = "Nüfus Bilgileri"
def __unicode__(self):
return '%s %s %s' % (self.ad, self.soyad, self.emekli_sicil_no)
class BAPProjeTurleri(Model):
kod = field.String(__(u"Proje tür kodu"))
ad = field.String(__(u"Proje türünün Adı"))
aciklama = field.Text(__(u"Proje türüne dair açıklama"))
min_sure = field.Integer(__(u"Projenin minumum süreceği ay sayısı"))
max_sure = field.Integer(__(u"Projenin maximum süreceği ay sayısı"))
butce_ust_limit = field.Float(__(u"Projenin üst limiti"))
gerceklestirme_gorevlisi_yurutucu_ayni_mi = field.Boolean(
__(u"Projenin gerçekleştirme görevlisi ile yürütücüsü aynı kişi mi?"))
class Meta:
verbose_name = __(u"Proje Türü")
verbose_name_plural = __(u"Proje Türleri")
list_fields = ['kod', 'ad', 'min_sure', 'max_sure', 'butce_ust_limit']
list_filters = [
'kod',
]
search_fields = [
'kod', 'ad', 'min_sure', 'max_sure', 'butce_ust_limit'
]
class Belgeler(ListNode):
class Meta:
title = __(u"Projede Kullanılacak Belgeler")
ad = field.String(__(u"Belgenin İsmi"))
gereklilik = field.Boolean(__(u"Belgenin Zorunluluğu"), required=False)
class Formlar(ListNode):
class Meta:
title = __(u"Projede Kullanılacak Formlar")
proje_formu = Form()
gereklilik = field.Boolean(__(u"Formun Gerekliliği"), default=False)
secili = field.Boolean(__(u"Projeye Dahil Et"), default=False)
def __unicode__(self):
return "%s: %s" % (self.kod, self.ad)
class Room(Model):
"""Oda modeli
Üniversitenin sahip olduğu odalara (sınıf, lab, amfi) ait data modelidir. Her odanın
bir kodu bulunur.
Odalar, binalara ve binalar aracılığıyla kampüslere bağlanır.
"""
code = field.String("Kod", index=True)
name = field.String("İsim", index=True)
room_type = RoomType("Oda Tipi", index=True)
#: Bina içerisindeki kat bilgisi
floor = field.String("Kat", index=True)
capacity = field.Integer("Kapasite", index=True)
building = Building()
is_active = field.Boolean("Aktif", index=True)
class Meta:
verbose_name = "Oda"
verbose_name_plural = "Odalar"
search_fields = ['code', 'name']
list_fields = ['code', 'name']
class RoomDepartments(ListNode):
"""Oda Departman ListNode
Bu odayı kullanabilecek birimlerin listesi saklanır.
"""
unit = Unit()
def __unicode__(self):
return '%s %s %s' % (self.code, self.name, self.capacity)
class RoomType(Model):
"""Oda tipleri modeli
Odalar sinif, amfi, salon, kimya laboratuvari vb tiplere ayrilirlar. Ilgili notlarla
birlikte bu tipler RoomType modelinde tanimlanir.
"""
type = field.String(_(u"Oda Tipi"), index=True)
notes = field.Text(_(u"Notlar"), index=True)
exam_available = field.Boolean(_(u"Sınav Amaçlı Kullanılabilir"),
index=True)
class Meta:
verbose_name = _(u"Oda Tipi")
verbose_name_plural = _(u"Oda Tipleri")
search_fields = ['type', 'notes']
list_fields = [
'type',
]
def __unicode__(self):
return '%s' % self.type
class KurumDisiGorevlendirmeBilgileri(Model):
"""Kurum Dışı Görevlendirme Bilgileri Modeli
Personelin bağlı olduğu kurumun dışındaki görev bilgilerine ait modeldir.
"""
gorev_tipi = field.Integer(_(u"Görev Tipi"), choices="gorev_tipi")
baslama_tarihi = field.Date(_(u"Başlama Tarihi"), format="%d.%m.%Y")
bitis_tarihi = field.Date(_(u"Bitiş Tarihi"), format="%d.%m.%Y")
aciklama = field.Text(_(u"Açıklama"))
resmi_yazi_sayi = field.String(_(u"Resmi Yazı Sayı"))
resmi_yazi_tarih = field.Date(_(u"Resmi Yazı Tarihi"), format="%d.%m.%Y")
maas = field.Boolean(_(u"Maaş"))
yevmiye = field.Boolean(_(u"Yevmiye"), default=False)
yolluk = field.Boolean(_(u"Yolluk"), default=False)
ulke = field.Integer(_(u"Ülke"), default="90", choices="ulke")
soyut_rol = AbstractRole(verbose_name=_(u"Görev"))
personel = Personel()
class Meta:
verbose_name = _(u"Kurum Dışı Görevlendirme")
verbose_name_plural = _(u"Kurum Dışı Görevlendirmeler")
list_fields = ["ulke", "gorev_tipi", "kurum_disi_gorev_baslama_tarihi"]
list_filters = [
"ulke", "gorev_tipi", "kurum_disi_gorev_baslama_tarihi"
]
search_fields = [
"aciklama",
]
form_grouping = [
{
"layout":
"4",
"groups": [{
"group_title":
_(u"Görev"),
"items": [
"gorev_tipi", "kurum_disi_gorev_baslama_tarihi",
"kurum_disi_gorev_bitis_tarihi", "ulke", "aciklama"
],
"collapse":
False
}]
},
{
"layout":
"2",
"groups": [{
"group_title": _(u"Resmi Yazi"),
"items": ["resmi_yazi_sayi", "resmi_yazi_tarih"],
"collapse": False
}, {
"items": ["maas", "yevmiye", "yolluk"],
"collapse": False
}]
},
]
def __unicode__(self):
return "%s %s %s" % (self.gorev_tipi, self.aciklama, self.ulke)
class Personel(Model):
"""Personel Modeli
Personelin özlük ve iletişim bilgilerini içerir.
"""
tckn = field.String(_(u"TC No"))
kurum_sicil_no_int = field.Integer(_(u"Kurum Sicil No"))
ad = field.String(_(u"Adı"))
soyad = field.String(_(u"Soyadı"))
cinsiyet = field.Integer(_(u"Cinsiyet"), choices='cinsiyet')
uyruk = field.String(_(u"Uyruk"))
ikamet_adresi = field.String(_(u"İkamet Adresi"))
ikamet_il = field.String(_(u"İkamet İl"))
ikamet_ilce = field.String(_(u"İkamet İlçe"))
adres_2 = field.String(_(u"Adres 2"))
oda_no = field.String(_(u"Oda Numarası"))
oda_tel_no = field.String(_(u"Oda Telefon Numarası"))
cep_telefonu = field.String(_(u"Cep Telefonu"))
e_posta = field.String(_(u"E-Posta"))
e_posta_2 = field.String(_(u"E-Posta 2"))
e_posta_3 = field.String(_(u"E-Posta 3"))
web_sitesi = field.String(_(u"Web Sitesi"))
yayinlar = field.String(_(u"Yayınlar"))
projeler = field.String(_(u"Projeler"))
kan_grubu = field.String(_(u"Kan Grubu"))
ehliyet = field.String(_(u"Ehliyet"))
verdigi_dersler = field.String(_(u"Verdiği Dersler"))
biyografi = field.Text(_(u"Biyografi"))
notlar = field.Text(_(u"Notlar"), required=False)
engelli_durumu = field.String(_(u"Engellilik"))
engel_grubu = field.String(_(u"Engel Grubu"))
engel_derecesi = field.String(_(u"Engel Derecesi"))
engel_orani = field.Integer(_(u"Engellilik Oranı"))
cuzdan_seri = field.String(_(u"Seri"))
cuzdan_seri_no = field.String(_(u"Seri No"))
baba_adi = field.String(_(u"Ana Adı"))
ana_adi = field.String(_(u"Baba Adı"))
dogum_tarihi = field.Date(_(u"Doğum Tarihi"), format="%d.%m.%Y")
dogum_yeri = field.String(_(u"Doğum Yeri"))
medeni_hali = field.Integer(_(u"Medeni Hali"), choices="medeni_hali")
kayitli_oldugu_il = field.String(_(u"İl"))
kayitli_oldugu_ilce = field.String(_(u"İlçe"))
kayitli_oldugu_mahalle_koy = field.String(_(u"Mahalle/Köy"))
kayitli_oldugu_cilt_no = field.String(_(u"Cilt No"))
kayitli_oldugu_aile_sira_no = field.String(_(u"Aile Sıra No"))
kayitli_oldugu_sira_no = field.String(_(u"Sıra No"))
kimlik_cuzdani_verildigi_yer = field.String(_(u"Cüzdanın Verildiği Yer"))
kimlik_cuzdani_verilis_nedeni = field.String(_(u"Cüzdanın Veriliş Nedeni"))
kimlik_cuzdani_kayit_no = field.String(_(u"Cüzdan Kayıt No"))
kimlik_cuzdani_verilis_tarihi = field.String(_(u"Cüzdan Kayıt Tarihi"))
kazanilmis_hak_derece = field.Integer(_(u"Güncel Kazanılmış Hak Derece"),
index=True)
kazanilmis_hak_kademe = field.Integer(_(u"Güncel Kazanılmış Hak Kademe"),
index=True)
kazanilmis_hak_ekgosterge = field.Integer(_(u"Kazanılmış Hak Ek Gösterge"),
index=True)
gorev_ayligi_derece = field.Integer(_(u"Güncel Görev Aylığı Derece"),
index=True)
gorev_ayligi_kademe = field.Integer(_(u"Güncel Görev Aylığı Kademe"),
index=True)
gorev_ayligi_ekgosterge = field.Integer(_(u"Görev Aylığı Ek Gösterge"),
index=True)
emekli_muktesebat_derece = field.Integer(
_(u"Güncel Emekli Müktesebat Derece"), index=True)
emekli_muktesebat_kademe = field.Integer(
_(u"Güncel Emekli Müktesebat Kademe"), index=True)
emekli_muktesebat_ekgosterge = field.Integer(
_(u"Emekli Müktesebat Ek Gösterge"), index=True)
kh_sonraki_terfi_tarihi = field.Date(
_(u"Kazanılmış Hak Sonraki Terfi Tarihi"),
index=True,
format="%d.%m.%Y")
ga_sonraki_terfi_tarihi = field.Date(
_(u"Görev Aylığı Sonraki Terfi Tarihi"), index=True, format="%d.%m.%Y")
em_sonraki_terfi_tarihi = field.Date(
_(u"Emekli Müktesebat Sonraki Terfi Tarihi"),
index=True,
format="%d.%m.%Y")
birim = Unit(_(u"Birim"))
# Personelin Kendi Ünvanı
unvan = field.Integer(_(u"Personel Unvan"),
index=True,
choices="unvan_kod",
required=False)
# Aşağıdaki bilgiler atama öncesi kontrol edilecek, Doldurulması istenecek
emekli_sicil_no = field.String(_(u"Emekli Sicil No"), index=True)
emekli_giris_tarihi = field.Date(_(u"Emekliliğe Giriş Tarihi"),
index=True,
format="%d.%m.%Y")
personel_turu = field.Integer(_(u"Personel Türü"), choices="personel_turu")
hizmet_sinifi = field.Integer(_(u"Hizmet Sınıfı"), choices="hizmet_sinifi")
statu = field.Integer(_(u"Statü"), choices="personel_statu")
brans = field.String(_(u"Branş"), index=True)
# akademik personeller icin sozlesme sureleri
gorev_suresi_baslama = field.Date(_(u"Görev Süresi Başlama"),
index=True,
format="%d.%m.%Y")
gorev_suresi_bitis = field.Date(_(u"Görev Süresi Bitiş"),
index=True,
format="%d.%m.%Y")
# todo: durum_degisikligi yonetimi
# kurumda ilk goreve baslama bilgileri, atama modelinden elde edilip
# edilemeyecegini soracagiz. mevcut otomasyonda ayrilmalar da burada tutuluyor.
# bunu tarih ve durum_degisikligi fieldlarindan olusan bir listnode seklinde tutabiliriz.
goreve_baslama_tarihi = field.Date(_(u"Göreve Başlama Tarihi"),
index=True,
format="%d.%m.%Y")
baslama_sebep = HitapSebep()
# aday ve idari memurlar icin mecburi hizmet suresi
mecburi_hizmet_suresi = field.Date(_(u"Mecburi Hizmet Süresi"),
index=True,
format="%d.%m.%Y")
# Arama için kullanılacak Flaglar
kadro_derece = field.Integer(default=0)
aday_memur = field.Boolean()
arsiv = field.Boolean() # ayrilmis personeller icin gecerlidir.
user = User(one_to_one=True)
class Meta:
app = 'Personel'
verbose_name = _(u"Personel")
verbose_name_plural = _(u"Personeller")
list_fields = ['ad', 'soyad', 'tckn', 'durum']
search_fields = ['ad', 'soyad', 'cep_telefonu', 'tckn']
def durum(self):
return self.nufus_kayitlari.durum if self.nufus_kayitlari.key else None
durum.title = "Durum"
@lazy_property
def gorunen_kazanilmis_hak_kademe(self):
return gorunen_kademe_hesapla(int(self.kazanilmis_hak_derece),
int(self.kazanilmis_hak_kademe))
@lazy_property
def gorunen_gorev_ayligi_kademe(self):
return gorunen_kademe_hesapla(int(self.gorev_ayligi_derece),
int(self.gorev_ayligi_kademe))
@lazy_property
def gorunen_emekli_muktesebat_kademe(self):
return gorunen_kademe_hesapla(int(self.emekli_muktesebat_derece),
int(self.emekli_muktesebat_kademe))
@lazy_property
def atama(self):
"""atama
Personelin atama bilgilerini iceren atama nesnesini getirir.
Returns:
Atama örneği (instance)
"""
# Mevcut pyoko API'i ile uyumlu olmasi icin, geriye bos bir Atama nesnesi dondurur.
atamalar = Atama.objects.set_params(
sort='goreve_baslama_tarihi desc').filter(personel=self)
return atamalar[0] if atamalar else Atama()
@lazy_property
def kadro(self):
"""Kadro
Personelin atama bilgilerinden kadrosuna erişir.
Returns:
Kadro örneği (instance)
"""
return self.atama.kadro
@lazy_property
def sicil_no(self):
"""Kadro
Personelin atama bilgilerinden sicil numarasina erişir.
Returns:
Sicil No (str)
"""
return self.atama.kurum_sicil_no
@lazy_property
def kurum_ici_gorevlendirme(self):
"""kurum_ici_gorevlendirme
Personelin varsa kurum içi görevlendirme bilgilerini getirir.
Returns:
KurumIciGorevlendirmeBilgileri listesi (instance list)
"""
simdiki_tarih = datetime.date.today()
gorevlendirmeler = KurumIciGorevlendirmeBilgileri.objects.filter(
kurum_ici_gorev_baslama_tarihi__lte=simdiki_tarih,
kurum_ici_gorev_bitis_tarihi__gte=simdiki_tarih,
personel=self)
return gorevlendirmeler[0] if gorevlendirmeler.count() == 1 else None
@lazy_property
def kurum_disi_gorevlendirme(self):
"""kurum_disi_gorevlendirme
Personelin varsa kurum dışı görevlendirme bilgilerini getiri.
Returns:
KurumDisiGorevlendirmeBilgileri listesi (instance list)
"""
simdiki_tarih = datetime.date.today()
gorevlendirmeler = KurumDisiGorevlendirmeBilgileri.objects.filter(
kurum_disi_gorev_baslama_tarihi__lte=simdiki_tarih,
kurum_disi_gorev_bitis_tarihi__gte=simdiki_tarih,
personel=self)
return gorevlendirmeler[0] if gorevlendirmeler.count() == 1 else None
@property
def kurum_sicil_no(self):
return "%s-%s" % (SICIL_PREFIX, self.kurum_sicil_no_int)
def __unicode__(self):
return gettext(u"%(ad)s %(soyad)s") % {
'ad': self.ad,
'soyad': self.soyad
}
class User(Model):
"""User modeli
User modeli Ulakbus temel kullanıcı modelidir. Temel kullanıcı
bilgilerini içerir. Ulakbus'de işlem yapan/yapılan her kullanıcıya
ait bir ve tek kullanıcı olması zorunludur.
"""
username = field.String("Username", index=True)
password = field.String("Password")
avatar = field.File("Profile Photo", random_name=True, required=False)
name = field.String("First Name", index=True)
surname = field.String("Surname", index=True)
superuser = field.Boolean("Super user", default=False)
class Meta:
app = 'Sistem'
verbose_name = "Kullanıcı"
verbose_name_plural = "Kullanıcılar"
search_fields = ['username', 'name', 'surname']
def get_avatar_url(self):
"""
Bu metot kullanıcıya ait avatar url'ini üretir.
Returns:
str: kullanıcı avatar url
"""
return "%s%s" % (settings.S3_PUBLIC_URL, self.avatar)
def __unicode__(self):
return "User %s" % self.username
def set_password(self, raw_password):
"""
Kullanıcı şifresini encrypt ederek set eder.
Args:
raw_password (str)
"""
self.password = pbkdf2_sha512.encrypt(raw_password,
rounds=10000,
salt_size=10)
def check_password(self, raw_password):
"""
Verilen encrypt edilmemiş şifreyle kullanıcıya ait encrypt
edilmiş şifreyi karşılaştırır.
Args:
raw_password (str)
Returns:
bool: Değerler aynı olması halinde True, değilse False
döner.
"""
return pbkdf2_sha512.verify(raw_password, self.password)
def get_role(self, role_id):
"""
Kullanıcıya ait Role nesnesini getirir.
Args:
role_id (int)
Returns:
dict: Role nesnesi
"""
return self.role_set.node_dict[role_id]
class Task(Model):
"""
Task definition for workflows
"""
run = field.Boolean(__(u"Create tasks now!"), default=False)
wf = BPMNWorkflow()
name = field.String(__(u"Name of task"))
abstract_role = AbstractRoleModel(__(u"Abstract Role"), null=True)
role = RoleModel(null=True)
unit = UnitModel(null=True)
get_roles_from = field.String(__(u"Get roles from"),
choices=ROLE_GETTER_CHOICES)
role_query_code = field.String(__(u"Role query dict"), null=True)
object_query_code = field.String(__(u"Object query dict"), null=True)
object_key = field.String(__(u"Subject ID"), null=True)
object_type = field.String(__(u"Object type"),
null=True,
choices=get_model_choices)
start_date = field.DateTime(__(u"Start time"), format="%d.%m.%Y")
finish_date = field.DateTime(__(u"Finish time"), format="%d.%m.%Y")
repeat = field.Integer(__(u"Repeating period"),
default=0,
choices=JOB_REPEATING_PERIODS)
notification_density = field.Integer(__(u"Notification density"),
choices=JOB_NOTIFICATION_DENSITY)
recursive_units = field.Boolean(__(u"Get roles from all sub-units"))
class Meta:
verbose_name = "Workflow Task"
verbose_name_plural = "Workflows Tasks"
search_fields = ['name']
list_fields = [
'name',
]
def create_wf_instances(self, roles=None):
"""
Creates wf instances.
Args:
roles (list): role list
Returns:
(list): wf instances
"""
# if roles specified then create an instance for each role
# else create only one instance
if roles:
wf_instances = [
WFInstance(wf=self.wf,
current_actor=role,
task=self,
name=self.wf.name) for role in roles
]
else:
wf_instances = [
WFInstance(wf=self.wf, task=self, name=self.wf.name)
]
# if task type is not related with objects save instances immediately.
if self.task_type in ["C", "D"]:
return [wfi.save() for wfi in wf_instances]
# if task type is related with its objects, save populate instances per object
else:
wf_obj_instances = []
for wfi in wf_instances:
role = wfi.current_actor if self.task_type == "A" else None
keys = self.get_object_keys(role)
wf_obj_instances.extend([
WFInstance(wf=self.wf,
current_actor=role,
task=self,
name=self.wf.name,
wf_object=key,
wf_object_type=self.object_type).save()
for key in keys
])
return wf_obj_instances
def create_task_invitation(self, instances, roles=None):
for wfi in instances:
current_roles = roles or [wfi.current_actor]
for role in current_roles:
inv = TaskInvitation(instance=wfi,
role=role,
wf_name=self.wf.name,
progress=get_progress(
start=self.start_date,
finish=self.finish_date),
start_date=self.start_date,
finish_date=self.finish_date)
inv.title = self.name
inv.save()
def create_tasks(self):
"""
will create a WFInstance per object
and per TaskInvitation for each role and WFInstance
"""
roles = self.get_roles()
if self.task_type in ["A", "D"]:
instances = self.create_wf_instances(roles=roles)
self.create_task_invitation(instances)
elif self.task_type in ["C", "B"]:
instances = self.create_wf_instances()
self.create_task_invitation(instances, roles)
def get_object_query_dict(self):
"""returns objects keys according to self.object_query_code
which can be json encoded queryset filter dict or key=value set
in the following format: ```"key=val, key2 = val2 , key3= value with spaces"```
Returns:
(dict): Queryset filtering dicqt
"""
if isinstance(self.object_query_code, dict):
# _DATE_ _DATETIME_
return self.object_query_code
else:
# comma separated, key=value pairs. wrapping spaces will be ignored
# eg: "key=val, key2 = val2 , key3= value with spaces"
return dict(
pair.split('=') for pair in self.object_query_code.split(','))
def get_object_keys(self, wfi_role=None):
"""returns object keys according to task definition
which can be explicitly selected one object (self.object_key) or
result of a queryset filter.
Returns:
list of object keys
"""
if self.object_key:
return [self.object_key]
if self.object_query_code:
model = model_registry.get_model(self.object_type)
return [
m.key for m in self.get_model_objects(
model, wfi_role, **self.get_object_query_dict())
]
@staticmethod
def get_model_objects(model, wfi_role=None, **kwargs):
"""
Fetches model objects by filtering with kwargs
If wfi_role is specified, then we expect kwargs contains a
filter value starting with role,
e.g. {'user': '******'}
We replace this `role` key with role instance parameter `wfi_role` and try to get
object that filter value 'role.program.user' points by iterating `getattribute`. At
the end filter argument becomes {'user': user}.
Args:
model (Model): Model class
wfi_role (Role): role instance of wf instance
**kwargs: filter arguments
Returns:
(list): list of model object instances
"""
query_dict = {}
for k, v in kwargs.items():
if isinstance(v, list):
query_dict[k] = [str(x) for x in v]
else:
parse = str(v).split('.')
if parse[0] == 'role' and wfi_role:
query_dict[k] = wfi_role
for i in range(1, len(parse)):
query_dict[k] = query_dict[k].__getattribute__(
parse[i])
else:
query_dict[k] = parse[0]
return model.objects.all(**query_dict)
def get_roles(self):
"""
Returns:
Role instances according to task definition.
"""
if self.role.exist:
# return explicitly selected role
return [self.role]
else:
roles = []
if self.role_query_code:
# use given "role_query_code"
roles = RoleModel.objects.filter(**self.role_query_code)
elif self.unit.exist:
# get roles from selected unit or sub-units of it
if self.recursive_units:
# this returns a list, we're converting it to a Role generator!
roles = (RoleModel.objects.get(k)
for k in UnitModel.get_role_keys(self.unit.key))
else:
roles = RoleModel.objects.filter(unit=self.unit)
elif self.get_roles_from:
# get roles from selected predefined "get_roles_from" method
return ROLE_GETTER_METHODS[self.get_roles_from](RoleModel)
if self.abstract_role.exist and roles:
# apply abstract_role filtering on roles we got
if isinstance(roles, (list, types.GeneratorType)):
roles = [
a for a in roles
if a.abstract_role.key == self.abstract_role.key
]
else:
roles = roles.filter(abstract_role=self.abstract_role)
else:
roles = RoleModel.objects.filter(abstract_role=self.abstract_role)
return roles
@property
def task_type(self):
"""
Returns:
(string) a task type defined as below
"Type A":
Roles are gathered from intersection of `get_roles_from`, `abstract_role` and
`unit` recursively.
Objects are filtered by `object_type` and `object_query_code`. And relation between
objects and roles specified in object_query_code by `role` key.
```
unit="A faculty",
abstract_role="Lecturer",
object_type="Class"
object_query_code="lecturer_id='role.key'" # role means lecturer's current role.
```
"fields": ["unit", "abstract_role", "get_roles_from", "object_type",
"object_query_code", "recursive"]
"Type B":
Roles are gathered from intersection of `get_roles_from`, `abstract_role` and
`unit` recursively.
Objects are filtered by `object_type` and `object_query_code`.
```
unit="A faculty",
abstract_role="Managers",
object_type="Class"
object_query_code="capacity>50"
```
"fields": ["unit", "abstract_role", "get_roles_from", "object_type",
"object_query_code", "recursive"]
"Type C":
Roles are gathered from `get_roles_from` or `abstract_role` or intersection of both.
No objects are specified. This type of task is for wfs which are not dependent on
any object or unit, etc. e.g, periodic system management wf.
```
abstract_role="Managers",
```
"fields": ["abstract_role", "get_roles_from"]
"Type D":
Roles are gathered from intersection of `get_roles_from`, `abstract_role` and
`unit` recursively.
No objects are specified. This type of task is for wfs which are not dependent on
any object, but unit. e.g, change timetable schedule, choose advisers
for department.
```
unit="A faculty"
abstract_role="Chief of Department",
```
"fields": ["unit", "abstract_role", "get_roles_from", "recursive"]
"""
if self.object_type:
return "A" if self.is_role_in_object_query_code() else "B"
else:
return "C" if not self.unit.exist else "D"
def is_role_in_object_query_code(self):
query_code = self.get_object_query_dict()
for k, v in query_code.items():
parse = str(v).split('.')
if parse[0] == 'role':
return True
return False
def post_save(self):
"""can be removed when a proper task manager admin interface implemented"""
if self.run:
self.run = False
self.create_tasks()
self.save()
def __unicode__(self):
return '%s' % self.name
class AbstractRole(Model):
"""
AbstractRoles are stand as a foundation for actual roles
"""
name = field.String(_(u"Name"), index=True)
read_only = field.Boolean(_(u"Archived"))
class Meta:
verbose_name = _(u"Abstract Role")
verbose_name_plural = _(u"Abstract Roles")
search_fields = ['name']
def __unicode__(self):
return "%s" % self.name
def get_permissions(self):
"""
Soyut role ait Permission nesnelerini bulur ve code değerlerini
döner.
Returns:
list: Permission code değerleri
"""
return [
p.permission.code for p in self.Permissions if p.permission.code
]
def add_permission(self, perm):
"""
Soyut Role Permission nesnesi tanımlamayı sağlar.
Args:
perm (object):
"""
self.Permissions(permission=perm)
PermissionCache.flush()
self.save()
def add_permission_by_name(self, code, save=False):
"""
Soyut role Permission eklemek veya eklenebilecek Permission
nesnelerini verilen ``code`` parametresine göre listelemek olmak
üzere iki şekilde kullanılır.
Args:
code (str): Permission nesnelerini filtre etmekte kullanılır
save (bool): True ise Permission ekler, False ise Permission
listesi döner.
Returns:
list: ``save`` False ise Permission listesi döner.
"""
if not save:
return [
"%s | %s" % (p.name, p.code)
for p in Permission.objects.filter(code__contains=code)
]
PermissionCache.flush()
for p in Permission.objects.filter(code__contains=code):
if p not in self.Permissions:
self.Permissions(permission=p)
if p:
self.save()
class Permissions(ListNode):
permission = Permission()
