29 Haziran 2014 Pazar

Python ile arp zehirlenmesi nasıl tespit edilir? Arp zehirlenmesi nedir? Arp poising örneğin bir kafede oturdunuz ve kafenin ağına bağlandınız. Bu durumda saldırgan ağ ile sizin aranıza girerek kendisini size gateway olarak gösterebilir. Bu şekilde trafiğinizi kendi üstüne çekerek bilgilerinizi çalabilir. İşte burada gateway değişme durumunu yakalayan Python scripti yazdık.
import os
from Tkinter import *

## Uyarı veren fonksiyon
def Alert():
    root = Tk()
    root.title('Alert Gateway')
    w =500
    h = 100
    ws = root.winfo_screenwidth()
    hs = root.winfo_screenheight()
    x = (ws/2) - (500/2)
    y = (hs/2) - (100/2)
    root.geometry('%dx%d+%d+%d' % (w, h, x, y))
    Message(root, text="Your gateway has been changed.", background='red', width=300,
          fg='ivory', relief=GROOVE).pack(padx=100, pady=10)
    root.mainloop()

##Program çalıştırıldığında gateway alınır.
gateway = (os.popen("route -n | grep 'UG[ \t]' | awk '{print $2}'")).read()
while 1:
    ##Daha sonra sürekli alınarak kıyaslama yapılır. Eğer değiştirilmiş ise uyarı verilir.
    gateway2 = (os.popen("route -n | grep 'UG[ \t]' | awk '{print $2}'")).read()
    if gateway != gateway2:
        Alert()
        break

Şifre Sıfırlama

Kullandığımız her sistemde bir kullanıcı adı ve şifreye sahip oluruz. Bazen bu şifreyi unuttuğumuz zamanlar olabiliyor. Genel olarak da güvenli olması sebebi ile kullanılan mail adresine şifre sıfırlama parolası gönderilerek kullanıcılara ya yeni şifreleri otomatik olarak atanır yada yeni şifre oluşturabilecekleri bir link gönderilir. İşte şimdi bu işlemi Django'da yapacağız. Bu işlemleri Django otomatik olarak yapar. Bizim bazı tanımlamalar yapmamız gerekiyor hepsi bu. Kullanıcıya e-posta ile yeni şifre alabileceği bir link göndereceğiz.
E-Posta Ayarları
Bu linki gönderebilmek için bir e-posta sunucusuna ihtiyacımız olacak. Siz eğer isterseniz sisteminize bir MTA(Mail Transfer Agent) kurabilir ve mail gönderme işlemini onun üzerinden yapabilirsiniz. Biz google'ın bize sağlamış olduğu sunucuyu kullanacağız. Bunun için sadece bir gmail hesabımızın olması yeterli. İlk önce settings.py dosyasında e-posta ayarlarımızı yapacağız.
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_HOST_USER = 'gmailhesabınız'
EMAIL_HOST_PASSWORD = 'gmailsifreniz'
DEFAULT_FROM_EMAIL = 'mailadresi'
EMAIL_PORT = 587
EMAIL_USE_TLS = True

Bu kodları settings.py dosyasına ekliyoruz.
Değişken Açıklama
EMAIL_HOST Posta sunucusunun ip adresi veya domaini. Eğer localda çalışan bir sunucu kullanıyorsanız localhost yazabilirsiniz. Yada doğrudan sunucunun ip adresini de yazabilirsiniz.
EMAIL_HOST_USER SMTP onaylaması isteniyorsa kullanıcı adı. Burada gmaili kullandığımız için gmail kullanıcı adımızı yazıyoruz.
EMAIL_HOST_PASSWPRD SMTP onaylaması isteniyorsa kullanıcı şifresi. Burda gmaili kullandığımız için gmail kullanıcı şifremizi yazıyoruz.
DEFAULT_FROM_EMAIL Kimden gittiği belli olmayan postalar için bu adresten gönderilir.
EMAIL_PORT Posta sunucusunun dinlediği port numarası.
EMAIL_USE_TLS Eğer SMTP sunucusu TLS kullanıyorsa TRUE yapmamız gerekir. Varsayılan olarak FALSE gelir. Genel olarak 587. portu dinleyen bağlantılar için kullanılır.
Sadece deneme yapmak için Python bize deneysel bir e-posta sunucusu sağlayabilir. Bunun için komut satırında şu komutu çalıştırın.
python -m smtpd -n -c DebuggingServer localhost:255
Bu komutu çalıştırdıktan sonra settings.py dosyasında yazdıklarımız için sadece şunları yazmanız yeterlidir.
EMAIL_HOST = 'localhost'
EMAIL_PORT = 2525
E-Posta Gönderme
Ayarlarımız yaptığımıza göre artık posta gönderebiliriz. İlk e-postayı python kabuğu ile gönderelim.
>>> from django.core.mail import send_mail
>>> send_mail('Test','Bu e-posta test amacı ile gönderilmiştir.','mazlum.agar@gmail.com',['mazlum.agar@hotmail.com'])
1
Eğer sizde de geriye 1 değeri döndürüldü ise posta gönderilmiş demektir. Eğer 1 değeri dönmez ise postanın neden gönderilmediğine dair ayrıntılı bilgi verilecektir.
send_mail fonksiyonundaki ilk argüman posta konusu, ikincisi posta içeriği, üçüncüsü kimden gideceği, dördüncüsü ise liste şeklinde postanın kimlere gideceği.
Eğer HTML içerikli bir posta göndermek isterseniz şu yöntemi kullanabilirsiniz.
>>> from django.core.mail import EmailMultiAlternatives
>>> konu = 'Test'
>>> kimden = 'mazlum.agar@hotmail.com'
>>> kime = 'mazlum.agar@gmail.com'
>>> metin_icerik = 'Test\n Bu bir test mailidir'
>>> html_icerik = '<h3>Test<h3><p>Bu bir test mailidir.</p>'
>>> posta = EmailMultiAlternatives(konu,metin_icerik,kimden,[kime])
>>> posta.attach_alternative(html_icerik,"text/html")
>>> 
>>> posta.send()
1
Site Adı
Hatırlarsanız Yönetim Paneli Sites Bölümünü Aktifleştirme yazısında Yönetim Panelinde Sites bölümünün nasıl aktifleştirileceğinden bahsetmiştik. İşte bu bölümden sitemizin alan ismini değiştirebiliriz. Django tüm siteler için varsayılan olarak example.com vermektedir.
Buradan site ismini değiştirebiliriz. Tabi her zaman olduğu gibi bu işlemi kabuktan nasıl yapabileceğimizi de gösterelim.
>>> from django.contrib.sites.models import Site
>>> site = Site.objects.get(id=1)
>>> site.name = "localhost"
>>> site.domain = "localhost:8000"
>>> site.save()
Şuan yerel makinede(localhost) çalıştığımız için bu şekilde yaptık. Gerçek bir projede site ismini yazmamız gerekir. Bu işlemi neden yaptık? Biraz sonra şifre sıfırlama işleminde mail gönderirken kullanıcıya yeni şifre oluşturabileceği bir link göndereceğiz. Django o linkte buraya yazdığımız site ismini kullanıyor. Eğer burayı düzeltmez ise link example.com ile başlayacaktır.
Şifre Sıfırlama Linkleri
urls.py dosyasında urlpatternsurlpatterns değişkenine aşağıdaki url'leri ekleyelim.
url(r'^accounts/password/reset/$',
        'django.contrib.auth.views.password_reset',
        {'post_reset_redirect':'/accounts/password/reset/done/'},
        name='password_reset'),

    url(r'^accounts/password/reset/done/$',
        'django.contrib.auth.views.password_reset_done',
        name='password_reset_done'),

    url(r'^accounts/password/reset/(?P<uidb64>[0-9A-Za-z]+)-(?P<token>.+)/$',
        'django.contrib.auth.views.password_reset_confirm',
        {'post_reset_redirect':'/accounts/password/done/'},
        name='password_reset_confirm'),

    url(r'^accounts/password/done/$',
        'django.contrib.auth.views.password_reset_complete',
        name='password_reset_complete'),
Tıpkı şifre değiştirme işleminde olduğu gibi şifre sıfırlarken de Django'nun Yönetim Panelini kullanacağız. Birazdan kendi şablonlarımızı da oluşturmayı göreceğiz. Url'leri eklediğimize göre taryıcıdan http://localhost:8000/accounts/password/reset/ yazdığınızda şifre sıfırlama penceresi ile karşılacaksınız.
Not: Bu url'leri istediğiniz gibi değiştirebilirsiniz.
Şifre sıfırlama linki için bizden e-posta istiyor. Burada kullanıcı kayıt olurken yazdığı e-postayı yazmak zorundadır. Şimdi kayıt olurken yazdığımız e-posta'yı girelim ve şifre sıfırlama mailini alalım. Gelen mail şu şekildedir.
Gördüğünüz gibi yeni şifre girebileceğimiz bir link gönderilmiş. Şimdi o linke tıklayalım.
Artık yeni şifremizi girebiliriz. Yönetim Paneli şablonlarını kullanarak şifre sıfırlamak bu kadar basit.
Kendi Şifre Sıfırlama Şablonlarımız
Şimdi Yönetim Paneli şablonlarını değilde kendi şablonlarımızı kullanarak şifre sıfırlama işlemini yapalım. Şifre değiştirme işleminde yaptığımız işlemlerin aynısı burası içinde geçerli. Tıpki şifre değiştirme şablonları gibi hastahane/hastahane/sablonlar/registration dosyası içerisine şablonlarımız oluşturuyoruz.
hastahane/hastahane/sablonlar/registration/password_reset_form.html
<!DOCTYPE html>
<html>
<head>
    <title>Şifre Sıfırlama İsteği</title>
     <link rel="stylesheet" type="text/css" href="/static/base.css" />
</head>
<body>
<h3>Şifre Sıfırlama</h3>
Şifrenizi unuttuysanız, aşağıdaki kutuya e-posta adresinizi giriniz. Size şifre sıfırlamanız için posta göndereceğiz.

<form action="" method="post">
    {% csrf_token %}
    {{form.email.errors}}
    <p>E-posta adresi:
    {{ form.email }}
    <input type="submit" value="Şifre Sıfırla" />
    </p>

</form>
</body>
</html>
hastahane/hastahane/sablonlar/registration/password_reset_done.html
<!DOCTYPE html>
<html>
<head>
    <title>Şifre Sıfırlama Tamamlandı</title>
    <link rel="stylesheet" type="text/css" href="/static/base.css" />
</head>
<body>

<h3>Şifre sıfırlama işlemi tamamlandı</h3>
Lütfen posta kutunuzu kontrol edin ve talimatları yerine getirin. Eğer e-posta alamadıysanız, doğru e-posta girdiğinizden emin olun.
</body>
</html>
hastahane/hastahane/sablonlar/registration/password_reset_email.html
{% autoescape off %}

Merhaba {{user.first_name}}

{{site_name}} web sitesinde şifre sıfırlama isteğinde bulunduğunuz için bu maili aldınız.
Eğer böyle bir istekte bulunmadıysanız bu maili göz ardı ediniz.

Lütfen, aşağıdaki linke tıklayarak yeni şifrenizi oluşturunuz.

{% block reset_link %}
{{protocol}}://{{domain}}{% url 'django.contrib.auth.views.password_reset_confirm' uidb64=uid token=token %}
{% endblock %}

Teşekkürler
{% endautoescape %}
hastahane/hastahane/sablonlar/registration/password_reset_confirm.html
<!DOCTYPE html>
<html>
<head>
    <title>Şifre Sıfırlama</title>
    <link rel="stylesheet" type="text/css" href="/static/base.css" />
</head>
<body>

{% if validlink %}

<h3>Şifre Sıfırlama</h3>

<form action="" method="post">
{% csrf_token %}
    <table border="1">
        {{form}}
    </table>
    <input type="submit" value="Şifre Değiştir" />
</form>
{% else %}
<p>Girdiğiniz link geçersiz. Şifre değiştirme isteğinde tekrardan bulunabilirsiniz.</p>
{% endif %}

</body>
</html>
Şablonlarımızı oluşturduk. Az önce Yönetim Paneli şablonlarını kullanırken yaptığımız işlemler aynen geçerli. Tarayıcıdan http://localhost:8000/accounts/password/reset/ yazarak şifre sıfırlama sayfasına gidiyoruz. Aşağıda kendi şablonlarımızın resimlerini görebilirsiniz.





Kullanıcı şifresini başarılı bir şekilde sıfırladık.
Kaynakça

26 Haziran 2014 Perşembe

Django Context Processor Kullanımı

Context Proccessor kullanarak her şablona göndereceğimiz içerikleri ayarlıyoruz. Yani her şablonda göstereceğimiz içerikleri Context Proccessor ile kullanarak her görünüm içerisinde tekrar tekrar içeriği göndermekten kendimizi kurtarıyoruz. Örneğin tüm kategorileri çektiğimiz şöyle bir kodumuz var.
kategoriler = Kategoriler.objects.all()
Eğer bu kategoriler tüm şablonlarda göstermek istersek tüm görünümler içerisinde bu kodu yazmak zorundayız. İşte hepsinde yazmamak için bunu context proccessor şekline dönüştüreceğiz. İlk önce uygulamamız içerisinde context_processors.py adında bir dosya oluşturuyoruz. İçerisine şu kodları yazıyoruz. uygulama/context_processors.py
from uygulama.models import Kategoriler
def kategoriler(request):
    kategoriler = Kategoriler.objects.all()
    return {
        "kategoriler":kategoriler
     }
Bunu yazdıktan sonra settings.py dosyası içerisine tanımlamayı yapmamız gerekiyor.
TEMPLATE_CONTEXT_PROCESSORS = (
    "django.contrib.auth.context_processors.auth",
    "django.core.context_processors.debug",
    "django.core.context_processors.i18n",
    "django.core.context_processors.media",
    "django.core.context_processors.static",
    "django.core.context_processors.request",
    "django.core.context_processors.tz",
    "django.contrib.messages.context_processors.messages",
    "uygulama.context_processors.kategoriler"
)
Artık her şablon içerisinde tüm kategorileri kategoriler adı ile kullanabiliriz. Örneğin;
<html>
<head></head>
<body>
   {% for kategori in kategoriler %}
       {{ kategori.adi }}
   {% endfor %}
</body>
</html>

24 Haziran 2014 Salı

Şifre Değiştirme

Kullanılan platformlarda kullanıcılar veya yöneticiler kullanıcı şifrelerini değiştirmek isteyebilirler. Biz de Django kullanırken kullanıcı şifrelerinin nasıl değiştirileceğinden bahsedeceğiz. Her zaman olduğu gibi kullanıcı şifresini değiştirmek için ilk önce Django kabuğunu kullanalım. Uç birimde python manage.py shell diyerek kabuğu açalım.
>>> from django.contrib.auth.models import User
>>> k = User.objects.get(username='mazlum') #Kullanıcı seçilir
>>> k.set_password('1234') #Seçilen kullanıcıya yeni şifre atanır.
>>> k.save()
Django kabuğunu kullanarak şifre değiştirmek bu kadar basit. Şifre değiştirme işlemleri Yönetim Paneli kullanılarak da çok kolay bir şekilde yapılabilir. Süper kullanıcı Yönetim Panelini kullanarak istediği kullanıcının şifresini değiştirebilir. Herhangi bir kullanıcı aynı şekilde kendi şifresini değiştirebilir. Tabi her kullanıcının yönetim paneline girme yetkisi olmayacak. Biz bu yüzden kullanıcı şifrelerini kendi sistemimizde değiştirmeye bakalım. Kullanıcı giriş yaptıktan sonra kullanıcıyı yönetim sayfasına yönlendiriyorduk. Şimdi bu yönetim sayfasına Şifre Değiştir köprüsü ekleyelim.
<div><a href="/accounts/password" target="_blank">Şifre Değiştir</a></div>
Köprüyü ekledikten sonra artık kullanıcıyı şifresini değiştirebileceği sayfaya yönlendireceğiz. Bunun için urls.py dosyasına şu url'leri ekliyoruz.
    url(r'accounts/password/$',
        'django.contrib.auth.views.password_change',
        name="password_change"),
    url(r'accounts/change-password-done/$',
        'django.contrib.auth.views.password_change_done',
        name="password_change_done"),
Şimdi şifre değiştir bağlantısına tıklayalım.
Sayfa tanıdık geldi değil mi? İşte bizim şuan da yaptığımız tek şey kullanıcıyı Yönetim Panelindeki şifre değiştirme bölümüne yönlendirmektir. Kullanıcı bu sayfayı kullanarak şifresini değiştirebilir. Ama geliştiriciler bu yöntemi pek sevmezler. Bunun yerine kendi sayfalarını oluşturarak kullanıcıyı buraya yönlendirirler. Biz de bu yöntemi kullanalım.
Django kayıt sistemine ait şablonları sablonlar/registration klasöründe arar. Bu klasör bulunmadığı için Django Yönetim Panelindeki şifre değiştirme sayfasına yönlendirir. Şimdi biz bu klasörü ve sayfaları oluşturacağımız için bizim oluşturduğumuz sayfaya yönlendirecek. Tabi şunu da söyleyelim; şifre değiştirme işlemi bizim üzerinde çalıştığımız yönetim uygulamasına has bir işlem değildir. Tüm kullanıcılar şifrelerini değiştirebilir. Yani tüm hastahane projesine ait bir işlemdir. Bu yüzden hastahane/settings.py dosyasındaki TEMPLATE_DIRS değişkenine sablonlar/registration yolunu eklemeliyiz.
TEMPLATE_DIRS = (
 os.path.join(anadizin,'yonetim/sablonlar'),
    os.path.join(dizin,'sablonlar'),
)
Yolu eklediğimize göre sablonlar/registration klasörünü oluşturarak içerisinde şablonları oluşturabiliriz.
hastahane/hastahane/sablonlar/registration/password_change_form.html
<!DOCTYPE html>
<html>
<head>
    <title>Parola Değiştirme</title>
    <link rel="stylesheet" type="text/css" href="/dosyalar/style.css" />
</head>
<body>

<h3>Şifre Değiştirme</h3>
Merhaba,<b>{{ user.get_full_name }}</b>
<br/>
<form action="." method="post">
    {% csrf_token %}
    <table border="1">
       {{ form }}
    </table>


    <input type="submit" value="Değiştir" />
</form>
</body>
</html>
hastahane/hastahane/sablonlar/registration/password_change_done.html
<!DOCTYPE html>
<html>
<head>
    <title>Parola Değiştirme</title>
    <link rel="stylesheet" type="text/css" href="/dosyalar/style.css" />
</head>
<body>

<h3>Şifre Değiştirme</h3><br/>
Şifreniz başarı ile değiştrildi..

</body>
</html>
Şimdi şifre değiştir bağlantısını tıklayalım.
Gördüğünüz gibi Django bizim oluşturmuş olduğumuz sablonlar/registration/password_change_form.html şablonuna yönlendirme yaptı. Burada dikkat etmemiz gereken en önemli nokta oluşturduğumuz şablonların isimleri password_change_form.html,password_change_done.html olmalıdır. Eğer isimleri farklı yaparsanız Django'nun Yönetim Paneli'ne yönlendirme yaptığını göreceksiniz.
Kaynakça

23 Haziran 2014 Pazartesi

Python ile Tree Komutu Programı

Bu yazıda Besim Altınok ile beraber yazdığımız tree komutunun verdiği çıktıyı veren programın Python ile yazılmış versiyonunu paylaşacağız. Bu program terminalden dizin adını parametre olarak alarak dizin içerisindeki dosya ve dizinleri ağaç yapısı şeklinde listelemektedir.
# -*- coding:utf-8 -*-

#Kütüphanelerin içe aktarımı
import os
from termcolor import colored
import sys

t_g = ""
t_b = ""
dosya_say, klasor_say = 0, 0

#Fonksion başlangıcı
def agac(dizin):
    global t_g, t_b, dosya_say, klasor_say
    #Dizin içerisindeki dosya ve dizinlerin isimleri liste içerisine atılmıştır.
    ls = os.listdir(dizin)
    for i in ls:
        yol = os.path.join(dizin, i)
        if os.path.isdir(yol):
            t_b = t_g
            if i.startswith(".") == False:
                klasor_say += 1
                print t_g+colored(i, 'red', attrs=['bold'])
                t_g += " "*len(i)
                #Her dizin içerisindeki dizinler için fonksiyon tekrar çağırılmıştır.
                agac(yol)
        else:
            print t_g+colored(i, 'blue')
            dosya_say += 1
    t_g = t_b
    t_b = ""

## Fonksiyon çağırılmıştır.
agac(sys.argv[1])
print "\nDizin sayısı = %s Dosya sayısı = %s\n" % (klasor_say, dosya_say)

22 Haziran 2014 Pazar

Kullanıcı Grupları

Daha önceki konularda kullanıcıları yetkilendirme işlemlerinden bahsetmiştik. Bu şekilde her kullanıcıyı teker teker yetkilendirmek çok zahmetli olacaktır. Bunun yerine Django'nun bize sağlamış olduğu Grupları kullanabiliriz. Grup oluşturarak yetkilendirme işlemini bu grup için yapacağız. Kullanıcıları ise bu gruba dahil edeceğiz ve dahil olan her kullanıcı grup yetkilerine sahip olacak.
Daha önceden yönetim sayfası oluşturmuştuk. Şimdi Django kabuğunu kullanarak yonetici isminde bir grup oluşturalım.
>>> from django.contrib.auth.models import Group
>>> grup = Group.objects.create(name='yonetici')
>>> grup.save()
Grubu oluşturmuş olduk. Tabi kullanıcılarda olduğu gibi gruplarda da bu işlemleri Django'nun Yönetim Panelinden yapabiliriz. Şimdi gelin bu panelden oluşturduğumuz gruba bakalım.
Gördüğünüz gibi grup oluşmuş. Yönetim panelinin gruplar sekmesinde sağ üst kısmında grup ekle bağlantısını görebiliyorsunuz. Bu bağlantıyı kullanarak da grup ekleme işlemini kolaylıkla yapabilirsiniz. Aynı şekilde Django kabuğunu kullanarak daha önceden oluşturmuş olduğumuz mazlum kullanıcısını bu gruba ekleyelim.
>>> from django.contrib.auth.models import User
>>> kullanici = User.objects.get(username='mazlum')
>>> kullanici.groups.add(grup)
>>> kullanici.save()
Artık mazlum kullanıcısı yonetici grubunda yer almaktadır. Bu işlemi de yönetim panelinden yapabiliriz. İlk önce kullanıcılar sekmesine gelerek mazlum kullanıcısına tıklayın. Sayfayı biraz aşağı kaydırdığınızda şu görüntü ile karşılaşacaksınız.
Biz kullanıcıyı yönetici grubuna eklediğimiz için, yonetici grubu seçilen gruplar altında yer almaktadır. Bu paneli kullanarak da istediğiniz bir kullanıcıyı gruba ekleyebilir veya gruptan çıkartabilirsiniz. Biz size her iki yolu da gösterelim ki lazım olduğu durumlarda zorlanmayın.
Daha önceden oluşturduğumuz yönetim sayfası adından da anlaşılacağı gibi sadece yöneticilerin görebileceği bir sayfa olmalıdır. Şimdi bu işlemi yapalım. İlk önce aşağıdaki kod parçasını yonetim/views.py dosyasına ekleyelim.( Dosyanın yukarısına yani import kısmına eklemek daha faydalı olacaktır.)
from django.contrib.auth.decorators import user_passes_test
def yonetici_kontrol(user):
    if user:
        if user.groups.filter(name='yonetici').count()>0:
            return True
    return False
Kullanığımız yöntem tanıdık geldi değil mi? Daha önceden kullanmıştık. Şimdi bu fonksiyonu daha önceden oluşturmuş olduğumuz yonetim görünümünün başına ekleyelim.
@user_passes_test(yonetici_kontrol)
def yonetim(request):
 if request.GET.get('cikis'):
  logout(request)
  return HttpResponseRedirect('/yonetim/')

 if request.POST.get('giris'):
  giris_formu = AuthenticationForm(data=request.POST)
  if giris_formu.is_valid():
   kullaniciadi = request.POST['username']
   sifre = request.POST['password']
   kullanici = authenticate(username=kullaniciadi,password=sifre)
   if kullanici is not None:
    if kullanici.is_active:
     login(request,kullanici)
 else:
  giris_formu = AuthenticationForm()

 return render_to_response('yonetim_giris.html',locals(),context_instance = RequestContext(request))
Artık yönetim sayfasını sadece yonetici grubuna ait olan kullanıcılar görebilecektir. Sizde ilk bu guruba eklediğiniz kullanıcı ve ardından bu gruptan olmayan bir kullanıcı ile deneyerek sonucu görebilirsiniz. Eğer yonetici grubunda olmayan bir kullanıcı ile yonetim sayfasını görmeye çalışırsanız daha önceden oluşturmuş olduğumuz giriş sayfasına yönlendirileceksiniz.
Burada dikkat etmemiz gereken bir diğer nokta ise root kullanıcısının her yetkiye sahip olmasıdır. Yani her sayfayı görebilmeli,her işlemi yapabilmelidir. Fakat bu kullanımda yonetim sayfasını göremeyecektir. Çünkü yonetici grubunda bulunmamaktadır. İşte bunun önüne geçebilmek için oluşturmuş olduğumuz yonetici_kontrol işlevini şu hale getirebiliriz.
def yonetici_kontrol(user):
    if user:
        if user.groups.filter(name='yonetici').count()>0 or user.is_superuser==True:
            return True
    return False
Oluşturmuş olduğumuz gruba yetki nasıl verilir? veya yetki nasıl silinir? Bunun için şu şablonu kullanabiliriz.
group.permissions = [izin_listesi] #yetkileri belirlenir
group.permissions.add(izin, izin, ...) #yetki eklenir
group.permissions.remove(izin, izin, ...) #yetki silinir
group.permissions.clear() #tüm yetkiler temizlenir
Şimdi bu şablona uyarak oluşturmuş olduğumuz yonetici grubuna bazı yetkiler verelim.
>>> from django.contrib.auth.models import Permission
>>> grup = Group.objects.get(name='yonetici')
>>> i1 = Permission.objects.get(codename='add_doktor')
>>> i2 = Permission.objects.get(codename='delete_doktor')
>>> grup.permissions = [i1,i2]
>>> grup.save()
Tabi ki her işlemde olduğu gibi bu işlemi de yönetim panelinden çok daha basit bir şekilde yapabiliyoruz. Yönetim panelinde gruplar sekmesi altında yonetici grubuna girince şu şekilde bir sayfa göreceksiniz.
Dikkat ederseniz az önce verdiğimiz izinler seçili izinler sekmesi altına gelmiş. Bu paneli kullanarak yetki verme veya silme işlemlerini çok kolay bir şekilde yapabilirsiniz.
Daha önceden sistemimizde bulunan tüm Doktorları kullanıcı haline getirmiştik. Şimdi sizde isterseniz Django kabuğunda şeklinde gösterdiğimiz gibi isterseniz yönetim panelinde gösterdiğimiz gibi doktorlar isminde bir grup oluşturun ve tüm doktorları bu gruba dahil edin. Şuana kadar eklemiş olduğumuz doktorları bu şekilde ekledik. Bundan sonra eklenen her doktor için bu işlemi yapmamalıyız. Bunun için öğretim elemanı formunu şu şekilde değiştirelim.
class DoktorFormu(ModelForm):
 sifre = forms.CharField(label="Şifre",
       help_text="Bir parola yazın",
       required=False)


 class Meta:
  model = Doktor
  fields = ('first_name','last_name','username','sifre','yas','telefon','email')

 def save(self,commit=True):
  instance = super(DoktorFormu,self).save(commit=False)
  if self.cleaned_data.get('sifre'):
   instance.password = make_password(self.cleaned_data['sifre'])
  if commit:
   instance.save()
   if not instance.groups.filter(name='doktorlar'):
    grup = Group.objects.get(name='doktorlar')
    instance.groups.add(grup)
  return instance

 def clean_telefon(self):
  tel = self.cleaned_data['telefon']
  if tel != "":
   if len(tel) != 11:
    raise forms.ValidationError('Telefon numarasi 11 karakter olmalidir.')
  return tel
17-18-19. satırlar yeni eklenmiştir.Bundan sonra eklenen her doktor aynı zamanda doktorlar grubunun da üyesi olarak kaydedilecektir.
Kaynakça

18 Haziran 2014 Çarşamba

Django Jquery Ajax Kullanımı

Bu yazıda çok basit bir şekilde Djangoda Jquery Ajax kullanımının nasıl olduğunu göstereceğiz. Eğer Php gibi bir dille daha önceden kullandıysanız pek bir farkı olmadığını göreceksiniz. Hemen anlatıma geçelim. Tabi bu yazıda proje, uygulama veya url gibi konulardan hiç bahsetmeyeceğim. Bu konular zaten Django giriş konuları. Eğer bunlarda eksikseniz buradan Django yazılarını okuyabilirsiniz. Şimdi gelelim asıl konumuza.
urls.py dosyamızın içeriği şu şekilde.

from trytry.views import *

urlpatterns = patterns('',
    url(r'^admin/', include(admin.site.urls)),
    url(r'^ajax/', ajax),
    url(r'^ajax-kullanimi', ajax_kullanimi)
)

Burada ki ajax url'i ajaxı kullanacağımız sayfa iken ajax-kullanimi url'i ise ajax'ı kullanırken gideceğimiz urldir. Gördüğünüz gibi ajax url'i içerisinde ajax görünümüne gitmişiz. Şimdi bunu hazırlamamız gerekiyor. Bu görünüm içerisinde herhangi bir işlem yapmayacağız. Sadece şablonu yüklemek için kullanacağız.
def ajax(request):
    return render_to_response('ajax.html')
ajax.html şablonunu oluşturalım.
<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
    <script type="text/javascript" src="/static/jquery-1.11.0.min.js"></script>
    <script type="text/javascript" src="/static/custom.js"></script>
</head>
<body>
hello
</body>
</html>
Burada iki tane javascript dosyası yüklediğimizi görüyorsunuz. İlki jquery dosyası iken ikincisi bizim kendi ajax kodlarımızı yazacağımız dosyadır. Dosyayı oluşturduğumuza göre içeriğini şu şekilde doldurabiliriz.
custom.js dosyası:
$(function(){

    $.ajax({
        type:'get',
        url:'/ajax-kullanimi/',
        success:function(veri){
            alert(veri);
        }
    });

});
Burada yaptığımız tek işlem en başta oluşturmuş olduğumuz url'e gitmek. Ardından dönen veriyi göstermek için alert() ile yazdırıyoruz. Oluşturduğumuz url dosyasını kontrol ederseniz ajax-kullanimi url'inde ajax_kullanimi görünümüne gidildiğini görebilirsiniz. Bu görünüm içerisinde istediğimiz işlemleri yapabiliriz. Yaptıktan sonra geriye dönen değer kullanıcıya gösterilebilir. Bu tarz işlemler artık sizin ihtiyacınıza kalıyor. Biz burada sadece basit bir şekilde aldığımız veriyi alert() ile ekrana bastıracağız. Şimdi ajax_kullanimi görünümün oluşturalım.
from django.shortcuts import render_to_response, HttpResponse
def ajax_kullanimi(request):
    return HttpResponse("Ajax Geri Donecek Deger");
Hepsi bu kadar. Jquery ajax kullanımı Djangoda bu kadar basit bir şekilde yapılabiliyor. Şimdi tarayıcıdan http://localhost:8000/ajax/ yazarsanız alert penceresini görebileceksiniz.

17 Haziran 2014 Salı

Modellerden Kullanıcı Oluşturma

Bu yazıda bir modelden kullanıcılar nasıl oluşturulur ondan bahsedeceğiz. Yani her Doktor aynı zamanda bir kullanıcı olmuş olacak. Bunun için Modeli yeniden tanımlamamız gerekiyor. Modeller konusunda söylemiştik; bir modele ait bir tablo sadece bir kere oluşturulur. Bu yüzden tabloyu yeniden oluşturacağız ve içindeki verileri kaybedeceğiz. Bu sebepten dolayı Django'da Modelleri tasarlamak çok önemli. Modelleri tasarlarken sonradan bir değişiklik olmaması için iyice düşünmemiz gerekiyor. İlk önce yonetim/models.py dosyasındaki Doktor modelini düzenleyeceğiz.
from django.contrib.auth.models import User
class Doktor(User):

 yas = models.IntegerField(blank=True,verbose_name="Yaşınız",validators=[
  MaxValueValidator(70),
  MinValueValidator(30)
  ]
 )


 telefon = models.CharField(max_length=50,blank=True,verbose_name="Telefon Numaranız")

 def __unicode__(self):
  return u'%s , %s ,%s' % (self.first_name,self.last_name,self.email)

 class Meta:
  ordering = ['first_name']
Doktor modeli önceden models.Model biçiminde bir nesne iken şimdi User biçiminde bir nesne oldu. Yani artık Doktor nesnesi User nesnesinin tüm özelliklerini kalıtım ile alacak. first_name,last_name,password,email,groups,user_permissions gibi User nesnesine ait tüm özellikler Doktor nesnesi içinde geçerli olacaktır. Bizde bu yüzden Doktor nesnesi içerisinde tanımlamış olduğumu adi,soyadi,eposta gibi alanları kaldırdık. Bu alanları artık User nesnesinden alıyoruz. Tabi Doktor nesnesi içerisinde kullandığımız adı,soyadı,email gibi alanları da first_name,lastname,email ile değiştirdiğimize dikkat edin. Modelimizi yeniden tasarladık. Şimdi bu yeni modele ait tabloyu tekrardan oluşturmamız gerekiyor. Bunun için ilk önce Python kabuğunu açarak var olan tabloyu silmeliyiz.
>>> import sqlite3
>>> from django.conf import settings
>>> vt = sqlite3.connect(settings.DATABASES['default']['NAME'])
>>> vt.execute('DROP TABLE yonetim_doktor')

>>> vt.commit()
>>> vt.close()
Tabloyu kaldırdığımıza göre yenisini oluşturabiliriz. Aşağıdaki komutu terminalde yazalım.
python manage.py syncdb
Artık diğer alanlarımızı da bu modele göre değiştirmemiz gerekiyor. İlk önce yonetim/forms.py dosyasında DoktorFormu'nu değiştireceğiz.
from django.contrib.auth.hashers import make_password
class DoktorFormu(ModelForm):

 sifre = forms.CharField(label="Şifre",
       help_text="Bir parola yazın",
       required=False)


 class Meta:
  model = Doktor
  fields = ('first_name','last_name','username','sifre','yas','telefon','email')

 def save(self,commit=True):
  instance = super(DoktorFormu,self).save(commit=False)
  if self.cleaned_data.get('sifre'):
   instance.password = make_password(self.cleaned_data['sifre'])
  if commit:
   instance.save()
  return instance


 def clean_telefon(self):
  tel = self.cleaned_data['telefon']
  if tel != "":
   if len(tel) != 11:
    raise forms.ValidationError('Telefon numarasi 11 karakter olmalidir.')
  return tel
Form içerisinde save() işlevini kendimiz tanımladık. Bunu kendimizin tanımlama sebebi; parolanın şifrelenerek veri tabanına kaydedilmesini sağlamaktır. Eğer bu şekilde yapmazsak şifreler girildiği gibi kaydedilir ve Django onaylama işlemini yapmayacaktır. Sıra geldi görünümleri düzenlemeye. yonetim/views.py dosyasındaki Doktor_listesi işlevi içerisindeki alanları değiştirmeliyiz. Sıralama kriterleri aşağıdaki gibi olmalıdır.
siralamaKriteleri = {
 '1':'first_name',
 '2':'last_name'
}
Doktorları veritabanından çekerken kullandığımız Q nesnesinin yeni hali şöyle olmalıdır.
doktorlar_tum = Doktor.objects.filter(
Q(first_name__contains=aranacak_kelime) | Q(last_name__contains=aranacak_kelime)
)
Ve son olarak da doktor_listesi.html şablonunda değişiklikler yapmalıyız.
doktor.adi => doktor.first_name
doktor.soyadi => doktor.last_name
doktor.eposta => doktor.email
Artık yeniden doktor ekleyebiliriz.
Ekleyeceğimiz her doktor bundan böyle aynı zamanda bir kullanıcı olacaktır. Tabi bu şekilde bir kullanımda doktorlara standart bir kullanıcı yetkisi de vermiş oluyoruz. Bu yüzden sayfalarımızı tasarlarken yetki meselesine çok dikkat etmemiz gerekiyor.
Kaynakça
  • Mustafa Başer - Django Kitabı

11 Haziran 2014 Çarşamba

Kullanıcı Yetkileri

Daha önce görünümleri bazı kullanıcılara göre gizlemenin veya göstermenin basit bir yolunu göstermiştik. Kullanıcı yetkileri ile elimizde bulunan bir şablonun bile istediğimiz bir bölümünü yetkisi olan kullanıcılara gösterebiliriz.
Daha önceden hazırlamış olduğumuz doktor listesi sayfasında Doktor Ekle köprüsü var. Bu köprünün sadece doktor ekleme yetkisi olan kullanıcılara görünmesini sağlayabiliriz. Bu gibi durumlarda kullanıcı yetkileri bizim için çok kullanışlı olacak.
Şimdi python kabuğuna girelim. İlk önce elimizde bulunan kullanıcılardan birine bakalım ve biraz irdeleyelim.
>>> from django.contrib.auth.models import User
>>> kullanici = User.objects.get(username='mazlum')
mazlum kullanıcısını çağırdık. Bu kullanıcı süper kullanıcı mı ona bakalım.
>>> kullanici.is_superuser
False
Süper kullanıcı tam da adına uygun olarak süper kullanıcıdır. Yani tüm yetkileri elinde barındıran kullanıcıdır. Tüm modeller üzerinden ekleme,silme,değiştirme kullanıcılar üzerinde silme,ekleme,yetkilendirme gibi aklınıza gelebilecek her şeyi yapabilir. mazlum kullanıcısı süper kullanıcı değilmiş. Şimdi mazlum kullanıcısının yetkilerine bakalım.
>>> kullanici.get_all_permissions()
set([])
Gördüğünüz gibi mazlum kullanıcısının hiç bir yetkisi yok. mazlum kullanıcısını süper kullanıcı yapalım.
>>> kullanici.is_superuser = True
>>> kullanici.is_superuser
True
Artık mazlum kullanıcısı süper kullanıcıdır. mazlum kullanıcısının yönetim panelini kullanabilmesi için is_staff=True yapmamız gerekiyor.
>>> kullanici.is_staff=True
>>> kullanici.save()
Son olarak kullanıcıyı kaydettiğimize göre yetkilerine tekrardan bakabiliriz.
>>> kullanici.get_all_permissions()
set([u'auth.add_user', u'admin.delete_logentry', u'auth.add_group', u'yonetim.add_hasta', u'yonetim.change_hasta', u'contenttypes.delete_contenttype', u'auth.add_permission', u'auth.change_permission', u'admin.change_logentry', u'yonetim.change_doktor', u'sessions.change_session', u'yonetim.add_doktor', u'yonetim.delete_doktor', u'sessions.add_session', u'yonetim.change_polikilinik', u'auth.delete_group', u'auth.delete_user', u'auth.delete_permission', u'yonetim.delete_hasta', u'admin.add_logentry', u'yonetim.delete_polikilinik', u'contenttypes.change_contenttype', u'auth.change_user', u'sessions.delete_session', u'contenttypes.add_contenttype', u'yonetim.add_polikilinik', u'auth.change_group'])
Gördüğünüz gibi mazlum kullanıcısı süper kullanıcı olduğu için tüm yetkilere sahip oldu.
Django'da yetkiler Permissions() nesnesi ile tanımlanır. Bir model tanımlanırken o model ile birlikte varsayılan olarak bazı izinler Django tarafından tanımlanır. Örneğin elimizde bulunan hasta modeli oluşturulurken model ile birlikte hasta ekleme,hasta silme,hasta değiştirme izinleri de model ile birlikte oluşturulur. Biz bu izinlerden fazlasını da tanımlayabiliriz. Django'nun bu üç izni tanımlaması şu şekildedir:
Hasta Ekleme : 'yonetim.add_hasta'
Hasta Silme  : 'yonetim.delete_hasta'
Hasta Değiştirme : 'yonetim.change_hasta'
Bir kullanıcının yetkilerini yönetim panelinden değiştirebilirsiniz. Tabi bu işlemi yapabilmek için superuser ve staff özelliklerinin True olması gerekir. Şimdi yönetim paneline ister mazlum isterseniz de root kullanıcısı ile giriş yapın. Girş yaptıktan sonra kullanıcılar köprüsünü kullanarak kullanıcılar kısmına geçin. Sağ üstteki Yeni kullanıcı bağlantısını kullanarak yeni kullanıcı oluşturun. Yeni kullanıcının kullanıcı adını ve şifresini girdikten sonra kullanıcının detaylı bilgilerini girebileceğiniz bir sayfaya yönlendirileceksiniz. Bu sayfada kullanıcının kişisel bilgileri ve izinleri gibi başlıkları görebilirsiniz. Biz izinleri altında kalan kısım ile ilgileneceğiz.
Kullanıcının şuanda hiç bir yetkisi bulunmamaktadır. Buradan Doktor Ekleme, Doktor Silme, Doktor Değiştirme izinlerini kullanıcı için verin.
Artık oluşturduğumuz ahmet kullanıcısı bu izinlere sahiptir. Kaydet butonuna basın ve kullanıcının izinlerini kaydedin. Şimdi gelin python kabuğunda oluşturduğumuz kullanıcının yetkilerine bakalım.
>>> ahmet = User.objects.get(username='ahmet')
>>> ahmet.get_all_permissions()
set([u'yonetim.change_doktor', u'yonetim.add_doktor', u'yonetim.delete_doktor'])
Gördüğünüz gibi verdiğimiz izinleri görebiliyoruz. Bir kullanıcının bir izne sahip olma durumunu kontrol etmek için has_perm() özelliğini kullanabiliriz.
>>> ahmet.has_perm('yonetim.change_doktor')
True
Yetki verme işlemini yönetim panelinden yaptık. Fakat bu işlemi kabuk üzerinde de yapabiliriz. İzin verme işlemi için aşağıdaki özellikleri kullanabiliriz.
kullanici.user_permissions = [izin_listesi] #izinleri bir liste şeklinde verme
kullanici.user_permissions.add(izin, izin, ...) #izin ekleme
kullanici.user_permissions.remove(izin, izin, ...) #izin silme
kullanici.user_permissions.clear() #tüm izinleri temizleme
Bir kullanıcı oluşturalım ve izinlerini kabuk üzerinde verelim.
>>> from django.contrib.auth.models import User
>>> from django.contrib.auth.models import Permission
>>> kullanici = User.objects.create_user('gul','guler@mail.com','1234')
>>> i1 = Permission.objects.get(codename='add_doktor')
>>> i2 = Permission.objects.get(codename='delete_doktor')
>>> i3 = Permission.objects.get(codename='change_doktor')
>>> kullanici.user_permissions = [i1,i2]
>>> kullanici.user_permissions.add(i3)
Kullanıcının izinlerini kontrol edelim.
>>> kullanici.get_all_permissions()
set([u'yonetim.change_doktor', u'yonetim.add_doktor', u'yonetim.delete_doktor'])
kullanici.save()
İsterseniz yaptığımız işlemleri kontrol etmek için yönetim panelini kullanabilirsiniz. Gelelim görünümlere. Başlığın en başındaki şablonu hatırlıyorsunuz. Orada doktor ekle bağlantısı bulunuyordu. Şimdi bu bağlantıyı sadece doktor ekleme izni olan kullanıcılara göstereceğiz. Bu yazı boyunca ahmet ve gul adında iki kullanıcı oluşturduk. gul kullanıcısından doktor ekleme yetkisini alıyoruz. Sizde yönetim panelinden bu işlemi yapabilirsiniz. Daha sonra doktor_listesi.html şablonundaki şu satırları değiştiriyoruz.
Doktor Ekle
Yeni hali şu şekilde olacak.
{% if perms.yonetim.add_doktor %}
Doktor Ekle
{% endif %}
Bu işlemi yaptıktan sonra Doktor_listesi görünümdeki son satıra yeni halini veriyoruz.
return render_to_response('doktor_listesi.html',locals(),
                           context_instance=RequestContext(request))
Eğer gul kullanıcısı ile giriş yaparsanız. doktor listesi sayfası şu şekilde görünecektir.
gul kullanısının yetkisi olmadığı için bağlantıyı göremedi. Tabi bağlantıyı göremedi ama giriş yaptığı için tarayıcıdan http://localhost:8000/doktor-ekle/ yazarsa sayfaya ulaşabilecek, doktor ekleye bilecektir. Çünkü biz daha önceden doktor_ekleme görünümünde sadece kullanıcı girişi olup olmadığını kontrol etmiştik. Bu durumun önüne geçebilmek için doktor_ekleme görünümdeki form.save() satırını değiştirmemiz gerekiyor.
if request.user.has_perm('yonetim.add_doktor'):
 form.save()
else:
 return HttpResponse(u'Doktor ekleme yetkiniz bulunmamaktadır.')
Eğer kullanıcı doktor eklemeye çalışırsa yetkisi olmadığı için uyarı ile karşılaşacaktır.
Özel İzin Oluşturma
Bir model oluşurken o model ile birlikte varsayılan olarak izinlerin oluştuğunu söyledik. Peki o izinler dışında izin tanımlamak istersek. Django bize bu imkanı sunuyor. Örneğin doktor listesini görme diye bir izin tanımlayalım.
>>> from django.contrib.contenttypes.models import ContentType
>>> from django.contrib.auth.models import Permission
>>> from django.contrib.auth.models import User
>>> model = ContentType.objects.get(model='doktor')
>>> gorebilme = Permission(name='Doktorları Görebilir',codename='view_doktor',content_type=model)
>>> ahmet = User.objects.get(username='ahmet') 
>>> ahmet.user_permissions.add(gorebilme)
>>> ahmet.save()
ahmet kullanıcısına view_doktor isminde bir izin tanımladık. Eğer yönetim panelinden ahmet kullanıcısının izinlerine bakarsanız iznin eklendiğini görebilirsiniz.
>>> ahmet.has_perm('yonetim.view_doktor')
True
Bu izni şablonlar içerisinde şu şekilde kullanabilirsiniz.
{{ perms.yonetim.doktor }}
Modellerde İzin Oluşturma
Yukarda özel izin oluşturarak bir kullanıcıya atadık. Bir model oluştuğunda onunla birlikte ekleme/silme/değiştirme izinleri de oluşuyordu. Yukarıdaki bir kullanım yerine Model oluştuğunda kendi istediğimiz izninde oluşturulmasını isteyebiliriz. Yukarıda yaptığımız view_doktor iznini bu sefer hastalar çin doğrudan model için de oluşturalım. Bunun için yonetim/models.py dosyasındaki Hasta modeline şu satırları eklemeliyiz.
class Meta:
 permissions = (
  ("view_hasta","Hasta Görebilir"),
 )
Daha sonra veritabanını terminal ile güncellememiz gerekiyor.
python manage.py syncdb
Python kabuğu ile modele ait izinleri görebiliriz.
>>> from django.contrib.contenttypes.models import ContentType
>>> model = ContentType.objects.get(model='hasta')
>>> model.permission_set.all()
[<Permission: yonetim | hasta | Can add hasta>, <Permission: yonetim | hasta | Can change hasta>, <Permission: yonetim | hasta | Can delete hasta>, <Permission: yonetim | hasta | Hasta Görebilir>]

Bizim oluşturduğumuz izni görebilirsiniz. Bu işlem size uzun geldiyse oluşturduğumuz izni yönetim panelinden de görebilirsiniz.
Kaynakça

8 Haziran 2014 Pazar

Giriş Görünümü Oluşturma

Django'nun bize sağlamış olduğu giriş sayfasını kullanarak kullanıcılara giriş yaptırdık. Burada Django bizim için giriş ve çıkışları otomatik olarak yapar. Peki ya kendi giriş görünümümüzü kendimiz tasarlamak istersek. Tabi ki yapabiliriz. Hazırlamış olduğumuz yonetim görünümünü düzenleyerek, giriş ve çıkış işlemlerini bu görünüm üzerinden yapalım.
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth import *

def yonetim(request):
 if request.GET.get('cikis'):
  logout(request)
  return HttpResponseRedirect('/yonetim/')

 if request.POST.get('giris'):
  giris_formu = AuthenticationForm(data=request.POST)
  if giris_formu.is_valid():
   kullaniciadi = request.POST['username']
   sifre = request.POST['password']
   kullanici = authenticate(username=kullaniciadi,password=sifre)
   if kullanici is not None:
    if kullanici.is_active:
     login(request,kullanici)
 else:
  giris_formu = AuthenticationForm()

 return render_to_response('yonetim_giris.html',locals(),context_instance = RequestContext(request))
Burada yaptığımız işlemlerin bazılarını satır satır açıklayalım.
  • 1.satır: Kullanacağımız giriş formunu içe aktardık.
  • 2.satır: Kullanacağımız login(),logout() ve authenticate() gibi fonksiyonları içe aktardık.
  • 5.satır: Eğer GET metodu ile çıkış değeri gönderilirse logout() fonksiyonu ile kullanıcının çıkış yapmasını sağladık. Ardından tekrar yonetim görünümüne yönlendirdik.
  • 10. ve 19. satır: Bu satırlarda giriş formunu değişkene atadık.
  • 14.satır: Daha önce bahsetmiş olduğumuz authenticate() fonksiyonu ile kullanıcıyı onayladık. Eğer onaylama işlemi olmaz ise. Kullanıcı uyarılır.
  • 17.satır: Eğer kullanıcı aktif durumdaysa login() fonksiyonu ile giriş yaptırdık.
Yönlendirme yaptığımız yonetim_giris.html şablonunu şu şekilde hazırlayalım.
<!DOCTYPE html>
<html>
<head>
    <title>Yönetim</title>
    <link rel="stylesheet" type="text/css" href="/dosyalar/style.css" />
</head>
<body>
<h2>Yönetim İşlemleri</h2>

{% if request.user.is_authenticated %}
    <h3>Hoş geldin, {{request.user.get_full_name}}</h3>

    <div><a href="/doktorlar">Doktor İşlemleri</a></div>
    <div><a href="/hasta-listesi">Hasta İşlemleri</a></div>
    <div><a href="/poliklinik-likstesi">Poliklinik İşlemleri</a></div>
    <a href="?cikis=cikis">Çıkış</a>
{% else %}
<h3>Giriş Formu</h3>
<form method="POST">
    {% csrf_token %}
    <div>
         {{ giris_formu }}
    </div>

    <input type="submit" name="giris" value="Giriş Yap" />
</form>
{% endif %}
</body>
</html>
Kendi giriş görünümümüzü yazmış olduk. Eğer isterseniz bu şekilde kendi giriş görünümünüzü kendiniz yazabilir, isterseniz Django'nun size sağlamış olduğunu kullanabilirsiniz.
Kaynakça
  • Mustafa Başer - Django Kitabı

4 Haziran 2014 Çarşamba

Şuana kadar projeyi geliştirmek için Django sunucusunu kullandık. Fakat üretim için bu sunucu kullanılmamalıdır. Bu yüzden Django'yu üretim amaçlı bir sunucu ile bütünleştirmek gerekir. Django mod_wsgi destekli tüm web sunucuları ile çalışmaktadır. Geliştiricileri Apache sunucusunu önermektedirler. Bizde bu yazımızda Apache sunucusunda kullanımını anlatacağız. Daha fazla bilgiye buradan ulaşabilirsiniz.
Linux için
Linux dağıtımlarında apache sunucusu kurulu olarak gelmektedir. Ama biz yinede gösterelim.
$ sudo apt-get install apache2
$ sudo apt-get install libapache2-mod-wsgi
Kurulum işlemleri tamam ise basit bir proje oluşturarak apache serverda nasıl kullanacağımıza bakalım. İlk önce /var/www dizini içerisine girerek bir proje oluşturuyoruz.
$ django-admin.py startproject proje
Projeyi oluşturduktan sonra, bu projeyi apache üzerinde koşturabilmek için konfigürasyon ayarlarını yapmamız gerekiyor. Bunun için ilk önce /etc/apache2/sites-available dizini içerisinde bir .conf dosyası oluşturuyoruz. Bizim bu proje için oluşturacağımız proje.conf dosyasının içeriği şu şekilde olacaktır.
<VirtualHost *:80>
ServerAdmin mazlum.agar@gmail.com
ServerName proje.com
ServerAlias www.proje.com
DocumentRoot /var/www/proje


Alias /static/ /var/www/proje/static/
WSGIScriptAlias / "/var/www/proje/proje/wsgi.py"


<Directory /var/www/proje>
Order allow,deny
Allow from all
</Directory>


</VirtualHost>
Bu proje.conf dosyasının /etc/apache2/apache2.conf dosyası içerisine yüklenmesi gerekiyor. apache'de tüm konfigürsayon ayarlamaları bu dosya içerisinde yapılır ve eğer başka dosyalar varsa bu dosya içerisine yüklenir. Bizim yapacağımı gibi.
/etc/apache2/apache2.conf dosyası içerisine aşağıdaki satırlardan birini ekliyoruz.
#Bu satırı eklerseniz sites-available dosyası içerisindeki tüm .conf dosyaları yüklenecektir.
IncludeOptional sites-available/*.conf

#Bu satırı eklerseniz sadece oluşturmuş olduğumuz proje.conf dosyası yüklenecektir.
IncludeOptional sites-available/proje.conf
proje.conf dosyası içeriğini açıklayalım.
  • 1.satır: Bu satırda yöneticinin mail adresini belirtiyoruz.
  • 2.satır: Sitenin adını belirtiyoruz.
  • 3.satır: Sitenin takma adını belirtiyoruz.
  • 8.satır: Statik dosyaların url'ini ve yolunu belirtiyoruz.
  • 9.satır: Projemizi oluştururken oluşan wsgi.py dosyasının yolunu belirtiyoruz.
  • 12.satır: Bu satırlarda projemizin ve içerisindeki dizinleri okunabilmesi için izinleri veriyoruz.
Konigürasyon dosyamız bu kadar. Yukarıda dikkat ederseniz sitemizin adınıproje.com olarak belirttik. Peki bilgisayarımız bunu nasıl bilecek bunun için /etc/hosts dosyasına ekleme yapıyoruz.
127.0.0.1       localhost
127.0.1.1       mazlum
172.16.78.1     proje.com
....
İlk yazdığımız bilgisayarımızın ip adresi. Komut satırından ifconfig yazarak ip adresinizi öğrenebilirsiniz. Apache sunucusunun yeniden başlatılması gerekiyor. Şu komutu vererek yeniden başlatabilirsiniz.
$ sudo /etc/init.d/apache2 restart
Şimdi tarayıcıdan proje.com yazarak projeyi açabilirsiniz. Bunu yaptığınız zaman 500 Internal Server Error hatası alacaksınız. Bu hatanın önüne geçebilmek için; Projemiz içerisinde bulunan wsgi.py dosyasına projemizin yollarını ekliyoruz. Dosyanın son hali şu şekilde olacaktır.
/var/www/proje/proje/wsgi.py

import os,sys
sys.path.append('/var/www')
sys.path.append('/var/www/proje')

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "proje.settings")

from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
Tarayıcıdan proje.com yazarak giriş yaptığınızda şu şekilde bir çıktı alacaksınız.
Yapmamız gereken son bir işlem kaldı. Eğer tarayıcıdan proje.com/admin yazarsanız statik dosyaların(css,resim vb) dosyalarının yüklenmediğini göreceksiniz. Çünkü biz yukarıda şu satır ile statik dosyaların proje içerisinde static dizini içerisinde olacağını söyledik.
Alias /static/ /var/www/proje/static/
Bu dosya içerisinde dosyalar bulunamadığı için yüklenemiyor. Biz de Django'nun statik dosyalarını projemizin ana dizininde static dizini içerisine kopyalayacağız. Bunun için ilk önce settings.py dosyası içerisine ekleyeceğimiz şu satır ile dosyaların nereye kopyalanacağını belirtiyoruz.
STATIC_ROOT = '/var/www/proje/static'
Proje dosyamız içerisine girdikten sonra şu komutu vererek kopyalama işlemini yapıyoruz.
python manage.py collectstatic
Artık projemiz Apache üzerinde çalışır durumda. Şimdi bu işlemleri kendi hastahane projesi için yapabiliriz. Yaptığımız işlemler aynen geçerli sadece .conf dosyamızda biraz değişiklik olacak. Bunun için /etc/apache2/site-available içerisinde hastahane.conf oluşturuyoruz ve içeriği şu şekilde oluyor.
<VirtualHost *:80>
ServerAdmin mazlum.agar@gmail.com
ServerName hastahane.com
ServerAlias www.hastahane.com
DocumentRoot /home/mazlum/Django/hastahane


Alias /dosyalar/ /home/mazlum/Django/hastahane/static/
WSGIScriptAlias / "/home/mazlum/Django/hastahane/hastahane/wsgi.py"


<Directory /home/mazlum/Django/hastahane/static>
Order allow,deny
Allow from all
AllowOverride None
Require all granted
</Directory>

Burada sadece izin verme işlemi yaparken Require all granted satırını ekledik. Eğer bu satırı eklemez iseniz Forbidden 403 hatası ile karşılaşırsınız.
Projeyi bu şekilde taşıdığınızda bazı hatalar ile karşılaşıyor olabilirsiniz. Bu hataları tahmin ederek düzeltebilirsiniz. Düşünemediğimiz bazı şeylerden dolayı hatalar çıkabilir. Bu yüzden bizce en doğrusu projeyi doğrudan apache üzerinde geliştirmek. Bu şekilde taşırken hatalar ile karşılaşmamış olursunuz.
Windows için
Windows için apache'nin kurulması gerekiyor. Bunun için buradan Win32 için olan sürümünü indirin. İndirdikten sonra çift tıklayarak çıkan wizard'ı her zaman ki gibi kullanarak Apache'yi kuruyoruz. Apache kurulduktan sonra mod_wsgi'nin kurulması gerekiyor. Sisteminize uygun olanınını buradan indirebilirsiniz. Örneğin mod_wsgi‑3.4.ap22.win32‑py2.7.zip Bu indirilen dosyanın Apache'nin modül dizinine kayıt edilmelidir. Bunun için dosyayı şuraya kaydedin; c:\Program Files\Apache Software Foundation\Apache2.2\modules.
Son olarak mod_wsgi'nin Apache'nin yapılandırma dosyasına eklenmesi gerekiyor. Bunu Başlat/Tüm Programlar/Apache HTTP Server 2.2/Configure Apache Server/Edit the Apache http.conf Configuration File yolunu takip ederek yapabilirsiniz. Dosyanın en sonuna şu satırı eklemelisiniz.
LoadModule wsgi_module modules/mod_wsgi.so
Bu satır eklendikten sonra projemiz için de aynı dosyanın sonuna şu satırları eklemelisiniz.
Alias /static "D:/Django/hastahane/static"
WSGIScriptAlias / "D:/Django/hastahane/hastahane/wsgi.py"

<Directory D:/Django/hastahane>
Order allow,deny
Allow from all
</Directory>
 
<Directory D:/Django/hastahane/hastahane/static>
Order allow,deny
Allow from all
</Directory>
Bu işlemleri kaydettikten sonra apache'nin yeniden başlatılması gerekir. Bunun için yine Başlat/Tüm Programlar/Apache HTTP Server 2.2/ girdiğiniz zaman sağ taraftan Restart diyerek yeniden başlatabilirsiniz. Apache'yi de yeniden başlattığınıza göre tarayıcıdan http://localhost/yonetim diyerek projeye ulaşabilirsiniz. Eğer bir hata ile karşılaşırsanız Apache'nin log dosyalarından hataya bakarak araştırabilirsiniz.
Not: Bu kurulumları ve kullanımları yaparken dosya izinlerine değinilmemiştir. Burada dosya dizinleri önemlidir. Yaptığımız kurulumlarda Django kullanıcısı kullanılmıştır. Örneğin resim eklediğimiz hastahane/static/resimler/profil_resimleri dosyasında yazma izninin olması gerekir. Aksi halde dosyalar yüklenmeye çalışılırken hata ile karşılaşılacaktır. Güvenlik için de bu dosyaların izinleri çok önemlidir. Bu konulara bu yazının konusu dahilinde olmadığı için değinmiyoruz.
Kaynakça